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 时,解释器执行:
- 在实例
obj的__dict__中查找method(通常无); - 在类
obj.__class__的__dict__中查找method; - 若找到的是函数对象,则将其包装为绑定方法(bound method)——将实例作为第一个参数传入;
- 若找到的是描述符对象(如
@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 原则,但需注意事件循环与协程调度。