inspect — Inspection d'objets

Code source : Lib/inspect.py

---

Le module inspect implémente plusieurs fonctions permettant d'obtenir de l'information à propos d'objets tels que les modules, classes, méthodes, fonctions, traces de piles, cadres d'exécution et objets code. Par exemple, il permet d'inspecter le contenu d'une classe, de retrouver le code source d'une méthode, d'extraire et de mettre en forme une liste d'arguments pour une fonction, ou obtenir toute l'information nécessaire pour afficher une pile d'appels détaillée.

Ce module donne accès à 4 types de services : vérification de typage, obtention de code source, inspection de classes et de fonctions et examen de la pile d'exécution.

Types et membres

The getmembers() function retrieves the members of an object such as a class or module. The functions whose names begin with "is" are mainly provided as convenient choices for the second argument to getmembers(). They also help you determine when you can expect to find the following special attributes:

Type	Attribut	Description
module	__doc__	texte de documentation
	__file__	nom de fichier (inexistant pour les fonctions natives)
classe	__doc__	texte de documentation
	__name__	nom de la classe lors de sa définition
	__qualname__	nom qualifié
	__module__	nom du module contenant la classe lors de sa définition
méthode	__doc__	texte de documentation
	__name__	nom de la méthode lors de sa définition
	__qualname__	nom qualifié
	__func__	objet fonction contenant l'implémentation de la méthode
	__self__	instance à laquelle cette méthode est liée, ou None
	__module__	nom du module contenant la méthode lors de sa définition
fonction	__doc__	texte de documentation
	__name__	nom de la fonction lors de sa définition
	__qualname__	nom qualifié
	__code__	objet code contenant le code intermédiaire d'une fonction compilée
	__defaults__	n-uplet de valeurs par défaut pour arguments positionnels ou nommés
	__kwdefaults__	tableau de correspondance de valeurs par défaut pour les paramètres nommés
	__globals__	espace de nommage global lors de la définition de la fonction
	__annotations__	tableau de correspondance des paramètres à leur annotation ; "return" est un mot-clé réservé pour les annotations de type renvoyé.
	__module__	nom du module contenant la fonction lors de sa définition
traceback	tb_frame	objet cadre à ce niveau
	tb_lasti	index de la dernière instruction lancée dans le code intermédiaire (bytecode)
	tb_lineno	numéro de ligne courant dans le code source Python
	tb_next	trace de pile interne suivante (appel par le cadre courant)
cadre	f_back	trace d'exécution externe suivante (le contexte appelant du cadre courant)
	f_builtins	espace de nommage natif du cadre courant
	f_code	objet code exécuté dans le cadre courant
	f_globals	espace de nommage global tel que vu par cadre courant
	f_lasti	index de la dernière instruction lancée dans le code intermédiaire (bytecode)
	f_lineno	numéro de ligne courant dans le code source Python
	f_locals	espace de nommage local du cadre courant
	f_trace	fonction de traçage du cadre courant, ou None
code	co_argcount	nombre d'arguments (excluant les arguments keyword-only, * ou **)
	co_code	texte du code intermédiaire compilé
	co_cellvars	n-uplet du nom des cellules variables (référencées par leur contexte)
	co_consts	n-uplet des constantes utilisées dans le code intermédiaire (bytecode)
	co_filename	nom du fichier dans lequel cet objet code a été créé
	co_firstlineno	numéro de la première ligne dans le code source Python
	co_flags	bitmap des options CO_*, voir plus ici
	co_lnotab	tableau de correspondance encodée des numéros de ligne aux numéros d'indices du code intermédiaire (bytecode)
	co_freevars	n-uplet des noms de variables libres (référencées par la fermeture (closure en anglais) d'une fonction)
	co_posonlyargcount	nombre d'arguments positionnels
	co_kwonlyargcount	nombre d'arguments keywords-only (excluant les arguments **)
	co_name	nom de l'objet code lors de sa définition
	co_names	tuple of names of local variables
	co_nlocals	nombre de variables locales
	co_stacksize	espace requis pour la pile de la machine virtuelle
	co_varnames	n-uplet des noms des arguments et variables locales
générateur	__name__	nom
	__qualname__	nom qualifié
	gi_frame	cadre
	gi_running	est-ce que le générateur est en cours d'exécution ?
	gi_code	code
	gi_yieldfrom	objet pointé par l'itérateur yield from, ou None
coroutine	__name__	nom
	__qualname__	nom qualifié
	cr_await	objet sur lequel on attend (await) présentement, ou None
	cr_frame	cadre
	cr_running	est-ce que la coroutine est en cours d'exécution ?
	cr_code	code
	cr_origin	lieu de création de la coroutine, ou None. Voir sys.set_coroutine_origin_tracking_depth()
builtin	__doc__	texte de documentation
	__name__	nom originel de cette fonction ou méthode
	__qualname__	nom qualifié
	__self__	instance à laquelle est liée une méthode, ou None

Modifié dans la version 3.5: ajout des attributs __qualname et gi_yieldfrom aux générateurs.

L'attribut __name__ du générateur est maintenant déterminé par le nom de la fonction, plutôt que le nom du code, et peut maintenant être modifié.

Modifié dans la version 3.7: Ajout de l'attribut cr_origin aux coroutines.

inspect.getmembers(object[, predicate])

Renvoie tous les membres d'un objet sous la forme d'une liste de paires (nom, valeur), ordonnée par nom. Si l'argument predicate (qui sera appelé avec la valeur de chaque membre) est fourni, seuls les membres pour lequel le prédicat est vrai seront inclus.

Note

getmembers() renvoie les attributs de classe définis dans la métaclasse seulement lorsque l'argument est une classe et que ces attributs ont été listés dans la méthode personnalisée __dir__() de cette métaclasse.

inspect.getmodulename(path)

Renvoie le nom du module indiqué par le fichier path, excluant le nom des paquets englobants. L'extension du fichier est vérifiée parmi toutes les entrées renvoyées par importlib.machinery.all_suffixes(). S'il y a une correspondance, le chemin final est renvoyé, sans l'extension. Autrement, None est renvoyé.

Notez que cette fonction renvoie un nom significatif seulement pour les modules Python - les chemins qui réfèrent à des paquets Python donnent toujours None.

Modifié dans la version 3.3: La fonction est basée directement sur importlib.

inspect.ismodule(object)

Renvoie True si l'objet est un module.

inspect.isclass(object)

Renvoie True si l'objet est une classe, qu'il s'agisse d'un objet natif ou qu'elle soit écrite en Python.

inspect.ismethod(object)

Renvoie True si l'objet est une méthode liée écrite en Python.

inspect.isfunction(object)

Renvoie True si l'objet est une fonction Python, ce qui inclut les fonctions créées par une expression lambda.

inspect.isgeneratorfunction(object)

Renvoie True si l'objet est un générateur.

Modifié dans la version 3.8: les fonctions englobées dans functools.partial() renvoient maintenant True si la fonction englobée est un générateur Python.

inspect.isgenerator(object)

Renvoie True si l'objet est un générateur.

inspect.iscoroutinefunction(object)

Renvoie True si l'objet est une fonction coroutine (une fonction définie avec une syntaxe async def).

Nouveau dans la version 3.5.

Modifié dans la version 3.8: les fonctions englobées par functools.partial() renvoient maintenant True si la fonction englobée est une coroutine.

inspect.iscoroutine(object)

Renvoie True si l'objet est une coroutine créée par une fonction async def.

Nouveau dans la version 3.5.

inspect.isawaitable(object)

Renvoie True si l'objet peut être utilisé par une expression await.

Peut aussi être utilisé pour distinguer les coroutines basées sur un générateur des générateurs normaux :

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

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

Nouveau dans la version 3.5.

inspect.isasyncgenfunction(object)

Renvoie True si l'objet est un générateur asynchrone, par exemple :

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

Nouveau dans la version 3.6.

Modifié dans la version 3.8: les fonctions englobées par functools.partial() renvoient maintenant True si la fonction englobée est une fonction génératrice asynchrone.

inspect.isasyncgen(object)

Renvoie True si l'objet est un itérateur de générateur asynchrone créé par une fonction génératrice asynchrone.

Nouveau dans la version 3.6.

inspect.istraceback(object)

Renvoie True si l'objet est une trace d'exécution.

inspect.isframe(object)

Renvoie True si l'objet est un cadre.

inspect.iscode(object)

Renvoie True si l'objet est un code.

inspect.isbuiltin(object)

Renvoie True si l'objet est une fonction native ou une méthode liée native.

inspect.isroutine(object)

Renvoie True si l'objet est une fonction, qu'elle soit définie par l'utilisateur, native, ou une méthode.

inspect.isabstract(object)

Renvoie True si l'objet est une classe de base abstraite.

inspect.ismethoddescriptor(object)

Renvoie True si l'objet est un descripteur de méthode sauf si ismethod(), isclass(), isfunction() ou isbuiltin() sont vrais (True).

Cela est par exemple vrai pour int.__add__. Un objet qui passe ce test a une méthode __get__(), pas de méthode __set__(), sans être regardant sur les autres les attributs. Un attribut __name__ sera souvent présent et __doc__ également.

Les méthodes implémentées via descripteurs et qui passent l'un ou l'autre des tests renvoie False pour ismethoddescriptor(), simplement parce que les autres tests garantissent davantage — vous pouvez supposer l'existence d'un attribut __func__ (etc.) lorsqu'un objet renvoie True pour ismethod() .

inspect.isdatadescriptor(object)

Renvoie True si l'objet est un descripteur de données.

Les descripteurs de données ont une méthode __set__ ou __delete__. Par exemple les propriétés (définies en Python), getsets et les membres. Les 2 derniers sont définis en C et il existe des tests plus spécifiques disponibles pour ceux-ci qui sont robustes à travers les implémentations Python. Normalement, les descripteurs de données auront aussi les attributs __name__ et __doc__ (les propriétés, getsets et membres auront les deux), mais cela n'est pas garanti.

inspect.isgetsetdescriptor(object)

Renvoie True si l'objet est un descripteur getset.

CPython implementation detail: getsets sont des attributs définis dans des extensions de modules via des structures PyGetSetDef. Pour les implémentations Python ne possédant pas ces types, cette méthode renvoie toujours False.

inspect.ismemberdescriptor(object)

Renvoie True si l'objet est un membre descripteur.

CPython implementation detail: Les membres descripteurs sont des attributs définis dans des extensions de modules via des structures PyMemberDef. Pour les implémentations Python ne possédant pas ces types, cette méthode renvoie toujours False.

Récupération du code source

inspect.getdoc(object)

Get the documentation string for an object, cleaned up with cleandoc(). If the documentation string for an object is not provided and the object is a class, a method, a property or a descriptor, retrieve the documentation string from the inheritance hierarchy.

Modifié dans la version 3.5: les chaînes de documentation sont maintenant héritées si elles ne sont pas surchargées.

inspect.getcomments(object)

Renvoie en une chaîne de caractères toute ligne de commentaire qui précède immédiatement le code source de l'objet (pour une classe, fonction ou méthode) ou en début d'un fichier de code source Python (si l'objet est un module). Si le code source de l'objet n'est pas disponible, renvoie None. Cela peut se produire si l'objet a été défini en C ou dans un interpréteur interactif.

inspect.getfile(object)

Renvoie le nom du fichier (texte ou binaire) dans lequel un objet a été défini. Cette méthode échoue avec TypeError si l'objet est un module, une classe ou une fonction native.

inspect.getmodule(object)

Try to guess which module an object was defined in.

inspect.getsourcefile(object)

Return the name of the Python source file in which an object was defined. This will fail with a TypeError if the object is a built-in module, class, or function.

inspect.getsourcelines(object)

Renvoie une liste de lignes du code source et le numéro de la première ligne d'un objet. L'argument peut être un module, classe, méthode, fonction, trace d'exécution, cadre ou objet code. Le code source est renvoyé comme une liste des lignes correspondant à l'objet, et le numéro de ligne indique la position à laquelle la première ligne de code a été trouvée. Une OSError est levée si le code source ne peut être retrouvé.

Modifié dans la version 3.3: OSError est levé plutôt que IOError, qui est maintenant un alias de ce premier.

inspect.getsource(object)

Renvoie le texte du code source pour un objet. L'argument peut être un module, classe, méthode, fonction, trace de pile, cadre ou objet code. Le code source est renvoyé comme une seule chaîne de caractères. OSError est levé si le code source ne peut être retrouvé.

Modifié dans la version 3.3: OSError est levé plutôt que IOError, qui est maintenant un alias de ce premier.

inspect.cleandoc(doc)

Nettoie les indentations des chaînes de documentation qui sont indentées de manières à s'aligner avec les blocs de code.

Enlève tous les espaces blancs en début de ligne à partir de la première. Tout espace blanc en début de ligne qui puisse être enlevé de manière uniforme à partir de la seconde ligne le sera. Les lignes vides en début et en fin de document seront ensuite enlevées. Les tabulations seront converties en espaces.

Introspection des appelables avec l'objet Signature

Nouveau dans la version 3.3.

L'objet Signature représente la signature de l'appel et de la valeur renvoyée d'un objet appelable. Utilisez la fonction signature() pour obtenir ces signatures.

inspect.signature(callable, *, follow_wrapped=True)

Renvoie un objet Signature pour un appelable :

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

La fonction accepte une grande étendue d'appelables Python, des fonctions et classes jusqu'aux objets functools.partials().

Raises ValueError if no signature can be provided, and TypeError if that type of object is not supported.

Une barre oblique (/) dans la signature d'une fonction dénote que les paramètres qui précèdent sont exclusivement positionnels. Pour plus d'information, voir l'entrée de la FAQ sur les arguments exclusivement positionnels.

Nouveau dans la version 3.5: paramètre follow_wrapped. Passez False pour obtenir une signature callable plus spécifiquement (callable.__wrapped__ ne sera pas utilisé pour dépouiller un appelable décoré.)

Note

Certains appelables ne peuvent bénéficier d'introspection dans certains environnements Python. Par exemple, en CPython, certaines fonctions natives définies en C ne fournissent aucune métadonnée sur leurs arguments.

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

L'objet Signature représente la signature d'appel d'une fonction et son annotation de type. Pour chaque paramètre accepté par une fonction, il conserve un objet Parameter dans sa collection parameters.

L'argument optionnel parameters est une séquence d'objets Parameters, qui permet de vérifier qu'il n'y a pas de duplication de noms de paramètres, que les paramètres sont dans le bon ordre (positionnels d'abord, positionnels ou nommés ensuite et que les paramètres avec valeurs par défaut sont placés après ceux qui n'en ont pas).

L'argument optionnel return_annotation pouvant être un objet Python arbitraire, est l'annotation du type renvoyé par appelable.

Les objets Signatures sont immuables. Utilisez Signature.replace() pour en faire une copie modifiée.

Modifié dans la version 3.5: les objets Signature sont pickable (sérialisables avec Pickle) et hachables.

empty

Un marqueur spécial, accessible via Signature.empty, indiquant l'absence d'une annotation de type renvoyé.

parameters

Une table de correspondance ordonnée des noms de paramètres avec les objets Parameter. Les paramètres apparaissent dans l'ordre strict de leur définition, incluant les paramètres exclusivement nommés.

Modifié dans la version 3.7: Python ne garantit explicitement la préservation de l'ordre des paramètres exclusivement nommés que depuis la version 3.7, bien qu'en pratique cet ordre a toujours été préservé sous Python 3.

return_annotation

L'annotation du type renvoyé par l'appelable. Si l'appelable n'a pas d'annotation de type, cet attribut est évalué à Signature.empty.

bind(*args, **kwargs)

Crée une table de correspondance entre les arguments positionnels et nommés avec les paramètres. Renvoie BoundArguments si *args et **kwargs concordent avec la signature, autrement lève une TypeError.

bind_partial(*args, **kwargs)

Fonctionne de manière similaire à Signature.bind(), mais permet l'omission de certains arguments (semblable au comportement de functools.partial()). Renvoie BoundArguments, ou lève une TypeError si l'argument passé ne correspond pas à la signature.

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

Crée une nouvelle instance de Signature sur la base de l'instance sur laquelle la méthode est invoquée. Il est possible de passer différents paramètres et/ou annotations de type pour remplacer les propriétés correspondantes de la signature de base. Pour enlever les annotations de type de la copie de la Signature, lui passer 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)

Return a Signature (or its subclass) object for a given callable obj. Pass follow_wrapped=False to get a signature of obj without unwrapping its __wrapped__ chain.

Cette méthode simplifie l'héritage de Signature :

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

Nouveau dans la version 3.5.

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

Les objets Parameter sont immuables. Utilisez Parameter.replace() pour créer une copie modifiée.

Modifié dans la version 3.5: les objets Parameters sont pickable (sérialisables avec Pickle) et hachable.

empty

Un marqueur spécial, accessible via Parameters.empty indiquant l'absence de valeurs par défaut et d'annotations.

name

Le nom du paramètre (chaîne de caractères). Le nom doit être un identifiant Python valide.

CPython implementation detail: CPython génère un nom de paramètre implicite de forme .0 sur les objets de code utilisés pour implémenter les compréhensions et expressions génératrices.

Modifié dans la version 3.6: ces paramètres sont exposés par ce module par des noms de forme implicit0.

default

La valeur par défaut de ce paramètre. Si le paramètre n'a pas de valeur par défaut, cet attribut vaut Parameter.empty.

annotation

L'annotation du paramètre. Si le paramètre n'a pas d'annotation, cet attribut est défini à Parameter.empty.

kind

Décrit comment les valeurs d'argument sont liées au paramètre. Les valeurs possibles (accessibles par Parameter, tel que Parameter.KEYWORD_ONLY) :

Nom	Signification
POSITIONAL_ONLY	La valeur doit être donnée comme argument positionnel. Les arguments exclusivement positionnels sont ceux qui apparaissent avant une entrée / (si présente) dans une définition de fonction Python.
POSITIONAL_OR_KEYWORD	La valeur peut être donnée comme argument nommé ou positionnel (ce qui est l'affectation de variable standard pour les fonctions implémentées en Python).
VAR_POSITIONAL	Un n-uplet d'arguments positionnels qui ne sont affectés à aucun autre paramètre. Cela correspond à un paramètre *args dans une définition de fonction Python.
KEYWORD_ONLY	La valeur doit être donnée comme argument nommé. Les arguments exclusivement nommés sont ceux qui apparaissent après un * ou *args dans une définition de fonction Python.
VAR_KEYWORD	Un dictionnaire d'arguments nommés qui ne sont liés à aucun autre paramètre. Cela correspond à une expression **kwargs dans une définition de fonction Python.

Exemple : afficher tous les arguments exclusivement nommés sans valeur par défaut :

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

Décrit une énumération de valeurs de Parameter.kind.

Nouveau dans la version 3.8.

Exemple : afficher toutes les descriptions d'arguments :

>>> 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])

Crée une nouvelle instance de Parameter sur la base de l'instance sur laquelle la méthode est invoquée. Pour redéfinir un attribut Parameter, lui passer l'argument correspondant. Pour enlever les valeurs par défaut et/ou les annotations de retour de la copie du Parameter, lui passer 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'"

Modifié dans la version 3.4: en Python 3.3, un objet Parameter pouvait avoir name à None si son attribut kind valait POSITIONAL_ONLY. Cela n'est plus possible.

class inspect.BoundArguments

Le résultat d'un appel à Signature.bind() ou Signature.bind_partial(). Contient la correspondance entre les arguments et les paramètres de la fonction.

arguments

Une correspondance muable entre les noms de paramètres et les valeurs des arguments. Contient seulement les arguments liés explicitement. Les changements dans arguments sont reflétés dans args et kwargs.

Doit être utilisé en combinaison avec Signature.parameters pour le traitement d'arguments.

Note

Les arguments pour lesquels Signature.bind() ou Signature.bind_partial() supposent une valeur par défaut sont ignorés. Au besoin, utiliser BoundArguments.apply_defaults() pour les inclure.

Modifié dans la version 3.9: arguments est maintenant de type dict. Anciennement, il était de type collections.OrderedDict.

args

Un n-uplets des valeurs d'arguments positionnels. Évalué dynamiquement à partir de l'attribut arguments.

kwargs

Un dictionnaire des valeurs des arguments nommés. Évalué dynamiquement à partir de l'attribut arguments.

signature

Une référence à l'objet Signature de la classe parente.

apply_defaults()

Assigne les valeurs par défaut pour les arguments manquants.

Pour les arguments positionnels variables (*args) la valeur par défaut est un n-uplet vide.

Pour les arguments nommés variables (**kwargs) la valeur par défaut est un dictionnaire vide.

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

Nouveau dans la version 3.5.

Les propriétés args et kwargs peuvent être utilisées pour l'appel de fonctions :

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

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

Voir aussi

PEP 362 — Function Signature Object.

La spécification détaillée, détails d'implémentation et exemples.

Classes et fonctions

inspect.getclasstree(classes, unique=False)

Organise la liste de classes donnée en une hiérarchie de listes imbriquées. Lorsqu'une liste imbriquée apparaît, elle contient les classes dérivées de la classe dont l'entrée précède immédiatement cette liste. Chaque entrée est une paire contenant la classe et un n-uplet de ses classes de base. Si l'argument unique est vrai, exactement une entrée apparaît dans la structure renvoyée pour chaque classe de la liste donnée en argument. Autrement, les classes utilisant l'héritage multiple et ses descendantes apparaissent plusieurs fois.

inspect.getargspec(func)

Get the names and default values of a Python function's parameters. A named tuple ArgSpec(args, varargs, keywords, defaults) is returned. args is a list of the parameter names. varargs and keywords are the names of the * and ** parameters 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.

Obsolète depuis la version 3.0: Use getfullargspec() for an updated API that is usually a drop-in replacement, but also correctly handles function annotations and keyword-only parameters.

Alternatively, use signature() and Signature Object, which provide a more structured introspection API for callables.

inspect.getfullargspec(func)

Obtenir les noms et les valeurs par défaut des paramètres de fonction Python. Un n-uplet nommé est renvoyé :

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

args est une liste de noms de paramètres positionnels. varargs est le nom du paramètre * ou None si les arguments positionnels arbitraires ne sont pas acceptés. varkw est le nom du paramètre **, ou None si les paramètres arbitraires nommés ne sont pas acceptés. defaults est un n-uplet des valeurs des arguments par défaut correspondant aux derniers n arguments positionnels, ou None si aucun défaut n'est défini. kwonlyargs est une liste d'arguments exclusivement nommés, ordonnée selon l'ordre de déclaration. kwonlydefaults est un dictionnaire de correspondance entre les noms de paramètres de kwonlyargs et les valeurs par défaut utilisées si aucun argument n'est donné. annotations est un dictionnaire de correspondance entre les noms de paramètres et les annotations. La clef spéciale "return" est utilisée pour obtenir la valeur de retour de l'annotation la fonction (si elle existe).

Notez que signature() et Signature Object fournissent l'API recommandé pour l’introspection d'appelables et prennent en charge des comportements additionnels (comme les arguments exclusivement positionnels) qui sont parfois rencontrés dans les APIs des modules d'extension. Cette fonction et maintenue principalement pour maintenir la compatibilité avec l'API du module inspect de Python 2.

Modifié dans la version 3.4: cette fonction est maintenant basée sur signature(), mais ignore toujours les attributs _wrapped_ et inclue le premier paramètre (déjà lié) dans la signature des méthodes liées.

Modifié dans la version 3.6: cette méthode fût précédemment documentée comme dépréciée en faveur de signature() en Python 3.5, mais cette décision fût renversée afin de ré-introduire une interface standard clairement supportée pour du code unifié Python 2/3 migrant pour se départir de l'API getargspec().

Modifié dans la version 3.7: Python ne garantit explicitement la préservation de l'ordre des paramètres exclusivement nommés que depuis la version 3.7, bien qu'en pratique cet ordre a toujours été préservé sous Python 3.

inspect.getargvalues(frame)

Obtenir de l'information sur les arguments passés à un cadre particulier. Un n-uplet nommé ArgInfo(args, varargs, keywords, locals) est renvoyé. args est une liste de noms d'arguments. varags et keywords sont les noms des arguments * et ** ou None. locals est le dictionnaire des variables locales du cadre courant.

Note

Cette fonction fût dépréciée par inadvertance en Python 3.5.

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

Format a pretty argument spec from the values returned by getfullargspec().

The first seven arguments are (args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations).

The other six arguments are functions that are called to turn argument names, * argument name, ** argument name, default values, return annotation and individual annotations into strings, respectively.

Par exemple :

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

Obsolète depuis la version 3.5: Use signature() and Signature Object, which provide a better introspecting API for callables.

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

Formatage lisible des quatre valeurs renvoyées par getargvalues(). Les arguments format* sont des fonctions de formatage optionnelles qui sont appelées pour convertir les noms et valeurs en chaînes de caractères.

Note

Cette fonction fût dépréciée par inadvertance en Python 3.5.

inspect.getmro(cls)

Renvoie un n-uplet des classes de base de cls, incluant cls, selon le l'ordre de résolution des méthodes (method resolution order). Aucune classe n'apparaît plus d'une fois dans ce n-uplet. Notez que le l'ordre de résolution des méthodes dépend du type de cls. Exception faite d'une utilisation très particulière de la métaclasse définie par l'usager, cls sera toujours le premier élément du tuple.

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

Lie args et kwds aux arguments nommés de la fonction ou méthode Python func, comme si elle était appelée avec ceux-ci. Pour les méthodes liées, lie aussi le premier argument (normalement appelé self) à l'instance associée. Un dictionnaire est renvoyé, une correspondance entre les noms des arguments (incluant les noms des arguments * et **, s'ils existent) et leurs valeurs obtenues de args et kwds. Lors d'une invocation incorrecte de func, i.e. lorsque func(*args, **kwds) lèverait une exception en raison de signature incompatible, une exception du même type et de message identique ou similaire est levée. Par exemple :

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

Nouveau dans la version 3.2.

Obsolète depuis la version 3.5: utilisez plutôt Signature.bind() et Signature.bind_partial().

inspect.getclosurevars(func)

Obtenir la correspondance de nom de références externes d'une fonction ou méthode Python func avec leur valeur courante. Un n-uplet nommé ClosureVars(nonlocals, globals, builtins, unbound) est renvoyé. nonlocals établit une correspondance des noms capturés par les fermetures lexicales, globals au module de la fonction et builtins aux noms natifs visibles depuis le corps de la fonction. unbound est un ensemble de noms référencés dans la fonction ne trouvant aucune résolution dans les valeurs globales du module courant ni à travers le lexique natif.

TypeError est levée si func n'est ni une fonction ni une méthode Python.

Nouveau dans la version 3.3.

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

Obtenir l'objet englobé par func. Suit une chaîne d'attributs de __wrapped__, renvoyant le dernier objet de la chaîne.

stop est une fonction de callback optionnelle qui accepte un objet de la chaîne englobée comme son seul argument et permet d'arrêter le déballage avant la fin si la fonction de callback renvoie une valeur vraie. Si la fonction callback ne renvoie jamais une valeur vraie, le dernier objet de la chaîne est renvoyé comme d'habitude. Par exemple, signature() utilise ceci pour arrêter le déballage si un objet dans la chaîne définit un attribut __signature__.

ValueError est levée si un cycle est rencontré.

Nouveau dans la version 3.4.

La pile d'interpréteur

When the following functions return "frame records," each record is a named tuple FrameInfo(frame, filename, lineno, function, code_context, index). The tuple contains 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.

Modifié dans la version 3.5: Return a named tuple instead of a tuple.

Note

Conserver des références à des objets cadre, tel que trouvé dans le 1er élément des enregistrements de cadres que ces fonctions renvoient, peut créer des cycles de référence dans votre programme. Lorsqu'un cycle de référence a été créé, la durée de vie de tous les objets pouvant être accessibles par ces objets peut être grandement augmentée, même si le détecteur de cycle (optionnel) de Python est activé. Si ces cycles doivent être créés, il est important de s'assurer qu'ils soient explicitement brisés pour éviter la destruction reportée des objets et l'augmentation résultante de l'utilisation de la mémoire.

Bien que le détecteur trouvera ces cycles, la destruction des cadres (et variables locales) peut être fait de manière déterministe en enlevant les cycles dans une clause finally. Cela est important si le détecteur de cycle a été désactivé lors de la compilation du code Python ou en utilisant gc.disable(). Par exemple :

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

Pour conserver ces cadres (par exemple pour imprimer une trace d'exécution plus tard), vous pouvez briser ces cycles de référence en utilisant la méthode frame.clear().

L'argument optionnel context supporté par la plupart de ces méthodes spécifie le nombre de lignes de contexte à renvoyer, qui sera centré autour de la ligne courante.

inspect.getframeinfo(frame, context=1)

Get information about a frame or traceback object. A named tuple Traceback(filename, lineno, function, code_context, index) is returned.

inspect.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.

Modifié dans la version 3.5: une liste de n-uplet nommé FrameInfo(frame, filename, lineno, function, code_context, index) est renvoyée.

inspect.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.

Modifié dans la version 3.5: une liste de n-uplet nommé FrameInfo(frame, filename, lineno, function, code_context, index) est renvoyée.

inspect.currentframe()

Renvoie l'objet cadre de la pile pour le cadre de l’appelant.

CPython implementation detail: cette fonction nécessite que l'interpréteur Python implémente une pile de cadres d'appel, ce qui n'est pas forcément le cas de toutes les implémentations Python. Si le code s'exécute dans une implémentation Python n'implémentant pas la pile de cadres, cette fonction renvoie None.

inspect.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.

Modifié dans la version 3.5: une liste de n-uplet nommé FrameInfo(frame, filename, lineno, function, code_context, index) est renvoyée.

inspect.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.

Modifié dans la version 3.5: une liste de n-uplet nommé FrameInfo(frame, filename, lineno, function, code_context, index) est renvoyée.

Recherche dynamique d'attributs

getattr() et hasattr() peuvent tous deux engendrer l'exécution de code lors la recherche ou vérification de l'existence d'attributs. Les descripteurs, comme les propriétés, seront invoqués et __getattr__() et __getattribute__() peuvent être appelés.

Pour les cas où une introspection passive est désirée, comme des outils de documentation, cela peut être inconvenable. getattr_static() possède la même signature que getattr(), mais évite l'exécution de code lors de la recherche d'attributs.

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

Retrouve des attributs sans lancer une recherche dynamique via le protocole descripteur, __getattr__() ou __getattribute__().

Note : cette fonction ne retrouve pas forcément tous les attributs renvoyés par getattr (tel que des attributs générés dynamiquement) et pourrait retrouver des attributs non retrouvés par getattr (tel que des descripteurs qui lèvent un AttributeError). Elle peut aussi donner des objets descripteurs, plutôt que des membres d'instance.

Si l'instance __dict__ est cachée (shadowed) par un autre membre (par exemple une propriété), cette fonction ne pourra pas retrouver les membres de l'instance.

Nouveau dans la version 3.2.

getattr_static() ne résout pas les descripteurs, par exemple slot descriptors ou les descripteurs getset des objets implémentés en C. Le descripteur de l'objet est renvoyé plutôt que l'attribut sous-jacent.

Vous pouvez gérer ces cas à l'aide du code suivant. Notez que pour des descripteurs arbitraires getset les invoquant, de l'exécution de code pourrait être lancée :

# 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

État courant de Générateurs et Coroutines

Lors de l'implémentation d'ordonnanceur de coroutine et autres utilisations avancées de générateurs, il est utile de déterminer si un générateur est présentement en cours d'exécution, en attente de démarrage ou de continuation, ou s'il a déjà terminé. getgeneratorstate() permet d'aisément déterminer l'état courant d'un générateur.

inspect.getgeneratorstate(generator)

Donne l'état courant d'un générateur-itérateur.

Les états possibles :

• GEN_CREATED : En attente de démarrage d'exécution.

• GEN_RUNNING : En cours d'exécution par l'interpréteur.

• GEN_SUSPENDED : Présentement suspendu à une expression yield.

• GEN_CLOSED : L'exécution est complétée.

Nouveau dans la version 3.2.

inspect.getcoroutinestate(coroutine)

Donne l'état courant d'un objet coroutine. L'utilisation est prévue avec des objets coroutine créés avec des fonctions async def, mais accepte n'importe quel objet semblable à une coroutine qui définisse des attributs cr_running cr_frame.

Les états possibles :

• CORO_CREATED : En attente de démarrage d'exécution.

• CORO_RUNNING : En cours d'exécution par l'interpréteur.

• CORO_SUSPENDED : Suspendu à une expression await.

• CORO_CLOSED : Exécution complétée.

Nouveau dans la version 3.5.

L'état courant interne du générateur peut aussi être vérifié. Ceci est utile pour des tests, afin d'assurer que l'état interne est mise à jour tel que prévu :

inspect.getgeneratorlocals(generator)

Donne une correspondance de variables locales dans generator avec les valeurs courantes. Un dictionnaire est renvoyé, établissant la correspondance entre variables et valeurs. Ceci est équivalent à appeler locals() dans le corps du générateur et les mêmes restrictions s'appliquent.

Si generator est un générateur sans cadre courant associé, alors un dictionnaire vide est renvoyé. TypeError est levé sir generator n'est pas un objet générateur Python.

CPython implementation detail: Cette fonction repose sur l'exposition d'une pile de cadres Python par le générateur pour l'introspection, ce qui n'est pas garanti dans toutes les implémentations Python. Dans un tel cas, cette fonction renvoie toujours un dictionnaire vide.

Nouveau dans la version 3.3.

inspect.getcoroutinelocals(coroutine)

Cette fonction est semblable à getgeneratorlocals(), mais fonctionne pour des objets coroutines créés avec des fonctions async def.

Nouveau dans la version 3.5.

Bit d'option des objets code

Les objets de code Python ont un attribut co_flags, ce qui est un bitmap des valeurs suivantes :

inspect.CO_OPTIMIZED

L'objet code est optimisé, utilisant des variables locales rapides.

inspect.CO_NEWLOCALS

Si défini, un nouveau dictionnaire sera créé pour le f_locals du cadre courant lorsque l'objet code est exécuté.

inspect.CO_VARARGS

L'objet code possède un paramètre de variable positionnel (*args ou semblable).

inspect.CO_VARKEYWORDS

L'objet code possède une paramètre par mot-clé variable (**kwargs ou semblable).

inspect.CO_NESTED

L'option est définie lorsque le code est une fonction imbriquée.

inspect.CO_GENERATOR

L'option est définie lorsque l'objet code est une fonction génératrice, c'est-à-dire qu'un objet générateur est renvoyé lorsque le code objet est exécuté.

inspect.CO_NOFREE

The flag is set if there are no free or cell variables.

inspect.CO_COROUTINE

L'option est définie lorsque le code objet est une fonction coroutine. Lors que le code objet est exécuté, il renvoie un objet coroutine. Voir PEP 492 pour plus de détails.

Nouveau dans la version 3.5.

inspect.CO_ITERABLE_COROUTINE

L'option est utilisée pour transformer un générateur en une coroutine basée sur un générateur. Les objets générateurs avec cette option peuvent être utilisés dans une expression await et un objet coroutine yield from. Voir PEP 492 pour plus de détails.

Nouveau dans la version 3.5.

inspect.CO_ASYNC_GENERATOR

L'option est définie lorsque l'objet code est une fonction génératrice asynchrone. Lorsque l'objet code est exécuté, il renvoie un objet générateur asynchrone. Voir PEP 525 pour les détails.

Nouveau dans la version 3.6.

Note

Ces options sont spécifiques à CPython et pourraient ne pas être définies dans d'autres implémentations Python. De plus, les options constituent des détails d'implémentation et pourraient être enlevées ou dépréciées dans des versions ultérieures. Il est recommandé d'utiliser les APIs publiques de inspect pour tous les besoins d'introspection.

Interface en ligne de commande

Le module inspect fournit également des capacités d'introspection de base en ligne de commande.

Par défaut, il accepte le nom d'un module et affiche la source de ce module. Une classe ou fonction à l'intérieur du module peut également être affichée en ajoutant un ":" et le nom qualifié de l'objet désiré.

--details

Affiche de l'information à propos de l'objet spécifié plutôt que du code source.