The following sections describe the standard types that are built into the interpreter.
The principal built-in types are numerics, sequences, mappings, classes, instances and exceptions.
Some collection classes are mutable. The methods that add, subtract, or rearrange their members in place, and don’t return a specific item, never return the collection instance itself but None.
Some operations are supported by several object types; in particular, practically all objects can be compared for equality, tested for truth value, and converted to a string (with the repr() function or the slightly different str()function). The latter function is implicitly used when an object is written by the print() function.
The while statement is used for repeated execution as long as an expression is true:
while_stmt ::= "while" assignment_expression ":" suite
["else" ":" suite]
This repeatedly tests the expression and, if it is true, executes the first suite; if the expression is false (which may be the first time it is tested) the suite of 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 goes back to testing the expression.
The if statement is used for conditional execution:
if_stmt ::= "if" assignment_expression ":" suite
("elif" assignment_expression ":" suite)*
["else" ":" suite]
It selects exactly one of the suites by evaluating the expressions one by one until one is found to be true (see section Boolean operations 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.
Lists are mutable sequences, typically used to store collections of homogeneous items (where the precise degree of similarity will vary by application).
class list([iterable])
Lists may be constructed in several ways:
- Using a pair of square brackets to denote the empty list:
[] - Using square brackets, separating items with commas:
[a], [a, b, c] - Using a list comprehension:
[x for x in iterable] - Using the type constructor:
codelist()orlist(iterable)
Tuples are immutable sequences, typically used to store collections of heterogeneous data (such as the 2-tuples produced by the enumerate() built-in). Tuples are also used for cases where an immutable sequence of homogeneous data is needed (such as allowing storage in a set or dict instance).
class tuple([iterable])
Tuples may be constructed in several ways:
- Using a pair of parentheses to denote the empty tuple:
() - Using a trailing comma for a singleton tuple:
a, or (a,) - Separating items with commas::
a, b, c or (a, b, c) - Using the
tuple() built-in:tuple() ortuple(iterable)