类与类之间的关系
⼤千世界, 万物之间皆有规则和规律. 我们的类和对象是对⼤千世界中的所有事物进行归
类. 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯向对象的世界中. 类与类
中存在以下关系:
1. 依赖关系
2. 关联关系
3. 组合关系
4. 聚合关系
5. 继承关系
6. 实现关系
由于python是⼀门弱类型编程语言. 并且所有的对象之间其实都是多态的关系. 也就是说,
所有的东⻄都可以当做对象来使用. 所以我们在写代码的时候很容易形成以上关系. ⾸先. 我
们先看第一种, 也是这些关系中紧密程度最低的一个, 依赖关系.
# 写一个植物大战僵尸 # 1. 植物 # 打僵尸. 僵尸掉血 # 2. 僵尸 # 吃植物. 植物掉血 class Plant: def __init__(self, name, hp, ad): # 200 self.name = name self.hp = hp self.ad = ad def attack(self, js): print("植物攻击僵尸") js.hp -= self.ad print(f"僵尸掉血{self.ad}, 还剩下{js.hp}") class JiangShi: def __init__(self, name, hp, ad): # 1000 800 self.name = name self.hp = hp self.ad = ad def attack(self, zw): print("僵尸咬植物") zw.hp -= self.ad print(f"植物掉血{self.ad}, 还剩{zw.hp}") # 植物 wd = Plant("歪脖子豌豆", 10, 20) # 僵尸 js = JiangShi("铁桶僵尸", 200, 1) wd.attack(js) wd.attack(js) wd.attack(js) wd.attack(js) wd.attack(js) js.attack(wd) js.attack(wd) js.attack(wd) js.attack(wd) # 攻击僵尸 # 僵尸掉血20, 还剩下180 # 植物攻击僵尸 # 僵尸掉血20, 还剩下160 # 植物攻击僵尸 # 僵尸掉血20, 还剩下140 # 植物攻击僵尸 # 僵尸掉血20, 还剩下120 # 植物攻击僵尸 # 僵尸掉血20, 还剩下100 # 僵尸咬植物 # 植物掉血1, 还剩9 # 僵尸咬植物 # 植物掉血1, 还剩8 # 僵尸咬植物 # 植物掉血1, 还剩7 # 僵尸咬植物 # 植物掉血1, 还剩6
我用着你. 但是你不属于我. 这种关系是最弱的.
比如. 公司和雇员之间. 对于正式员⼯, 肯定要签订劳动合同. 还得⼩心伺候着. 但是如果是兼
职. 那无所谓. 需要了你就来. 不需要你就可以拜拜了. 这里的兼职(临时工) 就属于依赖关系.
我用你. 但是你不属于我.
首先, 我们设计一个场景. 还是最初的那个例子. 要把大象装冰箱. 注意. 在这个场景中, 其
实是存在了两种事物的. ⼀个是大象, ⼤象负责整个事件的掌控者, 还有⼀个是冰箱, 冰箱负
责被大象操纵.
⾸先, 写出两个类, ⼀个是大象类, 一个是冰箱类.
class Elphant: def __init__(self, name): self.name = name def open(self): ''' 开⻔ return: ''' pass def close(self): ''' 关⻔ :retrrn: ''' pass class Refrigerator: def open_door(self): print("冰箱⻔门被打开了了") def close_door(self): print("冰箱⻔门被关上了了")
冰箱的功能非常简单, 只要会开门, 关⻔就行了. 但是大象就没那么简单了. 想想. 大象开
门和关⻔的时候是不是要先找个冰箱啊. 然后呢? 打开冰箱门. 是不是打开刚才找到的那个冰
箱⻔. 然后装⾃己. 最后呢? 关冰箱门, 注意, 关的是刚才那个冰箱吧. 也就是说. 开门和关门
用的是同⼀个冰箱. 并且. 大象有更换冰箱的权利, 想进那个冰箱就进那个冰箱. 这时, ⼤象类
和冰箱类的关系并没有那么的紧密. 因为大象可以指定任何一个冰箱. 接下来. 我们把代码完
善⼀下.
此时, 我们说, ⼤象和冰箱之间就是依赖关系. 我用着你. 但是你不属于我. 这种关系是最弱的.
比如. 公司和雇员之间. 对于正式员工, 肯定要签订劳动合同. 还得⼩心伺候着. 但是如果是兼
职. 那无所谓. 需要了你就来. 不需要你就可以拜拜了. 这里的兼职(临时工) 就属于依赖关
我用你. 但是你不属于我.
关联关系 .组合关系, 聚合关系
其实这三个在代码上写法是一样的. 但是, 从含义上是不一样的.
1. 关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更改和更换的.
2. 聚合关系. 属于关联关系中的一种特例. 侧重点是xxx和xxx聚合成xxx. 各⾃有各自的
生命周期. 比如电脑. 电脑里有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是
完整的个体
3. 组合关系. 属于关联关系中的一种特例. 写法上差不多. 组合关系比聚合还要紧密. 比如⼈的⼤脑, ⼼脏, 各个器官. 这些器官组合成⼀个人. 这时. 人如果挂了. 其他的东⻄也跟着挂了
首先我们看关联关系:
这个最简单. 也是最常用的⼀种关系. 比如. 大家都有男女朋友. 男人
关联着女朋友. 女人关联着男朋友. 这种关系可以是互相的, 也可以是单⽅的.
class Boy: def __init__(self, name, girlFriend=None): # 在初始化的时候可以给一个对象的属性设置成另一个类的对象 self.girlFriend = girlFriend # 一个男孩有一个女朋友 def chi(self): if self.girlFriend: print(f"带着他的女朋友{self.girlFriend.name}去吃饭") else: print("单身狗, 吃什么吃? 滚去学习.") def movie(self): if self.girlFriend: print(f"带着他的女朋友{self.girlFriend.name}去看电影") else: print("单身狗, 看什么看? 滚去学习.") class Girl: def __init__(self, name): self.name = name b = Boy("宝浪") g = Girl("孙艺珍") b.chi() # alex给包浪介绍了一个女朋. 孙艺珍 b.girlFriend = g b.chi() g2 = Girl("梁咏琪") b.girlFriend = g2 # 换了个女朋友 b.chi() # 单身狗, 吃什么吃? 滚去学习. # 带着他的女朋友孙艺珍去吃饭 # 带着他的女朋友梁咏琪去吃饭
注意. 此时Boy和Girl两个类之间就是关联关系. 两个类的对象紧密练习着. 其中一个没有
了. 另一个就孤单的不得了. 关联关系, 其实就是 我需要你. 你也属于我. 这就是关联关系. 像
这样的关系有很多很多. 比如. 学校和老师之间的关系.
School --- 学校
Teacher--- 老师
老师必然属于⼀个学校. 换句话说. 每个老师肯定有⼀个指定的工作机构. 就是学校. 那老师
的属性中必然关联着学校.
class School: def __init__(self, name): self.teach_list = [] # 这里要装多个老师 self.name = name def zhaopin(self, teach): self.teach_list.append(teach) def shangke(self): for t in self.teach_list: t.work() class Teacher: def __init__(self, name): self.name = name def work(self): print(f"{self.name}在上课") lnh = School("老男孩") t1 = Teacher("武sir") t2 = Teacher("太白") t3 = Teacher("哪吒") t4 = Teacher("女神") t5 = Teacher("日天") t6 = Teacher("宝浪") lnh.zhaopin(t1) lnh.zhaopin(t2) lnh.zhaopin(t3) lnh.zhaopin(t4) lnh.zhaopin(t5) lnh.zhaopin(t6) lnh.shangke() # 武sir在上课 # 太白在上课 # 哪吒在上课 # 女神在上课 # 日天在上课 # 宝浪在上课
好了. 这就是关联关系. 当我们在逻辑上出现了. 我需要你. 你还得属于我. 这种逻辑 就是关
联关系. 那注意. 这种关系的紧密程度比上面的依赖关系要紧密的多. 为什么呢? 想想吧
至于组合关系和聚合关系. 其实代码上的差别不⼤大. 都是把另一个类的对象作为这个类的
属性来传递和保存. 只是在含义上会有些许的不同而已.
继承关系
在⾯向对象的世界中存在着继承关系. 我们现实中也存在着这样的关系. 我们说过. x是一
种y, 那x就可以继承y. 这时理解层面上的. 如果上升到代码层面. 我们可以这样认为. 子类在不
影响父类的程序运行的基础上对父类进行的扩充和扩展. 这里.我们可以把父类被称为超类或
者基类. 子类被称为派生类
首先, 类名和对象默认是可以作为字典的key的
class Foo: pass print(hash(Foo)) # 可哈希 ##-9223371886657599443 print(hash(Foo())) ##150199209592 # 我们写好的类和创建的对象默认都是可哈希的 # 去掉可哈希 class Foo: __hash__ = None # 当前类的对象不可哈希 print(hash(Foo)) # 可哈希 # -9223371886657599384 # print(hash(Foo())) # TypeError: unhashable type: 'Foo'不可哈希 class Foo: def chi(self, food): print("我爱吃鱼和", food) class Bar: def chi(self, food): print("我爱吃肉和", food) dic = {Foo: "鸡蛋", Bar: "香肠"} for k, v in dic.items(): k().chi(v) # 我爱吃鱼和 鸡蛋 # 我爱吃肉和 香肠
类名和对象默认是可以作为字典的key的
接下来. 我们来继续研究继承上的相关内容. 在本节中主要研究一下self. 记住. 不管方法之
间如何进行调用. 类与类之间是何关系. 默认的self都是访问这个⽅法的对象.
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
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 #
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
总结. self在访问方法的顺序: 永远先找自己的. ⾃己的找不到再找⽗类的.
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() # 1 # 111 1 # 2 # 111 2 # 3 # 222 3
结论: self就是你访问方法的那个对象. 先找⾃己, 然后在找父类的.
类中的关系: 依赖关系是最轻的. 最重的是继承关系. 关联关系是比较微妙的.
self到底是谁?
self:谁调用的就是谁. 类型是根据调用方的对象来进行变换的
super:表示的是父类
类中的特殊成员
什么是特殊成员呢? __init_()就是一个特殊的成员. 说白了. 带双下划线的那一坨. 这些方
法在特殊的场景的时候会被自动的执行. 比如,
1. 类名() 会自动执行__init__()
2. 对象() 会⾃动执行__call__()
3. 对象[key] 会⾃动执行__getitem__()
4. 对象[key] = value 会自动执行__setitem__()
5. del 对象[key] 会⾃动执行 __delitem__()
6. 对象+对象 会⾃动执行 __add__()
7. with 对象 as 变量 会自动执行__enter__ 和__exit__
8. 打印对象的时候 会自动执行 __str__
9. 干掉可哈希 __hash__ == None 对象就不可哈希了了.
...
......
.........
特殊成员:
__init__() # 创建对象的时候初始化操作
__call__() # 对象()
__getitem__() # 对象[哈哈]
__setitem__() # 对象[哈哈] = 值
__new__() # 创建对象的时候.开辟内存
__enter__() # with 对象
__exit__() #结束with的时候
__hash__() # 可哈希 hash()
创建对象的真正步骤:
首先, 在执行类名()的时候. 系统会自动先执行__new__()来开辟内存. 此时新开辟出来的内
存区域是空的. 紧随其后, 系统⾃动调⽤__init__()来完成对象的初始化工作. 按照时间轴来算.
1. 加载类
2. 开辟内存(__new__)
3. 初始化(__init__)
4. 使⽤用对象⼲干xxxxxxxxx
类似的操作还有很多很多. 我们不需要完全刻意的去把所有的特殊成员全都记住. 实战中也
用不到那么多. 用到了查就是了.
面向对象编程的执行流程 ->
1. 加载类 -> 给类创建一个名称空间 -> 主要存放类变量.
2. 创建对象 -> 先找类. -> 根据类来开辟内存 ->
执行类中的__new__() -> 执行__init__() -> 返回对象
class Foo: def __init__(self): # 初始化操作 print("我是init, 我是老二") print("初始化操作. 在创建对象的时候自动调用这个方法") def __new__(cls, *args, **kwargs): # 创建, 它是真正的构造方法, 可以开辟内存 print("我是new. 我是老大") return object.__new__(cls) # 为了 对象() def __call__(self, *args, **kwargs): print("我是对象()") # 对象[] def __getitem__(self, item): print("item=",item) print("你执行了__getitem__") return "哈哈" # 对象[key] = value def __setitem__(self, key, value): print("key, ", key) print("value, ", value) # del lst[1] def __delitem__(self, key): print("key=", key) # with 对象: def __enter__(self): print("我是enter") # with 对象: 代码执行完毕. 最后执行这里 def __exit__(self, exc_type, exc_val, exc_tb): print("我叫exit") def __len__(self): print("我的天哪") return 3 f = Foo() # 自动执行__init__() f() # 调用-> __call__() print(callable(f)) # 对象() print(f["李嘉诚"]) # 自动调用__getitem__() f['jay'] = "林俊杰" del f['哈哈'] with f: print("我是哈哈哈哈") with open() : lst = ["孙艺珍", "李金珠", "井柏然"] lst[2] # =>自动的调用__getitem__() def func(): pass func = 3 print(callable(func)) # 判断xxx是否是可调用的 f.__init__() # 第一次这么写. 以后别这么写 lst = [1,2,3,4] it = iter(lst) print(it.__next__()) print(next(it)) # __next__() 面试之前翻一番 写出15个特殊成员, 并给出具体作用