Python 方法类对象|全面解析

Python 方法类对象核心体系深度解析

一、Python 方法类对象体系概览

Python 是一门以对象为核心的编程语言,其一切皆对象的设计哲学贯穿始终。从内置类型(如 int、str、list)到自定义类,对象是数据与行为的统一体。而方法(method)作为绑定到对象上的函数,是对象行为的具体体现;类(class)则是对象的蓝图与模板,定义了对象应具备的属性与方法;对象(object)则是类的实例,是程序运行时实际操作的数据载体。

理解方法、类、对象三者的关系是掌握 Python 面向对象编程(OOP)的关键。三者形成层级结构:类定义方法 → 对象由类实例化 → 对象调用方法完成操作。这一结构支撑起模块化、可复用、易维护的代码架构。

在实际开发中,合理设计类与方法能显著提升系统扩展性。例如,Django ORM 将数据库表抽象为类,每条记录为对象;Flask 将请求封装为 Request 对象;NumPy 中 ndarray 对象承载科学计算核心数据结构。这些都依赖于对方法、类、对象机制的深度理解与灵活运用。

二、方法的类型与本质

Python 中方法分为三类:实例方法(instance method)、类方法(class method)和静态方法(static method)。它们在绑定方式、参数签名、调用方式及适用场景上存在本质差异。

1. 实例方法:对象行为的直接体现

实例方法第一个参数必须是 self(约定俗成,非关键字),代表调用该方法的实例本身。它可访问实例属性及类属性,是使用最广泛的方法类型。

示例:实例方法访问实例与类属性
class Counter:
    total_created = 0  # 类属性,所有实例共享
    def __init__(self):
        self.count = 0   # 实例属性,每个对象独立
        Counter.total_created += 1
    def increment(self):  # 实例方法
        self.count += 1
        return self.count
    def get_total(self):
        return Counter.total_created

调用方式:counter = Counter(); counter.increment()。实例方法通过 self 隐式传入当前对象,实现对实例状态的操作。

2. 类方法:操作类级别状态

类方法使用 @classmethod 装饰器定义,第一个参数为 cls(代表类本身,非实例)。常用于工厂方法、类级配置管理等。

示例:使用类方法实现替代构造器
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    @classmethod
    def from_string(cls, s):
        name, age = s.split(',')
        return cls(name, int(age))
p = Person.from_string("Alice,30")

类方法允许通过类直接调用:Person.from_string("Bob,25"),无需实例化。它比静态方法更灵活,因 cls 可正确处理继承(如子类调用时 cls 为子类)。

3. 静态方法:与类逻辑相关但无状态依赖

静态方法使用 @staticmethod 装饰器定义,无 self 或 cls 参数。它与类无直接状态交互,仅在命名空间上属于类,常用于工具函数。

示例:静态方法实现单位转换工具
class UnitConverter:
    @staticmethod
    def celsius_to_fahrenheit(c):
        return c * 9/5 + 32
    @staticmethod
    def fahrenheit_to_celsius(f):
        return (f - 32) * 5/9

调用方式:UnitConverter.celsius_to_fahrenheit(25)。静态方法不依赖实例或类状态,更接近模块级函数,但归于类命名空间便于组织。

4. 方法绑定与查找机制

Python 中方法是描述符(descriptor)实现的。当访问 obj.method 时,解释器执行:

  1. 在实例 obj 的 __dict__ 中查找 method(通常无);
  2. 在类 obj.__class__ 的 __dict__ 中查找 method;
  3. 若找到的是函数对象,则将其包装为绑定方法(bound method)——将实例作为第一个参数传入;
  4. 若找到的是描述符对象(如 @classmethod 或 @staticmethod 包装后),则调用其 __get__ 方法返回实际可调用对象。

这一机制解释了为何实例方法需 self:它是绑定过程自动注入的;而静态方法无绑定,故无 self。

5. 方法重写与多态

子类可重写父类方法,实现多态。调用时根据对象实际类型动态绑定方法:

示例:多态实现形状面积计算
class Shape:
    def area(self):
        raise NotImplementedError
class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return 3.14 * self.r ** 2
class Square(Shape):
    def __init__(self, s):
        self.s = s
    def area(self):
        return self.s ** 2
shapes = [Circle(3), Square(4)]
for s in shapes:
    print(s.__class__.__name__, "area:", s.area())

输出:Circle area: 28.26,Square area: 16。同一接口 area(),不同行为,即多态。

三、类的定义与高级特性

1. 类的基本结构

类定义使用 class 关键字,包含类体(属性、方法、装饰器)。类体在定义时立即执行:

示例:类定义执行流程
print("开始定义类")
class MyClass:
    print("进入类体")
    class_var = "类属性"
    def method(self):
        print("实例方法")
print("类定义完成")

输出顺序:开始定义类 → 进入类体 → 类定义完成。类体代码在定义时执行一次,而非每次实例化。

2. 元类与类创建机制

类本身是对象,由元类(metaclass)创建。默认元类为 type。可自定义元类控制类创建过程:

示例:自定义元类强制属性命名规范
class NameMeta(type):
    def __new__(cls, name, bases, namespace):
        for key in namespace:
            if key.startswith('__'):
                continue
            if not key.islower():
                raise ValueError(f"属性 {key} 必须小写")
        return super().__new__(cls, name, bases, namespace)
class ValidClass(metaclass=NameMeta):
    good_var = 1
    # BAD_VAR = 2  # 抛出异常

元类适用于框架开发(如 Django ORM 的模型元类),但普通应用慎用,增加复杂度。

3. 类装饰器与动态修改

类装饰器是接收类并返回类的函数,常用于添加功能、注册、验证等:

示例:类装饰器实现单例模式
def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance
@singleton
class Config:
    def __init__(self):
        self.settings = {}
config1 = Config()
config2 = Config()
print(config1 is config2)  # True

类装饰器比继承更轻量,避免类爆炸问题。

4. 抽象基类(ABC)与接口设计

使用 abc 模块定义抽象基类,强制子类实现指定方法:

示例:定义动物接口
from abc import ABC, abstractmethod
class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass
# Animal()  # TypeError: Can't instantiate abstract class Animal
class Dog(Animal):
    def speak(self):
        return "Woof!"
d = Dog()
print(d.speak())

抽象基类支持 isinstance 检查,并可注册非子类实现接口:

示例:注册字符串为 Animal 实现
Animal.register(str)
print(isinstance("hello", Animal))  # True

但注册仅影响类型检查,不强制实现抽象方法,需结合 hasattr 或运行时检查。

四、对象的生命周期与特性

1. 实例化与 __init__ 与 __new__

实例化分两步:__new__ 创建实例(返回新对象),__init__ 初始化实例(无返回值)。通常重写 __init__,仅在需控制创建过程时重写 __new__:

示例:使用 __new__ 实现缓存实例
class CachedInt:
    _cache = {}
    def __new__(cls, value):
        if value in cls._cache:
            return cls._cache[value]
        obj = super().__new__(cls)
        obj.value = value
        cls._cache[value] = obj
        return obj
a = CachedInt(5)
b = CachedInt(5)
print(a is b)  # True

注意:__new__ 必须返回实例,否则 __init__ 不会被调用。

2. 属性访问控制

Python 通过 __getattr__、__getattribute__、__setattr__、__delattr__ 控制属性访问:

  • __getattribute__:无条件拦截所有属性访问(包括实例、类属性),慎用易死循环;
  • __getattr__:仅当常规查找失败时调用(如属性不存在);
  • __setattr__:拦截所有属性赋值。
示例:只读属性实现
class ReadOnly:
    def __init__(self, value):
        object.__setattr__(self, '_value', value)
    def __getattr__(self, name):
        if name == 'value':
            return object.__getattribute__(self, '_value')
        raise AttributeError(name)
    def __setattr__(self, name, value):
        raise AttributeError(f"属性 {name} 不可修改")
obj = ReadOnly(100)
print(obj.value)  # 100
# obj.value = 200  # AttributeError

注意:__init__ 中必须用 object.__setattr__ 绕过自定义逻辑。

3. 描述符:属性行为的统一抽象

描述符是实现 __get__、__set__、__delete__ 的类,用于复用属性逻辑:

示例:类型检查描述符
class TypedProperty:
    def __init__(self, name, expected_type):
        self.name = name
        self.expected_type = expected_type
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__[self.name]
    def __set__(self, instance, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"{self.name} 必须是 {self.expected_type}")
        instance.__dict__[self.name] = value
class Person:
    name = TypedProperty('name', str)
    age = TypedProperty('age', int)
p = Person()
p.name = "Alice"
p.age = 30
# p.age = "thirty"  # TypeError

描述符是 @property 的底层机制,也用于 Django ORM 的字段定义。

4. 上下文管理与 with 语句

实现 __enter__ 和 __exit__ 方法的对象可作为上下文管理器:

示例:文件操作上下文管理
class FileHandler:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()
with FileHandler('test.txt', 'w') as f:
    f.write("Hello, context!")

__exit__ 返回 True 可抑制异常,否则传播异常。

五、dunder 方法:自定义对象行为

dunder 方法(double underscore method,双下划线方法)是 Python 的特殊方法,用于自定义对象行为。常见 dunder 方法分类如下:

1. 对象表示与调试

  • __repr__(self):返回对象的“官方”字符串表示(用于调试),应尽可能返回可重建对象的表达式;
  • __str__(self):返回用户友好字符串(str() 调用),若未定义则回退到 __repr__;
  • __format__(self, format_spec):支持 format() 与 f-string 格式化。
示例:自定义 repr 与 str
class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"
    def __str__(self):
        return f"({self.x}, {self.y})"
v = Vector(3, 4)
print(v)          # (3, 4)
print(repr(v))    # Vector(3, 4)
print(f"{v!r}")   # Vector(3, 4)

2. 运算符重载

  • __add__、__sub__、__mul__、__truediv__ 等实现二元运算;
  • __radd__ 等实现反向运算(当左操作数不支持时);
  • __iadd__ 等实现原地运算(+=)。
示例:向量加法
class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)
    def __radd__(self, other):
        return self.__add__(other)
    def __iadd__(self, other):
        self.x += other.x
        self.y += other.y
        return self
v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2  # Vector(4, 6)
v1 += v2      # v1 变为 Vector(4, 6)

返回 NotImplemented 表示不支持,交由右操作数尝试 __radd__。

3. 容器模拟

  • __len__(self)、__getitem__(self, key)、__setitem__(self, key, value)、__delitem__(self, key);
  • __contains__(self, item):支持 in 操作;
  • __iter__(self)、__next__(self):实现迭代器协议。
示例:自定义序列类
class MyList:
    def __init__(self, items):
        self._items = list(items)
    def __len__(self):
        return len(self._items)
    def __getitem__(self, index):
        return self._items[index]
    def __setitem__(self, index, value):
        self._items[index] = value
    def __delitem__(self, index):
        del self._items[index]
    def __iter__(self):
        return iter(self._items)
    def __contains__(self, item):
        return item in self._items
ml = MyList([1, 2, 3])
print(len(ml))   # 3
print(ml[1])     # 2
ml[1] = 10
print(2 in ml)   # False

4. 上下文与资源管理

  • __enter__(self)、__exit__(self, exc_type, exc_val, exc_tb):实现上下文管理;
  • __await__(self):支持异步 await。

见前文 FileHandler 示例。

5. 对象生命周期控制

  • __new__(cls, *args, **kwargs):创建实例;
  • __init__(self, *args, **kwargs):初始化实例;
  • __del__(self):析构函数(不推荐依赖,GC 时间不确定)。
示例:使用 __del__ 记录销毁(仅用于调试)
class Resource:
    def __init__(self, name):
        self.name = name
        print(f"{name} 创建")
    def __del__(self):
        print(f"{name} 销毁")
r = Resource("DB连接")
del r  # 立即销毁
# 输出:DB连接 创建 → DB连接 销毁

注意:__del__ 在解释器退出时可能不被调用,且循环引用时可能失效。

6. 比较与哈希

  • __eq__、__ne__、__lt__、__le__、__gt__、__ge__;
  • __hash__(self):返回整数哈希值,定义 __eq__ 时应同时定义 __hash__ 或设为 None(不可哈希)。
示例:定义可哈希的点对象
from functools import total_ordering
@total_ordering
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)
    def __lt__(self, other):
        return (self.x, self.y) < (other.x, other.y)
    def __hash__(self):
        return hash((self.x, self.y))
p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 == p2)  # True
print(p1 < Point(2, 3))  # True
points = {p1, p2}  # 集合中仅存一个点

@total_ordering 装饰器可自动补全缺失的比较方法(需定义 __eq__ 和任一顺序方法)。

六、面向对象设计原则与实践

1. SOLID 原则在 Python 中的应用

  • Single Responsibility Principle(SRP):一个类只负责一个功能领域。例:ReportGenerator 仅生成报告,不处理数据持久化。
  • Open/Closed Principle(OCP):对扩展开放,对修改关闭。用继承/组合/装饰器扩展行为。
  • Liskov Substitution Principle(LSP):子类对象应能替换父类对象。避免重写方法改变父类契约。
  • Interface Segregation Principle(ISP):客户端不应依赖其不需要的接口。用小而专的抽象。
  • Dependency Inversion Principle(DIP):高层模块不依赖低层模块,二者依赖抽象。

2. 组合优于继承

继承易导致紧耦合与脆弱基类问题。组合通过将对象作为属性包含,实现更灵活的复用:

示例:组合实现邮件服务
class SMTPClient:
    def send(self, to, subject, body):
        print(f"发送邮件至 {to}: {subject}")
class EmailService:
    def __init__(self, smtp_client):
        self.smtp = smtp_client  # 组合
    def notify(self, user, message):
        self.smtp.send(user.email, "通知", message)
smtp = SMTPClient()
service = EmailService(smtp)
service.notify(user, "您的订单已发货")

可轻松替换 SMTP 客户端(如测试时用 Mock),符合依赖注入思想。

3. Mixin 模式:功能复用的轻量方案

Mixin 是仅提供方法而不定义状态的类,用于横向复用功能:

示例:JSON 序列化 Mixin
class JSONSerializableMixin:
    def to_json(self):
        import json
        return json.dumps(self.__dict__)
    @classmethod
    def from_json(cls, json_str):
        import json
        data = json.loads(json_str)
        return cls(**data)
class User(JSONSerializableMixin):
    def __init__(self, name, age):
        self.name = name
        self.age = age
u = User("Alice", 30)
print(u.to_json())  # {"name": "Alice", "age": 30}

Mixin 通常以 Mixin 结尾,不直接实例化,多继承顺序中位于基类前。

4. 设计模式在 Python 中的实现

  • 工厂模式:用类方法或工厂函数创建对象,解耦实例化逻辑;
  • 策略模式:将算法封装为可互换对象;
  • 装饰器模式:用类或函数包装对象增强功能;
  • 观察者模式:事件驱动系统,如 signal.signal。
示例:策略模式实现折扣计算
from abc import ABC, abstractmethod
class DiscountStrategy(ABC):
    @abstractmethod
    def apply(self, total):
        pass
class NoDiscount(DiscountStrategy):
    def apply(self, total):
        return total
class TenPercentDiscount(DiscountStrategy):
    def apply(self, total):
        return total * 0.9
class Checkout:
    def __init__(self, strategy):
        self.strategy = strategy
    def total(self, items):
        return self.strategy.apply(sum(items))
items = [100, 50, 25]
checkout = Checkout(TenPercentDiscount())
print(checkout.total(items))  # 157.5

七、常见陷阱与调试技巧

1. 可变默认参数陷阱

默认参数在函数定义时求值,若为可变对象(如 list、dict),会被所有调用共享:

错误示例
def add_item(item, items=[]):
    items.append(item)
    return items
a = add_item(1)
b = add_item(2)
print(a)  # [1, 2]!b 与 a 是同一列表

正确做法:使用 None 作为默认值:

正确示例
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

2. 类属性与实例属性混淆

类属性被所有实例共享,修改类属性可能影响所有实例:

示例:意外共享状态
class Counter:
    count = 0  # 类属性
    def __init__(self):
        self.count += 1  # 创建实例属性 count,不修改类属性!
c1 = Counter()
c2 = Counter()
print(Counter.count)  # 0!实例未改变类属性

正确方式:用 Counter.count += 1 修改类属性,或明确区分类/实例属性。

3. 多重继承与 MRO 问题

多重继承时,方法解析顺序(MRO)决定属性查找路径。Python 使用 C3 线性化算法:

示例:MRO 检查
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
print(D.__mro__)
# (, , , , )

确保所有父类继承自 object(Python3 默认),避免 MRO 冲突。使用 super() 而非直接调用父类方法,确保协作式继承:

协作式 super 示例
class Base:
    def __init__(self):
        print("Base init")
class A(Base):
    def __init__(self):
        super().__init__()
        print("A init")
class B(Base):
    def __init__(self):
        super().__init__()
        print("B init")
class C(A, B):
    def __init__(self):
        super().__init__()
        print("C init")
c = C()
# 输出顺序:Base → B → A → C

4. 属性访问死循环

重写 __getattribute__ 时若访问 self.attr,会再次触发 __getattribute__,导致死循环:

错误示例
class MyClass:
    def __getattribute__(self, name):
        if name == 'x':
            return self.x  # 死循环!

正确做法:使用 object.__getattribute__:

正确示例
class MyClass:
    def __getattribute__(self, name):
        if name == 'x':
            return object.__getattribute__(self, 'x')
        return super().__getattribute__(name)

5. 上下文管理异常处理

__exit__ 返回 True 会抑制异常,但可能隐藏错误:

示例:谨慎抑制异常
class SilentFile:
    def __init__(self, filename):
        self.filename = filename
    def __enter__(self):
        self.f = open(self.filename, 'w')
        return self.f
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()
        return True  # 总是抑制异常!
with SilentFile('test.txt') as f:
    f.write("Hello")
    raise ValueError("故意出错")  # 被抑制,无异常
print("继续执行")

除非明确需要,否则 __exit__ 返回 None(等价于 False)以传播异常。

八、实战项目:构建任务管理器

项目需求

设计一个命令行任务管理器,支持添加、完成、删除任务,按状态过滤,持久化到 JSON 文件。

核心类设计

  • Task:任务对象,含 ID、标题、状态(待办/已完成)、创建时间;
  • TaskManager:任务集合管理器,提供 CRUD 操作、过滤、保存/加载;
  • JSONStorage:持久化策略,实现读写 JSON 文件。

代码实现

Task 类:定义任务行为
from datetime import datetime
from uuid import uuid4
class Task:
    def __init__(self, title, status='pending'):
        self.id = str(uuid4())[:8]  # 简短 ID
        self.title = title
        self.status = status
        self.created_at = datetime.now()
    def complete(self):
        self.status = 'completed'
    def __repr__(self):
        return f"Task(id={self.id}, title='{self.title}', status='{self.status}')"
    def to_dict(self):
        return {
            'id': self.id,
            'title': self.title,
            'status': self.status,
            'created_at': self.created_at.isoformat()
        }
    @classmethod
    def from_dict(cls, data):
        task = cls(data['title'], data['status'])
        task.id = data['id']
        task.created_at = datetime.fromisoformat(data['created_at'])
        return task
JSONStorage 类:持久化策略
import json
import os
class JSONStorage:
    def __init__(self, filepath='tasks.json'):
        self.filepath = filepath
    def save(self, tasks):
        with open(self.filepath, 'w') as f:
            json.dump([t.to_dict() for t in tasks], f, indent=2)
    def load(self):
        if not os.path.exists(self.filepath):
            return []
        with open(self.filepath, 'r') as f:
            data = json.load(f)
        return [Task.from_dict(d) for d in data]
TaskManager 类:核心业务逻辑
class TaskManager:
    def __init__(self, storage):
        self.storage = storage
        self.tasks = storage.load()
    def add_task(self, title):
        task = Task(title)
        self.tasks.append(task)
        self.storage.save(self.tasks)
        return task
    def complete_task(self, task_id):
        for task in self.tasks:
            if task.id == task_id:
                task.complete()
                self.storage.save(self.tasks)
                return True
        return False
    def remove_task(self, task_id):
        self.tasks = [t for t in self.tasks if t.id != task_id]
        self.storage.save(self.tasks)
    def get_by_status(self, status):
        return [t for t in self.tasks if t.status == status]

CLI 交互示例

命令行界面
def main():
    storage = JSONStorage()
    manager = TaskManager(storage)
    while True:
        print("\n1. 添加任务 2. 完成任务 3. 删除任务 4. 查看待办 5. 查看已完成 0. 退出")
        choice = input("选择操作:").strip()
        if choice == '1':
            title = input("任务标题:")
            task = manager.add_task(title)
            print(f"任务已添加:{task}")
        elif choice == '2':
            task_id = input("任务 ID:")
            if manager.complete_task(task_id):
                print("任务已完成!")
            else:
                print("任务未找到")
        elif choice == '3':
            task_id = input("任务 ID:")
            manager.remove_task(task_id)
            print("任务已删除")
        elif choice == '4':
            pending = manager.get_by_status('pending')
            print("\n待办任务:")
            for t in pending:
                print(f"  [{t.id}] {t.title}")
        elif choice == '5':
            completed = manager.get_by_status('completed')
            print("\n已完成任务:")
            for t in completed:
                print(f"  [{t.id}] {t.title}")
        elif choice == '0':
            break
        else:
            print("无效选择")
if __name__ == "__main__":
    main()

运行此程序,用户可交互式管理任务,数据持久化到 tasks.json。该设计遵循 OCP:添加新存储策略(如数据库)只需实现 Storage 接口,无需修改 TaskManager。

以下内容与 Python 方法类对象 高度相关,常见于开发者社区讨论:

1. 如何在类中使用装饰器?

类方法可被装饰器包装,如 @staticmethod、@classmethod 本身是装饰器。自定义装饰器可添加日志、缓存、权限检查:

示例:类方法日志装饰器
import functools
def log_method(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__qualname__} with {args[1:]}")
        return func(*args, **kwargs)
    return wrapper
class Calculator:
    @log_method
    def add(self, x, y):
        return x + y
calc = Calculator()
calc.add(3, 5)  # 输出:调用 Calculator.add with (3, 5)

注意:args[0] 是 self,故切片从 1 开始。

2. 类属性与实例属性的内存开销

类属性存储在类的 __dict__ 中,被所有实例共享;实例属性存储在每个实例的 __dict__ 中。大量实例时,实例属性占用更多内存。

优化技巧:使用 __slots__ 限制实例属性,避免动态创建属性,减少内存:

示例:使用 __slots__ 优化内存
class Point:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y
p = Point(1, 2)
# p.z = 3  # AttributeError: 'Point' object has no attribute 'z'

适用于固定属性的类(如数据模型),但会禁止 __dict__ 和 __weakref__,不适用于需动态扩展的类。

3. 如何实现类似 Java 的 getter/setter?

Python 推崇直接访问属性(obj.attr),但可通过 @property 实现受控访问:

示例:使用 property 实现只读与只写
class Person:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):  # 只读
        return self._name
    @name.setter
    def name(self, value):  # 只写
        if not isinstance(value, str):
            raise TypeError("Name must be a string")
        self._name = value
p = Person("Alice")
print(p.name)  # Alice
p.name = "Bob"  # OK
# p.name = 123  # TypeError

@property 将方法转换为属性访问,隐藏内部实现,便于后续添加验证逻辑。

4. 类继承与鸭子类型的选择

Python 鼓励鸭子类型(Duck Typing):不关心对象类型,只关心其行为(是否具备所需方法)。继承应仅用于真正“是一个”(is-a)关系:

鸭子类型示例
def make_sound(animal):
    print(animal.sound())
class Dog:
    def sound(self):
        return "Woof"
class Car:
    def sound(self):
        return "Beep"
make_sound(Dog())  # Woof
make_sound(Car())  # Beep

鸭子类型更灵活,减少不必要的继承层次,符合 Python “优雅胜于严格”的哲学。

5. asyncio 中的类与方法

异步编程中,类方法可定义为 async def,支持 await。实例方法需用 self,类方法用 cls:

示例:异步任务类
import asyncio
class AsyncTask:
    def __init__(self, name):
        self.name = name
    async def run(self):
        print(f"开始任务 {self.name}")
        await asyncio.sleep(1)
        print(f"完成任务 {self.name}")
async def main():
    task = AsyncTask("数据处理")
    await task.run()
asyncio.run(main())

异步类方法遵循相同 OOP 原则,但需注意事件循环与协程调度。