python内置模块之inspect，获取、检查和操作活动对象的信息

一、简介

inspect 是 Python 的标准库中的一个模块，用于获取、检查和操作活动对象的信息。它提供了一组函数，可以在运行时检查代码对象（如模块、类、函数、方法等）的属性、源代码、参数签名等。
inspect 模块的主要功能包括：

1. 获取对象信息：可以获取对象的类型、名称、模块、源代码等信息。
2. 获取函数和方法的参数信息：可以获取函数或方法的参数列表、默认参数值、注解等信息。
3. 获取类的继承关系和属性信息：可以获取类的基类、方法、属性等信息。
4. 检查对象的属性和成员：可以检查对象是否具有某个属性或成员，并获取属性的值。
5. 检查代码对象的源代码：可以获取函数、类、方法等对象的源代码。
   inspect 模块在许多情况下非常有用，特别是在编写装饰器、元类和调试工具时。它提供了一种方便的方式来检查和操作代码对象，使开发者能够更好地理解和处理运行时的对象。

二、获取操作对象方法

1. inspect.stack(context)：用于获取当前调用栈的信息。它返回一个由栈帧对象inspect.FrameInfo.frame 组成的列表，每个栈帧对象包含有关调用栈的信息，例如文件名、行号、函数名等。

• context：用于指定要获取的调用栈帧的数量

import inspect

def foo():
    bar()

def bar():
    stack = inspect.stack()
    print(stack)
    for frame_info in stack:
        frame = frame_info.frame
        filename = frame.f_code.co_filename
        lineno = frame.f_lineno
        function_name = frame.f_code.co_name
        print(f"File: {filename}, Line: {lineno}, Function: {function_name}")

foo()

2. inspect.getmodule(object, _filename=None)：用于获取给定对象所属的模块对象module。

• object：对象
• _filename：用于指定一个文件名来辅助确定对象所属的模块

import inspect

def foo():
    pass

module = inspect.getmodule(foo)
print(module.__name__)

3. inspect.currentframe()：返回当前的堆栈帧对象inspect.FrameInfo.frame。
4. inspect.getframeinfo(frame, context=1)：返回给定堆栈帧的信息inspect.Traceback，包括文件名、行号、函数名等。

• frame：要获取信息的帧对象。
• context：指定要获取的源代码行数。默认值为1，表示获取当前行的上下文一行的源代码。

import inspect

def foo():
    bar()

def bar():
    frame = inspect.currentframe()
    frame_info = inspect.getframeinfo(frame)
    print(frame_info.filename)
    print(frame_info.lineno)
    print(frame_info.function)

foo()

5. inspect.unwrap(func, stop=None)：返回一个可迭代的对象，其中包含从外部包装器函数中解包的函数对象。可以用于获取函数的原始定义

• func：要获取最内层非包装函数的函数对象。
• stop：指定一个可调用对象（函数或方法），作为停止查找的标志。如果指定了 stop，则在达到 stop 对象之前的最内层非包装函数将被返回

import inspect

def decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@decorator
def my_function():
    print("Inside my_function")

# 获取最内层非包装函数
unwrapped_func = inspect.unwrap(my_function)
unwrapped_func()

6. inspect.classify_class_attrs(cls)：对给定类的属性进行分类，返回一个字典，其中包含类的数据属性、函数属性和描述符属性。

• cls：要分类属性的类对象。

import inspect

class MyClass:
    class_var = 10

    def __init__(self):
        self.instance_var = 20

    def instance_method(self):
        pass

    @property
    def prop(self):
        return 30

    @classmethod
    def class_method(cls):
        pass

    @staticmethod
    def static_method():
        pass

attrs = inspect.classify_class_attrs(MyClass)
for attr in attrs:
    '''
    name：属性的名称。
    kind：属性的分类，可能的取值为 'data'、'method'、'property'、'class method' 或 'static method'。
    defining_class：定义该属性的类对象。
    object：属性对象本身。
    '''
    print(attr.name, attr.kind, attr.defining_class, attr.object)

7. inspect.cleandoc(doc)：从文档字符串中去除缩进和空白行，返回一个干净的文档字符串。

• doc：要清理的文档字符串。

import inspect

docstring = """
    This is a multi-line
    docstring with indentation.

    It has leading and trailing
    empty lines.
"""

cleaned_docstring = inspect.cleandoc(docstring)
print(cleaned_docstring)

8. inspect.findsource(object)：尝试获取对象的源代码，并返回源代码行的列表和起始行号。

• object：要查找源代码的对象。

import inspect

def my_function():
    print("Hello, world!")

source_lines, source_file = inspect.findsource(my_function)
for line in source_lines:
    print(line.strip())

print("原代码文件路径:", source_file)

9. inspect.formatannotation(annotation, base_module)：将注解对象格式化为字符串表示形式。可以选择指定基本模块，以便在注解中使用相对导入。

• annotation：要格式化的注解对象。
• base_module：可选参数，指定基础模块的名称。

import inspect

def my_function(param: int) -> str:
    pass

param_annotation = inspect.signature(my_function).parameters['param'].annotation
formatted_annotation = inspect.formatannotation(param_annotation)
print(formatted_annotation)

10. inspect.signature(obj, follow_wrapped=True, globals=None, locals=None, eval_str) ：函数用于获取对象的签名信息，包括参数、默认值、注解等

• obj：要获取签名信息的对象，可以是函数、方法、类或可调用对象。
• follow_wrapped（可选）：指定是否跟踪被包装的对象。默认为 True，表示会跟踪被包装的对象以获取完整的签名信息。
• globals（可选）：一个字典，用于指定全局命名空间。默认为 None，表示使用当前的全局命名空间。
• locals（可选）：一个字典，用于指定局部命名空间。默认为 None，表示使用当前的局部命名空间。
• eval_str（可选）：一个字符串，用于指定额外的求值环境。默认为 None。

import inspect

def my_function(param1, param2='default', *args, **kwargs):
    pass

signature = inspect.signature(my_function)
print(signature)

import inspect

def my_function(param1, param2='default', *args, **kwargs):
    pass

signature = inspect.signature(my_function)
parameters = signature.parameters

for name, parameter in parameters.items():
    print(name, parameter.default, parameter.kind)

11. inspect.formatargvalues(args,…,formatvalue=lambda value: ‘=’ + repr(value))：用于格式化函数参数和值的字符串表示形式的工具函数

• args：函数的位置参数的元组。
• varargs：函数的可变位置参数的名称。
• varkw：函数的可变关键字参数的名称。
• locals：函数的本地命名空间字典。
• formatarg：函数，用于格式化位置参数的字符串表示形式，默认为 str 函数。
• formatvarargs：函数，用于格式化可变位置参数的字符串表示形式，默认为在参数名称前加上 ‘*’。
• formatvarkw：函数，用于格式化可变关键字参数的字符串表示形式，默认为在参数名称前加上 ‘**’。
• formatvalue：函数，用于格式化参数默认值的字符串表示形式，默认为在参数默认值前加上 ‘=’ 和 repr() 函数的结果。

import inspect

def my_function(param1, param2='default', *args, **kwargs):
    pass

args = ('param1', 'param2')
varargs = 'args'
varkw = 'kwargs'
locals_dict = {'param1': 10, 'param2': 'value', 'args': (1, 2, 3), 'kwargs': {'key': 'value'}}

argvalues = inspect.formatargvalues(args, varargs, varkw, locals_dict)
print(argvalues)

12. inspect.get_annotations(obj, globals=None, locals=None, eval_str=False)：用于获取对象的注解信息。

• obj：要获取注解的对象。
• globals：字典，用于指定全局命名空间。默认为 None，表示使用当前的全局命名空间。
• locals：字典，用于指定局部命名空间。默认为 None，表示使用当前的局部命名空间。
• eval_str：布尔值，指定是否将字符串注解解析为对象。默认为 False。

import inspect

def my_function(param1: int, param2: str = 'default') -> str:
    passannotations = inspect.get_annotations(my_function)
print(annotations)

13. inspect.getabsfile(object, _filename)：用于获取对象所在的文件的绝对路径

• object：要获取绝对文件路径的对象。
• _filename：对象的 file 属性。

import inspect

def my_function():
    pass

file_path = inspect.getabsfile(my_function)
print(file_path)

14. inspect.getargvalues(frame)：用于获取函数调用栈帧（frame）中的参数值信息

• frame：要获取参数值的帧对象。

import inspect


def my_function(param1, param2='default', *args, **kwargs):
    frame = inspect.currentframe()
    args_info = inspect.getargvalues(frame)

    print("位置参数值的列表:", args_info.args)
    print("可变位置参数:", args_info.varargs)
    print("可变关键字参数:", args_info.keywords)
    print("局部变量的字典:", args_info.locals)


my_function('value', param2='custom', extra_arg1='extra_value1', extra_arg2='extra_value2')

15. inspect.getattr_static(obj, attr, default)：用于获取对象的静态属性（static attribute）

• obj：要获取属性的对象。
• attr：属性的名称。
• default：如果属性不存在，则返回的默认值。

import inspect

class MyClass:
    static_attr = "Static Attribute"

class MyMeta(type):
    def __getattr__(self, attr):
        return inspect.getattr_static(self, attr, "Default Value")

class MySubClass(MyClass, metaclass=MyMeta):
    pass

print(MyClass.static_attr)  # 输出: Static Attribute
print(MySubClass.static_attr)  # 输出: Static Attribute
print(MySubClass.nonexistent_attr)  # 输出: Default Value

16. inspect.getcallargs(func, *positional, **named)：用于获取函数调用时的参数字典。它的作用是根据函数定义和传入的位置参数与关键字参数，生成一个字典，其中键是函数定义中的参数名，值是相应的参数值。

• func：要调用的函数对象。
• positional：位置参数的值。
• named：关键字参数的值。

import inspect

def my_func(a, b, c=0, d=0):
    pass

args = inspect.getcallargs(my_func, 1, 2, d=3)
print(args)

17. inspect.getclasstree(classes, unique)：用于获取类的继承关系树

• classes：类的列表。
• unique：布尔值，指定是否返回唯一的类树。默认为 False。

import inspect

class A:
    passclass B(A):
    passclass C(A):
    passclass D(B, C):
    passtree = inspect.getclasstree([A, B, C, D])
for item in tree:
    print(item)

18. inspect.getclosurevars(func)：用于获取函数的闭包变量信息

• func：要获取闭包变量的函数对象。

import inspect

def outer_func():
    x = 10    def inner_func():
        y = 20        print(x + y)
    return inner_func

closure_vars = inspect.getclosurevars(outer_func())
'''
nonlocals：一个字典，表示函数内部函数引用的外部函数的非局部变量。键是变量名，值是变量值。
globals：一个字典，表示函数内部函数引用的全局变量。键是变量名，值是变量值。
builtins：一个字典，表示函数内部函数引用的内置变量。键是变量名，值是变量值。
unbound：一个集合，表示函数内部函数引用的未绑定的变量。即在函数内部使用但未在函数内部或外部定义的变量。
'''
print(closure_vars.nonlocals)
print(closure_vars.globals)
print(closure_vars.builtins)
print(closure_vars.unbound)

19. inspect.getcomments(object)：获取对象的注释。object：要获取注释的对象。
20. inspect.getcoroutinelocals(coroutine)：获取协程对象的局部变量。coroutine：要获取局部变量的协程对象。
21. inspect.getcoroutinestate(coroutine)：获取协程对象的状态。coroutine：要获取状态的协程对象。
22. inspect.getdoc(object)：获取对象的文档字符串。object：要获取文档字符串的对象。

import inspect

class MyClass:
    """
    This is a class.
    """

    def my_method(self):
        """
        This is a method.
        """
        pass

docstring_class = inspect.getdoc(MyClass)
print(docstring_class)  # 输出：'This is a class.'

docstring_method = inspect.getdoc(MyClass.my_method)
print(docstring_method)  # 输出：'This is a method.'

23. inspect.getfile(object)：获取对象定义所在的文件名。object：要获取文件名的对象。

import inspect

def my_function():
    pass

file_name = inspect.getfile(my_function)
print(file_name)  # 输出：'path/to/my_script.py'

24. inspect.getfullargspec(func)：获取函数的完整参数规范。func：要获取参数规范的函数对象。

import inspect

def my_function(a, b=10, *args, c=20, **kwargs):
    pass

argspec = inspect.getfullargspec(my_function)
'''
args：一个包含函数或方法参数名称的列表。
varargs：表示可变位置参数的名称，如果函数没有可变位置参数，则为 None。
varkw：表示可变关键字参数的名称，如果函数没有可变关键字参数，则为 None。
defaults：一个包含函数或方法默认参数值的元组，如果没有默认参数，则为 None。
kwonlyargs：一个包含仅限关键字参数的名称的列表。
kwonlydefaults：一个包含仅限关键字参数默认值的字典，如果没有仅限关键字参数，则为 None。
annotations：一个包含参数注解的字典，如果没有参数注解，则为 None。
'''
print(argspec.args)  # 输出：['a', 'b']
print(argspec.varargs)  # 输出：'args'
print(argspec.varkw)  # 输出：'kwargs'
print(argspec.defaults)  # 输出：(10,)
print(argspec.kwonlyargs)  # 输出：['c']
print(argspec.kwonlydefaults)  # 输出：{'c': 20}
print(argspec.annotations)  # 输出：{}

25. inspect.getgeneratorlocals(generator)：获取生成器对象的局部变量。generator：要获取局部变量的生成器对象。

import inspect

def my_generator():
    x = 1
    yield x
    y = 2
    yield y

gen = my_generator()
next(gen)  # 执行生成器的第一个 yield 语句
locals_dict = inspect.getgeneratorlocals(gen)
print(locals_dict)  # 输出：{'x': 1}

next(gen)  # 执行生成器的第二个 yield 语句
locals_dict = inspect.getgeneratorlocals(gen)
print(locals_dict)  # 输出：{'x': 1, 'y': 2}

26. inspect.getgeneratorstate(generator)：获取生成器对象的状态。generator：要获取状态的生成器对象。
27. inspect.getinnerframes(tb, context=1)：获取堆栈跟踪中调用帧的信息。

• tb：堆栈跟踪对象；
• context：可选参数，指定要获取的帧数，默认为1。
  28.inspect.getlineno(frame)：获取帧对象所在的行号。frame：帧对象。

import inspect

def my_function():
    frame = inspect.currentframe()
    lineno = inspect.getlineno(frame)
    print(f"Line number: {lineno}")

my_function()

29. inspect.getmembers(object, predicate=None)：获取对象的成员列表。

• object：要获取成员列表的对象；
• predicate：可选参数，用于过滤成员的谓词函数。

import inspect

class MyClass:
    def __init__(self):
        self.x = 1        self.y = 2    def my_method(self):
        print("Hello, World!")

obj = MyClass()

members = inspect.getmembers(obj)

for member in members:
    print(member)

30. inspect.getmembers_static(object, predicate)：获取对象的静态成员列表。

• object：要获取静态成员列表的对象；
• predicate：可选参数，用于过滤成员的谓词函数。

31. inspect.getmodulename(path)：从文件路径中获取模块名。path：文件路径。
32. inspect.getmro(cls)：获取类的方法解析顺序 (Method Resolution Order, MRO)。cls：要获取 MRO 的类。
33. inspect.getouterframes(frame, context=1)：获取堆栈跟踪中调用帧及其上下文的信息。

• frame：帧对象；context：可选参数，指定要获取的帧数，默认为1。
• inspect.getsource(object)：获取对象的源代码。
• object：要获取源代码的对象。

34. inspect.getsourcefile(object)：获取对象定义所在的源文件名。object：要获取源文件名的对象。
35. inspect.getsourcelines(object)：获取对象的源代码行列表。object：要获取源代码行列表的对象。
36. inspect.trace(context)：跟踪程序的执行，并返回一个由 Traceback 对象组成的列表。每个 Traceback 对象表示程序执行过程中的一层调用栈信息，包括函数名、文件名、行号等。
37. inspect.formatannotationrelativeto(object)：格式化注解（annotation），相对于给定的对象。注解是函数参数或返回值的类型提示信息。
38. inspect.getblock(lines)：获取一段代码块的内容。它接收一个字符串列表作为参数，每个字符串代表一行代码，然后返回代码块的内容，即从第一个非空行开始到遇到空行或者缩进减少的行为止。
39. inspect.indentsize(line)：获取给定行的缩进大小。它接收一个字符串作为参数，表示一行代码，然后返回该行代码的缩进大小，以空格数为单位。

三、检查对象方法

1. inspect.isabstract(object)：检查对象是否是抽象基类（Abstract Base Class）。
2. inspect.isasyncgen(object)：检查对象是否是异步生成器（asynchronous generator）。
3. inspect.isasyncgenfunction(object)：检查对象是否是异步生成器函数（asynchronous generator function）。
4. inspect.isawaitable(object)：检查对象是否可等待（awaitable）。
5. inspect.isbuiltin(object)：检查对象是否是内置函数或方法。
6. inspect.isclass(object)：检查对象是否是类。
7. inspect.iscode(object)：检查对象是否是代码对象。
8. inspect.iscoroutine(object)：检查对象是否是协程（coroutine）。
9. inspect.iscoroutinefunction(object)：检查对象是否是协程函数（coroutine function）。
10. inspect.isdatadescriptor(object)：检查对象是否是数据描述符（data descriptor）。
11. inspect.isframe(object)：检查对象是否是帧对象（frame）。
12. inspect.isfunction(object)：检查对象是否是函数。
13. inspect.isgenerator(object)：检查对象是否是生成器（generator）。
14. inspect.isgeneratorfunction(object)：检查对象是否是生成器函数（generator function）。
15. inspect.isgetsetdescriptor(object)：检查对象是否是属性描述符（get-set descriptor）。
16. inspect.ismemberdescriptor(object)：检查对象是否是成员描述符（member descriptor）。
17. inspect.ismethod(object)：检查对象是否是方法。
18. inspect.ismethoddescriptor(object)：检查对象是否是方法描述符（method descriptor）。
19. inspect.ismethodwrapper(object)：检查对象是否是方法包装器（method wrapper）。
20. inspect.ismodule(object)：检查对象是否是模块。
21. inspect.isroutine(object)：检查对象是否是可调用对象（函数、方法、生成器等）。
22. inspect.istraceback(object)：检查对象是否是追踪回溯（traceback）对象。
23. inspect.walktree(classes, children, parent)
24. inspect.trace()
25. inspect.formatannotationrelativeto(object)
26. inspect.getblock(lines)
27. inspect.indentsize(line)

四、帧信息inspect.FrameInfo

1. inspect.FrameInfo.frame：帧对象（frame object）。
2. inspect.FrameInfo.filename：源代码文件名。
3. inspect.FrameInfo.lineno：源代码行号。
4. inspect.FrameInfo.function：函数或方法名。
5. inspect.FrameInfo.code_context：源代码行的文本列表。
6. inspect.FrameInfo.index：当前行在 code_context 中的索引。

五、堆栈帧对象inspect.FrameInfo.frame

1. inspect.FrameInfo.frame.f_back：指向调用当前帧的帧对象。
2. inspect.FrameInfo.frame.f_code：表示当前帧所执行的代码对象。

• f_code.co_name：表示代码对象的名称（函数名、方法名等）。
• f_code.co_filename：表示代码对象所在的文件名。
• f_code.co_firstlineno：表示代码对象的起始行号。
• f_code.co_argcount：表示代码对象的参数数量。
• f_code.co_kwonlyargcount：表示代码对象的仅关键字参数的数量。
• f_code.co_nlocals：表示代码对象的局部变量的数量。
• f_code.co_stacksize：表示代码对象的堆栈大小。
• f_code.co_flags：表示代码对象的标志位。
• f_code.co_consts：一个元组，表示代码对象的常量值。
• f_code.co_names：一个元组，表示代码对象使用的全局名称。
• f_code.co_varnames：一个元组，表示代码对象的局部变量名。
• f_code.co_cellvars：一个元组，表示代码对象的闭包变量名。
• f_code.co_freevars：一个元组，表示代码对象的自由变量名。
• f_code.co_code：表示代码对象的字节码。
• f_code.co_lnotab：表示代码对象的行号表。

3. inspect.FrameInfo.frame.f_locals：一个字典，包含当前帧的局部变量。
4. inspect.FrameInfo.frame.f_globals：一个字典，包含当前帧的全局变量。
5. inspect.FrameInfo.frame.f_lineno：表示当前帧所在的行号。
6. inspect.FrameInfo.frame.f_lasti：表示当前帧最后执行的指令的索引。
7. inspect.FrameInfo.frame.f_trace：表示当前帧的跟踪函数（如果有）。

六、模块对象module

1. name: 表示模块的名称，通常是一个字符串。如果模块是主模块（被直接执行的脚本），则其值为 “main”。
2. doc: 表示模块的文档字符串，即模块的描述信息。可以使用 help(module) 函数来查看该文档字符串。
3. file: 表示模块的文件路径，即模块所在的文件的绝对路径。对于内置模块或动态创建的模块，该属性可能不存在。
4. package: 表示模块所属的包的名称。对于独立模块而言，其值为 None。
5. loader: 表示加载模块的加载器对象。加载器负责从文件或其他来源加载模块。
6. spec: 表示模块的规范对象，包含模块的元数据信息，如名称、文件路径等。
7. path: 表示包模块的搜索路径。对于普通模块而言，该属性不存在。
8. builtins: 表示内置命名空间的字典，包含内置函数、异常和其他对象。可以通过 module.builtins 或 builtins 来访问内置对象。
9. 其他自定义属性: 模块对象自定义属性

七、签名对象inspect.Signature

1. signature.parameters：一个有序字典，表示函数或方法的参数，键是参数名称，值是 inspect.Parameter 对象，包含参数的各种信息，如名称、默认值、注解等。
2. signature.return_annotation：函数或方法的返回值注解。
3. signature.empty：一个特殊的对象，表示一个空的函数签名。
4. signature.bind_partial(*args, **kwargs)：创建一个部分绑定的函数签名对象，可以使用部分参数绑定进行后续的函数调用。
5. signature.from_callable(obj, follow_wrapped=True, globals=None, locals=None, eval_str)：从可调用对象 obj 创建一个函数签名对象。follow_wrapped 参数指示是否跟踪包装函数，默认为 True。globals 和 locals 参数用于在创建签名对象时解析全局和局部变量，默认为 None。eval_str 参数允许在创建签名对象时执行额外的字符串代码，默认为 None。
6. signature.bind(*args, **kwargs)：将函数签名与参数进行绑定，返回一个 inspect.BoundArguments 对象，其中包含绑定的参数和对应的参数值。
7. signature.replace(parameters, return_annotation)：创建一个新的函数签名对象，用给定的参数和返回值注解替换原有的参数和返回值注解。

七、其他

1. inspect.ArgInfo：在 Python 3.9 中引入的类，表示函数参数的信息。
2. inspect.Attribute：在 Python 3.5 中引入的类，表示类或模块的属性信息。
3. inspect.BlockFinder：在 Python 3.2 中引入的类，用于查找代码块的边界。
4. inspect.BoundArguments：在 Python 3.3 中引入的类，表示绑定到函数签名的参数和对应的参数值。
5. inspect.ClassFoundException：在 Python 3.8 中引入的异常类，用于表示在类定义中找到类定义的异常。
6. inspect.ClosureVars：在 Python 3.8 中引入的类，表示闭包函数的自由变量和绑定值。
7. inspect.CO_ASYNC_GENERATOR：在 Python 3.6 中引入的常量，表示异步生成器对象的代码对象标志。
8. inspect.CO_COROUTINE：在 Python 3.5 中引入的常量，表示协程对象的代码对象标志。
9. inspect.CO_GENERATOR：在 Python 3.2 中引入的常量，表示生成器对象的代码对象标志。
10. inspect.CO_ITERABLE_COROUTINE：在 Python 3.10 中引入的常量，表示可迭代协程对象的代码对象标志。
11. inspect.CO_NESTED：在 Python 3.2 中引入的常量，表示嵌套函数的代码对象标志。
12. inspect.CO_NEWLOCALS：在 Python 3.2 中引入的常量，表示代码对象将创建新的本地命名空间。
13. inspect.CO_NOFREE：在 Python 3.2 中引入的常量，表示代码对象不引用自由变量。
14. inspect.CO_OPTIMIZED：在 Python 3.2 中引入的常量，表示代码对象已进行优化。
15. inspect.CO_VARARGS：在 Python 3.2 中引入的常量，表示函数有可变数量的位置参数。
16. inspect.CO_VARKEYWORDS：在 Python 3.2 中引入的常量，表示函数有可变数量的关键字参数。
17. inspect.CORO_CLOSED：在 Python 3.5 中引入的常量，表示协程对象已关闭。
18. inspect.CORO_CREATED：在 Python 3.5 中引入的常量，表示协程对象已创建。
19. inspect.CORO_RUNNING：在 Python 3.5 中引入的常量，表示协程对象正在运行。
20. inspect.CORO_SUSPENDED：在 Python 3.5 中引入的常量，表示协程对象已暂停。
21. inspect.EndOfBlock：在 Python 3.2 中引入的异常类，表示代码块的结束。
22. inspect.FrameInfo：在 Python 3.2 中引入的类，表示帧对象的信息。
23. inspect.FullArgSpec：在 Python 3.0 中引入的类，表示函数的完整参数信息，包括参数名称、默认值、注解等。
24. inspect.GEN_CLOSED：在 Python 3.5 中引入的常量，表示生成器对象已关闭。
25. inspect.GEN_CREATED：在 Python 3.5 中引入的常量，表示生成器对象已创建。
26. inspect.GEN_RUNNING：在 Python 3.5 中引入的常量，表示生成器对象正在运行。
27. inspect.GEN_SUSPENDED：在 Python 3.5 中引入的常量，表示生成器对象已暂停。
28. inspect.modulesbyfile：一个字典，以文件路径为键，模块对象为值，用于存储已导入的模块。
29. inspect.Parameter：在 Python 3.3 中引入的类，表示函数参数的信息，包括参数名称、默认值、注解等。
30. inspect.TPFLAGS_IS_ABSTRACT：在 Python 3.3 中引入的常量，表示类对象是抽象的。
31. inspect.Traceback：在 Python 3.2 中引入的类，表示异常追踪信息。
32. inspect.Signature：在 Python 3.3 中引入的类，表示函数或方法的签名信息。