别再用if-else堆代码了！这才是Python面向对象的正确打开方式

写Python久了，你会发现一个现象：项目初期，用函数和if-else堆砌功能，开发速度飞快。但随着需求迭代，代码逐渐变成了“屎山”——加一个功能要改十几个地方，改一个bug引出三个新bug。

这时候，你可能需要重新审视你的代码设计。

面向对象编程（OOP）绝不是简单的“把函数塞进类里”。用好它的核心武器——多态和组合，能让你从“搬砖工人”蜕变为“代码架构师”。

1. 消灭if-else，用多态说话

我们先看一个“反面教材”。假设你需要一个记录日志的类，支持输出到文件、Redis和Elasticsearch：

class FancyLogger:
    def __init__(self, output_type):
        self.output_type = output_type

    def log(self, message):
        if self.output_type == "file":
            # 写文件逻辑...
            pass
        elif self.output_type == "redis":
            # 写Redis逻辑...
            pass
        elif self.output_type == "es":
            # 写ES逻辑...
            pass
        else:
            raise ValueError("不支持的输出类型")

这段代码的问题在于，它违背了开闭原则（对扩展开放，对修改封闭）。每增加一种日志输出方式（比如Kafka），你都得跑到这个类里改log方法。这会带来两个坏处：

风险集中：修改成熟的老代码，极有可能引入新Bug。
类无限膨胀：随着功能增加，这个类会变得臃肿不堪。

怎么改？用多态（Polymorphism）。

多态的核心思想是：针对“行为”编程，而不是针对“类型”编程。“写入日志”是一个行为，我们可以把这个行为抽象成独立的“写入器”（Writer）。

# 1. 定义统一的写入器接口（在Python里，鸭子类型就够了）
class FileWriter:
    def write(self, message):
        print(f"写入文件: {message}")

class RedisWriter:
    def __init__(self, max_length=1024):
        self.max_length = max_length

    def write(self, message):
        # Redis可能对长度有限制
        print(f"写入Redis: {message[:self.max_length]}")

# 2. 重构后的日志类
class FancyLogger:
    def __init__(self, writer):
        self._writer = writer  # 注入写入器

    def log(self, message):
        self._writer.write(message)  # 委托给写入器

改造后，世界变得清净了。

FancyLogger只负责日志的格式和调用时机，再也不需要关心日志写到哪里了。
想新增Kafka日志？写个KafkaWriter传进去就行了，FancyLogger一行代码都不用动。

这就是多态的魅力：把“变化”封装起来，让“不变”的部分稳定运行。

2. 组合优于继承

很多初学者一谈OOP就想到继承，恨不得把所有相似的功能都抽象出一个父类。但继承是一把双刃剑，子类与父类之间存在强耦合，父类的一个小改动，可能导致所有子类都出问题。

回过头看上面的日志例子。如果不用组合（注入Writer），而是用继承：

1 2	class FileLogger(Logger): ... class RedisLogger(Logger): ...

这会导致类层次结构极其僵硬。假如我想同时记录到文件和Redis呢？你就陷入“多重继承”的泥潭了。

组合（Composition） 的思路是：对象有什么（Has-A），而不是是什么（Is-A）。
FancyLogger有一个Writer，它不关心这个Writer具体是干嘛的，只要你会write就行。这种委托模式让代码的灵活度瞬间提升了一个维度。

3. 元类太遥远？试试这个平替：`__init_subclass__`

元类（Metaclass）是Python里的“黑魔法”，它能拦截类的创建过程，实现一些高级功能（如ORM框架）。但在日常开发中，杀鸡焉用牛刀？而且元类非常难写，稍有不慎就会让代码变得晦涩难懂。

Python 3.6引入了一个非常人性化的钩子方法：__init_subclass__。

它的作用很单纯：当一个类被继承时，这个方法会被自动调用。 用它来实现“自动注册子类”这种功能，简直完美。

比如，我们开发一个游戏，需要将所有怪物子类自动注册到怪物工厂中：

class Monster:
    # 怪物注册表
    registry = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        # 子类定义时，自动将其加入注册表
        Monster.registry[cls.__name__] = cls
        print(f"发现新怪物: {cls.__name__}")

class Goblin(Monster):
    pass

class Dragon(Monster):
    pass

# 测试
print(Monster.registry)
# 输出: {'Goblin': <class '__main__.Goblin'>, 'Dragon': <class '__main__.Dragon'>}

有了这个技巧，你再也不用在工厂里手动维护一份MAP列表了，每写一个子类，它都会“自动报名”！

4. 别为了面向对象而面向对象

Python虽然是面向对象的语言，但它也是一门“多范式”语言。不必为了追求纯粹的OOP，而把简单的逻辑搞得过于复杂。

外观模式（Facade）：如果某个类使用起来太复杂（比如需要初始化一大堆参数），写一个函数把它包裹起来，对外提供最简单的接口。就像requests库，虽然底层有复杂的Session对象，但你最常用的是requests.get()这个函数。
预绑定方法：如果某个类只需要一个全局实例（单例），没必要用__new__实现单例模式。直接创建一个模块，在模块里定义一个全局对象，然后把对象的方法赋值给模块级的函数，调用者就像调用普通函数一样简单。Python的模块本身就是天然的“单例”容器。

总结一下

面向对象编程的核心，不在于你用了多少设计模式，也不在于你的类层级有多深。它的本质是管理复杂度。