python类与类之间的关系

class Person:
    def f1(self,tools):     # 通过参数的传递把另外一个类的对象传递进来
        tools.run()
        print(‘皮一下很开心‘)
class Computer:
    def run(self):
        print(‘电脑开机运行‘)
class Phone:
    def run(self):
        print(‘手机开机‘)
c = Computer()
a = Phone()
p = Person()
p.f1(a)         #把Phone类的对象a传递给Person的f1方法作为参数
结果
手机开机
皮一下很开心

事例二
植物大战僵尸
class Plant:
    def __init__(self,hp,ad):
        self.hp = hp
        self.ad = ad
    def attack(self,js):
        print(‘植物攻击僵尸‘)
        js.hp -= self.ad
        print(f‘僵尸掉血{self.ad},剩余{js.hp}‘)
class JiangShi:
    def __init__(self,hp,ad):
        self.hp = hp
        self.ad = ad
    def attack(self,zw):
        print(‘僵尸咬植物‘)
        zw.hp -= self.ad
        print(f‘植物掉血{self.ad},剩余{zw.hp}‘)
zw = Plant(100,11)
js = JiangShi(80,15)
zw.attack(js)
zw.attack(js)
js.attack(zw)
js.attack(zw)
结果
植物攻击僵尸
僵尸掉血11,剩余69
植物攻击僵尸
僵尸掉血11,剩余58
僵尸咬植物
植物掉血15,剩余85
僵尸咬植物
植物掉血15,剩余70

一对一关系
class Boy:
    def __init__(self,name,girFriend=None):
        self.name = name
        self.girFriend = girFriend
    def play(self):
        if self.girFriend:
            print(f‘{self.name}带着他女朋友{self.girFriend.name}去吃饭‘)
        else:
            print(‘单身狗,还吃什么饭‘)
    def movie(self):
        if self.girFriend:
            print(f‘{self.name}带着他女朋友{self.girFriend.name}去看电影‘)
        else:
            print(‘单身狗,还看什么电影‘)
class Girl:
    def __init__(self,name):
        self.name = name
b = Boy(‘刘昊然‘)
g = Girl(‘刘丽‘)
b.play()

b.girFriend = g
b.play()

g2 = Girl(‘王萌‘)
b.girFriend = g2
b.movie()


一对多关系
self.teach_list = [t1,t2,...]
class School:
    def __init__(self,name):
        self.teach_list = []
    def zhaopin(self,teach):
        self.teach_list.append(teach)
    def shangke(self):
        for i in self.teach_list:
            i.work()
class Teacher:
    def __init__(self,name):
        self.name = name
    def work(self):
        print(f‘{self.name}在上课‘)
lnh = School(‘测试‘)
t1 = Teacher(‘赵老师‘)
t2 = Teacher(‘刘老师‘)
lnh.zhaopin(t1)
lnh.zhaopin(t2)
lnh.shangke()
结果
赵老师在上课
刘老师在上课

class Base:         #父类又叫基类又叫超类
    def chi(self):
        print(‘吃饭‘)
class Foo(Base):    #子类又叫派生类,这个类继承了Base类,Foo类是对Base的一个扩展
    def he(self):
        print(‘喝水‘)
f = Foo()
f.chi()
f.he()
print(hash(Foo))    #默认类和创建的对象都是可哈希的
print(hash(Foo()))
结果
吃饭
喝水
-9223371912599947772
-9223371912597968945

去掉可哈希
__hash__ = None
class Base:
    def chi(self):
        print(‘吃饭‘)
class Foo(Base):
    __hash__ = None     # 当前类的对象不可哈希
    def he(self):
        print(‘喝水‘)
f = Foo()
f.chi()
f.he()
print(hash(Foo))    # 类名永远可哈希
print(hash(Foo()))  # TypeError: unhashable type: ‘Foo‘

class Foo:
    def chi(self,food):
        print(‘吃鱼和‘,food)
class Bar:
    def chi(self,food):
        print(‘吃肉和‘,food)
dic = {Foo:‘面包‘,Bar:‘牛奶‘}
for k,v in dic.items():
    k().chi(v)
结果
吃鱼和 面包
吃肉和 牛奶

__call__ 
对象后面加括号,触发执行
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print(‘__call__‘)

obj = Foo()  # 执行 __init__
obj()  # 执行 __call__
结果
__call__

事例2
class Foo:
    def __init__(self):                 # 初始化操作
        print(‘我是init,我是第二‘)

    def __new__(cls, *args, **kwargs):  # 创建,是真正的构造方法,可以开辟内存
        print(‘我是new,我是第一‘)
        return object.__new__(cls)

    def __call__(self, *args, **kwargs): # 对象()   
        print(‘我是对象call‘)

    def __getitem__(self, item):        # 对象[]
        print(‘item‘,item)
        print(‘我是getite‘)

    def __setitem__(self, key, value):  # 对象[key] = value
        print(‘key‘,key)
        print(‘value‘,value)
Foo()
f = Foo()          # 自动执行__init__()
f()                # 调用__call__()
print(callable(f)) # 对象()
print(f[‘娃哈哈‘]) #自动调用__getitem__()
f[‘人‘]=‘刘丽‘     #自动的调用__getitem__()
结果
我是new,我是第一
我是init,我是第二
我是new,我是第一
我是init,我是第二
我是对象call
True
item 娃哈哈
我是getite
None
key 人
value 刘丽


事例3
class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print(‘del obj[key]时,我执行‘)
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print(‘del obj.key时,我执行‘)
        self.__dict__.pop(item)

f1=Foo(‘sb‘)
f1[‘age‘]=18
f1[‘age1‘]=19
print(f1.__dict__)
del f1.age1
del f1[‘age‘]
f1[‘name‘]=‘alex‘
print(f1.__dict__)
结果
{‘name‘: ‘sb‘, ‘age‘: 18, ‘age1‘: 19}
del obj.key时,我执行
del obj[key]时,我执行
{‘name‘: ‘alex‘}


事例4
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #这个对象字符串的表示
    def __str__(self):  #返回该对象的字符串表示形式
        return f‘{self.name},{self.age}‘
    def __repr__(self):  #该对象的官方的字符串表示形式
        return f‘{self.name},{self.age}‘
s = Person(‘bob‘,‘18‘)
print(s)
结果
bob,18

事例5
class B:
    def __str__(self):
        return ‘str : class B‘
    def __repr__(self):
        return ‘repr : class B‘
b = B()
print(‘%s‘ % b)     #这个执行的是__str__函数方法
print(‘%r‘ % b)     #这个执行的是__repr__函数方法
结果
str : class B 
repr : class B


__del__
析构方法,当对象在内存中被释放时,自动触发执行
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo:

    def __del__(self):
        print(‘执行我啦‘)

f1=Foo()
del f1
print(‘------->‘)
结果
执行我啦
------->