python 面向对象(三)类与类之间的关系 初始化方法一些类

###################总结#################

面试的时候 让写python一些特殊方法

__init__ 创建对象的时候初始化
__new__对象实例化调用第一个方法
__call__ 对象
__del__ 销毁的时候
__len__ len调用行为
__str__ str调用行为
__bytes__
__hash__
__bool__ 返回true或者false
__lt__小于
__le__小于等于
__eq__等于
__ne__不等于
__get__大于
__ge__大于等于
__add__添加
__sub__减法行为

1. 依赖关系
执行某个动作的时候. 需要xxx来帮助你完成这个操作. 此时的关系是最轻的.
随时可以更换另外一个东西来完成此操作

class Ren():
    def play(self,toos):
        toos.run()
        print('可以完游戏了')
class DianNao():
    def run(self):
        print('电脑开机了')
class ShouJi():
    def run(self):
        print('手机开机了')
dn=DianNao()
sj=ShouJi()

r=Ren()
r.play(dn)
r.play(sj)
##########################实例二

class ZhiWu:
    def __init__(self,name,xie,shanghai):
        self.name=name
        self.xie=xie
        self.shanghai=shanghai
    def gongji(self,js):
        # print('植物攻击僵')
        js.xie -= self.shanghai
        print(f'僵尸被攻击了{self.shanghai}还剩下{js.xie}')
class JingSi:
    def __init__(self,name,xie,shanghai):
        self.name=name
        self.xie=xie
        self.shanghai=shanghai
    def gongji(self,zw):#这里传入了植物
        # print('僵尸咬植物')
        zw.xie -= self.shanghai #
        #传入植物后 就可以使用zw的血量 减去僵尸的攻击 就是剩下的血量
        print(f'植物被攻击了{self.shanghai}还剩下{zw.xie}')
zw=ZhiWu('向日葵',10,10)
js=JingSi('铁桶僵尸',200,1)
zw.gongji(js)
zw.gongji(js)

js.gongji(zw)

2. 关联关系
在对象里面埋对象
self.girlFriend = girl
1. 一对一关系
你和你的女朋友

self.teach_list = [t1,t2,t3]

class Boy:
    def __init__(self,name,girlFriend=None):#初始化一个男孩,男孩的女孩等一girlFriend
        self.girlFriend=girlFriend
    def chi(self):
        if self.girlFriend:#判断有没有
            print(f'带着他的女朋友{self.girlFriend.name}去吃饭')
        else:
            print('单身狗呵呵呵')
class Girl:
    def __init__(self,name,age):
        self.name=name
        self.age = age
b=Boy('西门庆')#创建一个男的对象
g=Girl('潘金莲',11)#创建一个女的对象
print(g.name)
b.girlFriend = g #这里的绝对值可以写写g.name但是上面的格式化输出的时候 需要直接写成{self.girlFriend}
b.chi()#执行男孩下的chi方法

2. 一对多关系
一个学校. 一堆老师

class School:
    def __init__(self,name):
        self.name=name
        self.teacher_list=[]#用于存储老师
    def zhaoping(self,teacher):
        self.teacher_list.append(teacher)#这里把下面的lnh.zhaoping(t) 老师加入到列表中
    def shangke(self):
        for i in self.teacher_list:#循环出老师
            i.work()
class Teacher:
    def __init__(self,name):#t=Teacher('李白')赋值出老师
        self.name=name
    def work(self):
        print(f"{self.name}在上课")
lnh=School('老男孩')
t=Teacher('李白')
t2=Teacher('荆轲')
lnh.zhaoping(t)
lnh.zhaoping(t2)
lnh.shangke()

类中的关系: 依赖关系是最轻的. 最重的是继承关系. 关联关系是比较微妙的.

self到底是谁?
self:谁调用的就是谁. 类型是根据调用方的对象来进行变换的
super:表示的是父类

特殊成员:

class Foo:
    def __init__(self):
        print("我是初始化")

    def __call__(self, *args, **kwargs):
        print("我是靠")

    def __getitem__(self, item):
        print("我是getitem", item)
        return "大胖小子"
    def __setitem__(self, key, value):
        print(key, value)

    def __delitem__(self, key):
        print(key)

    def __enter__(self):
        print("我是进入")
        return "周润发"
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("我是出来")

# 类名()  __init__() 构造方法
obj = Foo()
# 对象() __call__()
obj() # python特有的.
# 对象[xxx] 从对象中获取数据  默认执行__getitem__()

# 对象[xxx] = ,.... 默认执行__setitem__()
obj["汪峰"] = "章子怡"

# del obj[key] 默认执行__delitem__()
del obj['马化腾']