🐍 Python 类的使用指南：从“语法糖”到“架构师思维”

摘要：在 Python 中，class 不仅仅是创建对象的模板，更是组织代码、封装逻辑和构建系统的核心工具。本文剥离晦涩的理论，通过 5 个关键维度，带你掌握 Python 类的正确打开方式：从属性管理的“君子协定”，到方法选择的“黄金法则”，再到避免继承陷阱的“组合艺术”。

01. 属性的“潜规则”：公开、私有与 `dict`

在 Java 或 Go 中，访问控制是强制的；而在 Python 中，它更像是一种**“君子协定”**。

🔒 双下划线 `__bar` vs 单下划线 `_bar`

单下划线 _bar：这是 Pythonic 的推荐做法。它告诉调用者：“这是内部实现，请别直接碰。”但它不阻止你访问。
双下划线 __bar：这不是真正的私有，而是名称修饰（Name Mangling）。解释器会将其重命名为 _ClassName__bar。
- 用途：防止子类意外覆盖父类属性。
- 误区：不要用它来隐藏数据，因为 _Foo__bar 依然可以被外部访问。

class User:
    def __init__(self, name):
        self._name = name       # 约定俗成的私有
        self.__secret = "pwd"   # 名称修饰，变成 _User__secret

u = User("Alice")
print(u._name)      # Alice (可以访问，但不建议)
# print(u.__secret) # AttributeError
print(u._User__secret) # pwd (依然可以访问，但很丑陋)

📦 实例的秘密仓库：`dict`

每个实例都有一个 __dict__ 字典，存储着它的所有动态属性。

常规操作：obj.attr = value（触发 __setattr__ 校验）。
黑客操作：obj.__dict__.update({'attr': value})（绕过校验，直接修改内存）。
- 场景：高性能序列化/反序列化，或元编程。日常业务中请慎用，因为它会破坏封装性。

02. 方法三剑客：何时用 `self`，何时用 `cls`？

很多初学者分不清普通方法、类方法和静态方法。记住这个决策树：

方法类型	装饰器	第一个参数	核心用途	示例
实例方法	无	`self`	操作实例状态	`user.save()`
类方法	`@classmethod`	`cls`	工厂模式，创建实例前处理类级别逻辑	`User.from_json(data)`
静态方法	`@staticmethod`	无	工具函数，与类状态无关，仅为了命名空间归类	`User.validate_email(email)`

💡 最佳实践：
如果一个方法既不需要 self 也不需要 cls，优先考虑将其移出类，作为模块级别的普通函数。除非它与类的语义紧密相关（如验证逻辑），才保留为静态方法。

03. 属性 vs 方法：`@property` 的艺术

属性代表状态（名词），方法代表行为（动词）。@property 允许你用方法的逻辑来实现属性的访问。

✅ 适合用 `@property` 的场景

计算衍生数据（如 full_name 由 first_name + last_name 组成）。
简单的格式转换或校验。
关键原则：读取速度要快，用户期望像访问变量一样瞬间得到结果。

❌ 不适合用 `@property` 的场景

涉及网络请求、数据库查询或耗时计算（超过几毫秒）。
有副作用的操作（如发送日志、修改其他状态）。

class FilePath:
    def __init__(self, path):
        self.path = path

    @property
    def basename(self):
        """像属性一样访问，但背后是逻辑"""
        return self.path.rsplit('/', 1)[-1]

    @basename.setter
    def basename(self, name):
        """支持赋值，自动更新路径"""
        parts = self.path.rsplit('/', 1)
        self.path = '/'.join(parts[:-1] + [name])

04. 类型系统：鸭子类型与抽象类的平衡

Python 是鸭子类型语言：“如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子。”

🦆 鸭子类型的优势与局限

优势：极度灵活。任何实现了 read() 方法的对象都可以传给需要文件对象的函数。
局限：接口是隐式的。大型项目中，你很难知道一个对象到底需要实现哪些方法才能被接受。

🏗️ 抽象类（ABC）：给鸭子戴上“项圈”

为了解决隐式接口的问题，Python 引入了 abc.ABC。

强制约束：使用 @abstractmethod 强制子类实现特定方法，否则无法实例化。
结构化子类化：通过 __subclasshook__，即使没有继承关系，只要实现了特定方法，isinstance() 也会返回 True。

from abc import ABC, abstractmethod

class Analyzer(ABC):
    @abstractmethod
    def analyze(self, data):
        pass

class UVAnalyzer(Analyzer):
    def analyze(self, data):
        return len(set(data)) # 必须实现，否则报错

05. 核心警示：继承是把双刃剑，组合才是解药

这是本章最深刻的教训。不要仅仅为了复用代码而使用继承。

📖 故事回顾：UV 统计器的崩溃

工程师小 R 让 Top10CommentsAnalyzer 继承了 UniqueVisitorAnalyzer，以复用日志读取逻辑。
后来，同事修改了父类的日志过滤逻辑（只保留新闻路径），导致子类突然拿不到评论数据，引发线上 Bug。

根本原因：继承建立了强耦合。子类的行为依赖于父类的内部实现，而父类的修改者往往 unaware 子类的存在。

✅ 解药：组合优于继承（Composition over Inheritance）

将“读取日志”和“解析日志”提取为独立的组件，通过组合而非继承来复用。

class LogReader:
    def read_lines(self): ...

class LogParser:
    def parse(self, line): ...

class UniqueVisitorAnalyzer:
    def __init__(self, date):
        self.reader = LogReader(date) # 组合
        self.parser = LogParser()

class Top10CommentsAnalyzer:
    def __init__(self, date):
        self.reader = LogReader(date) # 组合
        self.parser = LogParser()