深入讲解 Python 中的类与对象

深入讲解 Python 中的类与对象

一、基本概念

1. 类（Class）
   类是对象的蓝图，定义了对象的属性和方法。
   语法：class ClassName:
   示例：

   class Dog:
       pass  # 最简单的空类
   

2. 对象（Object）
   对象是类的实例化产物，具有类定义的属性和行为。
   示例：

   my_dog = Dog()  # 创建 Dog 类的实例
   

---

二、类核心要素详解

1. 构造函数 __init__
   用于初始化对象属性，创建对象时自动调用。

   class Dog:
       def __init__(self, name, age):
           self.name = name  # 实例属性
           self.age = age
   
   my_dog = Dog("Buddy", 3)
   print(my_dog.name)  # 输出: Buddy
   

2. 实例方法
   定义在类中的函数，第一个参数必须是 self（指向实例自身）。

   class Dog:
       def bark(self):
           print(f"{self.name} says: Woof!")
   
   my_dog.bark()  # 输出: Buddy says: Woof!
   

3. 类属性与实例属性

   类型	定义位置	访问方式	特点
   类属性	类内部（方法外）	ClassName.attr	所有实例共享
   实例属性	__init__ 或方法中	self.attr	每个实例独立

   示例：

   class Dog:
       species = "Canis lupus"  # 类属性
       def __init__(self, name):
           self.name = name      # 实例属性
   
   print(Dog.species)  # 输出: Canis lupus
   

---

三、面向对象三大特性

1. 封装（Encapsulation）

   • 隐藏内部实现细节，通过方法暴露操作接口
   • 使用单下划线 _var 约定私有属性（Python 无严格私有机制）

   class BankAccount:
       def __init__(self):
           self._balance = 0  # "私有"属性
       
       def deposit(self, amount):
           self._balance += amount
       
       def get_balance(self):
           return self._balance
   

2. 继承（Inheritance）
   子类继承父类的属性和方法，支持多继承。

   class Animal:
       def __init__(self, name):
           self.name = name
       
       def speak(self):
           raise NotImplementedError("子类必须实现此方法")
   
   class Cat(Animal):
       def speak(self):
           return "Meow!"
   
   class Dog(Animal):
       def speak(self):
           return "Woof!"
   

3. 多态（Polymorphism）
   不同子类对同一方法的不同实现。

   animals = [Cat("Whiskers"), Dog("Buddy")]
   for animal in animals:
       print(animal.speak())
   # 输出:
   # Meow!
   # Woof!
   

---

四、高级特性

1. 类方法与静态方法

   类型	装饰器	第一个参数	典型用途
   实例方法	无	self	操作实例属性
   类方法	@classmethod	cls	操作类属性或创建工厂方法
   静态方法	@staticmethod	无	工具函数

   示例：

   class Pizza:
       def __init__(self, ingredients):
           self.ingredients = ingredients
       
       @classmethod
       def margherita(cls):
           return cls(["tomato", "mozzarella"])
       
       @staticmethod
       def validate_ingredients(ingredients):
           return "tomato" in ingredients
   

2. 特殊方法（Magic Methods）
   通过实现特殊方法自定义对象行为。

   class Vector:
       def __init__(self, x, y):
           self.x = x
           self.y = y
       
       def __add__(self, other):
           return Vector(self.x + other.x, self.y + other.y)
       
       def __str__(self):
           return f"Vector({self.x}, {self.y})"
   
   v1 = Vector(2, 3)
   v2 = Vector(1, 4)
   print(v1 + v2)  # 输出: Vector(3, 7)
   

3. 属性装饰器 @property
   控制属性的访问和修改。

   class Circle:
       def __init__(self, radius):
           self._radius = radius
       
       @property
       def radius(self):
           return self._radius
       
       @radius.setter
       def radius(self, value):
           if value <= 0:
               raise ValueError("半径必须为正数")
           self._radius = value
   

---

五、继承进阶

1. 方法重写（Override）

   class Parent:
       def show(self):
           print("Parent method")
   
   class Child(Parent):
       def show(self):
           super().show()  # 调用父类方法
           print("Child method")
   

2. 多继承与 MRO
   Python 使用 C3 算法确定方法解析顺序。

   class A:
       def do(self):
           print("A")
   
   class B(A):
       def do(self):
           print("B")
   
   class C(A):
       def do(self):
           print("C")
   
   class D(B, C):
       pass
   
   d = D()
   d.do()  # 输出: B
   print(D.__mro__)  # 查看继承顺序
   

---

六、最佳实践

1. 组合优于继承
   优先使用对象组合而非类继承来实现代码复用。

   class Engine:
       def start(self):
           print("Engine started")
   
   class Car:
       def __init__(self):
           self.engine = Engine()
       
       def start(self):
           self.engine.start()
   

2. 遵循 SOLID 原则

   • 单一职责原则（SRP）
   • 开放封闭原则（OCP）
   • 里氏替换原则（LSP）
   • 接口隔离原则（ISP）
   • 依赖倒置原则（DIP）

---

七、常见问题与解决方案

1. 可变默认参数陷阱

   # 错误示例
   class Test:
       def __init__(self, items=[]):  # 所有实例共享同一个列表
           self.items = items
   
   # 正确写法
   class Test:
       def __init__(self, items=None):
           self.items = items if items is not None else []
   

2. 动态属性管理
   使用 __slots__ 优化内存占用：

   class Point:
       __slots__ = ('x', 'y')  # 限制允许的属性
       def __init__(self, x, y):
           self.x = x
           self.y = y
   

---

八、完整示例：游戏角色系统

class Character:
    MAX_HEALTH = 100

    def __init__(self, name, attack_power):
        self.name = name
        self.health = self.MAX_HEALTH
        self.attack_power = attack_power

    def attack(self, target):
        target.take_damage(self.attack_power)

    def take_damage(self, damage):
        self.health = max(0, self.health - damage)
        print(f"{self.name}受到 {damage} 点伤害，剩余生命值: {self.health}")

class Warrior(Character):
    def __init__(self, name):
        super().__init__(name, attack_power=15)
        self.shield = 10

    def take_damage(self, damage):
        actual_damage = max(0, damage - self.shield)
        super().take_damage(actual_damage)

class Mage(Character):
    def __init__(self, name):
        super().__init__(name, attack_power=20)
        self.mana = 100

    def cast_spell(self, target):
        if self.mana >= 30:
            target.take_damage(25)
            self.mana -= 30
        else:
            print("法力不足！")

# 使用示例
warrior = Warrior("Conan")
mage = Mage("Gandalf")

warrior.attack(mage)    # Gandalf受到 5 点伤害（15-10）
mage.cast_spell(warrior) # Conan受到 25 点伤害

---

总结

Python 的面向对象编程提供了强大的代码组织能力，通过合理使用类与对象可以实现：

1. 逻辑模块化
2. 代码复用
3. 复杂系统建模

关键要点：

• 明确区分类属性和实例属性
• 合理使用继承与组合
• 善用特殊方法实现 Pythonic 对象
• 遵循面向对象设计原则
• 注意 Python 特有的实现细节（如 self 参数、MRO 等）