Les nouveautés de Python 3.10
*****************************

Rédacteur:
   *Pablo Galindo Salgado*

This article explains the new features in Python 3.10, compared to
3.9. Python 3.10 was released on October 4, 2021. For full details,
see the changelog.


Résumé – Points forts de la publication
=======================================

Nouvelles fonctionnalités de syntaxe :

* **PEP 634**, Filtrage par motifs structurels : spécification ;

* **PEP 635**, Filtrage par motifs structurels : motivation et
  justification ;

* **PEP 636**, Filtrage par motifs structurels : tutoriel ;

* bpo-12782, Les gestionnaires de contextes entre parenthèses sont
  maintenant autorisés.

Nouvelles fonctionnalités dans la bibliothèque standard :

* **PEP 618**, ajout de la vérification optionnelle de taille dans
  "zip".

Améliorations de l'interpréteur :

* **PEP 626**, numéros de lignes précis pour le débogage et les autres
  outils.

Nouvelles fonctionnalités de typage :

* **PEP 604**, autorise l'écriture d'union de types sous la forme X |
  Y ;

* **PEP 612**, variables de spécification de paramètres.

* **PEP 613**, alias de types explicites ;

* **PEP 647**, User-Defined Type Guards

Obsolescences, retraits ou restrictions :

* **PEP 644**, mise à jour de la version minimale d'*OpenSSL* à 1.1.1
  ;

* **PEP 632**, obsolescence du module "distutils" ;

* **PEP 623**, obsolescence et préparation du retrait du membre "wstr"
  de "PyUnicodeObject" ;

* **PEP 624**, retrait des API d'encodage "Py_UNICODE" ;

* **PEP 597**, ajout de l'"EncodingWarning" optionnel


Nouvelles fonctionnalités
=========================


Gestionnaires de contextes entre parenthèses
--------------------------------------------

Il est maintenant possible de mettre les gestionnaires de contexte
entre parenthèses pour les répartir sur plusieurs lignes. Ceci permet
le formatage d'une longue série de gestionnaires de contexte sur
plusieurs lignes comme ce qui était préalablement possible avec les
instructions d'importation. Par exemple, tous ces blocs sont
maintenant valides :

   with (CtxManager() as example):
       ...

   with (
       CtxManager1(),
       CtxManager2()
   ):
       ...

   with (CtxManager1() as example,
         CtxManager2()):
       ...

   with (CtxManager1(),
         CtxManager2() as example):
       ...

   with (
       CtxManager1() as example1,
       CtxManager2() as example2
   ):
       ...

il est aussi possible d'utiliser une virgule en fin de ligne à la fin
du groupe entre parenthèses :

   with (
       CtxManager1() as example1,
       CtxManager2() as example2,
       CtxManager3() as example3,
   ):
       ...

Cette nouvelle syntaxe utilise la capacité *non-LL(1)* du nouvel
analyseur syntaxique. Voir **PEP 617** pour plus de détails.

(contribution de *Guido van Rossum*, *Pablo Galindo* et *Lysandros
Nikolaou* dans bpo-12782 et bpo-40334).


Meilleurs messages d'erreurs
----------------------------


"SyntaxError"
~~~~~~~~~~~~~

Pendant l'analyse syntaxique de code qui contient des parenthèses ou
autres balises ouvrantes et fermantes, l'interpréteur inclut
maintenant l'emplacement de la balise ou parenthèse non fermée plutôt
que d'afficher *SyntaxError: unexpected EOF while parsing* ou
d'indiquer un emplacement incorrect. Par exemple, considérez le code
suivant (remarquez l'accolade "'{'" non-fermée) :

   expected = {9: 1, 18: 2, 19: 2, 27: 3, 28: 3, 29: 3, 36: 4, 37: 4,
               38: 4, 39: 4, 45: 5, 46: 5, 47: 5, 48: 5, 49: 5, 54: 6,
   some_other_code = foo()

Les versions précédentes de l’interpréteur indiquaient des
emplacements qui portaient à confusion pour l'erreur de syntaxe :

   File "example.py", line 3
       some_other_code = foo()
                       ^
   SyntaxError: invalid syntax

mais dans Python 3.10, une erreur plus informative est levée :

   File "example.py", line 1
       expected = {9: 1, 18: 2, 19: 2, 27: 3, 28: 3, 29: 3, 36: 4, 37: 4,
                  ^
   SyntaxError: '{' was never closed

De façon similaire, les erreurs impliquant des chaînes littérales non-
fermées (avec simples ou triples apostrophes) pointent maintenant vers
le début de la chaîne plutôt de mentionner la fin de ligne ou la fin
du fichier.

Ces améliorations sont inspirées par un travail préalable sur
l'interpréteur *PyPy*

(contribution de *Pablo Galindo* dans bpo-42864 et *Batuhan Taskaya*
dans bpo-40176).

Les exceptions "SyntaxError" levées par l'interpréteur soulignent
maintenant toute la portée de l'expression qui constitue l'erreur de
syntaxe plutôt que seulement la position où le problème a été détecté.
De cette façon, plutôt que d'afficher (avant Python 3.10) :

   >>> foo(x, z for z in range(10), t, w)
     File "<stdin>", line 1
       foo(x, z for z in range(10), t, w)
              ^
   SyntaxError: Generator expression must be parenthesized

Python 3.10 affiche maintenant l'exception comme ceci :

   >>> foo(x, z for z in range(10), t, w)
     File "<stdin>", line 1
       foo(x, z for z in range(10), t, w)
              ^^^^^^^^^^^^^^^^^^^^
   SyntaxError: Generator expression must be parenthesized

Cette amélioration est une contribution de *Pablo Galindo* dans
bpo-43914.

Un nombre considérable de nouveaux messages spécialisés pour les
exceptions "SyntaxError" a été incorporé. Certains des plus notables
sont :

* ":" manquant avant les blocs :

     >>> if rocket.position > event_horizon
       File "<stdin>", line 1
         if rocket.position > event_horizon
                                           ^
     SyntaxError: expected ':'

  (Contributed by Pablo Galindo in bpo-42997.)

* Les *n*-uplets sans parenthèses dans les cibles de compréhensions :

     >>> {x,y for x,y in zip('abcd', '1234')}
       File "<stdin>", line 1
         {x,y for x,y in zip('abcd', '1234')}
          ^
     SyntaxError: did you forget parentheses around the comprehension target?

  (Contributed by Pablo Galindo in bpo-43017.)

* virgules manquantes dans les littéraux de collections et entre les
  expressions ; :

     >>> items = {
     ... x: 1,
     ... y: 2
     ... z: 3,
       File "<stdin>", line 3
         y: 2
            ^
     SyntaxError: invalid syntax. Perhaps you forgot a comma?

  (Contributed by Pablo Galindo in bpo-43822.)

* types multiples d'"Exception" sans parenthèses :

     >>> try:
     ...     build_dyson_sphere()
     ... except NotEnoughScienceError, NotEnoughResourcesError:
       File "<stdin>", line 3
         except NotEnoughScienceError, NotEnoughResourcesError:
                ^
     SyntaxError: multiple exception types must be parenthesized

  (Contributed by Pablo Galindo in bpo-43149.)

* ":" et valeurs manquantes dans les littéraux de dictionnaires :

     >>> values = {
     ... x: 1,
     ... y: 2,
     ... z:
     ... }
       File "<stdin>", line 4
         z:
          ^
     SyntaxError: expression expected after dictionary key and ':'

     >>> values = {x:1, y:2, z w:3}
       File "<stdin>", line 1
         values = {x:1, y:2, z w:3}
                             ^
     SyntaxError: ':' expected after dictionary key

  (Contributed by Pablo Galindo in bpo-43823.)

* blocs "try" sans blocs "except" ou "finally" :

     >>> try:
     ...     x = 2
     ... something = 3
       File "<stdin>", line 3
         something  = 3
         ^^^^^^^^^
     SyntaxError: expected 'except' or 'finally' block

  (Contributed by Pablo Galindo in bpo-44305.)

* utilisation de "=" au lieu de "==" dans les comparaisons :

     >>> if rocket.position = event_horizon:
       File "<stdin>", line 1
         if rocket.position = event_horizon:
                            ^
     SyntaxError: cannot assign to attribute here. Maybe you meant '==' instead of '='?

  (Contributed by Pablo Galindo in bpo-43797.)

* utilisation de "*" dans les chaînes formatées (*f-strings*) :

     >>> f"Black holes {*all_black_holes} and revelations"
       File "<stdin>", line 1
         (*all_black_holes)
          ^
     SyntaxError: f-string: cannot use starred expression here

  (Contributed by Pablo Galindo in bpo-41064.)


"IndentationError"
~~~~~~~~~~~~~~~~~~

Plusieurs exceptions "IndentationError" ont maintenant plus de
contexte concernant le genre de bloc qui attendait une indentation.
Ceci inclut l'emplacement de l'instruction :

   >>> def foo():
   ...    if lel:
   ...    x = 2
     File "<stdin>", line 3
       x = 2
       ^
   IndentationError: expected an indented block after 'if' statement in line 2


"AttributeError"
~~~~~~~~~~~~~~~~

When printing "AttributeError", "PyErr_Display()" will offer
suggestions of similar attribute names in the object that the
exception was raised from:

   >>> collections.namedtoplo
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   AttributeError: module 'collections' has no attribute 'namedtoplo'. Did you mean: namedtuple?

(contribution de *Pablo Galindo* dans bpo-38530).

Avertissement:

  Notice this won't work if "PyErr_Display()" is not called to display
  the error which can happen if some other custom error display
  function is used. This is a common scenario in some REPLs like
  IPython.


"NameError"
~~~~~~~~~~~

When printing "NameError" raised by the interpreter, "PyErr_Display()"
will offer suggestions of similar variable names in the function that
the exception was raised from:

   >>> schwarzschild_black_hole = None
   >>> schwarschild_black_hole
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   NameError: name 'schwarschild_black_hole' is not defined. Did you mean: schwarzschild_black_hole?

(contribution de *Pablo Galindo* dans bpo-38530).

Avertissement:

  Notice this won't work if "PyErr_Display()" is not called to display
  the error, which can happen if some other custom error display
  function is used. This is a common scenario in some REPLs like
  IPython.


PEP 626 : numéros de lignes précis pour le débogage et les autres outils
------------------------------------------------------------------------

La PEP 626 apporte des numéros de lignes plus précis pour le débogage,
le profilage et les outils de mesure de couverture. Les événements de
traçage, avec les numéros de ligne corrects, sont générés pour toutes
les lignes de code exécutées et seulement pour celles-ci.

The "f_lineno" attribute of frame objects will always contain the
expected line number.

The "co_lnotab" attribute of code objects is deprecated and will be
removed in 3.12. Code that needs to convert from offset to line number
should use the new "co_lines()" method instead.


PEP 634 : filtrage par motifs structurels
-----------------------------------------

Le filtrage par motifs a été ajouté sous la forme d'une instruction
*match* et d'instructions *case* pour les motifs avec des actions
associées. Les motifs filtrent des séquences, des dictionnaires, des
types de données et des instances de classes. Le filtrage par motifs
permet aux programmes d'extraire de l'information de types de données
complexes, faire du branchement selon la structure des données et
réaliser des actions spécifiques en fonction des différentes formes
des données.


Syntaxe et opérations
~~~~~~~~~~~~~~~~~~~~~

La syntaxe générique du filtrage par motifs est :

   match subject:
       case <pattern_1>:
           <action_1>
       case <pattern_2>:
           <action_2>
       case <pattern_3>:
           <action_3>
       case _:
           <action_wildcard>

Une instruction *match* prend une expression et compare successivement
sa valeur à différents filtres qui sont donnés comme un ou plusieurs
blocs *case*. Plus précisément, le filtrage par motifs s'effectue par
:

1. l'utilisation de données qui ont un type et une forme (ici
   "subject") ;

2. l'évaluation de "subject" dans une instruction "match" ;

3. l'application de chaque filtre sur "subject" dans des instructions
   "case" de haut en bas jusqu'à ce qu'un appariement soit confirmé ;

4. l’exécution de l'action associée au filtre s'il y a appariement ;

5. s'il n'y a aucun appariement et que le dernier "case" est un filtre
   *attrape-tout* "_", l'action correspondante est exécutée. S'il n'y
   a aucun appariement ni filtre attrape-tout, le bloc "match"
   n'effectue aucune opération.


Approche déclarative
~~~~~~~~~~~~~~~~~~~~

Le filtrage par motifs est peut-être connu des lecteurs par
l'intermédiaire des langages *C*, *Java* ou *JavaScript* (et plusieurs
autres langages), avec l'appariement simple d'un sujet (objet de
données) à un littéral (filtre) avec l'instruction "switch". Souvent,
l'instruction "switch" est utilisée pour comparer des objets ou
expressions à des instructions "case" qui contiennent des littéraux.

Des exemples plus puissants de filtrage par motifs sont présents dans
des langages tels que *Scala* et *Elixir*. Avec le filtrage par motifs
structurels, l'approche est « déclarative » et énonce les conditions
(les motifs) pour apparier les données.

Bien qu'une série d'instructions « impératives » utilisant des
instructions « if » imbriquées puisse être utilisée pour accomplir
quelque chose de similaire au filtrage par motifs structurels, ceci
est moins clair que l'approche « déclarative ». Cette dernière énonce
les conditions à remplir pour réaliser un appariement grâce à ses
filtres sur des motifs explicites. Bien que le filtrage par motifs
structurels puisse être utilisé dans sa forme la plus simple pour
comparer une variable à un littéral dans une instruction "case", son
intérêt réel en Python réside dans son traitement du sujet selon son
type et sa forme.


Filtre simple : apparier à un littéral
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Regardons cet exemple en tant que filtrage par motif dans sa forme la
plus simple : une valeur, le sujet, est comparée à (ou « filtrée par
») plusieurs littéraux, les motifs. Dans l'exemple ci-dessous,
"status" est le sujet de l'instruction "match". Les filtres sont
chacune des instructions "case", où les littéraux représentent les
codes de status des requêtes. Les actions associées au "case" sont
exécutés suite à un appariement :

   def http_error(status):
       match status:
           case 400:
               return "Bad request"
           case 404:
               return "Not found"
           case 418:
               return "I'm a teapot"
           case _:
               return "Something's wrong with the internet"

Si on passe 418 à "status" dans la fonction ci-haut, elle renvoie
""I'm a teapot"". Avec 500, l'instruction "case" qui contient "_"
apparie comme attrape-tout et la fonction renvoie ""Something's wrong
with the internet"". Prenez note que dans le dernier bloc, le nom de
variable, "_" agit comme un *attrape-tout* et garantit que le sujet
sera toujours apparié. L'utilisation de "_" est optionnelle.

Vous pouvez combiner plusieurs littéraux dans un seul filtre en
utilisant "|" (qui se lit « ou ») :

   case 401 | 403 | 404:
       return "Not allowed"


Comportement sans l'attrape-tout
""""""""""""""""""""""""""""""""

Modifions l'exemple ci-haut en enlevant le dernier bloc "case". Il
devient :

   def http_error(status):
       match status:
           case 400:
               return "Bad request"
           case 404:
               return "Not found"
           case 418:
               return "I'm a teapot"

Sans l'utilisation de "_" dans une instruction "case", il est possible
de ne pas avoir d'appariement. Dans ce cas, il ne se passe rien. Par
exemple, si 500 est passé à "status", aucune opération n'est
effectuée.


Filtres avec un littéral et une variable
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Les motifs des filtres peuvent prendre une forme similaire aux
affectations multiples et un filtre peut être utilisé pour lier plus
d'une variable. Dans cet exemple, un point peut être dissocié entre
son abscisse et son ordonnée :

   # point is an (x, y) tuple
   match point:
       case (0, 0):
           print("Origin")
       case (0, y):
           print(f"Y={y}")
       case (x, 0):
           print(f"X={x}")
       case (x, y):
           print(f"X={x}, Y={y}")
       case _:
           raise ValueError("Not a point")

Le motif du premier filtre comporte deux littéraux, "(0, 0)", et peut
être vu comme une extension du filtre sur un littéral montré plus
haut. Les motifs des deux filtres suivants regroupent un littéral et
une variable. De plus, la variable est liée à la valeur provenant du
sujet ("point"). Le motif du quatrième filtre capture deux valeurs, ce
qui le rend conceptuellement similaire à l'affectation multiple : "(x,
y) = point".


Filtres et classes
~~~~~~~~~~~~~~~~~~

If you are using classes to structure your data, you can use as a
pattern the class name followed by an argument list resembling a
constructor. This pattern has the ability to capture instance
attributes into variables:

   class Point:
       def __init__(self, x, y):
           self.x = x
           self.y = y

   def location(point):
       match point:
           case Point(x=0, y=0):
               print("Origin is the point's location.")
           case Point(x=0, y=y):
               print(f"Y={y} and the point is on the y-axis.")
           case Point(x=x, y=0):
               print(f"X={x} and the point is on the x-axis.")
           case Point():
               print("The point is located somewhere else on the plane.")
           case _:
               print("Not a point")


Filtres avec arguments positionnels
"""""""""""""""""""""""""""""""""""

Vous pouvez utiliser les arguments positionnels avec un certain nombre
de classes natives qui définissent l'ordre de leurs attributs,
notamment les classes de données (*dataclasses*). Vous pouvez aussi
spécifier la position des attributs quand ils sont utilisés dans les
filtres en définissant l'attribut spécial "__match_args__" dans vos
classes. Par exemple, le mettre à "("x", "y")" rend tous les filtres
ci-dessous équivalents (en particulier, tous provoquent la liaison de
l'attribut "y" à la variable "var") :

   Point(1, var)
   Point(1, y=var)
   Point(x=1, y=var)
   Point(y=var, x=1)


Filtres imbriqués
~~~~~~~~~~~~~~~~~

Les filtres peuvent être imbriqués de façon arbitraire. Par exemple,
si nous avons une courte liste de points, elle peut être appariée
comme ceci :

   match points:
       case []:
           print("No points in the list.")
       case [Point(0, 0)]:
           print("The origin is the only point in the list.")
       case [Point(x, y)]:
           print(f"A single point {x}, {y} is in the list.")
       case [Point(0, y1), Point(0, y2)]:
           print(f"Two points on the Y axis at {y1}, {y2} are in the list.")
       case _:
           print("Something else is found in the list.")


Filtres complexes et attrape-tout
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Jusqu'à maintenant, les exemples ont utilisé "_" seul dans la dernière
instruction "case". Un attrape-tout peut être utilisé dans un filtre
plus complexe tel que "('error', code, _)". Par exemple :

   match test_variable:
       case ('warning', code, 40):
           print("A warning has been received.")
       case ('error', code, _):
           print(f"An error {code} occurred.")

Dans l'exemple précédent, "test_variable" s'apparie à "('error', code,
100)" et à "('error', code, 800)".


Garde
~~~~~

On peut ajouter une clause "if" à un filtre, ce qu'on appelle une «
garde ». Si la garde s'évalue à faux, "match" poursuit avec la
tentative d'appariement du prochain bloc "case". Notez que la capture
de valeur se produit avant l'évaluation de la garde :

   match point:
       case Point(x, y) if x == y:
           print(f"The point is located on the diagonal Y=X at {x}.")
       case Point(x, y):
           print(f"Point is not on the diagonal.")


Autres fonctionnalités importantes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Plusieurs autres fonctionnalités importantes :

* Comme dans les affectations multiples, les motifs de filtres qui
  sont des *n*-uplets ou des listes sont totalement équivalents et
  autorisent tous les types de séquences. Techniquement, le sujet doit
  être une séquence. Ainsi, exception importante, les filtres
  n'autorisent pas les itérateurs. Aussi, pour prémunir d'une erreur
  commune, les filtres de séquences n'autorisent pas les chaînes ;

* les filtres de séquence peuvent faire intervenir l'affectation
  étoilée : "[x, y, *reste]" ou "(x, y, *reste)" ont le même sens que
  dans une affectation avec "=". Le nom de variable après l'étoile
  peut aussi être l'attrape-tout "_". Ainsi, "(x, y, *_)" est un motif
  de filtre qui reconnaît les séquences à deux éléments ou plus, en
  capturant les deux premiers et en ignorant le reste ;

* il existe les filtres d'association, qui ressemblent syntaxiquement
  aux dictionnaires. Par exemple, le filtre "{"bande_passante": b,
  "latence": l}" extrait les valeurs des clés ""bande_passante"" et
  ""latence"" dans un dictionnaire. Contrairement aux filtres de
  séquence, les clés absentes du filtre sont ignorées et le filtre
  réussit tout de même. L'affectation double-étoilée ("**reste")
  fonctionne aussi (cependant, "**_" serait redondant et n'est donc
  pas permis) ;

* on peut capturer la valeur d'une partie du motif d'un filtre avec le
  mot-clé "as", par exemple :

     case (Point(x1, y1), Point(x2, y2) as p2): ...

  Ceci lie "x1", "y1", "x2", "y2" comme attendu sans la clause "as",
  et lie "p2" à l’entièreté du second élément du sujet ;

* la plupart des littéraux sont comparés par égalité. Néanmoins, les
  singletons "True", "False" et "None" sont comparés par identité ;

* les filtres peuvent contenir des noms qui se réfèrent à des
  constantes. Ces noms doivent impérativement être qualifiés (contenir
  au moins un point) pour ne pas être interprétés comme des variables
  de capture :

     from enum import Enum
     class Color(Enum):
         RED = 0
         GREEN = 1
         BLUE = 2

     color = Color.GREEN
     match color:
         case Color.RED:
             print("I see red!")
         case Color.GREEN:
             print("Grass is green")
         case Color.BLUE:
             print("I'm feeling the blues :(")

Pour la spécification complète, voir la **PEP 634**. La motivation et
la justification des choix sont dans la **PEP 635**, et un tutoriel
plus élaboré se trouve dans la **PEP 636**.


"EncodingWarning" et option "encoding="locale"" optionnels
----------------------------------------------------------

The default encoding of "TextIOWrapper" and "open()" is platform and
locale dependent. Since UTF-8 is used on most Unix platforms, omitting
"encoding" option when opening UTF-8 files (e.g. JSON, YAML, TOML,
Markdown) is a very common bug. For example:

   # BUG: "rb" mode or encoding="utf-8" should be used.
   with open("data.json") as f:
       data = json.load(f)

Pour trouver ce type de bogue, un "EncodingWarning" optionnel a été
ajouté. Il est levé quand "sys.flags.warn_default_encoding" est "True"
et quand l'encodage utilisé est celui défini par les paramètres
régionaux.

L'option "-X warn_default_encoding" et la variable d’environnement
"PYTHONWARNDEFAULTENCODING" ont été ajoutées pour activer cet
avertissement.

Voir Encodage de texte pour plus d'informations.


Nouvelles fonctionnalités reliées aux indications de types
==========================================================

Cette section couvre les changements majeurs touchant le module
"typing" et les indications de types de style **PEP 484**.


PEP 604 : nouvel opérateur d'union de types
-------------------------------------------

Un nouvel opérateur d'union de types a été ajouté. Il permet la
syntaxe "X | Y". Ceci offre une façon plus propre d'exprimer « soit le
type X, soit le type Y » plutôt que d'utiliser "typing.Union", en
particulier pour les indications de types.

Dans les versions précédentes de Python, pour appliquer une indication
de type à des fonctions qui acceptent des arguments de plusieurs
types, "typing.Union" était utilisée :

   def square(number: Union[int, float]) -> Union[int, float]:
       return number ** 2

Les indications de type peuvent maintenant être écrites de façon plus
courte :

   def square(number: int | float) -> int | float:
       return number ** 2

Cette nouvelle syntaxe est aussi acceptée comme le second argument de
"isinstance()" et de "issubclass()" :

   >>> isinstance(1, int | str)
   True

Voir Type Union et la **PEP 604** pour plus de détails

(contribution de *Maggie Moss* et *Philippe Prados* dans bpo-41428,
avec ajouts par *Yurii Karabas* et *Serhiy Storchaka* dans bpo-44490).


PEP 612 : variables de spécification de paramètres
--------------------------------------------------

Deux nouvelles options ont été ajoutées au module "typing" pour
améliorer l'information donnée aux vérificateurs de types statiques
pour les "Callable" définis dans la **PEP 484**.

La première est la variable de spécification de paramètre. Elles sont
utilisées pour transférer le type d'un appelable à un autre – un
patron de conception souvent utilisé dans les fonctions d'ordre
supérieur et dans les décorateurs. Des exemples d'utilisation se
trouvent dans "typing.ParamSpec". Préalablement, il n'y avait pas de
façon facile pour annoter les dépendances de types des paramètres de
manière aussi précise.

La seconde option est le nouvel opérateur "Concatenate". Il est
utilisé en conjonction avec les variables de spécification de
paramètres pour annoter les types d'un appelable d'ordre supérieur qui
ajoute ou retire des paramètres à un autre appelable. Des exemples
d'utilisation se trouvent dans "typing.Concatenate".

Voir "typing.Callable", "typing.ParamSpec", "typing.Concatenate",
"typing.ParamSpecArgs", "typing.ParamSpecKwargs" et la **PEP 612**
pour plus de détails

(contribution de *Ken Jin* dans bpo-41559, avec améliorations mineures
par *Jelle Zijlstra* dans bpo-43783 ; PEP écrite par *Mark Mendoza*).


PEP 613 : "TypeAlias"
---------------------

La **PEP 484** a ajouté le concept d'alias de types, en exigeant
seulement qu'ils soient des assignations non-annotées au niveau du
module. Cette simplicité rendait parfois difficile pour les
vérificateurs de types de distinguer entre un alias de type et une
affectation ordinaire, en particulier quand des références
postérieures ou des types invalides étaient impliqués. Comparez :

   StrCache = 'Cache[str]'  # a type alias
   LOG_PREFIX = 'LOG[DEBUG]'  # a module constant

Now the "typing" module has a special value "TypeAlias" which lets you
declare type aliases more explicitly:

   StrCache: TypeAlias = 'Cache[str]'  # a type alias
   LOG_PREFIX = 'LOG[DEBUG]'  # a module constant

Voir la **PEP 613** pour plus de détails.

(contribution de *Mikhail Golubev* dans bpo-41923).


PEP 647 : gardes de type définies par l'utilisateur
---------------------------------------------------

"TypeGuard" has been added to the "typing" module to annotate type
guard functions and improve information provided to static type
checkers during type narrowing.  For more information, please see
"TypeGuard"'s documentation, and **PEP 647**.

(contribution de *Ken Jin* et *Guido van Rossum* dans bpo-43766. PEP
écrit par *Eric Traut*).


Autres changements au langage
=============================

* Le type "int" a une nouvelle méthode "int.bit_count()", qui renvoie
  le nombre de chiffres uns dans l’expansion binaire d'un entier
  donné, aussi connue sous le nom de chiffre de population
  (*population count*) (contribution de *Niklas Fiekas* dans
  bpo-29882).

* Les vues renvoyées par "dict.keys()", "dict.values()" et
  "dict.items()" ont maintenant toutes un attribut "mapping" qui donne
  un objet "types.MappingProxyType" encapsulant le dictionnaire
  original (contribution de *Dennis Sweeney* dans bpo-40890).

* **PEP 618** : la fonction "zip()" a maintenant un argument optionnel
  "strict", utilisé pour demander que tous les itérables soient de
  même longueur.

* Les fonctions d'extensions et les fonctions natives qui prennent des
  arguments entiers n'acceptent plus les "Decimal", "Fraction" et
  autres objets qui ne peuvent pas être convertis en entiers sans
  perte de précision (par exemple ceux qui ont une méthode "__int__()"
  mais pas une méthode "__index__()") (contribution de *Serhiy
  Storchaka* dans bpo-37999).

* If "object.__ipow__()" returns "NotImplemented", the operator will
  correctly fall back to "object.__pow__()" and "object.__rpow__()" as
  expected. (Contributed by Alex Shkop in bpo-38302.)

* Les expressions d'affectations peuvent maintenant être utilisées
  dans les littéraux d'ensembles, dans les compréhensions d'ensembles
  et dans les indices de séquences (mais pas dans les tranches).

* Les fonctions ont un nouvel attribut "__builtins__" qui est utilisé
  pour repérer les symboles natifs quand la fonction est exécutée,
  plutôt que de regarder dans "__globals__['__builtins__']".
  L'attribut est initialisé à partir de "__globals__["__builtins__"]"
  s'il existe, ou des symboles natifs en cours autrement (contribution
  de *Mark Shannon* dans bpo-42990).

* Deux nouvelles fonctions natives – "aiter()" et "anext()" – ont été
  ajoutées pour fournir les équivalents asynchrones de "iter()" et de
  "next()", respectivement (contribution de *Joshua Bronson*, *Daniel
  Pope* et *Justin Wang* dans bpo-31861).

* Les méthodes statiques ("@staticmethod") et les méthodes de classes
  ("@classmethod") héritent maintenant des attributs de méthodes
  ("__module__", "__name__", "__qualname__", "__doc__",
  "__annotations__") et ont un nouvel attribut "__wrapped__". De plus,
  les méthodes statiques sont maintenant appelables en tant que
  fonctions classiques (contribution de *Victor Stinner* dans
  bpo-43682).

* Les annotations des cibles complexes (toutes cibles autre que
  "simple name" telles que définies dans la **PEP 526**) n'ont plus
  d'effet à l'exécution avec "from __future__ import annotations"
  (contribution de *Batuhan Taskaya* dans bpo-42737).

* Les objets "class" et "module" créent maintenant paresseusement un
  dictionnaire d'annotations vide sur demande. Les dictionnaires
  d'annotations sont stockés dans le "__dict__" de l'objet pour garder
  la retro-compatibilité.  Cela renforce les bonnes pratiques
  relatives à "__annotations__" ; pour plus d'information, voir Bonnes
  pratiques concernant les annotations (contribution de *Larry
  Hastings* dans bpo-43901).

* Les annotations qui contiennent "yield", "yield from", "await" ou
  une expression nommée ne sont plus permises sous "from __future__
  import annotations" à cause de leurs effets secondaires
  (contribution de *Batuhan Taskaya* dans bpo-42725).

* L'utilisation de variables non liées, de "super()" et d'autres
  expressions qui peuvent changer le traitement de la table des
  symboles en tant qu'annotation n'ont plus d'effet sous "from
  __future__ import annotations" (contribution de *Batuhan Taskaya*
  dans bpo-42725).

* Le hachage des valeurs *NaN* des types "float" et "decimal.Decimal"
  dépend maintenant de l'identité de l'objet. Préalablement, cette
  valeur de hachage était toujours "0" alors que les valeurs *NaN* ne
  sont pas égales entre elles. Cela pouvait potentiellement entrainer
  un temps d'exécution quadratique en raison des collisions excessives
  des valeurs de hachage lors de la création de dictionnaires et
  d'ensembles qui contiennent plusieurs *NaN* (contribution de
  *Raymond Hettinger* dans bpo-43475).

* A "SyntaxError" (instead of a "NameError") will be raised when
  deleting the "__debug__" constant.  (Contributed by Donghee Na in
  bpo-45000.)

* Les exceptions "SyntaxError" ont maintenant des attributs
  "end_lineno" et "end_offset". La valeur est "None" quand ils ne
  peuvent pas être déterminés (contribution de *Pablo Galindo* dans
  bpo-43914).


Nouveaux modules
================

* None.


Modules améliorés
=================


"asyncio"
---------

Ajout de la méthode "connect_accepted_socket()" manquante
(contribution d'*Alex Grönholm* dans bpo-41332).


"argparse"
----------

L'expression ""optional arguments"" qui portait à confusion a été
remplacée par ""options"" dans le message d'aide d'"argparse".
Certains tests devront être adaptés s'ils dépendent d'une comparaison
exacte dans la sortie d'aide (contribution de *Raymond Hettinger* dans
bpo-9694).


"array"
-------

La méthode "index()" de la classe "array.array" a maintenant les
paramètres optionnels *start* et *stop* (contribution d'*Anders
Lorentsen* et de *Zackery Spytz* dans bpo-31956).


"asynchat", "asyncore", "smtpd"
-------------------------------

Ces modules ont étés déclarés obsolètes dans leur documentation de
modules depuis Python 3.6. Un "DeprecationWarning" au moment de
l'importation est maintenant ajouté pour ces trois modules.


"base64"
--------

Ajout de "base64.b32hexencode()" et de "base64.b32hexdecode()" pour
prendre en charge l'encodage Base32 avec l'alphabet hexadécimal
étendu.


"bdb"
-----

Ajout de "clearBreakpoints()" pour supprimer tous les points d'arrêt
(contribution d'*Irit Katriel* dans bpo-24160).


"bisect"
--------

Ajout de la possibilité de fournir une fonction "key" aux API dans le
module "bisect" (contribution de *Raymond Hettinger* dans bpo-4356).


"codecs"
--------

Ajout d'une fonction "codecs.unregister()" pour désinscrire une
fonction de recherche de codecs (contribution de *Hai Shi* dans
bpo-41842).


"collections.abc"
-----------------

L'attribut "__args__" des génériques paramétrables de
"collections.abc.Callable" est maintenant cohérent avec
"typing.Callable". Les génériques de "collections.abc.Callable"
aplatissent maintenant les types des paramètres à l'instar de
"typing.Callable". Ceci veut dire que "collections.abc.Callable[[int,
str], str]" aura un attribut "__args__" de valeur "(int, str, str)" ;
auparavant, il aurait été "([int, str], str)". Pour permettre ce
changement, "types.GenericAlias" peut être dérivée, et une sous-classe
sera renvoyée lors de la surcharge  du type
"collections.abc.Callable". Prenez note que "TypeError" sera levée
pour des formes invalides de paramétrisation de
"collections.abc.Callable", ce qui aurait pu passer silencieusement
dans Python 3.9 (contribution de *Ken Jin* dans bpo-42195).


"contextlib"
------------

Ajout d'un gestionnaire de contexte "contextlib.aclosing()" pour
fermer de façon sécurisée les générateurs asynchrones et les objets
représentants des ressources libérées de façon asynchrone
(contribution de *Joongi Kim* et *John Belmonte* dans bpo-41229).

Ajout d'un gestionnaire de contexte pour prendre en charge
"contextlib.nullcontext()" (contribution de *Tom Gringauz* dans
bpo-41543).

Add "AsyncContextDecorator", for supporting usage of async context
managers as decorators.


"curses"
--------

Les fonctions de couleurs étendues ajoutées dans *ncurses* 6.1 sont
utilisées de façon transparente par "curses.color_content()",
"curses.init_color()", "curses.init_pair()" et
"curses.pair_content()". Une nouvelle fonction,
"curses.has_extended_color_support()", indique si la prise en charge
des couleurs étendues est fournie par la bibliothèque *ncurses* sous-
jacente (contribution de *Jeffrey Kintscher* et de *Hans Petter
Jansson* dans bpo-36982).

Les constantes "BUTTON5_*" sont maintenant exposées dans le module
"curses" si elles sont fournies par la bibliothèque *curses* sous-
jacente (contribution de *Zackery Spytz* dans bpo-39273).


"dataclasses"
-------------


"__slots__"
~~~~~~~~~~~

Ajout du paramètre "slots" dans le décorateur
"dataclasses.dataclass()" (contribution de *Yurii Karabas* dans
bpo-42269).


Champs obligatoirement nommés
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Les classes de données ("dataclass") prennent maintenant en charge les
champs obligatoirement nommés dans la méthode "__init__" générée. Il y
a plusieurs façons de spécifier les champs obligatoirement nommés.

Vous pouvez indiquer que tous les champs sont obligatoirement nommés :

   from dataclasses import dataclass

   @dataclass(kw_only=True)
   class Birthday:
       name: str
       birthday: datetime.date

Les paramètres "name" et "birthday" sont tous deux obligatoirement
nommés dans la méthode "__init__" générée.

Pour chaque champ, vous pouvez indiquer s'il est obligatoirement nommé
:

   from dataclasses import dataclass, field

   @dataclass
   class Birthday:
       name: str
       birthday: datetime.date = field(kw_only=True)

Ici, seulement "birthday" est obligatoirement nommé. Si vous assignez
"kw_only" sur un champ particulier, notez qu'il y a des règles
concernant l'ordre des champs puisque les champs obligatoirement
nommés doivent suivre les champs optionnellement nommés. Voir la
documentation de "dataclass" pour plus de détails.

Vous pouvez aussi indiquer que tous les champs qui suivent un marqueur
"KW_ONLY" sont obligatoirement nommés. Ceci sera probablement
l'utilisation la plus commune :

   from dataclasses import dataclass, KW_ONLY

   @dataclass
   class Point:
       x: float
       y: float
       _: KW_ONLY
       z: float = 0.0
       t: float = 0.0

Here, "z" and "t" are keyword-only parameters, while "x" and "y" are
not. (Contributed by Eric V. Smith in bpo-43532.)


"distutils"
-----------

Le paquet "distutil" est entièrement obsolète et sera retiré dans
Python 3.12. Ses fonctionnalités pour spécifier la construction de
paquets sont déjà complètement remplacées par les paquets tierce-
parties  "setuptools" et "packaging". Les autres API régulièrement
utilisées sont disponibles ailleurs dans la bibliothèque standard (tel
que dans "platform", "shutil", "subprocess" ou "sysconfig"). Il n'est
pas prévu de migrer d'autres fonctionnalités de "distutils", aussi les
applications qui utilisent d'autres fonctions du module doivent faire
des copies privées du code. Voir la discussion dans la **PEP 632**.

La commande "bdist_wininst" qui est obsolète depuis Python 3.8 a été
retirée. La commande "bdist_wheel" est maintenant recommandée pour
distribuer des paquets binaires sous Windows (contribution de *Victor
Stinner* dans bpo-42802).


"doctest"
---------

Quand un module ne définit pas "__loader__", "__spec__.loader" est
utilisé (contribution de *Brett Cannon* dans bpo-42133).


"encodings"
-----------

La fonction "encodings.normalize_encoding()" ignore maintenant les
caractères non ASCII (contribution de *Hai Shi* dans bpo-39337).


enum
----

"Enum" "__repr__()" now returns "enum_name.member_name" and
"__str__()" now returns "member_name".  Stdlib enums available as
module constants have a "repr()" of "module_name.member_name".
(Contributed by Ethan Furman in bpo-40066.)

Add "enum.StrEnum" for enums where all members are strings.
(Contributed by Ethan Furman in bpo-41816.)


"fileinput"
-----------

Ajout des paramètres "encoding" et "errors" dans "fileinput.input()"
et dans "fileinput.FileInput" (contribution d'*Inada Naoki* dans
bpo-43712).

"fileinput.hook_compressed()" now returns "TextIOWrapper" object when
*mode* is "r" and file is compressed, like uncompressed files.
(Contributed by Inada Naoki in bpo-5758.)


"faulthandler"
--------------

Le module "faulthandler" détecte maintenant si une erreur fatale s'est
produite pendant un passage du ramasse-miettes (contribution de
*Victor Stinner* dans bpo-44466).


"gc"
----

Ajout de fonctions de rappels d'audit pour "gc.get_objects()",
"gc.get_referrers()" et "gc.get_referents()" (contribution de *Pablo
Galindo* dans bpo-43439).


"glob"
------

Ajout des paramètres "root_dir" et "dir_fd" dans "glob()" et dans
"iglob()" pour permettre la spécification du répertoire racine utilisé
pour la recherche (contribution de *Serhiy Storchaka* dans bpo-38144).


"hashlib"
---------

La version minimale d'*OpenSSL* pour le module "hashlib" est
maintenant 1.1.1 (contribution de *Christian Heimes* dans **PEP 644**
et dans bpo-43669).

Le module *hashlib* offre une prise en charge préliminaire pour
*OpenSSL* 3.0.0 (contribution de *Christian Heimes* dans bpo-38820 et
autres tickets).

Le repli vers la version en pur Python de "pbkdf2_hmac()" est
obsolète. Dorénavant, "PBKDF2-HMAC" n'est disponible que si Python a
été compilé avec la prise en charge d'*OpenSSL* (contribution de
*Christian Heimes* dans bpo-43880).


"hmac"
------

L'implémentation interne du module "hmac" utilise maintenant *HMAC*
d'*OpenSSL* (contribution de *Christian Heimes* dans bpo-40645).


IDLE et "idlelib"
-----------------

IDLE invoque maintenant "sys.excepthook()" (lorsque lancé sans
"'-n'"). Auparavant, les fonctions de rappel définies par
l'utilisateur étaient ignorées (contribution par *Ken Hilton* dans
bpo-43008).

Rearrange the settings dialog.  Split the General tab into Windows and
Shell/Ed tabs.  Move help sources, which extend the Help menu, to the
Extensions tab.  Make space for new options and shorten the dialog.
The latter makes the dialog better fit small screens.  (Contributed by
Terry Jan Reedy in bpo-40468.)  Move the indent space setting from the
Font tab to the new Windows tab.  (Contributed by Mark Roseman and
Terry Jan Reedy in bpo-33962.)

Les changements ci-dessus ont été rétro-portés dans le cadre de la
maintenance de 3.9.

Ajout d'une barre de côté à la console. Déplacement de l'invite de
commande principale (">>>") vers cette barre. Ajout des invites
secondaires ("...") à la barre de côté. Le clic de gauche et le
glisser optionnel sélectionnent une ou plusieurs lignes de texte, tout
comme dans la barre de numéros de ligne de la fenêtre d'édition. Le
clic droit après la sélection de lignes de texte affiche un menu
contextuel pour copier avec invites (*'copy with prompts'*). Ceci
combine les invites de la barre de côté avec le texte sélectionné.
Cette option apparait aussi dans le menu contextuel pour le texte
(contribution de *Tal Einat* dans bpo-37903).

Utilisation d'espaces plutôt que des tabulations pour indenter le code
interactif. Ceci donne au code interactif la « bonne apparence ».
Cette fonctionnalité est fortement corrélée à l'ajout de la barre de
côté de la console (contribution de *Terry Jan Reedy* dans bpo-37892).

Coloration des nouveaux mots clés ad-hoc "match", "case" et "_" dans
les instructions de filtrage par motifs (*pattern matching*). Par
contre, cette coloration n'est pas parfaite et elle sera incorrecte
dans quelques rares cas, y-compris certains "_" dans des instructions
"case" (contribution de Tal Einat dans bpo-44010).

Nouveau dans les versions de maintenance 3.10.

Applique la coloration syntaxique aux fichiers ".pyi" (contribution
d'*Alex Waygood* et de *Terry Jan Reedy* dans bpo-45447).

Include prompts when saving Shell with inputs and outputs.
(Contributed by Terry Jan Reedy in gh-95191.)


"importlib.metadata"
--------------------

Équivalence de fonctionnalités avec "importlib_metadata" 4.6
(historique).

importlib.metadata entry points now provide a nicer experience for
selecting entry points by group and name through a new
importlib.metadata.EntryPoints class. See the Compatibility Note in
the docs for more info on the deprecation and usage.

Added importlib.metadata.packages_distributions() for resolving top-
level Python modules and packages to their
importlib.metadata.Distribution.


"inspect"
---------

Quand un module ne définit pas "__loader__", "__spec__.loader" est
utilisé (contribution de *Brett Cannon* dans bpo-42133).

Add "inspect.get_annotations()", which safely computes the annotations
defined on an object. It works around the quirks of accessing the
annotations on various types of objects, and makes very few
assumptions about the object it examines. "inspect.get_annotations()"
can also correctly un-stringize stringized annotations.
"inspect.get_annotations()" is now considered best practice for
accessing the annotations dict defined on any Python object; for more
information on best practices for working with annotations, please see
Bonnes pratiques concernant les annotations. Relatedly,
"inspect.signature()", "inspect.Signature.from_callable()", and
"inspect.Signature.from_function()" now call
"inspect.get_annotations()" to retrieve annotations. This means
"inspect.signature()" and "inspect.Signature.from_callable()" can also
now un-stringize stringized annotations. (Contributed by Larry
Hastings in bpo-43817.)


itertools
---------

Add "itertools.pairwise()". (Contributed by Raymond Hettinger in
bpo-38200.)


"linecache"
-----------

Quand un module ne définit pas "__loader__", "__spec__.loader" est
utilisé (contribution de *Brett Cannon* dans bpo-42133).


"os"
----

Add "os.cpu_count()" support for VxWorks RTOS. (Contributed by Peixing
Xin in bpo-41440.)

Ajout d'une nouvelle fonction "os.eventfd()" et des fonctions
utilitaires associées pour encapsuler l'appel système "eventfd2" sur
Linux (contribution de *Christian Heimes* dans bpo-41001).

Add "os.splice()" that allows to move data between two file
descriptors without copying between kernel address space and user
address space, where one of the file descriptors must refer to a pipe.
(Contributed by Pablo Galindo in bpo-41625.)

Add "O_EVTONLY", "O_FSYNC", "O_SYMLINK" and "O_NOFOLLOW_ANY" for
macOS. (Contributed by Donghee Na in bpo-43106.)


"os.path"
---------

"os.path.realpath()" accepte maintenant l'argument nommé *strict*.
Lorsqu'il est "True", une "OSError" est levée si le chemin n'existe
pas ou si une boucle de liens symboliques est rencontrée (contribution
de *Barney Gale* dans bpo-43757).


"pathlib"
---------

Add slice support to "PurePath.parents". (Contributed by Joshua Cannon
in bpo-35498.)

Add negative indexing support to "PurePath.parents". (Contributed by
Yaroslav Pankovych in bpo-21041.)

Add "Path.hardlink_to" method that supersedes "link_to()". The new
method has the same argument order as "symlink_to()". (Contributed by
Barney Gale in bpo-39950.)

"pathlib.Path.stat()" et "chmod()" acceptent maintenant l'argument
nommé *follow_symlinks* pour rester cohérent avec les fonctions
correspondantes dans le module "os" (contribution de *Barney Gale*
dans bpo-39906).


"platform"
----------

Add "platform.freedesktop_os_release()" to retrieve operation system
identification from freedesktop.org os-release standard file.
(Contributed by Christian Heimes in bpo-28468.)


"pprint"
--------

"pprint.pprint()" accepte maintenant le nouvel argument nommé
"underscore_numbers" (contribution de *sblondon* dans bpo-42914).

"pprint" peut maintenant afficher élégamment les instances de
"dataclasses.dataclass" (contribution de *Lewis Gaul* dans bpo-43080).


"py_compile"
------------

Ajout de l'option de ligne de commande "--quiet" à l'interface de
"py_compile" (contribution de *Gregory Schevchenko* dans bpo-38731).


"pyclbr"
--------

Add an "end_lineno" attribute to the "Function" and "Class" objects in
the tree returned by "pyclbr.readmodule()" and
"pyclbr.readmodule_ex()".  It matches the existing (start) "lineno".
(Contributed by Aviral Srivastava in bpo-38307.)


"shelve"
--------

The "shelve" module now uses "pickle.DEFAULT_PROTOCOL" by default
instead of "pickle" protocol "3" when creating shelves. (Contributed
by Zackery Spytz in bpo-34204.)


"statistics"
------------

Ajout des fonctions "covariance()", "correlation()" (corrélation de
Pearson) et "linear_regression()" (régression linéaire simple)
(contribution de *Tymoteusz Wołodźko* dans bpo-38490).


"site"
------

Quand un module ne définit pas "__loader__", "__spec__.loader" est
utilisé (contribution de *Brett Cannon* dans bpo-42133).


"socket"
--------

L'exception "socket.timeout" est maintenant un alias de "TimeoutError"
(contribution de *Christian Heimes* dans bpo-42413).

Ajout d'une option pour créer des connecteurs (*socket*) *MPTCP* avec
"IPPROTO_MPTCP" (contribution de *Rui Cunha* dans bpo-43571).

Ajout de l'option "IP_RECVTOS" pour récupérer la valeur des champs
*type of service (ToS)* ou *differentiated services code point
(DSCP/ECN)* (contribution de *Georg Sauthoff* dans bpo-44077).


"ssl"
-----

La version minimale d'*OpenSSL* pour le module "ssl" est maintenant
1.1.1 (contribution de *Christian Heimes* dans **PEP 644** et dans
bpo-43669).

The ssl module has preliminary support for OpenSSL 3.0.0 and new
option "OP_IGNORE_UNEXPECTED_EOF". (Contributed by Christian Heimes in
bpo-38820, bpo-43794, bpo-43788, bpo-43791, bpo-43799, bpo-43920,
bpo-43789, and bpo-43811.)

Les fonctions obsolètes et l'accès aux constantes obsolètes lèvent
maintenant un "DeprecationWarning". "ssl.SSLContext.options" a options
"OP_NO_SSLv2" et "OP_NO_SSLv3" définies par défaut ; par conséquent,
il ne peut pas avertir si l'option est définie de nouveau. La section
obsolescence contient la liste des fonctionnalités obsolètes
(contribution de *Christian Heimes* dans bpo-43880).

La configuration du module "ssl" est plus sécuritaire par défaut. Les
algorithmes de chiffrement sans confidentialité persistante (*forward
secrecy*) et le code d'authentification de message (MAC) *SHA-1* sont
désactivés par défaut. Le niveau 2 de sécurité ne permet pas les clés
faibles de moins de 112 bits pour *RSA*, *DH* et *ECC*. La version
minimale du protocole *TLS* pour "SSLContext" est 1.2. La
configuration est basée sur la recherche de *Hynek Schlawack*
(contribution de *Christian Heimes* dans bpo-43998).

Les protocoles obsolètes *SSL* 3.0, *TLS* 1.0 et *TLS* 1.1 ne sont
plus officiellement pris en charge. Python ne les bloque pas
activement, mais les options de compilation d'*OpenSSL*, les
configurations du système d'exploitation, les rustines des fabricants
et les suites d'algorithmes de chiffrement peuvent empêcher
l’établissement d'une connexion.

Ajout d'un paramètre *timeout* à la fonction
"ssl.get_server_certificate()" (contribution de *Zackery Spytz* dans
bpo-31870).

Le module "ssl" utilise les types du tas et l'initialisation multi-
phase (contribution de *Christian Heimes* dans bpo-42333).

A new verify flag "VERIFY_X509_PARTIAL_CHAIN" has been added.
(Contributed by l0x in bpo-40849.)


"sqlite3"
---------

Ajout d'événements d'audit pour "connect/handle()",
"enable_load_extension()" et "load_extension()" (contribution
d'*Erlend E. Aasland* dans bpo-43762).


"sys"
-----

Ajout de l'attribut "sys.orig_argv" : la liste des arguments de ligne
de commande originalement passée à l'exécutable Python (contribution
de *Victor Stinner* dans bpo-23427).

Ajout de "sys.stdlib_module_names" qui contient la liste des noms des
modules de la bibliothèque standard (contribution de *Victor Stinner*
dans bpo-42955).


"_thread"
---------

"_thread.interrupt_main()" now takes an optional signal number to
simulate (the default is still "signal.SIGINT"). (Contributed by
Antoine Pitrou in bpo-43356.)


"threading"
-----------

Ajout des fonctions "threading.gettrace()" et "threading.getprofile()"
pour récupérer les fonctions assignées par "threading.settrace()" et
"threading.setprofile()" respectivement (contribution de *Mario
Corchero* dans bpo-42251).

Ajout de "threading.__excepthook__" pour permettre la récupération de
"threading.excepthook()" au cas où elle serait affectée à une valeur
incorrecte ou différente (contribution de *Mario Corchero* dans
bpo-42308).


"traceback"
-----------

Les fonctions "format_exception()", "format_exception_only()" et
"print_exception()" peuvent maintenant prendre un objet exception en
argument positionnel (contribution de *Zackery Spytz* et *Matthias
Bussonnier* dans bpo-26389).


"types"
-------

Les classes "types.EllipsisType", "types.NoneType" et
"types.NotImplementedType" sont ajoutées de nouveau. Elles fournissent
un nouvel ensemble de types facilement interprétable par les
vérificateurs de types (contribution de *Bas van Beek* dans
bpo-41810).


"typing"
--------

Pour les changements majeurs, voir Nouvelles fonctionnalités reliées
aux indications de types.

Le comportement de "typing.Literal" a été changé pour être conforme
avec la **PEP 586** et pour correspondre au comportement des
vérificateurs de types statiques défini dans la PEP.

1. "Literal" dé-duplique maintenant les paramètres.

2. La comparaison d'égalité entre objets "Literal" ne tient plus
   compte de l'ordre.

3. Les comparaisons de "Literal" respectent maintenant les types. Par
   exemple, "Literal[0] == Literal[False]" était préalablement évaluée
   à "True". Elle est maintenant "False". Pour prendre en charge ce
   changement, le cache des types de l'implémentation interne peut
   maintenant différencier entre les types.

4. Les objets "Literal" lèvent maintenant une exception "TypeError"
   pendant la comparaison d'égalité si au moins un de leurs paramètres
   n'est pas *hachable*. Notez que déclarer un "Literal" avec des
   paramètres non hachables ne lève pas d'erreur :

      >>> from typing import Literal
      >>> Literal[{0}]
      >>> Literal[{0}] == Literal[{False}]
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: unhashable type: 'set'

(contribution de *Yurii Karabas* dans bpo-42345).

Add new function "typing.is_typeddict()" to introspect if an
annotation is a "typing.TypedDict". (Contributed by Patrick Reader in
bpo-41792.)

Subclasses of "typing.Protocol" which only have data variables
declared will now raise a "TypeError" when checked with "isinstance"
unless they are decorated with "runtime_checkable()".  Previously,
these checks passed silently.  Users should decorate their subclasses
with the "runtime_checkable()" decorator if they want runtime
protocols. (Contributed by Yurii Karabas in bpo-38908.)

Importing from the "typing.io" and "typing.re" submodules will now
emit "DeprecationWarning".  These submodules have been deprecated
since Python 3.8 and will be removed in a future version of Python.
Anything belonging to those submodules should be imported directly
from "typing" instead. (Contributed by Sebastian Rittau in bpo-38291.)


"unittest"
----------

Ajout d'une nouvelle méthode "assertNoLogs()" pour complémenter la
méthode existante "assertLogs()" (contribution de *Kit Yan Choi* dans
bpo-39385).


"urllib.parse"
--------------

Python versions earlier than Python 3.10 allowed using both ";" and
"&" as query parameter separators in "urllib.parse.parse_qs()" and
"urllib.parse.parse_qsl()".  Due to security concerns, and to conform
with newer W3C recommendations, this has been changed to allow only a
single separator key, with "&" as the default.  This change also
affects "cgi.parse()" and "cgi.parse_multipart()" as they use the
affected functions internally.  For more details, please see their
respective documentation. (Contributed by Adam Goldschmidt, Senthil
Kumaran and Ken Jin in bpo-42967.)

The presence of newline or tab characters in parts of a URL allows for
some forms of attacks. Following the WHATWG specification that updates
**RFC 3986**, ASCII newline "\n", "\r" and tab "\t" characters are
stripped from the URL by the parser in "urllib.parse" preventing such
attacks. The removal characters are controlled by a new module level
variable "urllib.parse._UNSAFE_URL_BYTES_TO_REMOVE". (See gh-88048)


"xml"
-----

Ajout d'une classe "LexicalHandler" au module "xml.sax.handler"
(contribution de *Jonathan Gossage* de *Zackery Spytz* dans
bpo-35018).


"zipimport"
-----------

Ajout des méthodes relatives à la **PEP 451** : "find_spec()",
"zipimport.zipimporter.create_module()" et
"zipimport.zipimporter.exec_module()" (contribution de *Brett Cannon*
dans bpo-42131).

Ajout de la méthode "invalidate_caches()" (contribution de *Desmond
Cheong* dans bpo-14678).


Optimisations
=============

* Les constructeurs de "str()", "bytes()" et "bytearray()" sont
  maintenant plus rapides (environ 30—40 % pour les petits objets)
  (contribution de *Serhiy Storchaka* dans bpo-41334).

* Le module "runpy" importe maintenant moins de modules. Le temps de
  démarrage de la commande "python3 -m module-name" est en moyenne 1,4
  fois plus rapide. Sur Linux "python3 -I -m module-name" importe 69
  modules dans Python 3.9, alors qu'elle n'en importe que 51 (18 de
  moins) dans Python 3.10 (contribution de *Victor Stinner* dans
  bpo-41006 et dans bpo-41718).

* L'instruction "LOAD_ATTR" utilise maintenant le mécanisme de cache
  par code d'opération. Elle est environ 36 % plus rapide pour les
  attributs ordinaires et 44 % plus rapide pour les *slots*
  (contribution de *Pablo Galindo* et de *Yury Selivanov* dans
  bpo-42093 et *Guido van Rossum* dans bpo-42927, basée sur des idées
  originalement mises en œuvre dans *PyPy* et dans *MicroPython*).

* Lors de la construction de Python avec "--enable-optimizations",
  "-fno-semantic-interposition" est maintenant ajouté aux lignes de
  commande de compilation et d'édition des liens. Ceci accélère les
  binaires de l'interpréteur Python créés avec "--enable-shared" et
  "gcc" jusqu'à 30 %. Voir cet article (en anglais) pour plus de
  détails (contribution de *Victor Stinner* et *Pablo Galindo* dans
  bpo-38980).

* Ré-usinage du code assurant la gestion du tampon de sortie pour les
  modules "bz2", "lzma" et "zlib". Ajout de la fonction ".readall()" à
  la classe "_compression.DecompressReader". La décompression *bz2*
  est 1,09 à 1,17 fois plus rapide, la décompression *lzma* est 1,20 à
  1,32 fois plus rapide, "GzipFile.read(-1)" est 1,11 à 1,18 fois plus
  rapide (contribution de *Ma Lin*, révision par *Gregory P. Smith*
  dans bpo-41486).

* When using stringized annotations, annotations dicts for functions
  are no longer created when the function is created.  Instead, they
  are stored as a tuple of strings, and the function object lazily
  converts this into the annotations dict on demand.  This
  optimization cuts the CPU time needed to define an annotated
  function by half. (Contributed by Yurii Karabas and Inada Naoki in
  bpo-42202.)

* Les fonctions de recherche de sous-chaînes telles que "str1 in str2"
  et "str2.find(str1)" peuvent utiliser maintenant l'algorithme «
  bidirectionnel » de recherche de chaînes *Crochemore et Perrin* pour
  éviter le comportement quadratique sur les longues chaînes
  (contribution de *Dennis Sweeney* dans bpo-41972).

* Add micro-optimizations to "_PyType_Lookup()" to improve type
  attribute cache lookup performance in the common case of cache hits.
  This makes the interpreter 1.04 times faster on average.
  (Contributed by Dino Viehland in bpo-43452.)

* The following built-in functions now support the faster **PEP 590**
  vectorcall calling convention: "map()", "filter()", "reversed()",
  "bool()" and "float()". (Contributed by Donghee Na and Jeroen
  Demeyer in bpo-43575, bpo-43287, bpo-41922, bpo-41873 and
  bpo-41870.)

* "BZ2File" performance is improved by removing internal "RLock". This
  makes "BZ2File" thread unsafe in the face of multiple simultaneous
  readers or writers, just like its equivalent classes in "gzip" and
  "lzma" have always been.  (Contributed by Inada Naoki in bpo-43785.)


Obsolescence
============

* Currently Python accepts numeric literals immediately followed by
  keywords, for example "0in x", "1or x", "0if 1else 2".  It allows
  confusing and ambiguous expressions like "[0x1for x in y]" (which
  can be interpreted as "[0x1 for x in y]" or "[0x1f or x in y]").
  Starting in this release, a deprecation warning is raised if the
  numeric literal is immediately followed by one of keywords "and",
  "else", "for", "if", "in", "is" and "or". In future releases it will
  be changed to syntax warning, and finally to syntax error.
  (Contributed by Serhiy Storchaka in bpo-43833.)

* Starting in this release, there will be a concerted effort to begin
  cleaning up old import semantics that were kept for Python 2.7
  compatibility. Specifically, "find_loader()"/"find_module()"
  (superseded by "find_spec()"), "load_module()" (superseded by
  "exec_module()"), "module_repr()" (which the import system takes
  care of for you), the "__package__" attribute (superseded by
  "__spec__.parent"), the "__loader__" attribute (superseded by
  "__spec__.loader"), and the "__cached__" attribute (superseded by
  "__spec__.cached") will slowly be removed (as well as other classes
  and methods in "importlib"). "ImportWarning" and/or
  "DeprecationWarning" will be raised as appropriate to help identify
  code which needs updating during this transition.

* L'espace de noms "distutils" est complètement obsolète et sera
  retiré dans Python 3.12. Voir la section sur les changements aux
  modules pour plus d'information.

* Les arguments non entiers de "random.randrange()" sont obsolètes. La
  levée de "ValueError" dans ce cas est obsolète et est remplacée par
  "TypeError" (contribution de *Serhiy Storchaka* et *Raymond
  Hettinger* dans bpo-37319).

* Les multiples méthodes "load_module()" de "importlib" étaient
  documentées comme obsolètes depuis Python 3.6, mais elles vont
  maintenant aussi lever un "DeprecationWarning". Utilisez plutôt
  "exec_module()" (contribution de *Brett Cannon* dans bpo-26131).

* "zimport.zipimporter.load_module()" has been deprecated in
  preference for "exec_module()". (Contributed by Brett Cannon in
  bpo-26131.)

* L'utilisation de "load_module()" par le système d'importation lève
  maintenant un "ImportWarning" car "exec_module()" est recommandée
  (contribution de (*Brett Cannon* dans bpo-26131).

* The use of "importlib.abc.MetaPathFinder.find_module()" and
  "importlib.abc.PathEntryFinder.find_module()" by the import system
  now trigger an "ImportWarning" as
  "importlib.abc.MetaPathFinder.find_spec()" and
  "importlib.abc.PathEntryFinder.find_spec()" are preferred,
  respectively. You can use "importlib.util.spec_from_loader()" to
  help in porting. (Contributed by Brett Cannon in bpo-42134.)

* The use of "importlib.abc.PathEntryFinder.find_loader()" by the
  import system now triggers an "ImportWarning" as
  "importlib.abc.PathEntryFinder.find_spec()" is preferred. You can
  use "importlib.util.spec_from_loader()" to help in porting.
  (Contributed by Brett Cannon in bpo-43672.)

* The various implementations of
  "importlib.abc.MetaPathFinder.find_module()" (
  "importlib.machinery.BuiltinImporter.find_module()",
  "importlib.machinery.FrozenImporter.find_module()",
  "importlib.machinery.WindowsRegistryFinder.find_module()",
  "importlib.machinery.PathFinder.find_module()",
  "importlib.abc.MetaPathFinder.find_module()" ),
  "importlib.abc.PathEntryFinder.find_module()" (
  "importlib.machinery.FileFinder.find_module()" ), and
  "importlib.abc.PathEntryFinder.find_loader()" (
  "importlib.machinery.FileFinder.find_loader()" ) now raise
  "DeprecationWarning" and are slated for removal in Python 3.12
  (previously they were documented as deprecated in Python 3.4).
  (Contributed by Brett Cannon in bpo-42135.)

* "importlib.abc.Finder" is deprecated (including its sole method,
  "find_module()"). Both "importlib.abc.MetaPathFinder" and
  "importlib.abc.PathEntryFinder" no longer inherit from the class.
  Users should inherit from one of these two classes as appropriate
  instead. (Contributed by Brett Cannon in bpo-42135.)

* The deprecations of "imp", "importlib.find_loader()",
  "importlib.util.set_package_wrapper()",
  "importlib.util.set_loader_wrapper()",
  "importlib.util.module_for_loader()", "pkgutil.ImpImporter", and
  "pkgutil.ImpLoader" have all been updated to list Python 3.12 as the
  slated version of removal (they began raising "DeprecationWarning"
  in previous versions of Python). (Contributed by Brett Cannon in
  bpo-43720.)

* The import system now uses the "__spec__" attribute on modules
  before falling back on "module_repr()" for a module's "__repr__()"
  method. Removal of the use of "module_repr()" is scheduled for
  Python 3.12. (Contributed by Brett Cannon in bpo-42137.)

* "importlib.abc.Loader.module_repr()",
  "importlib.machinery.FrozenLoader.module_repr()", and
  "importlib.machinery.BuiltinLoader.module_repr()" are deprecated and
  slated for removal in Python 3.12. (Contributed by Brett Cannon in
  bpo-42136.)

* "sqlite3.OptimizedUnicode" est non-documenté et désuète depuis
  Python 3.3, quand elle devenue un alias de "str". Elle est
  maintenant déclarée obsolète et sera retiré dans Python 3.12
  (contribution de *Erlend E. Aasland* dans bpo-42264).

* La fonction native non-documentée "sqlite3.enable_shared_cache" est
  maintenant obsolète et sera retirée dans Python 3.12. Son
  utilisation est fortement déconseillée dans la documentation de
  SQLite3. Voir la documentation de SQLite3 (en anglais) pour plus de
  détails. Si un cache partagé est nécessaire, ouvrez la base de
  données en mode URI en utilisant le paramètre de requête
  "cache=shared" (contribution de *Erlend E. Aasland* dans bpo-24464).

* Les méthodes suivantes du module "threading" sont maintenant
  obsolètes :

  * "threading.currentThread" => "threading.current_thread()" ;

  * "threading.activeCount" => "threading.active_count()" ;

  * "threading.Condition.notifyAll" =>
    "threading.Condition.notify_all()" ;

  * "threading.Event.isSet" => "threading.Event.is_set()" ;

  * "threading.Thread.setName" => "threading.Thread.name" ;

  * "threading.thread.getName" => "threading.Thread.name" ;

  * "threading.Thread.isDaemon" => "threading.Thread.daemon" ;

  * "threading.Thread.setDaemon" => "threading.Thread.daemon".

  (Contributed by Jelle Zijlstra in gh-87889.)

* "pathlib.Path.link_to()" is deprecated and slated for removal in
  Python 3.12. Use "pathlib.Path.hardlink_to()" instead. (Contributed
  by Barney Gale in bpo-39950.)

* "cgi.log()" est obsolète et sera retirée dans Python 3.12
  (contribution de *Inada Naoki* dans bpo-41139).

* Les fonctionnalités suivantes de "ssl" sont obsolètes depuis Python
  3.6, Python 3.7 ou *OpenSSL* 1.1.0 et seront retirées dans 3.11 :

  * "OP_NO_SSLv2", "OP_NO_SSLv3", "OP_NO_TLSv1", "OP_NO_TLSv1_1",
    "OP_NO_TLSv1_2", and "OP_NO_TLSv1_3" are replaced by
    "minimum_version" and "maximum_version".

  * "PROTOCOL_SSLv2", "PROTOCOL_SSLv3", "PROTOCOL_SSLv23",
    "PROTOCOL_TLSv1", "PROTOCOL_TLSv1_1", "PROTOCOL_TLSv1_2", and
    "PROTOCOL_TLS" are deprecated in favor of "PROTOCOL_TLS_CLIENT"
    and "PROTOCOL_TLS_SERVER"

  * "wrap_socket()" is replaced by "ssl.SSLContext.wrap_socket()"

  * "match_hostname()"

  * "RAND_pseudo_bytes()", "RAND_egd()"

  * Les fonctionnalités NPN (*Next Protocol Negotiation*) telles que
    "ssl.SSLSocket.selected_npn_protocol()" et
    "ssl.SSLContext.set_npn_protocols()" sont remplacées par ALPN
    (*Application Layer Protocol Negotiation*).

* The threading debug ("PYTHONTHREADDEBUG" environment variable) is
  deprecated in Python 3.10 and will be removed in Python 3.12. This
  feature requires a debug build of Python. (Contributed by Victor
  Stinner in bpo-44584.)

* Importing from the "typing.io" and "typing.re" submodules will now
  emit "DeprecationWarning".  These submodules will be removed in a
  future version of Python.  Anything belonging to these submodules
  should be imported directly from "typing" instead. (Contributed by
  Sebastian Rittau in bpo-38291.)


Retrait
=======

* Les méthodes spéciales "__int__", "__float__", "__floordiv__",
  "__mod__", "__divmod__", "__rfloordiv__", "__rmod__" et
  "__rdivmod__" sont retirées de la classe "complex". Elles levaient
  toujours une "TypeError" (contribution de *Serhiy Storchaka* dans
  bpo-41974).

* La méthode "ParserBase.error()" du module privé et non-documenté
  "_markupbase" a été retirée. "html.parser.HTMLParser" est la seule
  sous-classe de "ParserBase" et son implémentation de la méthode
  "error()" a été retirée dans Python 3.5 (contribution de *Berker
  Peksag* dans bpo-31844).

* Retrait de l'attribut "unicodedata.ucnhash_CAPI" qui était un objet
  "PyCapsule" interne. La structure privée associée
  "_PyUnicode_Name_CAPI" a été déplacée vers l'API C interne
  (contribution de *Victor Stinner* dans bpo-42157).

* Retrait du module "parser" qui était obsolète depuis 3.9 étant donné
  la transition vers le nouvel analyseur syntaxique PEG. Retrait aussi
  des fichiers source et en-tête C qui n'étaient utilisés que par
  l'ancien analyseur, ceci comprend "node.h", "parser.h", "graminit.h"
  et "grammar.h".

* Retrait des fonctions "PyParser_SimpleParseStringFlags",
  "PyParser_SimpleParseStringFlagsFilename",
  "PyParser_SimpleParseFileFlags" et "PyNode_Compile" de l'API C
  publique. Elles étaient obsolètes depuis 3.9 étant donné la
  transition vers l'analyseur syntaxique *PEG*.

* Removed the "formatter" module, which was deprecated in Python 3.4.
  It is somewhat obsolete, little used, and not tested. It was
  originally scheduled to be removed in Python 3.6, but such removals
  were delayed until after Python 2.7 EOL. Existing users should copy
  whatever classes they use into their code. (Contributed by Donghee
  Na and Terry J. Reedy in bpo-42299.)

* Removed the "PyModule_GetWarningsModule()" function that was useless
  now due to the "_warnings" module was converted to a builtin module
  in 2.6. (Contributed by Hai Shi in bpo-42599.)

* Retrait des alias obsolètes Classes de base abstraites de
  collections du module "collections" (contribution de *Victor
  Stinner* dans bpo-37324).

* Le paramètre "loop" a été retiré de la majorité de l'API haut-niveau
  d'"asyncio". Il était obsolète depuis Python 3.8. La motivation pour
  ce changement avait plusieurs facettes :

  1. ceci simplifie l'API haut-niveau ;

  2. les fonctions dans l'API haut niveau reçoivent implicitement la
     boucle d'évènements qui tourne dans le présent fil d'exécution
     depuis Python 3.7. Il n'y a aucun besoin de passer la boucle
     d'évènements à l'API dans la majorité de son utilisation normale
     ;

  3. le passage de la boucle d'évènements cause facilement des erreurs
     quand plusieurs boucles qui tournent dans plusieurs fils
     d'exécution sont impliquées.

  Prenez note que l'API bas-niveau accepte toujours le paramètre
  "loop". Voir Changements dans l'API Python pour plus d'exemples sur
  comment remplacer le code existant

  (contribution de *Yurii Karabas*, *Andrew Svetlov*, *Yury Selivanov*
  et *Kyle Stanley* dans bpo-42392).


Portage vers Python 3.10
========================

Cette section liste les changements mentionnés préalablement et autres
améliorations qui peuvent demander des changements à votre code.


Changements à la syntaxe de Python
----------------------------------

* Deprecation warning is now emitted when compiling previously valid
  syntax if the numeric literal is immediately followed by a keyword
  (like in "0in x"). In future releases it will be changed to syntax
  warning, and finally to a syntax error.  To get rid of the warning
  and make the code compatible with future releases just add a space
  between the numeric literal and the following keyword. (Contributed
  by Serhiy Storchaka in bpo-43833.)


Changements dans l'API Python
-----------------------------

* Les paramètres *etype* des fonctions "format_exception()",
  "format_exception_only()" et "print_exception()" du module
  "traceback" ont étés renommés *exc* (contribution de *Zackery Spytz*
  et *Matthias Bussonnier* dans bpo-26389).

* "atexit" : à la fin de l'exécution de Python, si une fonction de
  rappel qui a été enregistrée avec "atexit.register()" échoue, son
  exception est maintenant journalisée. Préalablement, seulement
  certaines exceptions étaient journalisées et la dernière exception
  était toujours ignorée de façon silencieuse (contribution de *Victor
  Stinner* dans bpo-42639).

* Les génériques de "collections.abc.Callable" aplatissent maintenant
  les paramètres de types tel qu'il est fait par "typing.Callable".
  Ceci veut dire que "collections.abc.Callable[[int, str], str]" aura
  un attribut "__args__" de valeur "(int, str, str)" ; préalablement,
  il aurait été "([int, str], str)". Les codes qui accèdent aux
  arguments par "typing.get_args()" ou "__args__" doivent tenir compte
  de ce changement. De plus, "TypeError" sera levée pour des formes
  invalides de paramétrisation de "collections.abc.Callable", ce qui
  aurait pu passer silencieusement dans Python 3.9 (contribution de
  *Ken Jin* dans bpo-42195).

* "socket.htons()" et "socket.ntohs()" lèvent maintenant
  "OverflowError" plutôt que "DeprecationWarning" si le paramètre
  passé est trop grand pour être stocké dans un entier 16-bit non-
  signé (contribution de *Erlend E. Aasland* dans bpo-42393).

* Le paramètre "loop" a été retiré de la majorité de l'API haut-niveau
  d'"asyncio" suite à la déclaration de son obsolescence dans Python
  3.8.

  Une coroutine qui ressemble actuellement à ceci :

     async def foo(loop):
         await asyncio.sleep(1, loop=loop)

  Doit être remplacée par ceci :

     async def foo():
         await asyncio.sleep(1)

  Si "foo()" a été spécifiquement conçue pour *ne pas* s'exécuter dans
  le fil d'exécution courant, (par exemple pour tourner dans la boucle
  d'exécution d'un autre fil), l'utilisation de
  "asyncio.run_coroutine_threadsafe()" est probablement plus
  appropriée.

  (contribution de *Yurii Karabas*, *Andrew Svetlov*, *Yury Selivanov*
  et *Kyle Stanley* dans bpo-42392).

* Le constructeur de "types.FunctionType" hérite maintenant des
  définitions natives si le dictionnaire *globals* n'a pas de clé
  ""__builtins__"", plutôt que d'utiliser "{"None": None}" pour les
  définitions natives : même comportement que celui des fonctions
  "eval()" et "exec()". Définir une fonction avec "def function(...):
  ..." en Python n'est pas affecté, les globales ne peuvent pas être
  changées avec cette syntaxe : elles héritent aussi des définitions
  natives courantes (contribution de *Victor Stinner* dans bpo-42990).


Changements dans l'API C
------------------------

* Les fonctions de l'API C "PyParser_SimpleParseStringFlags",
  "PyParser_SimpleParseStringFlagsFilename",
  "PyParser_SimpleParseFileFlags" et "PyNode_Compile" ainsi que
  "struct _node", le type utilisé par ces fonctions, ont été retirés
  suite à la transition vers le nouvel analyseur syntaxique *PEG*.

  Le code source doit maintenant être compilé directement en un objet
  code, en utilisant par exemple "Py_CompileString()". L'objet code
  ainsi produit peut ensuite être évalué, en utilisant par exemple
  "PyEval_EvalCode()".

  Spécifiquement :

  * Un appel à "PyParser_SimpleParseStringFlags" suivi de
    "PyNode_Compile" peut être remplacé par "Py_CompileString()" ;

  * Il n'y a pas de remplacement immédiat pour
    "PyParser_SimpleParseFileFlags". Pour compiler du code à partir
    d'un argument "FILE *", vous devez lire le fichier en C et passer
    le tampon résultant à "Py_CompileString()".

  * Pour compiler un fichier à partir du "char *" de son nom, ouvrez
    le fichier de façon explicite, lisez son contenu et compilez le
    résultat. Une façon de faire est d'utiliser le module "io" en
    conjonction avec "PyImport_ImportModule()",
    "PyObject_CallMethod()", "PyBytes_AsString()" et
    "Py_CompileString()", comme dans l'esquisse qui suit (les
    déclarations et la gestion d'erreurs ne sont pas incluses)

       io_module = Import_ImportModule("io");
       fileobject = PyObject_CallMethod(io_module, "open", "ss", filename, "rb");
       source_bytes_object = PyObject_CallMethod(fileobject, "read", "");
       result = PyObject_CallMethod(fileobject, "close", "");
       source_buf = PyBytes_AsString(source_bytes_object);
       code = Py_CompileString(source_buf, filename, Py_file_input);

  * For "FrameObject" objects, the "f_lasti" member now represents a
    wordcode offset instead of a simple offset into the bytecode
    string. This means that this number needs to be multiplied by 2 to
    be used with APIs that expect a byte offset instead (like
    "PyCode_Addr2Line()" for example). Notice as well that the
    "f_lasti" member of "FrameObject" objects is not considered
    stable: please use "PyFrame_GetLineNumber()" instead.


Changements au code intermédiaire CPython
=========================================

* The "MAKE_FUNCTION" instruction now accepts either a dict or a tuple
  of strings as the function's annotations. (Contributed by Yurii
  Karabas and Inada Naoki in bpo-42202.)


Changements à la compilation
============================

* **PEP 644** : la version minimale d'*OpenSSL* pour Python est
  maintenant 1.1.1. *OpenSSL* 1.0.2 n'est plus prise en charge
  (contribution de *Christian Heimes* dans bpo-43669).

* Les fonctions de *C99* "snprintf()" et "vsnprintf()" sont maintenant
  nécessaires à la compilation de Python (contribution de *Victor
  Stinner* dans bpo-36020).

* La version minimale de SQLite pour le module "sqlite3" est
  maintenant 3.7.15 (contribution de *Sergey Fedoseev* et *Erlend E.
  Aasland* dans bpo-40744 et bpo-40810).

* Le module "atexit" doit maintenant toujours être compilé en tant que
  module natif (contribution de *Victor Stinner* dans bpo-42639).

* Ajout de l'option "--disable-test-modules" au script "configure" :
  ne pas compiler ni installer les modules de tests (contribution de
  *Xavier de Gaye*, *Thomas Petazzoni* et *Peixing Xin* dans
  bpo-27640).

* Ajout de l'option "--with-wheel-pkg-dir=PATH" au script
  "./configure". Si elle est passée, le module "ensurepip" recherche
  les paquets *wheel* de "setuptools" et de "pip" dans ce répertoire :
  si les deux sont présents, ces paquets *wheel* sont utilisés plutôt
  que ceux inclus avec *ensurepip*.

  La politique de paquets de certaines distributions Linux déconseille
  l'inclusion des dépendances. Par exemple, Fedora installe les
  paquets *wheel* dans le répertoire "/usr/share/python-wheels/" et
  n'installe pas le paquet "ensurepip._bundled"

  (contribution de *Victor Stinner* dans bpo-42856).

* Ajout d'une nouvelle option "--without-static-libpython" au script
  "configure" pour ne pas compiler la bibliothèque statique
  "libpythonMAJOR.MINOR.a" et ne pas installer le fichier objet
  "python.o"

  (contribution de *Victor Stinner* dans bpo-43103).

* The "configure" script now uses the "pkg-config" utility, if
  available, to detect the location of Tcl/Tk headers and libraries.
  As before, those locations can be explicitly specified with the "--
  with-tcltk-includes" and "--with-tcltk-libs" configuration options.
  (Contributed by Manolis Stamatogiannakis in bpo-42603.)

* Ajout de l'option "--with-openssl-rpath" au script "configure".
  Cette option simplifie la compilation de Python avec une
  installation personnalisée d'OpenSSL, par exemple : "./configure
  --with-openssl=/path/to/openssl --with-openssl-rpath=auto"
  (contribution de *Christian Heimes* dans bpo-43466).


Changements à l'API C
=====================


PEP 652 : maintenance d'une ABI stable
--------------------------------------

L'interface binaire-programme (*Application Binary Interface*, *ABI*
en anglais) stable pour les modules d'extension ou pour l'intégration
de Python est maintenant définie de façon explicite. Le document
Stabilité de l’API C décrit les garanties de stabilité pour l'API C et
pour l'interface binaire-programme ainsi que les bonnes pratiques pour
travailler avec l'interface binaire-programme stable

(contribution de *Petr Viktorin* dans **PEP 652** et dans bpo-43795).


Nouvelles fonctionnalités
-------------------------

* Le résultat de "PyNumber_Index()" est maintenant exactement de type
  "int". Auparavant, le résultat pouvait être une instance d'une
  classe dérivée de "int" (contribution de *Serhiy Storchaka* dans
  bpo-40792).

* Ajout d'un nouveau champ "orig_argv" à la structure "PyConfig" : la
  liste des arguments de ligne de commande originalement passée à
  l'exécutable Python (contribution de *Victor Stinner* dans
  bpo-23427).

* Les macros "PyDateTime_DATE_GET_TZINFO()" et
  "PyDateTime_TIME_GET_TZINFO()" ont été ajoutées pour récupérer
  l'attribut "tzinfo" des objets "datetime.datetime" et
  "datetime.time" (contribution de *Zackery Spytz* dans bpo-30155).

* Ajout d'une fonction "PyCodec_Unregister()" pour désinscrire une
  fonction de recherche de codecs (contribution de *Hai Shi* dans
  bpo-41842).

* Ajout de la fonction "PyIter_Send()" pour acheminer une valeur dans
  un itérateur sans lever une exception "StopIteration" (contribution
  de *Vladimir Matveev* dans bpo-41756).

* Ajout de "PyUnicode_AsUTF8AndSize()" à l'API C limitée (contribution
  d'*Alex Gaynor* dans bpo-41784).

* Ajout de la fonction "PyModule_AddObjectRef()" : comparable à
  "PyModule_AddObject()" mais ne s’accapare pas une référence à la
  valeur s'il y a réussite (contribution de *Victor Stinner* dans
  bpo-1635741).

* Ajout des fonctions "Py_NewRef()" et "Py_XNewRef()" pour incrémenter
  le compteur des références d'un objet et renvoyer l'objet
  (contribution de *Victor Stinner* dans bpo-42262).

* Les fonctions "PyType_FromSpecWithBases()" et
  "PyType_FromModuleAndSpec()" n'acceptent maintenant qu'une seule
  classe pour l'argument *bases* (contribution *Serhiy Storchaka* dans
  bpo-42423).

* La fonction "PyType_FromModuleAndSpec()" accepte maintenant "NULL"
  dans l'emplacement "tp_doc" (contribution de *Hai Shi* dans
  bpo-41832).

* La fonction "PyType_GetSlot()" peut maintenant accepter des types
  statiques (contribution de *Hai Shi* et *Petr Viktorin* dans
  bpo-41073).

* Ajout d'une nouvelle fonction "PySet_CheckExact()" à l'API C pour
  vérifier si un objet est une instance de "set" mais pas une instance
  d'un sous-type (contribution de *Pablo Galindo* dans bpo-43277).

* Ajout de "PyErr_SetInterruptEx()" qui accepte le numéro d'un signal
  à simuler (contribution d'*Antoine Pitrou* dans bpo-43356).

* L'API C limitée est maintenant prise en charge si Python est compilé
  en mode débogage (si la macro "Py_DEBUG" est définie). Dans l'API C
  limitée, les fonctions "Py_INCREF()" et "Py_DECREF()" sont
  maintenant implémentées en appel de fonctions opaques, plutôt que
  d'accéder directement au champ "PyObject.ob_refcnt". C'est le cas si
  Python est compilé en mode débogage et que la macro "Py_LIMITED_API"
  vise Python 3.10 ou plus récent. Il est possible de prendre en
  charge l'API C limitée en mode débogage, car la structure "PyObject"
  est la même dans les versions standard et dans les versions débogage
  depuis Python 3.8 (voir bpo-36465).

  L'API C limitée n'est toujours pas prise en charge dans les
  compilations spéciales avec l'option "--with-trace-refs" (macro
  "Py_TRACE_REFS") (Contribution de *Victor Stinner* dans bpo-43688).

* Ajout de la fonction "Py_Is(x, y)" pour vérifier si l'objet *x* est
  l'objet *y*, tout comme "x is y" en Python. Ajout aussi des
  fonctions "Py_IsNone()", "Py_IsTrue()" et "Py_IsFalse()" pour
  vérifier si l'objet est le singleton "None", le singleton "True" ou
  le singleton "False", respectivement (contribution de *Victor
  Stinner* dans bpo-43753).

* Ajout de fonctions pour contrôler le ramasse-miettes en C :
  "PyGC_Enable()", "PyGC_Disable()" et "PyGC_IsEnabled()". Ces
  fonctions permettent d'activer, de désactiver et d'interroger l'état
  du ramasse-miettes dans du code C sans avoir à importer le module
  "gc".

* Add a new "Py_TPFLAGS_DISALLOW_INSTANTIATION" type flag to disallow
  creating type instances. (Contributed by Victor Stinner in
  bpo-43916.)

* Add a new "Py_TPFLAGS_IMMUTABLETYPE" type flag for creating
  immutable type objects: type attributes cannot be set nor deleted.
  (Contributed by Victor Stinner and Erlend E. Aasland in bpo-43908.)


Portage vers Python 3.10
------------------------

* The "PY_SSIZE_T_CLEAN" macro must now be defined to use
  "PyArg_ParseTuple()" and "Py_BuildValue()" formats which use "#":
  "es#", "et#", "s#", "u#", "y#", "z#", "U#" and "Z#". See Analyse des
  arguments et construction des valeurs and **PEP 353**. (Contributed
  by Victor Stinner in bpo-40943.)

* Étant donné la conversion de "Py_REFCNT()" en fonction statique en-
  ligne, "Py_REFCNT(obj) = new_refcnt" doit être remplacé par
  "Py_SET_REFCNT(obj, new_refcnt)" : voir "Py_SET_REFCNT()"
  (disponible depuis Python 3.9). Pour la rétro-compatibilité, cette
  macro peut être utilisée :

     #if PY_VERSION_HEX < 0x030900A4
     #  define Py_SET_REFCNT(obj, refcnt) ((Py_REFCNT(obj) = (refcnt)), (void)0)
     #endif

  (contribution de *Victor Stinner* dans bpo-39573).

* Appeler "PyDict_GetItem()" sans avoir obtenu le *GIL* était autorisé
  pour des raisons historiques. Ceci n'est plus permis (contribution
  de *Victor Stinner* dans bpo-40839).

* "PyUnicode_FromUnicode(NULL, size)" et
  "PyUnicode_FromStringAndSize(NULL, size)" lèvent maintenant un
  "DeprecationWarning". Vous devez utiliser "PyUnicode_New()" pour
  allouer un objet Unicode sans donnée initiale (contribution de
  *Inada Naoki* dans bpo-36346).

* La structure privée "_PyUnicode_Name_CAPI" de l'API PyCapsule
  "unicodedata.ucnhash_CAPI" a été déplacée dans l'API C interne.
  (Contribution par Victor Stinner dans bpo-42157.)

* "Py_GetPath()", "Py_GetPrefix()", "Py_GetExecPrefix()",
  "Py_GetProgramFullPath()", "Py_GetPythonHome()" and
  "Py_GetProgramName()" functions now return "NULL" if called before
  "Py_Initialize()" (before Python is initialized). Use the new Python
  Initialization Configuration API to get the Python Path
  Configuration. (Contributed by Victor Stinner in bpo-42260.)

* "PyList_SET_ITEM()", "PyTuple_SET_ITEM()" and "PyCell_SET()" macros
  can no longer be used as l-value or r-value. For example, "x =
  PyList_SET_ITEM(a, b, c)" and "PyList_SET_ITEM(a, b, c) = x" now
  fail with a compiler error. It prevents bugs like "if
  (PyList_SET_ITEM (a, b, c) < 0) ..." test. (Contributed by Zackery
  Spytz and Victor Stinner in bpo-30459.)

* The non-limited API files "odictobject.h", "parser_interface.h",
  "picklebufobject.h", "pyarena.h", "pyctype.h", "pydebug.h",
  "pyfpe.h", and "pytime.h" have been moved to the "Include/cpython"
  directory. These files must not be included directly, as they are
  already included in "Python.h"; see Include Files. If they have been
  included directly, consider including "Python.h" instead.
  (Contributed by Nicholas Sim in bpo-35134.)

* Use the "Py_TPFLAGS_IMMUTABLETYPE" type flag to create immutable
  type objects. Do not rely on "Py_TPFLAGS_HEAPTYPE" to decide if a
  type object is mutable or not; check if "Py_TPFLAGS_IMMUTABLETYPE"
  is set instead. (Contributed by Victor Stinner and Erlend E. Aasland
  in bpo-43908.)

* The undocumented function "Py_FrozenMain" has been removed from the
  limited API. The function is mainly useful for custom builds of
  Python. (Contributed by Petr Viktorin in bpo-26241.)


Obsolescence
------------

* La fonction "PyUnicode_InternImmortal()" est maintenant obsolète et
  sera retirée dans Python 3.12 : utilisez plutôt
  "PyUnicode_InternInPlace()" (contribution de *Victor Stinner* dans
  bpo-41692).


Retrait
-------

* Retrait des fonctions "Py_UNICODE_str*" manipulant des chaînes
  "Py_UNICODE*" (contribution de *Inada Naoki* dans bpo-41123) :

  * "Py_UNICODE_strlen" : utilisez "PyUnicode_GetLength()" ou
    "PyUnicode_GET_LENGTH" ;

  * "Py_UNICODE_strcat" : utilisez "PyUnicode_CopyCharacters()" ou
    "PyUnicode_FromFormat()" ;

  * "Py_UNICODE_strcpy", "Py_UNICODE_strncpy" : utilisez
    "PyUnicode_CopyCharacters()" ou "PyUnicode_Substring()" ;

  * "Py_UNICODE_strcmp" : utilisez "PyUnicode_Compare()" ;

  * "Py_UNICODE_strncmp" : utilisez "PyUnicode_Tailmatch()" ;

  * "Py_UNICODE_strchr", "Py_UNICODE_strrchr" : utilisez
    "PyUnicode_FindChar()".

* Retrait de "PyUnicode_GetMax()". Vous devez migrer vers les
  nouvelles API de la **PEP 393** (contribution de *Inada Naoki* dans
  bpo-41103).

* Retrait de "PyLong_FromUnicode()". Vous devez migrer vers
  "PyLong_FromUnicodeObject()" (contribution de *Inada Naoki* dans
  bpo-41103).

* Retrait de "PyUnicode_AsUnicodeCopy()". Vous devez utiliser
  "PyUnicode_AsUCS4Copy()" ou "PyUnicode_AsWideCharString()"
  (contribution de *Inada Naoki* dans bpo-41103).

* Retrait de la variable "_Py_CheckRecursionLimit" : elle a été
  remplacée par le champ "ceval.recursion_limit" de la structure
  "PyInterpreterState" (contribution de *Victor Stinner* dans
  bpo-41834).

* Retrait des macros non-documentées "Py_ALLOW_RECURSION" et
  "Py_END_ALLOW_RECURSION" et du champ "recursion_critical" de la
  structure "PyInterpreterState" (contribution de *Serhiy Storchaka*
  dans bpo-41936).

* Retrait de la fonction non-documentée "PyOS_InitInterrupts()".
  L'initialisation de Python installe déjà les gestionnaires de
  signaux de façon implicite : voir "PyConfig.install_signal_handlers"
  (contribution de *Victor Stinner* dans bpo-41713).

* Retrait de la fonction "PyAST_Validate()". Il n'est plus possible de
  construire un objet *AST* (type "mod_ty") avec l'API C publique. La
  fonction était déjà retirée de l'API C limitée (**PEP 384**)
  (contribution de *Victor Stinner* dans bpo-43244).

* Retrait du fichier d'en-tête "symtable.h" et des fonctions non-
  documentées :

  * "PyST_GetScope()" ;

  * "PySymtable_Build()" ;

  * "PySymtable_BuildObject()" ;

  * "PySymtable_Free()" ;

  * "Py_SymtableString()" ;

  * "Py_SymtableStringObject()".

  Par erreur, la fonction "Py_SymtableString()" faisait partie de
  l'*ABI* stable, mais elle ne pouvait pas être utilisée, car le
  fichier d'en-tête "symtable.h" était exclu de l'API C limitée.

  Utilisez plutôt le module Python "symtable" (contribution de *Victor
  Stinner* dans bpo-43244).

* Retrait de "PyOS_ReadlineFunctionPointer()" des fichiers d'en-tête
  de l'API C limitée et de "python3.dll", la bibliothèque qui fournit
  l'*ABI* stable sur Windows. Étant donné que la fonction prend un
  "FILE*" en argument, la stabilité de son interface binaire-programme
  ne peut pas être garantie (contribution de *Petr Viktorin* dans
  bpo-43868).

* Retrait des fichiers d'en-tête "ast.h", "asdl.h" et "Python-ast.h".
  Ces fonctions étaient non-documentées et exclues de l'API C limitée.
  La majorité des noms définis dans ces fichiers d'en-tête n'avaient
  pas le préfixe "Py" et pouvaient ainsi causer des conflits de noms.
  Par exemple, "Python-ast.h" définit une macro "Yield" qui était en
  conflit avec le nom "Yield" utilisé dans le fichier d'en-tête
  "<winbase.h>" de Windows. Utilisez plutôt le module Python "ast"
  (contribution de *Victor Stinner* dans bpo-43244).

* Retrait des fonctions d'analyse syntaxique et de compilation qui
  utilisent le type "struct _mod" car l'API C publique pour manipuler
  les *AST* a été retirée :

  * "PyAST_Compile()" ;

  * "PyAST_CompileEx()" ;

  * "PyAST_CompileObject()" ;

  * "PyFuture_FromAST()" ;

  * "PyFuture_FromASTObject()" ;

  * "PyParser_ASTFromFile()" ;

  * "PyParser_ASTFromFileObject()" ;

  * "PyParser_ASTFromFilename()" ;

  * "PyParser_ASTFromString()" ;

  * "PyParser_ASTFromStringObject()".

  Ces fonctions étaient non-documentées et exclues de l'API C limitée
  (contribution de *Victor Stinner* dans bpo-43244).

* Retrait du fichier d'en-tête "pyarena.h" et des fonctions :

  * "PyArena_New()" ;

  * "PyArena_Free()" ;

  * "PyArena_Malloc()" ;

  * "PyArena_AddPyObject()".

  Ces fonctions étaient non-documentées et exclues de l'API C limitée
  ; elles n'étaient utilisées que par le compilateur dans
  l'implémentation interne (contribution de *Victor Stinner* dans
  bpo-43244).

* Retrait du champ "PyThreadState.use_tracing" pour optimiser Python
  (contribution de *Mark Shannon* dans bpo-43760).


Notable security feature in 3.10.7
==================================

Converting between "int" and "str" in bases other than 2 (binary), 4,
8 (octal), 16 (hexadecimal), or 32 such as base 10 (decimal) now
raises a "ValueError" if the number of digits in string form is above
a limit to avoid potential denial of service attacks due to the
algorithmic complexity. This is a mitigation for **CVE 2020-10735**.
This limit can be configured or disabled by environment variable,
command line flag, or "sys" APIs. See the integer string conversion
length limitation documentation.  The default limit is 4300 digits in
string form.


Notable security feature in 3.10.8
==================================

The deprecated "mailcap" module now refuses to inject unsafe text
(filenames, MIME types, parameters) into shell commands. Instead of
using such text, it will warn and act as if a match was not found (or
for test commands, as if the test failed). (Contributed by Petr
Viktorin in gh-98966.)


Notable changes in 3.10.12
==========================


tarfile
-------

* The extraction methods in "tarfile", and "shutil.unpack_archive()",
  have a new a *filter* argument that allows limiting tar features
  than may be surprising or dangerous, such as creating files outside
  the destination directory. See Extraction filters for details. In
  Python 3.12, use without the *filter* argument will show a
  "DeprecationWarning". In Python 3.14, the default will switch to
  "'data'". (Contributed by Petr Viktorin in **PEP 706**.)
