Pouvez-vous lister les arguments de mot-clé qu'une fonction reçoit?

J'ai un dict, dont j'ai besoin pour passer des clés / valeurs comme arguments de mot-clé. Par exemple ..

d_args = {'kw1': 'value1', 'kw2': 'value2'}
example(**d_args)

Cela fonctionne bien, mais s'il y a des valeurs dans le dict d_args qui ne sont pas acceptées par la examplefonction, il meurt évidemment. Disons, si la fonction d'exemple est définie commedef example(kw2):

C'est un problème car je ne contrôle ni la génération du d_args, ni la examplefonction .. Ils viennent tous les deux de modules externes, et examplen'acceptent que certains des mots-clés-arguments du dict ..

Idéalement, je ferais juste

parsed_kwargs = feedparser.parse(the_url)
valid_kwargs = get_valid_kwargs(parsed_kwargs, valid_for = PyRSS2Gen.RSS2)
PyRSS2Gen.RSS2(**valid_kwargs)

Je vais probablement filtrer simplement le dict, à partir d'une liste d'arguments-mots-clés valides, mais je me demandais: y a-t-il un moyen de lister par programme les arguments de mots-clés qu'une fonction spécifique prend?

Un peu plus agréable que d'inspecter directement l'objet de code et de travailler sur les variables est d'utiliser le module inspect.

>>> import inspect
>>> def func(a,b,c=42, *args, **kwargs): pass
>>> inspect.getargspec(func)
(['a', 'b', 'c'], 'args', 'kwargs', (42,))

Si vous voulez savoir s'il est appelable avec un ensemble particulier d'arguments, vous avez besoin des args sans une valeur par défaut déjà spécifiée. Ceux-ci peuvent être obtenus par:

def getRequiredArgs(func):
    args, varargs, varkw, defaults = inspect.getargspec(func)
    if defaults:
        args = args[:-len(defaults)]
    return args   # *args and **kwargs are not required, so ignore them.

Ensuite, une fonction pour dire ce que vous manquez dans votre dict particulier est:

def missingArgs(func, argdict):
    return set(getRequiredArgs(func)).difference(argdict)

De même, pour vérifier les arguments non valides, utilisez:

def invalidArgs(func, argdict):
    args, varargs, varkw, defaults = inspect.getargspec(func)
    if varkw: return set()  # All accepted
    return set(argdict) - set(args)

Et donc un test complet s'il est appelable est:

def isCallableWithArgs(func, argdict):
    return not missingArgs(func, argdict) and not invalidArgs(func, argdict)

(Ceci n'est bon que pour l'analyse des arguments de python. Tout runtime vérifie les valeurs non valides dans kwargs ne peut évidemment pas être détecté.)

Cela affichera les noms de tous les arguments passables, mots-clés et non-mots-clés:

def func(one, two="value"):
    y = one, two
    return y
print func.func_code.co_varnames[:func.func_code.co_argcount]

C'est parce que les premiers co_varnamessont toujours des paramètres (ensuite les variables locales, comme ydans l'exemple ci-dessus).

Alors maintenant, vous pouvez avoir une fonction:

def getValidArgs(func, argsDict):
    '''Return dictionary without invalid function arguments.'''
    validArgs = func.func_code.co_varnames[:func.func_code.co_argcount]
    return dict((key, value) for key, value in argsDict.iteritems() 
                if key in validArgs)

Que vous pourriez ensuite utiliser comme ceci:

>>> func(**getValidArgs(func, args))

EDIT : Un petit ajout: si vous n'avez vraiment besoin que des arguments de mots clés d'une fonction, vous pouvez utiliser l' func_defaultsattribut pour les extraire:

def getValidKwargs(func, argsDict):
    validArgs = func.func_code.co_varnames[:func.func_code.co_argcount]
    kwargsLen = len(func.func_defaults) # number of keyword arguments
    validKwargs = validArgs[-kwargsLen:] # because kwargs are last
    return dict((key, value) for key, value in argsDict.iteritems() 
                if key in validKwargs)

Vous pouvez maintenant appeler votre fonction avec des arguments connus, mais des kwargs extraits, par exemple:

func(param1, param2, **getValidKwargs(func, kwargsDict))

Cela suppose qu'il funcn'utilise aucun *argsou de la **kwargsmagie dans sa signature.

Dans Python 3.0:

>>> import inspect
>>> import fileinput
>>> print(inspect.getfullargspec(fileinput.input))
FullArgSpec(args=['files', 'inplace', 'backup', 'bufsize', 'mode', 'openhook'],
varargs=None, varkw=None, defaults=(None, 0, '', 0, 'r', None), kwonlyargs=[], 
kwdefaults=None, annotations={})

Pour une solution Python 3, vous pouvez utiliser inspect.signatureet filtrer en fonction du type de paramètres que vous souhaitez connaître.

Prenant un exemple de fonction avec des paramètres de position ou de mot-clé, de mot-clé uniquement, var positional et var mot-clé:

def spam(a, b=1, *args, c=2, **kwargs):
    print(a, b, args, c, kwargs)

Vous pouvez lui créer un objet de signature:

from inspect import signature
sig =  signature(spam)

puis filtrez avec une liste de compréhension pour trouver les détails dont vous avez besoin:

>>> # positional or keyword
>>> [p.name for p in sig.parameters.values() if p.kind == p.POSITIONAL_OR_KEYWORD]
['a', 'b']
>>> # keyword only
>>> [p.name for p in sig.parameters.values() if p.kind == p.KEYWORD_ONLY]
['c']

et, de même, pour var positionals en utilisant p.VAR_POSITIONALet var mot-clé avec VAR_KEYWORD.

De plus, vous pouvez ajouter une clause au if pour vérifier si une valeur par défaut existe en vérifiant si p.defaultégal à p.empty.

Extension de la réponse de DzinX:

argnames = example.func_code.co_varnames[:func.func_code.co_argcount]
args = dict((key, val) for key,val in d_args.iteritems() if key in argnames)
example(**args)