登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›[Python] inspect 模块 : 支持在运行时检查代码对象的 P ...

[Python] inspect 模块 : 支持在运行时检查代码对象的 Python 标准库

赐度虻 5 天前
缘起：获取指定的第三方模块的指定组件所在文件，并欲替换该组件


  • 文由： 获取指定的第三方模块的指定组件所在文件，并欲替换该组件。
该组件的某处源代码有bug。
概述： inspect 模块 : 支持在运行时检查代码对象的 Python 标准库

模块简介


  • inspect 是 Python 的标准库中的一个模块，用于获取、检查和操作活动对象的信息。
提供了一些有用的函数帮助获取对象的信息，例如模块、类、方法、函数、回溯、帧对象以及代码对象。
它提供了一组函数，可以在运行时检查代码对象（如模块、类、函数、方法等）的属性、源代码、参数签名等。
例如，它可以帮助你检查类的内容，获取某个方法的源代码，取得并格式化某个函数的参数列表，或者获取你需要显示的回溯的详细信息。


  • 源代码


  • https://github.com/python/cpython/tree/3.13/Lib/inspect.py


  • 官方文档


  • https://docs.python.org/zh-cn/3/library/inspect.html
主要功能

该模块提供了4种主要的功能：类型检查、获取源代码、检查类与函数、检查解释器的调用堆栈。
inspect 模块的主要功能包括：


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


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


  • context：用于指定要获取的调用栈帧的数量
  1. import inspect
  3. def foo():
  4.     bar()
  6. def bar():
  7.     stack = inspect.stack()
  8.     print(stack)
  9.     for frame_info in stack:
  10.         frame = frame_info.frame
  11.         filename = frame.f_code.co_filename
  12.         lineno = frame.f_lineno
  13.         function_name = frame.f_code.co_name
  14.         print(f"File: {filename}, Line: {lineno}, Function: {function_name}")
  16. foo()
复制代码

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


  • object：对象
  • _filename：用于指定一个文件名来辅助确定对象所属的模块
  1. import inspect
  3. def foo():
  4.     pass
  6. module = inspect.getmodule(foo)
  7. print(module.__name__)
复制代码

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


  • frame： 要获取信息的帧对象。
  • context： 指定要获取的源代码行数。默认值为1，表示获取当前行的上下文一行的源代码。
  1. import inspect
  3. def foo():
  4.     bar()
  6. def bar():
  7.     frame = inspect.currentframe()
  8.     frame_info = inspect.getframeinfo(frame)
  9.     print(frame_info.filename)
  10.     print(frame_info.lineno)
  11.     print(frame_info.function)
  13. foo()
复制代码

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


  • func：要获取最内层非包装函数的函数对象。
  • stop：指定一个可调用对象（函数或方法），作为停止查找的标志。如果指定了 stop，则在达到 stop 对象之前的最内层非包装函数将被返回
  1. import inspect
  3. def decorator(func):
  4.     def wrapper():
  5.         print("Before function call")
  6.         func()
  7.         print("After function call")
  8.     return wrapper
  10. @decorator
  11. def my_function():
  12.     print("Inside my_function")
  14. # 获取最内层非包装函数
  15. unwrapped_func = inspect.unwrap(my_function)
  16. unwrapped_func()
复制代码

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


  • cls：要分类属性的类对象。
  1. import inspect
  3. class MyClass:
  4.     class_var = 10
  6.     def __init__(self):
  7.         self.instance_var = 20
  9.     def instance_method(self):
  10.         pass
  12.     @property
  13.     def prop(self):
  14.         return 30
  16.     @classmethod
  17.     def class_method(cls):
  18.         pass
  20.     @staticmethod
  21.     def static_method():
  22.         pass
  24. attrs = inspect.classify_class_attrs(MyClass)
  25. for attr in attrs:
  26.     '''
  27.     name：属性的名称。
  28.     kind：属性的分类，可能的取值为 'data'、'method'、'property'、'class method' 或 'static method'。
  29.     defining_class：定义该属性的类对象。
  30.     object：属性对象本身。
  31.     '''
  32.     print(attr.name, attr.kind, attr.defining_class, attr.object)
复制代码

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


  • doc：要清理的文档字符串。
  1. import inspect
  3. docstring = """
  4.     This is a multi-line
  5.     docstring with indentation.
  7.     It has leading and trailing
  8.     empty lines.
  9. """
  11. cleaned_docstring = inspect.cleandoc(docstring)
  12. print(cleaned_docstring)
复制代码

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


  • object： 要查找源代码的对象。
  1. import inspect
  3. def my_function():
  4.     print("Hello, world!")
  6. source_lines, source_file = inspect.findsource(my_function)
  7. for line in source_lines:
  8.     print(line.strip())
  10. print("原代码文件路径:", source_file)
复制代码

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


  • annotation：要格式化的注解对象。
  • base_module：可选参数，指定基础模块的名称。
  1. import inspect
  3. def my_function(param: int) -> str:
  4.     pass
  6. param_annotation = inspect.signature(my_function).parameters['param'].annotation
  7. formatted_annotation = inspect.formatannotation(param_annotation)
  8. print(formatted_annotation)
复制代码

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


  • obj：要获取签名信息的对象，可以是函数、方法、类或可调用对象。
  • follow_wrapped（可选）：指定是否跟踪被包装的对象。默认为 True，表示会跟踪被包装的对象以获取完整的签名信息。
  • globals（可选）：一个字典，用于指定全局命名空间。默认为 None，表示使用当前的全局命名空间。
  • locals（可选）：一个字典，用于指定局部命名空间。默认为 None，表示使用当前的局部命名空间。
  • eval_str（可选）：一个字符串，用于指定额外的求值环境。默认为 None。
  1. import inspect
  3. def my_function(param1, param2='default', *args, **kwargs):
  4.     pass
  6. signature = inspect.signature(my_function)
  7. print(signature)
复制代码
  1. import inspect
  3. def my_function(param1, param2='default', *args, **kwargs):
  4.     pass
  6. signature = inspect.signature(my_function)
  7. parameters = signature.parameters
  9. for name, parameter in parameters.items():
  10.     print(name, parameter.default, parameter.kind)
复制代码

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


  • args：函数的位置参数的元组。
  • varargs：函数的可变位置参数的名称。
  • varkw：函数的可变关键字参数的名称。
  • locals：函数的本地命名空间字典。
  • formatarg：函数，用于格式化位置参数的字符串表示形式，默认为 str 函数。
  • formatvarargs：函数，用于格式化可变位置参数的字符串表示形式，默认为在参数名称前加上 ‘*’。
  • formatvarkw：函数，用于格式化可变关键字参数的字符串表示形式，默认为在参数名称前加上 ‘**’。
  • formatvalue：函数，用于格式化参数默认值的字符串表示形式，默认为在参数默认值前加上 ‘=’ 和 repr() 函数的结果。
  1. import inspect
  3. def my_function(param1, param2='default', *args, **kwargs):
  4.     pass
  6. args = ('param1', 'param2')
  7. varargs = 'args'
  8. varkw = 'kwargs'
  9. locals_dict = {'param1': 10, 'param2': 'value', 'args': (1, 2, 3), 'kwargs': {'key': 'value'}}
  11. argvalues = inspect.formatargvalues(args, varargs, varkw, locals_dict)
  12. print(argvalues)
复制代码

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


  • obj：要获取注解的对象。
  • globals：字典，用于指定全局命名空间。默认为 None，表示使用当前的全局命名空间。
  • locals：字典，用于指定局部命名空间。默认为 None，表示使用当前的局部命名空间。
  • eval_str：布尔值，指定是否将字符串注解解析为对象。默认为 False。
  1. import inspect
  3. def my_function(param1: int, param2: str = 'default') -> str:
  4.     passannotations = inspect.get_annotations(my_function)
  5. print(annotations)
复制代码

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


  • object：要获取绝对文件路径的对象。
  • _filename：对象的 file 属性。
  1. import inspect
  3. def my_function():
  4.     pass
  6. file_path = inspect.getabsfile(my_function)
  7. print(file_path)
复制代码

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


  • frame：要获取参数值的帧对象。
  1. import inspect
  4. def my_function(param1, param2='default', *args, **kwargs):
  5.     frame = inspect.currentframe()
  6.     args_info = inspect.getargvalues(frame)
  8.     print("位置参数值的列表:", args_info.args)
  9.     print("可变位置参数:", args_info.varargs)
  10.     print("可变关键字参数:", args_info.keywords)
  11.     print("局部变量的字典:", args_info.locals)
  14. my_function('value', param2='custom', extra_arg1='extra_value1', extra_arg2='extra_value2')
复制代码

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


  • obj：要获取属性的对象。
  • attr：属性的名称。
  • default：如果属性不存在，则返回的默认值。
  1. import inspect
  3. class MyClass:
  4.     static_attr = "Static Attribute"
  6. class MyMeta(type):
  7.     def __getattr__(self, attr):
  8.         return inspect.getattr_static(self, attr, "Default Value")
  10. class MySubClass(MyClass, metaclass=MyMeta):
  11.     pass
  13. print(MyClass.static_attr)  # 输出: Static Attribute
  14. print(MySubClass.static_attr)  # 输出: Static Attribute
  15. print(MySubClass.nonexistent_attr)  # 输出: Default Value
复制代码

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

  • func：要调用的函数对象。
  • positional：位置参数的值。
  • named：关键字参数的值。
  1. import inspect
  3. def my_func(a, b, c=0, d=0):
  4.     pass
  6. args = inspect.getcallargs(my_func, 1, 2, d=3)
  7. print(args)
复制代码

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


  • classes：类的列表。
  • unique：布尔值，指定是否返回唯一的类树。默认为 False。
  1. import inspect
  3. class A:
  4.     passclass B(A):
  5.     passclass C(A):
  6.     passclass D(B, C):
  7.     passtree = inspect.getclasstree([A, B, C, D])
  8. for item in tree:
  9.     print(item)
复制代码

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


  • func：要获取闭包变量的函数对象。
  1. import inspect
  3. def outer_func():
  4.     x = 10    def inner_func():
  5.         y = 20        print(x + y)
  6.     return inner_func
  8. closure_vars = inspect.getclosurevars(outer_func())
  9. '''
  10. nonlocals：一个字典，表示函数内部函数引用的外部函数的非局部变量。键是变量名，值是变量值。
  11. globals：一个字典，表示函数内部函数引用的全局变量。键是变量名，值是变量值。
  12. builtins：一个字典，表示函数内部函数引用的内置变量。键是变量名，值是变量值。
  13. unbound：一个集合，表示函数内部函数引用的未绑定的变量。即在函数内部使用但未在函数内部或外部定义的变量。
  14. '''
  15. print(closure_vars.nonlocals)
  16. print(closure_vars.globals)
  17. print(closure_vars.builtins)
  18. print(closure_vars.unbound)
复制代码

  • inspect.getcomments(object)：获取对象的注释。object：要获取注释的对象。
  • inspect.getcoroutinelocals(coroutine)：获取协程对象的局部变量。coroutine：要获取局部变量的协程对象。
  • inspect.getcoroutinestate(coroutine)：获取协程对象的状态。coroutine：要获取状态的协程对象。
  • inspect.getdoc(object)：获取对象的文档字符串。object：要获取文档字符串的对象。
  1. import inspect
  3. class MyClass:
  4.     """
  5.     This is a class.
  6.     """
  8.     def my_method(self):
  9.         """
  10.         This is a method.
  11.         """
  12.         pass
  14. docstring_class = inspect.getdoc(MyClass)
  15. print(docstring_class)  # 输出：'This is a class.'
  17. docstring_method = inspect.getdoc(MyClass.my_method)
  18. print(docstring_method)  # 输出：'This is a method.'
复制代码

  • inspect.getfile(object)：获取对象定义所在的文件名。object：要获取文件名的对象。
  1. import inspect
  3. def my_function():
  4.     pass
  6. file_name = inspect.getfile(my_function)
  7. print(file_name)  # 输出：'path/to/my_script.py'
复制代码

  • inspect.getfullargspec(func)：获取函数的完整参数规范。func：要获取参数规范的函数对象。
  1. import inspect
  3. def my_function(a, b=10, *args, c=20, **kwargs):
  4.     pass
  6. argspec = inspect.getfullargspec(my_function)
  7. '''
  8. args：一个包含函数或方法参数名称的列表。
  9. varargs：表示可变位置参数的名称，如果函数没有可变位置参数，则为 None。
  10. varkw：表示可变关键字参数的名称，如果函数没有可变关键字参数，则为 None。
  11. defaults：一个包含函数或方法默认参数值的元组，如果没有默认参数，则为 None。
  12. kwonlyargs：一个包含仅限关键字参数的名称的列表。
  13. kwonlydefaults：一个包含仅限关键字参数默认值的字典，如果没有仅限关键字参数，则为 None。
  14. annotations：一个包含参数注解的字典，如果没有参数注解，则为 None。
  15. '''
  16. print(argspec.args)  # 输出：['a', 'b']
  17. print(argspec.varargs)  # 输出：'args'
  18. print(argspec.varkw)  # 输出：'kwargs'
  19. print(argspec.defaults)  # 输出：(10,)
  20. print(argspec.kwonlyargs)  # 输出：['c']
  21. print(argspec.kwonlydefaults)  # 输出：{'c': 20}
  22. print(argspec.annotations)  # 输出：{}
复制代码

  • inspect.getgeneratorlocals(generator)：获取生成器对象的局部变量。generator：要获取局部变量的生成器对象。
  1. import inspect
  3. def my_generator():
  4.     x = 1
  5.     yield x
  6.     y = 2
  7.     yield y
  9. gen = my_generator()
  10. next(gen)  # 执行生成器的第一个 yield 语句
  11. locals_dict = inspect.getgeneratorlocals(gen)
  12. print(locals_dict)  # 输出：{'x': 1}
  14. next(gen)  # 执行生成器的第二个 yield 语句
  15. locals_dict = inspect.getgeneratorlocals(gen)
  16. print(locals_dict)  # 输出：{'x': 1, 'y': 2}
复制代码

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


  • tb：堆栈跟踪对象；
  • context：可选参数，指定要获取的帧数，默认为1。


  • inspect.getlineno(frame)：获取帧对象所在的行号。frame：帧对象。
  1. import inspect
  3. def my_function():
  4.     frame = inspect.currentframe()
  5.     lineno = inspect.getlineno(frame)
  6.     print(f"Line number: {lineno}")
  8. my_function()
复制代码

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


  • object：要获取成员列表的对象；
  • predicate：可选参数，用于过滤成员的谓词函数。
  1. import inspect
  3. class MyClass:
  4.     def __init__(self):
  5.         self.x = 1        self.y = 2    def my_method(self):
  6.         print("Hello, World!")
  8. obj = MyClass()
  10. members = inspect.getmembers(obj)
  12. for member in members:
  13.     print(member)
复制代码

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


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


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


  • frame：帧对象；
  • context：可选参数，指定要获取的帧数，默认为1。


  • inspect.getsource(object)：获取对象的源代码。


  • object：要获取源代码的对象。


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


  • inspect.isabstract(object)：检查对象是否是抽象基类（Abstract Base Class）。
  • inspect.isasyncgen(object)：检查对象是否是异步生成器（asynchronous generator）。
  • inspect.isasyncgenfunction(object)：检查对象是否是异步生成器函数（asynchronous generator function）。
  • inspect.isawaitable(object)：检查对象是否可等待（awaitable）。
  • inspect.isbuiltin(object)：检查对象是否是内置函数或方法。
  • inspect.isclass(object)：检查对象是否是类。
  • inspect.iscode(object)：检查对象是否是代码对象。
  • inspect.iscoroutine(object)：检查对象是否是协程（coroutine）。
  • inspect.iscoroutinefunction(object)：检查对象是否是协程函数（coroutine function）。
  • inspect.isdatadescriptor(object)：检查对象是否是数据描述符（data descriptor）。
  • inspect.isframe(object)：检查对象是否是帧对象（frame）。
  • inspect.isfunction(object)：检查对象是否是函数。
  • inspect.isgenerator(object)：检查对象是否是生成器（generator）。
  • inspect.isgeneratorfunction(object)：检查对象是否是生成器函数（generator function）。
  • inspect.isgetsetdescriptor(object)：检查对象是否是属性描述符（get-set descriptor）。
  • inspect.ismemberdescriptor(object)：检查对象是否是成员描述符（member descriptor）。
  • inspect.ismethod(object)：检查对象是否是方法。
  • inspect.ismethoddescriptor(object)：检查对象是否是方法描述符（method descriptor）。
  • inspect.ismethodwrapper(object)：检查对象是否是方法包装器（method wrapper）。
  • inspect.ismodule(object)：检查对象是否是模块。
  • inspect.isroutine(object)：检查对象是否是可调用对象（函数、方法、生成器等）。
  • inspect.istraceback(object)：检查对象是否是追踪回溯（traceback）对象。
  • inspect.walktree(classes, children, parent)
  • inspect.trace()
  • inspect.formatannotationrelativeto(object)
  • inspect.getblock(lines)
  • inspect.indentsize(line)
帧信息/inspect.FrameInfo


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


  • inspect.FrameInfo.frame.f_back：指向调用当前帧的帧对象。
  • 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：表示代码对象的行号表。


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


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


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


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

CASE 获取指定模块下指定组件的文件路径
  1. import inspect;
  2. import can;
  4. print('path：', inspect.getfile( can.io.BLFReader )) # 'C:\\Users\\EDY\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\can\\io\\blf.py'
  5. print('path：', inspect.getfile( can.io.ASCReader )) # 'C:\\Users\\EDY\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\can\\io\\asc.py'
复制代码
Y 推荐文献


  • Python Module : Inspect


  • https://docs.python.org/zh-cn/3/library/inspect.html
  • https://github.com/python/cpython/tree/3.13/Lib/inspect.py


  • Python Module : importlib
importlib是Python的内置模块，提供了用于动态加载和导入模块的功能。
我们可以使用importlib模块的find_loader()函数来获取模块的文件路径。
  1. import importlib.util
  3. # spec = importlib.util.find_spec("my_module")
  4. spec = importlib.util.find_spec("can")
  5. module_path = spec.origin
  6. print("模块的路径是：", module_path) # 'C:\\Users\\EDY\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\can\\__init__.py'
复制代码

  • Python Module : modulefinder
from modulefinder import ModuleFinder
X 参考文献


  • Python 如何获取模块的路径 - 极客教程
  • python内置模块之inspect，获取、检查和操作活动对象的信息 - CSDN
    本文作者：        千千寰宇   
    本文链接：         https://www.cnblogs.com/johnnyzen   
    关于博文：评论和私信会在第一时间回复，或直接私信我。   
    版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA     许可协议。转载请注明出处！
    日常交流：大数据与软件开发-QQ交流群: 774386015        【入群二维码】参见左下角。您的支持、鼓励是博主技术写作的重要动力！   

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
赐度虻
5 天前

0

粉丝关注

14

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫