Python 中的 `class`（类）是面向对象编程的核心概念，用于创建具有特定属性和行为的对象蓝图。类的使用可以提高代码的复用性、组织性和可维护性。以下将从类的定义、构造函数、属性和方法、继承、多态等核心方面进行详细介绍，并结合代码示例说明 [ref_1][ref_2][ref_4]。 ### 1. 类的定义与基本结构 类通过 `class` 关键字定义，其后跟类名（通常采用大驼峰命名法）和冒号。类体中可以定义属性和方法。 ```python # 定义一个简单的 Person 类 class Person: # 类属性（所有实例共享） species = 'human' # 实例方法（第一个参数为 self，代表实例本身） def introduce(self): return f"Hello, I am a {self.species}." # 创建类的实例（对象） p1 = Person() print(p1.introduce()) # 输出：Hello, I am a human. ``` ### 2. 构造函数 `__init__` 与实例属性 `__init__` 方法是类的构造函数，在创建新实例时自动调用，用于初始化实例的属性（即实例属性）[ref_1][ref_4]。`self` 参数指向实例本身。 ```python class Person: def __init__(self, name, age): # 初始化实例属性 self.name = name # 实例属性 self.age = age def introduce(self): return f"My name is {self.name}, I'm {self.age} years old." # 创建实例并传入初始化参数 p1 = Person("Alice", 25) print(p1.introduce()) # 输出：My name is Alice, I'm 25 years old. ``` ### 3. 类属性、实例属性与方法 | 类型 | 定义位置 | 访问方式 | 描述 | | :--- | :--- | :--- | :--- | | **类属性** | 类体中，所有方法外 | `类名.属性` 或 `实例.属性` | 所有实例共享，通常用于定义常量或共享状态 [ref_1]。 | | **实例属性** | 通常在 `__init__` 方法中定义 | `实例.属性` | 每个实例独有的数据。 | | **实例方法** | 类体中，第一个参数为 `self` | `实例.方法()` | 操作实例属性和类属性。 | | **类方法** | 使用 `@classmethod` 装饰器，第一个参数为 `cls` | `类名.方法()` 或 `实例.方法()` | 操作类属性，不能访问实例属性 [ref_4]。 | | **静态方法** | 使用 `@staticmethod` 装饰器，无 `self` 或 `cls` 参数 | `类名.方法()` 或 `实例.方法()` | 与类和实例状态无关的工具函数 [ref_4]。 | ```python class Calculator: # 类属性 manufacturer = "TechCorp" def __init__(self, model): self.model = model # 实例属性 # 实例方法 def add(self, a, b): return a + b # 类方法 @classmethod def get_manufacturer(cls): return cls.manufacturer # 静态方法 @staticmethod def multiply(a, b): return a * b # 使用 calc = Calculator("Calc-2000") print(calc.add(5, 3)) # 实例方法：输出 8 print(Calculator.get_manufacturer()) # 类方法：输出 "TechCorp" print(Calculator.multiply(5, 3)) # 静态方法：输出 15 ``` ### 4. 封装与访问控制 封装是指隐藏对象的内部实现细节，仅对外暴露公共接口。Python 通过名称改写实现“私有”属性/方法，在属性名或方法名前加双下划线 `__` 即可 [ref_4][ref_6]。 ```python class BankAccount: def __init__(self, owner, balance): self.owner = owner # 公有属性 self.__balance = balance # 私有属性（实际被重命名为 _BankAccount__balance） # 公有方法作为访问接口 def deposit(self, amount): if amount > 0: self.__balance += amount return True return False def get_balance(self): return self.__balance # 通过公有方法访问私有属性 # 使用 account = BankAccount("Bob", 1000) account.deposit(500) print(account.get_balance()) # 输出：1500 # print(account.__balance) # 报错：AttributeError，无法直接访问私有属性 # print(account._BankAccount__balance) # 可以访问，但不推荐 ``` ### 5. 继承 继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码复用和功能扩展 [ref_1][ref_2][ref_3]。 #### 5.1 单继承 ```python # 父类 class Animal: def __init__(self, name): self.name = name def speak(self): return f"{self.name} makes a sound." # 子类 class Dog(Animal): # Dog 类继承自 Animal 类 def __init__(self, name, breed): # 调用父类的 __init__ 方法初始化继承的属性 super().__init__(name) self.breed = breed # 方法重写（Override）：覆盖父类的 speak 方法 def speak(self): return f"{self.name} (a {self.breed} dog) says: Woof!" # 使用 dog = Dog("Buddy", "Golden Retriever") print(dog.speak()) # 输出：Buddy (a Golden Retriever dog) says: Woof! ``` #### 5.2 多重继承 Python 支持一个子类继承多个父类 [ref_2][ref_3]。当多个父类有同名方法或属性时，Python 会按照 **方法解析顺序** 进行查找，可以通过 `类名.__mro__` 属性查看。 ```python class Flyable: def fly(self): return "I can fly!" class Swimmable: def swim(self): return "I can swim!" class Duck(Flyable, Swimmable): # 多重继承 def speak(self): return "Quack!" duck = Duck() print(duck.fly()) # 输出：I can fly! print(duck.swim()) # 输出：I can swim! print(duck.speak()) # 输出：Quack! print(Duck.__mro__) # 查看方法解析顺序 ``` ### 6. 多态 多态是指同一个接口（如方法名）在不同的对象（类）中具有不同的行为。Python 的多态是“鸭子类型”的体现，只要对象具有相应的方法，就可以被调用，而不强制要求继承关系 [ref_2][ref_5][ref_6]。 ```python # 定义具有相同接口的不同类 class Cat: def speak(self): return "Meow!" class Car: def speak(self): # 即使Car不是动物，只要有speak方法，就可被多态调用 return "Vroom!" # 多态函数 def make_it_talk(entity): return entity.speak() # 使用 animals = [Cat(), Car()] for obj in animals: print(make_it_talk(obj)) # 输出： # Meow! # Vroom! ``` ### 7. 特殊方法（魔术方法） 特殊方法以双下划线开头和结尾，用于实现类的特定行为，如运算符重载、对象字符串表示等 [ref_1]。 ```python class Vector2D: def __init__(self, x, y): self.x = x self.y = y # 重载加法运算符 def __add__(self, other): return Vector2D(self.x + other.x, self.y + other.y) # 定义对象的字符串表示 def __str__(self): return f"Vector2D({self.x}, {self.y})" # 定义对象的“官方”字符串表示（用于调试） def __repr__(self): return f"Vector2D({self.x}, {self.y})" # 使用 v1 = Vector2D(1, 2) v2 = Vector2D(3, 4) v3 = v1 + v2 # 调用 __add__ print(v3) # 调用 __str__，输出：Vector2D(4, 6) ``` ### 8. 抽象基类与抽象方法 抽象基类定义了接口规范，不能实例化，其抽象方法必须由子类实现。这体现了面向对象编程中的“数据抽象”思想 [ref_5]。 ```python from abc import ABC, abstractmethod # 抽象基类 class Shape(ABC): @abstractmethod def area(self): pass # 子类必须实现此方法 @abstractmethod def perimeter(self): pass # 具体子类 class Rectangle(Shape): def __init__(self, width, height): self.width = width self.height = height def area(self): return self.width * self.height def perimeter(self): return 2 * (self.width + self.height) # 使用 rect = Rectangle(5, 3) print(f"Area: {rect.area()}") # 输出：Area: 15 print(f"Perimeter: {rect.perimeter()}") # 输出：Perimeter: 16 # shape = Shape() # 报错：无法实例化抽象类 ``` ### 9. 类与实例的内置属性和方法 Python 类本身也是对象，具有一些内置属性和方法 [ref_1]。 * `__dict__`：存储对象（类或实例）属性的字典。 * `__class__`：获取对象的类。 * `isinstance(obj, Class)`：检查对象是否为某类或其子类的实例。 * `issubclass(SubClass, BaseClass)`：检查一个类是否为另一个类的子类。 ```python class MyClass: pass obj = MyClass() print(obj.__class__) # 输出：<class '__main__.MyClass'> print(MyClass.__dict__.keys()) # 查看类的属性 print(isinstance(obj, MyClass)) # 输出：True ``` 综上，Python 的 `class` 机制完整支持了面向对象编程的三大特性：**封装**（通过私有属性和公共方法）、**继承**（单继承、多重继承）和**多态**（通过方法重写和鸭子类型）。同时，特殊方法和抽象基类等特性进一步增强了其表达能力和设计模式的实现能力 [ref_1][ref_5][ref_6]。理解并熟练运用这些概念，是编写高质量、可维护 Python 代码的关键。