概述
在上一节，我们介绍了Python的函数，包括：函数的定义、函数的调用、参数的传递、lambda函数等内容。在本节中，我们将介绍Python的面向对象编程。面向对象编程（Object-Oriented Programming, 即OOP）是一种编程范型，它以对象为基础，将数据和操作封装在一个类（Class）中。在Python中，类是一种定义对象结构和行为的模板，而对象则是类的实例。类定义了一个新的类型，用于创建具有特定属性和方法的对象。类是面向对象编程的核心，它允许程序员使用对象来组织代码和复用代码。
类的定义
在Python中，类的基本语法如下：
class ClassName:
# class attribute
class_variable = "class variable"
def __init__(self, arg1, arg2):
# instance variable
self.instance_variable = arg1 + arg2
# instance method
def instance_method(self):
print("I am an instance method")
# class method
@classmethod
def class_method(cls):
print("I am a class method")
# static method
@staticmethod
def static_method():
print("I am a static method")下面逐一介绍上面示例代码中的各个元素。
class ClassName：这是类定义的开始，以class关键字作为开头，ClassName是要定义的类的名称；最后面是冒号，冒号后面的内容需要缩进。
class_variable = “class variable”：这是类变量，它是一个在类中定义的全局变量，所有实例共享同一个变量。
def __init__(self, arg1, arg2)：这是类的构造函数，当一个类实例被创建时会自动调用。在这个例子中，构造函数接受两个参数：arg1和arg2。self是对当前实例的引用，调用时不需要写，由系统自动填入。构造函数可以不带参数，也可以带一个或多个参数。
self.instance_variable = arg1 + arg2：这是一个实例变量，每个实例都有自己独立的实例变量。在这个例子中，实例变量是arg1和arg2的和。
def instance_method(self)：这是一个实例方法，它需要一个实例作为其第一个参数（通常命名为self，也可以使用其他名称）。self是对当前实例的引用，调用时不需要写，由系统自动填入。
@classmethod：这是一个类方法装饰器，标识后面是一个类方法。它不需要实例作为其第一个参数，而是使用类名本身作为第一个参数（通常命名为cls，也可以使用其他名称）。cls是对当前类的引用，调用时不需要写，由系统自动填入。
@staticmethod：这是一个静态方法装饰器，标识后面是一个静态方法。它不需要实例或类作为其参数。
类的使用
定义好类之后，我们就可以实例化该类的对象，并调用其属性和方法了。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def show_info(self):
print(f'name is {self.name}, {self.age} years old')
@staticmethod
def show_skill():
print('walk, run, swim')
# 创建一个Person类的实例
person1 = Person('xiaoxiao', 20)
# 访问实例变量，输出：xiaoxiao 20
print(person1.name, person1.age)
# 访问实例方法，输出：name is xiaoxiao, 20 years old
person1.show_info()
# 访问静态方法，输出：walk, run, swim
person1.show_skill()
Person.show_skill()可以看到，访问实例变量和实例方法时，必须使用实例对象。访问静态方法时，既可以使用实例对象，也可以使用类名。
类的__init__方法是类的构造函数，当一个类实例被创建时会自动调用。同样的，类的__del__方法是类的析构函数，在释放实例对象时，也会被自动调用。
class Animal:
def __init__(self, name):
self.name = name
print(f'animal {name} constructed')
def __del__(self):
print(f'animal {self.name} destructed')
def show(self):
print(f'{self.name} is preset')
def test():
animal = Animal('seagull')
animal.show()
''' test作用域结束时，animal会销毁，故依次输出：
animal seagull constructed
seagull is preset
animal seagull destructed
'''
test()类变量和实例变量
类变量是在类的所有实例中共享的变量，这就意味着，如果你改变了一个类变量的值，那么这个改变将影响到类的所有实例。类变量在类定义时声明，通常在类的方法中使用。
class MyClass:
# 类变量
class_variable = 0
def __init__(self, instance_variable):
self.instance_variable = instance_variable
MyClass.class_variable = self.instance_variable + 100
instance1 = MyClass(66)
# 输出：166
print(MyClass.class_variable)
instance2 = MyClass(88)
# 均输出：188
print(MyClass.class_variable)
print(instance1.class_variable)
print(instance2.class_variable)在上面的示例代码中，class_variable是一个类变量，它被所有实例共享。每次创建一个新的实例时，都会改变class_variable的值。因此，当创建了instance2并给它一个值为88的参数时，class_variable的值就从166变成了188。
实例变量是在类的每个实例中单独存储的变量，这就意味着，如果你改变了一个实例的状态，那么这个改变只影响那个特定的实例。实例变量在类的__init__方法中声明，通常在实例的方法中使用。
class MyClass:
def __init__(self, instance_variable):
# 实例变量
self.instance_variable = instance_variable
instance1 = MyClass(66)
# 输出：66
print(instance1.instance_variable)
# 创建实例2
instance2 = MyClass(88)
# 输出：88
print(instance2.instance_variable)
# 输出：66
print(instance1.instance_variable)
# 改变实例1的实例变量值
instance1.instance_variable = 100
# 输出：100
print(instance1.instance_variable)
# 输出：88
print(instance2.instance_variable)在上面的示例代码中，instance_variable是一个实例变量，每个实例都有它自己的副本。当你改变instance1的 instance_variable值时，instance2的值不会受到影响。
在Python中，两个下划线开头的属性被声明为私有属性，不能在类的外部被使用或直接访问。否则，运行时会报AttributeError的错误信息。
class MyNumber:
def __init__(self, value):
self.__value = value
num = MyNumber(66)
# 访问私有属性，运行时报错：'MyNumber' object has no attribute '__value'
print(num.__value)实例方法、类方法和静态方法
实例方法是定义在类中的普通函数，它需要一个实例作为第一个参数（通常命名为self）。实例方法只能通过类的实例来调用，可以访问类变量和实例变量。
类方法是定义在类中的普通函数，它需要一个类作为第一个参数（通常命名为cls）。类方法可以通过类和类的实例来调用，只能访问类变量，不能访问实例变量。在定义类方法时，可以使用@classmethod装饰器进行声明。
静态方法是定义在类中的普通函数，它不需要任何参数（包括 self）。静态方法可以通过类和类的实例来调用，不可以访问类变量和实例变量。在定义静态方法时，可以使用@staticmethod装饰器进行声明。
class Person:
# 类变量
skills: ['walk', 'run', 'swim']
def __init__(self, name, age):
# 示例变量
self.name = name
self.age = age
# 实例方法，可以访问类变量和实例变量
def show_info(self):
print(f'name is {self.name}, {self.age} years old')
print(self.skills)
# 类方法，可以访问类变量
@classmethod
def show_skill(cls):
print(cls.skills)
# 静态方法，不可以访问类变量和实例变量
@staticmethod
def show_basic():
print('a person here')在Python中，两个下划线开头的方法被声明为私有方法，不能在类的外部被使用或直接访问。否则，运行时会报AttributeError的错误信息。
class MyNumber:
def __init__(self, value):
self.__value = value
def __show(self):
print(self.__value)
num = MyNumber(66)
# 访问私有属性，运行时报错：'MyNumber' object has no attribute '__show'
num.__show()与C++、Java等语言不同，Python不支持函数重载。当类的定义中有多个同名的函数时，将以最后一个声明的函数为准。
class MyNumber:
def __init__(self, value):
self.__value = value
def show(self):
print(self.__value)
def show(self, a):
print(self.__value, a)
num = MyNumber(100)
num.show(66)
# 运行时报错：MyNumber.show() missing 1 required positional argument: 'a'
num.show()类的运算符重载
可以通过定义特定方法来重载类对象的运算符，以下是一些常见的运算符重载方法。
__add__(self, other)：重载加法运算符 +，用于实现两个对象的相加。
__sub__(self, other)：重载减法运算符 -，用于实现两个对象的相减。
__mul__(self, other)：重载乘法运算符 *，用于实现两个对象的相乘。
__truediv__(self, other)：重载除法运算符 /，用于实现两个对象的相除。
__floordiv__(self, other)：重载整数除法运算符 //，用于实现两个对象的整数相除。
__mod__(self, other)：重载取模运算符 %，用于实现两个对象的取模运算。
__pow__(self, other)：重载幂运算运算符 **，用于实现两个对象的幂运算。
__eq__(self, other)：重载相等运算符 ==，用于判断两个对象是否相等。
__ne__(self, other)：重载不等运算符 !=，用于判断两个对象是否不相等。
__lt__(self, other)：重载小于运算符 <，用于判断两个对象是否小于。
__le__(self, other)：重载小于等于运算符 <=，用于判断两个对象是否小于等于。
__gt__(self, other)：重载大于运算符 >，用于判断两个对象是否大于。
__ge__(self, other)：重载大于等于运算符 >=，用于判断两个对象是否大于等于。
假如我们定义了一个名为MyNumber的类，可以按照以下方式重载加法运算符。
class MyNumber:
def __init__(self, value):
self.value = value
def __add__(self, other):
if isinstance(other, MyNumber):
return MyNumber(self.value + other.value)
return MyNumber(self.value + other)
num1 = MyNumber(100)
num2 = MyNumber(200)
num = num1 + num2
# 输出：300
print(num.value)继承
继承是一种实现面向对象编程的重要机制，它允许我们基于已有的类创建新的类，从而继承已有类的属性和方法。在Python中，使用class语句定义一个类时，可以在类名后面使用(base_classes)的形式指定该类要继承的父类。base_classes可以为一个类，也可以为多个类。多个类时，各个类之间用逗号进行分隔，属于多重继承的内容。
class Animal:
def __init__(self, name):
self.name = name
def eat(self):
print(self.name + " is eating...")
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name)
self.breed = breed
dog = Dog('Sky', 'Corgi')
# 输出：Sky is eating...
dog.eat()
# 输出：Corgi
print(dog.breed)在上面的示例代码中，Dog类继承了Animal类，因此Dog类具有了Animal类的属性和方法。在Dog类的定义中，我们可以通过调用super().__init__(name)来调用父类的构造函数，从而初始化Dog类实例的name属性。
除了继承父类的属性和方法，子类还可以重写父类的方法，从而实现对父类行为的修改。
class Animal:
def __init__(self, name):
self.name = name
def eat(self):
print(self.name + " is eating...")
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name)
self.breed = breed
def eat(self):
print(self.breed + " eats more")
dog = Dog('Sky', 'Corgi')
# 覆盖父类方法，输出：Corgi eats more
dog.eat()
# 强制调用父类方法，输出：Sky is eating...
super(Dog, dog).eat()在上面的示例代码中，我们直接在Dog类中定义了一个与父类同名的eat方法，从而完全覆盖了父类的行为。如果想强制调用父类的方法，可以使用类似super(Dog, dog)的方式获得父类的实例，再调用父类的方法。
文章出处登录后可见！
