About this document ...

genindex.html | ref.html | Python Reference Manual | contents.html | genindex.html
---
# About this document ...
Python Reference Manual,
December 21, 2001, Release 2.2
This document was generated using the LaTeX2HTML (http://saftsack.fs.uni-bayreuth.de/~latex2ht/) translator.
LaTeX2HTML (http://saftsack.fs.uni-bayreuth.de/~latex2ht/) is Copyright ©
1993, 1994, 1995, 1996, 1997, Nikos
Drakos (http://cbl.leeds.ac.uk/nikos/personal.html), Computer Based Learning Unit, University of
Leeds, and Copyright © 1997, 1998, Ross
Moore (http://www.maths.mq.edu.au/~ross/), Mathematics Department, Macquarie University,
Sydney.
The application of LaTeX2HTML (http://saftsack.fs.uni-bayreuth.de/~latex2ht/) to the Python
documentation has been heavily tailored by Fred L. Drake,
Jr. Original navigation icons were contributed by Christopher
Petrilli.
---
## Comments and Questions
General comments and questions regarding this document should
be sent by email to python-docs@python.org (mailto:python-docs@python.org). If you find specific errors in
this document, please report the bug at the Python Bug
Tracker (http://sourceforge.net/bugs/?group_id=5470) at SourceForge (http://sourceforge.net/).
Questions regarding how to use the information in this
document should be sent to the Python news group, comp.lang.python (news:comp.lang.python), or the Python mailing list (http://www.python.org/mailman/listinfo/python-list) (which is gated to the newsgroup and
carries the same content).
For any of these channels, please be sure not to send HTML email.
Thanks.
---
genindex.html | ref.html | Python Reference Manual | contents.html | genindex.html
---
Release 2.2, documentation updated on December 21, 2001.


6.2 Assert statements

exprstmts.html | simple.html | assignment.html | Python Reference Manual | contents.html | genindex.html
---
# 6.2 Assert statements
Assert statementsare a convenient way to insert
debugging assertionsinto a program:
`assert_statement` | ::= | `"assert" expression ["," expression ]`
Download entire grammar as text. (grammar.txt)
The simple form, "assert expression", is equivalent to
```text

if __debug__:
if not expression: raise AssertionError
```
The extended form, "assert expression1, expression2", is
equivalent to
```text

if __debug__:
if not expression1: raise AssertionError, expression2
```
These equivalences assume that `__debug__`and
AssertionErrorrefer to the built-in
variables with those names. In the current implementation, the
built-in variable `__debug__` is 1 under normal circumstances, 0
when optimization is requested (command line option -O). The current
code generator emits no code for an assert statement when optimization
is requested at compile time. Note that it is unnecessary to include
the source code for the expression that failed in the error message;
it will be displayed as part of the stack trace.
Assignments to `__debug__` are illegal. The value for the
built-in variable is determined when the interpreter starts.


6.3 Assignment statements

assert.html | simple.html | augassign.html | Python Reference Manual | contents.html | genindex.html
---
# 6.3 Assignment statements
Assignment statementsare used to
(re)bind names to values and to modify attributes or items of mutable
objects:
`assignment_stmt` | ::= | `( target_list "=")+ expression_list`
`target_list` | ::= | `target ("," target )* [","]`
`target` | ::= | `identifier | "(" target_list ")"
| "[" target_list "]"
| attributeref | subscription | slicing`
Download entire grammar as text. (grammar.txt)
(See section 5.3 (primaries.html#primaries) for the syntax definitions for the last
three symbols.)
An assignment statement evaluates the expression list (remember that
this can be a single expression or a comma-separated list, the latter
yielding a tuple) and assigns the single resulting object to each of
the target lists, from left to right.
Assignment is defined recursively depending on the form of the target
(list). When a target is part of a mutable object (an attribute
reference, subscription or slicing), the mutable object must
ultimately perform the assignment and decide about its validity, and
may raise an exception if the assignment is unacceptable. The rules
observed by various types and the exceptions raised are given with the
definition of the object types (see section 3.2 (types.html#types)).
Assignment of an object to a target list is recursively defined as
follows.
- If the target list is a single target: The object is assigned to that
target.
- If the target list is a comma-separated list of targets: The object
must be a sequence with the same number of items as the there are
targets in the target list, and the items are assigned, from left to
right, to the corresponding targets. (This rule is relaxed as of
Python 1.5; in earlier versions, the object had to be a tuple. Since
strings are sequences, an assignment like "a, b = "xy"" is
now legal as long as the string has the right length.)
Assignment of an object to a single target is recursively defined as
follows.
- If the target is an identifier (name):
- If the name does not occur in a global statement in the current
code block: the name is bound to the object in the current local
namespace.
- Otherwise: the name is bound to the object in the current global
namespace.
The name is rebound if it was already bound. This may cause the
reference count for the object previously bound to the name to reach
zero, causing the object to be deallocated and its
destructor(if it has one) to be called.
- If the target is a target list enclosed in parentheses or in square
brackets: The object must be a sequence with the same number of items
as there are targets in the target list, and its items are assigned,
from left to right, to the corresponding targets.
- If the target is an attribute reference: The primary expression in the
reference is evaluated. It should yield an object with assignable
attributes; if this is not the case, TypeError is raised. That
object is then asked to assign the assigned object to the given
attribute; if it cannot perform the assignment, it raises an exception
(usually but not necessarily AttributeError).
- If the target is a subscription: The primary expression in the
reference is evaluated. It should yield either a mutable sequence
object (e.g., a list) or a mapping object (e.g., a dictionary). Next,
the subscript expression is evaluated.
If the primary is a mutable sequence object (e.g., a list), the subscript
must yield a plain integer. If it is negative, the sequence's length
is added to it. The resulting value must be a nonnegative integer
less than the sequence's length, and the sequence is asked to assign
the assigned object to its item with that index. If the index is out
of range, IndexError is raised (assignment to a subscripted
sequence cannot add new items to a list).
If the primary is a mapping object (e.g., a dictionary), the subscript must
have a type compatible with the mapping's key type, and the mapping is
then asked to create a key/datum pair which maps the subscript to
the assigned object. This can either replace an existing key/value
pair with the same key value, or insert a new key/value pair (if no
key with the same value existed).
- If the target is a slicing: The primary expression in the reference is
evaluated. It should yield a mutable sequence object (e.g., a list). The
assigned object should be a sequence object of the same type. Next,
the lower and upper bound expressions are evaluated, insofar they are
present; defaults are zero and the sequence's length. The bounds
should evaluate to (small) integers. If either bound is negative, the
sequence's length is added to it. The resulting bounds are clipped to
lie between zero and the sequence's length, inclusive. Finally, the
sequence object is asked to replace the slice with the items of the
assigned sequence. The length of the slice may be different from the
length of the assigned sequence, thus changing the length of the
target sequence, if the object allows it.
(In the current implementation, the syntax for targets is taken
to be the same as for expressions, and invalid syntax is rejected
during the code generation phase, causing less detailed error
messages.)
WARNING: Although the definition of assignment implies that overlaps
between the left-hand side and the right-hand side are `safe' (e.g.,
"a, b = b, a" swaps two variables), overlaps within the
collection of assigned-to variables are not safe! For instance, the
following program prints "[0, 2]":
```text

x = [0, 1]
i = 0
i, x[i] = 1, 2
print x
```


5.2.1 Identifiers (Names)

atoms.html | atoms.html | atom-literals.html | Python Reference Manual | contents.html | genindex.html
---
## 5.2.1 Identifiers (Names)
An identifier occurring as an atom is a reference to a local, global
or built-in name binding. If a name is assigned to anywhere in a code
block (even in unreachable code), and is not mentioned in a
global statement in that code block, then it refers to a local
name throughout that code block. When it is not assigned to anywhere
in the block, or when it is assigned to but also explicitly listed in
a global statement, it refers to a global name if one exists,
else to a built-in name (and this binding may dynamically
change).5.1 (#foot3570)
When the name is bound to an object, evaluation of the atom yields
that object. When a name is not bound, an attempt to evaluate it
raises a NameError exception.
Private name mangling:when an identifier that textually occurs in a class definition begins
with two or more underscore characters and does not end in two or more
underscores, it is considered a private name of that class.
Private names are transformed to a longer form before code is
generated for them. The transformation inserts the class name in
front of the name, with leading underscores removed, and a single
underscore inserted in front of the class name. For example, the
identifier `__spam` occurring in a class named `Ham` will be
transformed to `_Ham__spam`. This transformation is independent
of the syntactical context in which the identifier is used. If the
transformed name is extremely long (longer than 255 characters),
implementation defined truncation may happen. If the class name
consists only of underscores, no transformation is done.


5.2.2 Literals

atom-identifiers.html | atoms.html | parenthesized.html | Python Reference Manual | contents.html | genindex.html
---
## 5.2.2 Literals
Python supports string literals and various numeric literals:
`literal` | ::= | `stringliteral | integer | longinteger | floatnumber | imagnumber`
Download entire grammar as text. (grammar.txt)
Evaluation of a literal yields an object of the given type (string,
integer, long integer, floating point number, complex number) with the
given value. The value may be approximated in the case of floating
point and imaginary (complex) literals. See section 2.4 (literals.html#literals)
for details.
All literals correspond to immutable data types, and hence the
object's identity is less important than its value. Multiple
evaluations of literals with the same value (either the same
occurrence in the program text or a different occurrence) may obtain
the same object or a different object with the same value.


5.2 Atoms

conversions.html | expressions.html | atom-identifiers.html | Python Reference Manual | contents.html | genindex.html
---
# 5.2 Atoms
Atoms are the most basic elements of expressions. The simplest atoms
are identifiers or literals. Forms enclosed in
reverse quotes or in parentheses, brackets or braces are also
categorized syntactically as atoms. The syntax for atoms is:
`atom` | ::= | `identifier | literal | enclosure`
`enclosure` | ::= | `parenth_form | list_display | dict_display | string_conversion`
Download entire grammar as text. (grammar.txt)


3.3.2 Customizing attribute access

customization.html | specialnames.html | callable-types.html | Python Reference Manual | contents.html | genindex.html
---
## 3.3.2 Customizing attribute access
The following methods can be defined to customize the meaning of
attribute access (use of, assignment to, or deletion of `x.name`)
for class instances.
For performance reasons, these methods are cached in the class object
at class definition time; therefore, they cannot be changed after the
class definition is executed.


5.3.1 Attribute references

primaries.html | primaries.html | subscriptions.html | Python Reference Manual | contents.html | genindex.html
---
## 5.3.1 Attribute references
An attribute reference is a primary followed by a period and a name:
`attributeref` | ::= | `primary "." identifier`
Download entire grammar as text. (grammar.txt)
The primary must evaluate to an object of a type that supports
attribute references, e.g., a module, list, or an instance. This
object is then asked to produce the attribute whose name is the
identifier. If this attribute is not available, the exception
AttributeErroris raised.
Otherwise, the type and value of the object produced is determined by
the object. Multiple evaluations of the same attribute reference may
yield different objects.


6.3.1 Augmented Assignment statements

assignment.html | assignment.html | pass.html | Python Reference Manual | contents.html | genindex.html
---
## 6.3.1 Augmented Assignment statements
Augmented assignment is the combination, in a single statement, of a binary
operation and an assignment statement:
`augmented_assignment_stmt` | ::= | `target augop expression_list`
`augop` | ::= | `"+=" | "-=" | "*=" | "/=" | "%=" | "**="
| "»=" | "«=" | "&=" | "^=" | "|="`
`target` | ::= | `identifier | "(" target_list ")"
| "[" target_list "]"
| attributeref | subscription | slicing`
Download entire grammar as text. (grammar.txt)
(See section 5.3 (primaries.html#primaries) for the syntax definitions for the last
three symbols.)
An augmented assignment evaluates the target (which, unlike normal
assignment statements, cannot be an unpacking) and the expression
list, performs the binary operation specific to the type of assignment
on the two operands, and assigns the result to the original
target. The target is only evaluated once.
An augmented assignment expression like `x += 1` can be rewritten as
`x = x + 1` to achieve a similar, but not exactly equal effect. In the
augmented version, `x` is only evaluated once. Also, when possible, the
actual operation is performed in-place, meaning that rather than
creating a new object and assigning that to the target, the old object is
modified instead.
With the exception of assigning to tuples and multiple targets in a single
statement, the assignment done by augmented assignment statements is handled
the same way as normal assignments. Similarly, with the exception of the
possible in-place behavior, the binary operation performed by
augmented assignment is the same as the normal binary operations.


5.6 Binary arithmetic operations

unary.html | expressions.html | shifting.html | Python Reference Manual | contents.html | genindex.html
---
# 5.6 Binary arithmetic operations
The binary arithmetic operations have the conventional priority
levels. Note that some of these operations also apply to certain
non-numeric types. Apart from the power operator, there are only two
levels, one for multiplicative operators and one for additive
operators:
`m_expr` | ::= | `u_expr | m_expr "*" u_expr | m_expr "/" u_expr | m_expr "%" u_expr`
`a_expr` | ::= | `m_expr | aexpr "+" m_expr aexpr "-" m_expr`
Download entire grammar as text. (grammar.txt)
The `*` (multiplication) operator yields the product of its
arguments. The arguments must either both be numbers, or one argument
must be an integer (plain or long) and the other must be a sequence.
In the former case, the numbers are converted to a common type and
then multiplied together. In the latter case, sequence repetition is
performed; a negative repetition factor yields an empty sequence.
The `/` (division) operator yields the quotient of its
arguments. The numeric arguments are first converted to a common
type. Plain or long integer division yields an integer of the same
type; the result is that of mathematical division with the `floor'
function applied to the result. Division by zero raises the
ZeroDivisionError exception.
The `%` (modulo) operator yields the remainder from the
division of the first argument by the second. The numeric arguments
are first converted to a common type. A zero right argument raises
the ZeroDivisionError exception. The arguments may be floating
point numbers, e.g., `3.14%0.7` equals `0.34` (since
`3.14` equals `4*0.7 + 0.34`.) The modulo operator always
yields a result with the same sign as its second operand (or zero);
the absolute value of the result is strictly smaller than the second
operand.
The integer division and modulo operators are connected by the
following identity: `x == (x/y)*y + (x%y)`. Integer division and
modulo are also connected with the built-in function divmod():
`divmod(x, y) == (x/y, x%y)`. These identities don't hold for
floating point and complex numbers; there similar identities hold
approximately where `x/y` is replaced by `floor(x/y)`) or
`floor(x/y) - 1` (for floats),5.2 (#foot3686) or `floor((x/y).real)` (for
complex).
The `+` (addition) operator yields the sum of its arguments.
The arguments must either both be numbers or both sequences of the
same type. In the former case, the numbers are converted to a common
type and then added together. In the latter case, the sequences are
concatenated.
The `-` (subtraction) operator yields the difference of its
arguments. The numeric arguments are first converted to a common
type.


5.8 Binary bit-wise operations

shifting.html | expressions.html | comparisons.html | Python Reference Manual | contents.html | genindex.html
---
# 5.8 Binary bit-wise operations
Each of the three bitwise operations has a different priority level:
`and_expr` | ::= | `shift_expr | and_expr "&" shift_expr`
`xor_expr` | ::= | `and_expr | xor_expr "^" and_expr`
`or_expr` | ::= | `xor_expr | or_expr "|" xor_expr`
Download entire grammar as text. (grammar.txt)
The `&` operator yields the bitwise AND of its arguments, which
must be plain or long integers. The arguments are converted to a
common type.
The `^` operator yields the bitwise XOR (exclusive OR) of its
arguments, which must be plain or long integers. The arguments are
converted to a common type.
The `|` operator yields the bitwise (inclusive) OR of its
arguments, which must be plain or long integers. The arguments are
converted to a common type.


2.1.6 Blank lines

implicit-joining.html | line-structure.html | indentation.html | Python Reference Manual | contents.html | genindex.html
---
## 2.1.6 Blank lines
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.


6.10 The break statement

raise.html | simple.html | continue.html | Python Reference Manual | contents.html | genindex.html
---
# 6.10 The break statement
`break_stmt` | ::= | `"break"`
Download entire grammar as text. (grammar.txt)
break may only occur syntactically nested in a for
or while loop, but not nested in a function or class definition
within that loop.
It terminates the nearest enclosing loop, skipping the optional
else clause if the loop has one.
If a for loop is terminated by break, the loop control
target keeps its current value.
When break passes control out of a try statement
with a finally clause, that finally clause is executed
before really leaving the loop.


3.3.3 Emulating callable objects

attribute-access.html | specialnames.html | sequence-types.html | Python Reference Manual | contents.html | genindex.html
---
## 3.3.3 Emulating callable objects


5.3.4 Calls

slicings.html | primaries.html | power.html | Python Reference Manual | contents.html | genindex.html
---
## 5.3.4 Calls
A call calls a callable object (e.g., a function) with a possibly empty
series of arguments:
`call` | ::= | `primary "(" [ argument_list [","]] ")"`
`argument_list` | ::= | `positional_arguments ["," keyword_arguments ["," "*" expression ["," "**" expression ]]]
| keyword_arguments ["," "*" expression ["," "**" expression ]]
| "*" expression ["," "**" expression ]
| "**" expression`
`positional_arguments` | ::= | `expression ("," expression )*`
`keyword_arguments` | ::= | `keyword_item ("," keyword_item )*`
`keyword_item` | ::= | `identifier "=" expression`
Download entire grammar as text. (grammar.txt)
A trailing comma may be present after an argument list but does not
affect the semantics.
The primary must evaluate to a callable object (user-defined
functions, built-in functions, methods of built-in objects, class
objects, methods of class instances, and certain class instances
themselves are callable; extensions may define additional callable
object types). All argument expressions are evaluated before the call
is attempted. Please refer to section 7.5 (function.html#function) for the syntax
of formal parameter lists.
If keyword arguments are present, they are first converted to
positional arguments, as follows. First, a list of unfilled slots is
created for the formal parameters. If there are N positional
arguments, they are placed in the first N slots. Next, for each
keyword argument, the identifier is used to determine the
corresponding slot (if the identifier is the same as the first formal
parameter name, the first slot is used, and so on). If the slot is
already filled, a TypeError exception is raised.
Otherwise, the value of the argument is placed in the slot, filling it
(even if the expression is `None`, it fills the slot). When all
arguments have been processed, the slots that are still unfilled are
filled with the corresponding default value from the function
definition. (Default values are calculated, once, when the function
is defined; thus, a mutable object such as a list or dictionary used
as default value will be shared by all calls that don't specify an
argument value for the corresponding slot; this should usually be
avoided.) If there are any unfilled slots for which no default value
is specified, a TypeError exception is raised. Otherwise,
the list of filled slots is used as the argument list for the call.
If there are more positional arguments than there are formal parameter
slots, a TypeError exception is raised, unless a formal
parameter using the syntax "*identifier" is present; in this
case, that formal parameter receives a tuple containing the excess
positional arguments (or an empty tuple if there were no excess
positional arguments).
If any keyword argument does not correspond to a formal parameter
name, a TypeError exception is raised, unless a formal
parameter using the syntax "**identifier" is present; in this
case, that formal parameter receives a dictionary containing the
excess keyword arguments (using the keywords as keys and the argument
values as corresponding values), or a (new) empty dictionary if there
were no excess keyword arguments.
If the syntax "*expression" appears in the function call,
"expression" must evaluate to a sequence. Elements from this
sequence are treated as if they were additional positional arguments;
if there are postional arguments x1,...,xN , and
"expression" evaluates to a sequence y1,...,yM, this
is equivalent to a call with M+N positional arguments
x1,...,xN,y1,...,yM.
A consequence of this is that although the "*expression" syntax
appears after any keyword arguments, it is processed
before the keyword arguments (and the
"**expression" argument, if any - see below). So:
```text

>>> def f(a, b):
... print a, b
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2
```
It is unusual for both keyword arguments and the
"*expression" syntax to be used in the same call, so in practice
this confusion does not arise.
If the syntax "**expression" appears in the function call,
"expression" must evaluate to a (subclass of) dictionary, the
contents of which are treated as additional keyword arguments. In the
case of a keyword appearing in both "expression" and as an
explicit keyword argument, a TypeError exception is
raised.
Formal parameters using the syntax "*identifier" or
"**identifier" cannot be used as positional argument slots or
as keyword argument names. Formal parameters using the syntax
"(sublist)" cannot be used as keyword argument names; the
outermost sublist corresponds to a single unnamed argument slot, and
the argument value is assigned to the sublist using the usual tuple
assignment rules after all other parameter processing is done.
A call always returns some value, possibly `None`, unless it
raises an exception. How this value is computed depends on the type
of the callable object.
If it is--
a user-defined function:: The code block for the function is
executed, passing it the argument list. The first thing the code
block will do is bind the formal parameters to the arguments; this is
described in section 7.5 (function.html#function). When the code block executes a
return statement, this specifies the return value of the
function call.
a built-in function or method:: The result is up to the
interpreter; see the Python
Library Reference (../lib/built-in-funcs.html) for the descriptions of built-in functions and
methods.
a class object:: A new instance of that class is returned.
a class instance method:: The corresponding user-defined
function is called, with an argument list that is one longer than the
argument list of the call: the instance becomes the first argument.
a class instance:: The class must define a __call__()
method; the effect is then the same as if that method was called.


7.6 Class definitions

function.html | compound.html | top-level.html | Python Reference Manual | contents.html | genindex.html
---
# 7.6 Class definitions
A class definition defines a class object (see section 3.2 (types.html#types)):
`classdef` | ::= | `"class" classname [ inheritance ] ":" suite`
`inheritance` | ::= | `"(" [ expression_list ] ")"`
`classname` | ::= | `identifier`
Download entire grammar as text. (grammar.txt)
A class definition is an executable statement. It first evaluates the
inheritance list, if present. Each item in the inheritance list
should evaluate to a class object. The class's suite is then executed
in a new execution frame (see section 4.1 (execframes.html#execframes)), using a newly
created local namespace and the original global namespace.
(Usually, the suite contains only function definitions.) When the
class's suite finishes execution, its execution frame is discarded but
its local namespace is saved. A class object is then created using
the inheritance list for the base classes and the saved local
namespace for the attribute dictionary. The class name is bound to this
class object in the original local namespace.


2.1.3 Comments

physical.html | line-structure.html | explicit-joining.html | Python Reference Manual | contents.html | genindex.html
---
## 2.1.3 Comments
A comment starts with a hash character (`#`) that is not part of
a string literal, and ends at the end of the physical line. A comment
signifies the end of the logical line unless the implicit line joining
rules are invoked.
Comments are ignored by the syntax; they are not tokens.


5.9 Comparisons

bitwise.html | expressions.html | lambda.html | Python Reference Manual | contents.html | genindex.html
---
# 5.9 Comparisons
Unlike C, all comparison operations in Python have the same priority,
which is lower than that of any arithmetic, shifting or bitwise
operation. Also unlike C, expressions like `a < b < c` have the
interpretation that is conventional in mathematics:
`comparison` | ::= | `or_expr ( comp_operator or_expr )*`
`comp_operator` | ::= | `"<" | ">" | "==" | ">=" | "<=" | "<>" | "!="
| "is" ["not"] | ["not"] "in"`
Download entire grammar as text. (grammar.txt)
Comparisons yield integer values: `1` for true, `0` for false.
Comparisons can be chained arbitrarily, e.g., `x < y <= z` is
equivalent to `x < y and y <= z`, except that `y` is
evaluated only once (but in both cases `z` is not evaluated at all
when `x < y` is found to be false).
Formally, if a, b, c, ..., y, z are
expressions and opa, opb, ..., opy are comparison
operators, then a opa b opb c ...y opy z is equivalent
to a opa b and b opb c and ...
y opy z, except that each expression is evaluated at most once.
Note that a opa b opb c doesn't imply any kind of comparison
between a and c, so that, e.g., `x < y > z` is
perfectly legal (though perhaps not pretty).
The forms `<>` and `!=` are equivalent; for consistency with
C, `!=` is preferred; where `!=` is mentioned below
`<>` is also accepted. The `<>` spelling is considered
obsolescent.
The operators `<`, `>`, `==`, `>=`, `<=`, and
`!=` compare
the values of two objects. The objects need not have the same type.
If both are numbers, they are coverted to a common type. Otherwise,
objects of different types always compare unequal, and are
ordered consistently but arbitrarily.
(This unusual definition of comparison was used to simplify the
definition of operations like sorting and the in and
not in operators. In the future, the comparison rules for
objects of different types are likely to change.)
Comparison of objects of the same type depends on the type:
- Numbers are compared arithmetically.
- Strings are compared lexicographically using the numeric equivalents
(the result of the built-in function ord()) of their
characters. Unicode and 8-bit strings are fully interoperable in this
behavior.
- Tuples and lists are compared lexicographically using comparison of
corresponding items.
- Mappings (dictionaries) compare equal if and only if their sorted
(key, value) lists compare equal.5.3 (#foot3339)Outcomes other than equality are resolved consistently, but are not
otherwise defined.5.4 (#foot3632)
- Most other types compare unequal unless they are the same object;
the choice whether one object is considered smaller or larger than
another one is made arbitrarily but consistently within one
execution of a program.
The operators in and not in test for set
membership. `x in s` evaluates to true if x
is a member of the set s, and false otherwise. `x not in s` returns the negation of `x in s`.
The set membership test has traditionally been bound to sequences; an
object is a member of a set if the set is a sequence and contains an
element equal to that object. However, it is possible for an object
to support membership tests without being a sequence. In particular,
dictionaries support memership testing as a nicer way of spelling
`key in dict`; other mapping types may follow suit.
For the list and tuple types, `x in y` is true if and
only if there exists an index i such that
`x == y [ i ]` is true.
For the Unicode and string types, `x in y` is true if
and only if there exists an index i such that `x == y [ i ]` is true. If `x` is not a string or
Unicode object of length `1`, a TypeError exception
is raised.
For user-defined classes which define the __contains__() method,
`x in y` is true if and only if
`y .__contains__( x )` is true.
For user-defined classes which do not define __contains__() and
do define __getitem__(), `x in y` is true if
and only if there is a non-negative integer index i such that
`x == y [ i ]`, and all lower integer indices
do not raise IndexError exception. (If any other exception
is raised, it is as if in raised that exception).
The operator not in is defined to have the inverse true value
of in.
The operators is and is not test for object identity:
`x is y` is true if and only if x and y
are the same object. `x is not y` yields the inverse
truth value.


7. Compound statements

exec.html | ref.html | if.html | Python Reference Manual | contents.html | genindex.html
---
# 7. Compound statements
Compound statements contain (groups of) other statements; they affect
or control the execution of those other statements in some way. In
general, compound statements span multiple lines, although in simple
incarnations a whole compound statement may be contained in one line.
The if, while and for statements implement
traditional control flow constructs. try specifies exception
handlers and/or cleanup code for a group of statements. Function and
class definitions are also syntactically compound statements.
Compound statements consist of one or more `clauses.' A clause
consists of a header and a `suite.' The clause headers of a
particular compound statement are all at the same indentation level.
Each clause header begins with a uniquely identifying keyword and ends
with a colon. A suite is a group of statements controlled by a
clause. A suite can be one or more semicolon-separated simple
statements on the same line as the header, following the header's
colon, or it can be one or more indented statements on subsequent
lines. Only the latter form of suite can contain nested compound
statements; the following is illegal, mostly because it wouldn't be
clear to which if clause a following else clause would
belong:
```text

if test1: if test2: print x
```
Also note that the semicolon binds tighter than the colon in this
context, so that in the following example, either all or none of the
print statements are executed:
```text

if x < y < z: print x; print y; print z
```
Summarizing:
`compound_stmt` | ::= | `if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef`
`suite` | ::= | `stmt_list NEWLINE
| NEWLINE INDENT statement + DEDENT`
`statement` | ::= | `stmt_list NEWLINE | compound_stmt`
`stmt_list` | ::= | `simple_stmt (";" simple_stmt )* [";"]`
Download entire grammar as text. (grammar.txt)
Note that statements always end in a
`NEWLINE`possibly followed by a
`DEDENT`.Also note that optional
continuation clauses always begin with a keyword that cannot start a
statement, thus there are no ambiguities (the `dangling
else' problem is solved in Python by requiring nested
if statements to be indented).
The formatting of the grammar rules in the following sections places
each clause on a separate line for clarity.


Contents

front.html | ref.html | introduction.html | Python Reference Manual | genindex.html
---
## Contents
Table of Contents
- Front Matter (front.html)
  1. Introduction (introduction.html)
  - 1.1 Notation (notation.html)
  2. Lexical analysis (lexical.html)
  - 2.1 Line structure (line-structure.html)
  - 2.1.1 Logical lines (logical.html)
  2.1.2 Physical lines (physical.html)
  2.1.3 Comments (comments.html)
  2.1.4 Explicit line joining (explicit-joining.html)
  2.1.5 Implicit line joining (implicit-joining.html)
  2.1.6 Blank lines (blank-lines.html)
  2.1.7 Indentation (indentation.html)
  2.1.8 Whitespace between tokens (whitespace.html)
  2.2 Other tokens (other-tokens.html)
  2.3 Identifiers and keywords (identifiers.html)
  - 2.3.1 Keywords (keywords.html)
  2.3.2 Reserved classes of identifiers (id-classes.html)
  2.4 Literals (literals.html)
  - 2.4.1 String literals (strings.html)
  2.4.2 String literal concatenation (string-catenation.html)
  2.4.3 Numeric literals (numbers.html)
  2.4.4 Integer and long integer literals (integers.html)
  2.4.5 Floating point literals (floating.html)
  2.4.6 Imaginary literals (imaginary.html)
  2.5 Operators (operators.html)
  2.6 Delimiters (delimiters.html)
  3. Data model (datamodel.html)
  - 3.1 Objects, values and types (objects.html)
  3.2 The standard type hierarchy (types.html)
  3.3 Special method names (specialnames.html)
  - 3.3.1 Basic customization (customization.html)
  3.3.2 Customizing attribute access (attribute-access.html)
  3.3.3 Emulating callable objects (callable-types.html)
  3.3.4 Emulating container types (sequence-types.html)
  3.3.5 Additional methods for emulation of sequence types (sequence-methods.html)
  3.3.6 Emulating numeric types (numeric-types.html)
  4. Execution model (execmodel.html)
  - 4.1 Code blocks, execution frames, and namespaces (execframes.html)
  4.2 Exceptions (exceptions.html)
  5. Expressions (expressions.html)
  - 5.1 Arithmetic conversions (conversions.html)
  5.2 Atoms (atoms.html)
  - 5.2.1 Identifiers (Names) (atom-identifiers.html)
  5.2.2 Literals (atom-literals.html)
  5.2.3 Parenthesized forms (parenthesized.html)
  5.2.4 List displays (lists.html)
  5.2.5 Dictionary displays (dict.html)
  5.2.6 String conversions (string-conversions.html)
  5.3 Primaries (primaries.html)
  - 5.3.1 Attribute references (attribute-references.html)
  5.3.2 Subscriptions (subscriptions.html)
  5.3.3 Slicings (slicings.html)
  5.3.4 Calls (calls.html)
  5.4 The power operator (power.html)
  5.5 Unary arithmetic operations (unary.html)
  5.6 Binary arithmetic operations (binary.html)
  5.7 Shifting operations (shifting.html)
  5.8 Binary bit-wise operations (bitwise.html)
  5.9 Comparisons (comparisons.html)
  5.10 Boolean operations (lambda.html)
  5.11 Expression lists (exprlists.html)
  5.12 Summary (summary.html)
  6. Simple statements (simple.html)
  - 6.1 Expression statements (exprstmts.html)
  6.2 Assert statements (assert.html)
  6.3 Assignment statements (assignment.html)
  - 6.3.1 Augmented Assignment statements (augassign.html)
  6.4 The pass statement (pass.html)
  6.5 The del statement (del.html)
  6.6 The print statement (print.html)
  6.7 The return statement (return.html)
  6.8 The yield statement (yield.html)
  6.9 The raise statement (raise.html)
  6.10 The break statement (break.html)
  6.11 The continue statement (continue.html)
  6.12 The import statement (import.html)
  6.13 The global statement (global.html)
  6.14 The exec statement (exec.html)
  7. Compound statements (compound.html)
  - 7.1 The if statement (if.html)
  7.2 The while statement (while.html)
  7.3 The for statement (for.html)
  7.4 The try statement (try.html)
  7.5 Function definitions (function.html)
  7.6 Class definitions (class.html)
  8. Top-level components (top-level.html)
  - 8.1 Complete Python programs (programs.html)
  8.2 File input (file-input.html)
  8.3 Interactive input (interactive.html)
  8.4 Expression input (expression-input.html)
  A. Future statements and nested scopes (futures.html)
  - A.1 Future statements (future-statements.html)
  A.2 __future__ -- Future statement definitions (module-future.html)
  A.3 Nested scopes (nested-scopes.html)
  - A.3.1 Definitions and rules (definitions.html)
  A.3.2 Interaction with dynamic features (dynamic-features.html)
  B. History and License (node98.html)
  - B.1 History of the software (node99.html)
  B.2 Terms and conditions for accessing or otherwise using Python (node100.html)
  About this document ... (about.html)
End of Table of Contents


6.11 The continue statement

break.html | simple.html | import.html | Python Reference Manual | contents.html | genindex.html
---
# 6.11 The continue statement
`continue_stmt` | ::= | `"continue"`
Download entire grammar as text. (grammar.txt)
continue may only occur syntactically nested in a for or
while loop, but not nested in a function or class definition or
try statement within that loop.6.1 (#foot4617)It continues with the next cycle of the nearest enclosing loop.


5.1 Arithmetic conversions

expressions.html | expressions.html | atoms.html | Python Reference Manual | contents.html | genindex.html
---
# 5.1 Arithmetic conversions
When a description of an arithmetic operator below uses the phrase
``the numeric arguments are converted to a common type,'' the
arguments are coerced using the coercion rules listed at the end of
chapter 3 (datamodel.html#datamodel). If both arguments are standard numeric
types, the following coercions are applied:
- If either argument is a complex number, the other is converted
to complex;
- otherwise, if either argument is a floating point number,
the other is converted to floating point;
- otherwise, if either argument is a long integer,
the other is converted to long integer;
- otherwise, both must be plain integers and no conversion
is necessary.
Some additional rules apply for certain operators (e.g., a string left
argument to the `%' operator). Extensions can define their own
coercions.


3.3.1 Basic customization

specialnames.html | specialnames.html | attribute-access.html | Python Reference Manual | contents.html | genindex.html
---
## 3.3.1 Basic customization


3. Data model

delimiters.html | ref.html | objects.html | Python Reference Manual | contents.html | genindex.html
---
# 3. Data model


A.3.1 Definitions and rules

nested-scopes.html | nested-scopes.html | dynamic-features.html | Python Reference Manual | contents.html | genindex.html
---
## A.3.1 Definitions and rules
Names refer to objects. Names are introduced by name binding
operations. Each occurrence of a name in the program text refers to
the binding of that name established in the innermost function block
containing the use.
A block is a piece of Python program text that is executed as
a unit. The following are blocks: a module, a function body, and a
class defintion.
A scope defines the visibility of a name within a block. If a
local variable is defined in a block, it's scope includes that block.
If the definition occurs in a function block, the scope extends to any
blocks contained within the defining one, unless a contained block
introduces a different binding for the name. The scope of names
defined in a class block is limited to the class block; it does not
extend to the code blocks of methods.
When a name is used in a code block, it is resolved using the nearest
enclosing scope. The set of all such scopes visible to a code block
is called the block's environment.
If a name is bound in a block, it is a local variable of that block.
If a name is bound at the module level, it is a global variable. (The
variables of the module code block are local and global.) If a
variable is used in a code block but not defined there, it is a
free variable.
The name binding operations are assignment, class and function
definition, import statements, for statements, and except statements.
Each assignment or import statement occurs within a block defined by a
class or function definition or at the module level (the top-level
code block).
If a name binding operation occurs anywhere within a code block, all
uses of the name within the block are treated as references to the
current block. This can lead to errors when a name is used within a
block before it is bound.
The previous rule is a subtle. Python lacks declarations and allows
name binding operations to occur anywhere within a code block. The
local variables of a code block can be determined by scanning the
entire text of the block for name binding operations.
If the global statement occurs within a block, all uses of the name
specified in the statement refer to the binding of that name in the
top-level namespace. Names are resolved in the top-level namespace by
searching the global namespace, i.e. the namespace of the module
containing the code block, and the builtin namespace, the namespace of
the module __builtin__. The global namespace is searched
first. If the name is not found there, the builtin namespace is
searched. The global statement must precede all uses of the name.
The global statement has the same scope as a name binding operation
in the same block. If the nearest enclosing scope for a free variable
contains a global statement, the free variable is treated as a global.
A class definition is an executable statement that may use and define
names. These references follow the normal rules for name resolution.
The namespace of the class definition becomes the attribute dictionary
of the class. Names defined at the class scope are not visible in
methods.


A.3.1 Definitions and rules

nested-scopes.html | nested-scopes.html | dynamic-features.html | Python Reference Manual | contents.html | genindex.html
---
## A.3.1 Definitions and rules
Names refer to objects. Names are introduced by name binding
operations. Each occurrence of a name in the program text refers to
the binding of that name established in the innermost function block
containing the use.
A block is a pice of Python program text that can is executed as
a unit. The following are blocks: a module, a function body, and a
class defintion.
A scope defines the visibility of a name within a block. If a
local variable is defined in a block, it's scope includes that block.
If the definition occurs in a function block, the scope extends to any
blocks contained within the defining one, unless a contained block
introduces a different binding for the name. The scope of names
defined in a class block is limited to the class block; it does not
extend to the code blocks of methods.
When a name is used in a code block, it is resolved using the nearest
enclosing scope. The set of all such scopes visible to a code block
is called the block's environment.
If a name is bound in a block, it is a local variable of that block.
If a name is bound at the module level, it is a global variable. (The
variables of the module code block are local and global.) If a
variable is used in a code block but not defined there, it is a
free variable.
The name binding operations are assignment, class and function
definition, import statements, for statements, and except statements.
Each assignment or import statement occurs within a block defined by a
class or function definition or at the module level (the top-level
code block).
If a name binding operation occurs anywhere within a code block, all
uses of the name within the block are treated as references to the
current block. This can lead to errors when a name is used within a
block before it is bound.
The previous rule is a subtle. Python lacks declarations and allows
name binding operations to occur anywhere within a code block. The
local variables of a code block can be determined by scanning the
entire text of the block for name binding operations.
If the global statement occurs within a block, all uses of the name
specified in the statement refer to the binding of that name in the
top-level namespace. Names are resolved in the top-level namespace by
searching the global namespace, i.e. the namespace of the module
containing the code block, and the builtin namespace, the namespace of
the module __builtin__. The global namespace is searched
first. If the name is not found there, the builtin namespace is
searched. The global statement must precede all uses of the name.
The global statement has the same scope as a name binding operation
in the same block. If the nearest enclosing scope for a free variable
contains a global statement, the free variable is treated as a global.
A class definition is an executable statement that may use and define
names. These references follow the normal rules for name resolution.
The namespace of the class definition becomes the attribute dictionary
of the class. Names defined at the class scope are not visible in
methods.


6.5 The del statement

pass.html | simple.html | print.html | Python Reference Manual | contents.html | genindex.html
---
# 6.5 The del statement
`del_stmt` | ::= | `"del" target_list`
Download entire grammar as text. (grammar.txt)
Deletion is recursively defined very similar to the way assignment is
defined. Rather that spelling it out in full details, here are some
hints.
Deletion of a target list recursively deletes each target, from left
to right.
Deletion of a name removes the binding of that name (which must exist)
from the local or global namespace, depending on whether the name
occurs in a global statement in the same code block.
Deletion of attribute references, subscriptions and slicings
is passed to the primary object involved; deletion of a slicing
is in general equivalent to assignment of an empty slice of the
right type (but even this is determined by the sliced object).


2.6 Delimiters

operators.html | lexical.html | datamodel.html | Python Reference Manual | contents.html | genindex.html
---
# 2.6 Delimiters
The following tokens serve as delimiters in the grammar:
```text

( ) [ ] { }
, : . ` = ;
+= -= *= /= //= %=
&= |= ^= >>= <<= **=
```
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.
The following printing ASCII characters have special meaning as part
of other tokens or are otherwise significant to the lexical analyzer:
```text

' " # \
```
The following printing ASCII characters are not used in Python. Their
occurrence outside string literals and comments is an unconditional
error:


5.2.5 Dictionary displays

lists.html | atoms.html | string-conversions.html | Python Reference Manual | contents.html | genindex.html
---
## 5.2.5 Dictionary displays
A dictionary display is a possibly empty series of key/datum pairs
enclosed in curly braces:
`dict_display` | ::= | `"" [ key_datum_list ] ""`
`key_datum_list` | ::= | `key_datum ("," key_datum )* [","]`
`key_datum` | ::= | `expression ":" expression`
Download entire grammar as text. (grammar.txt)
A dictionary display yields a new dictionary object.
The key/datum pairs are evaluated from left to right to define the
entries of the dictionary: each key object is used as a key into the
dictionary to store the corresponding datum.
Restrictions on the types of the key values are listed earlier in
section 3.2 (types.html#types). (To summarize,the key type should be hashable,
which excludes all mutable objects.) Clashes between duplicate keys
are not detected; the last datum (textually rightmost in the display)
stored for a given key value prevails.


A.3.2 Interaction with dynamic features

definitions.html | nested-scopes.html | node98.html | Python Reference Manual | contents.html | genindex.html
---
## A.3.2 Interaction with dynamic features
There are several cases where Python statements are illegal when
used in conjunction with nested scopes that contain free
variables.
If a variable is referenced in an enclosing scope, it is illegal
to delete the name. An error will be reported at compile time.
If the wild card form of import -- "import *" -- is used in a
function and the function contains or is a nested block with free
variables, the compiler will raise a SyntaxError.
If exec is used in a function and the function contains or is a nested
block with free variables, the compiler will raise a SyntaxError
unless the exec explicitly specifies the local namespace for the exec.
(In other words, "exec obj" would be illegal, but "exec obj in ns"
would be legal.)
The builtin functions eval() and input() can not
access free variables unless the variables are also referenced by the
program text of the block that contains the call to eval()
or input().
Compatibility note: The compiler for Python 2.1 will issue
warnings for uses of nested functions that will behave differently
with nested scopes. The warnings will not be issued if nested scopes
are enabled via a future statement. If a name bound in a function
scope and the function contains a nested function scope that uses the
name, the compiler will issue a warning. The name resolution rules
will result in different bindings under Python 2.1 than under Python
2.2. The warning indicates that the program may not run correctly
with all versions of Python.


4.2 Exceptions

execframes.html | execmodel.html | expressions.html | Python Reference Manual | contents.html | genindex.html
---
# 4.2 Exceptions
Exceptions are a means of breaking out of the normal flow of control
of a code block in order to handle errors or other exceptional
conditions. An exception is
raisedat the point where the error
is detected; it may be handledby
the surrounding code block or by any code block that directly or
indirectly invoked the code block where the error occurred.
The Python interpreter raises an exception when it detects a run-time
error (such as division by zero). A Python program can also
explicitly raise an exception with the raise statement.
Exception handlers are specified with the try ... except
statement. The try ... finally statement
specifies cleanup code which does not handle the exception, but is
executed whether an exception occurred or not in the preceding code.
Python uses the ``termination'' odel of
error handling: an exception handler can find out what happened and
continue execution at an outer level, but it cannot repair the cause
of the error and retry the failing operation (except by re-entering
the offending piece of code from the top).
When an exception is not handled at all, the interpreter terminates
execution of the program, or returns to its interactive main loop. In
either case, it prints a stack backtrace, except when the exception is
SystemExit.
Exceptions are identified by string objects or class instances.
Selection of a matching except clause is based on object identity
(i.e., two different string objects with the same value represent
different exceptions!) For string exceptions, the except
clause must reference the same string object. For class exceptions,
the except clause must reference the same class or a base
class of it.
When an exception is raised, an object (maybe `None`) is passed
as the exception's ``parameter'' or ``value''; this object does not
affect the selection of an exception handler, but is passed to the
selected exception handler as additional information. For class
exceptions, this object must be an instance of the exception class
being raised.


6.14 The exec statement

global.html | simple.html | compound.html | Python Reference Manual | contents.html | genindex.html
---
# 6.14 The exec statement
`exec_stmt` | ::= | `"exec" expression ["in" expression ["," expression ]]`
Download entire grammar as text. (grammar.txt)
This statement supports dynamic execution of Python code. The first
expression should evaluate to either a string, an open file object, or
a code object. If it is a string, the string is parsed as a suite of
Python statements which is then executed (unless a syntax error
occurs). If it is an open file, the file is parsed until EOF and
executed. If it is a code object, it is simply executed.
In all cases, if the optional parts are omitted, the code is executed
in the current scope. If only the first expression after in
is specified, it should be a dictionary, which will be used for both
the global and the local variables. If two expressions are given,
both must be dictionaries and they are used for the global and local
variables, respectively.
As a side effect, an implementation may insert additional keys into
the dictionaries given besides those corresponding to variable names
set by the executed code. For example, the current implementation
may add a reference to the dictionary of the built-in module
__builtin__ under the key `__builtins__` (!).
Programmer's hints:
dynamic evaluation of expressions is supported by the built-in
function eval(). The built-in functions
globals() and locals() return the current global
and local dictionary, respectively, which may be useful to pass around
for use by exec.
Also, in the current implementation, multi-line compound statements must
end with a newline:
`exec "for v in seq:\n\tprint v\n"` works, but
`exec "for v in seq:\n\tprint v"` fails with
SyntaxError.


execmodel.html | execmodel.html | exceptions.html | Python Reference Manual | contents.html | genindex.html
---
# 4.1 Code blocks, execution frames, and namespaces
A code blockis a piece
of Python program text that can be executed as a unit, such as a
module, a class definition or a function body. Some code blocks (like
modules) are normally executed only once, others (like function
bodies) may be executed many times. Code blocks may textually contain
other code blocks. Code blocks may invoke other code blocks (that may
or may not be textually contained in them) as part of their execution,
e.g., by invoking (calling) a function.
The following are code blocks: A module is a code block. A function
body is a code block. A class definition is a code block. Each
command typed interactively is a separate code block; a script file (a
file given as standard input to the interpreter or specified on the
interpreter command line the first argument) is a code block; a script
command (a command specified on the interpreter command line with the
`-c' option) is a code block. The file read by the built-in
function execfile() is a code block. The string argument
passed to the built-in function eval() and to the
exec statement is a code block. And finally, the expression
read and evaluated by the built-in function input() is a
code block.
A code block is executed in an execution frame. An execution
framecontains some administrative
information (used for debugging), determines where and how execution
continues after the code block's execution has completed, and (perhaps
most importantly) defines two namespaces, the local and the global
namespace, that affect execution of the code block.
A namespaceis a mapping from names
(identifiers) to objects. A particular namespace may be referenced by
more than one execution frame, and from other places as well. Adding
a name to a namespace is called bindinga
name (to an object); changing the mapping of a name is called
rebinding removing a name is
unbinding Namespaces are functionally
equivalent to dictionaries (and often implemented as dictionaries).
The local namespaceof an execution
frame determines the default place where names are defined and
searched. The
global namespacedetermines the place
where names listed in globalstatements are
defined and searched, and where names that are not bound anywhere in
the current code block are searched.
Whether a name is local or global in a code block is determined by
static inspection of the source text for the code block: in the
absence of global statements, a name that is bound anywhere
in the code block is local in the entire code block; all other names
are considered global. The global statement forces global
interpretation of selected names throughout the code block. The
following constructs bind names: formal parameters to functions,
import statements, class and function definitions (these
bind the class or function name in the defining block), and targets
that are identifiers if occurring in an assignment, for loop
header, or in the second position of an except clause
header. Local names are searched only on the local namespace; global
names are searched only in the global and built-in
namespace.4.1 (#foot2722)
A target occurring in a del statement is also considered bound
for this purpose (though the actual semantics are to ``unbind'' the
name).
When a global name is not found in the global namespace, it is
searched in the built-in namespace (which is actually the global
namespace of the module
__builtin__. The built-in
namespace associated with the execution of a code block is actually
found by looking up the name `__builtins__` in its global
namespace; this should be a dictionary or a module (in the latter case
its dictionary is used). Normally, the `__builtins__` namespace
is the dictionary of the built-in module __builtin__ (note:
no `s'); if it isn't, restricted
executionmode is in effect. When a
name is not found at all, a
NameError exception is raised.
The following table lists the meaning of the local and global
namespace for various types of code blocks. The namespace for a
particular module is automatically created when the module is first
imported (i.e., when it is loaded). Note that in almost all cases,
the global namespace is the namespace of the containing module --
scopes in Python do not nest!
Notes:
n.s.: means namespace
(1): The main module for a script is always called
__main__; ``the filename don't enter into it.''
(2): The global and local namespace for these can be
overridden with optional extra arguments.
(3): The exec statement and the eval() and
execfile() functions have optional arguments to override
the global and local namespace. If only one namespace is specified,
it is used for both.
The built-in functions globals() and locals() returns a
dictionary representing the current global and local namespace,
respectively. The effect of modifications to this dictionary on the
namespace are undefined.4.2 (#foot2730)


4. Execution model

numeric-types.html | ref.html | execframes.html | Python Reference Manual | contents.html | genindex.html
---
# 4. Execution model


2.1.4 Explicit line joining

comments.html | line-structure.html | implicit-joining.html | Python Reference Manual | contents.html | genindex.html
---
## 2.1.4 Explicit line joining
Two or more physical lines may be joined into logical lines using
backslash characters (`\`), as follows: when a physical line ends
in a backslash that is not part of a string literal or comment, it is
joined with the following forming a single logical line, deleting the
backslash and the following end-of-line character. For example:
```text

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
```
A line ending in a backslash cannot carry a comment. A backslash does
not continue a comment. A backslash does not continue a token except
for string literals (i.e., tokens other than string literals cannot be
split across physical lines using a backslash). A backslash is
illegal elsewhere on a line outside a string literal.


8.4 Expression input

interactive.html | top-level.html | futures.html | Python Reference Manual | contents.html | genindex.html
---
# 8.4 Expression input
There are two forms of expression input. Both ignore leading
whitespace.
The string argument to eval() must have the following form:
`eval_input` | ::= | `expression_list NEWLINE*`
Download entire grammar as text. (grammar.txt)
The input line read by input() must have the following form:
`input_input` | ::= | `expression_list NEWLINE`
Download entire grammar as text. (grammar.txt)
Note: to read `raw' input line without interpretation, you can use the
built-in function raw_input() or the readline() method
of file objects.


5. Expressions

exceptions.html | ref.html | conversions.html | Python Reference Manual | contents.html | genindex.html
---
# 5. Expressions
This chapter explains the meaning of the elements of expressions in
Python.
Syntax Notes: In this and the following chapters, extended
BNFnotation will be used to describe syntax, not lexical
analysis. When (one alternative of) a syntax rule has the form
`name` | ::= | `othername`
and no semantics are given, the semantics of this form of `name`
are the same as for `othername`.


5.11 Expression lists

lambda.html | expressions.html | summary.html | Python Reference Manual | contents.html | genindex.html
---
# 5.11 Expression lists
`expression_list` | ::= | `expression ( "," expression )* [","]`
Download entire grammar as text. (grammar.txt)
An expression list containing at least one comma yields a
tuple. The length of the tuple is the number of expressions in the
list. The expressions are evaluated from left to right.
The trailing comma is required only to create a single tuple (a.k.a. a
singleton); it is optional in all other cases. A single
expression without a trailing comma doesn't create a
tuple, but rather yields the value of that expression.
(To create an empty tuple, use an empty pair of parentheses:
`()`.)


6.1 Expression statements

simple.html | simple.html | assert.html | Python Reference Manual | contents.html | genindex.html
---
# 6.1 Expression statements
Expression statements are used (mostly interactively) to compute and
write a value, or (usually) to call a procedure (a function that
returns no meaningful result; in Python, procedures return the value
`None`). Other uses of expression statements are allowed and
occasionally useful. The syntax for an expression statement is:
`expression_stmt` | ::= | `expression_list`
Download entire grammar as text. (grammar.txt)
An expression statement evaluates the expression list (which may be a
single expression).
In interactive mode, if the value is not `None`, it is converted
to a string using the built-in repr()function and the resulting string is written to standard output (see
section 6.6 (print.html#print)) on a line by itself. (Expression statements
yielding `None` are not written, so that procedure calls do not
cause any output.)


8.2 File input

programs.html | top-level.html | interactive.html | Python Reference Manual | contents.html | genindex.html
---
# 8.2 File input
All input read from non-interactive files has the same form:
`file_input` | ::= | `(NEWLINE | statement )*`
Download entire grammar as text. (grammar.txt)
This syntax is used in the following situations:
- when parsing a complete Python program (from a file or from a string);
- when parsing a module;
- when parsing a string passed to the exec statement;


2.4.5 Floating point literals

integers.html | literals.html | imaginary.html | Python Reference Manual | contents.html | genindex.html
---
## 2.4.5 Floating point literals
Floating point literals are described by the following lexical
definitions:
`floatnumber` | ::= | `pointfloat | exponentfloat`
`pointfloat` | ::= | `[ intpart ] fraction | intpart "."`
`exponentfloat` | ::= | `( intpart | pointfloat ) exponent`
`intpart` | ::= | `digit +`
`fraction` | ::= | `"." digit +`
`exponent` | ::= | `("e" | "E") ["+" | "-"] digit +`
Download entire grammar as text. (grammar.txt)
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:
```text

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 operator
`-` and the literal `1`.


7.3 The for statement

while.html | compound.html | try.html | Python Reference Manual | contents.html | genindex.html
---
# 7.3 The for statement
The for statement is used to iterate over the elements of a
sequence (such as a string, tuple or list) or other iterable object:
`for_stmt` | ::= | `"for" target_list "in" expression_list ":" suite ["else" ":" suite ]`
Download entire grammar as text. (grammar.txt)
The expression list is evaluated once; it should yield a sequence. The
suite is then executed once for each item in the sequence, in the
order of ascending indices. Each item in turn is assigned to the
target list using the standard rules for assignments, and then the
suite is executed. When the items are exhausted (which is immediately
when the sequence is empty), the suite in the else clause, if
present, is executed, and the loop terminates.
A break statement executed in the first suite terminates the
loop without executing the else clause's suite. A
continue statement executed in the first suite skips the rest
of the suite and continues with the next item, or with the else
clause if there was no next item.
The suite may assign to the variable(s) in the target list; this does
not affect the next item assigned to it.
The target list is not deleted when the loop is finished, but if the
sequence is empty, it will not have been assigned to at all by the
loop. Hint: the built-in function range() returns a
sequence of integers suitable to emulate the effect of Pascal's
`for i := a to b do`;
e.g., `range(3)` returns the list `[0, 1, 2]`.
Warning:
There is a subtlety when the sequence is being modified
by the loop (this can only occur for mutable sequences, i.e. lists).
An internal counter is used to keep track of which item is used next,
and this is incremented on each iteration. When this counter has
reached the length of the sequence the loop terminates. This means that
if the suite deletes the current (or a previous) item from the
sequence, the next item will be skipped (since it gets the index of
the current item which has already been treated). Likewise, if the
suite inserts an item in the sequence before the current item, the
current item will be treated again the next time through the loop.
This can lead to nasty bugs that can be avoided by making a temporary
copy using a slice of the whole sequence, e.g.,
```text

for x in a[:]:
if x < 0: a.remove(x)
```


Front Matter

ref.html | ref.html | contents.html | Python Reference Manual | contents.html | genindex.html
---
# Front Matter
Copyright © 2001 Python Software Foundation.
All rights reserved.
Copyright © 2000 BeOpen.com.
All rights reserved.
Copyright © 1995-2000 Corporation for National Research Initiatives.
All rights reserved.
Copyright © 1991-1995 Stichting Mathematisch Centrum.
All rights reserved.
See the end of this document for complete license and permissions
information.
### Abstract:
Python is an interpreted, object-oriented, high-level programming
language with dynamic semantics. Its high-level built in data
structures, combined with dynamic typing and dynamic binding, make it
very attractive for rapid application development, as well as for use
as a scripting or glue language to connect existing components
together. Python's simple, easy to learn syntax emphasizes
readability and therefore reduces the cost of program
maintenance. Python supports modules and packages, which encourages
program modularity and code reuse. The Python interpreter and the
extensive standard library are available in source or binary form
without charge for all major platforms, and can be freely distributed.
This reference manual describes the syntax and ``core semantics'' of
the language. It is terse, but attempts to be exact and complete.
The semantics of non-essential built-in object types and of the
built-in functions and modules are described in the
Python Library Reference (../lib/lib.html). For an
informal introduction to the language, see the
Python Tutorial (../tut/tut.html). For C or
C++ programmers, two additional manuals exist:
Extending and Embedding the Python
Interpreter (../ext/ext.html) describes the high-level picture of how to write a Python
extension module, and the Python/C API
Reference Manual (../api/api.html) describes the interfaces available to
C/C++ programmers in detail.


7.5 Function definitions

try.html | compound.html | class.html | Python Reference Manual | contents.html | genindex.html
---
# 7.5 Function definitions
A function definition defines a user-defined function object (see
section 3.2 (types.html#types)):
`funcdef` | ::= | `"def" funcname "(" [ parameter_list ] ")"
":" suite`
`parameter_list` | ::= | `( defparameter ",")*
("*" identifier [, "**" identifier ]
| "**" identifier | defparameter [","])`
`defparameter` | ::= | `parameter ["=" expression ]`
`sublist` | ::= | `parameter ("," parameter )* [","]`
`parameter` | ::= | `identifier | "(" sublist ")"`
`funcname` | ::= | `identifier`
Download entire grammar as text. (grammar.txt)
A function definition is an executable statement. Its execution binds
the function name in the current local namespace to a function object
(a wrapper around the executable code for the function). This
function object contains a reference to the current global namespace
as the global namespace to be used when the function is called.
The function definition does not execute the function body; this gets
executed only when the function is called.
When one or more top-level parameters have the form parameter
`=` expression, the function is said to have ``default
parameter values.'' For a parameter with a
default value, the corresponding argument may be omitted from a call,
in which case the parameter's default value is substituted. If a
parameter has a default value, all following parameters must also have
a default value -- this is a syntactic restriction that is not
expressed by the grammar.
Default parameter values are evaluated when the function
definition is executed. This means that the expression is evaluated
once, when the function is defined, and that that same
``pre-computed'' value is used for each call. This is especially
important to understand when a default parameter is a mutable object,
such as a list or a dictionary: if the function modifies the object
(e.g. by appending an item to a list), the default value is in effect
modified. This is generally not what was intended. A way around this
is to use `None` as the default, and explicitly test for it in
the body of the function, e.g.:
```text

def whats_on_the_telly(penguin=None):
if penguin is None:
penguin = []
penguin.append("property of the zoo")
return penguin
```
Function call semantics are described in more detail in section
5.3.4 (calls.html#calls).
A function call always assigns values to all parameters mentioned in
the parameter list, either from position arguments, from keyword
arguments, or from default values. If the form ```*identifier`''
is present, it is initialized to a tuple receiving any excess
positional parameters, defaulting to the empty tuple. If the form
```**identifier`'' is present, it is initialized to a new
dictionary receiving any excess keyword arguments, defaulting to a
new empty dictionary.

It is also possible to create anonymous functions (functions not bound
to a name), for immediate use in expressions. This uses lambda forms,
described in section 5.10 (lambda.html#lambda). Note that the lambda form is
merely a shorthand for a simplified function definition; a function
defined in a ``def'' statement can be passed around or
assigned to another name just like a function defined by a lambda
form. The ``def'' form is actually more powerful since it
allows the execution of multiple statements.

Programmer's note: a ```def`'' form executed inside a
function definition defines a local function that can be returned or
passed around. The semantics of name resolution in the nested
function will change in Python 2.2. See the appendix for a
description of the new semantics.


A.1 Future statements

futures.html | futures.html | module-future.html | Python Reference Manual | contents.html | genindex.html
---
# A.1 Future statements
A future statementis a directive to
the compiler that a particular module should be compiled using syntax
or semantics that will be available in a specified future release of
Python. The future statement is intended to ease migration to future
versions of Python that introduce incompatible changes to the
language. It allows use of the new features on a per-module basis
before the release in which the feature becomes standard.
```text

future_statement: "from" "__future__" "import" feature ["as" name]
("," feature ["as" name])*

feature: identifier
name: identifier
```
A future statement must appear near the top of the module. The only
lines that can appear before a future statement are:
- the module docstring (if any),
- comments,
- blank lines, and
- other future statements.
The features recognized by Python 2.2 are "generators",
"division" and "nested_scopes". "nested_scopes"
is redundant in 2.2 as the nested scopes feature is active by default.
A future statement is recognized and treated specially at compile
time: Changes to the semantics of core constructs are often
implemented by generating different code. It may even be the case
that a new feature introduces new incompatible syntax (such as a new
reserved word), in which case the compiler may need to parse the
module differently. Such decisions cannot be pushed off until
runtime.
For any given release, the compiler knows which feature names have been
defined, and raises a compile-time error if a future statement contains
a feature not known to it.
The direct runtime semantics are the same as for any import statement:
there is a standard module __future__, described later, and
it will be imported in the usual way at the time the future statement
is executed.
The interesting runtime semantics depend on the specific feature
enabled by the future statement.
Note that there is nothing special about the statement:
```text

import __future__ [as name]
```
That is not a future statement; it's an ordinary import statement with
no special semantics or syntax restrictions.
Code compiled by an exec statement or calls to the builtin functions
compile() and execfile() that occur in a module
M containing a future statement will, by default, use the new
syntax or semantics associated with the future statement. This can,
starting with Python 2.2 be controlled by optional arguments to
compile() -- see the documentation of that function in the
library reference for details.
A future statement typed at an interactive interpreter prompt will
take effect for the rest of the interpreter session. If an
interpreter is started with the -i option, is passed a
script name to execute, and the script includes a future statement, it
will be in effect in the interactive session started after the script
is executed.


A. Future statements and nested scopes

expression-input.html | ref.html | future-statements.html | Python Reference Manual | contents.html | genindex.html
---
# A. Future statements and nested scopes
The semantics of Python's static scoping will change in version 2.2 to
support resolution of unbound local names in enclosing functions'
namespaces. The new semantics will be available in Python 2.1 through
the use of a future statement. This appendix documents these two
features for Python 2.1; it will be removed in Python 2.2 and the
features will be documented in the main sections of this manual.


Index

node100.html | ref.html | about.html | Python Reference Manual | contents.html
---
## Index
---
_ (#letter-_) |
a (#letter-a) |
b (#letter-b) |
c (#letter-c) |
d (#letter-d) |
e (#letter-e) |
f (#letter-f) |
g (#letter-g) |
h (#letter-h) |
i (#letter-i) |
k (#letter-k) |
l (#letter-l) |
m (#letter-m) |
n (#letter-n) |
o (#letter-o) |
p (#letter-p) |
q (#letter-q) |
r (#letter-r) |
s (#letter-s) |
t (#letter-t) |
u (#letter-u) |
v (#letter-v) |
w (#letter-w) |
x (#letter-x) |
y (#letter-y) |
z (#letter-z)
---
## _ (underscore)
---
## A
---
## B
---
## C
---
## D
---
## E
---
## F
---
## G
---
## H
---
## I
---
## K
---
## L
---
## M
---
## N
---
## O
---
## P
---
## Q
---
## R
---
## S
---
## T
---
## U
---
## V
---
## W
---
## X
---
## Y
---
## Z


6.13 The global statement

import.html | simple.html | exec.html | Python Reference Manual | contents.html | genindex.html
---
# 6.13 The global statement
`global_stmt` | ::= | `"global" identifier ("," identifier )*`
Download entire grammar as text. (grammar.txt)
The global statement is a declaration which holds for the
entire current code block. It means that the listed identifiers are to be
interpreted as globals. While using global names is automatic
if they are not defined in the local scope, assigning to global
names would be impossible without global.
Names listed in a global statement must not be used in the same
code block textually preceding that global statement.
Names listed in a global statement must not be defined as formal
parameters or in a for loop control target, class
definition, function definition, or import statement.
(The current implementation does not enforce the latter two
restrictions, but programs should not abuse this freedom, as future
implementations may enforce them or silently change the meaning of the
program.)
Programmer's note:
the global is a directive to the parser. It
applies only to code parsed at the same time as the global
statement. In particular, a global statement contained in an
exec statement does not affect the code block containing
the exec statement, and code contained in an exec
statement is unaffected by global statements in the code
containing the exec statement. The same applies to the
eval(), execfile() and compile() functions.


2.3.2 Reserved classes of identifiers

keywords.html | identifiers.html | literals.html | Python Reference Manual | contents.html | genindex.html
---
## 2.3.2 Reserved classes of identifiers
Certain classes of identifiers (besides keywords) have special
meanings. These are:
(XXX need section references here.)
Note:
(1): 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.


2.3 Identifiers and keywords

other-tokens.html | lexical.html | keywords.html | Python Reference Manual | contents.html | genindex.html
---
# 2.3 Identifiers and keywords
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"`
Download entire grammar as text. (grammar.txt)
Identifiers are unlimited in length. Case is significant.


7.1 The if statement

compound.html | compound.html | while.html | Python Reference Manual | contents.html | genindex.html
---
# 7.1 The if statement
The if statement is used for conditional execution:
`if_stmt` | ::= | `"if" expression ":" suite ( "elif" expression ":" suite )*
["else" ":" suite ]`
Download entire grammar as text. (grammar.txt)
It selects exactly one of the suites by evaluating the expressions one
by one until one is found to be true (see section 5.10 (lambda.html#Booleans) for
the definition of true and false); then that suite is executed (and no
other part of the if statement is executed or evaluated). If
all expressions are false, the suite of the else clause, if
present, is executed.


2.4.6 Imaginary literals

floating.html | literals.html | operators.html | Python Reference Manual | contents.html | genindex.html
---
## 2.4.6 Imaginary literals
Imaginary literals are described by the following lexical definitions:
`imagnumber` | ::= | `( floatnumber | intpart ) ("j" | "J")`
Download entire grammar as text. (grammar.txt)
An imaginary literal yields a complex number with a real part of
0.0. Complex numbers are represented as a pair of floating point
numbers and have the same restrictions on their range. To create a
complex number with a nonzero real part, add a floating point number
to it, e.g., `(3+4j)`. Some examples of imaginary literals:
```text

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


2.1.5 Implicit line joining

explicit-joining.html | line-structure.html | blank-lines.html | Python Reference Manual | contents.html | genindex.html
---
## 2.1.5 Implicit line joining
Expressions in parentheses, square brackets or curly braces can be
split over more than one physical line without using backslashes.
For example:
```text

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
```
Implicitly continued lines can carry comments. The indentation of the
continuation lines is not important. Blank continuation lines are
allowed. There is no NEWLINE token between implicit continuation
lines. Implicitly continued lines can also occur within triple-quoted
strings (see below); in that case they cannot carry comments.


6.12 The import statement

continue.html | simple.html | global.html | Python Reference Manual | contents.html | genindex.html
---
# 6.12 The import statement
`import_stmt` | ::= | `"import" module ["as" name ]
( "," module ["as" name ] )*
| "from" module "import" identifier ["as" name ]
( "," identifier ["as" name ] )*
| "from" module "import" "*"`
`module` | ::= | `( identifier ".")* identifier`
Download entire grammar as text. (grammar.txt)
Import statements are executed in two steps: (1) find a module, and
initialize it if necessary; (2) define a name or names in the local
namespace (of the scope where the import statement occurs).
The first form (without from) repeats these steps for each
identifier in the list. The form with from performs step
(1) once, and then performs step (2) repeatedly.
The system maintains a table of modules that have been initialized,
indexed by module name. This table is
accessible as `sys.modules`. When a module name is found in
this table, step (1) is finished. If not, a search for a module
definition is started. When a module is found, it is loaded. Details
of the module searching and loading process are implementation and
platform specific. It generally involves searching for a ``built-in''
module with the given name and then searching a list of locations
given as `sys.path`.
If a built-in module is found, its built-in initialization code is
executed and step (1) is finished. If no matching file is found,
ImportError is raised. If a file is found, it is parsed,
yielding an executable code block. If a syntax error occurs,
SyntaxError is raised. Otherwise, an empty module of the given
name is created and inserted in the module table, and then the code
block is executed in the context of this module. Exceptions during
this execution terminate step (1).
When step (1) finishes without raising an exception, step (2) can
begin.
The first form of import statement binds the module name in
the local namespace to the module object, and then goes on to import
the next identifier, if any. If the module name is followed by
as, the name following as is used as the local
name for the module. To avoid confusion, you cannot import modules
with dotted names as a different local name. So `import
module as m` is legal, but `import module.submod as s` is not.
The latter should be written as `from module import submod as s`;
see below.
The from form does not bind the module name: it goes through the
list of identifiers, looks each one of them up in the module found in step
(1), and binds the name in the local namespace to the object thus found.
As with the first form of import, an alternate local name can be
supplied by specifying "as localname". If a name is not found,
ImportError is raised. If the list of identifiers is replaced
by a star ("*"), all public names defined in the module are
bound in the local namespace of the import statement..
The public names defined by a module are determined by checking
the module's namespace for a variable named `__all__`; if
defined, it must be a sequence of strings which are names defined or
imported by that module. The names given in `__all__` are all
considered public and are required to exist. If `__all__` is not
defined, the set of public names includes all names found in the
module's namespace which do not begin with an underscore character
("_").
Names bound by import statements may not occur in
global statements in the same scope.
The from form with "*" may only occur in a module scope.
Hierarchical module names:when the module names contains one or more dots, the module search
path is carried out differently. The sequence of identifiers up to
the last dot is used to find a ``package''; the final
identifier is then searched inside the package. A package is
generally a subdirectory of a directory on `sys.path` that has a
file __init__.py.[XXX Can't be bothered to spell this out right now; see the URL
http://www.python.org/doc/essays/packages.html for more details, also
about how the module search works from inside a package.]
The built-in function __import__() is provided to support
applications that determine which modules need to be loaded
dynamically; refer to Built-in
Functions (../lib/built-in-funcs.html) in the
Python Library Reference (../lib/lib.html) for additional
information.


2.1.7 Indentation

blank-lines.html | line-structure.html | whitespace.html | Python Reference Manual | contents.html | genindex.html
---
## 2.1.7 Indentation
Leading whitespace (spaces and tabs) at the beginning of a logical
line is used to compute the indentation level of the line, which in
turn is used to determine the grouping of statements.
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.
Cross-platform compatibility note: because of the nature of
text editors on non-UNIX platforms, it is unwise to use a mixture of
spaces and tabs for the indentation in a single source file.
A formfeed character may be present at the start of the line; it will
be ignored for the indentation calculations above. Formfeed
characters occurring elsewhere in the leading whitespace have an
undefined effect (for instance, they may reset the space count to
zero).
The indentation levels of consecutive lines are used to generate
INDENT and DEDENT tokens, using a stack, as follows.
Before the first line of the file is read, a single zero is pushed on
the stack; this will never be popped off again. The numbers pushed on
the stack will always be strictly increasing from bottom to top. At
the beginning of each logical line, the line's indentation level is
compared to the top of the stack. If it is equal, nothing happens.
If it is larger, it is pushed on the stack, and one INDENT token is
generated. If it is smaller, it must be one of the numbers
occurring on the stack; all numbers on the stack that are larger are
popped off, and for each number popped off a DEDENT token is
generated. At the end of the file, a DEDENT token is generated for
each number remaining on the stack that is larger than zero.
Here is an example of a correctly (though confusingly) indented piece
of Python code:
```text

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
```
The following example shows various indentation errors:
```text

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
```
(Actually, the first three errors are detected by the parser; only the
last error is found by the lexical analyzer -- the indentation of
`return r` does not match a level popped off the stack.)


Python Reference Manual

../index.html | front.html | Python Reference Manual | contents.html | genindex.html
---
# Python Reference Manual
Guido van Rossum
Fred L. Drake, Jr., editor
PythonLabs
Email: python-docs@python.org
Release 2.2
December 21, 2001


2.4.4 Integer and long integer literals

numbers.html | literals.html | floating.html | Python Reference Manual | contents.html | genindex.html
---
## 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`
`decimalinteger` | ::= | `nonzerodigit digit * | "0"`
`octinteger` | ::= | `"0" octdigit +`
`hexinteger` | ::= | `"0" ("x" | "X") hexdigit +`
`nonzerodigit` | ::= | `"1"..."9"`
`octdigit` | ::= | `"0"..."7"`
`hexdigit` | ::= | `digit | "a"..."f" | "A"..."F"`
Download entire grammar as text. (grammar.txt)
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 decimal literals must be at most 2147483647 (i.e., the
largest positive integer, using 32-bit arithmetic). Plain octal and
hexadecimal literals may be as large as 4294967295, but values larger
than 2147483647 are converted to a negative value by subtracting
4294967296. There is no limit for long integer literals apart from
what can be stored in available memory.
Some examples of plain and long integer literals:
```text

7 2147483647 0177 0x80000000
3L 79228162514264337593543950336L 0377L 0x100000000L
```


8.3 Interactive input

file-input.html | top-level.html | expression-input.html | Python Reference Manual | contents.html | genindex.html
---
# 8.3 Interactive input
Input in interactive mode is parsed using the following grammar:
`interactive_input` | ::= | `[ stmt_list ] NEWLINE | compound_stmt NEWLINE`
Download entire grammar as text. (grammar.txt)
Note that a (top-level) compound statement must be followed by a blank
line in interactive mode; this is needed to help the parser detect the
end of the input.


1. Introduction

contents.html | ref.html | notation.html | Python Reference Manual | contents.html | genindex.html
---
# 1. Introduction
This reference manual describes the Python programming language.
It is not intended as a tutorial.
While I am trying to be as precise as possible, I chose to use English
rather than formal specifications for everything except syntax and
lexical analysis. This should make the document more understandable
to the average reader, but will leave room for ambiguities.
Consequently, if you were coming from Mars and tried to re-implement
Python from this document alone, you might have to guess things and in
fact you would probably end up implementing quite a different language.
On the other hand, if you are using
Python and wonder what the precise rules about a particular area of
the language are, you should definitely be able to find them here.
If you would like to see a more formal definition of the language,
maybe you could volunteer your time -- or invent a cloning machine
:-).
It is dangerous to add too many implementation details to a language
reference document -- the implementation may change, and other
implementations of the same language may work differently. On the
other hand, there is currently only one Python implementation in
widespread use (although a second one now exists!), and
its particular quirks are sometimes worth being mentioned, especially
where the implementation imposes additional limitations. Therefore,
you'll find short ``implementation notes'' sprinkled throughout the
text.
Every Python implementation comes with a number of built-in and
standard modules. These are not documented here, but in the separate
Python Library Reference (../lib/lib.html) document. A few
built-in modules are mentioned when they interact in a significant way
with the language definition.


2.3.1 Keywords

identifiers.html | identifiers.html | id-classes.html | Python Reference Manual | contents.html | genindex.html
---
## 2.3.1 Keywords
The following identifiers are used as reserved words, or
keywords of the language, and cannot be used as ordinary
identifiers. They must be spelled exactly as written here:
```text

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


5.10 Boolean operations

comparisons.html | expressions.html | exprlists.html | Python Reference Manual | contents.html | genindex.html
---
# 5.10 Boolean operations
Boolean operations have the lowest priority of all Python operations:
`expression` | ::= | `or_test | lambda_form`
`or_test` | ::= | `and_test | or_test "or" and_test`
`and_test` | ::= | `not_test | and_test "and" not_test`
`not_test` | ::= | `comparison | "not" not_test`
`lambda_form` | ::= | `"lambda" [ parameter_list ]: expression`
Download entire grammar as text. (grammar.txt)
In the context of Boolean operations, and also when expressions are
used by control flow statements, the following values are interpreted
as false: `None`, numeric zero of all types, empty sequences
(strings, tuples and lists), and empty mappings (dictionaries). All
other values are interpreted as true.
The operator not yields `1` if its argument is false,
`0` otherwise.
The expression `x and y` first evaluates x; if
x is false, its value is returned; otherwise, y is
evaluated and the resulting value is returned.
The expression `x or y` first evaluates x; if
x is true, its value is returned; otherwise, y is
evaluated and the resulting value is returned.
(Note that neither and nor or restrict the value
and type they return to `0` and `1`, but rather return the
last evaluated argument.
This is sometimes useful, e.g., if `s` is a string that should be
replaced by a default value if it is empty, the expression
`s or 'foo'` yields the desired value. Because not has to
invent a value anyway, it does not bother to return a value of the
same type as its argument, so e.g., `not 'foo'` yields `0`,
not `''`.)
Lambda forms (lambda expressions) have the same syntactic position as
expressions. They are a shorthand to create anonymous functions; the
expression `lambda arguments : expression`
yields a function object that behaves virtually identical to one
defined with
```text

def name(arguments):
return expression
```
See section 7.5 (function.html#function) for the syntax of parameter lists. Note
that functions created with lambda forms cannot contain statements.
Programmer's note: Prior to Python 2.1, a lambda form defined
inside a function has no access to names defined in the function's
namespace. This is because Python had only two scopes: local and
global. A common work-around was to use default argument values to
pass selected variables into the lambda's namespace, e.g.:
```text

def make_incrementor(increment):
return lambda x, n=increment: x+n
```
As of Python 2.1, nested scopes were introduced, and this work-around
has not been necessary. Python 2.1 supports nested scopes in modules
which include the statement "from __future__ import
nested_scopes", and more recent versions of Python enable nested
scopes by default. This version works starting with Python 2.1:
```text

from __future__ import nested_scopes

def make_incrementor(increment):
return lambda x: x+increment
```


2. Lexical analysis

notation.html | ref.html | line-structure.html | Python Reference Manual | contents.html | genindex.html
---
# 2. Lexical analysis
A Python program is read by a parser. Input to the parser is a
stream of tokens, generated by the lexical analyzer. This
chapter describes how the lexical analyzer breaks a file into tokens.
Python uses the 7-bit ASCII character set for program text and string
literals. 8-bit characters may be used in string literals and comments
but their interpretation is platform dependent; the proper way to
insert 8-bit characters in string literals is by using octal or
hexadecimal escape sequences.
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.