🐍 Python面向对象奇技淫巧：从鸭子类型到魔法方法的奇幻之旅

Python的面向对象编程就像一场魔法秀——看似简单，实则暗藏玄机。今天，就让我们一起揭开这些魔法背后的秘密！

🦆 多态与鸭子类型：Python的“形式主义”

多态：一个接口，多种实现

想象一下，你是个健身教练，你的口号是：“不管你是瑜伽爱好者、举重选手还是跑步达人，只要你能运动()，就是我的学员！”

Python中的多态正是如此：

# 多种类型，同一个接口
print(len("Hello"))      # 字符串：5
print(len([1, 2, 3]))    # 列表：3
print(len({"a": 1}))     # 字典：1

# 自定义类也能享受len()的待遇
class Playlist:
    def __init__(self, songs):
        self.songs = songs
    
    def __len__(self):
        return len(self.songs)  # 实现__len__就能用len()了！

my_playlist = Playlist(["歌1", "歌2", "歌3"])
print(f"播放列表有 {len(my_playlist)} 首歌")  # 输出：播放列表有 3 首歌

鸭子类型：Python的实用主义哲学

鸭子类型的核心思想：“如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子”。

让我们看看如何”孵化”几只不同品种的”鸭子”：

class Python:
    """Python语言鸭"""
    def language(self):
        print("我是Python，我有迷人的缩进！")

class Golang:
    """Go语言鸭"""
    def language(self):
        print("我是Golang，我并发超快！")

class Shell:
    """Shell脚本鸭"""
    def language(self):
        print("我是Shell，我是系统管理员的好朋友！")

def 让鸭子说话(鸭子):
    """我们不关心你是什么类型，只要你会说话！"""
    鸭子.language()

# 测试我们的鸭子们
python_鸭 = Python()
golang_鸭 = Golang()
shell_鸭 = Shell()

让鸭子说话(python_鸭)  # 输出：我是Python，我有迷人的缩进！
让鸭子说话(golang_鸭)  # 输出：我是Golang，我并发超快！
让鸭子说话(shell_鸭)   # 输出：我是Shell，我是系统管理员的好朋友！

# 甚至临时造一只"鸭子"！
class 临时鸭:
    def language(self):
        print("我是临时鸭，我现学现卖！")

让鸭子说话(临时鸭())  # 输出：我是临时鸭，我现学现卖！

鸭子类型的精髓：Python不检查对象的类型，只关心对象有没有需要的方法。这就像招聘时不看学历（类型），只看能力（方法）！

🔒 私有属性与`slots`：Python的”隐私保护”与”内存优化”

私有属性：Python的”名字游戏”

Python没有真正的私有变量，但它玩了一个聪明的”改名游戏”：

class 秘密特工:
    def __init__(self, 代号, 真实姓名):
        self.代号 = 代号          # 公开属性
        self.__真实姓名 = 真实姓名  # "私有"属性（其实只是改了名）
    
    def 获取真实姓名(self):
        return self.__真实姓名
    
    def 设置真实姓名(self, 新姓名):
        if self.__验证姓名(新姓名):
            self.__真实姓名 = 新姓名
    
    def __验证姓名(self, 姓名):  # 私有方法
        return len(姓名) > 0

# 创建特工
特工007 = 秘密特工("007", "詹姆斯·邦德")

print(特工007.代号)           # 输出：007
print(特工007.获取真实姓名())   # 输出：詹姆斯·邦德

# 尝试访问私有属性（会失败）
try:
    print(特工007.__真实姓名)  # 报错：AttributeError
except AttributeError as e:
    print(f"访问失败：{e}")

# 但是...Python的"隐私"是可以破解的！
print(特工007._秘密特工__真实姓名)  # 输出：詹姆斯·邦德
# 注意：双下划线属性被改名为 _类名__属性名

重要提示：Python的私有只是约定，不是强制。单下划线_属性表示”请勿直接访问”，双下划线__属性会触发名字改编。

`slots`：给类的”购物狂”属性加上预算

默认情况下，Python对象像是有无限额度的信用卡，可以随时添加属性。但有时我们需要限制一下：

class 普通用户:
    """这个类可以随意添加属性"""
    def __init__(self, 名字):
        self.名字 = 名字

用户1 = 普通用户("张三")
用户1.年龄 = 25      # 可以！
用户1.职业 = "程序员" # 可以！
用户1.爱好 = "打游戏" # 可以！
print(用户1.__dict__)  # 查看所有属性

class 节约内存用户:
    """使用__slots__限制属性，节省内存"""
    __slots__ = ["名字", "年龄"]  # 只能有这两个属性
    
    def __init__(self, 名字, 年龄):
        self.名字 = 名字
        self.年龄 = 年龄

用户2 = 节约内存用户("李四", 30)
print(用户2.名字)  # 输出：李四

try:
    用户2.职业 = "教师"  # 报错：AttributeError
except AttributeError as e:
    print(f"添加属性失败：{e}")

# __slots__的优势：
# 1. 节省内存（不创建__dict__）
# 2. 更快属性访问
# 3. 防止拼写错误创建新属性

使用场景：当你有数百万个对象时，__slots__可以显著减少内存使用。

✨ 魔法方法：Python的”幕后操纵者”

`new`和`del`：对象的生与死

class 定制字符串(str):
    """创建时自动大写的字符串"""
    
    def __new__(cls, 内容):
        """__new__是真正的构造器，创建实例"""
        print(f"正在创建字符串对象，原内容：{内容}")
        
        # 把内容转为大写
        大写内容 = 内容.upper() if 内容 else 内容
        
        # 调用父类的__new__创建实例
        return super().__new__(cls, 大写内容)
    
    def __init__(self, 内容):
        """__init__是初始化器，初始化已创建的对象"""
        print(f"初始化字符串：{self}")
        self.原始内容 = 内容
    
    def __del__(self):
        """对象被销毁时调用（时机不确定，慎用！）"""
        print(f"📣 对象 '{self}' 即将被回收，永别了！")

# 测试
我的字符串 = 定制字符串("hello world")
print(f"最终结果：{我的字符串}")  # 输出：HELLO WORLD
print(f"原始内容：{我的字符串.原始内容}")  # 输出：hello world

# 删除引用
del 我的字符串
# 输出：📣 对象 'HELLO WORLD' 即将被回收，永别了！

重要提醒：__del__不是析构函数！它的调用时机由垃圾回收器决定，不要依赖它做重要清理工作！

运算魔法方法：让对象支持数学运算

class 智能数字:
    """一个支持各种运算的智能数字"""
    
    def __init__(self, 值):
        self.值 = 值
    
    def __add__(self, 其他):
        """加法：+ 运算符"""
        if isinstance(其他, 智能数字):
            return 智能数字(self.值 + 其他.值)
        return 智能数字(self.值 + 其他)
    
    def __sub__(self, 其他):
        """减法：- 运算符"""
        return 智能数字(self.值 - (其他.值 if isinstance(其他, 智能数字) else 其他))
    
    def __mul__(self, 其他):
        """乘法：* 运算符"""
        return 智能数字(self.值 * (其他.值 if isinstance(其他, 智能数字) else 其他))
    
    def __str__(self):
        return f"智能数字({self.值})"
    
    def __repr__(self):
        return f"智能数字({self.值})"

# 测试运算
数字1 = 智能数字(10)
数字2 = 智能数字(5)

print(数字1 + 数字2)    # 输出：智能数字(15)
print(数字1 - 数字2)    # 输出：智能数字(5)
print(数字1 * 数字2)    # 输出：智能数字(50)
print(数字1 + 3)        # 输出：智能数字(13)

# 其他有用的运算魔法方法：
# __lt__: <    __le__: <=
# __eq__: ==   __ne__: !=
# __gt__: >    __ge__: >=
# __radd__: 反向加法（当左操作数不支持加法时）
# __iadd__: += 原地加法

🔍 属性访问的魔法方法：Python的属性”守门人”

属性访问的完整流程

class 智能用户:
    """一个智能的用户类，控制属性访问"""
    
    def __init__(self, 姓名, 年龄):
        self.姓名 = 姓名
        self.__年龄 = 年龄  # 私有属性
    
    def __getattribute__(self, 属性名):
        """访问任何属性时首先调用（优先级最高）"""
        print(f"🔍 __getattribute__被调用，尝试访问属性：{属性名}")
        
        # 特殊处理：访问"密码"属性时返回"********"
        if 属性名 == "密码":
            print("⚠️  密码访问被重定向")
            return "********"
        
        # 否则让父类处理
        return super().__getattribute__(属性名)
    
    def __getattr__(self, 属性名):
        """访问不存在的属性时调用（最后防线）"""
        print(f"🆕 __getattr__被调用，属性 {属性名} 不存在")
        
        # 动态创建默认值
        if 属性名.startswith("默认_"):
            默认值 = 属性名[3:]  # 去掉"默认_"前缀
            return f"这是默认值：{默认值}"
        
        # 或者抛出错误
        raise AttributeError(f"'{self.__class__.__name__}' 没有属性 '{属性名}'")
    
    def __setattr__(self, 属性名, 值):
        """设置属性时调用"""
        print(f"✏️  __setattr__被调用：设置 {属性名} = {值}")
        
        # 验证年龄范围
        if 属性名 == "_智能用户__年龄":  # 注意私有属性的改名！
            if not 0 <= 值 <= 150:
                raise ValueError(f"年龄 {值} 无效！必须在0-150之间")
        
        # 禁止设置"系统级"属性
        if 属性名 == "系统级":
            raise AttributeError("禁止设置系统级属性！")
        
        # 调用父类的__setattr__
        super().__setattr__(属性名, 值)
    
    def __delattr__(self, 属性名):
        """删除属性时调用"""
        print(f"🗑️  __delattr__被调用：删除属性 {属性名}")
        
        # 禁止删除姓名属性
        if 属性名 == "姓名":
            raise AttributeError("姓名是重要属性，不能删除！")
        
        # 调用父类的__delattr__
        super().__delattr__(属性名)

# 测试属性访问控制
用户 = 智能用户("张三", 25)

print("\n=== 测试正常属性访问 ===")
print(用户.姓名)  # 输出：张三

print("\n=== 测试不存在的属性 ===")
try:
    print(用户.不存在的属性)
except AttributeError as e:
    print(f"错误：{e}")

print(用户.默认_地址)  # 输出：这是默认值：地址

print("\n=== 测试属性设置验证 ===")
try:
    用户.年龄 = 200  # 注意：实际访问的是 _智能用户__年龄
except ValueError as e:
    print(f"验证失败：{e}")

print("\n=== 测试属性删除限制 ===")
try:
    del 用户.姓名
except AttributeError as e:
    print(f"删除失败：{e}")

# 使用内置函数操作属性
print("\n=== 使用内置函数 ===")
print(hasattr(用户, "姓名"))      # 输出：True
print(getattr(用户, "姓名", "默认姓名"))  # 输出：张三
setattr(用户, "新属性", "新值")    # 添加新属性
print(用户.新属性)                # 输出：新值

属性访问流程图解

访问 对象.属性 时的完整流程：
1. 首先调用 __getattribute__(属性名)
   ↓
2. 如果属性存在，返回属性值
   ↓
3. 如果属性不存在，调用 __getattr__(属性名)
   ↓
4. 如果 __getattr__ 也没处理，抛出 AttributeError

🎯 总结与最佳实践

特性	用途	最佳实践
多态与鸭子类型	提高代码灵活性和复用性	关注接口（方法），而不是类型
私有属性	实现封装和信息隐藏	使用单下划线约定，必要时用双下划线
`__slots__`	优化内存使用	在需要创建大量实例时使用
`__new__`	控制实例创建过程	用于不可变类型或单例模式
`__del__`	对象清理（谨慎使用）	不要依赖它做关键清理，用上下文管理器替代
运算魔法方法	让自定义类型支持运算符	实现完整的运算符重载集合
属性访问魔法	控制属性访问、设置、删除	用于数据验证、惰性计算、代理模式