Python面向对象详解（4-4）

# 定义一个父类Animal
class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print(f"{self.name}正在吃东西")

    def sleep(self):
        print(f"{self.name}正在睡觉")


# 定义一个子类Dog，继承自Animal类
class Dog(Animal):
    def __init__(self, name, breed):
        # 调用父类Animal的初始化方法，传递name参数
        super().__init__(name)
        self.breed = breed

    def bark(self):
        print(f"{self.name}正在汪汪叫")


# 定义另一个子类Cat，也继承自Animal类
class Cat(Animal):
    def __init__(self, name, color):
        # 调用父类Animal的初始化方法，传递name参数
        super().__init__(name)
        self.color = color

    def purr(self):
        print(f"{self.name}正在咕噜咕噜叫")


# 创建一个Dog实例并调用其方法
my_dog = Dog("旺财", "拉布拉多")
my_dog.eat()  # 继承自父类Animal的eat方法
my_dog.sleep()  # 继承自父类Animal的sleep方法
my_dog.bark()  # Dog类自己定义的bark方法

# 创建一个Cat实例并调用其方法
my_cat = Cat("咪咪", "白色")
my_cat.eat()  # 继承自父类Animal的eat方法
my_cat.sleep()  # 继承自父类Animal的sleep方法
my_cat.purr()  # Cat类自己定义的purr方法

旺财正在吃东西
旺财正在睡觉
旺财正在汪汪叫
咪咪正在吃东西
咪咪正在睡觉
咪咪正在咕噜咕噜叫

进程已结束,退出代码0

# coding:utf-8

# 书写一个父类
class Father(object):
    def talk(self):
        print('小白的爸爸说了一句话')

    @staticmethod
    def jump():
        print('大家都可以跳')


# 书写一个子类，并且继承一个父类
class Brother(Father):
    @staticmethod
    def run():
        print('小白的哥哥在奔跑着')

    # 重写父类函数
    def talk(self):
        print('小白的哥哥在说话')


"""
    为什么要使用多态？
    为什么要继承父类？
    答：
        为了使用已经写好的类的函数
        为了保留子类中某个和父类名称一样的函数功能，这时候，我们就用到了多态，
        可以帮助我们保留子类中的函数功能
"""


class XiaoShu(Father):
    def talk(self):
        print('小白也可以表达自己的观点')


if __name__ == '__main__':
    brother = Brother()
    brother.run()
    brother.talk()
    brother.jump()
    print('----------')
    father = Father()
    father.talk()
    father.jump()
    print('----------')

    xiaoshu = XiaoShu()
    xiaoshu.talk()
    xiaoshu.jump()
    print('----------')

小白的哥哥在奔跑着
小白的哥哥在说话
大家都可以跳
----------
小白的爸爸说了一句话
大家都可以跳
----------
小白也可以表达自己的观点
大家都可以跳
----------

进程已结束,退出代码0

# coding:utf-8

class Parent(object):
    def __init__(self, p):
        print('hello i am parent %s' % p)


class Child(Parent):
    def __init__(self, c, p):
        print('hello i am child %s' % c)
        super(Child, self).__init__(p)  # 这两种方法都可以实现，python3.0后。super括弧内不用传参数，也能执行
        super().__init__(p)  # 这两种方法都可以实现，python3.0后。super括弧内不用传参数，也能执行


if __name__ == '__main__':
    c = Child(c='child', p='parent')

hello i am child child
hello i am parent parent
hello i am parent parent

进程已结束,退出代码0

# coding:utf-8

class Point(object):
    # 自定义Point类的构造(初始化)方法
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 自定义Point类对象的格式化输出函数(string())
    def string(self):
        print(f'x:{self.x}, y:{self.y}')


class Circle(Point):
    # 自定义Circle类的构造(初始化)方法
    def __init__(self, x, y, radius):
        super().__init__(x, y)
        self.r = radius

    # 自定义Circle类对象的格式化输出函数(string())
    def string(self):
        print(f'该图形初始化点为：{{X：{self.x}, Y：{self.y}; {{半径为：{self.r}}}')


class Size(object):
    # 自定义Size类的构造(初始化)方法
    def __init__(self, width, height):
        self.width = width
        self.height = height

    # 自定义Size类对象的格式化输出函数(string())
    def string(self):
        print(f'{{Width：{self.width}, Height：{self.height}}}')


class Rectangle(Point, Size):
    # 自定义Rectangle类的构造(初始化)方法，并在方法中调用父类的初始化方法以完成初
    def __init__(self, x, y, width, height):
        # Point.__init__(self, x, y)  # 多重继承中调用不同类中的相同方法时所采用的格式（法一）
        # Size.__init__(self, width, height)  # 多重继承中调用不同类中的相同方法时所采用的格式（法一）
        super(Rectangle, self).__init__(x, y)  # 多重继承中调用不同类中的相同方法时所采用的格式（法二）super() 函数调用的是Rectangle类在其所在的 MRO 表（方法解析顺序）中的下一个类，也就是Point
        super(Point, self).__init__(width, height)  # 多重继承中调用不同类中的相同方法时所采用的格式（法二）super() 函数调用的是类在其所在的 MRO 表（方法解析顺序）中的下一个类
        """
            当前类所在的MRO表为 Rectangle>Point>Size>object,可以调用__mro__来查看方法解析顺序表，其中调用__mro__的类将作为MRO顺序表中的第一个类
            super() 函数调用的是当前类在方法解析顺序(MRO)中的下一个类，也就是在MRO列表中当前类的下一个类。MRO 是一种确定多重继承中继承顺序的算法，Python 中采用的是 C3 算法。在 Python 中，
            每个类都有一个 MRO，可以通过查看类属性 __mro__ 来获取其 MRO。在调用 super() 函数时，Python 会自动根据 MRO 找到下一个类。
        """

    # 自定义Rectangle类对象的格式化输出函数(string()
    def string(self):
        print(f'该图形初始化点为：{{X：{self.x}, Y：{self.y}}}; 长宽分别为：{{Width：{self.width}, Height：{self.height}}}')


if __name__ == "__main__":
    # 实例化Circle对象，圆心为（5,5），半径为8
    c = Circle(5, 5, 8)
    c.string()
    # 实例化Rectangle对象，顶点位置（15,15），长和宽
    r1 = Rectangle(15, 15, 15, 15)
    r1.string()
    # 实例化Rectangle对象，顶点位置（40,30），长和宽
    r2 = Rectangle(40, 30, 11, 14)
    r2.string()
    print('MRO为：', Rectangle.__mro__)  # 返回一个包含解析顺序的元组

该图形初始化点为：{X：5, Y：5; {半径为：8}
该图形初始化点为：{X：15, Y：15}; 长宽分别为：{Width：15, Height：15}
该图形初始化点为：{X：40, Y：30}; 长宽分别为：{Width：11, Height：14}
MRO为： (<class '__main__.Rectangle'>, <class '__main__.Point'>, <class '__main__.Size'>, <class 'object'>)

进程已结束,退出代码0

# coding:utf-8


class Test(object):
    # 当打印实例对象本身的时候，用于返回一个对象的字符串表示形式
    def __str__(self):
        return 'this is a test class'

    # 用于访问一个不存在的属性时进行拦截和处理
    def __getattr__(self, item):
        return f'这个{item}，不存在'

    # 用于拦截属性赋值的
    def __setattr__(self, key, value):
        """
        __setattr__方法是用于拦截属性赋值的，而不是拦截不存在的属性或值。当我们给一个对象的属性赋值时，Python会自动调用该对象的__setattr__方法来设置属性。

        :param key: 需要赋值的属性，如果该属性已经存在，则会更新它的值；如果该属性不存在，则会创建一个新属性，并将其值设置为赋值的值。
        :param value:需要传入的值
        """
        print(key, value)
        self.__dict__[key] = value
        '''
            __dict__是Python中的一个特殊属性，用于获取一个对象的所有属性和方法的字典。当我们访问一个对象的__dict__属性时，Python会返回一个字典对象，该字典的键是对象的属性名或方法名，而值是相应的属性值或方法对象。
        '''
        print(self.__dict__)
        """
        每个对象在Python中都有一个__dict__属性，它是一个字典对象，包含了某个对象的所有属性和方法以及它们所对应的值。每当我们给对象添加一个新的属性或方法时，这个属性或方法就会被添加到该对象的__dict__属性中。
        在Python中，通过访问__dict__属性，我们可以动态地添加、删除或修改对象的属性和方法，这也是Python动态语言的一个重要特性之一。
        """

    def __call__(self, *args, **kwargs):
        """
        __call__是Python中的一个特殊方法，用于让一个对象变成可调用对象（callable object）。当我们对一个对象
        使用函数调用运算符()时，如果该对象定义了__call__方法，Python会自动调用该对象的__call__方法来执行函数调用操作。

        :param args: 需要传入的多个位置参数
        :param kwargs: 需要传入的多个关键字参数
        """
        print('call is start')
        print(args, kwargs)


t = Test()
print(t)
print(t.a)  # 不存在的对象会直接打印出来而不是报错
t.name = 'xiaoshu'
t(123, name='xiaoding')
print('---------')

'''实现链式操作'''


class Test2(object):
    def __init__(self, attr=''):
        self.__attr = attr
        self(self.__attr)

    def __call__(self, name):
        print("key is {}".format(self.__attr))
        return name

    def test(self):
        print(self.b)

    def __getattr__(self, key):
        if self.__attr:
            key = '{}.{}'.format(self.__attr, key)
        else:
            key = key
        print(key)
        return Test2(key)  # 递归操作


t2 = Test2()
#  链式调用,a.c是在原有调用a的基础上调用c,链式操作就是多个点的形式
print(t2.a.c('xiaoshu'))
print('--------')
t2.test()

this is a test class
这个a，不存在
name xiaoshu
{'name': 'xiaoshu'}
call is start
(123,) {'name': 'xiaoding'}
---------
key is 
a
key is a
a.c
key is a.c
key is a.c
xiaoshu
--------
b
key is b
<__main__.Test2 object at 0x000001CD81718AD0>

进程已结束,退出代码0