Python装饰器原理与应用全解析

1. Python装饰器：从入门到精通

作为一名Python开发者，我经常遇到需要在不修改原函数代码的情况下为函数添加额外功能的场景。比如要给几十个函数添加执行时间统计，或者为关键业务函数添加日志记录。如果每个函数都手动添加这些代码，不仅工作量大，而且容易出错。这时候，Python装饰器就派上用场了。

装饰器是Python中一种强大的元编程工具，它允许我们通过简单的语法糖来扩展函数的行为。理解装饰器的工作原理，能让你写出更优雅、更可维护的Python代码。本文将从基础概念讲起，通过大量实际案例，带你全面掌握装饰器的使用技巧。

2. 装饰器基础概念

2.1 为什么需要装饰器？

想象一下这个场景：你正在开发一个数据分析系统，里面有几十个数据处理函数。现在产品经理要求你为所有函数添加执行时间统计功能。按照传统做法，你需要在每个函数开头和结尾添加计时代码：

python复制def process_data(data):
    start = time.time()  # 开始计时
    
    # 核心处理逻辑
    result = complex_calculation(data)
    
    end = time.time()  # 结束计时
    print(f"process_data执行耗时: {end-start:.2f}秒")
    return result

这种做法有几个明显问题：

1. 代码重复：同样的计时逻辑出现在每个函数中
2. 核心逻辑被辅助代码淹没，可读性降低
3. 如果需要修改计时逻辑，需要修改所有函数

装饰器就是为了解决这类问题而生的。使用装饰器后，代码可以简化为：

python复制@timer
def process_data(data):
    return complex_calculation(data)

2.2 理解函数作为对象

要理解装饰器，首先需要明白Python中函数是一等公民(first-class citizen)。这意味着：

• 函数可以被赋值给变量
• 函数可以作为参数传递给其他函数
• 函数可以作为其他函数的返回值

python复制def greet(name):
    return f"Hello, {name}!"

# 函数赋值给变量
say_hello = greet
print(say_hello("Alice"))  # 输出: Hello, Alice!

# 函数作为参数
def call_func(func, arg):
    return func(arg)

print(call_func(greet, "Bob"))  # 输出: Hello, Bob!

# 函数作为返回值
def create_greeting(prefix):
    def custom_greet(name):
        return f"{prefix}, {name}!"
    return custom_greet

morning_greet = create_greeting("Good morning")
print(morning_greet("Charlie"))  # 输出: Good morning, Charlie!

2.3 闭包机制

闭包(closure)是装饰器的核心技术。闭包是指内部函数可以访问外部函数作用域中的变量，即使外部函数已经执行完毕。

python复制def outer_function(msg):
    message = msg  # 外部函数变量
    
    def inner_function():
        print(f"Message: {message}")  # 内部函数访问外部变量
    
    return inner_function  # 返回内部函数对象

my_func = outer_function("Hello")
my_func()  # 输出: Message: Hello

在这个例子中，即使outer_function已经执行完毕，inner_function仍然可以访问message变量。这种特性使得装饰器能够"记住"被装饰的函数。

3. 装饰器基本用法

3.1 最简单的装饰器实现

让我们实现一个简单的计时装饰器：

python复制import time

def timer_decorator(func):
    def wrapper():
        start_time = time.time()
        result = func()  # 执行原函数
        end_time = time.time()
        print(f"{func.__name__}执行耗时: {end_time-start_time:.4f}秒")
        return result
    return wrapper

@timer_decorator
def my_function():
    print("正在执行任务...")
    time.sleep(1)
    return "任务完成"

result = my_function()
print(f"返回值: {result}")

输出：

code复制正在执行任务...
my_function执行耗时: 1.0012秒
返回值: 任务完成

3.2 装饰器语法解析

装饰器语法@decorator实际上是一种语法糖，它等价于：

python复制def my_function():
    ...

my_function = timer_decorator(my_function)

装饰器的工作流程：

1. 定义装饰器函数(timer_decorator)，它接收一个函数(func)作为参数
2. 在装饰器内部定义一个新的函数(wrapper)，它包裹原函数并添加额外功能
3. 装饰器返回这个新函数(wrapper)
4. 当调用被装饰的函数时，实际上调用的是wrapper函数

3.3 处理带参数的函数

上面的装饰器只能装饰无参函数。为了让装饰器能处理带参数的函数，我们需要使用*args和**kwargs：

python复制def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)  # 传递所有参数
        end_time = time.time()
        print(f"{func.__name__}执行耗时: {end_time-start_time:.4f}秒")
        return result
    return wrapper

@timer_decorator
def add(a, b):
    time.sleep(0.1)
    return a + b

print(add(10, 20))  # 正常调用带参函数

4. 实用装饰器案例

4.1 日志记录装饰器

日志记录是装饰器的典型应用场景：

python复制import datetime

def log_decorator(func):
    def wrapper(*args, **kwargs):
        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] 调用函数: {func.__name__}")
        print(f"    参数: args={args}, kwargs={kwargs}")
        
        try:
            result = func(*args, **kwargs)
            print(f"    返回值: {result}")
            print(f"    状态: 成功")
            return result
        except Exception as e:
            print(f"    错误: {str(e)}")
            print(f"    状态: 失败")
            raise
    
    return wrapper

@log_decorator
def calculate_bmi(weight, height):
    if height <= 0:
        raise ValueError("身高必须大于0")
    return weight / (height ** 2)

calculate_bmi(70, 1.75)  # 正常调用
calculate_bmi(70, 0)     # 触发异常

4.2 缓存装饰器

对于计算成本高的函数，可以使用装饰器实现缓存：

python复制def cache_decorator(func):
    cache = {}
    
    def wrapper(*args, **kwargs):
        # 创建缓存键
        key = (args, tuple(kwargs.items()))
        
        if key in cache:
            print(f"缓存命中: {func.__name__}{args}")
            return cache[key]
            
        print(f"执行计算: {func.__name__}{args}")
        result = func(*args, **kwargs)
        cache[key] = result
        return result
    
    return wrapper

@cache_decorator
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 第一次计算
print(fibonacci(10))  # 从缓存获取

4.3 权限验证装饰器

Web开发中常用装饰器进行权限验证：

python复制def require_role(role):
    def decorator(func):
        def wrapper(user_role, *args, **kwargs):
            if user_role != role:
                print(f"权限不足！需要{role}权限，当前是{user_role}")
                return None
            return func(*args, **kwargs)
        return wrapper
    return decorator

@require_role("admin")
def delete_user(user_id):
    print(f"正在删除用户{user_id}...")
    return f"用户{user_id}已删除"

print(delete_user("admin", "user001"))  # 管理员操作
print(delete_user("user", "user002"))   # 普通用户操作

5. 高级装饰器技巧

5.1 带参数的装饰器

有时候我们需要装饰器本身也能接受参数：

python复制def repeat(times=1):
    def decorator(func):
        def wrapper(*args, **kwargs):
            results = []
            for i in range(times):
                print(f"第{i+1}次执行:")
                result = func(*args, **kwargs)
                results.append(result)
            return results
        return wrapper
    return decorator

@repeat(times=3)
def greet(name):
    print(f"Hello, {name}!")
    return f"问候{name}完成"

print(greet("Alice"))

5.2 类装饰器

除了函数，我们也可以用类实现装饰器：

python复制class Retry:
    def __init__(self, max_retries=3):
        self.max_retries = max_retries
    
    def __call__(self, func):
        def wrapper(*args, **kwargs):
            last_exception = None
            for attempt in range(self.max_retries):
                try:
                    print(f"第{attempt+1}次尝试...")
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    print(f"尝试失败: {str(e)}")
                    if attempt < self.max_retries - 1:
                        time.sleep(1)
            print(f"所有{self.max_retries}次尝试都失败")
            raise last_exception
        return wrapper

@Retry(max_retries=3)
def unreliable_function():
    import random
    if random.random() < 0.7:
        raise ValueError("随机失败")
    return "操作成功"

print(unreliable_function())

5.3 保留函数元信息

装饰器会覆盖原函数的__name__、__doc__等元信息，使用functools.wraps可以解决这个问题：

python复制import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        """Wrapper函数的文档字符串"""
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def example():
    """示例函数的文档字符串"""
    pass

print(example.__name__)  # 输出: example
print(example.__doc__)   # 输出: 示例函数的文档字符串

6. 装饰器在实际项目中的应用

6.1 Web框架路由

装饰器在Web框架中广泛用于路由注册：

python复制class WebFramework:
    def __init__(self):
        self.routes = {}
    
    def route(self, path):
        def decorator(func):
            self.routes[path] = func
            return func
        return decorator
    
    def run(self):
        while True:
            path = input("请输入路径: ")
            if path in self.routes:
                print(self.routes[path]())
            else:
                print("404 Not Found")

app = WebFramework()

@app.route("/")
def home():
    return "欢迎来到首页"

@app.route("/about")
def about():
    return "关于我们"

app.run()

6.2 数据库事务管理

装饰器可以简化事务管理代码：

python复制class Database:
    def __init__(self):
        self.in_transaction = False
        self.operations = []
    
    def transaction(self, func):
        def wrapper(*args, **kwargs):
            if self.in_transaction:
                return func(*args, **kwargs)
            
            self.in_transaction = True
            self.operations = []
            
            try:
                result = func(*args, **kwargs)
                self.commit()
                return result
            except Exception as e:
                self.rollback()
                raise
            finally:
                self.in_transaction = False
        return wrapper
    
    def commit(self):
        print(f"提交事务: {len(self.operations)}个操作")
        self.operations = []
    
    def rollback(self):
        print(f"回滚事务: {len(self.operations)}个操作")
        self.operations = []

db = Database()

@db.transaction
def transfer_money(from_acc, to_acc, amount):
    db.operations.append(("withdraw", from_acc, amount))
    db.operations.append(("deposit", to_acc, amount))
    if amount > 1000:
        raise ValueError("转账金额过大")

transfer_money("A001", "B002", 500)  # 成功
transfer_money("A001", "B002", 1500) # 失败并回滚

7. 装饰器最佳实践

7.1 装饰器使用建议

1. 保持装饰器简单：每个装饰器应该只负责一个功能
2. 合理命名：装饰器名称应该清晰表达其功能
3. 使用functools.wraps：保留原函数的元信息
4. 考虑性能影响：避免在性能关键路径上使用复杂装饰器
5. 文档化装饰器：说明装饰器的用途和参数

7.2 常见陷阱与解决方案

1. 装饰器顺序问题：

   python复制@decorator1
   @decorator2
   def func():
       pass
   

   执行顺序是从下往上：先应用decorator2，再应用decorator1

2. 装饰器调试困难：

   • 使用functools.wraps保留原函数信息
   • 在装饰器中添加详细的日志

3. 装饰器影响性能：

   • 对于性能敏感的场景，考虑将装饰器逻辑移到函数内部
   • 使用缓存装饰器时注意内存使用

4. 装饰器与静态方法冲突：

   python复制class MyClass:
       @staticmethod
       @my_decorator  # 注意顺序
       def method():
           pass
   

   装饰器应该在@staticmethod之上

8. 装饰器进阶话题

8.1 装饰器与描述符协议

装饰器可以与描述符协议结合，实现更复杂的属性控制：

python复制class Validator:
    def __init__(self, validator_func):
        self.validator = validator_func
    
    def __set_name__(self, owner, name):
        self.name = name
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__.get(self.name)
    
    def __set__(self, instance, value):
        if not self.validator(value):
            raise ValueError(f"无效的{self.name}: {value}")
        instance.__dict__[self.name] = value

def validate_age(value):
    return isinstance(value, int) and 0 <= value <= 120

class Person:
    age = Validator(validate_age)

p = Person()
p.age = 30  # 有效
p.age = 150 # 抛出ValueError

8.2 异步函数装饰器

Python的async/await语法也支持装饰器：

python复制import asyncio

def async_timer(func):
    async def wrapper(*args, **kwargs):
        start_time = time.time()
        result = await func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__}执行耗时: {end_time-start_time:.4f}秒")
        return result
    return wrapper

@async_timer
async def fetch_data():
    await asyncio.sleep(1)
    return "数据获取完成"

asyncio.run(fetch_data())

8.3 装饰器工厂模式

对于复杂的装饰器逻辑，可以使用工厂模式：

python复制def decorator_factory(config):
    def decorator(func):
        if config.get("log"):
            print(f"为{func.__name__}应用装饰器")
        
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if config.get("pre_process"):
                args = [arg.upper() for arg in args]
            
            result = func(*args, **kwargs)
            
            if config.get("post_process"):
                result = result.upper()
            
            return result
        return wrapper
    return decorator

@decorator_factory({"log": True, "pre_process": True})
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))  # 输出: HELLO, ALICE!

9. 装饰器性能考量

9.1 装饰器开销分析

装饰器会引入额外的函数调用开销。对于性能敏感的场景，需要权衡装饰器的便利性和性能影响。

python复制import timeit

def no_op_decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@no_op_decorator
def simple_func():
    return 42

# 测试原始函数性能
print("原始函数:", timeit.timeit(simple_func, number=1000000))

# 测试装饰后函数性能
print("装饰后函数:", timeit.timeit(simple_func, number=1000000))

9.2 优化装饰器性能

1. 使用functools.lru_cache：对于纯函数，可以使用内置缓存装饰器
2. 避免不必要的装饰器嵌套：减少装饰器层数
3. 考虑使用类装饰器：对于复杂逻辑，类装饰器可能更高效
4. 在开发环境使用，生产环境移除：如调试用的日志装饰器

10. 装饰器设计模式

装饰器模式是面向对象设计模式的一种，Python的装饰器语法使其实现变得非常简单。

10.1 传统装饰器模式

python复制class Component:
    def operation(self):
        pass

class ConcreteComponent(Component):
    def operation(self):
        return "具体组件"

class Decorator(Component):
    def __init__(self, component):
        self._component = component
    
    def operation(self):
        return self._component.operation()

class ConcreteDecoratorA(Decorator):
    def operation(self):
        return f"装饰器A({self._component.operation()})"

class ConcreteDecoratorB(Decorator):
    def operation(self):
        return f"装饰器B[{self._component.operation()}]"

# 使用
simple = ConcreteComponent()
decorated = ConcreteDecoratorB(ConcreteDecoratorA(simple))
print(decorated.operation())  # 输出: 装饰器B[装饰器A(具体组件)]

10.2 Python装饰器与传统模式对比

Python的函数装饰器提供了更简洁的实现方式：

python复制def decorator_a(func):
    def wrapper():
        return f"装饰器A({func()})"
    return wrapper

def decorator_b(func):
    def wrapper():
        return f"装饰器B[{func()}]"
    return wrapper

@decorator_b
@decorator_a
def concrete_component():
    return "具体组件"

print(concrete_component())  # 输出: 装饰器B[装饰器A(具体组件)]

Python装饰器的优势：

1. 语法简洁直观
2. 不需要创建大量类
3. 更容易组合多个装饰器

11. 装饰器在标准库中的应用

Python标准库中有许多内置装饰器：

11.1 @property

将方法转换为属性：

python复制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.14 * self._radius ** 2

c = Circle(5)
print(c.area)  # 78.5
c.radius = 10
print(c.area)  # 314.0

11.2 @classmethod和@staticmethod

定义类方法和静态方法：

python复制class MyClass:
    @classmethod
    def class_method(cls):
        print(f"调用类方法，类名为{cls.__name__}")
    
    @staticmethod
    def static_method():
        print("调用静态方法")

MyClass.class_method()  # 调用类方法，类名为MyClass
MyClass.static_method() # 调用静态方法

11.3 @functools.lru_cache

函数结果缓存：

python复制import functools

@functools.lru_cache(maxsize=128)
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(50))  # 快速计算，因为有缓存

12. 装饰器单元测试

为装饰器编写单元测试非常重要：

python复制import unittest

def add_one(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result + 1
    return wrapper

@add_one
def return_five():
    return 5

class TestDecorator(unittest.TestCase):
    def test_add_one(self):
        self.assertEqual(return_five(), 6)
    
    def test_decorator_with_args(self):
        @add_one
        def add(a, b):
            return a + b
        
        self.assertEqual(add(2, 3), 6)

if __name__ == "__main__":
    unittest.main()

13. 装饰器与元类结合

装饰器可以与元类结合，实现更强大的类装饰功能：

python复制class Meta(type):
    def __new__(cls, name, bases, namespace):
        # 自动为所有方法添加日志装饰器
        for attr_name, attr_value in namespace.items():
            if callable(attr_value):
                namespace[attr_name] = log_decorator(attr_value)
        return super().__new__(cls, name, bases, namespace)

class MyClass(metaclass=Meta):
    def method1(self):
        return "方法1"
    
    def method2(self):
        return "方法2"

obj = MyClass()
obj.method1()  # 会自动记录日志

14. 装饰器在框架中的应用

许多流行Python框架都大量使用装饰器：

14.1 Flask路由

python复制from flask import Flask
app = Flask(__name__)

@app.route("/")
def home():
    return "首页"

@app.route("/about")
def about():
    return "关于"

14.2 Django权限控制

python复制from django.contrib.auth.decorators import login_required

@login_required
def my_view(request):
    return "需要登录的视图"

14.3 Pytest fixture

python复制import pytest

@pytest.fixture
def database():
    db = setup_database()
    yield db
    db.teardown()

def test_query(database):
    result = database.query("SELECT 1")
    assert result == 1

15. 创建自己的装饰器库

随着项目规模扩大，可以创建专门的装饰器模块：

code复制my_project/
│
├── decorators/
│   ├── __init__.py
│   ├── logging.py
│   ├── caching.py
│   └── validation.py
│
└── main.py

logging.py示例：

python复制import functools
import logging

def log_call(logger=None):
    if logger is None:
        logger = logging.getLogger(__name__)
    
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            logger.info(f"调用 {func.__name__} args={args} kwargs={kwargs}")
            try:
                result = func(*args, **kwargs)
                logger.info(f"{func.__name__} 返回: {result}")
                return result
            except Exception as e:
                logger.error(f"{func.__name__} 失败: {str(e)}")
                raise
        return wrapper
    return decorator

使用方式：

python复制from decorators.logging import log_call

@log_call()
def important_operation(x, y):
    return x * y

16. 装饰器代码风格指南

1. 命名约定：

   • 装饰器函数使用名词或动词短语，如timer、log_call
   • 内部wrapper函数通常命名为wrapper

2. 文档字符串：

   • 装饰器应该有详细的文档字符串，说明其功能和参数
   • 示例：

     python复制def retry(max_attempts=3):
         """重试装饰器
         
         参数:
             max_attempts: 最大重试次数
         
         示例:
             @retry(max_attempts=5)
             def might_fail():
                 ...
         """
     

3. 代码组织：

   • 复杂装饰器应该拆分为多个小函数
   • 考虑使用类装饰器来组织复杂逻辑

4. 错误处理：

   • 装饰器应该正确处理异常，或者明确向上抛出
   • 避免在装饰器中静默吞掉异常

17. 装饰器调试技巧

调试装饰器代码可能会比较困难，以下是一些技巧：

1. 使用print调试：

   python复制def debug_decorator(func):
       print(f"装饰器正在装饰: {func.__name__}")
       
       def wrapper(*args, **kwargs):
           print(f"调用 {func.__name__} args={args} kwargs={kwargs}")
           result = func(*args, **kwargs)
           print(f"{func.__name__} 返回: {result}")
           return result
       
       return wrapper
   

2. 使用pdb调试：

   python复制import pdb
   
   def debug_decorator(func):
       def wrapper(*args, **kwargs):
           pdb.set_trace()  # 设置断点
           return func(*args, **kwargs)
       return wrapper
   

3. 检查函数签名：

   python复制from inspect import signature
   
   def decorator(func):
       print("原函数签名:", signature(func))
       ...
   

4. 使用wrapt模块：
   wrapt模块提供了更强大的装饰器工具，可以更好地处理函数签名和调试信息。

18. 装饰器与类型提示

Python的类型提示系统可以与装饰器很好地配合：

python复制from typing import Callable, TypeVar, Any
import functools

T = TypeVar('T')

def type_check(func: Callable[..., T]) -> Callable[..., T]:
    @functools.wraps(func)
    def wrapper(*args: Any, **kwargs: Any) -> T:
        # 这里可以添加类型检查逻辑
        return func(*args, **kwargs)
    return wrapper

@type_check
def greet(name: str) -> str:
    return f"Hello, {name}!"

对于带参数的装饰器，类型提示会更复杂一些：

python复制from typing import Callable, TypeVar, Any, Optional
import functools

T = TypeVar('T')

def retry(max_attempts: int = 3) -> Callable[[Callable[..., T]], Callable[..., T]]:
    def decorator(func: Callable[..., T]) -> Callable[..., T]:
        @functools.wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> T:
            last_exception: Optional[Exception] = None
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
            raise last_exception  # type: ignore
        return wrapper
    return decorator

19. 装饰器性能优化技巧

对于性能关键的装饰器，可以考虑以下优化：

1. 使用functools.wraps：虽然看起来是额外开销，但实际上它能避免更昂贵的属性查找

2. 避免不必要的闭包变量访问：

   python复制# 不推荐
   def slow_decorator(func):
       context = load_context()  # 每次装饰都会执行
       
       def wrapper(*args, **kwargs):
           use(context)  # 每次调用都会访问闭包变量
           return func(*args, **kwargs)
       return wrapper
   
   # 推荐
   def fast_decorator(func):
       def wrapper(*args, **kwargs):
           context = load_context()  # 仅在调用时执行
           use(context)
           return func(*args, **kwargs)
       return wrapper
   

3. 使用类装饰器减少嵌套：

   python复制class Timer:
       def __init__(self, func):
           self.func = func
       
       def __call__(self, *args, **kwargs):
           start = time.time()
           result = self.func(*args, **kwargs)
           end = time.time()
           print(f"耗时: {end-start}秒")
           return result
   
   @Timer
   def my_func():
       ...
   

4. 考虑使用装饰器缓存：

   python复制from functools import lru_cache
   
   @lru_cache(maxsize=None)
   def expensive_decorator(func):
       # 复杂的装饰器初始化
       return wrapper
   

20. 装饰器与Python新特性

随着Python版本更新，装饰器也在不断发展：

20.1 Python 3.9的缓存装饰器改进

python复制from functools import cache  # Python 3.9+

@cache  # 等价于@lru_cache(maxsize=None)
def factorial(n):
    return n * factorial(n-1) if n else 1

20.2 Python 3.10的参数化装饰器类型提示

Python 3.10改进了参数化装饰器的类型提示：

python复制from typing import Callable, ParamSpec, TypeVar

P = ParamSpec('P')
T = TypeVar('T')

def decorator(func: Callable[P, T]) -> Callable[P, T]:
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
        return func(*args, **kwargs)
    return wrapper

20.3 Python 3.11的零成本装饰器

Python 3.11引入了@typing.dataclass_transform()装饰器，支持更灵活的数据类创建：

python复制from typing import dataclass_transform

@dataclass_transform()
def create_model(cls):
    return cls

@create_model
class Point:
    x: int
    y: int

p = Point(1, 2)  # 自动获得__init__等方法