python面向对象之 类的关系

内容梗概:
    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)