面向对象编程（OOP）是一种编程范式，它使用 "对象" 来设计程序。Python 支持面向对象的编程技术，允许你定义类，从而创建具有属性（变量）和方法（函数）的对象。

基础

定义类

在 Python 中，使用 class 关键字来定义一个类。

class Dog:
    """一种简单的狗类"""
    species = "Canis familiaris"  # 类变量

    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age

    def description(self):
        return f"{self.name} is {self.age} years old"

    def speak(self, sound):
        return f"{self.name} says {sound}"

创建实例

创建类的实例很简单，只需要像调用函数一样调用类本身，并传入初始化方法 __init__ 所需的参数。

my_dog = Dog("Buddy", 3)

访问属性和方法

可以使用点号（.）来访问对象的属性和方法。

print(my_dog.name)  # 输出: Buddy
print(my_dog.age)  # 输出: 3
print(my_dog.description())  # 输出: Buddy is 3 years old
print(my_dog.speak("Woof"))  # 输出: Buddy says Woof

类的方法

实例方法

实例方法是类中最常见的方法类型，它们操作对象实例的属性（也称为实例变量）。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def introduce(self):
        print(f"My name is {self.name} and I am {self.age} years old.")

在此示例中，introduce 是一个实例方法，它使用 self 参数来访问和操作实例的属性。

person = Person("Alice", 30)
person.introduce()

类方法

类方法是操作类变量的方法。与实例方法不同，类方法作用于整个类，而不是类的实例。

class Employee:
    num_employees = 0  # 类变量
    
    @classmethod
    def add_employee(cls):
        cls.num_employees += 1

使用 @classmethod 装饰器定义类方法，cls 参数代表类本身，@classmethod也可以不写，下面的写法也等效：

class Employee:
    num_employees = 0  # 类变量
    
    def add_employee(self):
        self.num_employees += 1

Employee.add_employee()
print(Employee.num_employees)

静态方法

静态方法不需要类或实例的上下文。它们可以看作是与类逻辑相关联的普通函数。

class Calculator:
    @staticmethod
    def add(a, b):
        return a + b

使用 @staticmethod 装饰器定义静态方法。

result = Calculator.add(5, 3)
print(result)

特殊方法

Python 类可以定义特殊方法（也称为魔术方法），这些方法有特殊的名称，以双下划线（__）开头和结尾。

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
    
    def __str__(self):
        return f"'{self.title}' by {self.author}"

__str__ 方法定义了对象的字符串表示。

book = Book("1984", "George Orwell")
print(book)  # 自动调用 __str__ 方法

继承

继承是面向对象编程（OOP）的一个核心概念，允许我们定义一个类（子类）来继承另一个类（父类）的属性和方法。这种机制有助于代码的重用，减少重复性，并促进代码的模块化。

基础概念

父类（也称为基类或超类）是被继承的类。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

在这里，Animal 类定义了一个构造方法和一个 speak 方法。speak 方法是一个所谓的抽象方法，目的是在子类中被重写。

子类（也称为派生类）继承自父类。

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

Dog 和 Cat 类继承自 Animal 类，并重写了 speak 方法。

使用继承

dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())  # 输出: Buddy says Woof!
print(cat.speak())  # 输出: Whiskers says Meow!

子类可以使用 super() 函数调用父类的方法。

class Bird(Animal):
    def __init__(self, name, can_fly):
        super().__init__(name)  # 调用父类的构造方法
        self.can_fly = can_fly

    def speak(self):
        return super().speak()  # 调用父类的方法（这里会引发 NotImplementedError）

多重继承

Python 也支持多重继承，允许一个子类同时继承多个父类。

class A:
    def method(self):
        print("A method")
        
class B:
    def method(self):
        print("B method")

class C(A, B):
    pass

c = C()
c.method()  # 输出: A method

在多重继承中，如果存在方法重名，则优先级按照声明父类的顺序决定（即第一个父类的方法会被调用）。

覆盖方法

子类可以覆盖其父类的方法，以提供特定于子类的行为。

class SomeBreed(Dog):
    def speak(self, sound="Arf"):
        return super().speak(sound)  # 使用 super() 调用父类的方法

多态

Python 自然支持多态。这意味着不同类的对象可以以相同的方式使用，即使它们可能执行不同的操作。

特殊方法

Python 类可以定义特殊方法（如 __init__），这些方法由特殊的双下划线命名。例如，__str__ 方法用于定义对象的字符串表示。

class Dog:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"A dog named {self.name}"