Comment puis-je trouver le nombre d'arguments d'une fonction Python? J'ai besoin de savoir combien d'arguments normaux il a et combien d'arguments nommés.

Exemple:

def someMethod(self, arg1, kwarg1=None):
    pass

Cette méthode a 2 arguments et 1 argument nommé.

La réponse précédemment acceptée a été dépréciée au Python 3.0. Au lieu d'utiliser, inspect.getargspecvous devriez maintenant opter pour la Signatureclasse qui l'a remplacé.

Créer une signature pour la fonction est facile via la signaturefonction :

from inspect import signature

def someMethod(self, arg1, kwarg1=None):
    pass

sig = signature(someMethod)

Désormais, vous pouvez soit afficher rapidement ses paramètres en l' strutilisant:

str(sig)  # returns: '(self, arg1, kwarg1=None)'

ou vous pouvez également obtenir un mappage des noms d'attributs aux objets paramètres via sig.parameters.

params = sig.parameters 
print(params['kwarg1']) # prints: kwarg1=20

De plus, vous pouvez appeler lenle sig.parametersvoir aussi le nombre d'arguments de cette fonction nécessite:

print(len(params))  # 3

Chaque entrée du paramsmappage est en fait un Parameterobjet qui a d'autres attributs qui vous facilitent la vie. Par exemple, saisir un paramètre et afficher sa valeur par défaut est désormais facile avec:

kwarg1 = params['kwarg1']
kwarg1.default # returns: None

de même pour le reste des objets contenus dans parameters.

Quant aux 2.xutilisateurs de Python , bien que inspect.getargspec non obsolète, le langage le sera bientôt :-). La Signatureclasse n'est pas disponible dans la 2.xsérie et ne le sera pas. Vous devez donc toujours travailler avec inspect.getargspec.

En ce qui concerne la transition entre Python 2 et 3, si vous avez du code qui repose sur l'interface de getargspecPython 2 et que le passage à signaturedans 3est trop difficile, vous avez la possibilité d'utiliser inspect.getfullargspec. Il offre une interface similaire à getargspec(un seul argument appelable) afin de récupérer les arguments d'une fonction tout en gérant des cas supplémentaires qui getargspecne le font pas:

from inspect import getfullargspec

def someMethod(self, arg1, kwarg1=None):
    pass

args = getfullargspec(someMethod)

Comme avec getargspec, getfullargspecrenvoie a NamedTuplequi contient les arguments.

print(args)
FullArgSpec(args=['self', 'arg1', 'kwarg1'], varargs=None, varkw=None, defaults=(None,), kwonlyargs=[], kwonlydefaults=None, annotations={})

import inspect
inspect.getargspec(someMethod)

voir le module inspect

someMethod.func_code.co_argcount

ou, si le nom de la fonction actuelle est indéterminé:

import sys

sys._getframe().func_code.co_argcount

inspect.getargspec ()

Obtenez les noms et les valeurs par défaut des arguments d'une fonction. Un tuple de quatre choses est retourné: (args, varargs, varkw, defaults). args est une liste des noms d'arguments (il peut contenir des listes imbriquées). varargs et varkw sont les noms des arguments * et ** ou None. defaults est un tuple de valeurs d'argument par défaut ou None s'il n'y a pas d'arguments par défaut; si ce tuple a n éléments, ils correspondent aux n derniers éléments listés dans args.

Modifié dans la version 2.6: renvoie un tuple nommé ArgSpec (args, varargs, mots-clés, valeurs par défaut).

Voir pouvez-vous-lister-les-arguments-mot-clé-qu'une-fonction-python-reçoit .

Ajoutant à ce qui précède, j'ai également vu que la plupart du temps, la fonction help () aide vraiment

Par exemple, il donne tous les détails sur les arguments qu'il prend.

help(<method>)

donne le ci-dessous

method(self, **kwargs) method of apiclient.discovery.Resource instance
Retrieves a report which is a collection of properties / statistics for a specific customer.

Args:
  date: string, Represents the date in yyyy-mm-dd format for which the data is to be fetched. (required)
  pageToken: string, Token to specify next page.
  parameters: string, Represents the application name, parameter name pairs to fetch in csv as app_name1:param_name1, app_name2:param_name2.

Returns:
  An object of the form:

    { # JSON template for a collection of usage reports.
    "nextPageToken": "A String", # Token for retrieving the next page
    "kind": "admin#reports#usageReports", # Th

Bonne nouvelle pour les personnes qui souhaitent le faire de manière portable entre Python 2 et Python 3.6+: utilisez la inspect.getfullargspec()méthode. Cela fonctionne à la fois dans Python 2.x et 3.6+

Comme Jim Fasarakis Hilliard et d'autres l'ont souligné, c'était comme ceci:
1. En Python 2.x: utiliser inspect.getargspec()
2. En Python 3.x: utiliser la signature, comme getargspec()et getfullargspec()étaient obsolètes.

Cependant, à partir de Python 3.6 (à la demande générale?), Les choses ont changé pour mieux:

Depuis la page de documentation de Python 3 :

inspect.getfullargspec (func)

Modifié dans la version 3.6 : Cette méthode était précédemment documentée comme obsolète au profit de signature()Python 3.5, mais cette décision a été annulée afin de restaurer une interface standard clairement prise en charge pour le code Python 2/3 à source unique migrant hors de l'ancienne getargspec()API.

inspect.getargspec () pour répondre à vos besoins

from inspect import getargspec

def func(a, b):
    pass
print len(getargspec(func).args)

Comme d'autres réponses le suggèrent, getargspecfonctionne bien tant que l'objet interrogé est en fait une fonction. Il ne fonctionne pas pour intégré des fonctions telles que open, len, etc, et va lancer une exception dans ce cas:

TypeError: <built-in function open> is not a Python function

La fonction ci-dessous (inspirée par cette réponse ) montre une solution de contournement. Il renvoie le nombre d'arguments attendus par f:

from inspect import isfunction, getargspec
def num_args(f):
  if isfunction(f):
    return len(getargspec(f).args)
  else:
    spec = f.__doc__.split('\n')[0]
    args = spec[spec.find('(')+1:spec.find(')')]
    return args.count(',')+1 if args else 0

L'idée est d'analyser la spécification de fonction hors de la __doc__chaîne. Évidemment, cela dépend du format de ladite chaîne, donc ce n'est guère robuste!

func.__code__.co_argcountvous donne plusieurs des arguments AVANT *args

func.__kwdefaults__vous donne un dict des arguments de mot - clé APRÈS *args

func.__code__.co_kwonlyargcount est égal à len(func.__kwdefaults__)

func.__defaults__vous donne les valeurs des arguments facultatifs qui apparaissent avant *args

Voici l'illustration simple:

>>> def a(b, c, d, e, f=1, g=3, h=None, *i, j=2, k=3, **L):
    pass

>>> a.__code__.co_argcount
7
>>> a.__defaults__
(1, 3, None)
>>> len(a.__defaults__)
3
>>> 
>>> 
>>> a.__kwdefaults__
{'j': 2, 'k': 3}
>>> len(a.__kwdefaults__)
2
>>> a.__code__.co_kwonlyargcount
2

Dans:

import inspect 

class X:
    def xyz(self, a, b, c): 
        return 

print(len(inspect.getfullargspec(X.xyz).args))

En dehors:

4

Remarque: si xyz n'était pas dans la classe X et n'avait pas de "self" et juste "a, b, c", alors il aurait imprimé 3.

Pour python inférieur à 3.5, vous voudrez peut-être remplacer inspect.getfullargspecpar inspect.getargspecdans le code ci-dessus.