mirror of
https://github.com/python/cpython.git
synced 2025-10-31 21:51:50 +00:00
525 lines
22 KiB
ReStructuredText
525 lines
22 KiB
ReStructuredText
:mod:`inspect` --- Inspect live objects
|
|
=======================================
|
|
|
|
.. module:: inspect
|
|
:synopsis: Extract information and source code from live objects.
|
|
.. moduleauthor:: Ka-Ping Yee <ping@lfw.org>
|
|
.. sectionauthor:: Ka-Ping Yee <ping@lfw.org>
|
|
|
|
|
|
The :mod:`inspect` module provides several useful functions to help get
|
|
information about live objects such as modules, classes, methods, functions,
|
|
tracebacks, frame objects, and code objects. For example, it can help you
|
|
examine the contents of a class, retrieve the source code of a method, extract
|
|
and format the argument list for a function, or get all the information you need
|
|
to display a detailed traceback.
|
|
|
|
There are four main kinds of services provided by this module: type checking,
|
|
getting source code, inspecting classes and functions, and examining the
|
|
interpreter stack.
|
|
|
|
|
|
.. _inspect-types:
|
|
|
|
Types and members
|
|
-----------------
|
|
|
|
The :func:`getmembers` function retrieves the members of an object such as a
|
|
class or module. The sixteen functions whose names begin with "is" are mainly
|
|
provided as convenient choices for the second argument to :func:`getmembers`.
|
|
They also help you determine when you can expect to find the following special
|
|
attributes:
|
|
|
|
+-----------+-----------------+---------------------------+
|
|
| Type | Attribute | Description |
|
|
+===========+=================+===========================+
|
|
| module | __doc__ | documentation string |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __file__ | filename (missing for |
|
|
| | | built-in modules) |
|
|
+-----------+-----------------+---------------------------+
|
|
| class | __doc__ | documentation string |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __module__ | name of module in which |
|
|
| | | this class was defined |
|
|
+-----------+-----------------+---------------------------+
|
|
| method | __doc__ | documentation string |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __name__ | name with which this |
|
|
| | | method was defined |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __func__ | function object |
|
|
| | | containing implementation |
|
|
| | | of method |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __self__ | instance to which this |
|
|
| | | method is bound, or |
|
|
| | | ``None`` |
|
|
+-----------+-----------------+---------------------------+
|
|
| function | __doc__ | documentation string |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __name__ | name with which this |
|
|
| | | function was defined |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __code__ | code object containing |
|
|
| | | compiled function |
|
|
| | | :term:`bytecode` |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __defaults__ | tuple of any default |
|
|
| | | values for arguments |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __globals__ | global namespace in which |
|
|
| | | this function was defined |
|
|
+-----------+-----------------+---------------------------+
|
|
| traceback | tb_frame | frame object at this |
|
|
| | | level |
|
|
+-----------+-----------------+---------------------------+
|
|
| | tb_lasti | index of last attempted |
|
|
| | | instruction in bytecode |
|
|
+-----------+-----------------+---------------------------+
|
|
| | tb_lineno | current line number in |
|
|
| | | Python source code |
|
|
+-----------+-----------------+---------------------------+
|
|
| | tb_next | next inner traceback |
|
|
| | | object (called by this |
|
|
| | | level) |
|
|
+-----------+-----------------+---------------------------+
|
|
| frame | f_back | next outer frame object |
|
|
| | | (this frame's caller) |
|
|
+-----------+-----------------+---------------------------+
|
|
| | f_builtins | built-in namespace seen |
|
|
| | | by this frame |
|
|
+-----------+-----------------+---------------------------+
|
|
| | f_code | code object being |
|
|
| | | executed in this frame |
|
|
+-----------+-----------------+---------------------------+
|
|
| | f_globals | global namespace seen by |
|
|
| | | this frame |
|
|
+-----------+-----------------+---------------------------+
|
|
| | f_lasti | index of last attempted |
|
|
| | | instruction in bytecode |
|
|
+-----------+-----------------+---------------------------+
|
|
| | f_lineno | current line number in |
|
|
| | | Python source code |
|
|
+-----------+-----------------+---------------------------+
|
|
| | f_locals | local namespace seen by |
|
|
| | | this frame |
|
|
+-----------+-----------------+---------------------------+
|
|
| | f_restricted | 0 or 1 if frame is in |
|
|
| | | restricted execution mode |
|
|
+-----------+-----------------+---------------------------+
|
|
| | f_trace | tracing function for this |
|
|
| | | frame, or ``None`` |
|
|
+-----------+-----------------+---------------------------+
|
|
| code | co_argcount | number of arguments (not |
|
|
| | | including \* or \*\* |
|
|
| | | args) |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_code | string of raw compiled |
|
|
| | | bytecode |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_consts | tuple of constants used |
|
|
| | | in the bytecode |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_filename | name of file in which |
|
|
| | | this code object was |
|
|
| | | created |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_firstlineno | number of first line in |
|
|
| | | Python source code |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_flags | bitmap: 1=optimized ``|`` |
|
|
| | | 2=newlocals ``|`` 4=\*arg |
|
|
| | | ``|`` 8=\*\*arg |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_lnotab | encoded mapping of line |
|
|
| | | numbers to bytecode |
|
|
| | | indices |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_name | name with which this code |
|
|
| | | object was defined |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_names | tuple of names of local |
|
|
| | | variables |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_nlocals | number of local variables |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_stacksize | virtual machine stack |
|
|
| | | space required |
|
|
+-----------+-----------------+---------------------------+
|
|
| | co_varnames | tuple of names of |
|
|
| | | arguments and local |
|
|
| | | variables |
|
|
+-----------+-----------------+---------------------------+
|
|
| builtin | __doc__ | documentation string |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __name__ | original name of this |
|
|
| | | function or method |
|
|
+-----------+-----------------+---------------------------+
|
|
| | __self__ | instance to which a |
|
|
| | | method is bound, or |
|
|
| | | ``None`` |
|
|
+-----------+-----------------+---------------------------+
|
|
|
|
|
|
.. function:: getmembers(object[, predicate])
|
|
|
|
Return all the members of an object in a list of (name, value) pairs sorted by
|
|
name. If the optional *predicate* argument is supplied, only members for which
|
|
the predicate returns a true value are included.
|
|
|
|
.. note::
|
|
|
|
:func:`getmembers` does not return metaclass attributes when the argument
|
|
is a class (this behavior is inherited from the :func:`dir` function).
|
|
|
|
|
|
.. function:: getmoduleinfo(path)
|
|
|
|
Returns a :term:`named tuple` ``ModuleInfo(name, suffix, mode,
|
|
module_type)`` of values that describe how Python will interpret the file
|
|
identified by *path* if it is a module, or ``None`` if it would not be
|
|
identified as a module. The return tuple is ``(name, suffix, mode, mtype)``,
|
|
where *name* is the name of the module without the name of any enclosing
|
|
package, *suffix* is the trailing part of the file name (which may not be a
|
|
dot-delimited extension), *mode* is the :func:`open` mode that would be used
|
|
(``'r'`` or ``'rb'``), and *mtype* is an integer giving the type of the
|
|
module. *mtype* will have a value which can be compared to the constants
|
|
defined in the :mod:`imp` module; see the documentation for that module for
|
|
more information on module types.
|
|
|
|
|
|
.. function:: getmodulename(path)
|
|
|
|
Return the name of the module named by the file *path*, without including the
|
|
names of enclosing packages. This uses the same algorithm as the interpreter
|
|
uses when searching for modules. If the name cannot be matched according to the
|
|
interpreter's rules, ``None`` is returned.
|
|
|
|
|
|
.. function:: ismodule(object)
|
|
|
|
Return true if the object is a module.
|
|
|
|
|
|
.. function:: isclass(object)
|
|
|
|
Return true if the object is a class.
|
|
|
|
|
|
.. function:: ismethod(object)
|
|
|
|
Return true if the object is a method.
|
|
|
|
|
|
.. function:: isfunction(object)
|
|
|
|
Return true if the object is a Python function or unnamed (:term:`lambda`)
|
|
function.
|
|
|
|
|
|
.. function:: isgeneratorfunction(object)
|
|
|
|
Return true if the object is a Python generator function.
|
|
|
|
|
|
.. function:: isgenerator(object)
|
|
|
|
Return true if the object is a generator.
|
|
|
|
|
|
.. function:: istraceback(object)
|
|
|
|
Return true if the object is a traceback.
|
|
|
|
|
|
.. function:: isframe(object)
|
|
|
|
Return true if the object is a frame.
|
|
|
|
|
|
.. function:: iscode(object)
|
|
|
|
Return true if the object is a code.
|
|
|
|
|
|
.. function:: isbuiltin(object)
|
|
|
|
Return true if the object is a built-in function.
|
|
|
|
|
|
.. function:: isroutine(object)
|
|
|
|
Return true if the object is a user-defined or built-in function or method.
|
|
|
|
.. function:: isabstract(object)
|
|
|
|
Return true if the object is an abstract base class.
|
|
|
|
|
|
.. function:: ismethoddescriptor(object)
|
|
|
|
Return true if the object is a method descriptor, but not if :func:`ismethod`
|
|
or :func:`isclass` or :func:`isfunction` are true.
|
|
|
|
This, for example, is true of ``int.__add__``. An object passing this test
|
|
has a :attr:`__get__` attribute but not a :attr:`__set__` attribute, but
|
|
beyond that the set of attributes varies. :attr:`__name__` is usually
|
|
sensible, and :attr:`__doc__` often is.
|
|
|
|
Methods implemented via descriptors that also pass one of the other tests
|
|
return false from the :func:`ismethoddescriptor` test, simply because the
|
|
other tests promise more -- you can, e.g., count on having the
|
|
:attr:`__func__` attribute (etc) when an object passes :func:`ismethod`.
|
|
|
|
|
|
.. function:: isdatadescriptor(object)
|
|
|
|
Return true if the object is a data descriptor.
|
|
|
|
Data descriptors have both a :attr:`__get__` and a :attr:`__set__` attribute.
|
|
Examples are properties (defined in Python), getsets, and members. The
|
|
latter two are defined in C and there are more specific tests available for
|
|
those types, which is robust across Python implementations. Typically, data
|
|
descriptors will also have :attr:`__name__` and :attr:`__doc__` attributes
|
|
(properties, getsets, and members have both of these attributes), but this is
|
|
not guaranteed.
|
|
|
|
|
|
.. function:: isgetsetdescriptor(object)
|
|
|
|
Return true if the object is a getset descriptor.
|
|
|
|
getsets are attributes defined in extension modules via ``PyGetSetDef``
|
|
structures. For Python implementations without such types, this method will
|
|
always return ``False``.
|
|
|
|
|
|
.. function:: ismemberdescriptor(object)
|
|
|
|
Return true if the object is a member descriptor.
|
|
|
|
Member descriptors are attributes defined in extension modules via
|
|
``PyMemberDef`` structures. For Python implementations without such types,
|
|
this method will always return ``False``.
|
|
|
|
|
|
.. _inspect-source:
|
|
|
|
Retrieving source code
|
|
----------------------
|
|
|
|
.. function:: getdoc(object)
|
|
|
|
Get the documentation string for an object, cleaned up with :func:`cleandoc`.
|
|
|
|
|
|
.. function:: getcomments(object)
|
|
|
|
Return in a single string any lines of comments immediately preceding the
|
|
object's source code (for a class, function, or method), or at the top of the
|
|
Python source file (if the object is a module).
|
|
|
|
|
|
.. function:: getfile(object)
|
|
|
|
Return the name of the (text or binary) file in which an object was defined.
|
|
This will fail with a :exc:`TypeError` if the object is a built-in module,
|
|
class, or function.
|
|
|
|
|
|
.. function:: getmodule(object)
|
|
|
|
Try to guess which module an object was defined in.
|
|
|
|
|
|
.. function:: getsourcefile(object)
|
|
|
|
Return the name of the Python source file in which an object was defined. This
|
|
will fail with a :exc:`TypeError` if the object is a built-in module, class, or
|
|
function.
|
|
|
|
|
|
.. function:: getsourcelines(object)
|
|
|
|
Return a list of source lines and starting line number for an object. The
|
|
argument may be a module, class, method, function, traceback, frame, or code
|
|
object. The source code is returned as a list of the lines corresponding to the
|
|
object and the line number indicates where in the original source file the first
|
|
line of code was found. An :exc:`IOError` is raised if the source code cannot
|
|
be retrieved.
|
|
|
|
|
|
.. function:: getsource(object)
|
|
|
|
Return the text of the source code for an object. The argument may be a module,
|
|
class, method, function, traceback, frame, or code object. The source code is
|
|
returned as a single string. An :exc:`IOError` is raised if the source code
|
|
cannot be retrieved.
|
|
|
|
|
|
.. function:: cleandoc(doc)
|
|
|
|
Clean up indentation from docstrings that are indented to line up with blocks
|
|
of code. Any whitespace that can be uniformly removed from the second line
|
|
onwards is removed. Also, all tabs are expanded to spaces.
|
|
|
|
|
|
.. _inspect-classes-functions:
|
|
|
|
Classes and functions
|
|
---------------------
|
|
|
|
.. function:: getclasstree(classes, unique=False)
|
|
|
|
Arrange the given list of classes into a hierarchy of nested lists. Where a
|
|
nested list appears, it contains classes derived from the class whose entry
|
|
immediately precedes the list. Each entry is a 2-tuple containing a class and a
|
|
tuple of its base classes. If the *unique* argument is true, exactly one entry
|
|
appears in the returned structure for each class in the given list. Otherwise,
|
|
classes using multiple inheritance and their descendants will appear multiple
|
|
times.
|
|
|
|
|
|
.. function:: getargspec(func)
|
|
|
|
Get the names and default values of a function's arguments. A
|
|
:term:`named tuple` ``ArgSpec(args, varargs, keywords,
|
|
defaults)`` is returned. *args* is a list of
|
|
the argument names. *varargs* and *varkw* are the names of the ``*`` and
|
|
``**`` arguments or ``None``. *defaults* is a tuple of default argument
|
|
values or None if there are no default arguments; if this tuple has *n*
|
|
elements, they correspond to the last *n* elements listed in *args*.
|
|
|
|
.. deprecated:: 3.0
|
|
Use :func:`getfullargspec` instead, which provides information about
|
|
keyword-only arguments and annotations.
|
|
|
|
|
|
.. function:: getfullargspec(func)
|
|
|
|
Get the names and default values of a function's arguments. A :term:`named
|
|
tuple` is returned:
|
|
|
|
``FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults,
|
|
annotations)``
|
|
|
|
*args* is a list of the argument names. *varargs* and *varkw* are the names
|
|
of the ``*`` and ``**`` arguments or ``None``. *defaults* is an n-tuple of
|
|
the default values of the last n arguments. *kwonlyargs* is a list of
|
|
keyword-only argument names. *kwonlydefaults* is a dictionary mapping names
|
|
from kwonlyargs to defaults. *annotations* is a dictionary mapping argument
|
|
names to annotations.
|
|
|
|
The first four items in the tuple correspond to :func:`getargspec`.
|
|
|
|
|
|
.. function:: getargvalues(frame)
|
|
|
|
Get information about arguments passed into a particular frame. A
|
|
:term:`named tuple` ``ArgInfo(args, varargs, keywords, locals)`` is
|
|
returned. *args* is a list of the argument names (it may contain nested
|
|
lists). *varargs* and *varkw* are the names of the ``*`` and ``**`` arguments
|
|
or ``None``. *locals* is the locals dictionary of the given frame.
|
|
|
|
|
|
.. function:: formatargspec(args[, varargs, varkw, defaults, formatarg, formatvarargs, formatvarkw, formatvalue, join])
|
|
|
|
Format a pretty argument spec from the four values returned by
|
|
:func:`getargspec`. The format\* arguments are the corresponding optional
|
|
formatting functions that are called to turn names and values into strings.
|
|
|
|
|
|
.. function:: formatargvalues(args[, varargs, varkw, locals, formatarg, formatvarargs, formatvarkw, formatvalue, join])
|
|
|
|
Format a pretty argument spec from the four values returned by
|
|
:func:`getargvalues`. The format\* arguments are the corresponding optional
|
|
formatting functions that are called to turn names and values into strings.
|
|
|
|
|
|
.. function:: getmro(cls)
|
|
|
|
Return a tuple of class cls's base classes, including cls, in method resolution
|
|
order. No class appears more than once in this tuple. Note that the method
|
|
resolution order depends on cls's type. Unless a very peculiar user-defined
|
|
metatype is in use, cls will be the first element of the tuple.
|
|
|
|
|
|
.. _inspect-stack:
|
|
|
|
The interpreter stack
|
|
---------------------
|
|
|
|
When the following functions return "frame records," each record is a tuple of
|
|
six items: the frame object, the filename, the line number of the current line,
|
|
the function name, a list of lines of context from the source code, and the
|
|
index of the current line within that list.
|
|
|
|
.. note::
|
|
|
|
Keeping references to frame objects, as found in the first element of the frame
|
|
records these functions return, can cause your program to create reference
|
|
cycles. Once a reference cycle has been created, the lifespan of all objects
|
|
which can be accessed from the objects which form the cycle can become much
|
|
longer even if Python's optional cycle detector is enabled. If such cycles must
|
|
be created, it is important to ensure they are explicitly broken to avoid the
|
|
delayed destruction of objects and increased memory consumption which occurs.
|
|
|
|
Though the cycle detector will catch these, destruction of the frames (and local
|
|
variables) can be made deterministic by removing the cycle in a
|
|
:keyword:`finally` clause. This is also important if the cycle detector was
|
|
disabled when Python was compiled or using :func:`gc.disable`. For example::
|
|
|
|
def handle_stackframe_without_leak():
|
|
frame = inspect.currentframe()
|
|
try:
|
|
# do something with the frame
|
|
finally:
|
|
del frame
|
|
|
|
The optional *context* argument supported by most of these functions specifies
|
|
the number of lines of context to return, which are centered around the current
|
|
line.
|
|
|
|
|
|
.. function:: getframeinfo(frame, context=1)
|
|
|
|
Get information about a frame or traceback object. A :term:`named tuple`
|
|
``Traceback(filename, lineno, function, code_context, index)`` is returned.
|
|
|
|
|
|
.. function:: getouterframes(frame, context=1)
|
|
|
|
Get a list of frame records for a frame and all outer frames. These frames
|
|
represent the calls that lead to the creation of *frame*. The first entry in the
|
|
returned list represents *frame*; the last entry represents the outermost call
|
|
on *frame*'s stack.
|
|
|
|
|
|
.. function:: getinnerframes(traceback, context=1)
|
|
|
|
Get a list of frame records for a traceback's frame and all inner frames. These
|
|
frames represent calls made as a consequence of *frame*. The first entry in the
|
|
list represents *traceback*; the last entry represents where the exception was
|
|
raised.
|
|
|
|
|
|
.. function:: currentframe()
|
|
|
|
Return the frame object for the caller's stack frame.
|
|
|
|
|
|
.. function:: stack(context=1)
|
|
|
|
Return a list of frame records for the caller's stack. The first entry in the
|
|
returned list represents the caller; the last entry represents the outermost
|
|
call on the stack.
|
|
|
|
|
|
.. function:: trace(context=1)
|
|
|
|
Return a list of frame records for the stack between the current frame and the
|
|
frame in which an exception currently being handled was raised in. The first
|
|
entry in the list represents the caller; the last entry represents where the
|
|
exception was raised.
|
|
|