Day7 初识面向对象，面向对象之继承与派生

角色：人、狗
人角色特性：攻击力、生命值、名字、等级
狗角色特性：攻击力、生命值、名字、品种

 1 class Person:
 2     rol = ‘人‘         #数据属性、静态属性、类属性
 3     country = ‘中国‘
 4     def __init__(self,name,age,life_value): #初始化方法
 5         # self.__dict__[‘name‘] = name
 6         self.name = name       #属性、对象属性
 7         self.theage = age
 8         self.life_value = life_value
 9 
10     def attack(self):  #函数属性、动态属性、方法
11         #self只是一个形式参数，可以叫其他名字，但正常没人会这样
12         #self是水性杨花，那个对象调这个方法，self就是那个对象
13         print(‘attack方法被%s执行了‘%self.name)
14 print(Person.rol)  ##属性引用

 1 class Person:
 2     rol = ‘人‘         #数据属性、静态属性、类属性
 3     country = ‘中国‘
 4     def __init__(self,name,age,life_value): #初始化方法
 5         # self.__dict__[‘name‘] = name
 6         self.name = name       #属性、对象属性
 7         self.theage = age
 8         self.life_value = life_value
 9 
10     def attack(self):  #函数属性、动态属性、方法
11         #self只是一个形式参数，可以叫其他名字，但正常没人会这样
12         #self是水性杨花，那个对象调这个方法，self就是那个对象
13         print(‘attack方法被%s执行了‘%self.name)
14 print(Person.rol)
15 alex=Person(‘alex‘,38,1000)
16 egg=Person(‘egon‘,18,2000)

print(alex.name)  ##查看属性信息 对象名.属性名
print(alex.attack()) #调用方法：对象名.方法名()

 1 class 类名:
 2     def __init__(self,参数1,参数2):
 3         self.对象的属性1 = 参数1
 4         self.对象的属性2 = 参数2
 5 
 6     def 方法名(self):pass
 7 
 8     def 方法名2(self):pass
 9 
10 对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
11                   #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
12                   #括号里传参数，参数不需要传self，其他与init中的形参一一对应
13                   #结果返回一个对象
14 对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
15 对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

 1 class Dog:
 2     def __init__(self,name,type,aggr):
 3         self.name = name
 4         self.dog_type = type
 5         self.aggr = aggr
 6         self.life_value = 2000
 7 
 8     def bite(self,person_obj):  #self==egg,person_obj=alex
 9         #属性的变化
10         print(‘%s咬了%s‘%(self.name,person_obj.name))
11         person_obj.life_value -= self.aggr
12 
13 class Person:
14     rol = ‘人‘         #数据属性、静态属性、类属性
15     country = ‘中国‘
16     def __init__(self,name,age,life_value): #初始化方法
17         self.name = name       #属性、对象属性
18         self.theage = age
19         self.life_value = life_value
20         self.aggr = 1
21 
22     def attack(self,dog_obj):#函数属性、动态属性、方法
23         print(‘%s攻击了%s‘%self.name,dog_obj)
24         dog_obj.life_value -= self.aggr
25 
26 alex = Person(‘alex‘,38,500)
27 egg = Dog(‘egon‘,‘二哈‘,20)
28 print(alex.life_value)
29 egg.bite(alex)   #Dog.bite(egg,alex)
30 print(alex.life_value)

组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同，

1.继承的方式

通过继承建立了派生类与基类之间的关系，它是一种‘是‘的关系，比如白马是马，人是动物。

当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人

2.组合的方式

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3..

 1 class Birthday:
 2     ‘‘‘
 3     生日类
 4     ‘‘‘
 5     def __init__(self,year,month,day):
 6         self.year = year
 7         self.month = month
 8         self.day = day
 9 class Person:
10     ‘‘‘
11     人类
12     ‘‘‘
13     # def __init__(self,name,birth):
14     def __init__(self,name):
15         self.name = name
16         # self.birthday =birth
17 # 实例化两个类，然后将两个类组合起来
18 alex_birth = Birthday(1968,1,1)
19 alex = Person(‘alex‘)
20 alex.birth =  alex_birth
21 print(alex.birth.year)

 1 from math import pi
 2 
 3 class Circle:
 4     ‘‘‘
 5     定义了一个圆形类；
 6     提供计算面积(area)和周长(perimeter)的方法
 7     ‘‘‘
 8     def __init__(self,radius):
 9         self.radius = radius
10     def area(self):
11          return pi * self.radius * self.radius
12     def perimeter(self):
13         return 2 * pi *self.radius
14 
15 circle =  Circle(10) #实例化一个圆
16 area1 = circle.area() #计算圆面积
17 per1 = circle.perimeter() #计算圆周长
18 print(area1,per1) #打印圆面积和周长
19 
20 class Ring:
21     ‘‘‘
22     定义了一个圆环类
23     提供圆环的面积和周长的方法
24     ‘‘‘
25     def __init__(self,radius_outside,radius_inside):
26         self.outsid_circle = Circle(radius_outside)
27         self.inside_circle = Circle(radius_inside)
28     def area(self):
29         return self.outsid_circle.area() - self.inside_circle.area()
30     def perimeter(self):
31         return  self.outsid_circle.perimeter() + self.inside_circle.perimeter()
32 
33 ring = Ring(10,5) #实例化一个环形
34 print(ring.perimeter()) #计算环形的周长
35 print(ring.area()) #计算环形的面积

class ParentClass1: #定义父类
    pass
class ParentClass2: #定义父类
    pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

 1 class Animal:
 2     def __init__(self,name,aggr,life_value):
 3         self.name=name
 4         self.aggr=aggr
 5         self.life_value=life_value
 6     def func(self):
 7         print(self.name)
 8 
 9 class Dog(Animal):
10     def __init__(self,name,aggr,life_value,type):
11         Animal.__init__(self,name,aggr,life_value)
12         self.type=type #派生属性
13     def bite(self):
14         #派生方法
15         Animal.func(self)
16 
17 class Person(Animal):
18     def __init__(self,name,aggr,life_value,money):
19         Animal.__init__(self,name,aggr,life_value)
20         self.money=money
21 egg=Dog(‘egon‘,200,2000,‘金毛‘)
22 alex=Person(‘alex‘,10,1000,2000)
23 
24 print(egg.__dict__)
25 print(alex.__dict__)

object 类祖宗
若一个类有指定的父类，那么他的父类就是被指定的那个
若一个类没有指定的父类，那么他的父类就是object
凡是继承了object类的类都是新式类
Python3里所有的类都是新式类
新式类调用父类的方法
    1、指名道姓：父类名.方法名(self,aggr1...)  ---->经典类  Python以经典类为主
    2、super关键字：super.方法名(aggr1....)   ----->只适合与新式类

 1 class Teacher:
 2     def __init__(self,name,age,salary):
 3         self.name = name
 4         self.age = age
 5         self.salary = salary
 6         self.teach()  ##和egon.teach()效果一样，所有调用优先自己的
 7     def teach(self):
 8         print(‘%s正在讲课‘ %self.name)
 9 
10 class Professor(Teacher):
11     # def __init__(self,name,age):
12     #     super().__init__(self,name,age)
13     def teach(self):
14         # super().teach()
15         print(‘教授%s正在讲课‘%self.name)
16     def print_write(self):
17         print(‘%s正在写专利‘%self.name)
18 # Write a patent 写专利
19 egon = Professor(‘egon‘,20,20000)
20 # print(egon.__dict__)
21 # egon.teach()

>>> F.mro() #等同于F.__mro__
[<class ‘__main__.F‘>, <class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.E‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]

1、继承的作用
    1）减少代码的重用
    2）提高代码可读性
    3）规范编程模式
2、名字解释
抽象：抽象即抽取类似或者说比较像的部分。是一个从具题到抽象的过程。
继承：子类继承了父类的方法和属性
派生：子类在父类方法和属性的基础上产生了新的方法和属性
3、钻石继承
    新式类：广度优先
    经典类：深度优先

4、经典类和新式类的区别
　　1、关于基类 ： 新式类默认继承object
　　2、关于在子类中执行父类的方法:新式类有super，经典类只能用指名道姓
　　3、关于多继承：新式类 广度优先（mro），经典类：深度优先
　　在py3没有经典类；在py2里经典类和新式类共存

5、关于继承：
子类继承父类
子类的对象调用方法，优先在子类中找，如果子类中有，就执行子类中的
                                如果子类中没有，就执行父类的
                                    多个父类以广度优先为准