There can be zero or more elif parts, and the
else part is optional. The keyword `elif' is
short for `else if', and is useful to avoid excessive indentation. An
if ... elif ... elif ... sequence
is a substitute for the switch or
case statements found in other languages.

4.2 for Statements

The for statement in Python differs a bit from
what you may be used to in C or Pascal. Rather than always
iterating over an arithmetic progression of numbers (like in Pascal),
or giving the user the ability to define both the iteration step and
halting condition (as C), Python's
for statement iterates over the items of any
sequence (e.g., a list or a string), in the order that they appear in
the sequence. For example (no pun intended):

It is not safe to modify the sequence being iterated over in the loop
(this can only happen for mutable sequence types, i.e., lists). If
you need to modify the list you are iterating over, e.g., duplicate
selected items, you must iterate over a copy. The slice notation
makes this particularly convenient:

4.3 The range() Function

If you do need to iterate over a sequence of numbers, the built-in
function range() comes in handy. It generates lists
containing arithmetic progressions, e.g.:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

The given end point is never part of the generated list;
range(10) generates a list of 10 values, exactly the legal
indices for items of a sequence of length 10. It is possible to let
the range start at another number, or to specify a different increment
(even negative; sometimes this is called the `step'):

4.4 break and continue Statements, and
else Clauses on Loops

The break statement, like in C, breaks out of the smallest
enclosing for or while loop.

The continue statement, also borrowed from C, continues
with the next iteration of the loop.

Loop statements may have an else clause; it is executed when
the loop terminates through exhaustion of the list (with
for) or when the condition becomes false (with
while), but not when the loop is terminated by a
break statement. This is exemplified by the following loop,
which searches for prime numbers:

The keyword def introduces a function definition. It
must be followed by the function name and the parenthesized list of
formal parameters. The statements that form the body of the function
start at the next line, and must be indented. The first statement of
the function body can optionally be a string literal; this string
literal is the function's documentation
string, or docstring.

There are tools which use docstrings to automatically produce online
or printed documentation, or to let the user interactively browse
through code; it's good practice to include docstrings in code that
you write, so try to make a habit of it.

The execution of a function introduces a new symbol table used
for the local variables of the function. More precisely, all variable
assignments in a function store the value in the local symbol table;
whereas variable references first look in the local symbol table, then
in the global symbol table, and then in the table of built-in names.
Thus, global variables cannot be directly assigned a value within a
function (unless named in a global statement), although
they may be referenced.

The actual parameters (arguments) to a function call are introduced in
the local symbol table of the called function when it is called; thus,
arguments are passed using call by value (where the
value is always an object reference, not the value of
the object).4.1 When a function calls another function, a new local symbol table is
created for that call.

A function definition introduces the function name in the current
symbol table. The value of the function name
has a type that is recognized by the interpreter as a user-defined
function. This value can be assigned to another name which can then
also be used as a function. This serves as a general renaming
mechanism:

You might object that fib is not a function but a procedure. In
Python, like in C, procedures are just functions that don't return a
value. In fact, technically speaking, procedures do return a value,
albeit a rather boring one. This value is called None (it's a
built-in name). Writing the value None is normally suppressed by
the interpreter if it would be the only value written. You can see it
if you really want to:

>>> print fib(0)
None

It is simple to write a function that returns a list of the numbers of
the Fibonacci series, instead of printing it:

The return statement returns with a value from a function.
return without an expression argument is used to return from
the middle of a procedure (falling off the end also returns from a
procedure), in which case the None value is returned.

The statement result.append(b) calls a method of the list
object result. A method is a function that `belongs' to an
object and is named obj.methodname, where obj is some
object (this may be an expression), and methodname is the name
of a method that is defined by the object's type. Different types
define different methods. Methods of different types may have the
same name without causing ambiguity. (It is possible to define your
own object types and methods, using classes, as discussed later
in this tutorial.)
The method append() shown in the example, is defined for
list objects; it adds a new element at the end of the list. In this
example it is equivalent to "result = result + [b]", but more
efficient.

4.7 More on Defining Functions

It is also possible to define functions with a variable number of
arguments. There are three forms, which can be combined.

4.7.1 Default Argument Values

The most useful form is to specify a default value for one or more
arguments. This creates a function that can be called with fewer
arguments than it is defined, e.g.

This function can be called either like this:
ask_ok('Do you really want to quit?') or like this:
ask_ok('OK to overwrite the file?', 2).

The default values are evaluated at the point of function definition
in the defining scope, so that e.g.

i = 5
def f(arg = i): print arg
i = 6
f()

will print 5.

Important warning: The default value is evaluated only once.
This makes a difference when the default is a mutable object such as a
list or dictionary. For example, the following function accumulates
the arguments passed to it on subsequent calls:

In general, an argument list must have any positional arguments
followed by any keyword arguments, where the keywords must be chosen
from the formal parameter names. It's not important whether a formal
parameter has a default value or not. No argument may receive a
value more than once -- formal parameter names corresponding to
positional arguments cannot be used as keywords in the same calls.
Here's an example that fails due to this restriction:

When a final formal parameter of the form **name is
present, it receives a dictionary containing all keyword arguments
whose keyword doesn't correspond to a formal parameter. This may be
combined with a formal parameter of the form
*name (described in the next subsection) which receives a
tuple containing the positional arguments beyond the formal parameter
list. (*name must occur before **name.)
For example, if we define a function like this:

4.7.3 Arbitrary Argument Lists

Finally, the least frequently used option is to specify that a
function can be called with an arbitrary number of arguments. These
arguments will be wrapped up in a tuple. Before the variable number
of arguments, zero or more normal arguments may occur.

def fprintf(file, format, *args):
file.write(format % args)

4.7.4 Lambda Forms

By popular demand, a few features commonly found in functional
programming languages and Lisp have been added to Python. With the
lambda keyword, small anonymous functions can be created.
Here's a function that returns the sum of its two arguments:
"lambda a, b: a+b". Lambda forms can be used wherever function
objects are required. They are syntactically restricted to a single
expression. Semantically, they are just syntactic sugar for a normal
function definition. Like nested function definitions, lambda forms
cannot reference variables from the containing scope, but this can be
overcome through the judicious use of default argument values, e.g.

def make_incrementor(n):
return lambda x, incr=n: x+incr

4.7.5 Documentation Strings

There are emerging conventions about the content and formatting of
documentation strings.

The first line should always be a short, concise summary of the
object's purpose. For brevity, it should not explicitly state the
object's name or type, since these are available by other means
(except if the name happens to be a verb describing a function's
operation). This line should begin with a capital letter and end with
a period.

If there are more lines in the documentation string, the second line
should be blank, visually separating the summary from the rest of the
description. The following lines should be one or more paragraphs
describing the object's calling conventions, its side effects, etc.

The Python parser does not strip indentation from multi-line string
literals in Python, so tools that process documentation have to strip
indentation if desired. This is done using the following convention.
The first non-blank line after the first line of the string
determines the amount of indentation for the entire documentation
string. (We can't use the first line since it is generally adjacent
to the string's opening quotes so its indentation is not apparent in
the string literal.) Whitespace ``equivalent'' to this indentation is
then stripped from the start of all lines of the string. Lines that
are indented less should not occur, but if they occur all their
leading whitespace should be stripped. Equivalence of whitespace
should be tested after expansion of tabs (to 8 spaces, normally).