TOC

Nouvelles fonctionnalités intéressantes dans Python 3.8

Nouvelles fonctionnalités intéressantes dans Python 3.8

La version newest de Python est disponible! Python 3.8 est disponible en versions bêta depuis l’été, mais sur 14 octobre 2019 la première version officielle est prête. Maintenant, nous pouvons tous commencer à jouer avec les nouvelles fonctionnalités et bénéficier des dernières améliorations.

Qu’est-ce que Python 3.8 apporte à la table? La documentation donne un bon aperçu des nouvelles fonctionnalités. Cependant, cet article va approfondir certains des changements les plus importants et vous montrer comment tirer parti de Python 3.8.

*Dans cet article, vous découvrirez:*

  • Utilisation d’expressions d’affectation pour simplifier certaines constructions de code

  • Appliquer des arguments positionnels uniquement dans vos propres fonctions

  • Spécification d’indications de type plus précises

  • Utilisation de chaînes f pour un débogage plus simple

À quelques exceptions près, Python 3.8 contient de nombreuses petites améliorations par rapport aux versions antérieures. Vers la fin de l’article, vous verrez un grand nombre de ces changements qui attirent moins l’attention, ainsi qu’une discussion sur certaines des optimisations qui rendent Python 3.8 plus rapide que ses prédécesseurs. Enfin, vous obtiendrez quelques conseils sur la mise à niveau vers la nouvelle version.

*Bonus gratuit:* lien: [Cliquez ici pour accéder à un chapitre de Python Tricks: The Book] qui vous montre les meilleures pratiques de Python avec des exemples simples que vous pouvez appliquer instantanément pour écrire du code Pythonic plus beau +.

Le morse dans la salle: expressions d’affectation

Le plus grand changement dans Python 3.8 est l’introduction des expressions d’affectation . Ils sont écrits en utilisant une nouvelle notation (+: = +). Cet opérateur est souvent appelé opérateur de morse car il ressemble aux yeux et aux défenses d’un morse de son côté.

Les expressions d’affectation vous permettent d’affecter et de renvoyer une valeur dans la même expression. Par exemple, si vous souhaitez affecter à une variable et imprimer sa valeur, vous faites généralement quelque chose comme ceci:

>>>

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

Dans Python 3.8, vous êtes autorisé à combiner ces deux instructions en une seule, à l’aide de l’opérateur morse:

>>>

>>> print(walrus := True)
True

L’expression d’affectation vous permet d’affecter + True + à + ​​morse + et d’imprimer immédiatement la valeur. Mais gardez à l’esprit que l’opérateur de morse ne fait rien qui ne serait pas possible sans lui. Cela rend seulement certaines constructions plus pratiques et peut parfois communiquer plus clairement l’intention de votre code.

Un modèle qui montre certaines des forces de l’opérateur de morse est + tandis que + boucles où vous devez initialiser et mettre à jour une variable. Par exemple, le code suivant demande à l’utilisateur de saisir jusqu’à ce qu’il tape «+ quitter +»:

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

Ce code n’est pas idéal. Vous répétez l’instruction + input () +, et vous devez d’une manière ou d’une autre ajouter + current + à la liste avant de le demander à l’utilisateur. Une meilleure solution consiste à configurer une boucle infinie + while +, et à utiliser + break + pour arrêter la boucle:

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

Ce code est équivalent à celui ci-dessus, mais évite la répétition et maintient en quelque sorte les lignes dans un ordre plus logique. Si vous utilisez une expression d’affectation, vous pouvez simplifier davantage cette boucle:

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

Cela ramène le test à la ligne + while +, où il devrait être. Cependant, il y a maintenant plusieurs choses qui se produisent sur cette ligne, il faut donc un peu plus d’efforts pour la lire correctement. Utilisez votre meilleur jugement pour savoir quand l’opérateur de morse aide à rendre votre code plus lisible.

PEP 572 décrit tous les détails des expressions d’affectation, y compris certaines des raisons de les introduire dans le langage, ainsi que https://www .python.org/dev/peps/pep-0572/# exemples [plusieurs exemples] de la façon dont l’opérateur morse peut être utilisé.

Arguments positionnels uniquement

La fonction intégrée + float () + peut être utilisée pour convertir des chaînes de texte et des nombres en objets + float +. Prenons l’exemple suivant:

>>>

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

[...]

Regardez attentivement la signature de + float () +. Remarquez la barre oblique (/) après le paramètre. Qu’est-ce que ça veut dire?

*Remarque:* Pour une discussion approfondie sur la notation `+/+`, voir https://www.python.org/dev/peps/pep-0457/[PEP 457 - Notation for Positional-Only Parameters].

Il se trouve que même si le seul paramètre de + float () + est appelé + x +, vous n’êtes pas autorisé à utiliser son nom:

>>>

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

Lorsque vous utilisez + float () +, vous êtes uniquement autorisé à spécifier des arguments par position, pas par mot clé. Avant Python 3.8, de tels arguments positionnels uniquement n’étaient possibles que pour les fonctions intégrées. Il n’y avait pas de moyen facile de spécifier que les arguments doivent être positionnels uniquement dans vos propres fonctions:

>>>

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

>>> incr(x=3.8)
4.8

Il est possible de https://github.com/python/cpython/blob/3.7/Lib/collections/init.py#L1000[simulate] arguments positionnels uniquement en utilisant + *args +, mais cela est moins flexible, moins lisible et vous oblige à implémenter votre propre analyse d’arguments. Dans Python 3.8, vous pouvez utiliser / pour indiquer que tous les arguments avant il doivent être spécifiés par position. Vous pouvez réécrire + incr () + pour accepter uniquement les arguments positionnels:

>>>

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

En ajoutant / après + x +, vous spécifiez que + x + est un argument positionnel uniquement. Vous pouvez combiner des arguments réguliers avec des arguments positionnels uniquement en plaçant les arguments réguliers après la barre oblique:

>>>

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

Dans + saluer () +, la barre oblique est placée entre + nom + et + salutation +. Cela signifie que + nom + est un argument positionnel uniquement, tandis que + message d’accueil + est un argument normal qui peut être transmis soit par position, soit par mot-clé.

À première vue, les arguments de position uniquement peuvent sembler un peu limitatifs et contraires au mantra de Python sur l’importance de la lisibilité. Vous constaterez probablement qu’il n’y a pas beaucoup d’occasions où les arguments positionnels seuls améliorent votre code.

Cependant, dans les bonnes circonstances, les arguments de position uniquement peuvent vous donner une certaine flexibilité lorsque vous concevez des fonctions. Tout d’abord, les arguments positionnels uniquement ont du sens lorsque vous avez des arguments qui ont un ordre naturel mais sont difficiles à donner de bons noms descriptifs.

Un autre avantage possible de l’utilisation d’arguments positionnels uniquement est que vous pouvez plus facilement refactoriser vos fonctions. En particulier, vous pouvez modifier le nom de vos paramètres sans vous soucier du fait que d’autres codes dépendent de ces noms.

Les arguments positionnels complètent parfaitement les arguments* mot clé uniquement . Dans n’importe quelle version de Python 3, vous pouvez spécifier des arguments de mots clés uniquement à l’aide de l’étoile (+ *+). Tout argument after + +

Related