python--类与类之间的关系,(魔术方法)特殊成员方法

class Person:

    def play(self, tools): # 通过参数的传递把另外一个类的对象传递进来

        tools.run()

        print("很开心, 我能玩儿游戏了")

class Computer:

    def run(self):

        print("电脑开机. 可以运行")

class Phone:

    def run(self):

        print("手机开机, 可以运行")

c = Computer()

phone = Phone()

p = Person()

p.play(phone)

# 写一个植物大战僵尸

# 1. 植物

#       打僵尸. 僵尸掉血

# 2. 僵尸

#       吃植物. 植物掉血

class Plant:

    def __init__(self, name, hp, ad): # 200

        self.name = name

        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, name, hp, ad): # 1000  800

        self.name = name

        self.hp = hp

        self.ad = ad

    def attack(self, zw):

        print("僵尸咬植物")

        zw.hp -= self.ad

        print(f"植物掉血{self.ad}, 还剩{zw.hp}")

# 植物

wd = Plant("歪脖子豌豆", 10, 20)

# 僵尸

js = JiangShi("铁桶僵尸", 200, 1)

wd.attack(js)

wd.attack(js)

wd.attack(js)

wd.attack(js)

wd.attack(js)

js.attack(wd)

js.attack(wd)

js.attack(wd)

js.attack(wd)

class Boy:

    def __init__(self, name,  girlFriend=None):

        # 在初始化的时候可以给一个对象的属性设置成另一个类的对象

        self.girlFriend = girlFriend  # 一个男孩有一个女朋友

    def chi(self):

        if self.girlFriend:

            print(f"带着他的女朋友{self.girlFriend.name}去吃饭")

        else:

            print("单身狗, 吃什么吃? 滚去学习.")

    def movie(self):

        if self.girlFriend:

            print(f"带着他的女朋友{self.girlFriend.name}去看电影")

        else:

            print("单身狗, 看什么看? 滚去学习.")

class Girl:

    def __init__(self, name):

        self.name = name

b = Boy("小明")

g = Girl("小红")

b.chi()

# 给小名介绍一个女朋友 小红

b.girlFriend = g

b.chi()

g2 = Girl("小红")

b.girlFriend = g2 # 换了个女朋友

b.chi()

class School:

    def __init__(self, name):

        self.teach_list = [] # 这里要装多个老师

        self.name = name

    def zhaopin(self, teach):

        self.teach_list.append(teach)

    def shangke(self):

        for t in self.teach_list:

            t.work()

class Teacher:

    def __init__(self, name):

        self.name = name

    def work(self):

        print(f"{self.name}在上课")

lnh = School("小学")

t1 = Teacher("王老师")

t2 = Teacher("赵老师")

t3 = Teacher("钱老师")

t4 = Teacher("孙老师")

t5 = Teacher("李老师")

t6 = Teacher("周老师")

lnh.zhaopin(t1)

lnh.zhaopin(t2)

lnh.zhaopin(t3)

lnh.zhaopin(t4)

lnh.zhaopin(t5)

lnh.zhaopin(t6)

lnh.shangke()

__init__ :      构造函数，在生成对象时调用,类名()会自动执行

__del__ :       析构函数，释放对象时使用

__repr__ :      打印，转换为解释器读取的形式

__setitem__ :   按照索引赋值

__getitem__:    按照索引获取值

__len__:        获得长度

__cmp__:        比较运算,对象比较

__call__:       调用

__add__:        加运算

__sub__:        减运算

__mul__:        乘运算

__div__:        除运算

__mod__:        求余运算

__pow__:        幂

__call__        对象()会自动执行

__getitem__     对象[key]会自动执行

__setitem__     [key]=value会自动执行

__delitem__      del对象[key]会自动执行

__enter__  和__exit__      with对象as变量会自动执行

__str__          打印对象的时候会自动执行

__hash__  == None 对象就不可哈希了

__new__          开辟内存

__iter__         iter(对象)

类名()会自动执行__init__()

def __init__(self): # 初始化操作

       print("我是init,  我是老二")

       print("初始化操作. 在创建对象的时候自动调用这个方法")

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

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

        print("我是对象()")

 # 对象[]

 def __getitem__(self, item):

      print("item=",item)

      print("你执行了__getitem__")

      return "哈哈"

del lst[1]

     def __delitem__(self, key):

          print("key=", key)

# with 对象:

def __enter__(self):

   print("我是enter")

# with 对象: 代码执行完毕. 最后执行这里

def __exit__(self, exc_type, exc_val, exc_tb):

   print("我叫exit")

class Student:

    def __init__(self, name, no, gender, cls, age):

        self.name = name

        self.no = no

        self.gender = gender

        self.cls = cls

        self.age = age

    # 这个对象字符串的表示.

    def __str__(self): # 返回该对象的字符串表示形式

        return f"{self.name}, {self.no}, {self.gender}"

    def __repr__(self): # 该对象的官方的字符串表示形式

        return f"{self.name}, {self.no}, {self.gender}"

s = Student("小名", "3", "男", "三年二班", "31")

print(s)

干掉可哈希__hash__ == None 对象就不可哈希了