在上一节，我们介绍了Python的函数，包括：函数的定义、函数的调用、参数的传递、lambda函数等内容。在本节中，我们将介绍Python的面向对象编程。面向对象编程（Object-Oriented Programming, 即OOP）是一种编程范型，它以对象为基础，将数据和操作封装在一个类（Class）中。在Python中，类是一种定义对象结构和行为的模板，而对象则是类的实例。类定义了一个新的类型，用于创建具有特定属性和方法的对象。类是面向对象编程的核心，它允许程序员使用对象来组织代码和复用代码。
类的定义在Python中，类的基本语法如下：
class ClassName: # 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") # method @classmethod def_method(cls): print("I am a 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 20print(person1.name, person1.age)# 访问实例方法，输出：name is xiaoxiao, 20 years oldperson1.show_info()# 访问静态方法，输出：walk, run, swimperson1.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 constructedseagull is presetanimal 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)# 输出：166print(MyClass.class_variable) instance2 = MyClass(88)# 均输出：188print(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)# 输出：66print(instance1.instance_variable) # 创建实例2instance2 = MyClass(88)# 输出：88print(instance2.instance_variable)# 输出：66print(instance1.instance_variable)# 改变实例1的实例变量值instance1.instance_variable = 100# 输出：100print(instance1.instance_variable)# 输出：88print(instance2.instance_variable)
在上面的示例代码中，instance_variable是一个实例变量，每个实例都有它自己的副本。当你改变instance1的 instance_variable值时，instance2的值不会受到影响。
在Python中，两个下划线开头的属性被声明为私有属性，不能在类的外部被使用或直接访问。否则，运行时会报AttributeError的错误信息。
class MyNumber: def __init__(self, value): self.__value = valuenum = 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# 输出：300print(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 = breeddog = Dog('Sky', 'Corgi')# 输出：Sky is eating...dog.eat()# 输出：Corgiprint(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 moredog.eat()# 强制调用父类方法，输出：Sky is eating...super(Dog, dog).eat()
在上面的示例代码中，我们直接在Dog类中定义了一个与父类同名的eat方法，从而完全覆盖了父类的行为。如果想强制调用父类的方法，可以使用类似super(Dog, dog)的方式获得父类的实例，再调用父类的方法。
