Ursprünglich ~~ oder ursprünglich ~~ * und Es besteht aus **. Es scheint jedoch, dass sie normalerweise in der Nachbarschaft als "* args" und "** kwargs" geschrieben werden. Der Hauptunterschied besteht darin, ob die Methode zum Ergänzen von Variablen "Tupel" oder "Wörterbuch" ist.
*args
def foo(*args):
for a in args:
print a
foo(1) #1
foo(1,2,3) #1\n2\n3\n
Wenn Sie "* args" als temporäres Argument eingeben, wenn Sie sagen "wie viele Argumente müssen noch verwendet werden" während der Funktionserstellung "
args ist dafür verantwortlich, alle Argumente zu übernehmen, die als Tupel-Platzhalter eingehen.
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
Ein Bild, in dem zuerst die Variable "args" vorbereitet und dann mit "* args" abgedeckt wird. Der erste "Parameter": 1 wird als "arg1" empfangen und der Rest wird alle in "arg2" und "arg3" platziert. Übrigens, wenn Sie zuerst die Anzahl der Argumente angeben und diese dann mit einer Funktion eingeben, beachten Sie, dass Sie nur so viele Argumente empfangen können, wie die zuerst definierte Funktion empfangen kann. Wenn es sich um "def function (arg1, * args)" handelt, geht nur die erste zu "arg1" und der Rest wird von "* args" übernommen.
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
Wenn Sie es auf diese Weise verwenden möchten, wissen Sie oft nicht, wie viele Argumente kommen werden. Daher ist es einfacher, "for loop" usw. zu verwenden, um "process x für die Anzahl der angezeigten Minuten" zu sagen. Es ist ein kleines Detail, aber wenn Sie hier "return" anstelle von "print" verwenden, wird nur das erste angezeigt. Ich denke, der Grund ist wahrscheinlich, dass return die Eigenschaft hat, dass die Schleife endet, sobald sie verarbeitet ist. Als Gegenmaßnahme, die Ihnen in den Sinn kommt, speichern Sie sie in einer Liste innerhalb der Schleife und führen Sie die __return-Anweisung außerhalb der __- Schleife aus.
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
Ich habe versucht, es so zu erzwingen, aber ich konnte nur die letzten drei bekommen. Der Grund ist, dass die Schleife mit dem Ende von arg endet, das auf 3 bleibt.
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
Kurz gesagt, * verwaltet Variablen mit Tupel, während ** sie als Wörterbuch speichert. Mit anderen Worten, Sie können zwei Argumente verwenden: "Schlüssel" und "Wert".
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
*l
Zusätzlich zu "* args" und "** kwargs" gibt es auch eine Redewendung namens "* l". Die Hauptverwendung besteht darin, die als Variable empfangene Liste zu öffnen, den Inhalt zu extrahieren und in "Tupel" zu speichern. Alles, was Sie tun müssen, ist, dem Wert der Variablen "l" eine Liste hinzuzufügen (oder sie zu definieren und später zu senden usw.) und sie einfach mit "func (* l)" aufzurufen. Es ist jedoch notwendig, die gleiche Anzahl von "Parametern" für die aufrufende Funktion vorzubereiten.
def foo(a, b):
print(a, b)
l = [1, 2]
foo(*l) #1, 2
Übrigens können sowohl "* args" als auch "** kwargs" nur als Ziele empfangen werden, die Funktionen empfangen. Was bedeutet das
def make_averaged(*args):
return *args / len(str(*args))
# causes syntax error
Da dies [Syntaxfehler] verursacht (http://qiita.com/weedslayer/items/b15cd3d244352844ba94), behandeln Sie die Variable nur mit dem Namen nach *. Als Memorandum, weil ich es manchmal vergesse.