% Format this file with latex.

\documentstyle[myformat]{report}

\title{\bf

Python Tutorial

}

\author{

Guido van Rossum \\

Dept. CST, CWI, Kruislaan 413 \\

1098 SJ Amsterdam, The Netherlands \\

E-mail: {\tt [email protected]}

}

\begin{document}

\pagenumbering{roman}

\maketitle

\begin{abstract}

\noindent

Python is a simple, yet powerful programming language that bridges the

gap between C and shell programming, and is thus ideally suited for

``throw-away programming''

and rapid prototyping. Its syntax is put

together from constructs borrowed from a variety of other languages;

most prominent are influences from ABC, C, Modula-3 and Icon.

The Python interpreter is easily extended with new functions and data

types implemented in C. Python is also suitable as an extension

language for highly customizable C applications such as editors or

window managers.

Python is available for various operating systems, amongst which

several flavors of {\UNIX}, Amoeba, the Apple Macintosh O.S.,

and MS-DOS.

This tutorial introduces the reader informally to the basic concepts

and features of the Python language and system. It helps to have a

Python interpreter handy for hands-on experience, but as the examples

are self-contained, the tutorial can be read off-line as well.

For a description of standard objects and modules, see the {\em

Library Reference} document. The {\em Language Reference} document

(when it is ever written)

will give a more formal definition of the language.

\end{abstract}

\pagebreak

\tableofcontents

\pagebreak

\pagenumbering{arabic}

\chapter{Whetting Your Appetite}

If you ever wrote a large shell script, you probably know this

feeling: you'd love to add yet another feature, but it's already so

slow, and so big, and so complicated; or the feature involves a system

call or other funcion that is only accessible from C \ldots Usually

the problem at hand isn't serious enough to warrant rewriting the

script in C; perhaps because the problem requires variable-length

strings or other data types (like sorted lists of file names) that are

easy in the shell but lots of work to implement in C; or perhaps just

because you're not sufficiently familiar with C.

In such cases, Python may be just the language for you. Python is

simple to use, but it is a real programming language, offering much

more structure and support for large programs than the shell has. On

the other hand, it also offers much more error checking than C, and,

being a {\em very-high-level language}, it has high-level data types

built in, such as flexible arrays and dictionaries that would cost you

days to implement efficiently in C. Because of its more general data

types Python is applicable to a much larger problem domain than {\em

Awk} or even {\em Perl}, yet most simple things are at least as easy

in Python as in those languages.

Python allows you to split up your program in modules that can be

reused in other Python programs. It comes with a large collection of

standard modules that you can use as the basis of your programs ---

or as examples to start learning to program in Python. There are also

built-in modules that provide things like file I/O, system calls, and

even a generic interface to window systems (STDWIN).

Python is an interpreted language, which saves you considerable time

during program development because no compilation and linking is

necessary. The interpreter can be used interactively, which makes it

easy to experiment with features of the language, to write throw-away

programs, or to test functions during bottom-up program development.

It is also a handy desk calculator.

Python allows writing very compact and readable programs. Programs

written in Python are typically much shorter than equivalent C

programs, for several reasons:

\begin{itemize}

\item

the high-level data types allow you to express complex operations in a

single statement;

\item

statement grouping is done by indentation instead of begin/end

brackets;

\item

no variable or argument declarations are necessary.

\end{itemize}

Python is {\em extensible}: if you know how to program in C it is easy

to add a new built-in

function or

module to the interpreter, either to

perform critical operations at maximum speed, or to link Python

programs to libraries that may only be available in binary form (such

as a vendor-specific graphics library). Once you are really hooked,

you can link the Python interpreter into an application written in C

and use it as an extension or command language.

\section{Where From Here}

Now that you are all excited about Python, you'll want to examine it

in some more detail. Since the best introduction to a language is

using it, you are invited here to do so.

In the next chapter, the mechanics of using the interpreter are

explained. This is rather mundane information, but essential for

trying out the examples shown later.

The rest of the tutorial introduces various features of the Python

language and system though examples, beginning with simple

expressions, statements and data types, through functions and modules,

and finally touching upon advanced concepts like exceptions.

When you're through with the turtorial (or just getting bored), you

should read the Library Reference, which gives complete (though terse)

reference material about built-in and standard types, functions and

modules that can save you a lot of time when writing Python programs.

\chapter{Using the Python Interpreter}

The Python interpreter is usually installed as {\tt /usr/local/python}

on those machines where it is available; putting {\tt /usr/local} in

your {\UNIX} shell's search path makes it possible to start it by

typing the command

\bcode\begin{verbatim}

python

\end{verbatim}\ecode

to the shell. Since the choice of the directory where the interpreter

lives is an installation option, other places are possible; check with

your local Python guru or system administrator.

The interpreter operates somewhat like the {\UNIX} shell: when called

with standard input connected to a tty device, it reads and executes

commands interactively; when called with a file name argument or with

a file as standard input, it reads and executes a {\em script} from

that file.

Note that there is a difference between ``{\tt python file}'' and

``{\tt python $<$file}''. In the latter case, input requests from the

program, such as calls to {\tt input()} and {\tt raw\_input()}, are

satisfied from {\em file}. Since this file has already been read

until the end by the parser before the program starts executing, the

program will encounter EOF immediately. In the former case (which is

usually what you want) they are satisfied from whatever file or device

is connected to standard input of the Python interpreter.

A third possibility is ``{\tt python -c command [arg] ...}'', which

executes the statement(s) in {\tt command}, analogous to the shell's

{\tt -c} option. Usually {\tt command} will contain spaces or other

characters that are special to the shell, so it is best to quote it.

When available, the script name and additional arguments thereafter

are passed to the script in the variable {\tt sys.argv}, which is a

list of strings.

When {\tt -c command} is used, {\tt sys.argv} is set to {\tt '-c'}.

When commands are read from a tty, the interpreter is said to be in

{\em interactive\ mode}. In this mode it prompts for the next command

with the {\em primary\ prompt}, usually three greater-than signs ({\tt

>>>}); for continuation lines it prompts with the {\em secondary\

prompt}, by default three dots ({\tt ...}). Typing an EOF (Control-D)

at the primary prompt causes the interpreter to exit with a zero exit

status.

When an error occurs in interactive mode, the interpreter prints a

message and a stack trace and returns to the primary prompt; with

input from a file, it exits with a nonzero exit status after printing

the stack trace. (Exceptions handled by an {\tt except} clause in a

{\tt try} statement are not errors in this context.) Some errors are

unconditionally fatal and cause an exit with a nonzero exit; this

applies to internal inconsistencies and some cases of running out of

memory. All error messages are written to the standard error stream;

normal output from the executed commands is written to standard

output.

Typing an interrupt (normally Control-C or DEL) to the primary or

secondary prompt cancels the input and returns to the primary prompt.

Typing an interrupt while a command is being executed raises the {\tt

KeyboardInterrupt} exception, which may be handled by a {\tt try}

statement.

When a module named

{\tt foo}

is imported, the interpreter searches for a file named

{\tt foo.py}

in a list of directories specified by the environment variable

{\tt PYTHONPATH}.

It has the same syntax as the {\UNIX} shell variable

{\tt PATH},

i.e., a list of colon-separated directory names.

When

{\tt PYTHONPATH}

is not set, an installation-dependent default path is used, usually

{\tt .:/usr/local/lib/python}.

(Modules are really searched in the list of directories given by the

variable {\tt sys.path} which is initialized from {\tt PYTHONPATH} or

from the installation-dependent default. See the section on Standard

Modules later.)

As an important speed-up of the start-up time for short programs, if a

file called {\tt foo.pyc} exists in the directory where {\tt foo.py}

is found, this is assumed to contain an already-``compiled'' version

of the module {\tt foo}. The last modification time of {\tt foo.py}

is recorded in {\tt foo.pyc}, and the file is ignored if these don't

match. Whenever {\tt foo.py} is successfully compiled, an attempt is

made to write the compiled version to {\tt foo.pyc}.

On BSD'ish {\UNIX} systems, Python scripts can be made directly

executable, like shell scripts, by putting the line

\bcode\begin{verbatim}

#! /usr/local/python

\end{verbatim}\ecode

(assuming that's the name of the interpreter) at the beginning of the

script and giving the file an executable mode. (The {\tt \#!} must be

the first two characters of the file.)

\section{Interactive Input Editing and History Substitution}

Some versions of the Python interpreter support editing of the current

input line and history substitution, similar to facilities found in

the Korn shell and the GNU Bash shell. This is implemented using the

{\em GNU\ Readline} library, which supports Emacs-style and vi-style

editing. This library has its own documentation which I won't

duplicate here; however, the basics are easily explained.

Perhaps the quickest check to see whether command line editing is

supported is typing Control-P to the first Python prompt you get. If

it beeps, you have command line editing. If nothing appears to

happen, or if \verb/^P/ is echoed, you can skip the rest of this

section.

If supported, input line editing is active whenever the interpreter

prints a primary or secondary prompt. The current line can be edited

using the conventional Emacs control characters. The most important

of these are: C-A (Control-A) moves the cursor to the beginning of the

line, C-E to the end, C-B moves it one position to the left, C-F to

the right. Backspace erases the character to the left of the cursor,

C-D the character to its right. C-K kills (erases) the rest of the

line to the right of the cursor, C-Y yanks back the last killed

string. C-underscore undoes the last change you made; it can be

repeated for cumulative effect.

History substitution works as follows. All non-empty input lines

issued are saved in a history buffer, and when a new prompt is given

you are positioned on a new line at the bottom of this buffer. C-P

moves one line up (back) in the history buffer, C-N moves one down.

Any line in the history buffer can be edited; an asterisk appears in

front of the prompt to mark a line as modified. Pressing the Return

key passes the current line to the interpreter. C-R starts an

incremental reverse search; C-S starts a forward search.

The key bindings and some other parameters of the Readline library can

be customized by placing commands in an initialization file called

{\tt \$HOME/.inputrc}. Key bindings have the form

\bcode\begin{verbatim}

key-name: function-name

\end{verbatim}\ecode

and options can be set with

\bcode\begin{verbatim}

set option-name value

\end{verbatim}\ecode

Example:

\bcode\begin{verbatim}

# I prefer vi-style editing:

set editing-mode vi

# Edit using a single line:

set horizontal-scroll-mode On

# Rebind some keys:

Meta-h: backward-kill-word

Control-u: universal-argument

\end{verbatim}\ecode

Note that the default binding for TAB in Python is to insert a TAB

instead of Readline's default filename completion function. If you

insist, you can override this by putting

\bcode\begin{verbatim}

TAB: complete

\end{verbatim}\ecode

in your {\tt \$HOME/.inputrc}. (Of course, this makes it hard to type

indented continuation lines.)

This facility is an enormous step forward compared to previous

versions of the interpreter; however, some wishes are left: It would

be nice if the proper indentation were suggested on continuation lines

(the parser knows if an indent token is required next). The

completion mechanism might use the interpreter's symbol table. A

function to check (or even suggest) matching parentheses, quotes etc.

would also be useful.

\chapter{An Informal Introduction to Python}

In the following examples, input and output are distinguished by the

presence or absence of prompts ({\tt >>>} and {\tt ...}): to repeat the

example, you must type everything after the prompt, when the prompt

appears;

lines that do not begin with a prompt are output from the interpreter.

Note that a secondary prompt on a line by itself in an example means

you must type a blank line; this is used to end a multi-line command.

\section{Using Python as a Calculator}

Let's try some simple Python commands. Start the interpreter and wait

for the primary prompt, {\tt >>>}.

The interpreter acts as a simple calculator: you can type an

expression at it and it will write the value. Expression syntax is

straightforward: the operators {\tt +}, {\tt -}, {\tt *} and {\tt /}

work just as in most other languages (e.g., Pascal or C); parentheses

can be used for grouping. For example:

\bcode\begin{verbatim}

>>> # This is a comment

>>> 2+2

4

>>>

>>> (50-5+5*6+25)/4

25

>>> # Division truncates towards zero:

>>> 7/3

2

>>>

\end{verbatim}\ecode

As in C, the equal sign ({\tt =}) is used to assign a value to a

variable. The value of an assignment is not written:

\bcode\begin{verbatim}

>>> width = 20

>>> height = 5*9

>>> width * height

900

>>>

\end{verbatim}\ecode

A value can be assigned to several variables simultaneously:

\bcode\begin{verbatim}

>>> # Zero x, y and z

>>> x = y = z = 0

>>>

\end{verbatim}\ecode

There is full support for floating point; operators with mixed type

operands convert the integer operand to floating point:

\bcode\begin{verbatim}

>>> 4 * 2.5 / 3.3

3.0303030303

>>>

\end{verbatim}\ecode

Besides numbers, Python can also manipulate strings, enclosed in

single quotes:

\bcode\begin{verbatim}

>>> 'foo bar'

'foo bar'

>>> 'doesn\'t'

'doesn\'t'

>>>

\end{verbatim}\ecode

Strings are written

the same way as they are typed for input:

inside quotes and with quotes and other funny characters escaped by

backslashes, to show the precise value. (There is also a way to write

strings without quotes and escapes.)

Strings can be concatenated (glued together) with the {\tt +}

operator, and repeated with {\tt *}:

\bcode\begin{verbatim}

>>> word = 'Help' + 'A'

>>> word

'HelpA'

>>> '<' + word*5 + '>'

'<HelpAHelpAHelpAHelpAHelpA>'

>>>

\end{verbatim}\ecode

Strings can be subscripted; as in C, the first character of a string

has subscript 0.

There is no separate character type; a character is simply a string of

size one. As in Icon, substrings can be specified with the {\em

slice} notation: two subscripts (indices) separated by a colon.

\bcode\begin{verbatim}

>>> word[4]

'A'

>>> word[0:2]

'He'

>>> word[2:4]

'lp'

>>> # Slice indices have useful defaults:

>>> word[:2] # Take first two characters

'He'

>>> word[2:] # Drop first two characters

'lpA'

>>> # A useful invariant: s[:i] + s[i:] = s

>>> word[:3] + word[3:]

'HelpA'

>>>

\end{verbatim}\ecode

Degenerate cases are handled gracefully: an index that is too large is

replaced by the string size, an upper bound smaller than the lower

bound returns an empty string.

\bcode\begin{verbatim}

>>> word[1:100]

'elpA'

>>> word[10:]

''

>>> word[2:1]

''

>>>

\end{verbatim}\ecode

Slice indices (but not simple subscripts) may be negative numbers, to

start counting from the right. For example:

\bcode\begin{verbatim}

>>> word[-2:] # Take last two characters

'pA'

>>> word[:-2] # Drop last two characters

'Hel'

>>> # But -0 does not count from the right!

>>> word[-0:] # (since -0 equals 0)

'HelpA'

>>>

\end{verbatim}\ecode

The best way to remember how slices work is to think of the indices as

pointing {\em between} characters, with the left edge of the first

character numbered 0. Then the right edge of the last character of a

string of {\tt n} characters has index {\tt n}, for example:

\bcode\begin{verbatim}

+---+---+---+---+---+

| H | e | l | p | A |

+---+---+---+---+---+

0 1 2 3 4 5

-5 -4 -3 -2 -1

\end{verbatim}\ecode

The first row of numbers gives the position of the indices 0...5 in

the string; the second row gives the corresponding negative indices.

For nonnegative indices, the length of a slice is the difference of

the indices, if both are within bounds, e.g., the length of {\tt

word[1:3]} is 3--1 = 2.

The built-in function {\tt len()} computes the length of a string:

\bcode\begin{verbatim}

>>> s = 'supercalifragilisticexpialidocious'

>>> len(s)

34

>>>

\end{verbatim}\ecode

Python knows a number of {\em compound} data types, used to group

together other values. The most versatile is the {\em list}, which

can be written as a list of comma-separated values between square

brackets:

\bcode\begin{verbatim}

>>> a = ['foo', 'bar', 100, 1234]

>>> a

['foo', 'bar', 100, 1234]

>>>

\end{verbatim}\ecode

As for strings, list subscripts start at 0:

\bcode\begin{verbatim}

>>> a[0]

'foo'

>>> a[3]

1234

>>>

\end{verbatim}\ecode

Lists can be sliced, concatenated and so on, like strings:

\bcode\begin{verbatim}

>>> a[1:3]

['bar', 100]

>>> a[:2] + ['bletch', 2*2]

['foo', 'bar', 'bletch', 4]

>>> 3*a[:3] + ['Boe!']

['foo', 'bar', 100, 'foo', 'bar', 100, 'foo', 'bar', 100, 'Boe!']

>>>

\end{verbatim}\ecode

Unlike strings, which are {\em immutable}, it is possible to change

individual elements of a list:

\bcode\begin{verbatim}

>>> a

['foo', 'bar', 100, 1234]

>>> a[2] = a[2] + 23

>>> a

['foo', 'bar', 123, 1234]

>>>

\end{verbatim}\ecode

Assignment to slices is also possible, and this may even change the size

of the list:

\bcode\begin{verbatim}

>>> # Replace some items:

>>> a[0:2] = [1, 12]

>>> a

[1, 12, 123, 1234]

>>> # Remove some:

>>> a[0:2] = []

>>> a

[123, 1234]

>>> # Insert some:

>>> a[1:1] = ['bletch', 'xyzzy']

>>> a

[123, 'bletch', 'xyzzy', 1234]

>>>

\end{verbatim}\ecode

The built-in function {\tt len()} also applies to lists:

\bcode\begin{verbatim}

>>> len(a)

4

>>>

\end{verbatim}\ecode

It is possible to nest lists (create lists containing other lists),

for example:

\bcode\begin{verbatim}

>>> p = [1, [2, 3], 4]

>>> len(p)

3

>>> p[1]

[2, 3]

>>> p[1][0]

2

>>> p[1].append('xtra')

>>> p

[1, [2, 3, 'xtra'], 4]

>>>

\end{verbatim}\ecode

\section{First Steps Towards Programming}

Of course, we can use Python for more complicated tasks than adding

two and two together. For instance, we can write an initial

subsequence of the {\em Fibonacci} series as follows:

\bcode\begin{verbatim}

>>> # Fibonacci series:

>>> # the sum of two elements defines the next

>>> a, b = 0, 1

>>> while b < 10:

... print b

... a, b = b, a+b

...

1

1

2

3

5

8

>>>

\end{verbatim}\ecode

This example introduces several new features.

\begin{itemize}

\item

The first line contains a {\em multiple assignment}: the variables

{\tt a} and {\tt b} simultaneously get the new values 0 and 1. On the

last line this is used again, demonstrating that the expressions on

the right-hand side are all evaluated first before any of the

assignments take place.

\item

The {\tt while} loop executes as long as the condition (here: {\tt b <

100}) remains true. In Python, as in C, any non-zero integer value is

true; zero is false. The condition may also be a string or list value,

in fact any sequence; anything with a non-zero length is true, empty

sequences are false. The test used in the example is a simple

comparison. The standard comparison operators are written as {\tt <},

{\tt >}, {\tt =}, {\tt <=}, {\tt >=} and {\tt <>}.%

\footnote{

The ambiguity of using {\tt =}

for both assignment and equality is resolved by disallowing

unparenthesized conditions on the right hand side of assignments.

Parenthesized assignment is also disallowed; instead it is

interpreted as an equality test.

}

\item

The {\em body} of the loop is {\em indented}: indentation is Python's

way of grouping statements. Python does not (yet!) provide an

intelligent input line editing facility, so you have to type a tab or

space(s) for each indented line. In practice you will prepare more

complicated input for Python with a text editor; most text editors have

an auto-indent facility. When a compound statement is entered

interactively, it must be followed by a blank line to indicate

completion (since the parser cannot guess when you have typed the last

line).

\item

The {\tt print} statement writes the value of the expression(s) it is

given. It differs from just writing the expression you want to write

(as we did earlier in the calculator examples) in the way it handles

multiple expressions and strings. Strings are written without quotes,

and a space is inserted between items, so you can format things nicely,

like this:

\bcode\begin{verbatim}

>>> i = 256*256

>>> print 'The value of i is', i

The value of i is 65536

>>>

\end{verbatim}\ecode

A trailing comma avoids the newline after the output:

\bcode\begin{verbatim}

>>> a, b = 0, 1

>>> while b < 1000:

... print b,

... a, b = b, a+b

...

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

>>>

\end{verbatim}\ecode

Note that the interpreter inserts a newline before it prints the next

prompt if the last line was not completed.

\end{itemize}

\chapter{More Control Flow Tools}

Besides the {\tt while} statement just introduced, Python knows the

usual control flow statements known from other languages, with some

twists.

\section{If Statements}

Perhaps the most well-known statement type is the {\tt if} statement.

For example:

\bcode\begin{verbatim}

>>> if x < 0:

... x = 0

... print 'Negative changed to zero'

... elif x = 0:

... print 'Zero'

... elif x = 1:

... print 'Single'

... else:

... print 'More'

...

\end{verbatim}\ecode

There can be zero or more {\tt elif} parts, and the {\tt else} part is

optional. The keyword `{\tt elif}' is short for `{\tt else if}', and is

useful to avoid excessive indentation. An {\tt if...elif...elif...}

sequence is a substitute for the {\em switch} or {\em case} statements

found in other languages.

\section{For Statements}

The {\tt 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 (as in Pascal), or leaving the user

completely free in the iteration test and step (as C), Python's {\tt

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

\bcode\begin{verbatim}

>>> # Measure some strings:

>>> a = ['cat', 'window', 'defenestrate']

>>> for x in a:

... print x, len(x)

...

cat 3

window 6

defenestrate 12

>>>

\end{verbatim}\ecode

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:

\bcode\begin{verbatim}

>>> for x in a[:]: # make a slice copy of the entire list

... if len(x) > 6: a.insert(0, x)

...

>>> a

['defenestrate', 'cat', 'window', 'defenestrate']

>>>

\end{verbatim}\ecode

\section{The {\tt range()} Function}

If you do need to iterate over a sequence of numbers, the built-in

function {\tt range()} comes in handy. It generates lists containing

arithmetic progressions, e.g.:

\bcode\begin{verbatim}

>>> range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>

\end{verbatim}\ecode

The given end point is never part of the generated list; {\tt 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):

\bcode\begin{verbatim}

>>> range(5, 10)

[5, 6, 7, 8, 9]

>>> range(0, 10, 3)

[0, 3, 6, 9]

>>> range(-10, -100, -30)

[-10, -40, -70]

>>>

\end{verbatim}\ecode

To iterate over the indices of a sequence, combine {\tt range()} and

{\tt len()} as follows:

\bcode\begin{verbatim}

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']

>>> for i in range(len(a)):

... print i, a[i]

...

0 Mary

1 had

2 a

3 little

4 lamb

>>>

\end{verbatim}\ecode

\section{Break and Continue Statements, and Else Clauses on Loops}

The {\tt break} statement, like in C, breaks out of the smallest

enclosing {\tt for} or {\tt while} loop.

The {\tt continue} statement, also borrowed from C, continues with the

next iteration of the loop.

Loop statements may have an {\tt else} clause; it is executed when the

loop terminates through exhaustion of the list (with {\tt for}) or when

the condition becomes false (with {\tt while}), but not when the loop is

terminated by a {\tt break} statement. This is exemplified by the

following loop, which searches for a list item of value 0:

\bcode\begin{verbatim}

>>> for n in range(2, 10):

... for x in range(2, n):

... if n % x = 0:

... print n, 'equals', x, '*', n/x

... break

... else:

... print n, 'is a prime number'

...

2 is a prime number

3 is a prime number

4 equals 2 * 2

5 is a prime number

6 equals 2 * 3

7 is a prime number

8 equals 2 * 4

9 equals 3 * 3

>>>

\end{verbatim}\ecode

\section{Pass Statements}

The {\tt pass} statement does nothing.

It can be used when a statement is required syntactically but the

program requires no action.

For example:

\bcode\begin{verbatim}

>>> while 1:

... pass # Busy-wait for keyboard interrupt

...

\end{verbatim}\ecode

\section{Defining Functions}

We can create a function that writes the Fibonacci series to an

arbitrary boundary:

\bcode\begin{verbatim}

>>> def fib(n): # write Fibonacci series up to n

... a, b = 0, 1

... while b <= n:

... print b,

... a, b = b, a+b

...

>>> # Now call the function we just defined:

>>> fib(2000)

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

>>>

\end{verbatim}\ecode

The keyword {\tt def} introduces a function {\em 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 starts at

the next line, indented by a tab stop.

The {\em 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 to from within a

function, 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 {\em call\ by\ value}.%

\footnote{

Actually, {\em call by object reference} would be a better

description, since if a mutable object is passed, the caller

will see any changes the callee makes to it (e.g., items

inserted into a list).

}

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:

\bcode\begin{verbatim}

>>> fib

<function object at 10042ed0>

>>> f = fib

>>> f(100)

1 1 2 3 5 8 13 21 34 55 89

>>>

\end{verbatim}\ecode

You might object that {\tt fib} is not a function but a procedure. In

Python, as 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 {\tt None} (it's a

built-in name). Writing the value {\tt None} is normally suppressed by

the interpreter if it would be the only value written. You can see it

if you really want to:

\bcode\begin{verbatim}

>>> print fib(0)

None

>>>

\end{verbatim}\ecode

It is simple to write a function that returns a list of the numbers of

the Fibonacci series, instead of printing it:

\bcode\begin{verbatim}

>>> def fib2(n): # return Fibonacci series up to n

... result = []

... a, b = 0, 1

... while b <= n:

... result.append(b) # see below

... a, b = b, a+b

... return result

...

>>> f100 = fib2(100) # call it

>>> f100 # write the result

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

>>>

\end{verbatim}\ecode

This example, as usual, demonstrates some new Python features:

\begin{itemize}

\item

The {\tt return} statement returns with a value from a function. {\tt

return} without an expression argument is used to return from the middle

of a procedure (falling off the end also returns from a proceduce), in

which case the {\tt None} value is returned.

\item

The statement {\tt result.append(b)} calls a {\em method} of the list

object {\tt result}. A method is a function that `belongs' to an

object and is named {\tt obj.methodname}, where {\tt obj} is some

object (this may be an expression), and {\tt 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 {\em classes}. This is an

advanced feature that is not discussed in this tutorial.)

The method {\tt 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 {\tt result = result + [b]}, but more efficient.

\end{itemize}

\chapter{Odds and Ends}

This chapter describes some things you've learned about already in

more detail, and adds some new things as well.

\section{More on Lists}

The list data type has some more methods. Here are all of the methods

of lists objects:

\begin{description}

\item[{\tt insert(i, x)}]

Insert an item at a given position. The first argument is the index of

the element before which to insert, so {\tt a.insert(0, x)} inserts at

the front of the list, and {\tt a.insert(len(a), x)} is equivalent to

{\tt a.append(x)}.

\item[{\tt append(x)}]

Equivalent to {\tt a.insert(len(a), x)}.

\item[{\tt index(x)}]

Return the index in the list of the first item whose value is {\tt x}.

It is an error if there is no such item.

\item[{\tt remove(x)}]

Remove the first item from the list whose value is {\tt x}.

It is an error if there is no such item.

\item[{\tt sort()}]

Sort the items of the list, in place.

\item[{\tt reverse()}]

Reverse the elements of the list, in place.

\end{description}

An example that uses all list methods:

\bcode\begin{verbatim}

>>> a = [66.6, 333, 333, 1, 1234.5]

>>> a.insert(2, -1)

>>> a.append(333)

>>> a

[66.6, 333, -1, 333, 1, 1234.5, 333]

>>> a.index(333)

1

>>> a.remove(333)

>>> a

[66.6, -1, 333, 1, 1234.5, 333]

>>> a.reverse()

>>> a

[333, 1234.5, 1, 333, -1, 66.6]

>>> a.sort()

>>> a

[-1, 1, 66.6, 333, 333, 1234.5]

>>>

\end{verbatim}\ecode

\section{The {\tt del} statement}

There is a way to remove an item from a list given its index instead

of its value: the {\tt del} statement. This can also be used to

remove slices from a list (which we did earlier by assignment of an

empty list to the slice). For example:

\bcode\begin{verbatim}

>>> a

[-1, 1, 66.6, 333, 333, 1234.5]

>>> del a[0]

>>> a

[1, 66.6, 333, 333, 1234.5]

>>> del a[2:4]

>>> a

[1, 66.6, 1234.5]

>>>

\end{verbatim}\ecode

{\tt del} can also be used to delete entire variables:

\bcode\begin{verbatim}

>>> del a

>>>

\end{verbatim}\ecode

Referencing the name {\tt a} hereafter is an error (at least until

another value is assigned to it). We'll find other uses for {\tt del}

later.

\section{Tuples and Sequences}

We saw that lists and strings have many common properties, e.g.,

subscripting and slicing operations. They are two examples of {\em

sequence} data types. As Python is an evolving language, other

sequence data types may be added. There is also another standard

sequence data type: the {\em tuple}.

A tuple consists of a number of values separated by commas, for

instance:

\bcode\begin{verbatim}

>>> t = 12345, 54321, 'hello!'

>>> t[0]

12345

>>> t

(12345, 54321, 'hello!')

>>> # Tuples may be nested:

>>> u = t, (1, 2, 3, 4, 5)

>>> u

((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

>>>

\end{verbatim}\ecode

As you see, on output tuples are alway enclosed in parentheses, so

that nested tuples are interpreted correctly; they may be input with

or without surrounding parentheses, although often parentheses are

necessary anyway (if the tuple is part of a larger expression).

Tuples have many uses, e.g., (x, y) coordinate pairs, employee records

from a database, etc. Tuples, like strings, are immutable: it is not

possible to assign to the individual items of a tuple (you can

simulate much of the same effect with slicing and concatenation,