Как получить имена параметров метода?

Учитывая функцию Python:

def a_method(arg1, arg2):
    pass

Как я могу извлечь количество и имена аргументов. То есть, учитывая, что у меня есть ссылка наfunc , я хочу func.[something]вернуться ("arg1", "arg2").

Сценарий использования для этого заключается в том, что у меня есть декоратор, и я хочу использовать аргументы метода в том же порядке, в котором они отображаются для фактической функции в качестве ключа. Т.е. как будет выглядеть декоратор, который напечатан "a,b"при звонке a_method("a", "b")?

Посмотрите на inspectмодуль - он проведет проверку различных свойств объекта кода для вас.

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

Другими результатами являются имена переменных * args и ** kwargs и предоставленные значения по умолчанию. то есть.

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

Обратите внимание, что некоторые вызовы могут не быть интроспективными в некоторых реализациях Python. Например, в CPython некоторые встроенные функции, определенные в C, не предоставляют метаданных об их аргументах. В результате вы получите, ValueErrorесли используете inspect.getfullargspec()встроенную функцию.

Начиная с Python 3.3, вы можете использовать inspect.signature()для просмотра подписи вызова вызываемого объекта:

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

В CPython количество аргументов

a_method.func_code.co_argcount

и их имена в начале

a_method.func_code.co_varnames

Это детали реализации CPython, так что это, вероятно, не работает в других реализациях Python, таких как IronPython и Jython.

Один из переносимых способов допустить «сквозные» аргументы - определить вашу функцию с помощью сигнатуры func(*args, **kwargs). Это часто используется, например, в matplotlib , где внешний уровень API передает множество ключевых аргументов в API более низкого уровня.

В методе декоратора вы можете перечислить аргументы исходного метода следующим образом:

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)

Если **kwargsэто важно для вас, то это будет немного сложно:

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

Пример:

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

Я думаю, что вы ищете метод местных жителей -

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

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

Версия Python 3:

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

Метод возвращает словарь, содержащий как args, так и kwargs.

Вот то, что я думаю, будет работать для того, что вы хотите, используя декоратор.

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

Запустите его, он даст следующий вывод:

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 () устарела, вместо этого используйте inspect.signature ()

Итак, ранее:

func_args = inspect.getargspec(function).args

Сейчас:

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

Тестировать:

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

Учитывая, что у нас есть функция 'function', которая принимает аргумент 'arg', она будет оцениваться как True, иначе как False.

Пример из консоли 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

В Python 3. + с Signatureобъектом под рукой, простой способ получить соответствие между именами аргументов и значениями, это использовать метод Signature bind()!

Например, вот декоратор для печати такой карты:

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}

Вот еще один способ получить параметры функции без использования какого-либо модуля.

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

Вывод:

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

Возвращает список имен аргументов, заботится о частичках и обычных функциях:

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

Обновление для ответа Брайана :

Если функция в Python 3 имеет аргументы только для ключевых слов, вам необходимо использовать inspect.getfullargspec:

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

дает это:

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

В Python 3, ниже, чтобы сделать *argsи **kwargsв dict(использовать OrderedDictдля Python <3,6 для поддержания dictзаказов):

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.signatureочень медленно Самый быстрый способ

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

Чтобы обновить немного ответ Брайана , теперь есть хороший портировать из inspect.signatureкоторый вы можете использовать в более старых версиях Python: funcsigs. Так что мои личные предпочтения

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

def aMethod(arg1, arg2):
    pass

sig = signature(aMethod)
print(sig)

Для интереса, если вам интересно играть с Signatureобъектами и даже динамически создавать функции со случайными подписями, вы можете взглянуть на мой makefunпроект.

Как насчет dir()иvars() сейчас?

Кажется, делает именно то, что просят супер просто ...

Должен вызываться из области действия функции.

Но будьте осторожны, что он вернет все локальные переменные, поэтому при необходимости обязательно сделайте это в самом начале функции.

Также обратите внимание, что, как указано в комментариях, это не позволяет делать это вне области видимости. Так что не совсем сценарий ОП, но все равно соответствует заголовку вопроса. Отсюда и мой ответ.