Coole neue Funktionen in Python 3.8

Die newest Version von Python wird veröffentlicht! Python 3.8 ist seit dem Sommer in Beta-Versionen verfügbar, aber unter October 14th, 2019 ist die erste offizielle Version fertig. Jetzt können wir alle mit den neuen Funktionen spielen und von den neuesten Verbesserungen profitieren.

Was bringt Python 3.8 auf den Tisch? Die documentation bietet einen guten Überblick über die neuen Funktionen. In diesem Artikel werden jedoch einige der größten Änderungen ausführlicher beschrieben und gezeigt, wie Sie Python 3.8 nutzen können.

*In diesem Artikel erfahren Sie mehr über:*

Verwenden von Zuweisungsausdrücken zur Vereinfachung einiger Codekonstrukte
Erzwingen von Nur-Position-Argumenten in Ihren eigenen Funktionen
Angabe genauerer Typhinweise
Verwenden von F-Strings zum einfacheren Debuggen

Mit wenigen Ausnahmen enthält Python 3.8 viele kleine Verbesserungen gegenüber den früheren Versionen. Gegen Ende des Artikels werden Sie viele dieser weniger aufmerksamkeitsstarken Änderungen sowie eine Diskussion über einige der Optimierungen sehen, die Python 3.8 schneller als seine Vorgänger machen. Abschließend erhalten Sie einige Tipps zum Upgrade auf die neue Version.

*Kostenloser Bonus:* Link: [Klicken Sie hier, um Zugriff auf ein Kapitel aus Python Tricks: The Book zu erhalten], das Ihnen die Best Practices von Python anhand einfacher Beispiele zeigt, die Sie sofort anwenden können, um schöneren + Pythonic-Code zu schreiben.

Das Walross im Raum: Zuweisungsausdrücke

Die größte Änderung in Python 3.8 ist die Einführung von Zuweisungsausdrücken . Sie werden in einer neuen Notation geschrieben (+: = +). Dieser Operator wird oft als Walross-Operator bezeichnet, da er den Augen und Stoßzähnen eines Walrosses auf seiner Seite ähnelt.

Mit Zuweisungsausdrücken können Sie einen Wert im selben Ausdruck zuweisen und zurückgeben. Wenn Sie beispielsweise einer Variablen zuweisen und ihren Wert drucken möchten, gehen Sie normalerweise wie folgt vor:

>>>

>>> walrus = False
>>> print(walrus)
False

In Python 3.8 können Sie diese beiden Anweisungen mit dem Walross-Operator zu einer kombinieren:

>>>

>>> print(walrus := True)
True

Mit dem Zuweisungsausdruck können Sie + True + zu + Walross + `zuweisen und den Wert sofort drucken. Beachten Sie jedoch, dass der Walross-Bediener nichts tut, was ohne ihn nicht möglich ist. Dies macht nur bestimmte Konstrukte bequemer und kann manchmal die Absicht Ihres Codes klarer kommunizieren.

Ein Muster, das einige der Stärken des Walross-Operators zeigt, ist "+ while " - Schleifen, in denen Sie eine Variable initialisieren und aktualisieren müssen. Der folgende Code fordert den Benutzer beispielsweise zur Eingabe auf, bis er " quit +" eingibt:

inputs = list()
current = input("Write something: ")
while current != "quit":
    inputs.append(current)
    current = input("Write something: ")

Dieser Code ist nicht ideal. Sie wiederholen die Anweisung "+ input () " und müssen irgendwie " current " zur Liste hinzufügen, bevor Sie den Benutzer danach fragen. Eine bessere Lösung besteht darin, eine Endlosschleife " while " einzurichten und die Schleife mit " break +" zu stoppen:

inputs = list()
while True:
    current = input("Write something: ")
    if current == "quit":
        break
    inputs.append(current)

Dieser Code entspricht dem obigen, vermeidet jedoch die Wiederholung und hält die Zeilen in einer logischeren Reihenfolge. Wenn Sie einen Zuweisungsausdruck verwenden, können Sie diese Schleife weiter vereinfachen:

inputs = list()
while (current := input("Write something: ")) != "quit":
    inputs.append(current)

Dadurch wird der Test zurück in die Zeile "+ while +" verschoben, in der er sich befinden sollte. In dieser Zeile passieren jetzt jedoch mehrere Dinge, sodass es etwas aufwendiger ist, sie richtig zu lesen. Überlegen Sie nach bestem Wissen, wann der Walross-Operator dazu beiträgt, dass Ihr Code besser lesbar ist.

PEP 572 beschreibt alle Details von Zuweisungsausdrücken, einschließlich einiger Gründe für deren Einführung in die Sprache sowie https://www .python.org/dev/peps/pep-0572/# Beispiele [mehrere Beispiele], wie der Walross-Operator verwendet werden kann.

Nur-Positions-Argumente

Die eingebaute Funktion + float () + kann zum Konvertieren von Textzeichenfolgen und Zahlen in + float + Objekte verwendet werden. Betrachten Sie das folgende Beispiel:

>>>

>>> float("3.8")
3.8

>>> help(float)
class float(object)
 |  float(x=0,/)
 |
 |  Convert a string or number to a floating point number, if possible.

[...]

Schauen Sie sich die Signatur von + float () + genau an. Beachten Sie den Schrägstrich (/) nach dem Parameter. Was bedeutet es?

*Hinweis:* Eine ausführliche Beschreibung der Notation `+/+` finden Sie unter https://www.python.org/dev/peps/pep-0457/[PEP 457 - Notation für Nur-Position-Parameter].

Es stellt sich heraus, dass der eine Parameter von "+ float () " zwar " x +" heißt, der Name jedoch nicht verwendet werden darf:

>>>

>>> float(x="3.8")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: float() takes no keyword arguments

Bei Verwendung von "+ float () +" dürfen Sie Argumente nur nach Position und nicht nach Schlüsselwort angeben. Vor Python 3.8 waren solche Nur-Position -Argumente nur für integrierte Funktionen möglich. Es gab keine einfache Möglichkeit anzugeben, dass Argumente in Ihren eigenen Funktionen nur positionell sein sollten:

>>>

>>> def incr(x):
...     return x + 1
...
>>> incr(3.8)
4.8

>>> incr(x=3.8)
4.8

Es ist möglich, https://github.com/python/cpython/blob/3.7/Lib/collections/init.py#L1000[simulate] Nur-Positions-Argumente using + *args +, aber dies ist weniger flexibel, weniger lesbar und zwingt Sie, Ihre eigene Argumentanalyse zu implementieren. In Python 3.8 können Sie "/" verwenden, um anzugeben, dass alle Argumente vor der Position angegeben werden müssen. Sie können + incr () + umschreiben, um nur Positionsargumente zu akzeptieren:

>>>

>>> def incr(x,/):
...     return x + 1
...
>>> incr(3.8)
4.8

>>> incr(x=3.8)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: incr() got some positional-only arguments passed as
           keyword arguments: 'x'

Durch Hinzufügen von "/" nach "+ x " geben Sie an, dass " x +" ein reines Positionsargument ist. Sie können reguläre Argumente mit nur positionellen Argumenten kombinieren, indem Sie die regulären Argumente nach dem Schrägstrich setzen:

>>>

>>> def greet(name,/, greeting="Hello"):
...     return f"{greeting}, {name}"
...
>>> greet("Łukasz")
'Hello, Łukasz'

>>> greet("Łukasz", greeting="Awesome job")
'Awesome job, Łukasz'

>>> greet(name="Łukasz", greeting="Awesome job")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: greet() got some positional-only arguments passed as
           keyword arguments: 'name'

In + greet () + wird der Schrägstrich zwischen + name + und + greeting + gesetzt. Dies bedeutet, dass "+ Name " ein reines Positionsargument ist, während " Begrüßung +" ein reguläres Argument ist, das entweder nach Position oder nach Schlüsselwort übergeben werden kann.

Auf den ersten Blick können reine Positionsargumente etwas einschränkend wirken und dem Python-Mantra über die Bedeutung der Lesbarkeit widersprechen. Sie werden wahrscheinlich feststellen, dass es nicht viele Fälle gibt, in denen nur Positionsargumente Ihren Code verbessern.

Unter den richtigen Umständen können Ihnen jedoch nur Positionsargumente Flexibilität beim Entwerfen von Funktionen bieten. Erstens sind reine Positionsargumente sinnvoll, wenn Sie Argumente haben, die eine natürliche Reihenfolge haben, denen jedoch nur schwer gute, beschreibende Namen zu geben sind.

Ein weiterer möglicher Vorteil der Verwendung von Nur-Positions-Argumenten besteht darin, dass Sie Ihre Funktionen einfacher umgestalten können. Insbesondere können Sie den Namen Ihrer Parameter ändern, ohne befürchten zu müssen, dass anderer Code von diesen Namen abhängt.

Nur-Position-Argumente ergänzen gut* Nur-Schlüsselwort -Argumente. In jeder Version von Python 3 können Sie Argumente nur mit Schlüsselwörtern mit dem Stern (+ +

TOC

Coole neue Funktionen in Python 3.8