PageRenderTime 432ms CodeModel.GetById 202ms app.highlight 90ms RepoModel.GetById 131ms app.codeStats 1ms

/Doc/reference/lexical_analysis.rst

http://unladen-swallow.googlecode.com/
ReStructuredText | 764 lines | 569 code | 195 blank | 0 comment | 0 complexity | 2d2b082c3b7944d650aa47971f87d75c MD5 | raw file
  1
  2.. _lexical:
  3
  4****************
  5Lexical analysis
  6****************
  7
  8.. index::
  9   single: lexical analysis
 10   single: parser
 11   single: token
 12
 13A Python program is read by a *parser*.  Input to the parser is a stream of
 14*tokens*, generated by the *lexical analyzer*.  This chapter describes how the
 15lexical analyzer breaks a file into tokens.
 16
 17Python uses the 7-bit ASCII character set for program text.
 18
 19.. versionadded:: 2.3
 20   An encoding declaration can be used to indicate that  string literals and
 21   comments use an encoding different from ASCII.
 22
 23For compatibility with older versions, Python only warns if it finds 8-bit
 24characters; those warnings should be corrected by either declaring an explicit
 25encoding, or using escape sequences if those bytes are binary data, instead of
 26characters.
 27
 28The run-time character set depends on the I/O devices connected to the program
 29but is generally a superset of ASCII.
 30
 31**Future compatibility note:** It may be tempting to assume that the character
 32set for 8-bit characters is ISO Latin-1 (an ASCII superset that covers most
 33western languages that use the Latin alphabet), but it is possible that in the
 34future Unicode text editors will become common.  These generally use the UTF-8
 35encoding, which is also an ASCII superset, but with very different use for the
 36characters with ordinals 128-255.  While there is no consensus on this subject
 37yet, it is unwise to assume either Latin-1 or UTF-8, even though the current
 38implementation appears to favor Latin-1.  This applies both to the source
 39character set and the run-time character set.
 40
 41
 42.. _line-structure:
 43
 44Line structure
 45==============
 46
 47.. index:: single: line structure
 48
 49A Python program is divided into a number of *logical lines*.
 50
 51
 52.. _logical:
 53
 54Logical lines
 55-------------
 56
 57.. index::
 58   single: logical line
 59   single: physical line
 60   single: line joining
 61   single: NEWLINE token
 62
 63The end of a logical line is represented by the token NEWLINE.  Statements
 64cannot cross logical line boundaries except where NEWLINE is allowed by the
 65syntax (e.g., between statements in compound statements). A logical line is
 66constructed from one or more *physical lines* by following the explicit or
 67implicit *line joining* rules.
 68
 69
 70.. _physical:
 71
 72Physical lines
 73--------------
 74
 75A physical line is a sequence of characters terminated by an end-of-line
 76sequence.  In source files, any of the standard platform line termination
 77sequences can be used - the Unix form using ASCII LF (linefeed), the Windows
 78form using the ASCII sequence CR LF (return followed by linefeed), or the old
 79Macintosh form using the ASCII CR (return) character.  All of these forms can be
 80used equally, regardless of platform.
 81
 82When embedding Python, source code strings should be passed to Python APIs using
 83the standard C conventions for newline characters (the ``\n`` character,
 84representing ASCII LF, is the line terminator).
 85
 86
 87.. _comments:
 88
 89Comments
 90--------
 91
 92.. index::
 93   single: comment
 94   single: hash character
 95
 96A comment starts with a hash character (``#``) that is not part of a string
 97literal, and ends at the end of the physical line.  A comment signifies the end
 98of the logical line unless the implicit line joining rules are invoked. Comments
 99are ignored by the syntax; they are not tokens.
100
101
102.. _encodings:
103
104Encoding declarations
105---------------------
106
107.. index::
108   single: source character set
109   single: encodings
110
111If a comment in the first or second line of the Python script matches the
112regular expression ``coding[=:]\s*([-\w.]+)``, this comment is processed as an
113encoding declaration; the first group of this expression names the encoding of
114the source code file. The recommended forms of this expression are ::
115
116   # -*- coding: <encoding-name> -*-
117
118which is recognized also by GNU Emacs, and ::
119
120   # vim:fileencoding=<encoding-name>
121
122which is recognized by Bram Moolenaar's VIM. In addition, if the first bytes of
123the file are the UTF-8 byte-order mark (``'\xef\xbb\xbf'``), the declared file
124encoding is UTF-8 (this is supported, among others, by Microsoft's
125:program:`notepad`).
126
127If an encoding is declared, the encoding name must be recognized by Python. The
128encoding is used for all lexical analysis, in particular to find the end of a
129string, and to interpret the contents of Unicode literals. String literals are
130converted to Unicode for syntactical analysis, then converted back to their
131original encoding before interpretation starts. The encoding declaration must
132appear on a line of its own.
133
134.. XXX there should be a list of supported encodings.
135
136
137.. _explicit-joining:
138
139Explicit line joining
140---------------------
141
142.. index::
143   single: physical line
144   single: line joining
145   single: line continuation
146   single: backslash character
147
148Two or more physical lines may be joined into logical lines using backslash
149characters (``\``), as follows: when a physical line ends in a backslash that is
150not part of a string literal or comment, it is joined with the following forming
151a single logical line, deleting the backslash and the following end-of-line
152character.  For example::
153
154   if 1900 < year < 2100 and 1 <= month <= 12 \
155      and 1 <= day <= 31 and 0 <= hour < 24 \
156      and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
157           return 1
158
159A line ending in a backslash cannot carry a comment.  A backslash does not
160continue a comment.  A backslash does not continue a token except for string
161literals (i.e., tokens other than string literals cannot be split across
162physical lines using a backslash).  A backslash is illegal elsewhere on a line
163outside a string literal.
164
165
166.. _implicit-joining:
167
168Implicit line joining
169---------------------
170
171Expressions in parentheses, square brackets or curly braces can be split over
172more than one physical line without using backslashes. For example::
173
174   month_names = ['Januari', 'Februari', 'Maart',      # These are the
175                  'April',   'Mei',      'Juni',       # Dutch names
176                  'Juli',    'Augustus', 'September',  # for the months
177                  'Oktober', 'November', 'December']   # of the year
178
179Implicitly continued lines can carry comments.  The indentation of the
180continuation lines is not important.  Blank continuation lines are allowed.
181There is no NEWLINE token between implicit continuation lines.  Implicitly
182continued lines can also occur within triple-quoted strings (see below); in that
183case they cannot carry comments.
184
185
186.. _blank-lines:
187
188Blank lines
189-----------
190
191.. index:: single: blank line
192
193A logical line that contains only spaces, tabs, formfeeds and possibly a
194comment, is ignored (i.e., no NEWLINE token is generated).  During interactive
195input of statements, handling of a blank line may differ depending on the
196implementation of the read-eval-print loop.  In the standard implementation, an
197entirely blank logical line (i.e. one containing not even whitespace or a
198comment) terminates a multi-line statement.
199
200
201.. _indentation:
202
203Indentation
204-----------
205
206.. index::
207   single: indentation
208   single: whitespace
209   single: leading whitespace
210   single: space
211   single: tab
212   single: grouping
213   single: statement grouping
214
215Leading whitespace (spaces and tabs) at the beginning of a logical line is used
216to compute the indentation level of the line, which in turn is used to determine
217the grouping of statements.
218
219First, tabs are replaced (from left to right) by one to eight spaces such that
220the total number of characters up to and including the replacement is a multiple
221of eight (this is intended to be the same rule as used by Unix).  The total
222number of spaces preceding the first non-blank character then determines the
223line's indentation.  Indentation cannot be split over multiple physical lines
224using backslashes; the whitespace up to the first backslash determines the
225indentation.
226
227**Cross-platform compatibility note:** because of the nature of text editors on
228non-UNIX platforms, it is unwise to use a mixture of spaces and tabs for the
229indentation in a single source file.  It should also be noted that different
230platforms may explicitly limit the maximum indentation level.
231
232A formfeed character may be present at the start of the line; it will be ignored
233for the indentation calculations above.  Formfeed characters occurring elsewhere
234in the leading whitespace have an undefined effect (for instance, they may reset
235the space count to zero).
236
237.. index::
238   single: INDENT token
239   single: DEDENT token
240
241The indentation levels of consecutive lines are used to generate INDENT and
242DEDENT tokens, using a stack, as follows.
243
244Before the first line of the file is read, a single zero is pushed on the stack;
245this will never be popped off again.  The numbers pushed on the stack will
246always be strictly increasing from bottom to top.  At the beginning of each
247logical line, the line's indentation level is compared to the top of the stack.
248If it is equal, nothing happens. If it is larger, it is pushed on the stack, and
249one INDENT token is generated.  If it is smaller, it *must* be one of the
250numbers occurring on the stack; all numbers on the stack that are larger are
251popped off, and for each number popped off a DEDENT token is generated.  At the
252end of the file, a DEDENT token is generated for each number remaining on the
253stack that is larger than zero.
254
255Here is an example of a correctly (though confusingly) indented piece of Python
256code::
257
258   def perm(l):
259           # Compute the list of all permutations of l
260       if len(l) <= 1:
261                     return [l]
262       r = []
263       for i in range(len(l)):
264                s = l[:i] + l[i+1:]
265                p = perm(s)
266                for x in p:
267                 r.append(l[i:i+1] + x)
268       return r
269
270The following example shows various indentation errors::
271
272    def perm(l):                       # error: first line indented
273   for i in range(len(l)):             # error: not indented
274       s = l[:i] + l[i+1:]
275           p = perm(l[:i] + l[i+1:])   # error: unexpected indent
276           for x in p:
277                   r.append(l[i:i+1] + x)
278               return r                # error: inconsistent dedent
279
280(Actually, the first three errors are detected by the parser; only the last
281error is found by the lexical analyzer --- the indentation of ``return r`` does
282not match a level popped off the stack.)
283
284
285.. _whitespace:
286
287Whitespace between tokens
288-------------------------
289
290Except at the beginning of a logical line or in string literals, the whitespace
291characters space, tab and formfeed can be used interchangeably to separate
292tokens.  Whitespace is needed between two tokens only if their concatenation
293could otherwise be interpreted as a different token (e.g., ab is one token, but
294a b is two tokens).
295
296
297.. _other-tokens:
298
299Other tokens
300============
301
302Besides NEWLINE, INDENT and DEDENT, the following categories of tokens exist:
303*identifiers*, *keywords*, *literals*, *operators*, and *delimiters*. Whitespace
304characters (other than line terminators, discussed earlier) are not tokens, but
305serve to delimit tokens. Where ambiguity exists, a token comprises the longest
306possible string that forms a legal token, when read from left to right.
307
308
309.. _identifiers:
310
311Identifiers and keywords
312========================
313
314.. index::
315   single: identifier
316   single: name
317
318Identifiers (also referred to as *names*) are described by the following lexical
319definitions:
320
321.. productionlist::
322   identifier: (`letter`|"_") (`letter` | `digit` | "_")*
323   letter: `lowercase` | `uppercase`
324   lowercase: "a"..."z"
325   uppercase: "A"..."Z"
326   digit: "0"..."9"
327
328Identifiers are unlimited in length.  Case is significant.
329
330
331.. _keywords:
332
333Keywords
334--------
335
336.. index::
337   single: keyword
338   single: reserved word
339
340The following identifiers are used as reserved words, or *keywords* of the
341language, and cannot be used as ordinary identifiers.  They must be spelled
342exactly as written here:
343
344.. sourcecode:: text
345
346   and       del       from      not       while
347   as        elif      global    or        with
348   assert    else      if        pass      yield
349   break     except    import    print
350   class     exec      in        raise
351   continue  finally   is        return
352   def       for       lambda    try
353
354.. versionchanged:: 2.4
355   :const:`None` became a constant and is now recognized by the compiler as a name
356   for the built-in object :const:`None`.  Although it is not a keyword, you cannot
357   assign a different object to it.
358
359.. versionchanged:: 2.5
360   Both :keyword:`as` and :keyword:`with` are only recognized when the
361   ``with_statement`` future feature has been enabled. It will always be enabled in
362   Python 2.6.  See section :ref:`with` for details.  Note that using :keyword:`as`
363   and :keyword:`with` as identifiers will always issue a warning, even when the
364   ``with_statement`` future directive is not in effect.
365
366
367.. _id-classes:
368
369Reserved classes of identifiers
370-------------------------------
371
372Certain classes of identifiers (besides keywords) have special meanings.  These
373classes are identified by the patterns of leading and trailing underscore
374characters:
375
376``_*``
377   Not imported by ``from module import *``.  The special identifier ``_`` is used
378   in the interactive interpreter to store the result of the last evaluation; it is
379   stored in the :mod:`__builtin__` module.  When not in interactive mode, ``_``
380   has no special meaning and is not defined. See section :ref:`import`.
381
382   .. note::
383
384      The name ``_`` is often used in conjunction with internationalization;
385      refer to the documentation for the :mod:`gettext` module for more
386      information on this convention.
387
388``__*__``
389   System-defined names.  These names are defined by the interpreter and its
390   implementation (including the standard library); applications should not expect
391   to define additional names using this convention.  The set of names of this
392   class defined by Python may be extended in future versions. See section
393   :ref:`specialnames`.
394
395``__*``
396   Class-private names.  Names in this category, when used within the context of a
397   class definition, are re-written to use a mangled form to help avoid name
398   clashes between "private" attributes of base and derived classes. See section
399   :ref:`atom-identifiers`.
400
401
402.. _literals:
403
404Literals
405========
406
407.. index::
408   single: literal
409   single: constant
410
411Literals are notations for constant values of some built-in types.
412
413
414.. _strings:
415
416String literals
417---------------
418
419.. index:: single: string literal
420
421String literals are described by the following lexical definitions:
422
423.. index:: single: ASCII@ASCII
424
425.. productionlist::
426   stringliteral: [`stringprefix`](`shortstring` | `longstring`)
427   stringprefix: "r" | "u" | "ur" | "R" | "U" | "UR" | "Ur" | "uR"
428   shortstring: "'" `shortstringitem`* "'" | '"' `shortstringitem`* '"'
429   longstring: "'''" `longstringitem`* "'''"
430             : | '"""' `longstringitem`* '"""'
431   shortstringitem: `shortstringchar` | `escapeseq`
432   longstringitem: `longstringchar` | `escapeseq`
433   shortstringchar: <any source character except "\" or newline or the quote>
434   longstringchar: <any source character except "\">
435   escapeseq: "\" <any ASCII character>
436
437One syntactic restriction not indicated by these productions is that whitespace
438is not allowed between the :token:`stringprefix` and the rest of the string
439literal. The source character set is defined by the encoding declaration; it is
440ASCII if no encoding declaration is given in the source file; see section
441:ref:`encodings`.
442
443.. index::
444   single: triple-quoted string
445   single: Unicode Consortium
446   single: string; Unicode
447   single: raw string
448
449In plain English: String literals can be enclosed in matching single quotes
450(``'``) or double quotes (``"``).  They can also be enclosed in matching groups
451of three single or double quotes (these are generally referred to as
452*triple-quoted strings*).  The backslash (``\``) character is used to escape
453characters that otherwise have a special meaning, such as newline, backslash
454itself, or the quote character.  String literals may optionally be prefixed with
455a letter ``'r'`` or ``'R'``; such strings are called :dfn:`raw strings` and use
456different rules for interpreting backslash escape sequences.  A prefix of
457``'u'`` or ``'U'`` makes the string a Unicode string.  Unicode strings use the
458Unicode character set as defined by the Unicode Consortium and ISO 10646.  Some
459additional escape sequences, described below, are available in Unicode strings.
460The two prefix characters may be combined; in this case, ``'u'`` must appear
461before ``'r'``.
462
463In triple-quoted strings, unescaped newlines and quotes are allowed (and are
464retained), except that three unescaped quotes in a row terminate the string.  (A
465"quote" is the character used to open the string, i.e. either ``'`` or ``"``.)
466
467.. index::
468   single: physical line
469   single: escape sequence
470   single: Standard C
471   single: C
472
473Unless an ``'r'`` or ``'R'`` prefix is present, escape sequences in strings are
474interpreted according to rules similar to those used by Standard C.  The
475recognized escape sequences are:
476
477+-----------------+---------------------------------+-------+
478| Escape Sequence | Meaning                         | Notes |
479+=================+=================================+=======+
480| ``\newline``    | Ignored                         |       |
481+-----------------+---------------------------------+-------+
482| ``\\``          | Backslash (``\``)               |       |
483+-----------------+---------------------------------+-------+
484| ``\'``          | Single quote (``'``)            |       |
485+-----------------+---------------------------------+-------+
486| ``\"``          | Double quote (``"``)            |       |
487+-----------------+---------------------------------+-------+
488| ``\a``          | ASCII Bell (BEL)                |       |
489+-----------------+---------------------------------+-------+
490| ``\b``          | ASCII Backspace (BS)            |       |
491+-----------------+---------------------------------+-------+
492| ``\f``          | ASCII Formfeed (FF)             |       |
493+-----------------+---------------------------------+-------+
494| ``\n``          | ASCII Linefeed (LF)             |       |
495+-----------------+---------------------------------+-------+
496| ``\N{name}``    | Character named *name* in the   |       |
497|                 | Unicode database (Unicode only) |       |
498+-----------------+---------------------------------+-------+
499| ``\r``          | ASCII Carriage Return (CR)      |       |
500+-----------------+---------------------------------+-------+
501| ``\t``          | ASCII Horizontal Tab (TAB)      |       |
502+-----------------+---------------------------------+-------+
503| ``\uxxxx``      | Character with 16-bit hex value | \(1)  |
504|                 | *xxxx* (Unicode only)           |       |
505+-----------------+---------------------------------+-------+
506| ``\Uxxxxxxxx``  | Character with 32-bit hex value | \(2)  |
507|                 | *xxxxxxxx* (Unicode only)       |       |
508+-----------------+---------------------------------+-------+
509| ``\v``          | ASCII Vertical Tab (VT)         |       |
510+-----------------+---------------------------------+-------+
511| ``\ooo``        | Character with octal value      | (3,5) |
512|                 | *ooo*                           |       |
513+-----------------+---------------------------------+-------+
514| ``\xhh``        | Character with hex value *hh*   | (4,5) |
515+-----------------+---------------------------------+-------+
516
517.. index:: single: ASCII@ASCII
518
519Notes:
520
521(1)
522   Individual code units which form parts of a surrogate pair can be encoded using
523   this escape sequence.
524
525(2)
526   Any Unicode character can be encoded this way, but characters outside the Basic
527   Multilingual Plane (BMP) will be encoded using a surrogate pair if Python is
528   compiled to use 16-bit code units (the default).  Individual code units which
529   form parts of a surrogate pair can be encoded using this escape sequence.
530
531(3)
532   As in Standard C, up to three octal digits are accepted.
533
534(4)
535   Unlike in Standard C, exactly two hex digits are required.
536
537(5)
538   In a string literal, hexadecimal and octal escapes denote the byte with the
539   given value; it is not necessary that the byte encodes a character in the source
540   character set. In a Unicode literal, these escapes denote a Unicode character
541   with the given value.
542
543.. index:: single: unrecognized escape sequence
544
545Unlike Standard C, all unrecognized escape sequences are left in the string
546unchanged, i.e., *the backslash is left in the string*.  (This behavior is
547useful when debugging: if an escape sequence is mistyped, the resulting output
548is more easily recognized as broken.)  It is also important to note that the
549escape sequences marked as "(Unicode only)" in the table above fall into the
550category of unrecognized escapes for non-Unicode string literals.
551
552When an ``'r'`` or ``'R'`` prefix is present, a character following a backslash
553is included in the string without change, and *all backslashes are left in the
554string*.  For example, the string literal ``r"\n"`` consists of two characters:
555a backslash and a lowercase ``'n'``.  String quotes can be escaped with a
556backslash, but the backslash remains in the string; for example, ``r"\""`` is a
557valid string literal consisting of two characters: a backslash and a double
558quote; ``r"\"`` is not a valid string literal (even a raw string cannot end in
559an odd number of backslashes).  Specifically, *a raw string cannot end in a
560single backslash* (since the backslash would escape the following quote
561character).  Note also that a single backslash followed by a newline is
562interpreted as those two characters as part of the string, *not* as a line
563continuation.
564
565When an ``'r'`` or ``'R'`` prefix is used in conjunction with a ``'u'`` or
566``'U'`` prefix, then the ``\uXXXX`` and ``\UXXXXXXXX`` escape sequences are
567processed while  *all other backslashes are left in the string*. For example,
568the string literal ``ur"\u0062\n"`` consists of three Unicode characters: 'LATIN
569SMALL LETTER B', 'REVERSE SOLIDUS', and 'LATIN SMALL LETTER N'. Backslashes can
570be escaped with a preceding backslash; however, both remain in the string.  As a
571result, ``\uXXXX`` escape sequences are only recognized when there are an odd
572number of backslashes.
573
574
575.. _string-catenation:
576
577String literal concatenation
578----------------------------
579
580Multiple adjacent string literals (delimited by whitespace), possibly using
581different quoting conventions, are allowed, and their meaning is the same as
582their concatenation.  Thus, ``"hello" 'world'`` is equivalent to
583``"helloworld"``.  This feature can be used to reduce the number of backslashes
584needed, to split long strings conveniently across long lines, or even to add
585comments to parts of strings, for example::
586
587   re.compile("[A-Za-z_]"       # letter or underscore
588              "[A-Za-z0-9_]*"   # letter, digit or underscore
589             )
590
591Note that this feature is defined at the syntactical level, but implemented at
592compile time.  The '+' operator must be used to concatenate string expressions
593at run time.  Also note that literal concatenation can use different quoting
594styles for each component (even mixing raw strings and triple quoted strings).
595
596
597.. _numbers:
598
599Numeric literals
600----------------
601
602.. index::
603   single: number
604   single: numeric literal
605   single: integer literal
606   single: plain integer literal
607   single: long integer literal
608   single: floating point literal
609   single: hexadecimal literal
610   single: binary literal
611   single: octal literal
612   single: decimal literal
613   single: imaginary literal
614   single: complex; literal
615
616There are four types of numeric literals: plain integers, long integers,
617floating point numbers, and imaginary numbers.  There are no complex literals
618(complex numbers can be formed by adding a real number and an imaginary number).
619
620Note that numeric literals do not include a sign; a phrase like ``-1`` is
621actually an expression composed of the unary operator '``-``' and the literal
622``1``.
623
624
625.. _integers:
626
627Integer and long integer literals
628---------------------------------
629
630Integer and long integer literals are described by the following lexical
631definitions:
632
633.. productionlist::
634   longinteger: `integer` ("l" | "L")
635   integer: `decimalinteger` | `octinteger` | `hexinteger` | `bininteger`
636   decimalinteger: `nonzerodigit` `digit`* | "0"
637   octinteger: "0" ("o" | "O") `octdigit`+ | "0" `octdigit`+
638   hexinteger: "0" ("x" | "X") `hexdigit`+
639   bininteger: "0" ("b" | "B") `bindigit`+
640   nonzerodigit: "1"..."9"
641   octdigit: "0"..."7"
642   bindigit: "0" | "1"
643   hexdigit: `digit` | "a"..."f" | "A"..."F"
644
645Although both lower case ``'l'`` and upper case ``'L'`` are allowed as suffix
646for long integers, it is strongly recommended to always use ``'L'``, since the
647letter ``'l'`` looks too much like the digit ``'1'``.
648
649Plain integer literals that are above the largest representable plain integer
650(e.g., 2147483647 when using 32-bit arithmetic) are accepted as if they were
651long integers instead. [#]_  There is no limit for long integer literals apart
652from what can be stored in available memory.
653
654Some examples of plain integer literals (first row) and long integer literals
655(second and third rows)::
656
657   7     2147483647                        0177
658   3L    79228162514264337593543950336L    0377L   0x100000000L
659         79228162514264337593543950336             0xdeadbeef
660
661
662.. _floating:
663
664Floating point literals
665-----------------------
666
667Floating point literals are described by the following lexical definitions:
668
669.. productionlist::
670   floatnumber: `pointfloat` | `exponentfloat`
671   pointfloat: [`intpart`] `fraction` | `intpart` "."
672   exponentfloat: (`intpart` | `pointfloat`) `exponent`
673   intpart: `digit`+
674   fraction: "." `digit`+
675   exponent: ("e" | "E") ["+" | "-"] `digit`+
676
677Note that the integer and exponent parts of floating point numbers can look like
678octal integers, but are interpreted using radix 10.  For example, ``077e010`` is
679legal, and denotes the same number as ``77e10``. The allowed range of floating
680point literals is implementation-dependent. Some examples of floating point
681literals::
682
683   3.14    10.    .001    1e100    3.14e-10    0e0
684
685Note that numeric literals do not include a sign; a phrase like ``-1`` is
686actually an expression composed of the unary operator ``-`` and the literal
687``1``.
688
689
690.. _imaginary:
691
692Imaginary literals
693------------------
694
695Imaginary literals are described by the following lexical definitions:
696
697.. productionlist::
698   imagnumber: (`floatnumber` | `intpart`) ("j" | "J")
699
700An imaginary literal yields a complex number with a real part of 0.0.  Complex
701numbers are represented as a pair of floating point numbers and have the same
702restrictions on their range.  To create a complex number with a nonzero real
703part, add a floating point number to it, e.g., ``(3+4j)``.  Some examples of
704imaginary literals::
705
706   3.14j   10.j    10j     .001j   1e100j  3.14e-10j
707
708
709.. _operators:
710
711Operators
712=========
713
714.. index:: single: operators
715
716The following tokens are operators::
717
718   +       -       *       **      /       //      %
719   <<      >>      &       |       ^       ~
720   <       >       <=      >=      ==      !=      <>
721
722The comparison operators ``<>`` and ``!=`` are alternate spellings of the same
723operator.  ``!=`` is the preferred spelling; ``<>`` is obsolescent.
724
725
726.. _delimiters:
727
728Delimiters
729==========
730
731.. index:: single: delimiters
732
733The following tokens serve as delimiters in the grammar::
734
735   (       )       [       ]       {       }      @
736   ,       :       .       `       =       ;
737   +=      -=      *=      /=      //=     %=
738   &=      |=      ^=      >>=     <<=     **=
739
740The period can also occur in floating-point and imaginary literals.  A sequence
741of three periods has a special meaning as an ellipsis in slices. The second half
742of the list, the augmented assignment operators, serve lexically as delimiters,
743but also perform an operation.
744
745The following printing ASCII characters have special meaning as part of other
746tokens or are otherwise significant to the lexical analyzer::
747
748   '       "       #       \
749
750.. index:: single: ASCII@ASCII
751
752The following printing ASCII characters are not used in Python.  Their
753occurrence outside string literals and comments is an unconditional error::
754
755   $       ?
756
757.. rubric:: Footnotes
758
759.. [#] In versions of Python prior to 2.4, octal and hexadecimal literals in the range
760   just above the largest representable plain integer but below the largest
761   unsigned 32-bit number (on a machine using 32-bit arithmetic), 4294967296, were
762   taken as the negative plain integer obtained by subtracting 4294967296 from
763   their unsigned value.
764