检查—检查活动物体

源代码： Lib/inspect.py

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

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

类型和成员

getmembers()函数检索对象的成员，例如类或模块。名称以“ is”开头的函数主要是为getmembers()的第二个参数提供方便的选择。它们还帮助您确定何时可以期望找到以下特殊属性：

在版本 3.5 中进行了更改：向生成器添加__qualname__和gi_yieldfrom属性。

现在，从函数名称(而不是代码名称)中设置了 generators 的__name__属性，并且可以对其进行修改。

在 3.7 版中进行了更改：向协程添加cr_origin属性。

• inspect. getmembers(* object * [，* predicate *])
  • 返回按名称排序的(name, value)对列表中的对象的所有成员。如果提供了可选的* predicate *参数(将使用每个成员的value对象调用)，则仅包含谓词为其返回真值的成员。

• inspect. getmodulename(* path *)
  • 返回由文件* path *命名的模块的名称，而不包括封闭软件包的名称。将对照importlib.machinery.all_suffixes()中的所有条目检查文件 extensions。如果匹配，则返回finally路径组件，且 extensions 已删除。否则，返回None。

请注意，此函数* only *返回实际 Python 模块的有意义的名称-可能引用 Python 包的路径仍将返回None。

在版本 3.3 中更改：该函数直接基于importlib。

• inspect. ismodule(* object *)

  • 如果对象是模块，则返回True。

• inspect. isclass(* object *)

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

• inspect. ismethod(* object *)

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

• inspect. isfunction(* object *)

  • 如果对象是 Python 函数(包括由lambda表达式创建的函数)，则返回True。

• inspect. isgeneratorfunction(* object *)

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

在版本 3.8 中进行了更改：如果包装的函数是 Python 生成器函数，则包装在functools.partial()中的函数现在将返回True。

• inspect. isgenerator(* object *)

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

• inspect. iscoroutinefunction(* object *)

  • 如果对象是coroutine function(使用async def语法定义的函数)，则返回True。

3.5 版中的新Function。

在版本 3.8 中进行了更改：如果包装的函数是coroutine function，则包装在functools.partial()中的函数现在返回True。

• inspect. iscoroutine(* object *)
  • 如果对象是由async def函数创建的coroutine，则返回True。

3.5 版中的新Function。

• inspect. isawaitable(* object *)
  • 如果可以在await表达式中使用该对象，则返回True。

也可以用于区分基于生成器的协程和常规生成器：

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

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

3.5 版中的新Function。

• inspect. isasyncgenfunction(* object *)
  • 如果对象是asynchronous generator函数，则返回True，例如：

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

3.6 版的新Function。

在版本 3.8 中进行了更改：如果包装的函数是asynchronous generator函数，则包装在functools.partial()中的函数现在将返回True。

• inspect. isasyncgen(* object *)
  • 如果对象是由asynchronous generator函数创建的异步生成器迭代器，则返回True。

3.6 版的新Function。

• inspect. istraceback(* object *)

  • 如果对象是回溯，则返回True。

• inspect. isframe(* object *)

  • 如果对象是框架，则返回True。

• inspect. iscode(* object *)

  • 如果对象是代码，则返回True。

• inspect. isbuiltin(* object *)

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

• inspect. isroutine(* object *)

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

• inspect. isabstract(* object *)

  • 如果对象是抽象 Base Class，则返回True。

• inspect. ismethoddescriptor(* object *)

  • 如果对象是方法 Descriptors，则返回True，但如果ismethod()，isclass()，isfunction()或isbuiltin()为 true，则返回True。

例如，int.__add__就是如此。pass此测试的对象具有get()方法，但没有set()方法，但除此之外，属性集有所不同。 name属性通常是明智的，而__doc__通常是明智的。

pass Descriptors 执行的方法也pass其他测试之一，而返回的结果则是从ismethoddescriptor()测试返回False，这仅仅是因为其他测试承诺了更多–例如，当对象passismethod()时，您可以指望拥有__func__属性(等)。

• inspect. isdatadescriptor(* object *)
  • 如果对象是数据 Descriptors，则返回True。

数据 Descriptors 具有set或delete方法。示例包括属性(在 Python 中定义)，getset 和成员。后两者是用 C 定义的，并且有针对这些类型的更具体的测试，这些测试在 Python 实现中非常可靠。通常，数据 Descriptors 还将具有name和__doc__属性(属性，getset 和成员都具有这两个属性)，但这不能保证。

• inspect. isgetsetdescriptor(* object *)
  • 如果对象是 getsetDescriptors，则返回True。

CPython 实现细节： getset 是在扩展模块中passPyGetSetDef结构定义的属性。对于没有此类类型的 Python 实现，此方法将始终返回False。

• inspect. ismemberdescriptor(* object *)
  • 如果对象是成员 Descriptors，则返回True。

CPython 实现细节： 成员 Descriptors 是在扩展模块中passPyMemberDef结构定义的属性。对于没有此类类型的 Python 实现，此方法将始终返回False。

检索源代码

• inspect. getdoc(* object *)
  • 获取对象的文档字符串，用cleandoc()清理。如果未提供对象的文档字符串，并且该对象是类，方法，属性或 Descriptors，请从继承层次结构中检索文档字符串。

在版本 3.5 中进行了更改：如果不覆盖文档字符串，则现在将继承它们。

• inspect. getcomments(* object *)

  • 以单个字符串返回紧接在对象源代码之前(对于类，函数或方法)或 Python 源文件顶部(如果对象是模块)的所有 Comments 行。如果对象的源代码不可用，则返回None。如果对象是在 C 或交互式 Shell 中定义的，则可能会发生这种情况。

• inspect. getfile(* object *)

  • 返回定义对象的(文本或二进制)文件的名称。如果对象是内置模块，类或函数，则失败并显示TypeError。

• inspect. getmodule(* object *)

  • try猜测在哪个模块中定义了对象。

• inspect. getsourcefile(* object *)

  • 返回定义对象的 Python 源文件的名称。如果对象是内置模块，类或函数，则失败并显示TypeError。

• inspect. getsourcelines(* object *)

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

在版本 3.3 中进行了更改：引发了OSError而不是IOError(现在是前者的别名)。

• inspect. getsource(* object *)
  • 返回对象的源代码文本。参数可以是模块，类，方法，函数，回溯，框架或代码对象。源代码作为单个字符串返回。如果无法获取源代码，则会引发OSError。

在版本 3.3 中进行了更改：引发了OSError而不是IOError(现在是前者的别名)。

• inspect. cleandoc(* doc *)
  • 从缩进以与代码块对齐的文档字符串中清除缩进。

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

使用 Signature 对象自省可调用对象

版本 3.3 中的新Function。

Signature 对象表示可调用对象的调用签名及其返回 Comments。要检索签名对象，请使用signature()函数。

• inspect. signature(* callable ，**，* follow_wrapped = True *)
  • 返回给定callable的Signature对象：

>>> 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'>

接受从纯函数和类到functools.partial()对象的各种 Python 可调用对象。

如果无法提供签名，则引发ValueError；如果不支持该类型的对象，则引发TypeError。

函数签名中的斜杠(/)表示函数之前的参数仅是位置信息。有关更多信息，请参见仅位置参数的 FAQ 条目。

版本 3.5 中的新Function：follow_wrapped参数。传递False以获得callable的签名(callable.__wrapped__将不会用于解包装饰的可调用对象.)

• • class * inspect. Signature(* parameters = None ，**，* return_annotation = Signature.empty *)
  • Signature 对象代表函数的调用签名及其返回 Comments。对于该函数接受的每个参数，它将在其parameters集合中存储一个Parameter对象。

可选的* parameters *参数是Parameter个对象的序列，经过验证可以检查是否没有名称重复的参数，并且参数的 Sequences 正确，即仅位置优先，然后位置或关键字，具有默认值的参数将跟随没有默认值的参数。

可选的* return_annotation *参数可以是任意的 Python 对象，是可调用对象的“ return”Comments。

签名对象是不可变的。使用Signature.replace()进行修改后的副本。

在版本 3.5 中进行了更改：签名对象是可拾取和可哈希的。

• empty

  • 一个特殊的类级别标记，用于指定缺少返回 Comments。

• parameters

  • 参数名称到相应的Parameter对象的有序 Map。参数以严格的定义 Sequences 出现，包括仅关键字参数。

在 3.7 版中进行了更改：Python 仅明确保证自 3.7 版起它保留了仅关键字参数的语句 Sequences，尽管实际上该 Sequences 始终在 Python 3 中保留。

• return_annotation

  • 可调用对象的“返回”Comments。如果可调用对象没有“返回”Comments，则此属性设置为Signature.empty。

• bind((args ，** kwargs *)

  • 创建从位置和关键字参数到参数的 Map。如果*args和**kwargs与签名匹配，则返回BoundArguments，或者引发TypeError。

• bind_partial((args ，** kwargs *)

  • 与Signature.bind()的工作方式相同，但是Ellipsis了一些必需的参数(模仿functools.partial()行为。)返回BoundArguments，如果传递的参数与签名不匹配，则引发TypeError。

• replace(** [，parameters] [，return_annotation] *)

  • 基于调用替换的实例创建一个新的 Signature 实例。可以传递不同的parameters和/或return_annotation来覆盖基本签名的相应属性。要从复制的签名中删除 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'"

• 类方法 from_callable(* obj ，**，* follow_wrapped = True *)
  • 返回给定可调用obj的Signature(或其子类)对象。传递follow_wrapped=False以获得obj的签名，而无需解开其__wrapped__链。

此方法简化了Signature的子类：

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

3.5 版中的新Function。

• • class * inspect. Parameter(* name ， kind ，**，* default = Parameter.empty ， annotation = Parameter.empty *)
  • 参数对象是* immutable *。您可以使用Parameter.replace()来创建修改后的副本，而不是修改 Parameter 对象。

在版本 3.5 中进行了更改：参数对象是可拾取和可哈希的。

• empty

  • 一个特殊的类级别标记，用于指定缺少默认值和 Comments。

• name

  • 参数的名称，为字符串。该名称必须是有效的 Python 标识符。

CPython 实现细节： CPython 在用于实现理解和生成器表达式的代码对象上生成形式为.0的隐式参数名称。

在版本 3.6 中更改：这些参数名称由该模块作为implicit0公开。

• default

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

• annotation

  • 参数的 Comments。如果参数没有 Comments，则此属性设置为Parameter.empty。

• kind

  • 描述参数值如何绑定到参数。可能的值(可passParameter访问，例如Parameter.KEYWORD_ONLY)：

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

>>> 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 版的新Function。

示例：打印所有参数说明：

>>> 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(** [，名称] [，种类] [，默认] [，Comments] *)

基于被替换的实例创建一个新的 Parameter 实例。要覆盖Parameter属性，请传递相应的参数。要从参数中删除默认值或/和 Comments，请传递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 中，如果将kind设置为POSITIONAL_ONLY，则可以将name设置为None。不再允许这样做。

• 类别 inspect. BoundArguments

  • Signature.bind()或Signature.bind_partial()通话的结果。保存参数到函数参数的 Map。

• arguments

  • 参数名称到参数值的有序可变 Map(collections.OrderedDict)。仅包含显式绑定的参数。 arguments中的更改将反映在args和kwargs中。

出于任何参数处理目的，应与Signature.parameters结合使用。

• args

  • 位置参数值的 Tuples。根据arguments属性动态计算。

• kwargs

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

• signature

  • 对父级Signature对象的引用。

• apply_defaults ( )

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

对于可变位置参数(*args)，默认值为空 Tuples。

对于可变关键字参数(**kwargs)，默认值为空 dict。

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

3.5 版中的新Function。

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

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

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

类和函数

• inspect. getclasstree(* classes ， unique = False *)

  • 将给定的类列表排列为嵌套列表的层次结构。在出现嵌套列表的地方，它包含派生自该类的类，这些类的条目紧接在列表之前。每个条目都是一个 2Tuples，其中包含一个类及其 Base Class 的 Tuples。如果* unique *参数为 true，则对于给定列表中的每个类，仅在返回的结构中出现一个条目。否则，使用多重继承的类及其子代将出现多次。

• inspect. getargspec(* func *)

  • 获取 Python 函数参数的名称和默认值。返回named tuple ArgSpec(args, varargs, keywords, defaults)。 * args *是参数名称的列表。 * varargs 和 keywords *是*和**参数或None的名称。 * defaults 是默认参数值的 Tuples；如果没有默认参数，则为None；如果该 Tuples 具有 n 个元素，则它们对应于 args 中列出的最后 n *个元素。

从 3.0 版开始不推荐使用：对更新的 API 使用getfullargspec()通常可以直接替换，但也可以正确处理函数 Comments 和仅关键字参数。

或者，使用signature()和Signature Object，它们为可调用对象提供了更结构化的自省 API。

• inspect. getfullargspec(* func *)
  • 获取 Python 函数参数的名称和默认值。返回named tuple：

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

• args *是位置参数名称的列表。 * varargs *是*参数的名称，如果不接受任意位置参数，则是None的名称。 * varkw *是**参数的名称，如果不接受任意关键字参数，则是None的名称。 * defaults 是 n -对应于最后 n *个位置参数的默认参数值的 Tuples，如果没有定义此类默认值，则为None。 * kwonlyargs *是语句 Sequences 的仅关键字参数名称的列表。 * kwonlydefaults 是一个字典，它将参数名称从 kwonlyargs *Map 到没有提供参数的默认值。 * annotations *是将参数名称 Map 到 Comments 的字典。特殊键"return"用于报告函数返回值 Comments(如果有)。

请注意，signature()和Signature Object为可调用的自省提供了推荐的 API，并支持扩展模块 API 中有时会遇到的其他行为(如仅位置参数)。保留此Function主要是为了在需要与 Python 2 inspect模块 API 保持兼容性的代码中使用。

在版本 3.4 中进行了更改：此函数现在基于signature()，但是仍然忽略__wrapped__属性，并且在绑定方法的签名输出中包括已经绑定的第一个参数。

在版本 3.6 中进行了更改：该方法先前在 Python 3.5 中被记录为不推荐使用signature()，但为了恢复从原始getargspec()迁移来的单源 Python 2/3 代码的明显支持的标准接口，该决定已被撤销。 API。

在 3.7 版中进行了更改：Python 仅明确保证自 3.7 版起它保留了仅关键字参数的语句 Sequences，尽管实际上该 Sequences 始终在 Python 3 中保留。

• inspect. getargvalues(* frame *)
  • 获取有关传递到特定框架的参数的信息。返回named tuple ArgInfo(args, varargs, keywords, locals)。 * args *是参数名称的列表。 * varargs 和 keywords *是*和**参数或None的名称。 * locals *是给定框架的本地字典。

• inspect. formatargspec((args * [，* varargs ， varkw ， defaults ， kwonlyargs ， kwonlydefaults ， annotations * [，* formatarg ， formatvarargs ， formatvarkw ， formatvalue ， formatreturns ， formatannotations *]]))
  • 根据getfullargspec()返回的值格式化漂亮的参数 spec。

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

其他六个自变量是调用这些函数以将自变量名称，*自变量名称，**自变量名称，默认值，返回 Comments 和各个 Comments 转换为字符串的函数。

For example:

>>> 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()返回的四个值格式化漂亮的参数 spec。 format *参数是相应的可选格式化函数，这些函数被调用以将名称和值转换为字符串。

• inspect. getmro(* cls *)

  • 以方法解析 Sequences 返回类 cls 的 Base Class(包括 cls)的 Tuples。在该 Tuples 中，没有一个类出现多次。请注意，方法的解析 Sequences 取决于 cls 的类型。除非使用非常特殊的用户定义的元类型，否则 cls 将是 Tuples 的第一个元素。

• inspect. getcallargs(* func ，/*， *args ， * kwds *)

  • 将* args 和 kwds 绑定到 Python 函数或方法 func 的参数名称，就好像它们是由它们调用的一样。对于绑定方法，还将第一个参数(通常命名为self)绑定到关联的实例。返回一个字典，将参数名称(包括*和**参数的名称，如果有的话)Map 到 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 版中的新Function。

自版本 3.5 起不推荐使用：改为使用Signature.bind()和Signature.bind_partial()。

• inspect. getclosurevars(* func *)
  • 获取 Python 函数或方法* func *中的外部名称引用到其当前值的 Map。返回named tuple ClosureVars(nonlocals, globals, builtins, unbound)。 * nonlocals 将引用的名称 Map 到词法闭包变量， globals Map 到函数的模块全局变量，而 builtins *Map 到从函数体可见的内建函数。 * unbound *是在函数中引用的一组名称，这些名称在给定当前模块的全局变量和内置函数的情况下根本无法解析。

如果* func *不是 Python 函数或方法，则引发TypeError。

版本 3.3 中的新Function。

• inspect. unwrap(* func ，**，* stop = None *)
  • 获取由* func *包装的对象。它遵循__wrapped__属性链，返回链中的最后一个对象。

• stop *是一个可选的回调函数，它接受包装器链中的一个对象作为其唯一参数，如果回调函数返回一个真值，则允许展开操作提前终止。如果回调从未返回真实值，则照常返回链中的最后一个对象。例如，如果链中的任何对象都定义了__signature__属性，则signature()使用此函数来停止解包。

如果遇到循环，将引发ValueError。

3.4 版的新Function。

解释器堆栈

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

在版本 3.5 中进行了更改：返回一个命名的 Tuples 而不是一个 Tuples。

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

大多数这些函数支持的可选* context *参数指定要返回的上下文行数，该行以当前行为中心。

• inspect. getframeinfo(* frame ， context = 1 *)

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

• inspect. getouterframes(* frame ， context = 1 *)

  • 获取一个框架和所有外部框架的框架记录列表。这些框架表示导致创建* frame 的调用。返回列表中的第一项表示 frame ；最后一个条目表示 frame *堆栈上的最外层调用。

在版本 3.5 中更改：返回了named tuples FrameInfo(frame, filename, lineno, function, code_context, index)的列表。

• inspect. getinnerframes(* traceback ， context = 1 *)
  • 获取回溯帧和所有内部帧的帧记录列表。这些框架表示由于* frame 而进行的调用。列表中的第一项表示 traceback *；最后一个条目表示引发异常的位置。

在版本 3.5 中更改：返回了named tuples FrameInfo(frame, filename, lineno, function, code_context, index)的列表。

• inspect. currentframe ( )
  • 返回调用者的堆栈框架的框架对象。

CPython 实现细节： 此函数依赖于解释器中的 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()均可触发代码执行。Descriptors(如属性)将被调用，并可以调用getattr()和getattribute()。

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

• inspect. getattr_static(* obj ， attr ， default = None *)
  • pass Descriptors 协议getattr()或getattribute()检索属性而无需触发动态查找。

注意：此函数可能无法检索 getattr 可以获取的所有属性(如动态创建的属性)，并且可能会找到 getattr 不能获取的所有属性(如引发 AttributeError 的 Descriptors)。它还可以返回 Descriptors 对象而不是实例成员。

如果实例dict被另一个成员(例如，属性)遮蔽，则此函数将无法找到实例成员。

3.2 版中的新Function。

getattr_static()不解析 Descriptors，例如，用 C 实现的对象上的插槽 Descriptors 或 getsetDescriptors。返回的是 Descriptors 对象，而不是基础属性。

您可以使用如下代码处理这些。请注意，对于调用这些方法的任意 getsetDescriptors，可能会触发代码执行：

# 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

Generator 和协同程序的当前状态

在实现协程调度程序并将其用于生成器的其他高级用途时，确定生成器是当前正在执行，正在 await 启动，恢复还是执行，还是已终止是很有用的。 getgeneratorstate()可以轻松确定 Generator 的当前状态。

• inspect. getgeneratorstate(* generator *)

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

• 可能的状态是：

  • • GEN_CREATED：await 开始执行。

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

• GEN_SUSPENDED：当前挂在 yield 表达式上。

• GEN_CLOSED：执行已完成。

3.2 版中的新Function。

• inspect. getcoroutinestate(协程)

  • 获取协程对象的当前状态。该函数旨在与async def函数创建的协程对象一起使用，但将接受具有cr_running和cr_frame属性的任何类似协程的对象。

• 可能的状态是：

  • • CORO_CREATED：await 开始执行。

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

• CORO_SUSPENDED：当前在 await 表达式中挂起。

• CORO_CLOSED：执行已完成。

3.5 版中的新Function。

也可以查询 Generator 的当前内部状态。这对于测试目的非常有用，以确保内部状态按预期进行更新：

• inspect. getgeneratorlocals(* generator *)
  • 获取* generator *中的实时局部变量到其当前值的 Map。返回一个从变量名 Map 到值的字典。这等效于在生成器的主体中调用locals()，并且所有相同的警告同样适用。

如果* generator 是generator且当前没有关联的帧，则返回一个空字典。如果 generator *不是 Python 生成器对象，则引发TypeError。

CPython 实现细节： 此函数依赖于生成器，该生成器公开了 Python 堆栈框架以进行内省，但不能保证在所有 Python 实现中都是如此。在这种情况下，此函数将始终返回空字典。

版本 3.3 中的新Function。

• inspect. getcoroutinelocals(协程)
  • 此函数类似于getgeneratorlocals()，但适用于由async def函数创建的协程对象。

3.5 版中的新Function。

代码对象的位标志

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

• inspect. CO_OPTIMIZED

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

• inspect. CO_NEWLOCALS

  • 如果设置，则在执行代码对象时将为框架的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 版中的新Function。

• inspect. CO_ITERABLE_COROUTINE
  • 该标志用于将生成器转换为基于生成器的协程。具有此标志的生成器对象可以在await表达式中使用，并且可以在yield from协程对象中使用。有关更多详细信息，请参见 PEP 492。

3.5 版中的新Function。

• inspect. CO_ASYNC_GENERATOR
  • 当代码对象是异步生成器函数时，将设置该标志。执行代码对象时，它将返回一个异步生成器对象。有关更多详细信息，请参见 PEP 525。

3.6 版的新Function。

命令行界面

inspect模块还从命令行提供基本的自省Function。

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

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