内容梗概:
1. 依赖关系
2. 关联关系, 组合关系, 聚合关系
3. 继承关系, self到底是什什么鬼?
4. 类中的特殊成员
1. 依赖关系
def:在方法中给方法传递一个对象. 此时类与类之间的关系是最轻的,
我⽤用着你. 但是你不属于我. 这种关系是最弱的.比如临时工.
详见实例:
class JiangShi():
def __init__(self,name,HP):
self.name = name
self.HP = HP
def beida(self): #方法中给方法传递一个对象
print("我是僵尸%s,我被暴打了一顿"%(self.name))
class ZhiWu():
def __init__(self,name,power,jineng):
self.name = name
self.power = power
self.jineng = jineng
def attack(self,el):
print("我是植物%s,我刚刚用%s攻击了僵尸%s"%(self.name,self.jineng,el.name ))
el.beida()
el.HP -= self.power
print("%s血量还剩下%s"%(el.name,el.HP))
zw = ZhiWu("小菊花",10,"无敌萌萌拳")
js = JiangShi("小可爱",1000)
zw.attack(js)
zw.attack(js)
2. 关联关系, 组合关系, 聚合关系
定义:
1. 关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更更改和更更换的.
2. 聚合关系. 属于关联关系中的一种特例例. 侧重点是xxx和xxx聚合成xxx. 各⾃有各⾃的声明周期.
比如电脑. 电脑里里有CPU, 硬盘, 内存等等. 电脑挂了了. CPU还是好的. 还是完整的个体
3. 组合关系. 属于关联关系中的一种特例.写法上差不多.组合关系比聚合还要紧密.比如人的大脑,心脏,各个器官.
这些器官组合成⼀个人. 这时. 人如果挂了了. 其他的东⻄也跟着挂了.
实例1:男女朋友
class Boy():
def __init__(self,name,girlfriend=None):
self.name = name
self.girlfriend = girlfriend
def chi(self):
if self.girlfriend:
print("%s和%s在街边吃麻辣烫"%(self.name,self.girlfriend.name))
else:
print("单身狗自己在家抠脚就好")
class Girl:
def __init__(self,name):
self.name = name
b1 = Boy("小鲜肉")
g1 = Girl("小白菜")
b1.girlfriend = g1
b1.chi()
b1.girlfriend = None
b1.chi()
实例2:老师和学生
class Teacher():
def __init__(self,name,student_list = None):
self.name = name
if student_list == None:
self.student_list = []
else:
self.student_list = student_list
def add(self,stu):
self.student_list.append(stu)
def show(self):
for el in self.student_list:
print(el.name)
class Student():
def __init__(self,num,name):
self.name = name
self.num = num
s1 = Student(1,"宋小宝")
s2 = Student(2,"赵四")
s3 = Student(3,"刘能")
s4 = Student(4,"小沈阳")
t1 = Teacher("赵本山",[s1,s2])
t1.add(s3)
t1.add(s4)
t1.show()
3.继承关系, self到底是什什么鬼?
定义:继承
在⾯面向对象的世界中存在着继承关系. 我们现实中也存在着这样的关系. 我们说过. x是⼀种y, 那x就可以继承y.
这时理解层⾯面上的.如果上升到代码层⾯.我们可以这样认为.子类在不影响父类的程序运行的基础上对父类进行的扩充和扩展.
这里.我们可以把父类被称为超类或者基类. 子类被称为派生类.
3.1注意tips:
首先, 类和对象默认都是可哈希的
class Foo:
def __init__(self):
pass
def method(self):
pass
__hash__ = None
print(hash(Foo))
print(hash(Foo()))
既然可以hash. 那就是说字典的key可以是对象或者类
3.2 self.
记住. 不管方法之间如何进行调用. 类与类之间是何关系. 默认的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.func1() #做完这个基本就会了
总结:
1.self在访问方法的顺序: 永远先找⾃己的. ⾃己的找不到再找父类的
2.不管方法之间如何进行调用. 类与类之间是何关系, 默认的self都是访问这个方法的对象
4. 类中的特殊成员
4.1 列举特殊成员
__init__() ,当构建生成对象时自动调用
__getitem__() ,当调用索引类操作的时候会自动调用 对象[索引]
__setitem__() ,当创建字典时会自动调用 对象[key] = values
__delitem__() ,当删除字典,自动调用 del 对象[key]
__enter__(),__exit__() ,当使用文件操作, with 对象 as 变量, 的时候进入和退出时自动调用
__call__() ,调用方法或函数时,对象()
__add__() ,有加法的时候会自动调用 +
__str__() ,当打印输出的时候,会自动调用(平民输出)
__repr__() ,当打印输出的时候,会自动调用(官方输出)
__hash__ == None ,此方法可是对象不可哈希
__len__() ,当调用查询对象长度时 len(对象)
__dir__() 当查询对象方法时自动调用 dir(对象)
__iter__() 对可迭代对象进行迭代会自动调用. 如for 变量 in 可迭代对象
__bool__() 点用布尔值的时候 bool(对象)
创建对象的真正步骤:
首先, 在执行类名()的时候. 系统会⾃动先执行__new__()来开辟内存. 此时新开辟出来的内存区域是空的.
紧随其后, 系统⾃动调用__init__()来完成对象的初始化工作. 按照时间轴来算.
1. 加载类
2. 开辟内存(__new__)
3. 初始化(__init__)
4. 使用对象⼲干xxxxxxxxx
实例1:
class Car:
def __init__(self, color, pai): # 初始化方法
print("哪有地呀")
self.color = color
self.pai = pai
# 这里才是真正的构造方法
def __new__(cls, *args, **kwargs):
print("我的天哪")
# 固定的返回值
return object.__new__(cls)
c = Car("红色", "京A66666") # 先执行__new__ 返回object.__new__(cls).把返回的空对象传递给 __init__()
print(c.color)
