In den folgenden Verfahren Definitionen, was bedeutet das *
und **
tut für param2
?
def foo(param1, *param2):
def bar(param1, **param2):
In den folgenden Verfahren Definitionen, was bedeutet das *
und **
tut für param2
?
def foo(param1, *param2):
def bar(param1, **param2):
def func(*args)
) gefragt wird . Für eine Frage zu fragen , was es bedeutet , in Funktion Anrufen (func(*[1,2])
) siehe hier . Für eine Frage zu stellen , wie Argumentlisten sehen auspacken hier . Für eine Frage, was die Bedeutung*
in Literalen ([*[1, 2]]
) bedeutet, siehe hier .Antworten:
Das
*args
und**kwargs
ist eine gebräuchliche Redewendung, um eine beliebige Anzahl von Argumenten für Funktionen zuzulassen, wie im Abschnitt über das Definieren von Funktionen in der Python-Dokumentation beschrieben.Das
*args
gibt Ihnen alle Funktionsparameter als Tupel :Das
**kwargs
gibt Ihnen alle Schlüsselwortargumente mit Ausnahme derjenigen, die einem formalen Parameter als Wörterbuch entsprechen.Beide Redewendungen können mit normalen Argumenten gemischt werden, um eine Reihe fester und einiger variabler Argumente zu ermöglichen:
Es ist auch möglich, dies umgekehrt zu verwenden:
Eine andere Verwendung des
*l
Idioms besteht darin, beim Aufrufen einer Funktion Argumentlisten zu entpacken .In Python 3 ist es möglich,
*l
auf der linken Seite einer Zuweisung ( Extended Iterable Unpacking ) zu verwenden, obwohl in diesem Kontext eine Liste anstelle eines Tupels angezeigt wird :Auch Python 3 fügt eine neue Semantik hinzu (siehe PEP 3102 ):
Eine solche Funktion akzeptiert nur 3 Positionsargumente, und alles danach
*
kann nur als Schlüsselwortargumente übergeben werden.quelle
**kwargs
entspricht jetzt der Reihenfolge, in der Schlüsselwortargumente an die Funktion übergeben wurden." - docs.python.org/3/whatsnew/3.6.html Tatsächlich werden alle Dikte in CPython 3.6 die Einfügereihenfolge als Implementierungsdetail speichern. Dies wird in Python 3.7 zum Standard.got an unexpected keyword argument 'name'
Es ist auch erwähnenswert, dass Sie
*
und**
beim Aufrufen von Funktionen auch verwenden können. Dies ist eine Verknüpfung, mit der Sie mehrere Argumente direkt über eine Liste / ein Tupel oder ein Wörterbuch an eine Funktion übergeben können. Zum Beispiel, wenn Sie die folgende Funktion haben:Sie können Dinge tun wie:
Hinweis: Die Tasten
mydict
müssen genau wie die Funktionsparameter benannt werdenfoo
. Andernfalls wird einTypeError
:quelle
Das einzelne * bedeutet, dass es beliebig viele zusätzliche Positionsargumente geben kann.
foo()
kann wie aufgerufen werdenfoo(1,2,3,4,5)
. Im Körper von foo () ist param2 eine Sequenz, die 2-5 enthält.Das doppelte ** bedeutet, dass es eine beliebige Anzahl von zusätzlichen benannten Parametern geben kann.
bar()
kann wie aufgerufen werdenbar(1, a=2, b=3)
. Im Hauptteil von bar () param2 befindet sich ein Wörterbuch mit {'a': 2, 'b': 3}Mit folgendem Code:
die Ausgabe ist
quelle
foobar(param1, *param2, **param3)
benötigt, um diese Antwort zu vervollständigen.Sie ermöglichen die Definition von Funktionen zur Annahme und die Übergabe einer beliebigen Anzahl von Argumenten, positional (
*
) und keyword (**
).Funktionen definieren
*args
ermöglicht eine beliebige Anzahl optionaler Positionsargumente (Parameter), die einem Tupel mit dem Namen zugewiesen werdenargs
.**kwargs
ermöglicht eine beliebige Anzahl von optionalen Schlüsselwortargumenten (Parametern), die in einem Diktat mit dem Namen enthalten sindkwargs
.Sie können (und sollten) einen geeigneten Namen auswählen, aber wenn die Argumente eine unspezifische Semantik haben sollen
args
undkwargs
Standardnamen sind.Erweiterung, Übergabe einer beliebigen Anzahl von Argumenten
Sie können auch verwendet werden
*args
und**kwargs
jeweils in den Parametern aus den Listen (oder jede iterable) und dicts (oder jedes mapping), zu übergeben.Die Funktion, die die Parameter empfängt, muss nicht wissen, dass sie erweitert werden.
Zum Beispiel erwartet der xrange von Python 2 nicht explizit
*args
, aber da 3 Ganzzahlen als Argumente verwendet werden:Als weiteres Beispiel können wir die Dikt-Erweiterung verwenden in
str.format
:Neu in Python 3: Funktionen mit Argumenten definieren, die nur Schlüsselwörter enthalten
Sie können nur Schlüsselwortargumente verwenden, nachdem
*args
- beispielsweise hierkwarg2
als Schlüsselwortargument angegeben werden muss - nicht positionell:Verwendungszweck:
Auch
*
selbst kann verwendet werden , um anzuzeigen , dass nur ein Schlüsselwort Argument folgen, ohne dass für unbegrenzte Positionsargumente.Auch hier
kwarg2
muss es sich um ein explizit benanntes Schlüsselwortargument handeln:Und wir können keine unbegrenzten Positionsargumente mehr akzeptieren, weil wir nicht haben
*args*
:Auch hier müssen wir einfacher gesagt
kwarg
namentlich und nicht positionell angegeben werden:In diesem Beispiel sehen wir, dass beim Versuch, die
kwarg
Position zu bestehen, eine Fehlermeldung angezeigt wird:Wir müssen den
kwarg
Parameter explizit als Schlüsselwortargument übergeben.Python 2-kompatible Demos
*args
(normalerweise "star-args" genannt) und**kwargs
(Sterne können durch das Aussprechen von "kwargs" impliziert werden, aber mit "double star kwargs" explizit angegeben werden) sind gängige Redewendungen von Python für die Verwendung der*
und**
-Notation. Diese spezifischen Variablennamen sind nicht erforderlich (z. B. könnten Sie*foos
und verwenden**bars
), aber eine Abweichung von der Konvention kann Ihre Python-Codierkollegen wahrscheinlich verärgern.Wir verwenden diese normalerweise, wenn wir nicht wissen, was unsere Funktion erhalten wird oder wie viele Argumente wir möglicherweise übergeben, und manchmal sogar, wenn jede Variable separat benannt wird, dies sehr chaotisch und redundant wird (dies ist jedoch ein Fall, in dem dies normalerweise explizit ist besser als implizit).
Beispiel 1
Die folgende Funktion beschreibt, wie sie verwendet werden können, und demonstriert das Verhalten. Beachten Sie, dass das genannte
b
Argument vom zweiten Positionsargument vor verwendet wird:Wir können in der Online-Hilfe nach der Signatur der Funktion suchen, mit
help(foo)
der es uns sagtNennen wir diese Funktion mit
foo(1, 2, 3, 4, e=5, f=6, g=7)
welche druckt:
Beispiel 2
Wir können es auch mit einer anderen Funktion aufrufen, die wir nur bereitstellen
a
:bar(100)
Drucke:Beispiel 3: Praktische Anwendung bei Dekorateuren
OK, vielleicht sehen wir das Dienstprogramm noch nicht. Stellen Sie sich vor, Sie haben mehrere Funktionen mit redundantem Code vor und / oder nach dem Differenzierungscode. Die folgenden benannten Funktionen sind nur zur Veranschaulichung Pseudocode.
Wir könnten in der Lage sein, dies anders zu handhaben, aber wir können die Redundanz mit einem Dekorateur auf jeden Fall extrahieren, und so zeigt unser unten stehendes Beispiel, wie
*args
und**kwargs
sehr nützlich sein kann:Und jetzt kann jede umschlossene Funktion viel prägnanter geschrieben werden, da wir die Redundanz herausgerechnet haben:
Und durch unseren Code Ausklammern, die
*args
und**kwargs
uns erlaubt , zu tun, reduzieren wir Codezeilen, die Verbesserung der Lesbarkeit und Wartbarkeit und die alleinige kanonische Standorte für die Logik in unserem Programm. Wenn wir einen Teil dieser Struktur ändern müssen, haben wir einen Ort, an dem wir jede Änderung vornehmen können.quelle
Lassen Sie uns zunächst verstehen, was Positionsargumente und Schlüsselwortargumente sind. Unten finden Sie ein Beispiel für die Funktionsdefinition mit Positionsargumenten.
Dies ist also eine Funktionsdefinition mit Positionsargumenten. Sie können es auch mit Schlüsselwort / benannten Argumenten aufrufen:
Lassen Sie uns nun ein Beispiel für die Funktionsdefinition mit Schlüsselwortargumenten untersuchen :
Sie können diese Funktion auch mit Positionsargumenten aufrufen:
So kennen wir jetzt Funktionsdefinitionen mit Positions- und Schlüsselwortargumenten.
Lassen Sie uns nun den Operator '*' und den Operator '**' untersuchen.
Bitte beachten Sie, dass diese Operatoren in 2 Bereichen verwendet werden können:
a) Funktionsaufruf
b) Funktionsdefinition
Die Verwendung von '*' Operator und '**' Operator im Funktionsaufruf.
Kommen wir gleich zu einem Beispiel und diskutieren es dann.
Also denk daran
wenn der Operator '*' oder '**' in einem Funktionsaufruf verwendet wird -
Der Operator '*' entpackt Datenstrukturen wie eine Liste oder ein Tupel in Argumente, die für die Funktionsdefinition benötigt werden.
Der Operator '**' entpackt ein Wörterbuch in Argumente, die für die Funktionsdefinition benötigt werden.
Lassen Sie uns nun die Verwendung des Operators '*' in der Funktionsdefinition untersuchen . Beispiel:
In Funktion Definition des ‚*‘ Operator - Pack , die empfangenen Argumente in ein Tupel.
Lassen Sie uns nun ein Beispiel für '**' sehen, das in der Funktionsdefinition verwendet wird:
In Funktion Definition des ‚**‘ Operator - Pack , die empfangenen Argumente in ein Wörterbuch.
Also denk daran:
In einem Funktionsaufruf entpackt das '*' die Datenstruktur von Tupel oder Liste in Positions- oder Schlüsselwortargumente, die von der Funktionsdefinition empfangen werden sollen.
In einem Funktionsaufruf entpackt das '**' die Datenstruktur des Wörterbuchs in Positions- oder Schlüsselwortargumente, die von der Funktionsdefinition empfangen werden sollen.
In einer Funktionsdefinition packt das '*' Positionsargumente in ein Tupel.
In einer Funktionsdefinition packt das '**' Schlüsselwortargumente in ein Wörterbuch.
quelle
Diese Tabelle ist praktisch für die Verwendung
*
und**
Funktion Aufbau und Funktion Aufruf :Dies dient wirklich nur dazu, Lorin Hochsteins Antwort zusammenzufassen, aber ich finde es hilfreich.
Im Zusammenhang damit: Verwendungen für die Stern- / Splat Operatoren wurden erweitert in Python 3
quelle
*
und**
haben eine besondere Verwendung in der Liste der Funktionsargumente.*
impliziert, dass das Argument eine Liste ist und**
dass das Argument ein Wörterbuch ist. Dadurch können Funktionen eine beliebige Anzahl von Argumenten annehmenquelle
Für diejenigen unter Ihnen, die anhand von Beispielen lernen!
*
besteht darin, Ihnen die Möglichkeit zu geben, eine Funktion zu definieren, die eine beliebige Anzahl von Argumenten als Liste verwenden kann (zf(*myList)
. B. ).**
besteht darin, Ihnen die Möglichkeit zu geben, die Argumente einer Funktion durch Bereitstellung eines Wörterbuchs (zf(**{'x' : 1, 'y' : 2})
. B. ) einzugeben .Lassen Sie uns dies zeigen , indem sie eine Funktion definieren , die zwei normalen Variablen nimmt
x
,y
und kann mehr Argumente als annehmenmyArgs
und akzeptieren kann noch mehr Argumente alsmyKW
. Später werden wir zeigen , wie zu fütterny
mitmyArgDict
.Vorsichtsmaßnahmen
**
ist ausschließlich Wörterbüchern vorbehalten.**
muss*
immer danach kommen.quelle
Aus der Python-Dokumentation:
quelle
*
bedeutet, variable Argumente als Tupel zu erhalten**
bedeutet, variable Argumente als Wörterbuch zu erhaltenWird wie folgt verwendet:
1) Single *
Ausgabe:
2) Jetzt
**
Ausgabe:
quelle
Ich möchte ein Beispiel geben, das andere nicht erwähnt haben
* kann auch einen Generator auspacken
Ein Beispiel aus Python3 Document
unzip_x ist [1, 2, 3], unzip_y ist [4, 5, 6]
Das zip () empfängt mehrere iretable args und gibt einen Generator zurück.
quelle
In Python 3.5, können Sie auch diese Syntax in verwenden
list
,dict
,tuple
, undset
Anzeigen (manchmal auch als Literale). Siehe PEP 488: Zusätzliche Entpackungsverallgemeinerungen .Außerdem können mehrere Iterables in einem einzigen Funktionsaufruf entpackt werden.
(Danke an mgilson für den PEP-Link.)
quelle
Zusätzlich zu Funktionsaufrufen sind * args und ** kwargs in Klassenhierarchien nützlich und vermeiden, dass
__init__
Methoden in Python geschrieben werden müssen. Eine ähnliche Verwendung findet sich in Frameworks wie Django-Code.Zum Beispiel,
Eine Unterklasse kann dann sein
Die Unterklasse wird dann instanziiert als
Außerdem kann eine Unterklasse mit einem neuen Attribut, das nur für diese Unterklasseninstanz sinnvoll ist, die Basisklasse aufrufen
__init__
, um die Attributeinstellung auszulagern. Dies geschieht durch * args und ** kwargs. kwargs werden hauptsächlich verwendet, damit Code mit benannten Argumenten gelesen werden kann. Zum Beispiel,was als ausgelöst werden kann
Der vollständige Code ist hier
quelle
Aufbauend auf Nickds Antwort ...
Ausgabe:
Grundsätzlich kann eine beliebige Anzahl von Positionsargumenten * args verwenden, und alle benannten Argumente (oder kwargs, auch als Schlüsselwortargumente bezeichnet) können ** kwargs verwenden.
quelle
*args
und**kwargs
: Sie können eine variable Anzahl von Argumenten an eine Funktion übergeben.*args
: wird verwendet, um eine nicht mit Schlüsselwörtern versehene Argumentliste mit variabler Länge an die Funktion zu senden:Wird herstellen:
**kwargs*
**kwargs
Mit dieser Option können Sie einer Funktion eine variable Länge von Argumenten mit Schlüsselwörtern übergeben. Sie sollten verwenden,**kwargs
wenn Sie benannte Argumente in einer Funktion verarbeiten möchten.Wird herstellen:
quelle
Dieses Beispiel würde helfen Sie sich daran erinnern
*args
,**kwargs
und auchsuper
und Vererbung in Python auf einmal.quelle
Ein gutes Beispiel für die Verwendung von beiden in einer Funktion ist:
quelle
TL; DR
Im Folgenden finden Sie 6 verschiedene Anwendungsfälle für
*
und**
in der Python-Programmierung:*args
: zu akzeptierendef foo(*args): pass
, werden hierfoo
beliebig viele Positionsargumente akzeptiert, dh die folgenden Aufrufe sind gültigfoo(1)
:foo(1, 'bar')
**kwargs
:def foo(**kwargs): pass
, hier ‚foo‘ eine beliebige Anzahl von Keyword - Argumente akzeptiert, dh die folgenden Anrufe gültigfoo(name='Tom')
,foo(name='Tom', age=33)
*args, **kwargs
: zu akzeptierendef foo(*args, **kwargs): pass
, werden hierfoo
beliebig viele Positions- und Schlüsselwortargumente akzeptiert, dh die folgenden Aufrufe sind gültigfoo(1,name='Tom')
:foo(1, 'bar', name='Tom', age=33)
*
: zu erzwingendef foo(pos1, pos2, *, kwarg1): pass
,*
bedeutet dies, dass foo nur Schlüsselwortargumente nach pos2 akzeptiert, daherfoo(1, 2, 3)
TypeError auslöst, aber in Ordnungfoo(1, 2, kwarg1=3)
ist.*_
(Hinweis: Dies ist nur eine Konvention) auszudrücken :def foo(bar, baz, *_): pass
bedeutet (gemäß Konvention)foo
nur Verwendungenbar
undbaz
Argumente in seiner Arbeitsweise und ignoriert andere.\**_
(Hinweis: Dies ist nur eine Konvention) auszudrücken :def foo(bar, baz, **_): pass
bedeutet (gemäß Konvention)foo
nur Verwendungenbar
undbaz
Argumente in seiner Arbeitsweise und ignoriert andere.BONUS: Ab Python 3.8 kann man
/
in der Funktionsdefinition nur Positionsparameter erzwingen. Im folgenden Beispiel sind die Parameter a und b nur positionell , während c oder d positionell oder Schlüsselwort sein können und e oder f Schlüsselwörter sein müssen:quelle
TL; DR
Es packt Argumente für die Funktion in geben
list
unddict
jeweils im Funktionskörper. Wenn Sie eine Funktionssignatur wie folgt definieren:Es kann mit einer beliebigen Anzahl von Argumenten und Schlüsselwortargumenten aufgerufen werden. Die Nicht-Schlüsselwort-Argumente werden in eine Liste gepackt,
args
die im Funktionskörper aufgerufen wird, und die Schlüsselwort-Argumente werden in ein Diktat gepackt,kwds
das im Funktionskörper aufgerufen wird.Wenn nun innerhalb des Funktionskörpers die Funktion aufgerufen wird, gibt es zwei lokale Variablen, nämlich
args
eine Liste mit Wert["this", "is a list of", "non-keyword", "arguments"]
undkwds
einedict
mit Wert{"keyword" : "ligma", "options" : [1,2,3]}
Dies funktioniert auch umgekehrt, dh von der Anruferseite. Zum Beispiel, wenn Sie eine Funktion definiert haben als:
Sie können es aufrufen, indem Sie iterable oder Mappings entpacken, die Sie im aufrufenden Bereich haben:
quelle
Kontext
**
Verwendung mit Zeichenfolgenformatierung
Zusätzlich zu den Antworten in diesem Thread gibt es hier ein weiteres Detail, das an keiner anderen Stelle erwähnt wurde. Dies erweitert die Antwort von Brad Solomon
Das Auspacken mit
**
ist auch nützlich, wenn Sie Python verwendenstr.format
.Dies ist etwas ähnlich wie bei Python-
f-strings
F-Strings aber mit dem zusätzlichen Aufwand, ein Diktat zu deklarieren, um die Variablen zu halten (F-String erfordert kein Diktat).Kurzes Beispiel
quelle
def foo(param1, *param2):
ist eine Methode, die eine beliebige Anzahl von Werten akzeptieren kann für*param2
,def bar(param1, **param2):
ist eine Methode, die eine beliebige Anzahl von Werten mit Schlüsseln für akzeptieren kann*param2
param1
ist ein einfacher Parameter.Die Syntax zum Implementieren von Varargs in Java lautet beispielsweise wie folgt:
quelle