关于python内置inspect

关于python内置inspect

inspect.getmembers(object[, predicate]) 是 Python 的 inspect 模块中的一个函数，用于获取对象的所有成员（属性和方法等），并返回一个按照名称排序的 (name, value) 对的列表。
参数：
object：必需参数，表示要检查其成员的对象。
predicate：可选参数，是一个函数，用于过滤对象的成员。这个函数会被传入每个成员的值对象，如果它返回 True，则相应的成员会被包含在返回的列表中。
返回值：
返回一个列表，其中每个元素都是一个 (name, value) 对，代表对象的一个成员。列表是按照成员名称的字母顺序排序的。

示例：

import inspect

class MyClass:
    def __init__(self):
        self.my_attribute = 10
        self.my_method = self.method

    def method(self):
        pass

# 获取 MyClass 的所有成员
members = inspect.getmembers(MyClass)
print(members)

结果：

[('__class__', <class 'type'>), ('__delattr__', <slot wrapper '__delattr__' of 'object' objects>), ('__dict__', mappingproxy({'__module__': '__main__', '__init__': <function MyClass.__init__ at 0x0000018CE826C4C0>, 'method': <function MyClass.method at 0x0000018CE82F7670>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None})), ('__dir__', <method '__dir__' of 'object' objects>), ('__doc__', None), ('__eq__', <slot wrapper '__eq__' of 'object' objects>), ('__format__', <method '__format__' of 'object' objects>), ('__ge__', <slot wrapper '__ge__' of 'object' objects>), ('__getattribute__', <slot wrapper '__getattribute__' of 'object' objects>), ('__gt__', <slot wrapper '__gt__' of 'object' objects>), ('__hash__', <slot wrapper '__hash__' of 'object' objects>), ('__init__', <function MyClass.__init__ at 0x0000018CE826C4C0>), ('__init_subclass__', <built-in method __init_subclass__ of type object at 0x0000018CE81C2100>), ('__le__', <slot wrapper '__le__' of 'object' objects>), ('__lt__', <slot wrapper '__lt__' of 'object' objects>), ('__module__', '__main__'), ('__ne__', <slot wrapper '__ne__' of 'object' objects>), ('__new__', <built-in method __new__ of type object at 0x00007FF886F0BB50>), ('__reduce__', <method '__reduce__' of 'object' objects>), ('__reduce_ex__', <method '__reduce_ex__' of 'object' objects>), ('__repr__', <slot wrapper '__repr__' of 'object' objects>), ('__setattr__', <slot wrapper '__setattr__' of 'object' objects>), ('__sizeof__', <method '__sizeof__' of 'object' objects>), ('__str__', <slot wrapper '__str__' of 'object' objects>), ('__subclasshook__', <built-in method __subclasshook__ of type object at 0x0000018CE81C2100>), ('__weakref__', <attribute '__weakref__' of 'MyClass' objects>), ('method', <function MyClass.method at 0x0000018CE82F7670>)]

使用 predicate 参数：
如果你想只获取类的方法，你可以提供一个 predicate 函数，比如：

def is_method(member):
    return inspect.isfunction(member) or inspect.ismethod(member)

members = inspect.getmembers(MyClass, is_method)
print(members)

结果

[('__init__', <function MyClass.__init__ at 0x000002E44BEDC4C0>), ('method', <function MyClass.method at 0x000002E44BF67670>)]

上面的代码会只输出类的方法，而不会输出属性或其他类型的成员。这个函数在反射（reflection）或动态地分析对象结构时非常有用。
inspect.getmembers_static(object[, predicate])
是Python的inspect模块中的一个函数，用于获取对象的所有成员，并以名称排序的(name, value)对列表的形式返回。这个函数的一个关键特性是，它在获取成员时不会触发动态查找。

参数解释：
object：要检查其成员的对象。
predicate（可选）：一个函数，用于过滤成员。如果提供了这个函数，则只返回那些使predicate(member)为True的成员

inspect.getmodulename(path) ，用于从文件路径中提取模块名。具体来说，这个函数的作用是返回由文件路径命名的模块的名称，但不包括外部包的名称。
参数：
path：一个字符串，表示文件的路径
**inspect.ismodule(object)**用于判断一个对象是否是一个模块。
参数：
object：要检查的对象。
返回值：
如果 object 是一个模块，返回 True。
如果 object 不是一个模块，返回 False

inspect.isclass(object) 用于判断一个对象是否是一个类。无论是内置类还是通过 Python 代码创建的类，只要它是一个类，这个函数都会返回 True。

参数：
object：需要检查的对象。
返回值：
如果 object 是一个类，返回 True。
如果 object 不是一个类，返回 False。
inspect.ismethod(object) 用于判断一个对象是否是一个在 Python 中定义的绑定方法。
参数：
object：需要检查的对象。
返回值：
如果 object 是一个在 Python 中定义的绑定方法，返回 True。
如果 object 不是一个绑定方法，或者它不是一个在 Python 中定义的绑定方法（例如，它是一个内置方法或来自其他语言的扩展模块的方法），返回 False。

inspect.isfunction(object) 用于判断一个对象是否是一个 Python 函数。这包括通过普通 def 语句定义的函数以及通过 lambda 表达式创建的匿名函数。

参数：
object：需要被检查的对象。
返回值：
如果 object 是一个 Python 函数，返回 True。
如果 object 不是一个 Python 函数，返回 False。
**inspect.isgeneratorfunction(object)**用于判断一个对象是否是一个生成器函数。生成器函数是特殊的函数，它们在执行时返回一个生成器对象，而不是一次性返回所有结果。生成器函数使用 yield 关键字来定义，允许函数在返回一个值后暂停执行，并在下次调用时从暂停处继续执行。

参数：
object：需要检查的对象。
返回值：
如果 object 是一个生成器函数，返回 True。
如果 object 不是一个生成器函数，返回 False。

inspect.getmodulename(path)，用于从文件路径中提取模块名。具体来说，这个函数的作用是返回由文件路径命名的模块的名称，但不包括外部包的名称。
参数：
path：一个字符串，表示文件的路径。
返回值：
如果文件扩展名与 importlib.machinery.all_suffixes() 中的任何一个条目匹配，那么返回不带扩展名的最后一个路径组件。
如果不匹配，则返回 None。

inspect.ismodule(object) 用于判断一个对象是否是一个模块。

参数：
object：要检查的对象。
返回值：
如果 object 是一个模块，返回 True。
如果 object 不是一个模块，返回 False。

inspect.isclass(object) 用于判断一个对象是否是一个类。无论是内置类还是通过 Python 代码创建的类，只要它是一个类，这个函数都会返回 True。

参数：
object：需要检查的对象。
返回值：
如果 object 是一个类，返回 True。
如果 object 不是一个类，返回 False。

inspect.ismethod(object) 用于判断一个对象是否是一个在 Python 中定义的绑定方法。
参数：
object：需要检查的对象。
返回值：
如果 object 是一个在 Python 中定义的绑定方法，返回 True。
如果 object 不是一个绑定方法，或者它不是一个在 Python 中定义的绑定方法（例如，它是一个内置方法或来自其他语言的扩展模块的方法），返回 False。

**inspect.isfunction(object)**用于判断一个对象是否是一个 Python 函数。这包括通过普通 def 语句定义的函数以及通过 lambda 表达式创建的匿名函数。

参数：
object：需要被检查的对象。
返回值：
如果 object 是一个 Python 函数，返回 True。
如果 object 不是一个 Python 函数，返回 False。

inspect.isgeneratorfunction(object) 用于判断一个对象是否是一个生成器函数。生成器函数是特殊的函数，它们在执行时返回一个生成器对象，而不是一次性返回所有结果。生成器函数使用 yield 关键字来定义，允许函数在返回一个值后暂停执行，并在下次调用时从暂停处继续执行。

参数：
object：需要检查的对象。
返回值：
如果 object 是一个生成器函数，返回 True。
如果 object 不是一个生成器函数，返回 False。

**inspect.isgenerator(object)**用于判断一个对象是否是一个生成器对象。生成器是一种特殊的迭代器，它允许你在迭代过程中使用 yield 语句来暂停和恢复执行。这使得生成器能够按需生成值，从而节省内存，因为它们不必一次性计算所有值。

参数：
object：需要检查的对象。
返回值：
如果 object 是一个生成器对象，返回 True。
如果 object 不是一个生成器对象，返回 False。

释义这段文本
inspect.iscoroutinefunction(object) 是 Python 的 inspect 模块中的一个函数，用于判断一个对象是否是一个协程函数（coroutine function）。协程函数是使用 async def 语法定义的函数，它们在 Python 3.5 及以后的版本中引入，用于定义异步执行的代码。

参数：
object：需要检查的对象。
返回值：
如果 object 是一个协程函数，或者是一个通过 functools.partial() 包裹的协程函数，或者是一个通过 markcoroutinefunction() 标记的同步函数，则返回 True。
如果 object 不是一个协程函数，返回 False。

**inspect.markcoroutinefunction(func)**用于将一个可调用对象标记为协程函数。如果不用这个装饰器，iscoroutinefunction() 函数将不会检测到它是一个协程函数。

inspect.iscoroutine(object) 用于检查一个对象是否是由 async def 语句创建的协程（coroutine）。
参数：
object：需要检查的对象。
返回值：
如果 object 是一个由 async def 语句创建的协程对象，则返回 True。
如果 object 不是一个协程对象，则返回 False。

**inspect.isawaitable(object)**它用于判断一个对象是否可以在 await 表达式中使用。如果一个对象是可等待的（awaitable），那么它要么是一个协程（coroutine），要么是一个实现了 await() 方法的对象。

inspect.isasyncgen(object) 是 Python 的 inspect 模块中的一个函数，用于检查一个对象是否是由异步生成器函数创建的异步生成器迭代器。

inspect.istraceback(object) 用于检查一个对象是否是一个 traceback 对象。

在 Python 中，当程序发生异常时，解释器会生成一个 traceback 对象，该对象包含了异常发生时调用栈的信息。这些信息对于调试和错误排查非常有用，因为它们可以告诉我们异常是在哪里以及如何发生的。

inspect.istraceback(object) 函数允许你检查一个对象是否是这种 traceback 对象。如果对象是 traceback，则函数返回 True；否则返回 False。

inspect.isframe(object) 用于检查传入的 object 是否是一个帧对象（frame object）。在 Python 的实现中，帧对象代表了执行堆栈中的一个层次，通常与函数调用相关联。

帧对象
在 Python 的执行过程中，每次函数调用时都会创建一个新的帧对象。这个帧对象包含了函数调用的局部变量、当前执行的代码行号、函数参数等信息。这些信息对于调试、异常处理和反射（reflection）等任务非常有用。

inspect.isframe 函数
inspect.isframe(object) 函数接受一个对象作为参数，并返回一个布尔值。如果对象是一个帧对象，函数返回 True；否则返回 False。

示例
通常，你不会直接创建帧对象，而是通过 Python 的内建函数或 inspect 模块的其他函数来获取它们。但是，为了演示 inspect.isframe 的用法，我们可以使用 inspect.currentframe() 函数来获取当前执行的帧对象：

import inspect

def my_function():
    frame = inspect.currentframe()
    print(inspect.isframe(frame))  # 输出: True

my_function()

在上面的代码中，my_function 函数调用了 inspect.currentframe() 来获取当前执行的帧对象，并将其赋值给变量 frame。然后，它使用 inspect.isframe(frame) 来检查 frame 是否是一个帧对象，并打印结果。由于 frame 确实是一个帧对象，所以输出将是 True。

inspect.iscode(object) 是 Python 的 inspect 模块中的一个函数，它用于检查一个对象是否是一个代码对象（code object）。

在 Python 中，代码对象通常是编译后的源代码块，它们可以由内置的 compile() 函数生成，或者通过 Python 解释器在加载和执行模块或函数时隐式地创建。代码对象包含了字节码，这是 Python 解释器实际执行的指令序列。

当你定义一个函数、方法或类时，Python 解释器会将这些定义编译成代码对象。同样，当你执行 exec() 或 eval() 函数时，传递给它们的字符串也会被编译成代码对象。

inspect.iscode(object) 函数允许你检查一个对象是否是这种代码对象。如果是，函数返回 True；否则返回 False。

示例：
下面是一个简单的示例，展示了如何使用 inspect.iscode() 函数：

python
import inspect

# 定义一个函数
def my_function():
    pass

# 获取函数的代码对象
code_obj = my_function.__code__

# 使用 inspect.iscode 检查对象
is_code = inspect.iscode(code_obj)
print(is_code)  # 输出: True

# 尝试检查一个非代码对象
is_not_code = inspect.iscode("Hello, world!")
print(is_not_code)  # 输出: False

在上面的代码中，我们首先定义了一个简单的函数 my_function。然后，我们通过访问函数的 code 属性来获取该函数的代码对象。接下来，我们使用 inspect.iscode() 函数来检查这个对象是否是一个代码对象，并打印结果。最后，我们尝试检查一个字符串对象，由于它不是代码对象，所以函数返回 False。

**inspect.isbuiltin(object)**用于检查一个对象是否是一个内置函数（built-in function）或者是一个绑定到对象的内置方法（bound built-in method）。

内置函数与内置方法
在 Python 中，内置函数是那些由解释器预先定义并始终可用的函数，例如 len(), type(), print() 等。这些函数不需要导入任何模块就可以直接使用。

内置方法则是指那些绑定到特定对象上的内置函数，例如列表对象的 append() 方法或字典对象的 keys() 方法。这些方法通常用于操作对象本身，并且只能在其所属的对象上调用。

inspect.isbuiltin 函数
inspect.isbuiltin(object) 函数会检查传入的 object 是否是上述的内置函数或内置方法。如果是，则返回 True；否则返回 False。

示例

python
import inspect

# 内置函数示例
def is_len_builtin():
    return inspect.isbuiltin(len)

print(is_len_builtin())  # 输出: True

# 自定义函数示例
def my_function():
    pass

print(inspect.isbuiltin(my_function))  # 输出: False

# 列表对象的内置方法示例
my_list = []
def is_append_builtin():
    return inspect.isbuiltin(my_list.append)

print(is_append_builtin())  # 输出: True

在上面的代码中，我们检查了 len 函数（一个内置函数）、my_function（一个自定义函数）以及列表对象 my_list 的 append 方法（一个内置方法）。inspect.isbuiltin() 函数正确地识别了 len 和 append 是内置函数或方法，而 my_function 不是。

**inspect.ismethodwrapper(object)**用于检查传入的 object 是否是一个方法包装器（MethodWrapper）类型。

在 Python 中，方法包装器是一种特殊的对象类型，它通常用于包装一个方法，使得这个方法可以以一种特定的方式被调用或访问。方法包装器通常用于实现一些特殊的调用语义，比如绑定方法到实例对象，或者实现一些装饰器（decorator）的效果。

inspect.ismethodwrapper(object) 函数会检查传入的 object 是否是这种类型。如果是，函数返回 True；否则返回 False。

示例
这里是一个简单的例子来说明如何使用 inspect.ismethodwrapper()：

python
import inspect

class MyClass:
    def my_method(self):
        pass

# 创建一个 MyClass 的实例
instance = MyClass()

# 获取实例方法
method = instance.my_method

# 检查 method 是否是方法包装器
is_method_wrapper = inspect.ismethodwrapper(method)
print(is_method_wrapper)  # 输出: False

# 获取方法的一个属性，它可能是一个方法包装器
# 例如，通过 __get__ 方法获取绑定到实例的方法
bound_method = MyClass.my_method.__get__(instance)

# 检查 bound_method 是否是方法包装器
is_bound_method_wrapper = inspect.ismethodwrapper(bound_method)
print(is_bound_method_wrapper)  # 输出可能会根据 Python 版本和具体实现有所不同

在上面的代码中，我们定义了一个简单的类 MyClass，并创建了一个该类的实例 instance。我们尝试获取实例的一个方法 my_method，并检查它是否是方法包装器。通常情况下，直接获取的方法对象不是方法包装器，所以 is_method_wrapper 会是 False。

然后，我们尝试通过 get 方法获取绑定到实例的 my_method。这可能会返回一个方法包装器（取决于 Python 的实现和版本），因此 is_bound_method_wrapper 的值可能会是 True 或 False。

**inspect.isroutine(object)**它用于检查传入的 object 是否是一个用户定义或内置的函数或方法。

解释
在 Python 中，函数和方法是执行特定任务的可调用对象。用户定义的函数是程序员通过 def 关键字创建的，而内置函数则是 Python 解释器预定义的，例如 len(), print(), type() 等。方法通常与类相关联，并且是通过类定义或实例来调用的。

inspect.isroutine(object) 函数检查传入的 object 是否满足以下条件之一：

是一个用户定义的函数。
是一个内置的函数。
是一个绑定到对象的方法（无论是用户定义的还是内置的）。
如果满足上述条件之一，则函数返回 True；否则返回 False。

示例

python
import inspect

# 用户定义的函数
def my_function():
    pass

# 内置函数
builtin_function = len

# 类定义及其方法
class MyClass:
    def my_method(self):
        pass

# 创建 MyClass 的实例
instance = MyClass()

# 获取实例的方法
instance_method = instance.my_method

# 检查 my_function 是否是函数或方法
is_my_function_routine = inspect.isroutine(my_function)
print(is_my_function_routine)  # 输出: True

# 检查 builtin_function 是否是函数或方法
is_builtin_routine = inspect.

inspect.isabstract(object) 用于检查传入的 object 是否是一个抽象基类（abstract base class，简称 ABC）。

抽象基类在 Python 中是一种特殊的类，它不能被实例化，而是作为其他类的基类，用于定义一组方法但不提供具体的实现。抽象基类的主要目的是定义接口，即定义一组子类应该实现的方法，但不提供这些方法的具体实现。这样做可以确保任何继承自该抽象基类的子类都遵循相同的接口规范。

抽象基类通常使用 abc 模块中的 ABCMeta 作为其元类，并使用 @abstractmethod 装饰器来标记需要子类实现的方法。

inspect.isabstract(object) 函数允许你检查一个类是否是抽象基类。如果是，函数返回 True；否则返回 False。

示例：
下面是一个简单的示例，展示了如何使用 inspect.isabstract() 函数：

python
import inspect
from abc import ABC, abstractmethod

# 定义一个抽象基类
class MyAbstractBaseClass(ABC):
    @abstractmethod
    def my_abstract_method(self):
        pass

# 定义一个非抽象类
class MyConcreteClass:
    def my_method(self):
        pass

# 检查抽象基类
is_abstract = inspect.isabstract(MyAbstractBaseClass)
print(is_abstract)  # 输出: True

# 检查非抽象类
is_not_abstract = inspect.isabstract(MyConcreteClass)
print(is_not_abstract)  # 输出: False

在上面的代码中，MyAbstractBaseClass 是一个定义了一个抽象方法的抽象基类，而 MyConcreteClass 是一个非抽象类。inspect.isabstract()

**inspect.ismethoddescriptor(object)**用于检查传入的 object 是否是一个方法描述符（method descriptor），同时确保它不是方法（method）、类（class）、函数（function）或内置函数（builtin function）。

在 Python 中，方法描述符是一种特殊的对象，它定义了当通过实例或类访问方法时应该发生什么。方法描述符通常与类的方法相关联，但并不直接与方法实例本身相关联。当你通过类访问一个方法时，返回的就是这个方法描述符；而当通过类的实例访问同一个方法时，会调用这个方法描述符的 get 方法，返回一个绑定到该实例的方法对象。

inspect.ismethoddescriptor(object) 函数会检查传入的 object 是否满足上述条件。如果是，函数返回 True；否则返回 False。需要注意的是，这个方法返回 True 的对象不会是方法（通过实例访问）、类、函数或内置函数，因为这些类型都已经被其他 inspect 模块中的函数覆盖了。

示例
这里是一个简单的例子来说明如何使用 inspect.ismethoddescriptor()：

python
import inspect

class MyClass:
    def my_method(self):
        pass

# 获取 MyClass 类的 my_method 方法描述符
method_descriptor = MyClass.__dict__['my_method']

# 检查 method_descriptor 是否是方法描述符
is_method_descriptor = inspect.ismethoddescriptor(method_descriptor)
print(is_method_descriptor)  # 输出: True

# 创建 MyClass 的实例
instance = MyClass()

# 通过实例获取绑定方法，此时不是方法描述符
bound_method = instance.my_method

# 检查 bound_method 是否是方法描述符
is_not_method_descriptor = inspect.ismethoddescriptor(bound_method)
print(is_not_method_descriptor)  # 输出: False

# 检查其他类型的对象
is_not_descriptor_for_function = inspect.ismethoddescriptor(len)
print(is_not_descriptor_for_function)  # 输出: False

在上面的示例中，我们创建了一个类 MyClass，并获取了它的 my_method 方法描述符。inspect.ismethoddescriptor() 正确识别了 method_descriptor 是一个方法描述符。然而，当我们通过类的实例访问 my_method 时，得到的是一个绑定方法，而不是方法描述符，所以 inspect.ismethoddescriptor() 返回 False。同时，我们检查内置函数 len 也不是方法描述符。

*class inspect.Signature(parameters=None, , return_annotation=Signature.empty)
检查 Signature对象表示函数的整体签名。它为函数接受的每个参数存储一个Parameter对象，以及特定于函数本身的信息。 Signature对象具有以下公共属性和方法： 参数：OrderedDict 参数名称到相应Parameter对象的有序映射（仅限关键字的参数与代码.covarnames中列出的顺序相同）。 return注释：对象 函数的返回类型的注释（如果指定）。如果函数的返回类型没有注释，则此属性将设置为Signature.empty。 bind（args，kwargs）->BoundArguments 创建从位置参数和关键字参数到参数的映射。 bind_partial（args，kwargs）->BoundArguments 创建从位置和关键字参数到参数的部分映射（模拟“functools.partial”行为）

inspect.Signature 用于表示函数的签名。函数的签名包括了函数的参数、返回值的注解以及可变参数等信息。

当你查看一个函数的签名时，你可能会注意到函数的参数名、它们的类型（如果提供了注解的话），以及它是否有默认值等。inspect.Signature 允许你以编程的方式获取和操作这些信息。

inspect.Signature 的构造函数接受以下参数：

parameters：一个参数对象（通常是由 inspect.Parameter 对象组成的列表或字典），它定义了函数或方法的参数。如果这个参数为 None，则签名为空。
return_annotation：函数的返回值的注解。如果这个参数未提供或为 Signature.empty，则签名不包含返回注解。
这个类的其他方法和属性允许你进一步查询和操作签名。例如，你可以使用 parameters 属性来获取参数列表，或者使用 bind 方法来绑定参数到一个实例上。

以下是一个简单的示例：

python
import inspect

def my_function(a, b=2, *args, c: int = 3, d: str, **kwargs) -> None:
    pass

sig = inspect.signature(my_function)

# 打印参数
for name, param in sig.parameters.items():
    print(f"Name: {name}, Kind: {param.kind}, Annotation: {param.annotation}")

# 打印返回注解
print(f"Return Annotation: {sig.return_annotation}")

在这个示例中，我们首先定义了一个函数 my_function，然后使用 inspect.signature 来获取其签名。之后，我们遍历签名中的参数并打印它们的信息，包括名称、类型和注解。最后，我们打印函数的返回注解。

inspect.Signature 是一个非常有用的工具，特别是在元编程和函数/方法的动态分析场景中。

replace(*[, parameters][, return_annotation]) 是 inspect.Signature 类的一个方法，它允许你基于调用 replace() 方法的原始 Signature 实例创建一个新的 Signature 实例。你可以传递不同的参数和/或返回注解来覆盖基础签名的对应属性。
参数
*parameters：这是一个可变参数，允许你传入一个或多个 inspect.Parameter 对象。这些对象定义了新签名的参数列表。如果你不提供这个参数或传递一个空序列，新签名将使用与原始签名相同的参数列表。
return_annotation：这是一个可选参数，用于指定新签名的返回注解。如果你不提供这个参数或传递 Signature.empty，新签名将不会包含返回注解。

用法
replace() 方法的主要用途是创建一个新的签名，该签名与原始签名类似，但可能在参数或返回注解方面有所不同。这在你想修改一个函数的签名但又不想改变原始签名时特别有用。

示例
下面是一个简单的例子，展示了如何使用 replace() 方法来修改一个签名的返回注解：

python
import inspect

def example_function(a, b):
    pass

# 获取原始函数的签名
original_sig = inspect.signature(example_function)

# 打印原始签名
print("Original Signature:", original_sig)

# 使用 replace() 方法创建一个新的签名，其中返回注解被修改为 int
new_sig = original_sig.replace(return_annotation=int)

# 打印新签名
print("New Signature:", new_sig)

在这个例子中，example_function 函数原本没有定义返回注解。我们使用 replace() 方法创建了一个新的签名 new_sig，其中返回注解被设置为 int。这样，new_sig 就表示一个函数，它接受与 example_function 相同的参数，但应该返回一个整数。

如果你想要完全移除返回注解，可以传递 Signature.empty 作为 return_annotation 的值：

python
# 创建一个没有返回注解的新签名
new_sig_no_return = original_sig.replace(return_annotation=inspect.Signature.empty)

# 打印没有返回注解的新签名
print("New Signature without return annotation:", new_sig_no_return)

在这个例子中，new_sig_no_return 表示一个函数，它接受与 example_function 相同的参数，但没有定义返回类型。

更多详解官方文档python-inspect