python面向对象三大特性

封装

python的封装是将事物的特征和行为，封装成对应的属性和方法

魔法方法

魔法方法是指不需要主动调用，在某种特定情况下自动调用的方法。

魔法方法的定义方式：__方法名__()

初始化方法

python中类的初始化方法为__init__()

是一个魔法方法，当对象创建时自动调用

class A:
    def __init__(self):
        print("调用A类的初始化方法")


a = A()

# 执行结果
调用A类的初始化方法

初始化方法可以带参数，用于给实例属性赋值，如下：

class A:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
        print(f"a = {self.a}, b = {self.b}, c = {self.c}")


a = A(10, 20, 30)

# 执行结果
a = 10, b = 20, c = 30

self的含义和用法

self是在类中调用属性和方法的关键字，它代表当前调用属性和方法的对象，比如a对象调用实例方法x，此时方法x里面所使用的self就表示a对象

实例属性和实例方法

实例属性就是定义在__init__()里面的属性，通过self.定义和调用

实例方法就是定义在类里面的方法，第一个参数为self。

实例属性和实例方法，可以在类内和类外调用，类内通过self.调用，类外通过对象名调用

class A:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
        print("类内调用实例方法")
        self.func1()  # 类内调用实例方法
        print(f"a = {self.a}, b = {self.b}, c = {self.c}")

    def func1(self):
        print(f'调用了func1()实例方法')
        # 类内调用实例属性
        return self.a + self.b


a = A(10, 20, 30)
print(a.a)  # 类外调用实例属性
print(a.b)
print(a.c)
c = a.func1()  # 类外调用实例方法
print(c)

# 执行结果
类内调用实例方法
调用了func1()实例方法
a = 10, b = 20, c = 30
10
20
30
调用了func1()实例方法
30

类属性和类方法

类属性

类属性就是定义在类中但不定义在__init__()方法中的属性

在类内通过self.或类名调用，在类外可以通过对象名或类名调用

class A:
    x = 100
    y = 200

    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
        print(f'类内调用类属性：x = {self.x}, y = {self.y}')


a = A(10, 20, 30)
print('类外调用类属性')
print(f'通过对象名调用：x = {a.x}')
print(f'通过类名调用：x = {A.x}')

# 执行结果
类内调用类属性：x = 100, y = 200
类外调用类属性
通过对象名调用：x = 100
通过类名调用：x = 100

类方法

类方法是被 @classmethod装饰器 修饰的方法

类方法的第一个参数是cls，代表类本身

cls可以调用类属性和类方法

class A:
    x = 100
    y = 200

    @classmethod
    def class_method(cls):
        cls.x = 88888
        cls.y = 99999
        print(f'x = {cls.x}, y = {cls.y}')


a1 = A()
print(a1.x)
a1.class_method()
print(f'a1调用属性x和y：x = {a1.x}, y = {a1.y}')
a2 = A()
print(f'a2调用属性x和y：x = {a2.x}, y = {a2.y}')

# 执行结果
100
x = 88888, y = 99999
a1调用属性x和y：x = 88888, y = 99999
a2调用属性x和y：x = 88888, y = 99999

静态方法

静态方法是被 @staticmethod装饰器修饰的方法

他没有固定参数

所以它调用不了类里面的属性和方法

类内可以通过self.或类名的方式调用静态方法

类外可以通过对象名或类名的方式调用静态方法

class A:
    x = 100
    y = 200

    def func1(self):
        # 类内调用静态方法
        self.static_method()

    @staticmethod
    def static_method():
        print('调用了静态方法')


a1 = A()
print('类内调用静态方法：')
a1.func1()
print('类外通过对象名调用静态方法：')
a1.static_method()
print('类外通过类名调用静态方法：')
A.static_method()

# 执行结果
类内调用静态方法：
调用了静态方法
类外通过对象名调用静态方法：
调用了静态方法
类外通过类名调用静态方法：
调用了静态方法

继承

继承可以增加代码的复用性

python中有单继承和多继承，其中多继承的继承顺序是从左到右，在调用不同父类中相同的方法时，会优先调用自身的方法，然后才是父类，父类调用的优先级和继承顺序相同，都是从左到右。

super()

子类可以通过super()调用父类的属性和方法，包括__init__()魔法方法

调用父类的__init__()要注意：如果父类的__init__()方法有形参，则调用时也要传参

class A:
    def __init__(self):
        self.a = 'aaaaa'

    def func1(self):
        print('调用 A类 的func1方法')


class B:
    def __init__(self):
        self.b = 'bbbbb'

    def func1(self):
        print('调用 B类 的func1方法')


class C(A, B):
    def __init__(self):
        # 调用多个父类的__init__()方法可以使用下面这种方式
        super().__init__()
        super(A, self).__init__()
        self.c = 'ccccc'

    def func1(self):
        print('调用 C类 的func1方法')


c = C()
# 打印该类的优先级
print(C.__mro__)
print(c.a)
print(c.b)
print(c.c)
c.func1()

# 执行结果
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
aaaaa
bbbbb
ccccc
调用 C类 的func1方法

多态

多态的含义：同一个引用，因为它指向的对象不同，所以表现出来的状态也不同

isinstance()

该方法第一个参数为对象、第二个参数为类名

可以判断该对象是否属于该类或者该类的子类，如果是返回True，不是返回False

可以通过它验证对象的合法性

class A:
    def __init__(self):
        self.name = 'aaaaa'


class B(A):
    def __init__(self):
        super().__init__()
        self.name = 'bbbbb'


class C(A):
    def __init__(self):
        super().__init__()
        self.name = 'ccccc'

# 此处的a变量，因为每次传入的对象是不一样的，所以调用它所产生的结果是不一样的
def printName(a: A):
    print(a.name)


a1 = A()
printName(a1)
b1 = B()
printName(b1)
c1 = C()
printName(c1)
# 可以通过isinstance判断对象是否属于该类或属于该类的子类，返回结果为bool类型
print(isinstance(a1, A))
print(isinstance(b1, A))
print(isinstance(c1, A))

# 执行结果
aaaaa
bbbbb
ccccc
True
True
True