• Erledigen Sie die Anwendungssicherheit auf die richtige Weise! Erkennen, schützen, überwachen, beschleunigen und mehr…
  • Python ist die am häufigsten verwendete Programmiersprache. Heute lernen Sie, eine der wichtigsten – aber oft ignorierten – Funktionen zu verwenden, die in Python entpackt wird.

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

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

    • Iterable: Jede Sequenz, die von a . iteriert werden kann for-Schleife, wie Sätze, Listen, Tupel und Wörterbücher
    • Abrufbar: Ein Python-Objekt, das mit doppelter Klammer () aufgerufen werden kann, zum Beispiel, meinefunktion()
    • Hülle: Interaktive Laufzeitumgebung, in 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: Asteristiken in Python sind auch arithmetische Operatoren. Ein Stern (*) wird für die Multiplikation verwendet, während zwei davon (**) sich auf die Potenzierung beziehen.

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

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

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

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

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

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

    Machen Sie sich keine Sorgen, wenn Sie es nicht verstehen, dies ist nur eine Präambel zum Entpacken in Python. Also mach weiter und lies das gesamte Tutorial!

    What’s unpacking?

    Das Entpacken ist der Prozess, bei dem Dinge herausgeholt werden – iterierbare Elemente wie Listen, Tupel und Wörterbücher. Stellen Sie sich das so vor, als würden Sie eine Schachtel öffnen und verschiedene Gegenstände wie Kabel herausholen, Kopfhörer, oder einen USB-Stick.

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

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

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

    Wie Sie sehen können, weisen wir die drei Elemente innerhalb des mybox Liste mit drei Variablen auf Artikel1, Artikel2, Artikel2. Diese Art der Variablenzuweisung ist das grundlegende Konzept des Entpackens in Python.

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

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

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

    >>> 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)

    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?

    Es tut es nicht, weil wir ein bekommen ValueError mit der Meldung „zu viele Werte zum Entpacken“. Das passiert, weil wir uns einstellen drei Variablen links, und vier Werte (entsprechend der Newbox-Liste) rechts.

    Wenn Sie versuchen, einen ähnlichen Prozess durchzuführen, aber mit mehr Variablen als Werten zu entpacken, erhalten Sie einen anderen ValueError außer mit einer etwas anderen Meldung:

    >>> 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)
    

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

    Wie also überwinden wir diese Situation? Gibt es eine Möglichkeit, alle Elemente eines Iterables in ein paar Variablen zu entpacken, ohne Fehler zu erhalten?

    Sicher gibt es das, und es heißt Entpackoperator oder Sternchenoperator (*, **). Sehen wir uns an, wie es in Python verwendet wird.

    How to Unpack Lists With the * operator

    Der Stern-Operator (*) wird verwendet, um alle noch nicht zugewiesenen Werte eines Iterables zu entpacken.

    Angenommen, Sie möchten das erste und letzte Element einer Liste ohne Indizes abrufen, wir könnten dies mit dem Stern-Operator tun:

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

    Wie Sie sich vorstellen können, erhalten wir alle nicht verwendeten Werte mit dem Sternchen-Operator. Die bevorzugte Methode zum Verwerfen von Werten besteht darin, eine Unterstrichvariable (_) zu verwenden, die manchmal als „Dummy-Variable“ verwendet wird.

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

    Wir können diesen Trick auch dann noch anwenden, wenn die Liste nur zwei Elemente enthält:

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

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

    Allgemeine Fehlerbehebung

    Wir können ein einzigartiges Element eines Iterables auspacken. Sie würden sich zum Beispiel so etwas einfallen lassen:

    >>> *string = 'PythonIsTheBest'

    Der obige Code gibt jedoch a . zurück Syntax-Fehler:

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

    Dies, weil nach den PEP-Spezifikation:

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

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

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

    Ein weiteres Beispiel wäre die Verwendung der Angebot Funktion, die eine Zahlenfolge zurückgibt.

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

    Nachdem Sie nun wissen, wie man Listen und Tupel mit einem Sternchen entpackt, ist es an der Zeit, Wörterbücher zu entpacken.

    How to Unpack Dictionaries With ** operator

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

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

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

    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:

    >>> 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'}

    Dies ist ein ziemlich kurzer Weg, um zusammengesetzte Wörterbücher zu erstellen, dies ist jedoch nicht der Hauptansatz beim Entpacken in Python.

    Mal sehen, wie wir das Auspacken mit Callables nutzen können

    Packing in Functions: args and kwargs

    Sie haben wahrscheinlich 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.

    Packen mit dem Operator * (Args)

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

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

    Wie ihr seht, packen wir die Liste aus Zahlen auf die Funktion, also führen wir tatsächlich Folgendes aus:

    >>> product(12, 1)
    12
    

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

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

    Wir können das alles einfach lösen Verpackung die Liste direkt auf der Funktion, wodurch eine iterierbare darin erstellt wird und wir eine beliebige Anzahl von Argumenten an die Funktion übergeben können.

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

    Hier behandeln wir die args Parameter als iterierbar, durchläuft seine Elemente und gibt 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 verwenden

    Wir könnten der Funktion auch beliebige Zahlen übergeben, ohne eine Liste zu verwenden, genau wie beim eingebauten built Druckfunktion.

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

    Lassen Sie uns zum Schluss den Objekttyp des args einer Funktion.

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

    Wie im obigen Code erwähnt, ist die Art von args wird immer sein Tupel, und der Inhalt besteht aus allen Argumenten ohne Schlüsselworte, die an die Funktion übergeben werden.

    Packen mit dem ** Operator (kwargs)

    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.

    Lass uns eine Funktion erstellen machen_person, das ein Positionsargument "name" und eine undefinierte Anzahl von Schlüsselwortargumenten erhält.

    >>> 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 Sie sehen können, die ** kwargs -Anweisung konvertiert alle mit Schlüsselwörtern versehenen Argumente in ein Wörterbuch, das wir innerhalb der Funktion durchlaufen können.

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

    Wir können die Art der Kwargs so wie wir es mit gemacht haben args:

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

    Das  Kwargs Die interne Variable wird immer zu einem Wörterbuch, in dem die an die Funktion übergebenen Schlüssel-Wert-Paare gespeichert werden.

    Schließlich nutzen wir argsKwargs in der gleichen Funktion:

    >>> 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'}
    

    Fazit

    Entpackoperatoren sind in alltäglichen Aufgaben sehr 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
    • args werden verwendet, um Parameter ohne Schlüsselworte an Funktionen zu übergeben
    • Kwargs werden verwendet, um mit Schlüsselwörtern versehene Parameter an Funktionen zu übergeben.