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 = 30self的含义和用法
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()
# 执行结果
(, , , )
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