鸭子类型,反射

什么是鸭子类型

• 鸭子模型（Duck Typing）是编程语言类型检查中的一种设计思想，核心原则是：“如果一个东西走路像鸭子，叫起来像鸭子，那么它就是鸭子”。(是一种编程语言风格，不是一个真实存在的约束关系,而是一种普遍的规范)
• 简单来说，它不通过对象的 “类型”（如继承关系、接口实现）来判断其是否能执行某个操作，而是通过对象是否具备所需的方法、属性或行为来决定。只要对象拥有特定的行为（方法 / 属性），就可以被当作 “对应类型” 来使用，无需显式声明继承或实现接口。

举个例子理解：

假设我们需要一个 “能叫的动物” 功能，传统静态类型语言（如 Java）可能需要先定义一个Animal接口，要求实现quack()方法，然后让Duck、Goose等类实现该接口，才能被调用。
而在支持鸭子模型的动态类型语言（如 Python）中，无需定义接口，只要一个对象有quack()方法，就可以直接传入 “叫的功能” 中使用：

def make_sound(animal):
    animal.quack()  # 只要animal有quack()方法，就能执行

class Duck:
    def quack(self):
        print("嘎嘎嘎")

class Goose:
    def quack(self):  # 鹅也实现了quack()，尽管和鸭子无关
        print("咯咯咯")

class Car:
    pass  # 没有quack()方法

# 测试
duck = Duck()
goose = Goose()
car = Car()

make_sound(duck)   # 输出：嘎嘎嘎（鸭子能叫）
make_sound(goose)  # 输出：咯咯咯（鹅也能叫，被当作“能叫的动物”）
make_sound(car)    # 报错：'Car' object has no attribute 'quack'（汽车不能叫，不被接受）

• 这里，Goose（鹅）虽然不是Duck（鸭子）的子类，但因为有quack()方法，依然能被make_sound函数处理 —— 这就是鸭子模型的核心：关注 “行为” 而非 “类型本身”。

特点与适用场景：

灵活性高：无需严格的继承或接口约束，降低代码耦合，方便扩展（新增一个 “能叫的动物” 只需实现quack()即可）。
动态类型语言常见：如 Python、JavaScript、Ruby 等，依赖运行时检查对象是否具备所需行为。
优点： 代码简洁、复用性强，适合快速开发。
缺点： 缺乏编译时类型校验，可能在运行时才发现 “缺少方法” 的错误（如上述Car的例子）。

与传统类型检查的区别：

• 传统静态类型（如 Java、C#）依赖 “显式类型声明”（继承、接口实现），编译时就会检查类型是否匹配；而鸭子模型依赖 “隐式行为匹配”，运行时才检查是否具备所需方法 / 属性。

---

反射

反射（Reflection）指程序在运行时可以动态地访问、检测和修改对象的属性、方法或模块等信息的能力。简单说，就是通过字符串来操作对象的成员（属性、方法），而不需要在代码中硬编码具体的名称。

为什么需要反射？

当我们不知道对象具体有哪些属性/方法，或者需要根据运行时的动态输入（如用户输入、配置文件）来操作对象时，反射能极大提高代码的灵活性。例如：框架中根据配置字符串动态加载模块、根据用户输入调用不同的方法等。

反射方法

函数	作用	示例
hasattr(obj, name)	判断对象obj是否有名称为name的属性 / 方法（name是字符串）	hasattr(person, 'age') # 判断 person 是否有 age 属性
getattr(obj, name, default)	获取对象obj中名称为name的属性 / 方法；若不存在，返回default（默认报错）	getattr(person, 'say_hello') # 获取 say_hello 方法
setattr(obj, name, value)	给对象obj设置名称为name的属性，值为value	setattr(person, 'gender', 'male') # 给 person 添加 gender 属性
delattr(obj, name)	删除对象obj中名称为name的属性	delattr(person, 'age') # 删除 person 的 age 属性

示例：用反射操作对象

• 假设我们有一个Person类，通过反射动态操作它的实例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def say_hello(self):
        print(f"Hello, I'm {self.name}")

# 创建实例
p = Person("Alice", 20)

# 1. 判断是否有某个属性/方法
print(hasattr(p, "name"))  # True（有name属性）
print(hasattr(p, "say_hello"))  # True（有say_hello方法）
print(hasattr(p, "gender"))  # False（无gender属性）

# 2. 获取属性/方法
name = getattr(p, "name")
print(name)  # Alice

say_func = getattr(p, "say_hello")
say_func()  # 调用方法，输出：Hello, I'm Alice

# 若属性不存在，返回默认值
gender = getattr(p, "gender", "unknown")
print(gender)  # unknown

# 3. 设置属性
setattr(p, "gender", "female")
print(p.gender)  # female（成功添加属性）

setattr(p, "age", 21)  # 修改已有属性
print(p.age)  # 21

# 4. 删除属性
delattr(p, "age")
print(hasattr(p, "age"))  # False（age已被删除）

反射的进阶：动态操作模块

• 除了对象，反射还能动态加载模块、操作模块中的成员。例如，根据字符串导入模块并调用其中的函数：

# 假设有一个模块 demo.py，内容如下：
# def add(a, b):
#     return a + b

# 动态导入模块（通过字符串）
module_name = "demo"
demo_module = __import__(module_name)  # 等价于 import demo

# 动态调用模块中的add函数
func_name = "add"
if hasattr(demo_module, func_name):
    add_func = getattr(demo_module, func_name)
    print(add_func(2, 3))  # 5

反射的应用场景

1. 框架开发：如 Django 的视图函数路由映射（通过 URL 字符串匹配视图函数）、Flask 的路由注册等，大量依赖反射动态加载组件。
2. 配置驱动开发：根据配置文件（如 JSON）中的字符串，动态实例化类、调用方法（无需修改代码，仅改配置）。
3. 插件系统：动态加载用户编写的插件模块，调用插件中的指定方法。
4. 序列化 / 反序列化：动态获取对象属性并转换为字典（如 ORM 框架中对象转 SQL 的过程）。

优点： 极大提高代码灵活性和动态性，降低耦合度，适合复杂场景（如框架、插件系统）。
缺点：
动态操作绕过了静态检查，可能在运行时才暴露错误（如拼写错误导致属性不存在）。
过度使用会降低代码可读性（动态逻辑比直接调用更难理解）。