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.

Si aucune déclaration d'encodage n'est trouvée, l'encodage par défaut
est utilisé : UTF-8. En plus, si les premiers octets du fichier sont
l'indicateur d'ordre des octets UTF-8 ("b'\xef\xbb\xbf'", *BOM* en
anglais pour *byte order mark*), le fichier est considéré comme étant
en UTF-8 (cette convention est reconnue, entre autres, par **notepad**
de Microsoft).

Si un encodage est déclaré, le nom de l'encodage doit être reconnu par
Python. 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* -- liste explicite des caractères de PropList.txt
  pour la compatibilité descendante

* *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 4.1 can be found at
https://www.unicode.org/Public/13.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. 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 :

"_*"
   L'identifiant spécial "_" n'est pas importé par "from module import
   *". Il est utilisé dans l'interpréteur interactif pour stocker le
   résultat de la dernière évaluation ; il est stocké dans le module
   "builtins". Lorsque vous n'êtes pas en mode interactif, "_" n'a pas
   de signification particulière et n'est pas défini. Voir la section
   L'instruction import.

   Note:

     Le nom "_" est souvent utilisé pour internationaliser l'affichage
     ; reportez-vous à la documentation du module "gettext" pour plus
     d'informations sur cette convention.

"__*__"
   System-defined names, informally known as "dunder" names. These
   names are defined by the interpreter and its implementation
   (including the standard library). Current system names are
   discussed in the Méthodes spéciales section and elsewhere. More
   will likely be defined in future versions of Python.  *Any* use of
   "__*__" names, in any context, that does not follow explicitly
   documented use, is subject to breakage without warning.

"__*"
   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.

Description en français : les deux types de littéraux peuvent être
encadrés par une paire de guillemets simples ("'") ou doubles (""").
Ils peuvent aussi être encadrés par une paire de trois guillemets
simples ou une paire de trois guillemets doubles (on appelle alors
généralement ces chaînes *entre triples guillemets*). La barre oblique
inversée peut être utilisée pour échapper des caractères qui auraient
sinon une signification spéciale, tels que le retour à la ligne, la
barre oblique inversée elle-même ou le guillemet utilisé pour
délimiter la chaîne.

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.

Nouveau dans la version 3.3: le support du préfixe historique pour les
chaînes Unicode a été réintroduit 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 Chaînes de
caractères formatées littérales. 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 """).

À 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          | Signification                     | Notes   |
| d'échappement     |                                   |         |
|===================|===================================|=========|
| "\newline"        | barre oblique inversée et retour  |         |
|                   | à 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*  | (1,3)   |
|                   | en octal                          |         |
+-------------------+-----------------------------------+---------+
| "\xhh"            | caractère dont le code est *ooo*  | (2,3)   |
|                   | en hexadécimal                    |         |
+-------------------+-----------------------------------+---------+

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

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

Notes :

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

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

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

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

5. Exactement quatre chiffres hexadécimaux sont requis.

6. 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: Les séquences d'échappement non
   reconnues produisent un avertissement DeprecationWarning. Dans les
   futures versions de Python, elles génèreront une erreur de syntaxe.

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. Chaînes de caractères formatées littérales
-------------------------------------------------

Nouveau dans la version 3.6.

Une *chaine de caractères formatée littérale* 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 | NULL | 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. Après l'expression, il peut y avoir un champ de
conversion, introduit par un point d'exclamation "'!'". Une
spécification de format peut aussi être ajouté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 une expression "lambda" doit être explicitement entourée
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: Prior to Python 3.7, an "await"
expression and comprehensions containing an "async for" clause were
illegal in the expressions in formatted string literals due to a
problem with the implementation.

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()".

Le résultat est ensuite formaté en utilisant le protocole de
"format()". La spécification du format est passée à la méthode
"__format__()" de l'expression ou du résultat de la conversion. Une
chaîne vide est passée lorsque la spécification de format est omise.
Le résultat formaté est alors inclus dans la valeur finale de la
chaîne complète.

Les spécifications de format peuvent inclure des champs de
remplacement imbriqués. Ces champs imbriqués peuvent inclure leurs
propres champs de conversion et spécifications de format mais
l'imbrication ne doit pas aller plus profond. Le mini-langage de
spécification de format est le même que celui utilisé par la méthode
".format()" du type "str".

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'
   >>> number = 1024
   >>> f"{number:#0x}"  # using integer format specifier
   '0x400'

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'assignation 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] http://www.unicode.org/Public/11.0.0/ucd/NameAliases.txt
