Wie verwende ich die Entpackoperatoren (*, **) in Python?

Python ist die am häufigsten verwendete Programmiersprache. Heute werden Sie lernen, eines seiner wichtigsten – aber oft ignorierten – Features zu verwenden, nämlich das Entpacken in Python.

Sie haben wahrscheinlich * und ** im Code anderer gesehen oder sie sogar verwendet, ohne wirklich zu wissen, was ihr Zweck ist. Wir werden das Konzept des Entpackens durchgehen und wie man es verwendet, um mehr Pythonic-Code zu schreiben.

Hier ist eine Liste von Konzepten, die Sie beim Lesen dieses Tutorials nützlich finden werden:

• Iterierbar: Jede Sequenz, die von einer for-Schleife iteriert werden kann, wie Mengen, Listen, Tupel und Wörterbücher
• Callable: Ein Python-Objekt, das mit doppelten Klammern () aufgerufen werden kann, zum Beispiel myfunction()
• Shell: Interaktive Laufzeitumgebung, mit der wir Python-Code ausführen können. Wir können es aufrufen, indem wir „python“ in einem Terminal ausführen
• Variable: Symbolischer Name, der ein Objekt speichert und einen reservierten Speicherplatz hat.

Beginnen wir mit der häufigsten Verwirrung: Asteristics in Python sind auch arithmetische Operatoren. Ein Sternchen

wird für die Multiplikation verwendet, während zwei von ihnen (**) sich auf die Potenzierung beziehen.

>>> 3*3
9
>>> 3**3
27

Wir können das beweisen, indem wir eine Python-Shell öffnen und Folgendes eingeben:

Hinweis: Sie müssen Python 3 installiert haben, um diesem Tutorial folgen zu können. Wenn Sie es nicht installiert haben, sehen Sie sich unsere Python-Installationsanleitung an.

Wie Sie sehen können, verwenden wir das Sternchen nach der ersten Zahl und vor der zweiten. Wenn Sie dies sehen, bedeutet dies, dass wir die arithmetischen Operatoren verwenden.

>>> *range(1, 6),
(1, 2, 3, 4, 5)
>>> {**{'vanilla':3, 'chocolate':2}, 'strawberry':2}
{'vanilla': 3, 'chocolate': 2, 'strawberry': 2}

Andererseits verwenden wir die Sternchen (*, **) vor einem Iterable, um es zu entpacken – zum Beispiel:

Machen Sie sich keine Sorgen, wenn Sie es nicht verstehen, dies ist nur eine Einleitung zum Entpacken in Python. Also machen Sie weiter und lesen Sie das gesamte Tutorial!

Was ist Auspacken?

Entpacken ist der Prozess, Dinge herauszuholen – Iterables wie Listen, Tupel und Wörterbücher. Stellen Sie sich vor, Sie öffnen eine Kiste und holen verschiedene Gegenstände wie Kabel, Kopfhörer oder einen USB-Stick heraus.

Das Auspacken in Python ähnelt dem Auspacken einer Kiste im wirklichen Leben.

>>> mybox = ['cables', 'headphones', 'USB']
>>> item1, item2, item3 = mybox

Lassen Sie uns dasselbe Beispiel zum besseren Verständnis in Code übersetzen:

Wie Sie sehen können, weisen wir die drei Elemente in der mybox-Liste den drei Variablen item1, item2, item2 zu. Diese Art der Variablenzuweisung ist das grundlegende Konzept des Entpackens in Python.

>>> item1
'cables'
>>> item2
'headphones'
>>> item3
'USB'

Wenn Sie versuchen, den Wert jedes Elements zu ermitteln, werden Sie feststellen, dass sich item1 auf „Kabel“, item2 auf „Kopfhörer“ und so weiter bezieht.

>>> newbox = ['cables', 'headphones', 'USB', 'mouse']
>>> item1, item2, item3 = newbox
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 3)

Bis hierhin scheint mit diesem Code alles in Ordnung zu sein, aber was wäre, wenn wir eine Liste mit mehr Elementen entpacken wollten – mit der gleichen Anzahl zugewiesener Variablen?

Wahrscheinlich haben Sie diese Art von Fehler erwartet. Im Wesentlichen weisen wir drei Variablen 4 Listenelemente zu. Wie schafft es Python, die richtigen Werte zuzuweisen? Das tut es nicht, weil wir a bekommen WertFehler

mit der Meldung „zu viele Werte zum Entpacken“. Dies geschieht, weil wir links drei Variablen und rechts vier Werte (entsprechend der Newbox-Liste) setzen.

>>> lastbox = ['cables', 'headphones']
>>> item1, item2, item3 = lastbox
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 3, got 2)

Wenn Sie versuchen, einen ähnlichen Vorgang durchzuführen, aber mit mehr Variablen als Werten zum Entpacken, erhalten Sie einen weiteren ValueError, außer dem mit einer etwas anderen Meldung:

Hinweis: Wir haben mit Listen gearbeitet, aber Sie können diese Form des Entpackens mit jedem Iterable (Listen, Sets, Tupel, Wörterbücher) verwenden.

Wie also überwinden wir diese Situation? Gibt es eine Möglichkeit, alle Elemente einer Iterable in ein paar Variablen zu entpacken, ohne dass Fehler auftreten?

Sicher gibt es das, und es heißt Entpackoperator oder Sternchenoperator (*, **). Mal sehen, wie man es in Python verwendet.

So entpacken Sie Listen mit dem *-Operator

Der Sternchen-Operator

>>> first, *unused, last = [1, 2, 3, 5, 7]
>>> first
1
>>> last
7
>>> unused
[2, 3, 5]

wird verwendet, um alle noch nicht zugewiesenen Werte eines Iterablen zu entpacken.

>>> first, *_, last = [1, 2, 3, 5, 7]
>>> _
[2, 3, 5]

Angenommen, Sie möchten das erste und letzte Element einer Liste abrufen, ohne Indizes zu verwenden. Wir könnten dies mit dem Sternchenoperator tun:

>>> first, *_, last = [1, 2]
>>> first
1
>>> last
2
>>> _
[]

Wie Sie sehen können, erhalten wir alle nicht verwendeten Werte mit dem Sternchen-Operator. Die bevorzugte Methode zum Verwerfen von Werten ist die Verwendung einer Unterstrich-Variablen (_), die manchmal als „Dummy-Variable“ verwendet wird.

Wir können diesen Trick auch dann anwenden, wenn die Liste nur zwei Elemente hat:

In diesem Fall speichert die Unterstrich-Variable (Dummy-Variable) eine leere Liste, sodass die anderen beiden Variablen um sie herum auf die verfügbaren Werte der Liste zugreifen können.

>>> *string = 'PythonIsTheBest'

Allgemeine Fehlerbehebung

>>> *string = 'PythonIsTheBest'
  File "<stdin>", line 1
SyntaxError: starred assignment target must be in a list or tuple

Wir können ein einzigartiges Element eines Iterablen entpacken. Du würdest dir zum Beispiel so etwas einfallen lassen: Der obige Code gibt jedoch einen SyntaxError zurück:Dies, weil laut

PEP-Spezifikation

:

>>> *string, = 'PythonIsTheBest'
>>> string
['P', 'y', 't', 'h', 'o', 'n', 'I', 's', 'T', 'h', 'e', 'B', 'e', 's', 't']

Ein Tupel (oder eine Liste) auf der linken Seite einer einfachen Zuweisung

>>> *numbers, = range(5)
>>> numbers
[0, 1, 2, 3, 4]

Wenn wir alle Werte einer Iterable in eine einzelne Variable entpacken wollen, müssen wir ein Tupel einrichten, daher reicht das Hinzufügen eines einfachen Kommas aus:

Ein weiteres Beispiel wäre die Verwendung der Bereichsfunktion, die eine Folge von Zahlen zurückgibt.

Nachdem Sie nun wissen, wie man Listen und Tupel mit einem Sternchen entpackt, ist es an der Zeit, sich mit dem Entpacken von Wörterbüchern zu befassen.

So entpacken Sie Wörterbücher mit dem **-Operator

>>> **greetings, = {'hello': 'HELLO', 'bye':'BYE'} 
...
SyntaxError: invalid syntax

Während ein einzelner Stern zum Entpacken von Listen und Tupeln verwendet wird, dient der doppelte Stern (**) zum Entpacken von Wörterbüchern.

>>> food = {'fish':3, 'meat':5, 'pasta':9} 
>>> colors = {'red': 'intensity', 'yellow':'happiness'}
>>> merged_dict = {**food, **colors}
>>> merged_dict
{'fish': 3, 'meat': 5, 'pasta': 9, 'red': 'intensity', 'yellow': 'happiness'}

Leider können wir ein Wörterbuch nicht in eine einzelne Variable entpacken, wie wir es mit Tupeln und Listen getan haben. Das bedeutet, dass Folgendes einen Fehler auslöst:

Wir können jedoch den Operator ** innerhalb von Callables und anderen Wörterbüchern verwenden. Wenn wir beispielsweise ein zusammengeführtes Wörterbuch aus anderen Wörterbüchern erstellen möchten, können wir den folgenden Code verwenden:

Dies ist eine ziemlich kurze Möglichkeit, zusammengesetzte Wörterbücher zu erstellen, dies ist jedoch nicht der Hauptansatz beim Entpacken in Python.

Mal sehen, wie wir das Entpacken mit Callables verwenden können

Packen in Funktionen: args und kwargs

Wahrscheinlich haben Sie schon einmal args und kwargs gesehen, die entweder in Klassen oder Funktionen implementiert wurden. Mal sehen, warum wir sie zusammen mit Callables verwenden müssen.

>>> def product(n1, n2):
...     return n1 * n2
... 
>>> numbers = [12, 1]
>>> product(*numbers)
12

Packen mit dem Operator * (args)

>>> product(12, 1)
12

Angenommen, wir haben eine Funktion, die das Produkt zweier Zahlen berechnet.

>>> numbers = [12, 1, 3, 4]
>>> product(*numbers)
...
TypeError: product() takes 2 positional arguments but 4 were given

Wie Sie sehen können, entpacken wir die Listennummern in die Funktion, also führen wir tatsächlich Folgendes aus:

>>> def product(*args):
...     result = 1
...     for i in args:
...             result *= i
...     return result
...
>>> product(*numbers)
144

Bis hierher funktioniert alles einwandfrei, aber was wäre, wenn wir eine längere Liste weitergeben wollten? Es wird sicherlich einen Fehler auslösen, da die Funktion mehr Argumente empfängt, als sie verwalten kann.

Wir können all dies lösen, indem wir die Liste direkt in die Funktion packen, was eine iterierbare darin erstellt und es uns ermöglicht, eine beliebige Anzahl von Argumenten an die Funktion zu übergeben.

Hier behandeln wir den args-Parameter als Iterable, durchlaufen seine Elemente und geben das Produkt aller Zahlen zurück. Beachten Sie, dass die Startnummer des Ergebnisses eins sein muss, denn wenn wir mit Null beginnen, gibt die Funktion immer Null zurück. Hinweis: args ist nur eine Konvention, Sie können jeden anderen Parameternamen verwendenWir könnten auch beliebige Zahlen an die Funktion übergeben, ohne eine Liste zu verwenden, genau wie bei der eingebauten

>>> product(5, 5, 5)
125
>>> print(5, 5, 5)
5 5 5

Druckfunktion

>>> def test_type(*args):
...     print(type(args))
...     print(args)
... 
>>> test_type(1, 2, 4, 'a string')
<class 'tuple'>
(1, 2, 4, 'a string')

.

Lassen Sie uns schließlich den Objekttyp der Argumente einer Funktion abrufen.

Wie im obigen Code angemerkt, ist der Typ der Argumente immer Tupel, und der Inhalt davon sind alle Argumente, die nicht aus Schlüsselwörtern bestehen und an die Funktion übergeben werden.

Packen mit dem Operator ** (kwargs)

>>> def make_person(name, **kwargs):
...     result = name + ': '
...     for key, value in kwargs.items():
...             result += f'{key} = {value}, '
...     return result
... 
>>> make_person('Melissa', id=12112, location='london', net_worth=12000)
'Melissa: id = 12112, location = london, net_worth = 12000, '

Wie wir bereits gesehen haben, wird der Operator ** ausschließlich für Wörterbücher verwendet. Das bedeutet, dass wir mit diesem Operator Schlüssel-Wert-Paare als Parameter an die Funktion übergeben können.

Lassen Sie uns eine Funktion make_person erstellen, die ein Positionsargument „Name“ und eine undefinierte Anzahl von Schlüsselwortargumenten erhält.

Wie Sie sehen können, wandelt die **kwargs-Anweisung alle Schlüsselwortargumente in ein Wörterbuch um, das wir innerhalb der Funktion iterieren können.

>>> def test_kwargs(**kwargs):
...     print(type(kwargs))
...     print(kwargs)
... 
>>> test_kwargs(random=12, parameters=21)
<class 'dict'>
{'random': 12, 'parameters': 21}

Hinweis: kwargs ist nur eine Konvention, mit der Sie diesen Parameter beliebig benennen können

Wir können den Typ der kwargs auf die gleiche Weise wie bei args überprüfen:

>>> def my_final_function(*args, **kwargs):
...     print('Type args: ', type(args))
...     print('args: ', args)
...     print('Type kwargs: ', type(kwargs))
...     print('kwargs: ', kwargs)
... 
>>> my_final_function('Python', 'The', 'Best', language="Python", users="A lot")
Type args:  <class 'tuple'>
args:  ('Python', 'The', 'Best')
Type kwargs:  <class 'dict'>
kwargs:  {'language': 'Python', 'users': 'A lot'}

Die interne Variable kwargs wird immer zu einem Wörterbuch, das die an die Funktion übergebenen Schlüssel-Wert-Paare speichert.

Lassen Sie uns schließlich args und kwargs in derselben Funktion verwenden:

Fazit

• Entpackoperatoren sind bei alltäglichen Aufgaben wirklich nützlich, jetzt wissen Sie, wie Sie sie sowohl in einzelnen Anweisungen als auch in Funktionsparametern verwenden.
• In diesem Tutorial haben Sie gelernt:
• Sie verwenden * für Tupel und Listen und ** für Wörterbücher
• Sie können Entpackoperatoren in Funktionen und Klassenkonstruktoren verwenden