Sortie du langage de programmation Python 3.9

Après un an de développement présenté une publication significative du langage de programmation Python 3.9. Python 3.9 est le premier version après de la transition le projet sur un nouveau cycle de préparation et de support des versions. Les nouvelles versions majeures seront désormais publiées une fois par an et les mises à jour correctives tous les deux mois. Chaque version majeure sera supportée pendant un an et demi, après quoi des corrections pour des failles de sécurité seront fournies pendant encore trois ans et demi.

Le travail sur la nouvelle branche commence désormais cinq mois avant la sortie de la nouvelle branche, c'est-à-dire en même temps que la sortie de Python 3.9 a commencé le test alpha de la branche Python 3.10. La branche Python 3.10 sera en phase de versions alpha pendant sept mois, au cours desquels de nouvelles fonctionnalités seront ajoutées et des bugs seront corrigés. Ensuite, pendant trois mois, des versions bêta seront testées, durant lesquels l’ajout de nouvelles fonctionnalités sera interdit et toute l’attention sera portée à la correction d’erreurs. Les deux derniers mois précédant la sortie, la branche sera en phase de candidat à la version, où la stabilisation finale sera effectuée.

Parmi ajoutées innovations dans Python 3.9 :

• Dans les dictionnaires définis par la classe intégrée dict, est désormais la prise en charge des opérateurs de fusion «|» et de mise à jour «|=», qui complètent les méthodes {**d1, **d2} et dict.update, précédemment proposées pour fusionner des dictionnaires.

  >>> x = {«key1»: «value1 from x», «key2»: «value2 from x»}
  >>> y = {«key2»: «value2 from y», «key3»: «value3 from y»}

  >>> x | y
  {‘key1’: ‘value1 from x’, ‘key2’: ‘value2 from y’, ‘key3’: ‘value3 from y’}

  >>> y | x
  {‘key2’: ‘value2 from x’, ‘key3’: ‘value3 from y’, ‘key1’: ‘value1 from x’}

• La collection de types intégrée comprend list, dict et tuple, qui peuvent être utilisés comme types de base sans importation depuis le module typing. C'est-à-dire qu'au lieu de typing.List, typing.Dict et typing.Tuple, on peut désormais simplement indiquer
  list, dict et tuple :

  def greet_all(names: list[str]) -> None :
  for name in names :
  print(«Hello», name)

• Des moyens flexibles ont été fournis pour annoter les fonctions et les variables. Pour attacher des annotations, un nouveau type Annotated a été ajouté au module typing, étendant les types existants avec des métadonnées supplémentaires pouvant être utilisées pour une analyse statique ou pour des optimisations à l'exécution. Pour accéder aux métadonnées depuis le code, un paramètre include_extras a été ajouté à la méthode typing.get_type_hints().

  charType = Annotated[int, ctype(«char»)]
  UnsignedShort = Annotated[int, struct2.ctype(‘H’)]

• Assouplies Les exigences grammaticales des décorateurs — toute expression valable pour une utilisation dans des blocs if et while peut désormais être utilisée comme décorateur. Ce changement a permis d'améliorer considérablement la lisibilité du code PyQt5 et de simplifier la maintenance de ce module :

  Avant :
  button_0 = buttons[0]
  @button_0.clicked.connect

  Maintenant, vous pouvez écrire :
  @buttons[0].clicked.connect

• Dans la bibliothèque standard ajouté modèle zoneinfo, incluant des informations de la base de données des fuseaux horaires IANA.

  >>> from zoneinfo import ZoneInfo
  >>> from datetime import datetime, timedelta
  >>> # Heure d'été
  >>> dt = datetime(2020, 10, 31, 12, tzinfo=ZoneInfo(«America\/Los_Angeles»))
  >>> print(dt)
  2020-10-31 12:00:00-07:00

  >>> dt.tzname()
  ‘PDT’

  >>> # Heure standard
  >>> dt += timedelta(days=7)
  >>> print(dt)
  2020-11-07 12:00:00-08:00

  >>> print(dt.tzname())
  PST

• Un module graphlib a été ajouté, qui réalisée prend en charge le tri topologique des graphes.
• Des nouvelles méthodes pour supprimer des préfixes et des suffixes de chaînes — str.removeprefix(prefix) et str.removesuffix(suffix). Ces méthodes ont été ajoutées aux objets str, bytes, bytearray et collections.UserString.

  >>> s = «FooBar»
  >>> s.removeprefix(«Foo»)
  ‘Bar’

• Utilisé un nouveau parseur PEG (Parsing Expression Grammar), qui remplace le parseur LL(1). L'utilisation du nouveau parseur a permis d'éliminer certaines «ruses» utilisées pour contourner les limitations de LL(1), réduisant ainsi considérablement le temps de maintenance du parseur. En termes de performance, le nouveau parseur est à peu près au même niveau que le précédent, mais le dépasse sur le plan de la flexibilité, ce qui permet plus de liberté dans la conception de nouvelles fonctionnalités du langage. Le code de l'ancien parseur est toujours conservé et peut être réactivé à l'aide du drapeau «-X oldparser» ou de la variable d'environnement «PYTHONOLDPARSER=1», mais sera supprimé dans la version 3.10.
• Fournie la possibilité pour les méthodes d'extensions C d'accéder à l'état des modules dans lesquels elles sont définies en utilisant la déréférenciation directe des pointeurs plutôt qu'en recherchant l'état du module à l'aide de la fonction PyState_FindModule. Ce changement permet d'augmenter la performance des modules C en réduisant ou en éliminant complètement les frais généraux liés à la vérification de l'état du module. Pour associer un module à une classe, une fonction C PyType_FromModuleAndSpec() est proposée, pour obtenir le module et son état, les fonctions C PyType_GetModule() et PyType_GetModuleState(), et pour donner à la méthode accès à la classe dans laquelle elle est définie, la fonction C PyCMethod et le flag METH_METHOD.
• Le ramasse-miettes libéré de la blocage des collections comprenant des objets réanimés, qui restent accessibles de l'extérieur après le lancement du finalisateur.
• Méthode ajoutée os.pidfd_openpermettant d'utiliser le sous-système noyau Linux "pidfd" pour gérer le problème de réutilisation de PID (pidfd est lié à un processus spécifique et ne change pas, tandis que le PID peut être affecté à un autre processus après la fin du processus actuel associé à ce PID).
• Le support de la spécification Unicode a été mis à jour vers la version 13.0.0.
• Corrigé fuite de mémoire lors de la réinitialisation de l'interpréteur Python dans un même processus.
• Une optimisation des performances des types intégrés range, tuple, set, frozenset, list et dict a été réalisée grâce à l'application du protocole d'appel rapide Vectorcall pour un accès plus rapide aux objets écrits en C. Modules _abc, audioop, _bz2, _codecs, _contextvars, _crypt, _functools, _json, _locale, operator, resource, time et _weakref traduits pour un chargement avec
• initialisation en plusieurs étapes Les modules de la bibliothèque standard audioop, ast, grp, _hashlib, pwd, _posixsubprocess, random, select, struct, termios et zlib ont été traduits pour utiliser une ABI.
• stable limitée , qui résout le problème de compatibilité des builds de modules d'extension pour différentes versions de Python (lors de la mise à jour de la version, il n'est pas nécessaire de reconstruire les modules d'extension, et les modules compilés pour 3.9 pourront fonctionner dans la branche 3.10).Dans le module asyncio, en raison de problèmes de sécurité potentiels, le support du paramètre reuse_address a été interrompu (l'utilisation de SO_REUSEADDR pour UDP sous Linux permet à différents processus de relier des sockets d'écoute à un port UDP).
• De nouvelles optimisations ont été ajoutées, par exemple, la performance des gestionnaires de signaux dans des applications multithreads a été améliorée, la vitesse d'exécution du module subprocess dans un environnement FreeBSD a été augmentée et l'attribution de variables temporaires a été accélérée (l'affectation d'une variable dans l'expression "for y in [expr]" n'est désormais pas moins performante que l'expression "y = expr"). Dans l'ensemble, la plupart des tests
• montre une diminution des performances par rapport à la branche 3.8 (l'accélération est observée uniquement dans les tests write_local et write_deque): montrent Version Python 3.4 3.5 3.6 3.7 3.8 3.9

  Accès à la lecture de variables et d'attributs:
  ————— — — — — — —

  read_local 7.1 7.1 5.4 5.1 3.9 4.0
  read_nonlocal 7.1 8.1 5.8 5.4 4.4 4.8
  read_global 15.5 19.0 14.3 13.6 7.6 7.7
  read_builtin 21.1 21.6 18.5 19.0 7.5 7.7
  lire_builtin 21.1 21.6 18.5 19.0 7.5 7.7
  lire_variable_de_classe 25.6 26.5 20.7 19.5 18.4 18.6
  lire_variable_d_instance 22.8 23.5 18.8 17.1 16.4 20.1
  lire_instancevariable 32.4 33.1 28.0 26.3 25.4 27.7
  lire_instancevariable_slots 27.8 31.3 20.8 20.8 20.2 24.5
  lire_namedtuple 73.8 57.5 45.0 46.8 18.4 23.2
  lire_méthode_liee 37.6 37.9 29.6 26.9 27.7 45.9

  Accès en écriture aux variables et attributs :
  écrire_local 8.7 9.3 5.5 5.3 4.3 4.2
  écrire_nonlocal 10.5 11.1 5.6 5.5 4.7 4.9
  écrire_global 19.7 21.2 18.0 18.0 15.8 17.2
  écrire_variable_de_classe 92.9 96.0 104.6 102.1 39.2 43.2
  écrire_instancevariable 44.6 45.8 40.0 38.9 35.5 40.7
  écrire_instancevariable_slots 35.6 36.1 27.3 26.6 25.7 27.7

  Accès en lecture à la structure de données :
  lire_liste 24.2 24.5 20.8 20.8 19.0 21.1
  lire_deque 24.7 25.5 20.2 20.6 19.8 21.6
  lire_dictionnaire 24.3 25.7 22.3 23.0 21.0 22.5
  lire_strdict 22.6 24.3 19.5 21.2 18.9 21.6

  Accès en écriture à la structure de données :
  écrire_liste 27.1 28.5 22.5 21.6 20.0 21.6
  écrire_deque 28.7 30.1 22.7 21.8 23.5 23.2
  écrire_dictionnaire 31.4 33.3 29.3 29.2 24.7 27.8
  écrire_strdict 28.4 29.9 27.5 25.2 23.1 29.8

  Opérations de pile (ou de file) :
  ajouter_supprimer_liste 93.4 112.7 75.4 74.2 50.8 53.9
  ajouter_supprimer_deque 43.5 57.0 49.4 49.2 42.5 45.5
  ajouter_supprimer_gauche_deque 43.7 57.3 49.7 49.7 42.8 45.5

  Chronométrage de la boucle :
  frais_de_boucle 0.5 0.6 0.4 0.3 0.3 0.3

• la méthode non standard de nombreuses fonctions et méthodes Python 2.7, qui avaient précédemment été marquées comme obsolètes et dans la dernière version avaient entraîné l'émission d'un avertissement DeprecationWarning, y compris la méthode unescape() dans html.parser.HTMLParser,
  tostring() et fromstring() dans array.array, isAlive() dans threading.Thread, getchildren() et getiterator() dans ElementTree, sys.getcheckinterval(), sys.setcheckinterval(), asyncio.Task.current_task(), asyncio.Task.all_tasks(), base64.encodestring() et base64.decodestring().

Source : opennet.ru