1.类传递参数

import self as self


class Person:

    def __init__(self, name, age):
        """
        init 魔术方法在实例化对象的时候触发
        self = 类的对象
        """
        print("init被触发")
        # 定义对象属性
        self.name = name
        self.age = age

    # 定义一个普通方法
    def eat(self):
        print(f"{self.name}在吃饭, 他今年{self.age}岁")


if __name__ == '__main__':
    # 实例化根根 对象
    lyg = Person("刘鸡鸡", 3)
    # 调用类中的方法
    lyg.eat()

    lh = Person("刘鸡", 5)
    lh.eat()

2.测试

f = open("1.txt", "r")
con_list = f.readlines()
print(con_list)
con_list.insert(2, "my name is bobi")
f.close()

print(con_list)

3.str魔术方法

# 定义一个Monkey类

class Monkey:
    def __init__(self, name, hair):
        """
        name = "刘鸡鸡"
        hair = "gold
        """
        self.name = name
        self.hair = hair

    def __str__(self):
        """
        当实例化对象被打印的时候触发打印输出的是返回值
        """
        return f"这个猴子的名字叫{self.name}, 毛发颜色是{self.hair}"


if __name__ == '__main__':
    # 实例化一个刘鸡鸡对象
    ljj = Monkey("刘鸡鸡", "gold")
    print(ljj)

4.del魔术方法

# 定义一个类
class Computer:

    def __init__(self, name, address):
        self.name = name
        self.address = address

    def __del__(self):
        """
        触发时机：在对象被删除的时候触发
        """
        print(f"{self.name}对象被删除")


if __name__ == '__main__':
    # 定义一个联想的电脑
    Lenovo = Computer("联想", "青岛")
    # 删除对象
    del Lenovo
    

5.继承

# 定义一个类
# Python中的所有的类都默认继承object基类
class A(object):
    def __init__(self):
        self.num = 1

    def print_info(self):
        print(self.num)


# 定义一个子类
# 在B后面的括号中写A说明 A是B的父类
class B(A):
    pass


if __name__ == '__main__':
    # 实例化一个B的对象
    b = B()
    # b调用父类的方法
    b.print_info()
    # 子类的对象定义父类的属性
    print(b.num)

6.单继承

# 定义一个师类
class Master(object):

    def __init__(self):
        self.Kongfu = '[大师傅配方]'

    def make_cake(self):
        print(f"运用{self.Kongfu}制作煎饼果子")


# 定义一个徒弟类 只有一对父子关系 的叫单继承
class Prentice(Master):
    pass


if __name__ == '__main__':
    # 创建一个徒弟类的对象
    rpp = Prentice()
    # 使用徒弟类的对象去 使用kongfu
    print(rpp.Kongfu)
    # 使用徒弟类的对象去调用大师类的方法
    rpp.make_cake()

7.多继承

# 定义一个大师类
class Master(object):
    def __init__(self):
        self.kongfu = "大师煎饼果子配方"

    def make_cake(self):
        print(f"运用{self.kongfu}制作煎饼果子")


# 定义一个学校类
class School:
    def __init__(self):
        self.kongfu = "【连锁品牌的煎饼果子配方】"

    def make_cake(self):
        print(f"运用{self.kongfu}制作煎饼果子")


# 定义一个徒弟类 一个类有两个，甚至多个父类叫做多继承
# 寻找父类的方法，会从第一个父类开始找
class Prentice(School, Master):
    pass


if __name__ == '__main__':
    # 实例化一个徒弟类的对象
    rpp = Prentice()
    # 使用徒弟类的对象调用师傅类的属性
    print(rpp.kongfu)
    # 使用徒弟类的对象调用师傅类的方法
    rpp.make_cake()

8.子类重写父类的属性和方法

# 定义一个大师类
class Master(object):
    def __init__(self):
        self.kongfu = "大师煎饼果子配方"

    def make_cake(self):
        print(f"运用{self.kongfu}制作煎饼果子")


# 定义一个学校类
class School(object):
    def __init__(self):
        self.kongfu = "【连锁品牌的煎饼果子配方】"

    def make_cake(self):
        print(f"运用{self.kongfu}制作煎饼果子")


# 定义一个徒弟类 一个类有两个，甚至多个父类叫做多继承
# 寻找父类的方法，会从第一个父类(超类)开始找
class Prentice(School, Master):
    # 定义子类自己的init函数 不会触发父类init
    def __init__(self):
        self.kongfu = "[独创煎饼果子配方]"

    # 重写父类的方法
    def make_cake(self):
        print(f"运用{self.kongfu}制作煎饼果子")


if __name__ == '__main__':
    # 实例化一个徒弟类的对象
    rpp = Prentice()
    # 使用的是子类自己的配方
    print(rpp.kongfu)
    # 使用的是子类自己的方法
    rpp.make_cake()