Come posso trovare il numero di argomenti di una funzione Python? Devo sapere quanti argomenti normali ha e quanti argomenti nominati.

Esempio:

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

Questo metodo ha 2 argomenti e 1 argomento denominato.

La risposta precedentemente accettata è stata deprecata a partire da Python 3.0. Invece di usare inspect.getargspecora dovresti optare per la Signatureclasse che l'ha sostituita.

La creazione di una firma per la funzione è facile tramite la signaturefunzione :

from inspect import signature

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

sig = signature(someMethod)

Ora puoi visualizzare rapidamente i suoi parametri strinserendolo:

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

oppure puoi anche ottenere una mappatura dei nomi degli attributi agli oggetti parametro tramite sig.parameters.

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

Inoltre, è possibile chiamare lensu sig.parametersdi vedere anche il numero di argomenti di questa funzione richiede:

print(len(params))  # 3

Ogni voce nella paramsmappatura è in realtà un Parameteroggetto che ha ulteriori attributi che ti semplificano la vita. Ad esempio, afferrare un parametro e visualizzarne il valore predefinito ora è facilmente eseguibile con:

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

allo stesso modo per il resto degli oggetti contenuti in parameters.

Per quanto riguarda gli 2.xutenti di Python , sebbene inspect.getargspec non sia deprecato, la lingua sarà presto :-). La Signatureclasse non è disponibile nella 2.xserie e non lo sarà. Quindi devi ancora lavorare con inspect.getargspec.

Per quanto riguarda la transizione tra Python 2 e 3, se hai codice che si basa sull'interfaccia di getargspecin Python 2 e il passaggio a signaturein 3è troppo difficile, hai la preziosa opzione di usare inspect.getfullargspec. Offre un'interfaccia simile a getargspec(un singolo argomento richiamabile) al fine di afferrare gli argomenti di una funzione gestendo anche alcuni casi aggiuntivi che getargspecnon:

from inspect import getfullargspec

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

args = getfullargspec(someMethod)

Come con getargspec, getfullargspecrestituisce un NamedTupleche contiene gli argomenti.

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

import inspect
inspect.getargspec(someMethod)

vedere il modulo di ispezione

someMethod.func_code.co_argcount

oppure, se il nome della funzione corrente non è definito:

import sys

sys._getframe().func_code.co_argcount

inspect.getargspec ()

Ottieni i nomi e i valori predefiniti degli argomenti di una funzione. Viene restituita una tupla di quattro cose: (args, varargs, varkw, default). args è un elenco dei nomi degli argomenti (può contenere elenchi nidificati). varargs e varkw sono i nomi degli argomenti * e ** o Nessuno. defaults è una tupla di valori degli argomenti predefiniti o Nessuno se non ci sono argomenti predefiniti; se questa tupla ha n elementi, corrispondono agli ultimi n elementi elencati in args.

Modificato nella versione 2.6: restituisce una tupla ArgSpec denominata (args, varargs, parole chiave, valori predefiniti).

Vedi can-you-list-the-keyword-argomenti-a-python-function-riceve .

In aggiunta a quanto sopra, ho anche visto che la maggior parte delle volte la funzione help () aiuta davvero

Ad esempio, fornisce tutti i dettagli sugli argomenti che prende.

help(<method>)

dà il seguito

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

Buone notizie per le persone che vogliono farlo in modo portatile tra Python 2 e Python 3.6+: usare il inspect.getfullargspec()metodo. Funziona in Python 2.xe 3.6+

Come hanno sottolineato Jim Fasarakis Hilliard e altri, era in questo modo:
1. In Python 2.x: usa inspect.getargspec()
2. In Python 3.x: usa la firma, come getargspec()ed getfullargspec()era deprecato.

Tuttavia, a partire da Python 3.6 (a grande richiesta?), Le cose sono migliorate:

Dalla pagina della documentazione di Python 3 :

inspect.getfullargspec (func)

Modificato nella versione 3.6 : questo metodo era stato precedentemente documentato come deprecato a favore di signature()Python 3.5, ma tale decisione è stata annullata al fine di ripristinare un'interfaccia standard chiaramente supportata per il codice Python 2/3 single-source che migra getargspec()dall'API legacy .

inspect.getargspec () per soddisfare le tue esigenze

from inspect import getargspec

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

Come suggeriscono altre risposte, getargspecfunziona bene finché la cosa da interrogare è in realtà una funzione. Non funziona per built-in funzioni quali open, len, ecc, e sarà un'eccezione in questi casi:

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

La funzione di seguito (ispirata a questa risposta ) mostra una soluzione alternativa. Restituisce il numero di argomenti previsti da 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'idea è di analizzare la specifica della funzione dalla __doc__stringa. Ovviamente questo si basa sul formato di detta stringa, quindi non è certo robusto!

func.__code__.co_argcountti dà il numero di tutti gli argomenti PRIMA *args

func.__kwdefaults__ti dà una spiegazione degli argomenti parola chiave DOPO *args

func.__code__.co_kwonlyargcount è uguale a len(func.__kwdefaults__)

func.__defaults__ti dà i valori degli argomenti opzionali che appaiono prima *args

Ecco la semplice illustrazione:

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

Nel:

import inspect 

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

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

Su:

4

Nota: se xyz non fosse all'interno della classe X e non avesse "sé" e solo "a, b, c", avrebbe stampato 3.

Per python inferiore a 3.5, potresti voler sostituire inspect.getfullargspeccon inspect.getargspecil codice sopra.