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 uses the 7-bit ASCII character set for program text.

Nouveau dans la version 2.3: An encoding declaration can be used to
indicate that  string literals and comments use an encoding different
from ASCII.

For compatibility with older versions, Python only warns if it finds
8-bit characters; those warnings should be corrected by either
declaring an explicit encoding, or using escape sequences if those
bytes are binary data, instead of characters.

The run-time character set depends on the I/O devices connected to the
program but is generally a superset of ASCII.

**Future compatibility note:** It may be tempting to assume that the
character set for 8-bit characters is ISO Latin-1 (an ASCII superset
that covers most western languages that use the Latin alphabet), but
it is possible that in the future Unicode text editors will become
common.  These generally use the UTF-8 encoding, which is also an
ASCII superset, but with very different use for the characters with
ordinals 128-255.  While there is no consensus on this subject yet, it
is unwise to assume either Latin-1 or UTF-8, even though the current
implementation appears to favor Latin-1.  This applies both to the
source character set and the run-time character set.


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

A physical line is a sequence of characters terminated by an end-of-
line sequence.  In source files and strings, any of the standard
platform line termination sequences can be used - the Unix form using
ASCII LF (linefeed), the Windows form using the ASCII sequence CR LF
(return followed by linefeed), or the old Macintosh form using the
ASCII CR (return) character.  All of these forms can be used equally,
regardless of platform. The end of input also serves as an implicit
terminator for the final physical line.

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>

which is recognized by Bram Moolenaar’s VIM. In addition, if the first
bytes of the file are the UTF-8 byte-order mark ("'\xef\xbb\xbf'"),
the declared file encoding is UTF-8 (this is supported, among others,
by Microsoft’s **notepad**).

If an encoding is declared, the encoding name must be recognized by
Python. The encoding is used for all lexical analysis, in particular
to find the end of a string, and to interpret the contents of Unicode
literals. String literals are converted to Unicode for syntactical
analysis, then converted back to their original encoding before
interpretation starts.


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

A logical line that contains only spaces, tabs, formfeeds and possibly
a comment, is ignored (i.e., no NEWLINE token is generated).  During
interactive input of statements, handling of a blank line may differ
depending on the implementation of the read-eval-print loop.  In the
standard implementation, an entirely blank logical line (i.e. one
containing not even whitespace or a comment) terminates a multi-line
statement.


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.

First, tabs are replaced (from left to right) by one to eight spaces
such that the total number of characters up to and including the
replacement is a multiple of eight (this is intended to be the same
rule as used by Unix).  The total number of spaces preceding the first
non-blank character then determines the line’s indentation.
Indentation cannot be split over multiple physical lines using
backslashes; the whitespace up to the first backslash determines the
indentation.

**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
==============================

Identifiers (also referred to as *names*) are described by the
following lexical definitions:

   identifier ::= (letter|"_") (letter | digit | "_")*
   letter     ::= lowercase | uppercase
   lowercase  ::= "a"..."z"
   uppercase  ::= "A"..."Z"
   digit      ::= "0"..."9"

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


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 :

   and       del       from      not       while
   as        elif      global    or        with
   assert    else      if        pass      yield
   break     except    import    print
   class     exec      in        raise
   continue  finally   is        return
   def       for       lambda    try

Modifié dans la version 2.4: "None" became a constant and is now
recognized by the compiler as a name for the built-in object "None".
Although it is not a keyword, you cannot assign a different object to
it.

Modifié dans la version 2.5: Using "as" and "with" as identifiers
triggers a warning.  To use them as keywords, enable the
"with_statement" future feature .

Modifié dans la version 2.6: "as" and "with" are full keywords.


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 :

"_*"
   Not imported by "from module import *".  The special identifier "_"
   is used in the interactive interpreter to store the result of the
   last evaluation; it is stored in the "__builtin__" module.  When
   not in interactive mode, "_" has no special meaning and is not
   defined. See 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.

"__*__"
   Noms définis par le système. 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. String literals
----------------------

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

   stringliteral   ::= [stringprefix](shortstring | longstring)
   stringprefix    ::= "r" | "u" | "ur" | "R" | "U" | "UR" | "Ur" | "uR"
                    | "b" | "B" | "br" | "Br" | "bR" | "BR"
   shortstring     ::= "'" shortstringitem* "'" | '"' shortstringitem* '"'
   longstring      ::= "'''" longstringitem* "'''"
                  | '"""' longstringitem* '"""'
   shortstringitem ::= shortstringchar | escapeseq
   longstringitem  ::= longstringchar | escapeseq
   shortstringchar ::= <any source character except "\" or newline or the quote>
   longstringchar  ::= <any source character except "\">
   escapeseq       ::= "\" <any ASCII character>

One syntactic restriction not indicated by these productions is that
whitespace is not allowed between the "stringprefix" and the rest of
the string literal. The source character set is defined by the
encoding declaration; it is ASCII if no encoding declaration is given
in the source file; see section Déclaration d’encodage.

In plain English: String 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.
String literals may optionally be prefixed with a letter "'r'" or
"'R'"; such strings are called *raw strings* and use different rules
for interpreting backslash escape sequences.  A prefix of "'u'" or
"'U'" makes the string a Unicode string.  Unicode strings use the
Unicode character set as defined by the Unicode Consortium and ISO
10646.  Some additional escape sequences, described below, are
available in Unicode strings. A prefix of "'b'" or "'B'" is ignored in
Python 2; it indicates that the literal should become a bytes literal
in Python 3 (e.g. when code is automatically converted with 2to3).  A
"'u'" or "'b'" prefix may be followed by an "'r'" prefix.

In triple-quoted strings, unescaped newlines and quotes are allowed
(and are retained), except that three unescaped quotes in a row
terminate the string.  (A « quote » is the character used to open the
string, i.e. either "'" or """.)

Unless an "'r'" or "'R'" prefix is present, escape sequences in
strings are interpreted according to rules similar to those used by
Standard C.  The recognized escape sequences are:

+-------------------+-----------------------------------+---------+
| Séquence          | Signification                     | Notes   |
| d’échappement     |                                   |         |
+===================+===================================+=========+
| "\newline"        | Ignoré                            |         |
+-------------------+-----------------------------------+---------+
| "\\"              | 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)          |         |
+-------------------+-----------------------------------+---------+
| "\N{name}"        | Character named *name* in the     |         |
|                   | Unicode database (Unicode only)   |         |
+-------------------+-----------------------------------+---------+
| "\r"              | retour à la ligne ASCII (CR)      |         |
+-------------------+-----------------------------------+---------+
| "\t"              | tabulation horizontale ASCII      |         |
|                   | (TAB)                             |         |
+-------------------+-----------------------------------+---------+
| "\uxxxx"          | Character with 16-bit hex value   | (1)     |
|                   | *xxxx* (Unicode only)             |         |
+-------------------+-----------------------------------+---------+
| "\Uxxxxxxxx"      | Character with 32-bit hex value   | (2)     |
|                   | *xxxxxxxx* (Unicode only)         |         |
+-------------------+-----------------------------------+---------+
| "\v"              | tabulation verticale ASCII (VT)   |         |
+-------------------+-----------------------------------+---------+
| "\ooo"            | caractère dont le code est *ooo*  | (3,5)   |
|                   | en octal                          |         |
+-------------------+-----------------------------------+---------+
| "\xhh"            | caractère dont le code est *ooo*  | (4,5)   |
|                   | en hexadécimal                    |         |
+-------------------+-----------------------------------+---------+

Notes :

1. Individual code units which form parts of a surrogate pair can
   be encoded using this escape sequence.

2. Any Unicode character can be encoded this way, but characters
   outside the Basic Multilingual Plane (BMP) will be encoded using a
   surrogate pair if Python is compiled to use 16-bit code units (the
   default).

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

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

5. In a string literal, hexadecimal and octal escapes denote the
   byte with the given value; it is not necessary that the byte
   encodes a character in the source character set. In a Unicode
   literal, these escapes denote a Unicode character with the given
   value.

Unlike Standard C, all unrecognized escape sequences are left in the
string unchanged, i.e., *the backslash is left in the string*.  (This
behavior is useful when debugging: if an escape sequence is mistyped,
the resulting output is more easily recognized as broken.)  It is also
important to note that the escape sequences marked as « (Unicode only)
» in the table above fall into the category of unrecognized escapes
for non-Unicode string literals.

When an "'r'" or "'R'" prefix is present, a character following a
backslash is included in the string without change, and *all
backslashes are left in the string*.  For example, the string literal
"r"\n"" consists of two characters: a backslash and a lowercase "'n'".
String quotes can be escaped with a backslash, but the backslash
remains in the string; for example, "r"\""" is a valid string literal
consisting of two characters: a backslash and a double quote; "r"\""
is not a valid string literal (even a raw string cannot end in an odd
number of backslashes).  Specifically, *a raw string cannot end in a
single backslash* (since the backslash would escape the following
quote character).  Note also that a single backslash followed by a
newline is interpreted as those two characters as part of the string,
*not* as a line continuation.

When an "'r'" or "'R'" prefix is used in conjunction with a "'u'" or
"'U'" prefix, then the "\uXXXX" and "\UXXXXXXXX" escape sequences are
processed while  *all other backslashes are left in the string*. For
example, the string literal "ur"\u0062\n"" consists of three Unicode
characters: “LATIN SMALL LETTER B”, “REVERSE SOLIDUS”, and “LATIN
SMALL LETTER N”. Backslashes can be escaped with a preceding
backslash; however, both remain in the string.  As a result, "\uXXXX"
escape sequences are only recognized when there are an odd number of
backslashes.


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

Multiple adjacent string literals (delimited by whitespace), possibly
using different quoting conventions, are allowed, and their meaning is
the same as their concatenation.  Thus, ""hello" 'world'" is
equivalent to ""helloworld"".  This feature can be used to reduce the
number of backslashes needed, to split long strings conveniently
across long lines, or even to add comments to parts of strings, for
example:

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

Note that this feature is defined at the syntactical level, but
implemented at compile time.  The “+” operator must be used to
concatenate string expressions at run time.  Also note that literal
concatenation can use different quoting styles for each component
(even mixing raw strings and triple quoted strings).


2.4.3. Littéraux numériques
---------------------------

There are four types of numeric literals: plain integers, long
integers, floating point numbers, and imaginary numbers.  There are no
complex literals (complex numbers can be formed by adding a real
number and an imaginary number).

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.4. Integer and long integer literals
----------------------------------------

Integer and long integer literals are described by the following
lexical definitions:

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

Although both lower case "'l'" and upper case "'L'" are allowed as
suffix for long integers, it is strongly recommended to always use
"'L'", since the letter "'l'" looks too much like the digit "'1'".

Plain integer literals that are above the largest representable plain
integer (e.g., 2147483647 when using 32-bit arithmetic) are accepted
as if they were long integers instead. [1]  There is no limit for long
integer literals apart from what can be stored in available memory.

Some examples of plain integer literals (first row) and long integer
literals (second and third rows):

   7     2147483647                        0177
   3L    79228162514264337593543950336L    0377L   0x100000000L
         79228162514264337593543950336             0xdeadbeef


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

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

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

Note that the integer and exponent parts of floating point numbers can
look like octal integers, but are interpreted using radix 10.  For
example, "077e010" is legal, and denotes the same number as "77e10".
The allowed range of floating point literals is implementation-
dependent. Some examples of floating point literals:

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

Note that numeric literals do not include a sign; a phrase like "-1"
is actually an expression composed of the unary operator "-" and the
literal "1".


2.4.6. Imaginaires littéraux
----------------------------

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

   imagnumber ::= (floatnumber | intpart) ("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


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

Les lexèmes suivants sont des opérateurs :

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

The comparison operators "<>" and "!=" are alternate spellings of the
same operator.  "!=" is the preferred spelling; "<>" is obsolescent.


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

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

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

The period can also occur in floating-point and imaginary literals.  A
sequence of three periods has a special meaning as an ellipsis in
slices. The second half of the list, the augmented assignment
operators, serve lexically as delimiters, but also perform an
operation.

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] In versions of Python prior to 2.4, octal and hexadecimal
    literals in the range just above the largest representable plain
    integer but below the largest unsigned 32-bit number (on a machine
    using 32-bit arithmetic), 4294967296, were taken as the negative
    plain integer obtained by subtracting 4294967296 from their
    unsigned value.
