Day 11 · 类、继承、魔术方法

Week 2 · Day 11 / 56 · 预计 2 小时 · 返回大纲

一、为什么需要类

函数是对动作的抽象,类是对数据和行为的封装。当你需要"把相关的数据和操作这些数据的函数绑在一起"时,就需要类。

JavaScript
// ES6 class
class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }

  greet() {
    return `Hello, I'm ${this.name}`;
  }
}

const alice = new User('Alice', 'alice@example.com');
console.log(alice.greet());
Python
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def greet(self):
        return f"Hello, I'm {self.name}"

alice = User('Alice', 'alice@example.com')
print(alice.greet())

二、定义类

2.1 基本结构

class Dog:
    # 类变量(所有实例共享)
    species = 'Canis lupus familiaris'

    # 初始化方法(构造函数)
    def __init__(self, name, age):
        # 实例变量(每个实例独有)
        self.name = name
        self.age = age

    # 实例方法
    def bark(self):
        return f"{self.name}: Woof!"

    # 魔术方法:打印时显示
    def __str__(self):
        return f"{self.name} ({self.age}岁)"

# 创建实例
my_dog = Dog('旺财', 3)
print(my_dog.bark())      # 旺财: Woof!
print(my_dog)             # 旺财 (3岁)
print(my_dog.species)     # Canis lupus familiaris

2.2 self 是什么

self 是 Python 的惯例,代表实例本身。调用 my_dog.bark() 时,Python 自动翻译成 Dog.bark(my_dog)。

JavaScript
class Dog {
  constructor(name) {
    this.name = name;  // this = 实例
  }
  bark() {
    return `${this.name}: Woof!`;
  }
}

const dog = new Dog('旺财');
dog.bark();  // this 自动绑定
Python
class Dog:
    def __init__(self, name):
        self.name = name  # self = 实例
    def bark(self):
        return f"{self.name}: Woof!"

dog = Dog('旺财')
dog.bark()  # 自动翻译成 Dog.bark(dog)
注意:Python 必须显式写 self,JS 的 this 是隐式的。这是 Python 和 JS 类的最大区别。

2.3 类变量 vs 实例变量

类变量实例变量
定义位置类内部,方法外部__init__ 里
共享性所有实例共享每个实例独有
修改影响影响所有实例只影响当前实例
例子speciesname, age
class Dog:
    species = 'Canis lupus familiaris'  # 类变量

dog1 = Dog('旺财', 3)
dog2 = Dog('来福', 5)

print(dog1.species)  # Canis lupus familiaris
print(dog2.species)  # Canis lupus familiaris

# 修改类变量
Dog.species = 'Dog'
print(dog1.species)  # Dog
print(dog2.species)  # Dog

三、继承

3.1 基本继承

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

    def speak(self):
        raise NotImplementedError("子类必须实现这个方法")

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

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

dog = Dog('旺财')
cat = Cat('咪咪')
print(dog.speak())  # 旺财: Woof!
print(cat.speak())  # 咪咪: Meow!

3.2 super() 调用父类

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

    def info(self):
        return f"{self.name} ({self.species})"

class Dog(Animal):
    def __init__(self, name, breed):
        # 调用父类构造函数
        super().__init__(name, species='Dog')
        self.breed = breed  # 子类自己的属性

    def info(self):
        # 调用父类方法
        base_info = super().info()
        return f"{base_info}, 品种: {self.breed}"

dog = Dog('旺财', '金毛')
print(dog.info())  # 旺财 (Dog), 品种: 金毛

3.4 多重继承和 MRO

Python 支持多重继承,但要小心方法解析顺序(MRO)。

class A:
    def hello(self):
        print('A')

class B(A):
    def hello(self):
        print('B')
        super().hello()

class C(A):
    def hello(self):
        print('C')
        super().hello()

class D(B, C):
    def hello(self):
        print('D')
        super().hello()

d = D()
d.hello()
# 输出:
# D
# B
# C
# A

# 查看 MRO
print(D.__mro__)
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)
💡 C3 线性化:Python 的 MRO 采用 C3 算法,保证类的顺序是:自己 → 父类从左到右 → 最终父类。

四、魔术方法(Magic Methods)

魔术方法是以双下划线开头和结尾的特殊方法,让你的类支持 Python 的内置操作。

4.1 常用魔术方法

魔术方法触发时机例子
__init__创建实例时MyClass()
__str__print() 时print(obj)
__repr__交互式输出时>>> obj
__len__len() 时len(obj)
__getitem__索引访问时obj[0]
__call__实例当函数调用时obj()
__add__+ 运算时obj1 + obj2

4.2 实战:向量类

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __len__(self):
        # 返回向量长度
        return int((self.x**2 + self.y**2)**0.5)

    def __getitem__(self, index):
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        raise IndexError("向量只有两个维度")

v1 = Vector(3, 4)
v2 = Vector(1, 2)

print(v1)           # Vector(3, 4)
print(v1 + v2)      # Vector(4, 6)
print(len(v1))      # 5
print(v1[0])        # 3
print(v1[1])        # 4

五、Property 属性

@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

    @property
    def area(self):
        return 3.14159 * self._radius ** 2

c = Circle(5)
print(c.radius)   # 5(像属性一样访问)
print(c.area)     # 78.53975(计算属性)

c.radius = 10     # 触发 setter
print(c.area)     # 314.159

c.radius = -1     # 抛出 ValueError

六、抽象基类(ABC)

抽象基类定义接口,子类必须实现特定方法。

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)

# Shape 不能实例化
# Shape()  #  TypeError

# 子类必须实现所有抽象方法
class Circle(Shape):
    def area(self):
        return 3.14 * self.radius ** 2
    # 忘记实现 perimeter()

# Circle()  # TypeError: Can't instantiate abstract class

七、类方法和静态方法

class User:
    # 类变量
    user_count = 0

    def __init__(self, name):
        self.name = name
        User.user_count += 1

    # 实例方法:第一个参数是 self
    def greet(self):
        return f"Hi, I'm {self.name}"

    # 类方法:第一个参数是 cls
    @classmethod
    def from_string(cls, user_str):
        name = user_str.split(',')[0]
        return cls(name)

    # 静态方法:没有强制的第一个参数
    @staticmethod
    def is_valid_name(name):
        return len(name) > 0

# 使用
u1 = User('Alice')
u2 = User.from_string('Bob, bob@example.com')

print(u1.greet())              # Hi, I'm Alice
print(u2.name)                 # Bob
print(User.user_count)         # 2
print(User.is_valid_name(''))  # False

八、练习

练习 1:图书类

写一个 Book 类,有 title、author、pages 属性,能显示信息。

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    def __str__(self):
        return f"《{self.title}》- {self.author} ({self.pages}页)"

    def __len__(self):
        return self.pages

book = Book('Python编程', 'Guido', 500)
print(book)          # 《Python编程》- Guido (500页)
print(len(book))     # 500

练习 2:学生继承

写一个 Student 类继承 Person,加 grade 属性。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"我叫 {self.name},今年 {self.age} 岁"

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

    def introduce(self):
        base = super().introduce()
        return f"{base},读 {self.grade} 年级"

stu = Student('小明', 12, 6)
print(stu.introduce())  # 我叫 小明,今年 12 岁,读 6 年级

练习 3:栈类

实现一个栈(Stack),支持 push、pop、peek。

class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if not self.items:
            raise IndexError("栈为空")
        return self.items.pop()

    def peek(self):
        if not self.items:
            raise IndexError("栈为空")
        return self.items[-1]

    def __len__(self):
        return len(self.items)

    def __str__(self):
        return f"Stack({self.items})"

s = Stack()
s.push(1)
s.push(2)
s.push(3)
print(s)           # Stack([1, 2, 3])
print(s.peek())    # 3
print(s.pop())     # 3
print(len(s))      # 2

练习 4:计数器类

实现一个 Counter 类,每次调用实例就加 1。

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

    def __str__(self):
        return f"Counter: {self.count}"

c = Counter()
print(c())   # 1
print(c())   # 2
print(c())   # 3
print(c)     # Counter: 3

九、打卡验收

理解了类和实例的关系,知道 self 是什么
能区分类变量和实例变量
会写继承,能用 super() 调用父类方法
理解了魔术方法,知道 __init__、__str__、__len__ 的作用
会写 @classmethod 和 @staticmethod
能实现支持 +、len()、索引访问的类
理解了多重继承的 MRO(方法解析顺序)
完成了至少 2 个练习,代码能跑通
打卡方式: 全部勾选后,告诉我 "Day 11 打卡",并贴出你的代码,我帮你检查。
明天预告(Day 12): 类型注解——Python 3.5+ 的类型提示,让代码更健壮、IDE 更智能。