python类与类的关系

类与类之间的关系(依赖关系,大象与冰箱是依赖关系)

class DaXiang:
    def open(self, bx): #  这里是依赖关系. 想执行这个动作. 必须传递一个bx
        print("大象高高兴兴走到了冰箱的面向前")
        bx.kai() # 传递来的对象执行kai()动作
        print("大象成功的打开了冰箱门")

    def zhuang(self):
        print("自己走进了冰箱")

    def close(self, bx):
        print("大象要关冰箱门了")
        bx.guan()


class BingXiang:
    def kai(self):
        print("我是冰箱. 我会开门 ")
    def guan(self):
        print("我是冰箱. 我会关门 ")

bx1 = BingXiang()
bx2 = BingXiang()
dx = DaXiang()

dx.open(dfg)
dx.zhuang()
dx.close(dfg)

例二 植物大战僵尸

# 植物大战僵尸. 创建一个植物. 创建一个僵尸
# 植物: 名字, 攻击力
# 僵尸: 名字, 血量
# 植物可以打僵尸. 僵尸掉血
# 显示出僵尸挨揍之后的血量
class ZhiWu:
    def __init__(self, name, attack, hp):
        self.name = name
        self.attack = attack
        self.hp = hp

    def fight(self, js):
        js.hp -= self.attack

class JiangShi:
    def __init__(self, name, hp, attack):
        self.name = name
        self.hp = hp
        self.attack = attack

    def chi(self, zhiwu):
        zhiwu.hp -= self.attack

lvluo = ZhiWu("绿萝", 20, 10)
js1 = JiangShi("僵尸一号", 100, 5)
lvluo.fight(js1)
lvluo.fight(js1)
lvluo.fight(js1)

js1.chi(lvluo)
js1.chi(lvluo)
js1.chi(lvluo)
print(lvluo.hp)
print(js1.hp)

⼆. 关联关系.组合关系, 聚合关系
其实这三个在代码上写法是⼀样的. 但是, 从含义上是不⼀样的.
1. 关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更改和更换的.
2. 聚合关系. 属于关联关系中的⼀种特例. 侧重点是xxx和xxx聚合成xxx. 各⾃有各⾃的
声明周期. 比如电脑. 电脑⾥有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是
完整的个体
3. 组合关系. 属于关联关系中的⼀种特例. 写法上差不多. 组合关系比聚合还要紧密. 比
如⼈的⼤脑, ⼼脏, 各个器官. 这些器官组合成⼀个⼈. 这时. ⼈如果挂了. 其他的东⻄
也跟着挂了

关联关系
简单来说就是一对一的关系
例子一
class Boy:
    def __init__(self, name, girlFriend = None):
        self.name = name
        self.girlFriend = girlFriend # 关联关系
    def chi(self): # b
        if self.girlFriend:
            self.girlFriend.happy()
            print("%s和%s在吃饭"  %  (self.name, self.girlFriend.name))
        else:
            print("没女朋友吃什么吃")

class Girl:
    def __init__(self, name):
        self.name = name

    def happy(self):
        print("有好吃的就开心")


b = Boy("王明")
g = Girl("肉丝")
# b对象的girlFriend赋值  g

b.girlFriend = g # 突然天降女朋友
b.chi()
b.girlFriend = None
b.chi()例
例二老师和学生的关系. 一对多的关系  反过来就是一对一

class Teacher:
    def __init__(self, name, lst=None):
        self.name = name
        if lst == None: # 判断传递过来的参数是否是空
            self.lst = []
        else: # 传递过来的是一个列表
            self.lst = lst

    # 添加学生
    def tianjia(self, student):
        self.lst.append(student)

    def display(self):
        for s in self.lst: # s 是老师的学生
            print(s.name)


class Student:
    def __init__(self, num, name, teacher=None):
        self.name = name
        self.num = num
        self.teacher = teacher
t = Teacher("大张伟")
s1 = Student(1, "郭德纲")
s2 = Student(2, "岳云鹏")
s3 = Student(3, "张鹤伦")
s4 = Student(4, "朱云峰")

t.tianjia(s1) # 把学生添加给老师
t.tianjia(s2)
t.tianjia(s4)

# 帖子和评论
class Tie:
    def __init__(self, title, content, author, time, pinglun_lst = None):
        self.title = title
        self.content = content
        self.author = author
        self.time = time
        if pinglun_lst == None:
            self.pinglun_lst = []
        else:
            self.pinglun_lst = pinglun_lst

class Pinglun:
    def __init__(self, name, time, content, fav):
        self.name = name
        self.time = time
        self.content = content
        self.fav = fav

pl1 = Pinglun("UZI", "昨天1", "UZI发出祝福",1888888)
pl2 = Pinglun("xiaohu", "昨天2", "UZI发出祝福",1888888)
pl3 = Pinglun("若风", "昨天3", "UZI发出祝福",1888888)
pl4 = Pinglun("let me", "昨天3", "UZI发出祝福",1888888)
pl5 = Pinglun("长长", "昨天4", "UZI发出祝福",1888888)
pl6 = Pinglun("jackylove", "昨天5", "UZI发出祝福",1888888)
pl7 = Pinglun("mlxg", "昨天6", "UZI发出祝福",1888888)
pl8 = Pinglun("miss", "昨天7", "UZI发出祝福",1888888)

lst = []
lst.append(pl1)
lst.append(pl2)
lst.append(pl3)
lst.append(pl4)
lst.append(pl5)
lst.append(pl6)
lst.append(pl7)
lst.append(pl8)


# 显示帖子的内容.  评论的内容
tie = Tie("S8_IG夺冠. 王思聪怒吃热狗. ", "IG的上单The Shy疯了一样. 一个打5个. 自己人都不放过", "王明","某年某月某一天",lst )
print(tie.content)

# 评论
# print(tie.pinglun_lst)
for pl in tie.pinglun_lst:
    print(pl.content)

继承关系,指的是子类继承父类除私有属性外所有的属性.
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()

四. 类中的特殊成员
 什么是特殊成员呢? __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
 
类似的操作还有很多很多. 我们不需要完全刻意的去把所有的特殊成员全都记住. 实战中也
⽤不到那么多. ⽤到了查就是了.