“如果你也有这样的困惑——写脚本很溜，一看到框架源码就头大，那问题大概率出在：你还没有真正理解面向对象（OOP）。
很多人学Python都是从函数和脚本入门的，但当你开始接触FastAPI、Pandas、LangChain这些框架时，会发现一切都变成了"类"和"对象"。今天这篇，咱们就把OOP这块硬骨头啃下来。我尽量用大白话讲，保证你看完能懂，也希望大家能从"调包侠"进阶到"看得懂源码"的段位。”
1.1 类与对象：图纸和房子的关系
先记住一句话：类就是设计图，对象就是按图造出来的房子。
概念 | 写法 | 说明 |
类 | class Dog:
| 定义了一种类型 |
实例化 | dog = Dog("旺财")
| 造出一个具体的对象 |
实例属性 | self.name = "旺财"
| 每个对象自己的数据 |
实例方法 | def bark(self):
| 对象能做的事情 |
构造方法 | def __init__(self, ...):
| 创建对象时自动调用，用来初始化 |
self 到底是什么？简单说，self就是"当前这个对象自己"。当你调用 dog.bark() 时，Python 偷偷把 dog 传给了 bark 方法的第一个参数，所以方法里才写 self。
classDog:def__init__(self, name):self.name = name # 实例属性defbark(self):return f"{self.name}：汪汪！"dog = Dog("旺财")print(dog.bark()) # 旺财：汪汪！
其实你也可以写成 Dog.bark(dog)，效果一样。理解了这一点，你就看懂了方法调用的本质。
类属性 vs 实例属性：共享的和私有的
class Dog: species = "Canis lupus" # 类属性，所有狗共享 count = 0 # 类属性，可用来计数 def __init__(self, name): self.name = name # 实例属性，每只狗独立 Dog.count += 1 # 修改类属性用类名
记住这个黄金规则：
这是新手最容易踩的坑，没有之一。
封装与 @property：把方法包装成属性
Python 里没有真正的"私有"，全靠约定：
@property 的作用，就是把一个方法伪装成属性，让你读写的时候能加校验逻辑：
class Account: def __init__(self, balance): self.balance = balance # 这里会调用下面的 setter！ @property def balance(self): return self._balance @balance.setter def balance(self, value): if value < 0: raise ValueError("余额不能为负") self._balance = value
注意一个反直觉但超有用的点：__init__ 里写 self.balance = balance，会顺带触发 setter 的校验，所以从创建对象开始就安全了。
类属性 vs 实例属性：共享的和私有的
继承：子类复用父类的东西。class Cat(Animal): 就是猫继承自动物。
super()：专门用来调用父类的方法（尤其是 __init__）。
多态：只要你有同名方法，就能用同一个接口调用。Python 的多态不靠继承，靠的是"有没有这个方法"（鸭子类型）。
class Animal: def __init__(self, name): self.name = name def speak(self): return "..."class Dog(Animal): def speak(self): return f"{self.name}：汪汪"class Cat(Animal): def speak(self): return f"{self.name}：喵喵"def make_noise(a:Animal):
print(a.speak())make_noise(Dog("旺财")) # 旺财：汪汪make_noise(Cat("咪咪")) # 咪咪：喵喵
多继承时，Python 用 MRO（方法解析顺序） 决定先找谁，可以看 ClassName.__mro__ 查看。
类属性 vs 实例属性：共享的和私有的
抽象基类（ABC）用来强制子类必须实现某些方法，这是写框架的利器：
from abc import ABC, abstractmethodclassWorker(ABC): @abstractmethoddefrun(self): ... @abstractmethoddefname(self) -> str: ...# Worker() # 报错！不能实例化抽象类classCrawler(Worker):defrun(self):return"抓取中"defname(self) -> str:return"crawler"
Crawler().run() # OK，所有抽象方法都实现了
LLM 里的 BaseChatModel、BaseEmbeddings 就是这个套路——规定你要实现哪些方法。
魔法方法：让对象"活"起来
这些 __xxx__ 方法决定了对象在 Python 语法里的行为，比如：
魔法方法 | 触发方式 | 用途 |
__init__
| X()
| 初始化 |
__str__
| print(x) / str(x)
| 给人看 |
__repr__
| repr(x) / 直接显示
| 给开发者看，最好能重建对象 |
__eq____hash__
| ==x in set
| 比较/可哈希 |
__lt__ 等
| <>sorted
| 排序 |
__call__
| x(...)
| 让对象像函数一样调用（LCEL链） |
__len__
| len(x)
| 容器协议 |
__getitem__
| x[k]
| 下标访问 |
__contains__
| k in x
| 成员判断 |
__iter____next__
| for i in x
| 迭代协议 |
__enter____exit__
| with x:
| 上下文管理 |
__add__ 等
| x + y
| 运算符重载 |
一句话：自定义容器、配置或数据类时，实现 __repr__ 绝对不亏。
静态方法 / 类方法：工具和工厂
实例方法（默认）：第一个参数 self，访问实例数据。
类方法 @classmethod：第一个参数 cls（类本身），常用作备选构造函数（工厂方法）。
静态方法 @staticmethod：逻辑上属于这个类，但不依赖实例数据。
classUser:def__init__(self, name, age):self.name, self.age = name, age @classmethoddeffrom_dict(cls, d):return cls(d["name"], d["age"]) # 工厂方法 @staticmethoddefis_adult(age):return age >= 18# 工具函数
单例一般用模块级变量就搞定了，没必要整花活。
静态方法 / 类方法：工具和工厂
dataclass 自动帮你生成 __init__、__repr__、__eq__，是 Pydantic 模型的精神前身：
from dataclasses import dataclass, field@dataclassclassPoint: x: float y: float tags: list[str] = field(default_factory=list) # 可变默认值必须用 fieldp = Point(1, 2)print(p) # Point(x=1.0, y=2.0, tags=[])
重点：可变默认值（list/dict）绝对不能写 = []，必须 field(default_factory=list)，不然所有实例会共享同一份数据。
静态方法 / 类方法：工具和工厂
"优先组合对象，而非继承类" —— GoF 设计模式
class Engine: def start(self): return "引擎启动"class Car: def __init__(self, engine:Engine): # 组合：把 Engine 注入进来 self.engine = engine def start(self): return self.engine.start()Car(Engine()).start()
LLM 里的 Agent 拥有 llm、tools、memory，就是组合；而不是 class Agent(LLM) 这种继承。
小结：一张表记住今天的核心
概念 | 后端 | 数据分析 | LLM/Agent |
class/__init__
| 路由依赖类、配置类 | DataFrame 本质
| 所有组件都是类 |
__call__
| 中间件 | — | LCEL 链可被 () 调用 |
@property
| 配置只读字段 | .iloc/.loc 属性化
| .tokens 访问器
|
继承/ABC | BaseModel 基类
| — | BaseChatModel 等 ABC
|
dataclass
| 配置项 | — | Pydantic 的近亲 |
组合 | 依赖注入 | — | Agent = llm+tools+memory |
动手练一练
光看是学不会的，赶紧动起来：
运行配套的 01_类与对象基础.py，改改参数，做做末尾练习。
依次跑完 02_属性与封装.py 到 08_组合vs继承.py。
卡壳了就看 练习答案.py。
一句话总结：OOP 不是语法，而是一种"用对象思考"的编程世界观。 理解了它，你再看 FastAPI 的路由、Pandas 的 DataFrame、LangChain 的 Agent，都会觉得"原来如此"。
需要练习题的小伙伴，可以一键三连，后续我会将资料整理到网盘分享给大家。制作不易，您的赞赏支持就是我最大的动力
