Étant donné un objet de fonction, comment puis-je obtenir sa signature? Par exemple, pour:
def myMethod(firt, second, third='something'):
pass
Je voudrais obtenir "myMethod(firt, second, third='something')"
.
import inspect
def foo(a, b, x='blah'):
pass
print(inspect.getargspec(foo))
# ArgSpec(args=['a', 'b', 'x'], varargs=None, keywords=None, defaults=('blah',))
Toutefois, notez que inspect.getargspec()
est obsolète depuis Python 3.0.
Python 3.0--3.4 recommande inspect.getfullargspec()
.
Python 3.5+ recommande inspect.signature()
.
Le moyen le plus simple de trouver la signature d’une fonction serait probablement help(function)
:
>>> def function(arg1, arg2="foo", *args, **kwargs): pass
>>> help(function)
Help on function function in module __main__:
function(arg1, arg2='foo', *args, **kwargs)
De plus, dans Python 3, une méthode a été ajoutée au module inspect
appelée signature
, conçue pour représenter la signature d'un objet appelable et son annotation de retour :
>>> 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'>
#! /usr/bin/env python
import inspect
from collections import namedtuple
DefaultArgSpec = namedtuple('DefaultArgSpec', 'has_default default_value')
def _get_default_arg(args, defaults, arg_index):
""" Method that determines if an argument has default value or not,
and if yes what is the default value for the argument
:param args: array of arguments, eg: ['first_arg', 'second_arg', 'third_arg']
:param defaults: array of default values, eg: (42, 'something')
:param arg_index: index of the argument in the argument array for which,
this function checks if a default value exists or not. And if default value
exists it would return the default value. Example argument: 1
:return: Tuple of whether there is a default or not, and if yes the default
value, eg: for index 2 i.e. for "second_arg" this function returns (True, 42)
"""
if not defaults:
return DefaultArgSpec(False, None)
args_with_no_defaults = len(args) - len(defaults)
if arg_index < args_with_no_defaults:
return DefaultArgSpec(False, None)
else:
value = defaults[arg_index - args_with_no_defaults]
if (type(value) is str):
value = '"%s"' % value
return DefaultArgSpec(True, value)
def get_method_sig(method):
""" Given a function, it returns a string that pretty much looks how the
function signature would be written in python.
:param method: a python method
:return: A string similar describing the pythong method signature.
eg: "my_method(first_argArg, second_arg=42, third_arg='something')"
"""
# The return value of ArgSpec is a bit weird, as the list of arguments and
# list of defaults are returned in separate array.
# eg: ArgSpec(args=['first_arg', 'second_arg', 'third_arg'],
# varargs=None, keywords=None, defaults=(42, 'something'))
argspec = inspect.getargspec(method)
arg_index=0
args = []
# Use the args and defaults array returned by argspec and find out
# which arguments has default
for arg in argspec.args:
default_arg = _get_default_arg(argspec.args, argspec.defaults, arg_index)
if default_arg.has_default:
args.append("%s=%s" % (arg, default_arg.default_value))
else:
args.append(arg)
arg_index += 1
return "%s(%s)" % (method.__name__, ", ".join(args))
if __== '__main__':
def my_method(first_arg, second_arg=42, third_arg='something'):
pass
print get_method_sig(my_method)
# my_method(first_argArg, second_arg=42, third_arg="something")
Essayez d'appeler help
sur un objet pour le découvrir.
>>> foo = [1, 2, 3]
>>> help(foo.append)
Help on built-in function append:
append(...)
L.append(object) -- append object to end
Peut-être un peu tard pour la soirée, mais si vous souhaitez également conserver l'ordre des arguments et leurs valeurs par défaut, vous pouvez utiliser le module Arbre de syntaxe abstraite (ast) .
Voici une preuve de concept (méfiez-vous du code pour trier les arguments et les faire correspondre à leurs valeurs par défaut peut certainement être amélioré/rendu plus clair):
import ast
for class_ in [c for c in module.body if isinstance(c, ast.ClassDef)]:
for method in [m for m in class_.body if isinstance(m, ast.FunctionDef)]:
args = []
if method.args.args:
[args.append([a.col_offset, a.id]) for a in method.args.args]
if method.args.defaults:
[args.append([a.col_offset, '=' + a.id]) for a in method.args.defaults]
sorted_args = sorted(args)
for i, p in enumerate(sorted_args):
if p[1].startswith('='):
sorted_args[i-1][1] += p[1]
sorted_args = [k[1] for k in sorted_args if not k[1].startswith('=')]
if method.args.vararg:
sorted_args.append('*' + method.args.vararg)
if method.args.kwarg:
sorted_args.append('**' + method.args.kwarg)
signature = '(' + ', '.join(sorted_args) + ')'
print method.name + signature
Si vous essayez uniquement d'imprimer la fonction, utilisez pydoc.
import pydoc
def foo(arg1, arg2, *args, **kwargs):
'''Some foo fn'''
pass
>>> print pydoc.render_doc(foo).splitlines()[2]
foo(arg1, arg2, *args, **kwargs)
Si vous essayez d'analyser réellement la signature de la fonction, utilisez argspec du module de contrôle. Je devais le faire lors de la validation de la fonction de script de raccordement d'un utilisateur dans un cadre général.
Exemple de code:
import inspect
from collections import OrderedDict
def get_signature(fn):
params = inspect.signature(fn).parameters
args = []
kwargs = OrderedDict()
for p in params.values():
if p.default is p.empty:
args.append(p.name)
else:
kwargs[p.name] = p.default
return args, kwargs
def test_sig():
def fn(a, b, c, d=3, e="abc"):
pass
assert get_signature(fn) == (
["a", "b", "c"], OrderedDict([("d", 3), ("e", "abc")])
)
Utilisez% pdef dans la ligne de commande (IPython), cela n’imprimera que la signature.
par exemple. %pdef np.loadtxt
np.loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes')