好的，我们来看一个新的题目。

Python中的函数签名（Function Signature）与inspect.signature动态解析

题目描述

在Python中，函数签名（Function Signature） 是函数或可调用对象接口的正式定义，它包含了参数的名字、类型、默认值以及可能的返回类型注解。理解函数签名对于实现装饰器、依赖注入、参数验证、序列化等高级功能至关重要。本知识点将深入讲解函数签名的构成，以及如何使用inspect.signature模块动态地、以编程方式获取和操作签名信息。

解题过程（知识讲解）

第一步：核心概念——什么是函数签名？

函数签名就像是函数的“身份证”或“蓝图”。它不关心函数体内部如何实现，只精确描述其“外貌”——即调用这个函数时需要提供什么信息（参数），以及它承诺返回什么信息（返回值类型提示）。
一个完整的函数签名包含：

1. 参数（Parameters）：包括位置参数、默认参数、可变参数（*args）、关键字参数（**kwargs）等。
2. 参数注解（Annotations）：参数名后使用 : type 指定的类型提示。
3. 返回类型注解（Return Annotation）：使用 -> type 在参数列表后指定的类型提示。

第二步：如何查看函数签名——inspect.signature()

Python标准库的inspect模块提供了signature()函数，它接受一个可调用对象（如函数、方法、类、实现了__call__方法的对象），并返回一个Signature对象。

示例1：基本用法

import inspect

def example_func(name: str, age: int = 30, *args, **kwargs) -> str:
    """一个示例函数"""
    return f"{name} is {age} years old."

# 获取函数签名
sig = inspect.signature(example_func)
print(sig)
# 输出： (name: str, age: int = 30, *args, **kwargs) -> str

print(sig)的结果就是人类可读的函数签名字符串。

第三步：深入剖析Signature和Parameter对象

inspect.signature()返回的sig是一个Signature对象。这个对象包含了函数的所有参数信息，我们可以进一步探索它。

1. Signature.parameters：有序参数字典

params = sig.parameters
print(type(params))  # <class 'mappingproxy'>
print(params)
# 输出： OrderedDict([('name', <Parameter "name: str">), ('age', <Parameter "age: int = 30">), ('args', <Parameter "*args">), ('kwargs', <Parameter "**kwargs">)])

for param_name, param_obj in params.items():
    print(f"参数名: {param_name}, 参数对象: {param_obj}")

parameters是一个有序映射，键是参数名，值是Parameter对象。这个顺序与函数定义中参数的顺序完全一致。

2. Parameter对象的属性
每个Parameter对象都有几个关键属性，用于精确描述一个参数：

• name：参数的名字（字符串）。
• default：参数的默认值。如果没有默认值，这个属性就是Parameter.empty（一个特殊的哨兵值）。
• annotation：参数的类型注解。如果没有注解，也是Parameter.empty。
• kind：描述参数的类型/位置。这是最关键的属性之一，它是一个_ParameterKind枚举，有以下几种值：
  • POSITIONAL_ONLY：仅限位置参数（在Python中，纯用C实现的函数可能有这种参数，普通Python函数无法定义）。
  • POSITIONAL_OR_KEYWORD：既可以是位置参数，也可以是关键字参数（最常见的类型，如def func(a, b)中的a, b）。
  • VAR_POSITIONAL：可变位置参数（即*args）。
  • KEYWORD_ONLY：仅限关键字参数（出现在*或*args之后，如def func(*, kw)或def func(*args, kw)中的kw）。
  • VAR_KEYWORD：可变关键字参数（即**kwargs）。

示例2：分析Parameter对象

for param_name, param_obj in sig.parameters.items():
    print(f"""
    参数名: {param_name}
    种类(kind): {param_obj.kind}
    注解(annotation): {param_obj.annotation}
    默认值(default): {param_obj.default}
    是否有默认值: {param_obj.default is not inspect.Parameter.empty}
    """)

运行这段代码，你可以清晰地看到name是POSITIONAL_OR_KEYWORD，age有默认值30，args是VAR_POSITIONAL，kwargs是VAR_KEYWORD。

3. Signature.return_annotation：返回类型注解

print(f"返回类型注解: {sig.return_annotation}")  # 输出： <class 'str'>

第四步：动态绑定参数——Signature.bind()和bind_partial()

这是inspect.signature最强大的功能之一。它允许你将实际提供的参数，按照函数的签名规则进行“绑定”或“匹配”，验证调用是否合法，并得到一个参数到值的映射。

• bind(*args, **kwargs)：将所有提供的参数绑定到签名上。如果提供的参数与签名不匹配（如缺少必需参数、提供了多余的参数等），会抛出TypeError，异常信息与直接调用函数时非常相似。
• bind_partial(*args, **kwargs)：部分绑定。允许你只提供部分参数，未提供的参数保持为“未绑定”状态。

示例3：使用bind()进行参数验证

def func(a, b: int, c=10, *, d):
    pass

sig_func = inspect.signature(func)

# 合法的绑定
bound_args = sig_func.bind(1, 2, d=20)
print(bound_args.arguments)  # 输出： {'a': 1, 'b': 2, 'd': 20}

# 非法的绑定 - 缺少仅关键字参数d
try:
    sig_func.bind(1, 2)
except TypeError as e:
    print(e)  # 输出： missing a required keyword-only argument: 'd'

# 非法的绑定 - 类型不匹配（bind不检查类型注解，但你可以手动检查）
bound_args = sig_func.bind(1, “not_an_int”, d=20) # 这不会报错，因为b的注解只是提示
# 但我们可以手动检查：
for name, value in bound_args.arguments.items():
    param = sig_func.parameters[name]
    if param.annotation is not inspect.Parameter.empty:
        if not isinstance(value, param.annotation):
            print(f"警告: 参数'{name}'期望类型{param.annotation}，但得到{type(value)}")

BoundArguments对象（即bound_args）有一个arguments属性，它是一个有序字典，包含了所有已绑定的参数名和值。这使得你可以基于函数签名，以一种结构化的方式处理所有传入的参数。

第五步：高级应用场景

掌握了函数签名的动态解析，你可以实现许多强大的功能：

1. 智能装饰器：编写一个能处理任何签名的通用装饰器。

   def debug_decorator(func):
       sig = inspect.signature(func)
       def wrapper(*args, **kwargs):
           bound_args = sig.bind(*args, **kwargs)
           print(f"调用 {func.__name__}{bound_args}")
           result = func(*args, **kwargs)
           print(f"结果: {result}")
           return result
       return wrapper
   
   @debug_decorator
   def add(x: int, y: int) -> int:
       return x + y
   
   add(5, 3)  # 输出： 调用 add(BoundArguments(args=(5, 3), kwargs={})) \n 结果: 8
   

2. 依赖注入/参数映射：根据参数名，从某个配置字典或上下文中自动填充函数参数。

3. 序列化/命令行接口(CLI)生成：根据函数签名自动生成命令行参数解析器（像argparse或click库内部所做的那样）。

4. 类型验证：结合annotation属性，在运行时进行参数类型校验。

总结

函数签名是Python元编程和自省能力的基石之一。通过inspect.signature，你可以：

• 获取：以编程方式获得函数接口的完整描述。
• 解析：深入理解每个参数的种类、默认值和类型提示。
• 验证：在调用函数前，验证传入的参数是否符合其签名规范。
• 操作：实现与函数签名无关的通用逻辑，如装饰器、框架路由等。

这个过程体现了Python“动态但不失结构”的设计哲学，让你能在运行时充分了解和利用代码的静态结构信息。