inspect ---检查带电物体

源代码： Lib/inspect.py

---

这个 inspect 模块提供了几个有用的函数来帮助获取有关活动对象的信息，如模块、类、方法、函数、回溯、帧对象和代码对象。例如，它可以帮助您检查类的内容，检索方法的源代码，提取和格式化函数的参数列表，或者获取显示详细的回溯所需的所有信息。

该模块提供四种主要的服务：类型检查、获取源代码、检查类和函数以及检查解释器堆栈。

类型和成员

这个 getmembers() 函数检索对象（如类或模块）的成员。名称以“is”开头的函数主要作为第二个参数 getmembers() . 它们还可以帮助您确定何时可以找到以下特殊属性：

类型	属性	描述
模块	__doc__	文档字符串
	__file__	文件名（内置模块缺少）
类	__doc__	文档字符串
	__name__	定义此类时使用的名称
	__qualname__	限定名
	__module__	定义此类的模块的名称
方法	__doc__	文档字符串
	__name__	定义此方法的名称
	__qualname__	限定名
	__func__	包含方法实现的函数对象
	__self__	此方法绑定到的实例，或 None
	__module__	定义此方法的模块的名称
功能	__doc__	文档字符串
	__name__	定义此函数时使用的名称
	__qualname__	限定名
	__code__	包含已编译函数的代码对象 bytecode
	__defaults__	位置参数或关键字参数的任何默认值的元组
	__kwdefaults__	仅关键字参数的任何默认值的映射
	__globals__	定义此函数的全局命名空间
	__annotations__	参数名称到注释的映射； "return" 键是为返回批注保留的。
	__module__	定义此函数的模块的名称
追溯	tb_frame	在此级别设置对象的框架
	tb_lasti	字节码中上次尝试指令的索引
	tb_lineno	python源代码中的当前行号
	tb_next	下一个内部回溯对象（由该级别调用）
框架	f_back	下一个外部帧对象（此帧的调用方）
	f_builtins	此帧看到的内置命名空间
	f_code	在此框架中执行的代码对象
	f_globals	此框架看到的全局命名空间
	f_lasti	字节码中上次尝试指令的索引
	f_lineno	python源代码中的当前行号
	f_locals	此框架看到的本地命名空间
	f_trace	此帧的跟踪函数，或 None
代码	co_argcount	参数数目（不包括仅关键字的参数， * 或 * * 参数）
	co_code	原始编译字节码字符串
	co_cellvars	单元格变量名称的元组（由包含范围引用）
	co_consts	字节码中使用的常量元组
	co_filename	创建此代码对象的文件名
	co_firstlineno	python源代码中的第一行数
	co_flags	位图 CO_* 标记，阅读更多 here
	co_lnotab	行号到字节码索引的编码映射
	co_freevars	自由变量名的元组（通过函数的闭包引用）
	co_posonlyargcount	仅位置参数的数目
	co_kwonlyargcount	仅关键字参数的数目（不包括 * * 精氨酸）
	co_name	用于定义此代码对象的名称
	co_names	局部变量名元组
	co_nlocals	局部变量数
	co_stacksize	需要虚拟机堆栈空间
	co_varnames	参数和局部变量名称的元组
生成器	__name__	名称
	__qualname__	限定名
	gi_frame	框架
	gi_running	生成器在运行吗？
	gi_code	代码
	gi_yieldfrom	正在被迭代的对象 yield from 或 None
协同程序	__name__	名称
	__qualname__	限定名
	cr_await	正在等待的对象，或 None
	cr_frame	框架
	cr_running	协同程序在运行吗？
	cr_code	代码
	cr_origin	创建协同程序的位置，或 None . 参见协程原点链接|
内建	__doc__	文档字符串
	__name__	此函数或方法的原始名称
	__qualname__	限定名
	__self__	方法绑定到的实例，或 None

在 3.5 版更改: 添加 __qualname__ 和 gi_yieldfrom 生成器的属性。

这个 __name__ 生成器的属性现在由函数名而不是代码名设置，现在可以修改它。

在 3.7 版更改: 添加 cr_origin 属于协同作战。

inspect.getmembers(object[, predicate])

返回对象列表中的所有成员 (name, value) 按名称排序的对。如果可选 谓语 将用调用的参数 value 提供每个成员的对象，只包括谓词返回真值的成员。

注解

getmembers() 当参数为类且这些属性已在元类的自定义中列出时，将仅返回在元类中定义的类属性 __dir__() .

inspect.getmodulename(path)

返回由文件命名的模块的名称 path ，不包括封闭包的名称。文件扩展名将根据中的所有条目进行检查。 importlib.machinery.all_suffixes() . 如果匹配，则返回最终路径组件并删除扩展名。否则， None 返回。

注意这个函数 only 为实际的python模块返回一个有意义的名称-可能引用python包的路径仍将返回 None .

在 3.3 版更改: 该函数直接基于 importlib .

inspect.ismodule(object)

返回 True 如果对象是模块。

inspect.isclass(object)

返回 True 如果对象是类，则无论是内置的还是用Python代码创建的。

inspect.ismethod(object)

返回 True 如果对象是用Python编写的绑定方法。

inspect.isfunction(object)

返回 True 如果对象是Python函数，它包括由 lambda 表达式。

inspect.isgeneratorfunction(object)

返回 True 如果对象是Python生成器函数。

在 3.8 版更改: 函数包装 functools.partial() 现在回来 True 如果包装的函数是Python生成器函数。

inspect.isgenerator(object)

返回 True 如果对象是生成器。

inspect.iscoroutinefunction(object)

返回 True 如果对象是 coroutine function （函数定义为 async def 语法）。

3.5 新版功能.

在 3.8 版更改: 函数包装 functools.partial() 现在回来 True 如果包装函数是 coroutine function .

inspect.iscoroutine(object)

返回 True 如果对象是 coroutine 由AN创建 async def 功能。

3.5 新版功能.

inspect.isawaitable(object)

返回 True 如果对象可以用于 await 表达式。

也可用于区分基于生成器的协同程序与常规生成器：

def gen():
    yield
@types.coroutine
def gen_coro():
    yield

assert not isawaitable(gen())
assert isawaitable(gen_coro())

3.5 新版功能.

inspect.isasyncgenfunction(object)

返回 True 如果对象是 asynchronous generator 函数，例如：

>>> async def agen():
...     yield 1
...
>>> inspect.isasyncgenfunction(agen)
True

3.6 新版功能.

在 3.8 版更改: 函数包装 functools.partial() 现在回来 True 如果包装函数是 asynchronous generator 功能。

inspect.isasyncgen(object)

返回 True 如果对象是 asynchronous generator iterator 由AN创建 asynchronous generator 功能。

3.6 新版功能.

inspect.istraceback(object)

返回 True 如果对象是回溯。

inspect.isframe(object)

返回 True 如果对象是帧。

inspect.iscode(object)

返回 True 如果对象是代码。

inspect.isbuiltin(object)

返回 True 如果对象是内置函数或绑定内置方法。

inspect.isroutine(object)

返回 True 如果对象是用户定义的或内置的函数或方法。

inspect.isabstract(object)

返回 True 如果对象是抽象基类。

inspect.ismethoddescriptor(object)

返回 True 如果对象是方法描述符，但不是 ismethod() ， isclass() ， isfunction() 或 isbuiltin() 是真的。

例如，这是对的 int.__add__ . 通过此测试的对象具有 __get__() 方法，但不是 __set__() 方法，但除此之外，属性集也会有所不同。一 __name__ 属性通常是合理的，并且 __doc__ 往往是。

通过也通过其他测试之一的描述符实现的方法返回 False 从 ismethoddescriptor() 测试，仅仅是因为其他测试承诺更多——您可以，例如，依靠 __func__ 对象通过时的属性（等） ismethod() .

inspect.isdatadescriptor(object)

返回 True 如果对象是数据描述符。

数据描述符有 __set__ 或A __delete__ 方法。例如属性（在python中定义）、getset和成员。后两个测试是在C中定义的，对于这些类型有更具体的测试可用，这在Python实现中是健壮的。通常，数据描述符也会 __name__ 和 __doc__ 属性（属性、getset和成员都具有这两个属性），但这是不保证的。

inspect.isgetsetdescriptor(object)

返回 True 如果对象是getset描述符。

CPython implementation detail: getset是在扩展模块中通过 PyGetSetDef 结构。对于没有此类类型的Python实现，此方法将始终返回 False .

inspect.ismemberdescriptor(object)

返回 True 如果对象是成员描述符。

CPython implementation detail: 成员描述符是在扩展模块中通过 PyMemberDef 结构。对于没有此类类型的Python实现，此方法将始终返回 False .

正在检索源代码

inspect.getdoc(object)

获取对象的文档字符串，使用 cleandoc() . 如果没有提供对象的文档字符串，并且对象是类、方法、属性或描述符，请从继承层次结构中检索文档字符串。

在 3.5 版更改: 如果不重写，文档字符串现在将被继承。

inspect.getcomments(object)

在单个字符串中，返回对象源代码（对于类、函数或方法）前面或Python源文件顶部（如果对象是模块）的任何注释行。如果对象的源代码不可用，则返回 None . 如果对象是在C或交互shell中定义的，则可能发生这种情况。

inspect.getfile(object)

返回在其中定义对象的（文本或二进制）文件的名称。这将失败 TypeError 如果对象是内置模块、类或函数。

inspect.getmodule(object)

尝试猜测对象是在哪个模块中定义的。

inspect.getsourcefile(object)

返回定义对象的python源文件的名称。这将失败 TypeError 如果对象是内置模块、类或函数。

inspect.getsourcelines(object)

返回对象的源行和起始行号列表。参数可以是模块、类、方法、函数、回溯、框架或代码对象。源代码作为与对象对应的行的列表返回，行号指示在原始源文件中找到第一行代码的位置。安 OSError 如果无法检索源代码，则引发。

在 3.3 版更改: OSError 被引发而不是 IOError ，现在是前者的别名。

inspect.getsource(object)

返回对象的源代码文本。参数可以是模块、类、方法、函数、回溯、框架或代码对象。源代码作为单个字符串返回。安 OSError 如果无法检索源代码，则引发。

在 3.3 版更改: OSError 被引发而不是 IOError ，现在是前者的别名。

inspect.cleandoc(doc)

清除文档字符串中与代码块对齐的缩进。

所有前导空格都从第一行中删除。任何可以从第二行开始均匀删除的前导空格都将被删除。开始和结束的空行随后被删除。此外，所有选项卡都展开为空格。

使用签名对象自省可调用文件

3.3 新版功能.

签名对象表示可调用对象及其返回批注的调用签名。要检索签名对象，请使用 signature() 功能。

inspect.signature(callable, *, follow_wrapped=True, globalns=None, localns=None)

返回A Signature 给定对象 callable ：：

>>> from inspect import signature
>>> def foo(a, *, b:int, **kwargs):
...     pass

>>> sig = signature(foo)

>>> str(sig)
'(a, *, b:int, **kwargs)'

>>> str(sig.parameters['b'])
'b:int'

>>> sig.parameters['b'].annotation
<class 'int'>

接受广泛的python可调用文件，从普通函数和类到 functools.partial() 物体。

引发 ValueError 如果不能提供签名，以及 TypeError 如果不支持该类型的对象。

globalns 和 localns 被传递到 typing.get_type_hints() 在解析注释时。

函数签名中的斜线（/）表示其前面的参数仅为位置参数。有关详细信息，请参阅 the FAQ entry on positional-only parameters .

3.5 新版功能: follow_wrapped 参数。通过 False 得到…的签名 callable 明确地 (callable.__wrapped__ 不会用于打开装饰的可调用文件。）

3.10 新版功能: globalns 和 localns 参数。

注解

在某些Python实现中，某些可调用文件可能不可内省。例如，在cpython中，C中定义的一些内置函数没有提供关于其参数的元数据。

注解

将首先尝试解析批注，但当执行该操作时失败并遇到错误时，批注将原封不动地返回(以字符串形式)。

class inspect.Signature(parameters=None, *, return_annotation=Signature.empty)

签名对象表示函数及其返回批注的调用签名。对于函数接受的每个参数，它存储一个 Parameter 对象中 parameters 收集。

可选的 参数 参数是 Parameter 对象，验证以检查是否没有具有重复名称的参数，以及参数的顺序是否正确，即只按位置排序，然后按位置或关键字，以及具有默认值的参数是否遵循不带默认值的参数。

可选的 return_annotation 参数，可以是任意的python对象，是可调用的“返回”注释。

签名对象是 不变的 . 使用 Signature.replace() 制作修改过的副本。

在 3.5 版更改: 签名对象是可拾取的和可散列的。

empty

用于指定缺少返回批注的特殊类级标记。

parameters

参数名称到相应的 Parameter 物体。参数按严格的定义顺序出现，包括仅关键字的参数。

在 3.7 版更改: 从3.7版开始，python只显式地保证了只包含关键字的参数的声明顺序，尽管在实践中，这个顺序一直保留在python 3中。

return_annotation

可调用文件的“返回”注释。如果可调用文件没有“返回”批注，则此属性设置为 Signature.empty .

bind(*args, **kwargs)

创建从位置参数和关键字参数到参数的映射。返回 BoundArguments 如果 *args 和 **kwargs 匹配签名，或引发 TypeError .

bind_partial(*args, **kwargs)

工作方式与 Signature.bind() ，但允许省略某些必需的参数（模拟 functools.partial() 行为。）返回 BoundArguments 或提出 TypeError 如果传递的参数与签名不匹配。

replace(*[, parameters][, return_annotation])

根据调用的实例replace创建新的签名实例。可以通过不同的 parameters 和/或 return_annotation 重写基签名的相应属性。要从复制的签名中删除返回注释，请传入 Signature.empty .

>>> def test(a, b):
...     pass
>>> sig = signature(test)
>>> new_sig = sig.replace(return_annotation="new return anno")
>>> str(new_sig)
"(a, b) -> 'new return anno'"

classmethod from_callable(obj, *, follow_wrapped=True, globalns=None, localns=None)

返回一个 Signature 给定可调用对象的(或其子类)对象 obj 。经过 follow_wrapped=False 获得…的签名 obj 而不展开其 __wrapped__ 链条。 globalns 和 localns 在解析注释时将用作命名空间。

此方法简化了 Signature ：：

class MySignature(Signature):
    pass
sig = MySignature.from_callable(min)
assert isinstance(sig, MySignature)

3.5 新版功能.

3.10 新版功能: globalns 和 localns 参数。

class inspect.Parameter(name, kind, *, default=Parameter.empty, annotation=Parameter.empty)

参数对象是 不变的 . 您可以使用 Parameter.replace() 创建修改过的副本。

在 3.5 版更改: 参数对象是可拾取的和可散列的。

empty

用于指定缺少默认值和注释的特殊类级标记。

name

作为字符串的参数名称。名称必须是有效的python标识符。

CPython implementation detail: cpython生成表单的隐式参数名 .0 用于实现理解和生成器表达式的代码对象。

在 3.6 版更改: 此模块将这些参数名公开为以下名称： implicit0 .

default

参数的默认值。如果参数没有默认值，则此属性设置为 Parameter.empty .

annotation

参数的批注。如果参数没有注释，则此属性设置为 Parameter.empty .

kind

描述参数值如何绑定到参数。可能值（可通过访问 Parameter ，像 Parameter.KEYWORD_ONLY ）：

名字	意义
POSITIONAL_ONLY	值必须作为位置参数提供。仅位置参数是出现在 / python函数定义中的条目（如果存在）。
POSITIONAL_OR_KEYWORD	值可以作为关键字或位置参数提供（这是在Python中实现的函数的标准绑定行为）。
VAR_POSITIONAL	没有绑定到任何其他参数的位置参数的元组。这对应于 *args python函数定义中的参数。
KEYWORD_ONLY	值必须作为关键字参数提供。仅关键字参数是出现在 * 或 *args python函数定义中的项。
VAR_KEYWORD	未绑定到任何其他参数的关键字参数的dict。这对应于 **kwargs python函数定义中的参数。

示例：打印没有默认值的所有仅关键字参数：：

>>> def foo(a, b, *, c, d=10):
...     pass

>>> sig = signature(foo)
>>> for param in sig.parameters.values():
...     if (param.kind == param.KEYWORD_ONLY and
...                        param.default is param.empty):
...         print('Parameter:', param)
Parameter: c

kind.description

描述parameter.kind的枚举值。

3.8 新版功能.

示例：打印参数的所有描述：：

>>> def foo(a, b, *, c, d=10):
...     pass

>>> sig = signature(foo)
>>> for param in sig.parameters.values():
...     print(param.kind.description)
positional or keyword
positional or keyword
keyword-only
keyword-only

replace(*[, name][, kind][, default][, annotation])

基于在上调用的替换实例创建新的参数实例。覆盖一个 Parameter 属性，传递相应的参数。要从参数中删除默认值或/和批注，请通过 Parameter.empty .

>>> from inspect import Parameter
>>> param = Parameter('foo', Parameter.KEYWORD_ONLY, default=42)
>>> str(param)
'foo=42'

>>> str(param.replace()) # Will create a shallow copy of 'param'
'foo=42'

>>> str(param.replace(default=Parameter.empty, annotation='spam'))
"foo:'spam'"

在 3.4 版更改: 在python 3.3中，允许参数对象具有 name 设置为 None 如果他们 kind 被设定为 POSITIONAL_ONLY .这不再被允许。

class inspect.BoundArguments

A的结果 Signature.bind() 或 Signature.bind_partial() 调用。保留参数到函数参数的映射。

arguments

参数“名称到参数”值的可变映射。只包含显式绑定的参数。变化 arguments 将反映在 args 和 kwargs .

应与 Signature.parameters 用于任何参数处理目的。

注解

其中的参数 Signature.bind() 或 Signature.bind_partial() 依赖默认值将被跳过。但是，如果需要，使用 BoundArguments.apply_defaults() 添加它们。

在 3.9 版更改: arguments 现在是类型 dict . 以前，它是 collections.OrderedDict .

args

位置参数值的元组。动态计算自 arguments 属性。

kwargs

关键字参数值的字典。动态计算自 arguments 属性。

signature

对父级的引用 Signature 对象。

apply_defaults()

为缺少的参数设置默认值。

对于变量位置参数 (*args ）默认值为空元组。

对于变量关键字参数 (**kwargs ）默认值是空的dict。

>>> def foo(a, b='ham', *args): pass
>>> ba = inspect.signature(foo).bind('spam')
>>> ba.apply_defaults()
>>> ba.arguments
{'a': 'spam', 'b': 'ham', 'args': ()}

3.5 新版功能.

这个 args 和 kwargs 属性可用于调用函数：：

def test(a, *, b):
    ...

sig = signature(test)
ba = sig.bind(10, b=20)
test(*ba.args, **ba.kwargs)

参见

PEP 362 -函数签名对象。

详细的规范、实现细节和示例。

类和函数

inspect.getclasstree(classes, unique=False)

将给定的类列表排列成嵌套列表的层次结构。如果出现嵌套列表，则它包含从其条目位于列表前面的类派生的类。每个条目都是一个包含类及其基类的元组的2元组。如果 独特的 参数为true，给定列表中每个类的返回结构中只显示一个条目。否则，使用多重继承的类及其后代将出现多次。

inspect.getargspec(func)

获取python函数参数的名称和默认值。一 named tuple ArgSpec(args, varargs, keywords, defaults) 返回。 args 是参数名称的列表。 可变参数 和 关键词 是的名字 * 和 ** 参数或 None . 默认值 是默认参数值的元组或 None 如果没有默认参数；如果此元组具有 n 元素，它们对应于最后一个 n 中列出的元素 args .

3.0 版后已移除: 使用 getfullargspec() 对于更新后的API，它通常是一种替换，但也正确地处理函数注释和仅关键字参数。

或者，使用 signature() 和 Signature Object 它为可调用文件提供了一个更结构化的自省API。

inspect.getfullargspec(func)

获取python函数参数的名称和默认值。一 named tuple 返回：

FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations)

args 是位置参数名称的列表。 可变参数 是的名称 * 参数或 None 如果不接受任意位置参数。 瓦千瓦 是的名称 ** 参数或 None 如果不接受任意关键字参数。 默认值 是一个 n -与最后一个参数值对应的默认参数值的元组 n 位置参数，或 None 如果没有定义此类默认值。 库瓦利格斯 是按声明顺序排列的仅关键字参数名列表。 KyLyDebug 是字典映射参数名的来源 库瓦利格斯 如果没有提供参数，则使用默认值。 注解 是将参数名映射到批注的字典。特殊键 "return" 用于报告函数返回值注释（如果有）。

注意 signature() 和 Signature Object 为可调用的内省提供推荐的API，并支持扩展模块API中有时遇到的其他行为（如仅位置参数）。此函数主要用于需要与Python2保持兼容性的代码中。 inspect 模块API。

在 3.4 版更改: 此函数现在基于 signature() 但仍然忽略 __wrapped__ 属性，并在绑定方法的签名输出中包含已绑定的第一个参数。

在 3.6 版更改: 此方法以前被记录为赞成 signature() 在python 3.5中，但是为了恢复一个清晰支持的标准接口，这个决定被颠倒了，因为从遗留代码迁移出去的单源python 2/3代码需要一个清晰支持的标准接口。 getargspec() 应用程序编程接口。

在 3.7 版更改: 从3.7版开始，python只显式地保证了只包含关键字的参数的声明顺序，尽管在实践中，这个顺序一直保留在python 3中。

inspect.getargvalues(frame)

获取有关传递到特定框架的参数的信息。A named tuple ArgInfo(args, varargs, keywords, locals) 返回。 args 是参数名的列表。 可变参数 和 关键词 是的名字 * 和 ** 参数或 None . locals 是给定帧的本地字典。

注解

在Python3.5中，该函数被无意中标记为已弃用。

inspect.formatargspec(args[, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations[, formatarg, formatvarargs, formatvarkw, formatvalue, formatreturns, formatannotations]])

根据返回的值设置漂亮的参数规范的格式 getfullargspec() .

前七个参数是 (args ， varargs ， varkw ， defaults ， kwonlyargs ， kwonlydefaults ， annotations ）

其他六个参数是调用以转换参数名的函数， * 参数名， ** 参数名、默认值、返回注释和单个注释分别为字符串。

例如：

>>> from inspect import formatargspec, getfullargspec
>>> def f(a: int, b: float):
...     pass
...
>>> formatargspec(*getfullargspec(f))
'(a: int, b: float)'

3.5 版后已移除: 使用 signature() 和 Signature Object 这为可调用文件提供了更好的自省API。

inspect.formatargvalues(args[, varargs, varkw, locals, formatarg, formatvarargs, formatvarkw, formatvalue])

从返回的四个值中格式化一个漂亮的参数规范 getargvalues() . 格式 * 参数是相应的可选格式化函数，用于将名称和值转换为字符串。

注解

在Python3.5中，该函数被无意中标记为已弃用。

inspect.getmro(cls)

以方法解析顺序返回类cls的基类（包括cls）的元组。在这个元组中没有类出现过一次以上。请注意，方法解析顺序取决于cls的类型。除非使用非常特殊的用户定义的元类型，否则cls将是tuple的第一个元素。

inspect.getcallargs(func, /, *args, **kwds)

绑定 args 和 kwds 到python函数或方法的参数名 func 好像是他们一起调用来的。对于绑定方法，还绑定第一个参数（通常命名为 self ）到关联的实例。返回dict，映射参数名（包括 * 和 ** 参数（如果有）的值来自 args 和 kwds . 如果调用 func 不正确，即无论何时 func(*args, **kwds) 将引发异常，因为签名不兼容，将引发相同类型和相同或类似消息的异常。例如：：

>>> from inspect import getcallargs
>>> def f(a, b=1, *pos, **named):
...     pass
>>> getcallargs(f, 1, 2, 3) == {'a': 1, 'named': {}, 'b': 2, 'pos': (3,)}
True
>>> getcallargs(f, a=2, x=4) == {'a': 2, 'named': {'x': 4}, 'b': 1, 'pos': ()}
True
>>> getcallargs(f)
Traceback (most recent call last):
...
TypeError: f() missing 1 required positional argument: 'a'

3.2 新版功能.

3.5 版后已移除: 使用 Signature.bind() 和 Signature.bind_partial() 相反。

inspect.getclosurevars(func)

获取python函数或方法中外部名称引用的映射 func 它们的当前值。A named tuple ClosureVars(nonlocals, globals, builtins, unbound) 返回。 非本地人 将引用的名称映射到词法闭包变量， globals 到函数的模块全局 Builtins 从函数体中可见的内置函数。 未绑定的 在给定当前模块全局值和内置值的情况下，函数中引用的一组名称根本无法解析。

TypeError 如果 func 不是python函数或方法。

3.3 新版功能.

inspect.unwrap(func, *, stop=None)

将对象封装 func . 它沿着 __wrapped__ 返回链中最后一个对象的属性。

stop 是可选回调，接受封装链中的对象作为其唯一参数，如果回调返回真值，则允许提前终止展开。如果回调从未返回真值，则会像往常一样返回链中的最后一个对象。例如， signature() 如果链中的任何对象具有 __signature__ 属性已定义。

ValueError 在遇到循环时引发。

3.4 新版功能.

解释器堆栈

当以下函数返回“帧记录”时，每个记录都是 named tuple FrameInfo(frame, filename, lineno, function, code_context, index) . 元组包含帧对象、文件名、当前行的行号、函数名、源代码中上下文行的列表以及该列表中当前行的索引。

在 3.5 版更改: 返回命名元组而不是元组。

注解

保存对帧对象的引用（在帧的第一个元素中找到）可以记录这些函数返回的结果，这会导致程序创建引用循环。一旦创建了一个引用循环，即使启用了python的可选循环检测器，从构成循环的对象访问的所有对象的寿命也会更长。如果必须创建这样的循环，则必须确保它们被显式破坏，以避免对象的延迟破坏和发生的内存消耗增加。

虽然周期检测器会捕捉到这些信息，但是通过在 finally 条款。如果在编译或使用python时禁用了循环检测器，则这一点也很重要。 gc.disable() . 例如：：

def handle_stackframe_without_leak():
    frame = inspect.currentframe()
    try:
        # do something with the frame
    finally:
        del frame

如果您想保留框架（例如稍后打印一个回溯），您也可以使用 frame.clear() 方法。

可选的 context 大多数函数支持的参数指定要返回的上下文行数，这些行围绕当前行居中。

inspect.getframeinfo(frame, context=1)

获取有关帧或回溯对象的信息。一 named tuple Traceback(filename, lineno, function, code_context, index) 返回。

inspect.getouterframes(frame, context=1)

获取帧和所有外部帧的帧记录列表。这些帧表示导致创建 框架 . 返回列表中的第一个条目表示 框架 ；最后一个条目表示对 框架 堆栈。

在 3.5 版更改: 列表 named tuples FrameInfo(frame, filename, lineno, function, code_context, index) 返回。

inspect.getinnerframes(traceback, context=1)

获取回溯框架和所有内部框架的框架记录列表。这些帧表示由于 框架 . 列表中的第一个条目表示 追溯 ；最后一个条目表示引发异常的位置。

在 3.5 版更改: 列表 named tuples FrameInfo(frame, filename, lineno, function, code_context, index) 返回。

inspect.currentframe()

返回调用方堆栈帧的帧对象。

CPython implementation detail: 这个函数依赖于解释器中的python堆栈帧支持，这并不能保证在python的所有实现中都存在。如果在没有python堆栈帧的实现中运行，则此函数返回 None .

inspect.stack(context=1)

返回调用方堆栈的帧记录列表。返回列表中的第一个条目表示调用者；最后一个条目表示堆栈上最外层的调用。

在 3.5 版更改: 列表 named tuples FrameInfo(frame, filename, lineno, function, code_context, index) 返回。

inspect.trace(context=1)

返回当前帧和引发当前正在处理的异常的帧之间堆栈的帧记录列表。列表中的第一个条目表示调用方；最后一个条目表示引发异常的位置。

在 3.5 版更改: 列表 named tuples FrameInfo(frame, filename, lineno, function, code_context, index) 返回。

静态获取属性

两个 getattr() 和 hasattr() 在获取或检查属性是否存在时，可以触发代码执行。描述符和属性一样，将被调用并 __getattr__() 和 __getattribute__() 可以称之为。

对于需要被动自省的情况，比如文档工具，这可能不方便。 getattr_static() 签名与 getattr() 但在获取属性时避免执行代码。

inspect.getattr_static(obj, attr, default=None)

在不通过描述符协议触发动态查找的情况下检索属性， __getattr__() 或 __getattribute__() .

注意：此函数可能无法检索getattr可以获取的所有属性（如动态创建的属性），并且可能会查找getattr不能获取的属性（如引发attributeError的描述符）。它还可以返回描述符对象而不是实例成员。

如果实例 __dict__ 被另一个成员（例如属性）隐藏，则此函数将找不到实例成员。

3.2 新版功能.

getattr_static() 不解析描述符，例如在C中实现的对象上解析槽描述符或getset描述符。将返回描述符对象而不是基础属性。

您可以使用如下代码处理这些问题。注意，对于任意的getset描述符，调用这些描述符可能会触发代码执行：

# example code for resolving the builtin descriptor types
class _foo:
    __slots__ = ['foo']

slot_descriptor = type(_foo.foo)
getset_descriptor = type(type(open(__file__)).name)
wrapper_descriptor = type(str.__dict__['__add__'])
descriptor_types = (slot_descriptor, getset_descriptor, wrapper_descriptor)

result = getattr_static(some_object, 'foo')
if type(result) in descriptor_types:
    try:
        result = result.__get__()
    except AttributeError:
        # descriptors can raise AttributeError to
        # indicate there is no underlying value
        # in which case the descriptor itself will
        # have to do
        pass

生成器和协程器的当前状态

当实现协同调度程序以及其他高级的生成器使用时，确定生成器当前正在执行、正在等待启动、恢复或执行，或者已经终止都很有用。 getgeneratorstate() 允许轻松确定生成器的当前状态。

inspect.getgeneratorstate(generator)

获取生成器迭代器的当前状态。

可能的状态有：

• gen_created:等待开始执行。

• gen_正在运行：当前由解释器执行。

• gen_suspended：当前在产量表达式处暂停。

• Gen_Closed:执行已完成。

3.2 新版功能.

inspect.getcoroutinestate(coroutine)

获取协程对象的当前状态。该函数用于由 async def 函数，但将接受具有 cr_running 和 cr_frame 属性。

可能的状态有：

• 创建：等待开始执行。

• CORO U运行：当前正在由解释器执行。

• coro_suspended：当前在等待表达式中被挂起。

• 关闭：执行已完成。

3.5 新版功能.

还可以查询生成器的当前内部状态。这主要用于测试目的，以确保内部状态按预期进行更新：

inspect.getgeneratorlocals(generator)

获取活动局部变量的映射 生成器 它们的当前值。返回从变量名映射到值的字典。这相当于调用 locals() 在生成器的机体中，同样的警告也适用。

如果 生成器 是一个 generator 如果没有当前关联的框架，则返回空字典。 TypeError 如果 生成器 不是python生成器对象。

CPython implementation detail: 这个函数依赖于一个为内省而公开Python堆栈框架的生成器，这在所有的Python实现中都不一定是这样的。在这种情况下，此函数将始终返回空字典。

3.3 新版功能.

inspect.getcoroutinelocals(coroutine)

此函数类似于 getgeneratorlocals() ，但适用于由 async def 功能。

3.5 新版功能.

代码对象位标志

python代码对象具有 co_flags 属性，它是以下标志的位图：

inspect.CO_OPTIMIZED

使用快速局部变量优化代码对象。

inspect.CO_NEWLOCALS

如果设置，将为框架创建新的dict f_locals 执行代码对象时。

inspect.CO_VARARGS

代码对象具有可变位置参数 (*args -像）。

inspect.CO_VARKEYWORDS

代码对象有一个变量关键字参数 (**kwargs -像）。

inspect.CO_NESTED

当代码对象是嵌套函数时，将设置该标志。

inspect.CO_GENERATOR

当代码对象是一个生成器函数时，即在代码对象执行时返回一个生成器对象时，将设置该标志。

inspect.CO_NOFREE

如果没有自由变量或单元格变量，则设置该标志。

inspect.CO_COROUTINE

当代码对象是协同程序函数时，将设置该标志。当代码对象被执行时，它返回一个协程对象。见 PEP 492 了解更多详细信息。

3.5 新版功能.

inspect.CO_ITERABLE_COROUTINE

该标志用于将生成器转换为基于生成器的协程。带有此标志的生成器对象可用于 await 表达式，并且可以 yield from 协程对象。见 PEP 492 了解更多详细信息。

3.5 新版功能.

inspect.CO_ASYNC_GENERATOR

当代码对象是异步生成器函数时，将设置该标志。当代码对象被执行时，它返回一个异步生成器对象。见 PEP 525 了解更多详细信息。

3.6 新版功能.

注解

这些标志是特定于cpython的，可能在其他Python实现中没有定义。此外，这些标志是一个实现细节，可以在将来的Python版本中删除或弃用。建议使用来自 inspect 任何自省需要的模块。

命令行界面

这个 inspect 模块还提供了来自命令行的基本自省能力。

默认情况下，接受模块的名称并打印该模块的源。模块中的类或函数可以通过附加冒号和目标对象的限定名来打印。

--details

打印有关指定对象而不是源代码的信息