Як отримати назви параметрів методу?

З огляду на функцію 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об'єктом під рукою, простий спосіб отримати відображення між іменами аргументів на значення, використовуючи bind()метод Signature !

Наприклад, ось декоратор для друку такої карти:

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()тепер?

Здається, робити саме те, що просять супер просто ...

Потрібно викликати всередині функції.

Але будьте обережні, що вона поверне всі локальні змінні, тому обов'язково виконайте це на самому початку функції, якщо це необхідно.

Також зауважте, що, як зазначено в коментарях, це не дозволяє зробити це поза межами сфери застосування. Тож не зовсім сценарій роботи ОП, але все ще відповідає назві питання. Звідси моя відповідь.