¿Cómo obtener nombres de parámetros de método?

Dada la función Python:

def a_method(arg1, arg2):
    pass

¿Cómo puedo extraer el número y los nombres de los argumentos? Es decir, dado que tengo una referencia func, quiero func.[something]que regrese ("arg1", "arg2").

El escenario de uso para esto es que tengo un decorador, y deseo usar los argumentos del método en el mismo orden en que aparecen para la función real como una clave. Es decir, ¿cómo se vería el decorador que impreso "a,b"cuando llamo a_method("a", "b")?

Eche un vistazo al inspectmódulo: esto hará la inspección de las diferentes propiedades del objeto de código por usted.

>>> inspect.getfullargspec(a_method)
(['arg1', 'arg2'], None, None, None)

Los otros resultados son el nombre de las variables * args y ** kwargs, y los valores predeterminados proporcionados. es decir.

>>> def foo(a, b, c=4, *arglist, **keywords): pass
>>> inspect.getfullargspec(foo)
(['a', 'b', 'c'], 'arglist', 'keywords', (4,))

Tenga en cuenta que algunas llamadas no pueden ser introspectables en ciertas implementaciones de Python. Por ejemplo, en CPython, algunas funciones integradas definidas en C no proporcionan metadatos sobre sus argumentos. Como resultado, obtendrá un ValueErrorsi lo usa inspect.getfullargspec()en una función incorporada.

Desde Python 3.3, puede usar inspect.signature()para ver la firma de la llamada de un objeto invocable:

>>> inspect.signature(foo)
<Signature (a, b, c=4, *arglist, **keywords)>

En CPython, el número de argumentos es

a_method.func_code.co_argcount

y sus nombres están al comienzo de

a_method.func_code.co_varnames

Estos son detalles de implementación de CPython, por lo que probablemente esto no funcione en otras implementaciones de Python, como IronPython y Jython.

Una forma portátil de admitir argumentos de "transferencia" es definir su función con la firma func(*args, **kwargs). Esto se usa mucho, por ejemplo , en matplotlib , donde la capa API externa pasa muchos argumentos de palabras clave a la API de nivel inferior.

En un método de decorador, puede enumerar los argumentos del método original de esta manera:

import inspect, itertools 

def my_decorator():

        def decorator(f):

            def wrapper(*args, **kwargs):

                # if you want arguments names as a list:
                args_name = inspect.getargspec(f)[0]
                print(args_name)

                # if you want names and values as a dictionary:
                args_dict = dict(itertools.izip(args_name, args))
                print(args_dict)

                # if you want values as a list:
                args_values = args_dict.values()
                print(args_values)

Si **kwargsson importantes para usted, entonces será un poco complicado:

        def wrapper(*args, **kwargs):

            args_name = list(OrderedDict.fromkeys(inspect.getargspec(f)[0] + kwargs.keys()))
            args_dict = OrderedDict(list(itertools.izip(args_name, args)) + list(kwargs.iteritems()))
            args_values = args_dict.values()

Ejemplo:

@my_decorator()
def my_function(x, y, z=3):
    pass


my_function(1, y=2, z=3, w=0)
# prints:
# ['x', 'y', 'z', 'w']
# {'y': 2, 'x': 1, 'z': 3, 'w': 0}
# [1, 2, 3, 0]

Creo que lo que estás buscando es el método local:

In [6]: def test(a, b):print locals()
   ...: 

In [7]: test(1,2)              
{'a': 1, 'b': 2}

La versión de Python 3 es:

def _get_args_dict(fn, args, kwargs):
    args_names = fn.__code__.co_varnames[:fn.__code__.co_argcount]
    return {**dict(zip(args_names, args)), **kwargs}

El método devuelve un diccionario que contiene args y kwargs.

Aquí hay algo que creo que funcionará para lo que quieres, usando un decorador.

class LogWrappedFunction(object):
    def __init__(self, function):
        self.function = function

    def logAndCall(self, *arguments, **namedArguments):
        print "Calling %s with arguments %s and named arguments %s" %\
                      (self.function.func_name, arguments, namedArguments)
        self.function.__call__(*arguments, **namedArguments)

def logwrap(function):
    return LogWrappedFunction(function).logAndCall

@logwrap
def doSomething(spam, eggs, foo, bar):
    print "Doing something totally awesome with %s and %s." % (spam, eggs)


doSomething("beans","rice", foo="wiggity", bar="wack")

Ejecútelo, producirá el siguiente resultado:

C:\scripts>python decoratorExample.py
Calling doSomething with arguments ('beans', 'rice') and named arguments {'foo':
 'wiggity', 'bar': 'wack'}
Doing something totally awesome with beans and rice.

Python 3.5+:

DeprecationWarning: inspect.getargspec () está en desuso, use inspect.signature () en su lugar

Entonces anteriormente:

func_args = inspect.getargspec(function).args

Ahora:

func_args = list(inspect.signature(function).parameters.keys())

Probar:

'arg' in list(inspect.signature(function).parameters.keys())

Dado que tenemos la función 'función' que toma el argumento 'arg', esto se evaluará como Verdadero, de lo contrario, como Falso.

Ejemplo de la consola de Python:

Python 3.6.0 (v3.6.0:41df79263a11, Dec 23 2016, 07:18:10) [MSC v.1900 32 bit (Intel)] on win32
>>> import inspect
>>> 'iterable' in list(inspect.signature(sum).parameters.keys())
True

¡En Python 3. + con el Signatureobjeto en mano, una manera fácil de obtener una asignación entre los nombres de los argumentos y los valores es usar el bind()método de la Firma !

Por ejemplo, aquí hay un decorador para imprimir un mapa como ese:

import inspect

def decorator(f):
    def wrapper(*args, **kwargs):
        bound_args = inspect.signature(f).bind(*args, **kwargs)
        bound_args.apply_defaults()
        print(dict(bound_args.arguments))

        return f(*args, **kwargs)

    return wrapper

@decorator
def foo(x, y, param_with_default="bars", **kwargs):
    pass

foo(1, 2, extra="baz")
# This will print: {'kwargs': {'extra': 'baz'}, 'param_with_default': 'bars', 'y': 2, 'x': 1}

Aquí hay otra forma de obtener los parámetros de la función sin usar ningún módulo.

def get_parameters(func):
    keys = func.__code__.co_varnames[:func.__code__.co_argcount][::-1]
    sorter = {j: i for i, j in enumerate(keys[::-1])} 
    values = func.__defaults__[::-1]
    kwargs = {i: j for i, j in zip(keys, values)}
    sorted_args = tuple(
        sorted([i for i in keys if i not in kwargs], key=sorter.get)
    )
    sorted_kwargs = {}
    for i in sorted(kwargs.keys(), key=sorter.get):
        sorted_kwargs[i] = kwargs[i]      
    return sorted_args, sorted_kwargs


def f(a, b, c="hello", d="world"): var = a


print(get_parameters(f))

Salida:

(('a', 'b'), {'c': 'hello', 'd': 'world'})

Devuelve una lista de nombres de argumentos, se ocupa de parciales y funciones regulares:

def get_func_args(f):
    if hasattr(f, 'args'):
        return f.args
    else:
        return list(inspect.signature(f).parameters)

Actualización para la respuesta de Brian :

Si una función en Python 3 tiene argumentos de solo palabras clave, entonces debe usar inspect.getfullargspec:

def yay(a, b=10, *, c=20, d=30):
    pass
inspect.getfullargspec(yay)

produce esto:

FullArgSpec(args=['a', 'b'], varargs=None, varkw=None, defaults=(10,), kwonlyargs=['c', 'd'], kwonlydefaults={'c': 20, 'd': 30}, annotations={})

En python 3, a continuación es para hacer *argsy **kwargsen un dict(uso OrderedDictpara python <3.6 para mantener los dictpedidos):

from functools import wraps

def display_param(func):
    @wraps(func)
    def wrapper(*args, **kwargs):

        param = inspect.signature(func).parameters
        all_param = {
            k: args[n] if n < len(args) else v.default
            for n, (k, v) in enumerate(param.items()) if k != 'kwargs'
        }
        all_param .update(kwargs)
        print(all_param)

        return func(**all_param)
    return wrapper

inspect.signaturees muy lento. La forma más rápida es

def f(a, b=1, *args, c, d=1, **kwargs):
   pass

f_code = f.__code__
f_code.co_varnames[:f_code.co_argcount + f_code.co_kwonlyargcount]  # ('a', 'b', 'c', 'd')

Para actualizar un poco la respuesta de Brian , ahora hay un buen backport de inspect.signatureque se puede utilizar en las versiones anteriores de Python: funcsigs. Entonces mi preferencia personal iría por

try:  # python 3.3+
    from inspect import signature
except ImportError:
    from funcsigs import signature

def aMethod(arg1, arg2):
    pass

sig = signature(aMethod)
print(sig)

Por diversión, si estás interesado en jugar con Signatureobjetos e incluso crear funciones con firmas aleatorias dinámicamente, puedes echar un vistazo a mi makefunproyecto.

¿Qué pasa dir()y vars()ahora?

Parece hacer exactamente lo que se le pide súper simplemente ...

Debe llamarse desde el ámbito de la función.

Pero tenga cuidado de que devolverá todas las variables locales, así que asegúrese de hacerlo al comienzo de la función si es necesario.

También tenga en cuenta que, como se señaló en los comentarios, esto no permite que se haga desde fuera del alcance. Entonces, no es exactamente el escenario de OP, pero aún coincide con el título de la pregunta. De ahí mi respuesta.