| | method | __doc__ | documentation string | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | __name__ | name with which this | | |
| | | | method was defined | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | im_class | class object that asked | \(1) | |
| | | | for this method | | |
| +-----------+-----------------+---------------------------+-------+ |
n | | | im_func | function object | | |
n | | | im_func or | function object | | |
| | | | containing implementation | | |
| | | __func__ | containing implementation | | |
| | | | of method | | |
| +-----------+-----------------+---------------------------+-------+ |
n | | | im_self | instance to which this | | |
n | | | im_self or | instance to which this | | |
| | | | method is bound, or | | |
| | | __self__ | method is bound, or | | |
| | | | ``None`` | | |
| +-----------+-----------------+---------------------------+-------+ |
| | function | __doc__ | documentation string | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | __name__ | name with which this | | |
| | | | function was defined | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | func_code | code object containing | | |
| | | | compiled function | | |
n | | | | bytecode | | |
n | | | | :term:`bytecode` | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | func_defaults | tuple of any default | | |
| | | | values for arguments | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | func_doc | (same as __doc__) | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | func_globals | global namespace in which | | |
| | | | this function was defined | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | func_name | (same as __name__) | | |
n | +-----------+-----------------+---------------------------+-------+ |
| | generator | __iter__ | defined to support | | |
| | | | iteration over container | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | close | raises new GeneratorExit | | |
| | | | exception inside the | | |
| | | | generator to terminate | | |
| | | | the iteration | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | gi_code | code object | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | gi_frame | frame object or possibly | | |
| | | | None once the generator | | |
| | | | has been exhausted | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | gi_running | set to 1 when generator | | |
| | | | is executing, 0 otherwise | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | next | return the next item from | | |
| | | | the container | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | send | resumes the generator and | | |
| | | | "sends" a value that | | |
| | | | becomes the result of the | | |
| | | | current yield-expression | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | throw | used to raise an | | |
| | | | exception inside the | | |
| | | | generator | | |
| +-----------+-----------------+---------------------------+-------+ |
| | traceback | tb_frame | frame object at this | | |
| | | | level | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | tb_lasti | index of last attempted | | |
| | | | instruction in bytecode | | |
| +-----------+-----------------+---------------------------+-------+ |
| | | tb_lineno | current line number in | | |
| :attr:`im_class` used to refer to the class that defined the method. |
| |
| |
| .. 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. |
n | |
| .. 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) |
| |
| Return a tuple 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 |
n | package, *suffix* is the trailing part of the file name (which may not be a dot- |
n | package, *suffix* is the trailing part of the file name (which may not be a |
| delimited extension), *mode* is the :func:`open` mode that would be used |
| 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. |
| (``'r'`` or ``'rb'``), and *mtype* is an integer giving the type of the |
| *mtype* will have a value which can be compared to the constants defined in the |
| module. *mtype* will have a value which can be compared to the constants |
| :mod:`imp` module; see the documentation for that module for more information on |
| defined in the :mod:`imp` module; see the documentation for that module for |
| more information on module types. |
| |
| .. versionchanged:: 2.6 |
| Returns a :term:`named tuple` ``ModuleInfo(name, suffix, mode, |
| module types. |
| module_type)``. |
| |
| |
| .. 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. |
| |
| 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. |
| |
n | .. function:: isabstract(object) |
| |
| Return true if the object is an abstract base class. |
| |
| .. versionadded:: 2.6 |
| |
| |
| .. function:: ismethoddescriptor(object) |
| |
n | Return true if the object is a method descriptor, but not if ismethod() or |
n | Return true if the object is a method descriptor, but not if :func:`ismethod` |
| isclass() or isfunction() are true. |
| or :func:`isclass` or :func:`isfunction` are true. |
| |
n | This is new as of Python 2.2, and, for example, is true of int.__add__. An |
n | This is new as of Python 2.2, and, for example, is true of |
| object passing this test has a __get__ attribute but not a __set__ attribute, |
| ``int.__add__``. An object passing this test has a :attr:`__get__` attribute |
| but beyond that the set of attributes varies. __name__ is usually sensible, and |
| but not a :attr:`__set__` attribute, but beyond that the set of attributes |
| __doc__ often is. |
| varies. :attr:`__name__` is usually sensible, and :attr:`__doc__` often is. |
| |
n | Methods implemented via descriptors that also pass one of the other tests return |
n | Methods implemented via descriptors that also pass one of the other tests |
| false from the ismethoddescriptor() test, simply because the other tests promise |
| return false from the :func:`ismethoddescriptor` test, simply because the |
| more -- you can, e.g., count on having the im_func attribute (etc) when an |
| other tests promise more -- you can, e.g., count on having the |
| object passes ismethod(). |
| :attr:`im_func` attribute (etc) when an object passes :func:`ismethod`. |
| |
| |
| .. function:: isdatadescriptor(object) |
| |
| Return true if the object is a data descriptor. |
| |
n | Data descriptors have both a __get__ and a __set__ attribute. Examples are |
n | Data descriptors have both a :attr:`__get__` and a :attr:`__set__` attribute. |
| properties (defined in Python), getsets, and members. The latter two are |
| Examples are properties (defined in Python), getsets, and members. The |
| defined in C and there are more specific tests available for those types, which |
| latter two are defined in C and there are more specific tests available for |
| is robust across Python implementations. Typically, data descriptors will also |
| those types, which is robust across Python implementations. Typically, data |
| have __name__ and __doc__ attributes (properties, getsets, and members have both |
| descriptors will also have :attr:`__name__` and :attr:`__doc__` attributes |
| of these attributes), but this is not guaranteed. |
| (properties, getsets, and members have both of these attributes), but this is |
| not guaranteed. |
| |
| .. versionadded:: 2.3 |
| |
| |
| .. function:: isgetsetdescriptor(object) |
| |
| Return true if the object is a getset descriptor. |
| |
| .. versionadded:: 2.5 |
| |
| |
| .. function:: ismemberdescriptor(object) |
| |
| Return true if the object is a member descriptor. |
| |
| Member descriptors are attributes defined in extension modules via |
n | ``PyMemberDef`` structures. For Python implementations without such types, this |
n | ``PyMemberDef`` structures. For Python implementations without such types, |
| method will always return ``False``. |
| this method will always return ``False``. |
| |
| .. versionadded:: 2.5 |
| |
| |
| .. _inspect-source: |
| |
| Retrieving source code |
| ---------------------- |
| |
n | |
| .. function:: getdoc(object) |
| |
n | Get the documentation string for an object. All tabs are expanded to spaces. To |
n | Get the documentation string for an object, cleaned up with :func:`cleandoc`. |
| clean up docstrings that are indented to line up with blocks of code, any |
| whitespace than can be uniformly removed from the second line onwards is |
| removed. |
| |
| |
| .. 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). |
| |
| |
| Get the names and default values of a function's arguments. A tuple of four |
| things is returned: ``(args, varargs, varkw, defaults)``. *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``. *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*. |
| |
n | .. versionchanged:: 2.6 |
| Returns a :term:`named tuple` ``ArgSpec(args, varargs, keywords, |
| defaults)``. |
| |
| |
| .. function:: getargvalues(frame) |
| |
| Get information about arguments passed into a particular frame. A tuple of four |
| things is returned: ``(args, varargs, varkw, locals)``. *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. |
n | |
| .. versionchanged:: 2.6 |
| Returns a :term:`named tuple` ``ArgInfo(args, varargs, keywords, |
| locals)``. |
| |
| |
| .. 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. |
| |