Get Inside kwargs Fonction

Question

Si j'ai une fonction python comme ceci:

def some_func(arg1, arg2, arg3=1, arg4=2): 

est-il un moyen de déterminer quels arguments ont été adoptés par mot-clé à l'intérieur de la fonction?

EDIT

Pour ceux qui demandent pourquoi j'ai besoin, je n'ai aucune raison réelle, il est venu dans une conversation et la curiosité a obtenu le meilleur de moi.

Answer 1

Non, il n'y a pas moyen de le faire dans le code Python avec cette signature - si vous avez besoin de ces informations, vous devez changer la signature de la fonction. Si vous regardez l'API C de Python, vous verrez que la manière dont les arguments sont passés à une fonction Python normale est toujours un tuple plus un dict, c'est-à-dire la manière directe d'une signature de *args, **kwargs. Ce tuple et dict sont ensuite analysés dans des arguments positionnels spécifiques et ceux qui sont nommés dans la signature même s'ils ont été passés par nom, et les *a et **kw, si présents, ne prennent le "débordement" de cette analyse, le cas échéant - C'est seulement à ce moment-là que votre code Python prend le contrôle, et d'ici là, l'information que vous demandez (comment les ont été passés) n'est plus disponible. Pour obtenir l'information que vous avez demandée, changez donc la signature en *a, **kw et faites votre propre analyse/validation - cela va "de l'oeuf à l'omelette", c'est-à-dire un certain travail mais certainement faisable, ce que vous cherchez serait "de l'omelette à l'œuf" ... tout simplement impossible ;-).

Answer 2

voulez-vous savoir si arg3 était 1 parce qu'il a été transmis de l'extérieur ou parce qu'il s'agissait d'une valeur par défaut? Non, il n'y a aucun moyen de le faire pour autant que je sache. La raison principale, je soupçonne, qu'il n'y a pas besoin d'une telle connaissance. Ce qui est généralement fait est le suivant:

>>> def func(a, b=None): 
    if b is None: 
# here we know that function was called as: 
# func('spam') or func('spam', None) or func('spam', b=None) or func(a='spam', b=None) 

     b = 42 

Answer 3

suffit de le faire comme ceci:

def some_func (arg1, arg2, arg3=None, arg4=None): 
    if arg3 is None: 
     arg3 = 1 # default value 
    if arg4 is None: 
     arg4 = 2 # default value 

    # do something 

De cette façon, vous pouvez voir quand quelque chose a été mis, et vous êtes également capable de travailler avec des structures par défaut plus complexes (comme les listes) sans se heurter à des problèmes tels que ceux-ci:

>>> def test(arg=[]): 
     arg.append(1) 
     print(arg) 
>>> test() 
[1] 
>>> test() 
[1, 1] 

Answer 4

Vous êtes à peu près devoir redéfinir votre fonction:

def some_func(*args, **kwargs): 

et faites le marshaling vous-même. Il n'y a aucun moyen de faire la différence entre la position par défaut, le mot de passe par passe et la valeur par défaut.

Answer 5

Voici ma solution par les décorateurs:

def showargs(function): 
    def inner(*args, **kwargs): 
     return function((args, kwargs), *args, **kwargs) 
    return inner 

@showargs 
def some_func(info, arg1, arg2, arg3=1, arg4=2): 
    print arg1,arg2,arg3,arg4 
    return info 

In [226]: some_func(1,2,3, arg4=4) 
1 2 3 4 
Out[226]: ((1, 2, 3), {'arg4': 4}) 

Il peut y avoir un moyen de nettoyer cette place plus loin, mais cela me semble peu intrusive et ne nécessite aucune modification du code d'appel.

Edit: Pour tester réellement si args particulières ont été adoptées par mot-clé, puis faire quelque chose comme ce qui suit à l'intérieur de some_func:

args, kwargs = info 
if 'arg4' in kwargs: 
    print "arg4 passed as keyword argument" 

Avertissement: vous devriez probablement envisager si vous vraiment ou non comment les arguments ont été passés. Toute cette approche peut être inutile.