À l'origine ~~ ou à l'origine ~~ * et Il est composé de **. Cependant, il semble qu'ils soient généralement écrits comme «* args» et «** kwargs» dans le voisinage. La principale différence est de savoir si la méthode de complémentarité des variables est «tuple» ou «dictionnaire».

À quoi cela sert-il

*args

def foo(*args):
    for a in args:
        print a

foo(1) #1
foo(1,2,3) #1\n2\n3\n

Si vous mettez * args comme argument temporaire, quand vous dites" combien d'arguments encore prendre "lors de la création de la fonction" ʻArgs` est responsable de prendre tous les arguments qui entrent comme un espace réservé de tuple.

def test_var_args_call(arg1, arg2, arg3):
    print ("arg1:", arg1)
    print ("arg2:", arg2)
    print ("arg3:", arg3)

args = ("two", 3)
test_var_args_call(1, *args)

#result
arg1: 1
arg2: two
arg3: 3

Une image de la préparation de la variable ʻargsd'abord, puis de la recouvrir de* args. Le premier paramètre: 1 est reçu comme ʻarg1 et les autres sont tous placés à l'intérieur de ʻarg2 et ʻarg3. Soit dit en passant, si vous spécifiez d'abord le nombre d'arguments puis que vous le saisissez dans la fonction, soyez prudent car vous ne pouvez recevoir que le nombre d'arguments que la fonction définie en premier peut recevoir. Si c'est def function (arg1, * args), seul le premier va à ʻarg1 et le reste est pris en charge par * args`.

def test_var_args(farg, *args):
    print "formal arg:", farg
    for arg in args:
        print "another arg:", arg

test_var_args(1, "two", 3)

#result
formal arg: 1
another arg: two
another arg: 3

Si vous voulez l'utiliser de cette façon, vous ne savez souvent pas combien d'arguments viendront, il est donc plus facile de dire "traiter x pour le nombre de minutes qui sortent" avec for loop. C'est un petit détail, mais si vous utilisez «return» au lieu de «print» ici, seul le premier sera affiché. Je pense que la raison est probablement que return a la caractéristique qu'une fois traitée, la boucle se termine. Comme contre-mesure qui vous vient à l'esprit, enregistrez-la dans une liste à l'intérieur de la boucle et exécutez __return statement en dehors de la boucle __.

def test_var_args(farg, *args):
    print("formal arg:", farg)
    for arg in args:
        print("another arg:", arg)

    return arg

#result
formal arg: 1
another arg: two
another arg: 3
3

J'ai essayé de le forcer comme ça, mais je n'ai pu obtenir que les trois derniers. La raison est que la boucle se termine avec la fin de «arg» collée à 3.

The for-loop runs each statement in it for however so many times.. if one of your statements is a return, then the function will return when it hits it. This makes sense in, for example, the following case:

def get_index(needle, haystack):
    for x in range(len(haystack)):
        if haystack[x] == needle:
            return x

Here, the function iterates until it finds where the needle is in the haystack, and then returns that index (there's a builtin function to do this, anyways). If you want the function to run for however many times you tell it to, you have to put the return AFTER the for-loop, not inside it, that way, the function will return after the control gets off the loop

def add(numbers):
    ret = 0
    for x in numbers:
        ret = ret + x
    return ret # needs to be outside the loop

**kwargs

En un mot, * gère les variables avec tuple, tandis que ** les enregistre en tant que dictionnaire. En d'autres termes, vous pouvez prendre deux arguments, «clé» et «valeur».

def bar(**kwargs):
    for a in kwargs:
        print(a, kwargs[a])

bar(name="your mom", age=12, hotness=1) #hotness 1\nage 12\nname your mom

En plus de «* args» et «** kwargs», il existe également un idiome appelé «* l». L'utilisation principale est d'ouvrir la liste reçue en tant que variable, d'extraire le contenu et de l'enregistrer dans tuple. Tout ce que vous avez à faire est d'ajouter une liste à la valeur de la variable l (ou de la définir et de l'envoyer plus tard, etc.) et de l'appeler simplement avec func (* l). Cependant, il est nécessaire de préparer le même nombre de "paramètres" pour la fonction appelante.

def foo(a, b):
    print(a, b)

l = [1, 2]
foo(*l) #1, 2

Postscript

A propos, les deux «* args» et «** kwargs» ne peuvent être reçus que comme cibles recevant des fonctions. Qu'est-ce que ça veut dire

def make_averaged(*args):
    return *args / len(str(*args))
# causes syntax error

Puisqu'il provoque une erreur de syntaxe, traitez la variable uniquement avec le nom après *. En mémoire parce que je l'oublie parfois.

python3x: Que signifient * args et ** kwargs comme paramètres?

À quoi cela sert-il

Postscript

Lien référencé