1. 这不是语法糖，是Python世界运转的底层齿轮
很多人第一次看到class Person:的时候，下意识觉得：“哦，就是把函数打包在一起的写法吧？”——这种理解在入门阶段勉强能跑通代码，但一旦项目规模超过500行，或者需要和别人协作、维护半年以上的项目，就会发现：类不是“更方便的函数组织方式”，而是Python中唯一能承载状态、行为与契约的复合结构体。它不像C语言的struct只存数据，也不像Java的class那样强制抽象，Python的类是动态的、可修改的、带着运行时呼吸感的活体结构。
我带过三届实习生，几乎所有人都在第二周卡在一个问题上：为什么list.append()不返回新列表，而sorted()却返回新对象？答案不在文档里，而在类的设计哲学里——list是一个可变容器类，它的实例（比如my_list = [1,2,3]）本身就是一个独立的生命体，有自己的一块内存、自己的身份（id(my_list)）、自己的状态演化路径；而sorted()是一个纯函数，不绑定任何实例。这个区别，直接决定了你写my_list.append(4)后，my_list就真的变了；而sorted(my_list)只是给你一张快照，原列表纹丝不动。
关键词Python Classes和Objects在这里不是并列关系，而是因果关系：Class 是模具，Object 是铸件；Class 是蓝图，Object 是正在施工的楼；Class 是乐谱，Object 是此刻正在演奏的乐团。没有对象的类是空谱，没有类的对象是无源之水——Python里所有东西（包括int、str、甚至type本身）都是对象，而它们之所以能存在、能调用方法、能比较大小、能被打印，全靠背后那个看不见却无处不在的类系统在支撑。
你可能已经用过len("hello")、"world".upper()、[1,2].pop()，但未必意识到：这三个点号（.）后面调用的，全是不同类定义的方法。str.upper是字符串类的实例方法，list.pop是列表类的实例方法，而len()看似是函数，实则触发的是对象的__len__特殊方法——这个双下划线开头结尾的命名，就是Python为类预留的“系统接口区”。它不让你直接写obj.__len__()，而是用len(obj)这种统一入口，让不同类的对象都能以同一种方式被询问长度。这就是面向对象编程（OOP）最朴素也最强大的设计：统一接口，差异化实现。
所以，当你搜索“python零基础入门教程”或“python基础语法”时，真正该建立的第一认知不是“怎么写class”，而是“为什么必须用class”。这不是为了炫技，而是因为——没有类，你就无法封装状态；没有封装，逻辑就必然散落在全局变量和一堆孤立函数里；一旦逻辑散落，调试五分钟，重构两小时，交接三天，维护三年。这不是危言耸听，是我亲手重构过17个遗留项目的血泪总结。
2. 实例、类、元类：三层嵌套的俄罗斯套娃
Python的类体系不是平面的，而是立体的三层结构：最外层是实例（Instance），中间是类（Class），最内核是元类（Metaclass）。绝大多数人只在第一层活动，但真正理解类，必须看清这三层如何咬合。
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} says woof!" # 创建两个实例 dog_a = Dog("Buddy", 3) dog_b = Dog("Max", 5)dog_a和dog_b是两个独立的实例。它们各自拥有自己的name和age（实例属性），但共享同一个species（类属性）和同一个bark方法（类方法）。你可以验证：
print(dog_a.name) # "Buddy" print(dog_b.name) # "Max" print(dog_a.species) # "Canis lupus familiaris" print(dog_b.species) # "Canis lupus familiaris" print(dog_a.bark is dog_b.bark) # True —— 同一个函数对象提示：
self不是关键字，只是约定俗成的参数名。你写成def bark(this_dog):也能运行，但会立刻被团队踢出群聊。self的本质，是Python自动把调用者实例作为第一个参数传进来。dog_a.bark()等价于Dog.bark(dog_a)。这是Python实现“实例方法”的底层机制，也是你理解@staticmethod和@classmethod的起点。
2.2 类：实例的模板与行为的仓库
类本身也是一个对象，它的类型是type：
print(type(Dog)) # <class 'type'> print(isinstance(Dog, type)) # True这意味着类可以被赋值、被传递、被动态创建。Dog这个名字，只是指向内存中某个type实例的一个标签。你可以这样操作：
MyDog = Dog # MyDog 和 Dog 指向同一个类对象 another_dog = MyDog("Luna", 2) # 完全合法类对象存储了所有实例共享的数据（类属性）和行为（方法）。但要注意：类属性不是“静态变量”。如果类属性是可变对象（如列表、字典），修改它会影响所有实例：
class BadExample: shared_list = [] def add_item(self, item): self.shared_list.append(item) x = BadExample() y = BadExample() x.add_item("from x") print(y.shared_list) # ['from x'] —— y 也被污染了！正确做法是：在__init__中为每个实例初始化独立的可变属性：
class GoodExample: def __init__(self): self.instance_list = [] # 每个实例独享 def add_item(self, item): self.instance_list.append(item)2.3 元类：类的制造工厂
如果你觉得“类是对象”已经够烧脑，那元类就是给这个对象再套一层壳。type是Python默认的元类，它负责创建类对象。你可以用type动态创建类：
# 等价于 class MyClass: pass MyClass = type('MyClass', (), {}) # 等价于 class Person: name = "Unknown" Person = type('Person', (), {'name': 'Unknown'}) # 等价于 class Animal: def speak(self): return "sound" Animal = type('Animal', (), { 'speak': lambda self: "sound" })元类真正的威力，在于控制类的创建过程。比如你想强制所有类都必须定义一个required_attr属性：
class RequireAttrMeta(type): def __new__(cls, name, bases, attrs): if 'required_attr' not in attrs: raise TypeError(f"Class {name} must define 'required_attr'") return super().__new__(cls, name, bases, attrs) class ValidClass(metaclass=RequireAttrMeta): required_attr = "I am required" # class InvalidClass(metaclass=RequireAttrMeta): # 会报错 # pass注意：元类是高级武器，95%的项目完全用不到。过早使用元类，就像给自行车装涡轮增压——不仅没用，还容易炸缸。先吃透实例和类的关系，再考虑元类。
3.__init__不是构造函数，__new__才是真正的出生证明
这是Python类中最常被误解的概念。几乎所有中文教程都说“__init__是构造函数”，但严格来说，__init__是初始化方法，__new__才是构造函数。它们分工明确：
__new__：负责分配内存、创建空白对象（即“生出来”）__init__：负责给这个刚出生的空白对象“起名字、穿衣服、教说话”（即“养大”）
看一个经典例子：单例模式（Singleton）的正确实现：
class Singleton: _instance = None def __new__(cls): if cls._instance is None: # 调用父类的 __new__ 创建新对象 cls._instance = super().__new__(cls) return cls._instance def __init__(self): # 每次调用 Singleton() 都会执行 __init__ # 所以这里不能放初始化逻辑，否则会重复执行 print("Initializing...") # 测试 a = Singleton() # 输出 "Initializing..." b = Singleton() # 再次输出 "Initializing..." —— 问题来了！你会发现__init__被调用了两次，但a is b为True。这说明__new__确保了只有一个对象，但__init__没有被控制。正确写法是：
class Singleton: _instance = None _initialized = False def __new__(cls): if cls._instance is None: cls._instance = super().__new__(cls) return cls._instance def __init__(self): if not self._initialized: print("Initializing only once...") self._initialized = True再看一个更硬核的例子：不可变对象的自定义。str、int、tuple都是不可变的，你无法修改它们的内容。想自定义一个不可变的Point类：
class Point: def __new__(cls, x, y): # 创建对象前，先冻结参数 instance = super().__new__(cls) # 把 x, y 存到对象的私有字典里，阻止后续修改 instance._x = x instance._y = y return instance @property def x(self): return self._x @property def y(self): return self._y def __setattr__(self, name, value): # 拦截所有属性赋值，只允许在 __new__ 中设置 raise TypeError(f"'{self.__class__.__name__}' object is immutable") p = Point(1, 2) print(p.x, p.y) # 1 2 # p.x = 3 # TypeError: 'Point' object is immutable这里__new__承担了“出生即定型”的职责，而__setattr__则是“终身守卫”。__new__的返回值必须是当前类的实例（或其子类），否则__init__根本不会被调用。
实操心得：当你需要控制对象的创建时机、来源（比如从缓存取、从数据库查）、或强制某些约束（如单例、不可变、类型检查）时，才动
__new__。日常开发中，99%的需求用__init__就够了。滥用__new__是新手最容易犯的“炫技型错误”。
4. 继承不是“复制粘贴”，是协议继承与责任委托
很多初学者把继承理解为“子类自动获得父类的所有代码”，这导致两个严重后果：一是过度继承（为了用一个方法，硬拉一个八竿子打不着的父类），二是破坏封装（子类随意访问父类的内部属性，导致父类一改，子类全崩）。
Python的继承核心，是“is-a” 关系的建模和“委托协议”的定义。我们来看一个真实场景：电商系统中的订单处理。
class Order: def __init__(self, items, total): self.items = items self.total = total self.status = "pending" def calculate_discount(self): # 基础折扣：满100减10 return max(0, 10 if self.total >= 100 else 0) def process_payment(self): # 假设这里是调用支付网关 self.status = "paid" return "Payment processed" class VipOrder(Order): def calculate_discount(self): # VIP用户：满100减20，且额外95折 base_discount = super().calculate_discount() vip_discount = self.total * 0.05 return base_discount + vip_discount def process_payment(self): # VIP订单有专属支付通道 result = super().process_payment() self.send_vip_receipt() return result def send_vip_receipt(self): print("Sending VIP receipt...")关键点在于super()的使用。super()不是“调用父类”，而是“调用MRO（Method Resolution Order）中下一个类的方法”。Python用C3线性化算法计算MRO，确保多继承时方法调用顺序可预测：
print(VipOrder.__mro__) # (<class '__main__.VipOrder'>, <class '__main__.Order'>, <class 'object'>)这意味着super().calculate_discount()会去Order类里找，而不是死写Order.calculate_discount(self)。好处是：如果未来Order的父类变成BaseOrder，super()会自动适配，而硬编码的Order.则会断裂。
但更关键的是协议设计。Order类定义了一个隐含协议：任何子类只要重写calculate_discount，就必须返回一个数字；只要重写process_payment，就必须能改变self.status并返回字符串。这个协议，比代码本身更重要。
反面教材：强行继承dict来做配置管理：
# ❌ 错误示范：过度继承 class ConfigDict(dict): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._source = "unknown" def save_to_file(self, path): # ... 保存逻辑 pass问题在哪？ConfigDict和dict是“has-a”（拥有）关系，不是“is-a”（是）关系。ConfigDict应该包含一个dict，而不是是一个dict。正确做法是组合（Composition）：
# ✅ 正确：组合优于继承 class Config: def __init__(self): self._data = {} # 内部使用 dict self._source = "unknown" def __getitem__(self, key): return self._data[key] def __setitem__(self, key, value): self._data[key] = value def save_to_file(self, path): # ... 保存逻辑 pass这样，Config控制了所有对外接口，_data是它的私有实现细节，未来可以轻松替换成json.loads()或数据库查询，而不影响使用者。
踩坑实录：我在一个金融项目里见过
TradingStrategy类继承自pandas.DataFrame。结果当pandas升级，DataFrame的__init__签名变了，整个策略回测系统崩溃。后来重构为TradingStrategy持有一个DataFrame实例，问题迎刃而解。记住：继承表达的是“是什么”，组合表达的是“有什么”。宁可多写几行self.data.xxx，也不要为省事搞错关系。
5. 多重继承与Mixin：用乐高积木搭建复杂行为
Python支持多重继承，这既是强大武器，也是深水炸弹。直接写class A(B, C, D):很容易陷入“钻石继承”困境（B和C都继承自D，D的方法被调用两次）。但Python用MRO完美解决了这个问题。真正值得掌握的，是Mixin 模式——一种轻量级、专注单一职责的多重继承用法。
Mixin不是完整的类，它不单独使用，只为给其他类“注入”特定能力。比如，你想给多个类添加日志功能：
class LoggingMixin: """提供统一的日志记录能力""" def log_info(self, message): print(f"[INFO] {self.__class__.__name__}: {message}") def log_error(self, message): print(f"[ERROR] {self.__class__.__name__}: {message}") class PaymentProcessor(LoggingMixin): def process(self, amount): self.log_info(f"Processing payment of ${amount}") # ... 实际处理逻辑 class NotificationService(LoggingMixin): def send_email(self, to): self.log_info(f"Sending email to {to}") # ... 发送逻辑LoggingMixin没有__init__，不定义状态，只提供行为。它和PaymentProcessor之间不是“is-a”，而是“can-do”（能做）关系。Mixin的命名惯例是加Mixin后缀，这是Python社区的强烈约定。
再看一个更实用的JSONSerializableMixin：
import json class JSONSerializableMixin: """让任何类都能一键转JSON""" def to_json(self): # 使用 __dict__ 获取所有实例属性 return json.dumps(self.__dict__, indent=2, default=str) @classmethod def from_json(cls, json_str): data = json.loads(json_str) # 创建新实例，用字典解包初始化 return cls(**data) class User(JSONSerializableMixin): def __init__(self, name, email, created_at): self.name = name self.email = email self.created_at = created_at user = User("Alice", "alice@example.com", "2023-01-01") print(user.to_json()) # { # "name": "Alice", # "email": "alice@example.com", # "created_at": "2023-01-01" # }Mixin的威力在于可组合性。一个类可以同时混入多个Mixin：
class AdvancedUser(User, LoggingMixin, JSONSerializableMixin): pass u = AdvancedUser("Bob", "bob@example.com", "2023-02-01") u.log_info("User created") print(u.to_json())实操技巧：写Mixin时，务必遵守三个铁律：
- 不定义
__init__：避免与主类的初始化冲突；- 方法名加前缀或用下划线：如
log_info而非info，防止命名冲突；- 只做一件事：
LoggingMixin只管日志，CacheMixin只管缓存，ValidationMixin只管校验。混入越多，越要警惕职责爆炸。
6. 特殊方法（Dunder Methods）：Python对象的暗语系统
Python对象之所以能和内置函数、运算符无缝协作，全靠一套以双下划线开头和结尾的特殊方法（Dunder Methods）。它们不是给你随便调用的，而是Python解释器在特定语法糖下自动触发的“钩子”。
| 语法糖 | 触发的特殊方法 | 典型用途 |
|---|---|---|
len(obj) | obj.__len__() | 返回对象长度 |
obj[key] | obj.__getitem__(key) | 支持索引访问 |
obj + other | obj.__add__(other) | 支持加法运算 |
for x in obj: | obj.__iter__()→iterator.__next__() | 支持迭代 |
str(obj) | obj.__str__() | 返回用户友好的字符串表示 |
repr(obj) | obj.__repr__() | 返回开发者友好的调试字符串 |
obj == other | obj.__eq__(other) | 支持相等性比较 |
看一个完整例子：实现一个支持切片、相加、打印的Vector类：
class Vector: def __init__(self, *components): self.components = list(components) def __len__(self): return len(self.components) def __getitem__(self, key): # 支持索引和切片 if isinstance(key, slice): return Vector(*self.components[key]) return self.components[key] def __add__(self, other): if len(self) != len(other): raise ValueError("Vectors must have same dimension") return Vector(*[a + b for a, b in zip(self.components, other.components)]) def __str__(self): return f"Vector({', '.join(map(str, self.components))})" def __repr__(self): return f"Vector{tuple(self.components)}" def __eq__(self, other): return (isinstance(other, Vector) and self.components == other.components) # 使用 v1 = Vector(1, 2, 3) v2 = Vector(4, 5, 6) print(len(v1)) # 3 print(v1[0]) # 1 print(v1[1:3]) # Vector(2, 3) print(v1 + v2) # Vector(5, 7, 9) print(str(v1)) # Vector(1, 2, 3) print(repr(v1)) # Vector(1, 2, 3) print(v1 == Vector(1,2,3)) # True这里的关键洞察是：__str__和__repr__的分工。__str__是给终端用户看的，要简洁友好；__repr__是给开发者看的，要尽可能精确、可复现。理想情况下，eval(repr(obj))应该能重建出obj（虽然实际中很少真这么干，但这是设计目标）。
另一个易错点是__eq__。如果不定义，Python默认用id()比较，即两个不同对象永远不相等。定义__eq__时，必须同时定义__hash__，否则对象无法放入set或作为dict的键：
class HashableVector(Vector): def __hash__(self): # 基于不可变的元组计算哈希 return hash(tuple(self.components))注意：
__hash__必须保证：如果a == b，那么hash(a) == hash(b)。所以__hash__的计算逻辑，必须和__eq__的判断逻辑一致。这也是为什么可变对象（如list）默认没有__hash__——因为它的内容会变，哈希值就不可靠。
7. 属性控制：@property、描述符与__slots__的三重防御
Python的属性访问看似简单，背后却有三层控制机制，分别应对不同强度的封装需求。
7.1@property：最轻量的访问拦截
当你需要对属性读写加一点逻辑（如验证、转换、懒加载），@property是首选：
class Temperature: def __init__(self, celsius): self._celsius = celsius @property def celsius(self): return self._celsius @celsius.setter def celsius(self, value): if value < -273.15: raise ValueError("Temperature below absolute zero!") self._celsius = value @property def fahrenheit(self): return (self._celsius * 9/5) + 32 temp = Temperature(25) print(temp.celsius) # 25 temp.celsius = 30 # 触发 setter print(temp.fahrenheit) # 86.0 # temp.celsius = -300 # ValueError@property让你把方法伪装成属性，调用方无需知道背后是否有逻辑。但它有个局限：所有实例都会创建一个__dict__来存储_celsius，内存开销随实例数线性增长。
7.2 描述符（Descriptor）：中等强度的属性协议
描述符是一个实现了__get__、__set__或__delete__方法的类。它能被多个类共享，是实现通用属性逻辑的利器。比如，一个类型检查描述符：
class Typed: 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__.get(self.name) def __set__(self, instance, value): if not isinstance(value, self.expected_type): raise TypeError(f"{self.name} must be {self.expected_type.__name__}") instance.__dict__[self.name] = value class Person: name = Typed("name", str) age = Typed("age", int) p = Person() p.name = "Alice" # OK # p.age = "25" # TypeError描述符的优势在于：逻辑复用性强，一个Typed描述符可以用在无数个类上。但它比@property复杂，需要理解描述符协议。
7.3__slots__：终极内存优化开关
当你有成千上万个实例，且属性名固定，__slots__能大幅减少内存占用：
class MemoryEfficientPoint: __slots__ = ('x', 'y') # 明确声明只允许这两个属性 def __init__(self, x, y): self.x = x self.y = y p = MemoryEfficientPoint(1, 2) # p.z = 3 # AttributeError: 'MemoryEfficientPoint' object has no attribute 'z' print(p.__slots__) # ('x', 'y') print(hasattr(p, '__dict__')) # False —— 没有 __dict__，节省内存__slots__的原理是：禁止实例创建__dict__，所有属性直接存储在预分配的固定内存槽（slot）里。测试显示，10万个实例，__slots__比普通类节省约40%-50%内存。
实操建议：不要一上来就用
__slots__。先用普通类开发，等性能分析（如memory_profiler）确认是__dict__成为瓶颈时，再引入。而且一旦用了__slots__，就不能动态添加属性，会破坏很多依赖__dict__的库（如dataclasses、pydantic的部分功能），需谨慎权衡。
8. 类的现代替代方案：@dataclass、NamedTuple与TypedDict
Python 3.7+ 引入了更简洁的类定义方式，它们不是要取代传统类，而是针对特定场景提供更优解。
8.1@dataclass：为数据容器而生
当你写一个类，主要目的就是存几个字段、支持相等比较、能打印、能序列化，@dataclass就是为你定制的：
from dataclasses import dataclass, field from datetime import datetime @dataclass class Book: title: str author: str isbn: str published_date: datetime = field(default_factory=datetime.now) tags: list[str] = field(default_factory=list) def is_recent(self) -> bool: return (datetime.now() - self.published_date).days < 30 book = Book("Python Crash Course", "Eric Matthes", "978-1-59327-603-4") print(book) # Book(title='Python Crash Course', author='Eric Matthes', ...) print(book.is_recent()) # True or False@dataclass自动生成__init__、__repr__、__eq__等方法。field()提供精细控制，如default_factory用于可变默认值（避免列表共享陷阱）。
8.2NamedTuple：不可变的轻量级数据结构
如果数据一旦创建就永不改变，NamedTuple比@dataclass更轻、更快、内存更省：
from typing import NamedTuple class Coordinate(NamedTuple): x: float y: float z: float = 0.0 # 支持默认值 coord = Coordinate(1.0, 2.0) print(coord.x, coord.y) # 1.0 2.0 # coord.x = 3.0 # AttributeError: can't set attributeNamedTuple实例是不可变的，且是tuple的子类，因此天然支持解包、哈希、作为字典键。
8.3TypedDict：字典的类型提示增强版
当你必须用字典（比如解析JSON），但又想要IDE的类型提示和运行时的部分检查，TypedDict是桥梁：
from typing import TypedDict class UserDict(TypedDict): name: str age: int email: str user: UserDict = {"name": "Alice", "age": 30, "email": "alice@example.com"} # user["phone"] = "123" # IDE会警告：Extra key 'phone' for TypedDictTypedDict在运行时只是普通dict，但为类型检查器（如mypy）提供了结构信息。
选择指南：
- 需要可变、有方法、有复杂逻辑→ 用传统
class- 主要是存数据、少逻辑、要便捷→ 用
@dataclass- 数据绝对不可变、追求极致性能→ 用
NamedTuple- 必须用字典格式、但要类型安全→ 用
TypedDict
9. 实战避坑：从真实项目中挖出的7个致命陷阱
这些不是教科书里的理论错误，而是我在Code Review中亲手揪出、导致线上事故的真问题。
9.1 陷阱一：__del__不是析构函数，别指望它准时执行
class FileHandler: def __init__(self, path): self.path = path self.file = open(path, 'w') def __del__(self): # ❌ 危险！__del__ 调用时机不确定，可能在程序退出时才执行 self.file.close() # 如果文件很大，可能已丢失数据__del__由垃圾回收器调用，时机不可控。正确做法是实现上下文管理器：
class FileHandler: def __init__(self, path): self.path = path self.file = None def __enter__(self): self.file = open(self.path, 'w') return self def __exit__(self, exc_type, exc_val, exc_tb): if self.file: self.file.close() # 使用 with FileHandler("log.txt") as f: f.file.write("Hello") # 自动关闭，无论是否异常9.2 陷阱二：循环引用导致内存泄漏
class Parent: def __init__(self): self.children = [] def add_child(self, child): self.children.append(child) child.parent = self # ❌ 创建循环引用 class Child: def __init__(self): self.parent = None # 这样创建后，Parent 和 Child 互相引用，GC可能无法及时回收 p = Parent() c = Child() p.add_child(c) # del p, c # 内存可能不释放解决方案：用weakref打破循环：
import weakref class Parent: def __init__(self): self.children = [] def add_child(self, child): self.children.append(child) child.parent_ref = weakref.ref(self) # 弱引用，不增加引用计数 class Child: def __init__(self): self.parent_ref = None @property def parent(self): return self.parent_ref() if self.parent_ref else None9.3 陷阱三：is和==混用
a = [1, 2, 3] b = [1, 2, 3] print(a == b) # True —— 内容相等 print(a is b) # False —— 不是同一个对象 # 但小整数和短字符串有缓存 x = 100 y = 100 print(x is y) # True —— Python缓存了-5到256的整数永远用==比较值，用is比较身份（如if x is None:）。依赖is比较数值是定时炸弹。
9.4 陷阱四：类属性被意外修改
class Cache: data = {} # 类属性，所有实例共享！ def set(self, key, value): self.data[key] = value # ❌ 所有实例都在改同一个字典 # 正确：在 __init__ 中初始化实例属性 class Cache: def __init__(self): self.data = {} # 每个实例独享9.5 陷阱五：super()在多重继承中漏掉
class A: def method(self): print("A.method") class B(A): def method(self): print("B.method") super().method() # OK class C(A): def method(self): print("C.method") super().method() # OK class D(B, C): def method(self): print("D.method") super().method() # 会按 MRO 调用 B.method → C.method → A.method # 但如果 C 忘了 super() class C_Broken(A): def method(self): print("C.method") # 忘了 super().method()！此时D().method()会停在C_Broken.method()，不再调用A.method()。用mypy或pylint开启super-call检查可避免。
9.6 陷阱六：__init__中调用可被重写的方法
class Base: def __init__(self
