类的空间问题
何处可以添加对象属性
class A: def __init__(self,name): self.name = name def func(self,sex): self.sex = sex
# 类外面可以： obj = A('barry') obj.age = 18 print(obj.__dict__) # {'name': 'barry', 'age': 18} # 类内部也可以： obj = A('barry') # __init__方法可以。 obj.func('男') # func 方法也可以。
总结：对象的属性不仅可以在__init__里面添加，还可以在类的其他方法或者类的外面添加
何处可以添加类的静态属性
class A: def __init__(self,name): self.name = name def func(self,sex): self.sex = sex def func1(self):
print(self) A.bbb = 'ccc'
# 类的外部可以添加 A.aaa = 'taibai' 这个还是有疑问？？？？没看懂 print(A.__dict__) # 类的内部也可以添加。 A.func1(111) print(A.__dict__)
总结：类的属性不仅可以在类内部添加，还可以在类的外部添加。
对象如何找到类的属性
之前咱们都学习过，实例化一个对象，可以通过点的方式找到类中的属性，那么他为什么可以找到类中的属性呢？
对象查找属性的顺序：先从对象空间找 ------> 类空间找 ------> 父类空间找 ------->.....
类名查找属性的顺序：先从本类空间找 -------> 父类空间找--------> ........
上面的顺序都是单向不可逆，类名不可能找到对象的属性。
类与类之间的关系
千世界, 万物之间皆有规则和规律. 我们的类和对象是对⼤千世界中的所有事物进⾏归类. 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯向对象的世界中. 类与类中存在以下关系:
1. 依赖关系
2. 关联关系
3. 组合关系
4. 聚合关系
5. 实现关系
6. 继承关系(类的三大特性之一：继承。)
依赖关系
首先, 我们设计一个场景. 大象使用冰箱. 注意. 在这个场景中, 其实是存在了两种事物的.一个是大象, 大象负责整个事件的掌控者, 还有一个是冰箱, 冰箱负责被⼤象操纵.
⾸写出两个类,一个是大象类, 一个是冰箱类
class Elphant: def __init__(self, name): self.name = name def open(self): ''' 开⻔ ''' pass def close(self): ''' 关⻔ ''' pass class Refrigerator: def open_door(self): print("冰箱⻔被打开了") def close_door(self): print("冰箱⻔被关上了")
冰箱的功能非常简单, 只要会开, 关，就行了. 但是大象就没那么简单了. 想想. 大象开和关的时候是不是要先找个冰箱啊. 然后呢? 打开冰箱. 是不是打开刚才找到的那个冰箱. 然后装东西. 最后呢? 关冰箱, 注意, 关的是刚才那个冰箱吧. 也就是说. 开和关的是同一个冰箱. 并且.大象有更换冰箱的权利, 想进那个冰箱就进那个冰箱. 这时, 大象类和冰箱类的关系并没有那么的紧密. 因为大象可以指定任何一个冰箱. 接下来. 我们把代码完善一下.
class Elphant: def __init__(self, name): self.name = name def open(self,obj1): ''' 开⻔ ''' print('大象要开门了，默念三声，开') obj1.open_door() def close(self): ''' 关⻔ ''' print('大象要关门了，默念三声，关') class Refrigerator: def open_door(self): print("冰箱⻔被打开了") def close_door(self): print("冰箱⻔被关上了") elphant1 = Elphant('大象') haier = Refrigerator() 这一步没整明白？？？？ elphant1.open(haier)
动作发起的主体是大象，你们把关门这个练一下。依赖关系：将一个类的对象或者类名传到另一个类的方法使用。此时, 我们说, 大象和冰箱之间就是依赖关系. 我看着你. 但是你不属于我. 这种关系是最弱的.比如. 公司和雇员之间. 对于正式员, 肯定要签订劳动合同. 还得好好伺候着. 但是如果是兼职. 那就无所谓. 需要了你就来. 不需要你就可以拜拜了. 这样的兼职(临时工) 就属于依赖关系.
关联,聚合,组合关系
其实这三个在代码上写法是一样的. 但是, 从含义上是不一样的.
1. 关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更改和更换的.
2. 聚合关系. 属于关联关系中的一种特例. 侧重点是xxx和xxx聚合成xxx. 各个有各个的声明周期. 比如电脑. 电脑拥有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是完整的个体
3. 组合关系. 属于关联关系中的一种特例. 写法上差不多. 组合关系比聚合还要紧密. 比如人的大脑, 心脏, 各个器官. 这些器官组合成一个人. 这时. 人如果挂了. 其他的东⻄也跟着挂了
先看关联关系：
这个最简单. 也是最常见的一种关系. 比如. 都有男女朋友. 男的关联着女朋友. 女的关联着男朋友. 这种关系可以是互相的, 也可以是单一的.
class Boy: def __init__(self,name,girlFriend=None): self.name = name self.girlFriend = girlFriend def have_a_diner(self): if self.girlFriend: print('%s 和 %s 一起晚饭'%(self.name,self.girlFriend)) else: print('单身狗，吃什么饭') class Girl: def __init__(self,name): self.name = name
b = Boy('日天') b.have_a_diner() # 此时是单身狗 # 突然有一天，日天牛逼了 b.girlFriend = '如花' b.have_a_diner() #共进晚餐
# wusir 生下来就有女朋友 服不服 gg = Girl('小花') bb = Boy('wusir', gg) 这里还是存在疑惑 就是这个 . 的作用 对静态和动态的作用 这个会无法显示想要的效果，需要再进一步的核查 bb.have_a_diner() # 结果嫌他有点娘，分了 bb.girlFriend = None bb.have_a_diner()
注意. 此时Boy和Girl两个类之间就是关联关系. 两个类的对象紧密练习着. 其中一个没有了. 另一个就孤单的不得了. 关联关系, 其实就是 我需要你. 你也属于我. 这就是关联关系. 像这样的关系有很多很多. 比如. 学校和老师之间的关系.
# 老师属于学校，必须有学校才可以工作 class School: def __init__(self,name,address): self.name = name self.address = address class Teacher: def __init__(self,name,school): self.name = name self.school = school s1 = School('北京校区','美丽的沙河') s2 = School('上海校区','上海迪士尼旁边') s3 = School('深圳校区','南山区') t1 = Teacher('武大',s1) t2 = Teacher('海峰',s2) t3 = Teacher('日天',s3) print(t1.school.name) 这里没理解？？？？？ print(t2.school.name) print(t3.school.name)
但是学校也是依赖于老师的，所以老师学校应该互相依赖。
class School: def __init__(self,name,address): self.name = name self.address = address self.teacher_list = [] def append_teacher(self,teacher): self.teacher_list.append(teacher) class Teacher: def __init__(self,name,school): self.name = name self.school = school s1 = School('北京校区','美丽的沙河') s2 = School('上海校区','上海迪士尼旁边') s3 = School('深圳校区','南山区') t1 = Teacher('武大',s1) t2 = Teacher('海峰',s2) t3 = Teacher('日天',s3) s1.append_teacher(t1) s1.append_teacher(t2) s1.append_teacher(t3) # print(s1.teacher_list) # for teacher in s1.teacher_list: # print(teacher.name)
好了. 这就是关联关系. 当我们在逻辑上出现了. 我需要你. 你还得属于我. 这种逻辑 就是关联关系. 那注意. 这种关系的紧密程度比上⾯的依赖关系要紧密的多. 为什么呢? 想想吧
至于组合关系和聚合关系，其实代码上差别不大，咱们就以组合举例：
组合：将一个类的对象封装到另一个类的对象的属性中，就叫组合。
咱们设计一个游戏人物类，让实例化几个对象让这几个游戏人物实现互殴的效果。
class Gamerole: def __init__(self,name,ad,hp): self.name = name self.ad = ad self.hp = hp def attack(self,p1): p1.hp -= self.ad print('%s攻击%s,%s掉了%s血,还剩%s血'%(self.name,p1.name,p1.name,self.ad,p1.hp)) gailun = Gamerole('盖伦',10,200) yasuo= Gamerole('亚索',50,80) #盖伦攻击亚索 gailun.attack(yasuo) # 亚索攻击盖伦 yasuo.attack(盖伦)
但是这样互相攻击没有意思，一般游戏类的的对战方式要借助武器，武器是一个类，武器类包含的对象很多：刀枪棍剑斧钺钩叉等等，所以咱们要写一个武器类。
class Gamerole: def __init__(self,name,ad,hp): self.name = name self.ad = ad self.hp = hp def attack(self,p1): p1.hp -= self.ad print('%s攻击%s,%s掉了%s血,还剩%s血'%(self.name,p1.name,p1.name,self.ad,p1.hp)) class Weapon: def __init__(self,name,ad): self.name = name self.ad = ad def weapon_attack(self,p1,p2): p2.hp = p2.hp - self.ad - p1.ad print('%s 利用 %s 攻击了%s,%s还剩%s血' %(p1.name,self.name,p2.name,p2.name,p2.hp)) 复制代码
接下来借助武器攻击对方：
gailun = Gamerole('盖伦',10,200)
yasuo = Gamerole('亚索',50,80)
pillow = Weapon('绣花枕头',2) pillow.weapon_attack(gailun,yasuo) # 但是上面这么做不好，利用武器攻击也是人类是动作的发起者，所以不能是pillow武器对象，而是人类利用武器攻击对方
所以，对代码进行修改
class Gamerole: def __init__(self,name,ad,hp): self.name = name self.ad = ad self.hp = hp def attack(self,p1): p1.hp -= self.ad print('%s攻击%s,%s掉了%s血,还剩%s血'%(self.name,p1.name,p1.name,self.ad,p1.hp)) def equip_weapon(self,wea): self.wea = wea # 组合：给一个对象封装一个属性改属性是另一个类的对象 class Weapon: def __init__(self,name,ad): self.name = name self.ad = ad def weapon_attack(self,p1,p2): p2.hp = p2.hp - self.ad - p1.ad print('%s 利用 %s 攻击了%s,%s还剩%s血' %(p1.name,self.name,p2.name,p2.name,p2.hp)) # 实例化三个人物对象： barry = Gamerole('太白',10,200) panky = Gamerole('金莲',20,50) pillow = Weapon('绣花枕头',2) # 给人物装备武器对象。 barry.equip_weapon(pillow) # 开始攻击 barry.wea.weapon_attack(barry,panky)
上面就是组合，只要是人物.equip_weapon这个方法，那么人物就封装了一个武器对象，再利用武器对象调用其类中的weapon_attack方法。
什么面向对象的继承？
比较官方的说法就是：
继承（英语：inheritance）是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B，就把这个A称为“B的子类别”，而把B称为“A的父类别”也可以称“B是A的超类”。继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。另外，为子类别追加新的属性和方法也是常见的做法。 一般静态的面向对象编程语言，继承属于静态的，意即在子类别的行为在编译期就已经决定，无法在执行期扩充。
字面意思就是：子承父业，合法继承家产，就是如果你是独生子，而且你也很孝顺，不出意外，你会继承你父母所有家产，他们的所有财产都会由你使用（败家子儿除外）
class Person: def __init__(self,name,sex,age): self.name = name self.age = age self.sex = sex class Cat: def __init__(self,name,sex,age): self.name = name self.age = age self.sex = sex class Dog: def __init__(self,name,sex,age): self.name = name self.age = age self.sex = sex # 继承的用法： class Aniaml(object): def __init__(self,name,sex,age): self.name = name self.age = age self.sex = sex class Person(Aniaml): pass class Cat(Aniaml): pass class Dog(Aniaml): pass
继承的有点也是显而易见的：
1，增加了类的耦合性（耦合性不宜多，宜精）。
2，减少了重复代码。
3，使得代码更加规范化，合理化。
继承的分类
就向上面的例子：
Aminal 叫做父类,基类,超类。
Person Cat Dog: 子类，派生类。
继承：可以分单继承，多继承。
这里需要补充一下python中类的种类（继承需要）：
在python2x版本中存在两种类.：
⼀个叫经典类. 在python2.2之前. ⼀直使⽤的是经典类. 经典类在基类的根如果什么都不写.
⼀个叫新式类. 在python2.2之后出现了新式类. 新式类的特点是基类的根是object类。
python3x版本中只有一种类：
python3中使用的都是新式类. 如果基类谁都不继承. 那这个类会默认继承 object
单继承
类名，对象执行父类方法
class Aniaml(object): type_name = '动物类' def __init__(self,name,sex,age): self.name = name self.age = age self.sex = sex def eat(self): print(self) print('吃东西') class Person(Aniaml): pass class Cat(Aniaml): pass class Dog(Aniaml): pass # 类名： print(Person.type_name) # 可以调用父类的属性，方法。 Person.eat(111) print(Person.type_name) # 对象： # 实例化对象 p1 = Person('春哥','男',18) print(p1.__dict__) # 对象执行类的父类的属性，方法。 print(p1.type_name) p1.type_name = '666' print(p1) p1.eat() 类名，对象分别调用父类方法
执行顺序
class Aniaml(object): type_name = '动物类' def __init__(self,name,sex,age): self.name = name self.age = age self.sex = sex def eat(self): print(self) print('吃东西') class Person(Aniaml): def eat(self): print('%s 吃饭'%self.name) class Cat(Aniaml): pass class Dog(Aniaml): pass p1 = Person('barry','男',18) # 实例化对象时必须执行__init__方法,类中没有，从父类找，父类没有，从object类中找。 这里面object类是谁？？？ p1.eat() # 先要执行自己类中的eat方法，自己类没有才能执行父类中的方法。 执行顺序
同时执行类以及父类的方法
方法一：如果想执行父类的func方法，这个方法并且子类中也用，那么就在子类的方法中写上：
父类.func(对象,其他参数)
class Aniaml(object): type_name = '动物类' def __init__(self,name,sex,age): self.name = name self.age = age self.sex = sex def eat(self): print('吃东西') class Person(Aniaml): def __init__(self,name,sex,age,mind): ''' self = p1 name = '春哥' sex = 'laddboy' age = 18 mind = '有思想' ''' # Aniaml.__init__(self,name,sex,age) # 方法一 self.mind = mind def eat(self): super().eat() print('%s 吃饭'%self.name) class Cat(Aniaml): pass class Dog(Aniaml): pass # 方法一： Aniaml.__init__(self,name,sex,age) # p1 = Person('春哥','laddboy',18,'有思想') # print(p1.__dict__) # 对于方法一如果不理解： # def func(self): # print(self) # self = 3 # func(self)
方法二：利用super，super().func(参数)
class Aniaml(object): type_name = '动物类' def __init__(self,name,sex,age): self.name = name self.age = age self.sex = sex def eat(self): print('吃东西') class Person(Aniaml): def __init__(self,name,sex,age,mind): ''' self = p1 name = '春哥' sex = 'laddboy' age = 18 mind = '有思想' ''' # super(Person,self).__init__(name,sex,age) # 方法二 super().__init__(name,sex,age) # 方法二 self.mind = mind def eat(self): super().eat() print('%s 吃饭'%self.name) class Cat(Aniaml): pass class Dog(Aniaml): pass # p1 = Person('春哥','laddboy',18,'有思想') # print(p1.__dict__)
# 1 class Base: def __init__(self, num): self.num = num def func1(self): print(self.num) class Foo(Base): pass obj = Foo(123) obj.func1() # 123 运⾏的是Base中的func1 # 2 class Base: def __init__(self, num): self.num = num def func1(self): print(self.num) class Foo(Base): def func1(self): print("Foo. func1", self.num) obj = Foo(123) obj.func1() # Foo. func1 123 运⾏的是Foo中的func1 # 3 class Base: def __init__(self, num): self.num = num def func1(self): print(self.num) class Foo(Base): def func1(self): print("Foo. func1", self.num) obj = Foo(123) obj.func1() # Foo. func1 123 运⾏的是Foo中的func1 # 4 class Base: def __init__(self, num): self.num = num def func1(self): print(self.num) self.func2() def func2(self): print("Base.func2") class Foo(Base): def func2(self): print("Foo.func2") obj = Foo(123) obj.func1() # 123 Foo.func2 func1是Base中的 func2是⼦类中的 # 再来 class Base: def __init__(self, num): self.num = num def func1(self): print(self.num) self.func2() def func2(self): print(111, self.num) class Foo(Base): def func2(self): print(222, self.num) lst = [Base(1), Base(2), Foo(3)] for obj in lst: obj.func2() # 111 1 | 111 2 | 222 3 # 再来 class Base: def __init__(self, num): self.num = num def func1(self): print(self.num) self.func2() def func2(self): print(111, self.num) class Foo(Base): def func2(self): print(222, self.num) lst = [Base(1), Base(2), Foo(3)] for obj in lst: obj.func1() # 那笔来吧. 好好算
多继承
class ShenXian: # 神仙 def fei(self): print("神仙都会⻜") class Monkey: # 猴 def chitao(self): print("猴⼦喜欢吃桃⼦") class SunWukong(ShenXian, Monkey): # 孙悟空是神仙, 同时也是⼀只猴 pass sxz = SunWukong() # 孙悟空 sxz.chitao() # 会吃桃⼦ sxz.fei() # 会⻜
此时, 孙悟空是一只猴⼦, 同时也是一个神仙. 那孙悟空继承了这两个类. 孙悟空就可以执行这两个类中的方法. 多继承看起来简单. 也很好理解. 但是多继承中, 存在着这样一个问题. 当两个不同的类中出现了重名的方法的时候. 这时该怎么办呢? 这时就涉及到如何查找类的方法的这么一个问题.即MRO(method resolution order) 问题. 在python中这是一个很复杂的问题. 因为在不同的python版本中使用的是不同的算法来完成MRO的.
这里需要补充一下python中类的种类（继承需要）：
在python2x版本中存在两种类.：
⼀个叫经典类. 在python2.2之前. 一直使用的是经典类. 经典类在基类的根如果什么都不写.
⼀个叫新式类. 在python2.2之后出现了新式类. 新式类的特点是基类的根是object类。
python3x版本中只有一种类：
python3中使用的都是新式类. 如果基类谁都不继承. 那这个类会默认继承 object。
经典类的多继承
虽然在python3中已经不存在经典类了. 但是经典类的MRO最好还是学一学. 这是一种树形结构遍历的一个最直接的案例. 在python的继承体系中. 我们可以把类与类继承关系化成一个树形结构的图. 来, 上代码:
class A: pass class B(A): pass class C(A): pass class D(B, C): pass class E: pass class F(D, E): pass class G(F, D): pass class H: pass class Foo(H, G): pass 代码示例
对付这种mro画图就可以：
继承关系图已经有了. 那如何进行查找呢? 记住一个原则. 在经典类中采用的是深度优先，遍历方案. 什么是深度优先. 就是一条路走到头. 然后再回来. 继续找下一个.
图中每个圈都是准备要送鸡蛋的住址. 箭头和线表示线路. 那送鸡蛋的顺序告诉你入口在最下面的R. 并且必须从左往右送. 那怎么送呢?
如图. 肯定是按照123456这样的顺序来送. 那这样的顺序就叫深度优先遍历. ⽽如果是142356呢? 这种被称为深度优先遍历. 好了. 广度优先就说这么多. 那么上面那个图怎么找的呢? MRO是什么呢? 很简单. 记住. 从头开始. 从左往右. 一条路跑到头, 然后回头. 继续一条路跑到头. 就是经典类的MRO算法.
类的MRO: Foo-> H -> G -> F -> E -> D -> B -> A -> C. 你猜对了么?
新式类的多继承
mro序列
MRO是一个有序列表L，在类被创建时就计算出来。
通用计算公式为：
mro(Child(Base1，Base2)) = [ Child ] + merge( mro(Base1), mro(Base2), [ Base1, Base2] )
（其中Child继承自Base1, Base2）
如果继承至一个基类：class B(A)
这时B的mro序列为
mro( B ) = mro( B(A) ) = [B] + merge( mro(A) + [A] ) = [B] + merge( [A] + [A] ) = [B,A]
如果继承至多个基类：class B(A1, A2, A3 …)
这时B的mro序列
mro(B) = mro( B(A1, A2, A3 …) ) = [B] + merge( mro(A1), mro(A2), mro(A3) ..., [A1, A2, A3] ) = ...
计算结果为列表，列表中至少有一个元素即类自己，如上述示例[A1,A2,A3]。merge操作是C3算法的核心。
表头和表尾
表头：
列表的第一个元素
表尾：
列表中表头以外的元素集合（可以为空）
示例
列表：[A, B, C]
表头是A，表尾是B和C
列表之间的+操作
+操作：
[A] + [B] = [A, B]
（以下的计算中默认省略）
---------------------
merge操作示例：
如计算merge( [E,O], [C,E,F,O], [C] ) 有三个列表 ： ① ② ③ 1 merge不为空，取出第一个列表列表①的表头E，进行判断 各个列表的表尾分别是[O], [E,F,O]，E在这些表尾的集合中，因而跳过当前当前列表 2 取出列表②的表头C，进行判断 C不在各个列表的集合中，因而将C拿出到merge外，并从所有表头删除 merge( [E,O], [C,E,F,O], [C]) = [C] + merge( [E,O], [E,F,O] ) 3 进行下一次新的merge操作 ...... ---------------------
计算mro(A)方式：
mro(A) = mro( A(B,C) ) 原式= [A] + merge( mro(B),mro(C),[B,C] ) mro(B) = mro( B(D,E) ) = [B] + merge( mro(D), mro(E), [D,E] ) # 多继承 = [B] + merge( [D,O] , [E,O] , [D,E] ) # 单继承mro(D(O))=[D,O] = [B,D] + merge( [O] , [E,O] , [E] ) # 拿出并删除D = [B,D,E] + merge([O] , [O]) = [B,D,E,O] mro(C) = mro( C(E,F) ) = [C] + merge( mro(E), mro(F), [E,F] ) = [C] + merge( [E,O] , [F,O] , [E,F] ) = [C,E] + merge( [O] , [F,O] , [F] ) # 跳过O，拿出并删除 = [C,E,F] + merge([O] , [O]) = [C,E,F,O] 原式= [A] + merge( [B,D,E,O], [C,E,F,O], [B,C]) = [A,B] + merge( [D,E,O], [C,E,F,O], [C]) = [A,B,D] + merge( [E,O], [C,E,F,O], [C]) # 跳过E = [A,B,D,C] + merge([E,O], [E,F,O]) = [A,B,D,C,E] + merge([O], [F,O]) # 跳过O = [A,B,D,C,E,F] + merge([O], [O]) = [A,B,D,C,E,F,O] ---------------------
结果OK. 那既然python提供了. 为什么我们还要如此麻烦的计算MRO呢? 因为笔试.......你在笔试的时候, 是没有电脑的. 所以这个算法要知道. 并且简单的计算要会. 真是项目开发的时候很少有这么去写代码. 这个说完了. 那C3到底怎么看更容易呢? 其实很简单. C3是把我们多个类产生的共同继承留到最后去找. 所以. 我们也可以从图上来看到相关的规律. 这个要多写多画图就能感觉到了. 但是如果没有所谓的共同继承关系. 那么就当成是深度遍历就可以了。
方法二：
利用super，super().func(参数)