Como posso encontrar o número de argumentos de uma função Python? Preciso saber quantos argumentos normais ele possui e quantos argumentos nomeados.

Exemplo:

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

Este método possui 2 argumentos e 1 argumento nomeado.

A resposta aceita anteriormente foi descontinuada a partir de Python 3.0. Em vez de usar, inspect.getargspecvocê deve agora optar pela Signatureclasse que a substituiu.

Criar uma assinatura para a função é fácil através da signaturefunção :

from inspect import signature

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

sig = signature(someMethod)

Agora, você pode visualizar seus parâmetros rapidamente, usando str-o:

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

ou você também pode obter um mapeamento de nomes de atributos para objetos de parâmetro via sig.parameters.

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

Além disso, você pode chamar lende sig.parametersver também o número de argumentos Esta função exige:

print(len(params))  # 3

Cada entrada no paramsmapeamento é na verdade um Parameterobjeto que possui outros atributos, facilitando sua vida. Por exemplo, pegar um parâmetro e visualizar seu valor padrão agora é facilmente realizado com:

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

da mesma forma para o restante dos objetos contidos em parameters.

Quanto aos 2.xusuários de Python , embora inspect.getargspec não seja preterido, a linguagem em breve será :-). A Signatureturma não está disponível na 2.xsérie e não estará. Então você ainda precisa trabalhar inspect.getargspec.

Quanto à transição entre Python 2 e 3, se você tiver o código que se baseia na interface getargspecem Python 2 e mudar para signaturenos 3é muito difícil, você tem a opção valiosa de utilizar inspect.getfullargspec. Ele oferece uma interface semelhante a getargspec(um único argumento que pode ser chamado) para capturar os argumentos de uma função enquanto também lida com alguns casos adicionais que getargspecnão:

from inspect import getfullargspec

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

args = getfullargspec(someMethod)

Assim como getargspec, getfullargspecretorna a NamedTupleque contém os argumentos.

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

import inspect
inspect.getargspec(someMethod)

veja o módulo de inspeção

someMethod.func_code.co_argcount

ou, se o nome da função atual for indeterminado:

import sys

sys._getframe().func_code.co_argcount

inspect.getargspec ()

Obtenha os nomes e os valores padrão dos argumentos de uma função. Uma tupla de quatro coisas é retornada: (args, varargs, varkw, padrões). args é uma lista dos nomes dos argumentos (pode conter listas aninhadas). varargs e varkw são os nomes dos argumentos * e ** ou Nenhum. defaults é uma tupla de valores de argumento padrão ou None se não houver argumentos padrão; se essa tupla tiver n elementos, eles corresponderão aos últimos n elementos listados em args.

Alterado na versão 2.6: Retorna uma tupla nomeada ArgSpec (args, varargs, palavras-chave, padrões).

Veja você pode listar a palavra-chave-argumentos-a-função-python-recebe .

Além disso, também vi que na maioria das vezes a função help () realmente ajuda

Por exemplo, fornece todos os detalhes sobre os argumentos necessários.

help(<method>)

dá o abaixo

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

Boas notícias para quem deseja fazer isso de maneira portátil entre o Python 2 e o Python 3.6+: use inspect.getfullargspec()method. Funciona no Python 2.xe 3.6+

Como Jim Fasarakis Hilliard e outros apontaram, costumava ser assim:
1. No Python 2.x: use inspect.getargspec()
2. No Python 3.x: use assinatura, como getargspec()e getfullargspec()foi preterido.

No entanto, iniciando o Python 3.6 (por demanda popular?), As coisas mudaram para melhor:

Na página de documentação do Python 3 :

inspect.getfullargspec (func)

Alterado na versão 3.6 : esse método foi documentado anteriormente como obsoleto no signature()Python 3.5, mas essa decisão foi revertida para restaurar uma interface padrão claramente suportada para código Python 2/3 de fonte única que migra para longe da getargspec()API herdada .

inspect.getargspec () para atender às suas necessidades

from inspect import getargspec

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

Como sugerem outras respostas, getargspecfunciona bem desde que a coisa que está sendo consultada seja realmente uma função. Ele não funciona para built-in funções, tais como open, len, etc, e irá lançar uma exceção em tais casos:

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

A função abaixo (inspirada nesta resposta ) demonstra uma solução alternativa. Retorna o número de argumentos esperado por 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

A idéia é analisar a especificação da função fora da __doc__string. Obviamente, isso depende do formato da referida string, portanto, dificilmente é robusta!

func.__code__.co_argcountdá-lhe número de quaisquer argumentos ANTES *args

func.__kwdefaults__fornece um ditado dos argumentos da palavra - chave APÓS *args

func.__code__.co_kwonlyargcount é igual a len(func.__kwdefaults__)

func.__defaults__fornece os valores dos argumentos opcionais que aparecem antes *args

Aqui está a ilustração simples:

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

No:

import inspect 

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

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

Fora:

4

Nota: Se xyz não pertencesse à classe X e não tivesse "eu" e apenas "a, b, c", seria impresso 3.

Para python abaixo de 3,5, convém substituir inspect.getfullargspecpor inspect.getargspecno código acima.