本节主要内容:
1. 依赖关系
2. 关联关系, 组合关系, 聚合关系
3. 继承关系, self到底是什什么⿁鬼?
4. 类中的特殊成员
⼀. 类与类之间的依赖关系
⼤大千世界, 万物之间皆有规则和规律律. 我们的类和对象是对⼤大千世界中的所有事物进⾏行行归 类. 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯面向对象的世界中. 类与类 中存在以下关系:
1. 依赖关系
2. 关联关系
3. 组合关系
4. 聚合关系
5. 继承关系
6. 实现关系
⾸首先. 我 们先看第⼀一种, 也是这些关系中紧密程度最低的⼀一个, 依赖关系.
⾸首先, 我们设计⼀一个场景. 还是最初的那个例例⼦子. 要把⼤大象装冰箱. 注意. 在这个场景中, 其 实是存在了了两种事物的. ⼀一个是⼤大象, ⼤大象负责整个事件的掌控者, 还有⼀一个是冰箱, 冰箱负 责被⼤大象操纵. ⾸首先, 写出两个类, ⼀一个是⼤大象类, ⼀一个是冰箱类.
class Elphant:
def __init__(self, name):
self.name = name
def open(self):
'''
开⻔
:return :return:
'''
pass
def close(self):
'''
关⻔
:return :return:
'''
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, ref):
print("⼤大象要开⻔门了了. 默念三声. 开!")
# 由外界传递进来⼀一个冰箱, 让冰箱开⻔门. 这时. ⼤大象不不⽤用背着冰箱到处跑.
# 类与类之间的关系也就不那么的紧密了了. 换句话说. 只要是有open_door()⽅方法的对象. 都可以接收运⾏
ref.open_door()
def close(self, ref):
print("⼤大象要关⻔门了了. 默念三声. 关!")
pass
def take(self):
print("钻进去")
class Refrigerator:
def open_door(self):
print("冰箱⻔门被打开了了")
def close_door(self):
print("冰箱⻔门被关上了了")
# 造冰箱
r = Refrigerator()
# 造⼤大象
el = Elphant("神奇的⼤大象")
el.open(r) # 注意. 此时是把⼀一个冰箱作为参数传递进去了了. 也就是说. ⼤大象可以指定任何⼀一个 冰箱.
el.take()
el.close(r)
此时, 我们说, ⼤大象和冰箱之间就是依赖关系. 我⽤用着你. 但是你不属于我. 这种关系是最弱的. 比如. 公司和雇员之间. 对于正式员⼯工, 肯定要签订劳动合同. 还得⼩小⼼心伺候着. 但是如果是兼 职. 那⽆无所谓. 需要了了你就来. 不需要你就可以拜拜了了. 这⾥里里的兼职(临时⼯工) 就属于依赖关系. 我⽤用你. 但是你不属于我.
二. 关联关系.组合关系, 聚合关系
其实这三个在代码上写法是⼀一样的. 但是, 从含义上是不⼀一样的.
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_dinner(self):
if self.girlFriend:
print("%s 和 %s⼀一起去吃晚餐" % (self.name, self.girlFriend.name))
else:
print("单身狗. 吃什什么饭")
class Girl:
def __init__(self, name):
self.name = name
b = Boy("alex")
b.have_a_dinner()
# 突然⽜牛B了了. 找到女朋友了了
g = Girl("如花") b.girlFriend = g # 有女朋友了了. 6666
b.have_a_dinner()
gg = Girl("李李⼩小花")
bb = Boy("wusir", gg) # 娃娃亲. 出⽣生就有女朋友. 服不服
bb.have_a_dinner() # 多么幸福的一家
# 突然.bb失恋了了. 娃娃亲不不跟他好了了
bb.girlFriend = None bb.have_a_dinner() # ⼜单身了.
注意. 此时Boy和Girl两个类之间就是关联关系. 两个类的对象紧密练习着. 其中⼀一个没有 了了. 另一个就孤单的不得了了. 关联关系, 其实就是 我需要你. 你也属于我. 这就是关联关系. 像 这样的关系有很多很多. 比如. 学校和老师之间的关系.
School --- 学校
Teacher--- 老师
老师必然属于一个学校. 换句句话说. 每个老师肯定有一个指定的工作机构. 就是学校. 那老师 的属性中必然关联着学校.
class School: def __init__(self, name, address): self.name = name self.address = address
class Teacher: def __init__(self, name, school=None): self.name = name self.school = school
s1 = School("北京高中", "美丽的首都") s2 = School("上海高中", "美丽的上海") s3 = School("深圳高中", "发达的深圳") t1 = Teacher("李老师", s1) t2 = Teacher("王老师", s1) t3 = Teacher("张老师", s2) t4 = Teacher("⾼老师", s3) # 找到⾼老师所在的校区地址 print(t4.school.address)
想想, 这样的关系如果反过来. ⼀一个老师可以选⼀一个学校任职, 那反过来. ⼀一个学校有多少 老师呢? ⼀一堆吧? 这样的关系如何来描述呢?
class School: def __init__(self, name, address): self.name = name self.address = address self.t_list = [] # 每个学校都应该有⼀一个装⼀一堆⽼老老师的列列表 def add_teacher(self, teacher): self.t_list.append(teacher) class Teacher: def __init__(self, name, school=None): self.name = name
self.school = school
s1 = School("北京高中", "美丽的首都") s2 = School("上海高中", "美丽的上海") s3 = School("深圳高中", "发达的深圳")
t1 = Teacher("李老师", s1) t2 = Teacher("王老师", s1) t3 = Teacher("张老师", s2) t4 = Teacher("高老师", s3)
s1.add_teacher(t1) s1.add_teacher(t2) s1.add_teacher(t3) # 查看北京高中有哪些⽼老老师 for t in s1.t_list:
print(t.name)
好了了. 这就是关联关系. 当我们在逻辑上出现了了. 我需要你. 你还得属于我. 这种逻辑 就是关 联关系. 那注意. 这种关系的紧密程度比上⾯面的依赖关系要紧密的多. 为什什么呢? 想想吧
至于组合关系和聚合关系. 其实代码上的差别不大. 都是把另一个类的对象作为这个类的属性来传递和保存. 只是在含义上会有些许的不同⽽而已.
三. 继承关系.
在⾯面向对象的世界中存在着继承关系. 我们现实中也存在着这样的关系. 我们说过. x是一 种y, 那x就可以继承y. 这时理解层⾯面上的. 如果上升到代码层面. 我们可以这样认为. 子类在不 影响父类的程序运⾏的基础上对父类进⾏的扩充和扩展. 这里.我们可以把⽗类被称为超类或 者基类. 子类被称为派生类.
首先, 类名和对象默认是可以作为字典的key的
class Foo:
def __init__(self):
pass
def method(self):
pass
# __hash__ = None
print(hash(Foo))
print(hash(Foo()))
既然可以hash. 那就是说字典的key可以是对象或者类
dic = {}
dic[Foo] = 123
dic[Foo()] = 456
print(dic) # {<class '__main__.Foo'>: 123, <__main__.Foo object at 0x103491550>: 456}
虽然显⽰示的有点⼉儿诡异. 但是是可以⽤用的.
接下来. 我们来继续研究继承上的相关内容. 在本节中主要研究⼀一下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 运⾏行行的是Base中的func1
继续:
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
再来：
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是⼦子类中的
总结. 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() # 那笔来吧. 好好算.
结论: self就是你访问方法的那个对象. 先找自⼰, 然后在找父类的.
四. 类中的特殊成员
什么是特殊成员呢? __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 对象就不可哈希了了.
创建对象的真正步骤:
⾸首先, 在执⾏行行类名()的时候. 系统会⾃自动先执⾏行行__new__()来开辟内存. 此时新开辟出来的内 存区域是空的. 紧随其后, 系统⾃自动调⽤用__init__()来完成对象的初始化⼯工作. 按照时间轴来算.
1. 加载类
2. 开辟内存(__new__)
3. 初始化(__init__)
4. 使⽤用对象⼲干xxxxxxxxx
类似的操作还有很多很多. 我们不需要完全刻意的去把所有的特殊成员全都记住. 实战中也 ⽤用不到那么多. ⽤用到了了查就是了了.