2. Analyse lexicale
*******************

Un programme Python est lu par un analyseur syntaxique (*parser* en
anglais). En entrée de cet analyseur syntaxique, nous trouvons des
lexèmes (*tokens* en anglais), produits par un analyseur lexical. Ce
chapitre décrit comment l'analyseur lexical découpe le fichier en
lexèmes.

Python lit le texte du programme comme des suites de caractères
Unicode ; l'encodage du fichier source peut être spécifié par une
déclaration d'encodage et vaut par défaut UTF-8, voir la **PEP 3120**
pour les détails. Si le fichier source ne peut pas être décodé, une
exception "SyntaxError" (erreur de syntaxe) est levée.


2.1. Structure des lignes
=========================

Un programme en Python est divisé en *lignes logiques*.


2.1.1. Lignes logiques
----------------------

La fin d'une ligne logique est représentée par le lexème NEWLINE. Les
instructions ne peuvent pas traverser les limites des lignes logiques,
sauf quand NEWLINE est autorisé par la syntaxe (par exemple, entre les
instructions des instructions composées). Une ligne logique est
constituée d'une ou plusieurs *lignes physiques* en fonction des
règles, explicites ou implicites, de *continuation de ligne*.


2.1.2. Lignes physiques
-----------------------

Une ligne physique est une suite de caractères terminée par une
séquence de fin de ligne. Dans les fichiers sources et les chaînes de
caractères, n'importe quelle séquence de fin de ligne des plateformes
standards peut être utilisée ; Unix utilise le caractère ASCII LF
(pour *linefeed*, saut de ligne en français), Windows utilise la
séquence CR LF (*carriage return* suivi de *linefeed*) et Macintosh
utilisait le caractère ASCII CR. Toutes ces séquences peuvent être
utilisées, quelle que soit la plateforme. La fin de l'entrée est aussi
une fin de ligne physique implicite.

Lorsque vous encapsulez Python, les chaînes de code source doivent
être passées à l'API Python en utilisant les conventions du C standard
pour les caractères de fin de ligne : le caractère "\n", dont le code
ASCII est LF.


2.1.3. Commentaires
-------------------

Un commentaire commence par le caractère croisillon ("#", *hash* en
anglais et qui ressemble au symbole musical dièse, c'est pourquoi il
est souvent improprement appelé caractère dièse) situé en dehors d'une
chaine de caractères littérale et se termine à la fin de la ligne
physique. Un commentaire signifie la fin de la ligne logique à moins
qu'une règle de continuation de ligne implicite ne s'applique. Les
commentaires sont ignorés au niveau syntaxique, ce ne sont pas des
lexèmes.


2.1.4. Déclaration d'encodage
-----------------------------

Si un commentaire placé sur la première ou deuxième ligne du script
Python correspond à l'expression rationnelle "coding[=:]\s*([-\w.]+)",
ce commentaire est analysé comme une déclaration d'encodage ; le
premier groupe de cette expression désigne l'encodage du fichier
source. Cette déclaration d'encodage doit être seule sur sa ligne et,
si elle est sur la deuxième ligne, la première ligne doit aussi être
une ligne composée uniquement d'un commentaire. Les formes
recommandées pour l'expression de l'encodage sont

   # -*- coding: <encoding-name> -*-

qui est reconnue aussi par GNU Emacs et

   # vim:fileencoding=<encoding-name>

qui est reconnue par VIM de Bram Moolenaar.

If no encoding declaration is found, the default encoding is UTF-8.
If the implicit or explicit encoding of a file is UTF-8, an initial
UTF-8 byte-order mark (b'xefxbbxbf') is ignored rather than being a
syntax error.

Si un encodage est déclaré, le nom de l'encodage doit être reconnu par
Python (voir Standard Encodings). L'encodage est utilisé pour toute
l'analyse lexicale, y compris les chaînes de caractères, les
commentaires et les identifiants.


2.1.5. Continuation de ligne explicite
--------------------------------------

Deux lignes physiques, ou plus, peuvent être jointes pour former une
seule ligne logique en utilisant la barre oblique inversée ("\") selon
la règle suivante : quand la ligne physique se termine par une barre
oblique inversée qui ne fait pas partie d'une chaine de caractères ou
d'un commentaire, la ligne immédiatement suivante lui est adjointe
pour former une seule ligne logique, en supprimant la barre oblique
inversée et le caractère de fin de ligne. Par exemple :

   if 1900 < year < 2100 and 1 <= month <= 12 \
      and 1 <= day <= 31 and 0 <= hour < 24 \
      and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
           return 1

Une ligne que se termine par une barre oblique inversée ne peut pas
avoir de commentaire. La barre oblique inversée ne permet pas de
continuer un commentaire. La barre oblique inversée ne permet pas de
continuer un lexème, sauf s'il s'agit d'une chaîne de caractères (par
exemple, les lexèmes autres que les chaînes de caractères ne peuvent
pas être répartis sur plusieurs lignes en utilisant une barre oblique
inversée). La barre oblique inversée n'est pas autorisée ailleurs sur
la ligne, en dehors d'une chaîne de caractères.


2.1.6. Continuation de ligne implicite
--------------------------------------

Les expressions entre parenthèses, crochets ou accolades peuvent être
réparties sur plusieurs lignes sans utiliser de barre oblique
inversée. Par exemple :

   month_names = ['Januari', 'Februari', 'Maart',      # These are the
                  'April',   'Mei',      'Juni',       # Dutch names
                  'Juli',    'Augustus', 'September',  # for the months
                  'Oktober', 'November', 'December']   # of the year

Les lignes continuées implicitement peuvent avoir des commentaires.
L'indentation des lignes de continuation n'est pas importante. Une
ligne blanche est autorisée comme ligne de continuation. Il ne doit
pas y avoir de lexème NEWLINE entre des lignes implicitement
continuées. Les lignes continuées implicitement peuvent être utilisées
dans des chaînes entre triples guillemets (voir ci-dessous) ; dans ce
cas, elles ne peuvent pas avoir de commentaires.


2.1.7. Lignes vierges
---------------------

Une ligne logique qui ne contient que des espaces, tabulations,
caractères de saut de page (*formfeed* en anglais) ou commentaires est
ignorée (c'est-à-dire que le lexème NEWLINE n'est pas produit).
Pendant l'édition interactive d'instructions, la gestion des lignes
vierges peut différer en fonction de l'implémentation de la boucle
REPL. Dans l'interpréteur standard, une ligne complètement vierge
(c'est-à-dire ne contenant strictement rien, même pas une espace ou un
commentaire) termine une instruction multi-lignes.


2.1.8. Indentation
------------------

Des espaces ou tabulations au début d’une ligne logique sont utilisées
pour connaître le niveau d’indentation de la ligne, qui est ensuite
utilisé pour déterminer comment les instructions sont groupées.

Les tabulations sont remplacées (de la gauche vers la droite) par une
à huit espaces de manière à ce que le nombre de caractères remplacés
soit un multiple de huit (nous avons ainsi la même règle que celle
d'Unix). Le nombre total d'espaces précédant le premier caractère non
blanc détermine alors le niveau d'indentation de la ligne.
L'indentation ne peut pas être répartie sur plusieurs lignes physiques
à l'aide de barres obliques inversées ; les espaces jusqu'à la
première barre oblique inversée déterminent l'indentation.

L'indentation est déclarée inconsistante et rejetée si, dans un même
fichier source, le mélange des tabulations et des espaces est tel que
la signification dépend du nombre d'espaces que représente une
tabulation. Une exception "TabError" est levée dans ce cas.

**Note de compatibilité entre les plateformes :** en raison de la
nature des éditeurs de texte sur les plateformes non Unix, il n'est
pas judicieux d'utiliser un mélange d'espaces et de tabulations pour
l'indentation dans un seul fichier source. Il convient également de
noter que des plateformes peuvent explicitement limiter le niveau
d'indentation maximal.

Un caractère de saut de page peut être présent au début de la ligne ;
il est ignoré pour les calculs d'indentation ci-dessus. Les caractères
de saut de page se trouvant ailleurs avec les espaces en tête de ligne
ont un effet indéfini (par exemple, ils peuvent remettre à zéro le
nombre d'espaces).

Les niveaux d'indentation de lignes consécutives sont utilisés pour
générer les lexèmes INDENT et DEDENT, en utilisant une pile, de cette
façon :

Avant que la première ligne du fichier ne soit lue, un « zéro » est
posé sur la pile ; il ne sera plus jamais enlevé. Les nombres empilés
sont toujours strictement croissants de bas en haut. Au début de
chaque ligne logique, le niveau d'indentation de la ligne est comparé
au sommet de la pile. S'ils sont égaux, il ne se passe rien. S'il est
plus grand, il est empilé et un lexème INDENT est produit. S'il est
plus petit, il *doit* être l'un des nombres présents dans la pile ;
tous les nombres de la pile qui sont plus grands sont retirés et, pour
chaque nombre retiré, un lexème DEDENT est produit. À la fin du
fichier, un lexème DEDENT est produit pour chaque nombre supérieur à
zéro restant sur la pile.

Voici un exemple de code Python correctement indenté (bien que très
confus) :

   def perm(l):
           # Compute the list of all permutations of l
       if len(l) <= 1:
                     return [l]
       r = []
       for i in range(len(l)):
                s = l[:i] + l[i+1:]
                p = perm(s)
                for x in p:
                 r.append(l[i:i+1] + x)
       return r

L'exemple suivant montre plusieurs erreurs d'indentation :

    def perm(l):                       # error: first line indented
   for i in range(len(l)):             # error: not indented
       s = l[:i] + l[i+1:]
           p = perm(l[:i] + l[i+1:])   # error: unexpected indent
           for x in p:
                   r.append(l[i:i+1] + x)
               return r                # error: inconsistent dedent

En fait, les trois premières erreurs sont détectées par l'analyseur
syntaxique ; seule la dernière erreur est trouvée par l'analyseur
lexical (l'indentation de "return r" ne correspond à aucun niveau dans
la pile).


2.1.9. Espaces entre lexèmes
----------------------------

Sauf au début d'une ligne logique ou dans les chaînes de caractères,
les caractères « blancs » espace, tabulation et saut de page peuvent
être utilisés de manière interchangeable pour séparer les lexèmes. Un
blanc n'est nécessaire entre deux lexèmes que si leur concaténation
pourrait être interprétée comme un lexème différent (par exemple, ab
est un lexème, mais a b comporte deux lexèmes).


2.2. Autres lexèmes
===================

Outre NEWLINE, INDENT et DEDENT, il existe les catégories de lexèmes
suivantes : *identifiants*, *mots clés*, *littéraux*, *opérateurs* et
*délimiteurs*. Les blancs (autres que les fins de lignes, vus
auparavant) ne sont pas des lexèmes mais servent à délimiter les
lexèmes. Quand une ambiguïté existe, le lexème correspond à la plus
grande chaîne possible qui forme un lexème licite, en lisant de la
gauche vers la droite.


2.3. Identifiants et mots-clés
==============================

Les identifiants (aussi appelés *noms*) sont décrits par les
définitions lexicales suivantes.

La syntaxe des identifiants en Python est basée sur l'annexe UAX-31 du
standard Unicode avec les modifications définies ci-dessous ;
consultez la **PEP 3131** pour plus de détails.

Dans l'intervalle ASCII (*U+0001..U+007F*), les caractères licites
pour les identifiants sont les mêmes que pour Python 2.x : les lettres
minuscules et majuscules de "A" à "Z", le souligné (ou *underscore*)
"_" et, sauf pour le premier caractère, les chiffres de "0" à "9".

Python 3.0 introduit des caractères supplémentaires en dehors de
l'intervalle ASCII (voir la **PEP 3131**). Pour ces caractères, la
classification utilise la version de la « base de données des
caractères Unicode » telle qu'incluse dans le module "unicodedata".

Les identifiants n'ont pas de limite de longueur. La casse est prise
en compte.

   identifier   ::= xid_start xid_continue*
   id_start     ::= <all characters in general categories Lu, Ll, Lt, Lm, Lo, Nl, the underscore, and characters with the Other_ID_Start property>
   id_continue  ::= <all characters in id_start, plus characters in the categories Mn, Mc, Nd, Pc and others with the Other_ID_Continue property>
   xid_start    ::= <all characters in id_start whose NFKC normalization is in "id_start xid_continue*">
   xid_continue ::= <all characters in id_continue whose NFKC normalization is in "id_continue*">

Les codes de catégories Unicode cités ci-dessus signifient :

* *Lu* — lettres majuscules

* *Ll* — lettres minuscules

* *Lt* — lettres majuscules particulières (catégorie *titlecase* de
  l'Unicode)

* *Lm* — lettres modificatives avec chasse

* *Lo* — autres lettres

* *Nl* — nombres lettres (par exemple, les nombres romains)

* *Mn* — symboles que l'on combine avec d'autres (accents ou autres)
  sans générer d'espace (*nonspacing marks* en anglais)

* *Mc* — symboles que l'on combine avec d'autres en générant une
  espace (*spacing combining marks* en anglais)

* *Nd* — chiffres (arabes et autres)

* *Pc* — connecteurs (tirets et autres lignes)

* *Other_ID_Start* - explicit list of characters in PropList.txt to
  support backwards compatibility

* *Other_ID_Continue* — pareillement

Tous les identifiants sont convertis dans la forme normale NFKC
pendant l'analyse syntaxique : la comparaison des identifiants se base
sur leur forme NFKC.

A non-normative HTML file listing all valid identifier characters for
Unicode 14.0.0 can be found at
https://www.unicode.org/Public/14.0.0/ucd/DerivedCoreProperties.txt


2.3.1. Mots-clés
----------------

Les identifiants suivants sont des mots réservés par le langage et ne
peuvent pas être utilisés en tant qu'identifiants normaux. Ils doivent
être écrits exactement comme ci-dessous :

   False      await      else       import     pass
   None       break      except     in         raise
   True       class      finally    is         return
   and        continue   for        lambda     try
   as         def        from       nonlocal   while
   assert     del        global     not        with
   async      elif       if         or         yield


2.3.2. Mots-clés ad hoc
-----------------------

Nouveau dans la version 3.10.

Certains identifiants ne sont réservés que dans des contextes
particuliers. Ils sont appelés *mots-clés ad hoc*. Les identifiants
"match", "case" et "_" peuvent être interprétés en tant que mots-clés
dans le contexte d'instructions de filtrage par motifs, mais cette
distinction est effectuée au niveau de l'analyseur syntaxique
(*parser* en anglais), pas lors de l'analyse lexicale (*tokenization*
en anglais).

En tant que mots-clés ad hoc, leur utilisation dans le filtrage par
motifs est possible tout en conservant la compatibilité avec du code
existant qui utilise "match", "case" et "_" comme identifiants.


2.3.3. Classes réservées pour les identifiants
----------------------------------------------

Certaines classes d'identifiants (outre les mots-clés) ont une
signification particulière. Ces classes se reconnaissent par des
caractères de soulignement en tête et en queue d'identifiant :

"_*"
   N'est pas importé par "from module import *".

"_"
   Dans un motif "case" d'une instruction "match", "_" est un mot-clé
   ad hoc qui décrit un motif attrape-tout.

   De son côté, l'interpréteur interactif place le résultat de la
   dernière évaluation dans la variable "-" (son emplacement se situe
   dans le module "builtins", avec les fonctions natives telles que
   "print").

   Ailleurs, "_" est un identifiant comme un autre. Il est souvent
   utilisé pour désigner des éléments « spéciaux », mais il n'est pas
   spécial pour Python en tant que tel.

   Note:

     Le nom "_" est souvent utilisé pour internationaliser l'affichage
     ; reportez-vous à la documentation du module "gettext" pour plus
     d'informations sur cette convention.Il est aussi communément
     utilisé pour signifier que la variable n'est pas utilisée.

"__*__"
   Noms définis par le système, appelés noms « *dunder* » (pour
   *Double Underscores*) de manière informelle. Ces noms sont définis
   par l'interpréteur et son implémentation (y compris la bibliothèque
   standard). Les noms actuels définis par le système sont abordés
   dans la section Méthodes spéciales, mais aussi ailleurs. D'autres
   noms seront probablement définis dans les futures versions de
   Python. Toute utilisation de noms de la forme "__*__", dans
   n'importe quel contexte, qui n'est pas conforme à ce qu'indique
   explicitement la documentation, est sujette à des mauvaises
   surprises sans avertissement.

"__*"
   Noms privés pour une classe. Les noms de cette forme, lorsqu'ils
   sont utilisés dans le contexte d'une définition de classe, sont
   réécrits sous une forme modifiée pour éviter les conflits de noms
   entre les attributs « privés » des classes de base et les classes
   dérivées. Voir la section Identifiants (noms).


2.4. Littéraux
==============

Les littéraux sont des notations pour indiquer des valeurs constantes
de certains types natifs.


2.4.1. Littéraux de chaînes de caractères et de suites d'octets
---------------------------------------------------------------

Les chaînes de caractères littérales sont définies par les définitions
lexicales suivantes :

   stringliteral   ::= [stringprefix](shortstring | longstring)
   stringprefix    ::= "r" | "u" | "R" | "U" | "f" | "F"
                    | "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF"
   shortstring     ::= "'" shortstringitem* "'" | '"' shortstringitem* '"'
   longstring      ::= "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
   shortstringitem ::= shortstringchar | stringescapeseq
   longstringitem  ::= longstringchar | stringescapeseq
   shortstringchar ::= <any source character except "\" or newline or the quote>
   longstringchar  ::= <any source character except "\">
   stringescapeseq ::= "\" <any source character>

   bytesliteral   ::= bytesprefix(shortbytes | longbytes)
   bytesprefix    ::= "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB"
   shortbytes     ::= "'" shortbytesitem* "'" | '"' shortbytesitem* '"'
   longbytes      ::= "'''" longbytesitem* "'''" | '"""' longbytesitem* '"""'
   shortbytesitem ::= shortbyteschar | bytesescapeseq
   longbytesitem  ::= longbyteschar | bytesescapeseq
   shortbyteschar ::= <any ASCII character except "\" or newline or the quote>
   longbyteschar  ::= <any ASCII character except "\">
   bytesescapeseq ::= "\" <any ASCII character>

Une restriction syntaxique non indiquée par ces règles est qu'aucun
blanc n'est autorisé entre le "stringprefix" ou "bytesprefix" et le
reste du littéral. Le jeu de caractères source est défini par la
déclaration d'encodage ; il vaut UTF-8 si aucune déclaration
d'encodage n'est donnée dans le fichier source ; voir la section
Déclaration d'encodage.

In plain English: Both types of literals can be enclosed in matching
single quotes ("'") or double quotes (""").  They can also be enclosed
in matching groups of three single or double quotes (these are
generally referred to as *triple-quoted strings*).  The backslash
("\") character is used to escape characters that otherwise have a
special meaning, such as newline, backslash itself, or the quote
character.

Les littéraux de suites d'octets sont toujours préfixés par "'b'" ou
"'B'" ; cela crée une instance de type "bytes" au lieu du type "str".
Ils ne peuvent contenir que des caractères ASCII ; les octets dont la
valeur est supérieure ou égale à 128 doivent être exprimés à l'aide
d'échappements.

Les chaînes et suites d'octets littérales peuvent être préfixées par
la lettre "'r'" ou "'R'" ; de telles chaînes sont appelées *chaines
brutes* (*raw strings* en anglais) et traitent la barre oblique
inversée comme un caractère normal. En conséquence, les chaînes
littérales "'\U'" et "'\u'" ne sont pas considérées comme spéciales.
Comme les littéraux Unicode de Python 2.x se comportent différemment,
la syntaxe "'ur'" n'est pas reconnue en Python 3.x.

Nouveau dans la version 3.3: le préfixe "'rb'" a été ajouté comme
synonyme de "'br'" pour les littéraux de suites d'octets.la gestion du
préfixe historique pour les chaînes Unicode ("u'chaine'") a été
réintroduite afin de simplifier la maintenance de code compatible
Python 2.x et 3.x. Voir la **PEP 414** pour davantage d'informations.

Une chaîne littérale qui contient "'f'" ou "'F'" dans le préfixe est
une *chaîne de caractères littérale formatée* ; lisez f-strings. Le
"'f'" peut être combiné avec "'r'" mais pas avec "'b'" ou "'u'", donc
les chaînes de caractères formatées sont possibles mais les littéraux
de suites d'octets ne peuvent pas l'être.

Dans les chaînes entre triples guillemets, les sauts de ligne et
guillemets peuvent ne pas être échappés (et sont donc pris en compte),
mais trois guillemets non échappés à la suite terminent le littéral
(on entend par guillemet le caractère utilisé pour commencer le
littéral, c'est-à-dire "'" ou """).


2.4.1.1. Escape sequences
~~~~~~~~~~~~~~~~~~~~~~~~~

À moins que le préfixe "'r'" ou "'R'" ne soit présent, les séquences
d'échappement dans les littéraux de chaînes et suites d'octets sont
interprétées comme elles le seraient par le C Standard. Les séquences
d'échappement reconnues sont :

+---------------------------+-----------------------------------+---------+
| Séquence d'échappement    | Signification                     | Notes   |
|===========================|===================================|=========|
| "\"<newline>              | barre oblique inversée et retour  | (1)     |
|                           | à la ligne ignorés                |         |
+---------------------------+-----------------------------------+---------+
| "\\"                      | barre oblique inversée ("\")      |         |
+---------------------------+-----------------------------------+---------+
| "\'"                      | guillemet simple ("'")            |         |
+---------------------------+-----------------------------------+---------+
| "\""                      | guillemet double (""")            |         |
+---------------------------+-----------------------------------+---------+
| "\a"                      | cloche ASCII (BEL)                |         |
+---------------------------+-----------------------------------+---------+
| "\b"                      | retour arrière ASCII (BS)         |         |
+---------------------------+-----------------------------------+---------+
| "\f"                      | saut de page ASCII (FF)           |         |
+---------------------------+-----------------------------------+---------+
| "\n"                      | saut de ligne ASCII (LF)          |         |
+---------------------------+-----------------------------------+---------+
| "\r"                      | retour à la ligne ASCII (CR)      |         |
+---------------------------+-----------------------------------+---------+
| "\t"                      | tabulation horizontale ASCII      |         |
|                           | (TAB)                             |         |
+---------------------------+-----------------------------------+---------+
| "\v"                      | tabulation verticale ASCII (VT)   |         |
+---------------------------+-----------------------------------+---------+
| "\*ooo*"                  | caractère dont le code est *ooo*  | (2,4)   |
|                           | en octal                          |         |
+---------------------------+-----------------------------------+---------+
| "\x*hh*"                  | caractère dont le code est *ooo*  | (3,4)   |
|                           | en hexadécimal                    |         |
+---------------------------+-----------------------------------+---------+

Les séquences d'échappement reconnues seulement dans les chaînes
littérales sont :

+---------------------------+-----------------------------------+---------+
| Séquence d'échappement    | Signification                     | Notes   |
|===========================|===================================|=========|
| "\N{*name*}"              | caractère dont le nom est *name*  | (5)     |
|                           | dans la base de données Unicode   |         |
+---------------------------+-----------------------------------+---------+
| "\u*xxxx*"                | caractère dont le code est *xxxx* | (6)     |
|                           | en hexadécimal                    |         |
+---------------------------+-----------------------------------+---------+
| "\U*xxxxxxxx*"            | caractère dont le code est        | (7)     |
|                           | *xxxxxxxx* en hexadécimal sur 32  |         |
|                           | bits                              |         |
+---------------------------+-----------------------------------+---------+

Notes :

1. A backslash can be added at the end of a line to ignore the
   newline:

      >>> 'This string will not include \
      ... backslashes or newline characters.'
      'This string will not include backslashes or newline characters.'

   The same result can be achieved using triple-quoted strings, or
   parentheses and string literal concatenation.

2. Comme dans le C Standard, jusqu'à trois chiffres en base huit sont
   acceptés.

   Modifié dans la version 3.11: Octal escapes with value larger than
   "0o377" produce a "DeprecationWarning". In a future Python version
   they will be a "SyntaxWarning" and eventually a "SyntaxError".

3. Contrairement au C Standard, il est obligatoire de fournir deux
   chiffres hexadécimaux.

4. Dans un littéral de suite d'octets, un échappement hexadécimal ou
   octal est un octet dont la valeur est donnée. Dans une chaîne
   littérale, un échappement est un caractère Unicode dont le code est
   donné.

5. Modifié dans la version 3.3: Ajout du support pour les alias de
   noms [1].

6. Exactement quatre chiffres hexadécimaux sont requis.

7. N'importe quel caractère Unicode peut être encodé de cette façon.
   Exactement huit chiffres hexadécimaux sont requis.

Contrairement au C standard, toutes les séquences d'échappement non
reconnues sont laissées inchangées dans la chaîne, c'est-à-dire que
*la barre oblique inversée est laissée dans le résultat* (ce
comportement est utile en cas de débogage : si une séquence
d'échappement est mal tapée, la sortie résultante est plus facilement
reconnue comme source de l'erreur). Notez bien également que les
séquences d'échappement reconnues uniquement dans les littéraux de
chaînes de caractères ne sont pas reconnues pour les littéraux de
suites d'octets.

Modifié dans la version 3.6: Unrecognized escape sequences produce a
"DeprecationWarning".  In a future Python version they will be a
"SyntaxWarning" and eventually a "SyntaxError".

Même dans une chaîne littérale brute, les guillemets peuvent être
échappés avec une barre oblique inversée mais la barre oblique
inversée reste dans le résultat ; par exemple, "r"\""" est une chaîne
de caractères valide composée de deux caractères : une barre oblique
inversée et un guillemet double ; "r"\"" n'est pas une chaîne de
caractères valide (même une chaîne de caractères brute ne peut pas se
terminer par un nombre impair de barres obliques inversées). Plus
précisément, *une chaîne littérale brute ne peut pas se terminer par
une seule barre oblique inversée* (puisque la barre oblique inversée
échappe le guillemet suivant). Notez également qu'une simple barre
oblique inversée suivie d'un saut de ligne est interprétée comme deux
caractères faisant partie du littéral et *non* comme une continuation
de ligne.


2.4.2. Concaténation de chaînes de caractères
---------------------------------------------

Plusieurs chaînes de caractères ou suites d'octets adjacentes
(séparées par des blancs), utilisant éventuellement des conventions de
guillemets différentes, sont autorisées. La signification est la même
que leur concaténation. Ainsi, ""hello" 'world'" est l'équivalent de
""helloworld"". Cette fonctionnalité peut être utilisée pour réduire
le nombre de barres obliques inverses, pour diviser de longues chaînes
de caractères sur plusieurs lignes ou même pour ajouter des
commentaires à des portions de chaînes de caractères. Par exemple :

   re.compile("[A-Za-z_]"       # letter or underscore
              "[A-Za-z0-9_]*"   # letter, digit or underscore
             )

Notez que cette fonctionnalité agit au niveau syntaxique mais est
implémentée au moment de la compilation. Pour concaténer les
expressions des chaînes de caractères au moment de l'exécution, vous
devez utiliser l'opérateur "+". Notez également que la concaténation
littérale peut utiliser un style différent de guillemets pour chaque
composant (et même mélanger des chaînes de caractères brutes et des
chaînes de caractères entre triples guillemets). Enfin, les chaînes de
caractères formatées peuvent être concaténées avec des chaînes de
caractères ordinaires.


2.4.3. f-strings
----------------

Nouveau dans la version 3.6.

Une *chaine de caractères littérale formatée* ou *f-string* est une
chaine de caractères littérale préfixée par "'f'" ou "'F'". Ces
chaines peuvent contenir des champs à remplacer, c'est-à-dire des
expressions délimitées par des accolades "{}". Alors que les autres
littéraux de chaines ont des valeurs constantes, les chaines formatées
sont de vraies expressions évaluées à l'exécution.

Les séquences d'échappement sont décodées comme à l'intérieur des
chaînes de caractères ordinaires (sauf lorsqu'une chaîne de caractères
est également marquée comme une chaîne brute). Après décodage, la
grammaire s'appliquant au contenu de la chaîne de caractères est :

   f_string          ::= (literal_char | "{{" | "}}" | replacement_field)*
   replacement_field ::= "{" f_expression ["="] ["!" conversion] [":" format_spec] "}"
   f_expression      ::= (conditional_expression | "*" or_expr)
                      ("," conditional_expression | "," "*" or_expr)* [","]
                    | yield_expression
   conversion        ::= "s" | "r" | "a"
   format_spec       ::= (literal_char | replacement_field)*
   literal_char      ::= <any code point except "{", "}" or NULL>

Les portions qui sont en dehors des accolades sont traitées comme les
littéraux, sauf les doubles accolades "'{{'" ou "'}}'" qui sont
remplacées par la simple accolade correspondante. Une simple accolade
ouvrante "'{'" marque le début du champ à remplacer, qui commence par
une expression Python. Pour afficher à la fois le texte de
l'expression et sa valeur une fois évaluée (utile lors du débogage),
un signe égal "'='" peut être ajouté après l'expression. Ensuite, il
peut y avoir un champ de conversion, introduit par un point
d'exclamation "'!'". Une spécification de format peut aussi être
rajoutée, introduite par le caractère deux-points "':'". Le champ à
remplacer se termine par une accolade fermante "'}'".

Les expressions dans les chaînes de caractères formatées littérales
sont traitées comme des expressions Python normales entourées de
parenthèses, à quelques exceptions près. Une expression vide n'est pas
autorisée et les expressions "lambda" comme les affectations ":="
doivent être explicitement entourées de parenthèses. Les expressions
de remplacement peuvent contenir des sauts de ligne (par exemple dans
les chaînes de caractères entre triples guillemets) mais elles ne
peuvent pas contenir de commentaire. Chaque expression est évaluée
dans le contexte où la chaîne de caractères formatée apparaît, de
gauche à droite.

Modifié dans la version 3.7: Avant Python 3.7, il était illégal
d’utiliser "await" ainsi que les compréhensions utilisant "async for"
dans les expressions au sein des chaînes de caractères formatées
littérales à cause d’un problème dans l’implémentation.

Lorsqu'un signe égal "'='" est présent, la sortie comprend le texte de
l'expression, le signe "'='" et la valeur calculée. Les espaces après
l'accolade ouvrante "'{'", dans l'expression et après le signe "'='"
sont conservées à l'affichage. Par défaut, le signe "'='" utilise la
"repr()" de l'expression, sauf si un format est indiqué. Quand le
format est indiqué, c'est "str()" de l'expression qui est utilisée à
moins qu'une conversion "!r" ne soit déclarée.

Nouveau dans la version 3.8: le signe égal "'='".

Si une conversion est spécifiée, le résultat de l'évaluation de
l'expression est converti avant d'être formaté. La conversion "'!s'"
appelle "str()" sur le résultat, "'!r'" appelle "repr()" et "'!a'"
appelle "ascii()".

The result is then formatted using the "format()" protocol.  The
format specifier is passed to the "__format__()" method of the
expression or conversion result.  An empty string is passed when the
format specifier is omitted.  The formatted result is then included in
the final value of the whole string.

Top-level format specifiers may include nested replacement fields.
These nested fields may include their own conversion fields and format
specifiers, but may not include more deeply nested replacement fields.
The format specifier mini-language is the same as that used by the
"str.format()" method.

Les chaînes formatées littérales peuvent être concaténées mais les
champs à remplacer ne peuvent pas être divisés entre les littéraux.

Quelques exemples de chaines formatées littérales :

   >>> name = "Fred"
   >>> f"He said his name is {name!r}."
   "He said his name is 'Fred'."
   >>> f"He said his name is {repr(name)}."  # repr() is equivalent to !r
   "He said his name is 'Fred'."
   >>> width = 10
   >>> precision = 4
   >>> value = decimal.Decimal("12.34567")
   >>> f"result: {value:{width}.{precision}}"  # nested fields
   'result:      12.35'
   >>> today = datetime(year=2017, month=1, day=27)
   >>> f"{today:%B %d, %Y}"  # using date format specifier
   'January 27, 2017'
   >>> f"{today=:%B %d, %Y}" # using date format specifier and debugging
   'today=January 27, 2017'
   >>> number = 1024
   >>> f"{number:#0x}"  # using integer format specifier
   '0x400'
   >>> foo = "bar"
   >>> f"{ foo = }" # preserves whitespace
   " foo = 'bar'"
   >>> line = "The mill's closed"
   >>> f"{line = }"
   'line = "The mill\'s closed"'
   >>> f"{line = :20}"
   "line = The mill's closed   "
   >>> f"{line = !r:20}"
   'line = "The mill\'s closed" '

Une conséquence de partager la même syntaxe avec les chaînes
littérales normales est que les caractères dans les champs à remplacer
ne doivent pas entrer en conflit avec le guillemet utilisé pour
encadrer la chaine formatée littérale :

   f"abc {a["x"]} def"    # error: outer string literal ended prematurely
   f"abc {a['x']} def"    # workaround: use different quoting

La barre oblique inversée (ou antislash) n'est pas autorisée dans les
expressions des champs à remplacer et son utilisation génère une
erreur :

   f"newline: {ord('\n')}"  # raises SyntaxError

Pour inclure une valeur où l'échappement par barre oblique inversée
est nécessaire, vous devez créer une variable temporaire.

>>> newline = ord('\n')
>>> f"newline: {newline}"
'newline: 10'

Une chaine formatée littérale ne peut pas être utilisée en tant que
*docstring*, même si elle ne comporte pas d'expression.

   >>> def foo():
   ...     f"Not a docstring"
   ...
   >>> foo.__doc__ is None
   True

Consultez aussi la **PEP 498** qui propose l'ajout des chaines
formatées littérales et "str.format()" qui utilise un mécanisme
similaire pour formater les chaînes de caractères.


2.4.4. Littéraux numériques
---------------------------

Il existe trois types de littéraux numériques : les entiers, les
nombres à virgule flottante et les nombres imaginaires. Il n'y a pas
de littéraux complexes (les nombres complexes peuvent être construits
en ajoutant un nombre réel et un nombre imaginaire).

Notez que les littéraux numériques ne comportent pas de signe ; une
phrase telle que "-1" est en fait une expression composée de
l'opérateur unitaire "-" et du littéral "1".


2.4.5. Entiers littéraux
------------------------

Les entiers littéraux sont décrits par les définitions lexicales
suivantes :

   integer      ::= decinteger | bininteger | octinteger | hexinteger
   decinteger   ::= nonzerodigit (["_"] digit)* | "0"+ (["_"] "0")*
   bininteger   ::= "0" ("b" | "B") (["_"] bindigit)+
   octinteger   ::= "0" ("o" | "O") (["_"] octdigit)+
   hexinteger   ::= "0" ("x" | "X") (["_"] hexdigit)+
   nonzerodigit ::= "1"..."9"
   digit        ::= "0"..."9"
   bindigit     ::= "0" | "1"
   octdigit     ::= "0"..."7"
   hexdigit     ::= digit | "a"..."f" | "A"..."F"

Il n'y a pas de limite pour la longueur des entiers littéraux, sauf
celle relative à la capacité mémoire.

Les tirets bas sont ignorés pour déterminer la valeur numérique du
littéral. Ils peuvent être utilisés pour grouper les chiffres afin de
faciliter la lecture. Un souligné peut être placé entre des chiffres
ou après la spécification de la base telle que "0x".

Notez que placer des zéros en tête de nombre pour un nombre décimal
différent de zéro n'est pas autorisé. Cela permet d'éviter l’ambigüité
avec les littéraux en base octale selon le style C que Python
utilisait avant la version 3.0.

Quelques exemples d'entiers littéraux :

   7     2147483647                        0o177    0b100110111
   3     79228162514264337593543950336     0o377    0xdeadbeef
         100_000_000_000                   0b_1110_0101

Modifié dans la version 3.6: Les tirets bas ne sont pas autorisés pour
grouper les littéraux.


2.4.6. Nombres à virgule flottante littéraux
--------------------------------------------

Les nombres à virgule flottante littéraux sont décrits par les
définitions lexicales suivantes :

   floatnumber   ::= pointfloat | exponentfloat
   pointfloat    ::= [digitpart] fraction | digitpart "."
   exponentfloat ::= (digitpart | pointfloat) exponent
   digitpart     ::= digit (["_"] digit)*
   fraction      ::= "." digitpart
   exponent      ::= ("e" | "E") ["+" | "-"] digitpart

Notez que la partie entière et l'exposant sont toujours interprétés
comme étant en base 10. Par exemple, "077e010" est licite et désigne
le même nombre que "77e10". La plage autorisée pour les littéraux de
nombres à virgule flottante dépend de l'implémentation. Comme pour les
entiers littéraux, les soulignés permettent de grouper des chiffres.

Quelques exemples de nombres à virgule flottante littéraux :

   3.14    10.    .001    1e100    3.14e-10    0e0    3.14_15_93

Modifié dans la version 3.6: Les tirets bas ne sont pas autorisés pour
grouper les littéraux.


2.4.7. Imaginaires littéraux
----------------------------

Les nombres imaginaires sont décrits par les définitions lexicales
suivantes :

   imagnumber ::= (floatnumber | digitpart) ("j" | "J")

Un littéral imaginaire produit un nombre complexe dont la partie
réelle est "0.0". Les nombres complexes sont représentés comme une
paire de nombres à virgule flottante et possèdent les mêmes
restrictions concernant les plages autorisées. Pour créer un nombre
complexe dont la partie réelle est non nulle, ajoutez un nombre à
virgule flottante à votre littéral imaginaire. Par exemple "(3+4j)".
Voici d'autres exemples de littéraux imaginaires :

   3.14j   10.j    10j     .001j   1e100j   3.14e-10j   3.14_15_93j


2.5. Opérateurs
===============

Les lexèmes suivants sont des opérateurs :

   +       -       *       **      /       //      %      @
   <<      >>      &       |       ^       ~       :=
   <       >       <=      >=      ==      !=


2.6. Délimiteurs
================

Les lexèmes suivants servent de délimiteurs dans la grammaire :

   (       )       [       ]       {       }
   ,       :       .       ;       @       =       ->
   +=      -=      *=      /=      //=     %=      @=
   &=      |=      ^=      >>=     <<=     **=

Le point peut aussi apparaître dans les littéraux de nombres à virgule
flottante et imaginaires. Une suite de trois points possède une
signification spéciale : c'est une ellipse littérale. La deuxième
partie de la liste, les opérateurs d'affectation augmentés, servent de
délimiteurs pour l'analyseur lexical mais sont aussi des opérateurs.

Les caractères ASCII suivants ont une signification spéciale en tant
que partie d'autres lexèmes ou ont une signification particulière pour
l'analyseur lexical :

   '       "       #       \

Les caractères ASCII suivants ne sont pas utilisés en Python. S'ils
apparaissent en dehors de chaines littérales ou de commentaires, ils
produisent une erreur :

   $       ?       `

-[ Notes ]-

[1] https://www.unicode.org/Public/11.0.0/ucd/NameAliases.txt
