The Java Language Environment White Paper [Gosling96] lists a number of desirable features of a programming language:

Python meets and exceeds most of these expectations. We'll look closely at each of these twelve desireable attributes.

Simple and Familiar. By simple, we mean that there is no GOTO statement, we don't need to explicitly manage memory and pointers, there is no confusing preprocessor, we don't have the aliasing problems associated wuth unions. We note that this list summarizes the most confusing and bug-inducing features of the C programming language.

Python is simple. It relies on a few core data structures and statements. The rich set of features is introduced by explicit import of extension modules. Python lacks the problem-plagued GOTO statement, and includes the more reliable break, continue and exception raise statements. Python conceals the mechanics of object references from the programmer, making it impossible to corrupt a pointer. There is no language preprocessor to obscure the syntax of the language. There is no C-style union (or COBOL-style REDEFINES) to create problematic aliases for data in memory.

Python uses an English-like syntax, making it reasonably familiar to people who read and write English or related languages. There are few syntax rules, and ordinary, obvious indentation is used to make the structure of the software very clear.

Object-Oriented. Python is object oriented. Almost all language features are first class objects, and can be used in a variety of contexts. This is distinct from Java and C++ which create confusion by having objects as well as primitive data types that are not objects. The built-in type(x) function can interrogate the types of all objects. The language permits creation of new object classes. It supports single and multiple inheritance. Polymorphism is supported via run-time interpretation, leading to some additional implementation freedoms not permitted in Java or C++.

Secure. The Python language environment is reasonably secure from tampering. Pre-compiled python modules can be distributed to prevent altering the source code. Additional security checks can be added by supplementing the built-in __import__ function.

Many security flaws are problems with operating systems or framework software (for example, database servers or web servers). There is, however, one prominent language-related security problem: the "buffer overflow" problem, where an input buffer, of finite size, is overwritten by input data which is larger than the available buffer. Python doesn't suffer from this problem.

Python is a dynamic language, and abuse of features like the exec statement or the eval function can introduce security problems. These mechanisms are easy to identify and audit in a large program.

Interpreted. An interpreted language, like Python allows for rapid, flexible, exploratory software development. Compiled languages require a sometimes lengthy edit-compile-link-execute cycle. Interpreted languages permit a simpler edit-execute cycle. Interpreted languages can support a complete debugging and diagnostic environment. The Python interpreter can be run interactively; which can help with program development and testing.

The Python interpreter can be extended with additional high-performance modules. Also, the Python interpreter can be embedded into another application to provide a handy scripting extension to that application.

Dynamic. Python executes dynamically. Python modules can be distributed as source; they are compiled (if necessary) at import time. Object messages are interpreted, and problems are reported at run time, allowing for flexible development of applications.

In C++, any change to centrally used class headers will lead to lengthy recompilation of dependent modules. In Java, a change to the public interface of a class can invalidate a number of other modules, leading to recompilation in the best case, or runtime errors in the worst case.

Portable. Since Python rests squarely on a portable C source, Python programs behave the same on a variety of platforms. Subtle issues like memory management are completely hidden. Operating system inconsistency makes it impossible to provide perfect portability of every feature. Portable GUI's are built using the widely-ported Tk GUI tools Tkinter, or the GTK+ tools and the the pyGTK bindings.

Robust. Programmers do not directly manipulate memory or pointers, making the language run-time environment very robust. Errors are raised as exceptions, allowing programs to catch and handle a variety of conditions. All Python language mistakes lead to simple, easy-to-interpret error messages from exceptions.

Multithreaded. The Python threading module is a Posix-compliant threading library. This is not completely supported on all platforms, but does provide the necessary interfaces. Beyond thread management, OS process management is also available, as are execution of shell scripts and other programs from within a Python program.

Additionally, many of the web frameworks include thread management. In products like TurboGears, individual web requests implicitly spawn new threads.

Garbage Collection. Memory-management can be done with explicit deletes or automated garbage collection. Since Python uses garbage collection, the programmer doesn't have to worry about memory leaks (failure to delete) or dangling references (deleting too early).

The Python run-time environment handles garbage collection of all Python objects. Reference counters are used to assure that no live objects are removed. When objects go out of scope, they are eligible for garbage collection.

Exceptions. Python has exceptions, and a sophisticated try statement that handles exceptions. Unlike the standard C library where status codes are returned from some functions, invalid pointers returned from others and a global error number variable used for determining error conditions, Python signals almost all errors with an exception. Even common, generic OS services are wrapped so that exceptions are raised in a uniform way.

High Performance. The Python interpreter is quite fast. However, where necessary, a class or module that is a bottleneck can be rewritten in C or C++, creating an extension to the runtime environment that improves performance.

One of the languages which strongly influenced the design of Python was Modula-2. In 1974, N. Wirth (creator of Pascal and its successor, Modula-2) wrote an article “On the Design of Programming Languages” [Wirth74], which defined some timeless considerations in designing a programming language. He suggests the following:

Python syntax is designed for readability; the language is quite simple, making it easy to learn and use. The Python community is always alert to ways to simplify Python. The Python 3.0 project is actively working to remove a few poorly-concieved features of Python. This will mean that Python 3.0 will be simpler and easier to use, but incompatible with Python 2.x in a few areas.

Most Python features are brought in via modules, assuring that extensions do not change or break existing features. This allows tremendous flexibility and permits rapid growth in the language libraries.

The Python interpreter is very small. Typically, it is smaller than the Java Virtual Machine. Since Python is (ultimately) written in C, it has the same kind of broad access to external libraries and extensions. Also, this makes Python completely portable.

Backup. Before installing software, back up your computer. I strongly recommend that you get a tool like Norton's Ghost™. This product will create a CD that you can use to reconstruct the operating system on your PC in case something goes wrong. It is difficult to undo an installation in Windows, and get your computer back the way it was before you started.

I've never had a single problem installing Python. I've worked with a number of people, however, who either have bad luck or don't read carefully and have managed to corrupt their Windows installation by downloading and installing software. While Python is safe, stable, reliable, virus-free, and well-respected, you may be someone with bad luck who has a problem. Often the problem already existed on your PC and installing Python was the straw that broke the camel's back. A backup is cheap insurance.

You should also have a folder for saving your downloads. You can create a folder in My Documents called downloads. I suggest that you keep all of your various downloaded tools and utilities in this folder for two reasons. If you need to reinstall your software, you know exactly what you downloaded. When you get a new computer (or an additional computer), you know what needs to be installed on that computer.

Download. After making a backup, go to the www.python.org web site and look for the Download area. In here, you're looking for the pre-built Windows installer. This book will emphasize Python 2.5. In that case, the kit is python-2.5.x.msi. When you click on the filename, your browser should start downloading the file. Save it in your downloads folder.

Backup. Now is a good time to make a second backup. Seriously. This backup will have your untouched Windows system, plus the Python installation kit. It is still cheap insurance.

If you have anti-virus software [you do, don't you?] you may need to disable this until you are done installing Python.

At this point, you have everything you need to install Python:

You'll need two things to install Python. If you don't have both, see the previous section on pre-installation.

Double-click the Python installer (python-2.5.x.msi).

The first step is to select a destination directory. The default destination should be C:\Python25. Note that Python does not expect to live in the C:\My Programs folder. Because the My Programs folder has a space in the middle of the name — something that is atypical for all operating systems other than Windows — subtle problems can arise. Consequently, Python folks prefer to put Python into C:\Python25 on Windows machines. Click Next to continue.

The next step is to confirm that you want to backup replaced files. The option to make backups is already selected and the folder is usually C:\Python25\BACKUP. This is the way it should be. Click Next to continue.

The next step is the list of components to install. You have a list of five components.

There is an Advanced Options... button that is necessary if you are using a company-supplied computer for which you are not the administrator. If you are not the administrator, and you have permission to install additional software, you can click on this button to get the Advanced Options panel. There's a button labeled Non-Admin install that you'll need to click in order to install Python on a PC where you don't have administrator privileges.

Click Next to continue.

You can pick a Start Menu Group for the Python program, IDLE and the help files. Usually, it is placed in a menu named Python 2.5. I can't see any reason for changing this, since it only seems to make things harder to find. Click Next to continue.

The installer puts files in the selected places. This takes less than a minute.

Click Finish; you have just installed Python on your computer.

In your Start... menu, under All Programs, you will now have a Python 2.5 group that lists five things:

GUI is the Graphic User Interface. We'll turn to IDLE in the section called “The IDLE Development Environment”.

Python 2.5.1 (r251:54863, Apr 18 2007, 08:51:08) [MSC v.1310 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

If you select the Python Manuals menu item, this will open a Microsoft Help reader that will show the complete Python documentation library.

Before installing software, back up your computer. While you can't easily burn a DVD of everything on your computer, you can usually burn a DVD of everything in your Mac OS X Home directory.

I've never had a single problem installing Python. I've worked with a number of people, however, who either have bad luck or don't read carefully and have managed to corrupt their Mac OS installation by downloading and installing software. While Python is safe, stable, reliable, virus-free, and well-respected, you may be someone with bad luck who has a problem. A backup is cheap insurance.

You should also have a folder for saving your downloads. You can create a folder in hour Documents called downloads. I suggest that you keep all of your various downloaded tools and utilities in this folder for two reasons. If you need to reinstall your software, you know exactly what you downloaded. When you get a new computer (or an additional computer), you know what needs to be installed on that computer.

Download. After making a backup, go to the www.python.org web site and look for the Download area. In here, you're looking for the pre-built Mac OS X installer. This book will emphasize Python 2.5. In that case, the kit is python-2.5.x-macosxdate.dmg. When you click on the filename, your browser should start downloading the file. Save it in your downloads folder.

Backup. Now is a good time to make a second backup. Seriously. It is still cheap insurance.

At this point, you have everything you need to install Python:

When you double-click the python-2.5.x-macosxdate.dmg file, it will create a disk image named Universal MacPython 2.5.x. This disk image has your license, a ReadMe file, and the MacPython.mpkg.

When you double-click the MacPython.mpkg fie, it will take all the necessary steps to install Python on your computer. The installer will take you through seven steps. Generally, you'll read the messages and

Introduction. Read the message and click Continue.

Read Me. This is the contents of the ReadMe file on the installer disk image. Read the message and click Continue.

License. You can read the history of Python, and the terms and conditions for using it. To install Python, you must agree with the license. When you click Continue, you will get a pop-up window that asks if you agree. Click Agree to install Python.

Select Destination. Generally, your primary disk drive, usually named Macintosh HD will be highlighted with a green arrow. Click Continue.

Installation Type. If you've done this before, you'll see that this will be an upgrade. If this is the first time, you'll be doing an install. Click the Install or Upgrade button.

You'll be asked for your password. If, for some reason, you aren't the administrator for this computer, you won't be able to install software. Otherwise, provide your password so that you can install software.

Finish Up. The message is usually "The software was successfully installed". Click Close to finish.

In your Applications folder, you'll find a MacPython 2.5 folder, which contains a number of applications.

Look in /System/Library/Frameworks/Python.Framework/Versions for the relevant files. In the bin, Extras and Resources directories you'll find the various applications. The bin/idle file will launch IDLE for us.

Once you've finished installation, you should check to be sure that everything is working correctly.

Python 2.5.1 (r251:54863, Oct  5 2007, 21:08:09) 
[GCC 4.0.1 (Apple Inc. build 5465)] on darwin
Type "copyright", "credits" or "license()" for more information.

    ****************************************************************
    Personal firewall software may warn about the connection IDLE
    makes to its subprocess using this computer's internal loopback
    interface.  This connection is not visible on any external
    interface and no data is sent to or received from the Internet.
    ****************************************************************
    
IDLE 1.2.1      
>>> 

You may notice a Help menu. This has the Python Docs menu item, which you can access through the menu or by hitting F1. This will launch Safari to show you the Python documents available on the Internet.

Before installing software, back up your computer.

You should also have a directory for saving your downloads. I recommend that you create a /opt directory for these kinds of options which are above and beyond the basic Linx installation. You can keep all of your various downloaded tools and utilities in this directory for two reasons. If you need to reinstall your software, you know exactly what you downloaded. When you get a new computer (or an additional computer), you know what needs to be installed on that computer.

A typical scenario for installing Python is a command like the following. This has specific file names for Fedora Core 9. You'll need to locate appropriate RPM's for your distribution of Linux.

rpm -i http://download.fedora.redhat.com/pub/fedora/linux/development\
/i386/os/Packages/python-2.5.1-18.fc9.i386.rpm

Often, that's all there is to it. In some cases, you'll get warnings about the DSA signature. These are expected, since we didn't tell RPM the public key that was used to sign the packages.

Starting and stopping Python varies with your operating system. Generally, all of the variations are nearly identical, and differ only in minor details.

Windows. There are two ways to start interactive Python under Windows. You can run the command tool (cmd.exe) or you can run the Python (Command Line) program. If you run cmd.exe, enter the command python to start interactive Python. If you run Python (Command Line) from the Start menu, the result will be essentially the same.

To exit from Python, enter the end-of-file character sequence, Control-Z and Return.

Mac OS, GNU/Linux and Unix. You will run the Terminal tool. You can enter the command python to start interactive Python.

To exit from Python, enter the end-of-file character, Control-D.

When we run the Python interpreter (called python, or Python.exe in Windows), we see a greeting like the following:

52:~ slott$ env python
Python 2.5.1 (r251:54863, Oct  5 2007, 21:08:09) 
[GCC 4.0.1 (Apple Inc. build 5465)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 

When we get the >>> prompt, the Python interpreter is looking for input. We can type any Python statements we want. Each complete statement is executed when it is entered. Some statements are called compound statements; a compound statement has a suite of statements indented inside of it. Python will wait until the entire compound statement is entered before it does does the evaluation.

In this section, we'll emphasize the prompts from Python. This can help newbies see the complete cycle of interaction between themselves and the Python interpreter. In the long run we'll be writing scipts and won't see this level of interaction.

The Return Key. For this section only, we'll also emphasize the usually invisible Return (↵) key. When we start using compound statements in Chapter 7, Truth, Comparison and Conditional Processing, we'll add some additional syntax rules. For now, however, statements can't be indented; they must begin without any leading spaces or tabs.

>>> 2 + 3 ↵
5
>>>

This shows Python doing simple integer arithmetic. When you entered 2 + 3 and then hit Return, the Python interpreter evaluated this statement. Since the statement was only an expression, Python printed the results.

We'll dig into to the various kinds of numbers in Simple Numeric Expressions and Output. For now, it's enough to know that you have integers and floating-point numbers that look much like other programming languages. As a side note, integers have two slightly different flavors -- fast (but small) and long (but slow). Python prefers will use the fast integers (called int) until your numbers get so huge that it has to switch to long.

Arithmetic operators include the usual culprits: +, -, *, /, % and ** standing for addition, subtraction, multiplication, division, modulo (remainder after division) and raising to a power. The usual mathematical rules of operator precedence (multiplys and divides done before adds and subtracts) are in full force, and ()'s are used to group terms against precedence rules.

For example, converting 65° Fahrenheit to Celsius is done as follows:

>>> (65 - 32) * 5 / 9 ↵
18
>>> (65.-32)*5/9 ↵
18.333333333333332
>>>

Note that the first example used all integer values, and the result was an integer result. In the second example, the presence of a float caused all the values to be coerced to float.

End-Of-Statement Rules. What happens when the expression is obviously incomplete?

>>> ( 65 - 32 ) * 5 / ↵

  File "<stdin>", line 1
    (65-32)*5 /
              ^
SyntaxError: invalid syntax

>>>

One basic syntax rule is that statements must be complete on a single line. There are few formal lexical rules for the structure of statements; we'll present them more formally after we've experienced them.

There is an escape clause in the basic rule of “one statement one line”. When the parenthesis are incomplete, Python will allow the statement to run on to multiple lines.

>>> ( 65 - 32 ↵
... ) * 5 / 9 ↵
18
>>>

It is also possible to continue a long statement using a \ escape just before hitting Return at the end of the line.

>>> 5 + 6 *\ ↵
... 7↵
47
>>>

This escape allows you to break up an extremely long statement for easy reading. It creates an escape from the usual meaning of the end-of-line character; the end-of-line is demoted to just another whitespace character, and loses it's meaning of “end-of-statement, commence execution now”.

Indentation. Python relies heavily on indendentation to make a program readable. When interacting with Python, we are often typing simple expression statements, which are not indented. Later, when we start typing compound statements, indentation will begin to matter.

Here's what happens if we try to indent a simple expression statement.

>>>       5+6
      
SyntaxError: invalid syntax

Command History. When we type a complete expression, Python evaluates it and displays the result. When we type a complete statement, Python executes it silently. We'll see more of this, starting in Chapter 6, Variables, Assignment and Input. We'll make heavy use of this feature in Chapter 4, Simple Numeric Expressions and Output.

Small mistakes can be frustrating when typing a long or complex statement. Python has a reasonable command history capability, so you can use the up-arrow key to recover a previous statement. Generally, you'll prefer to create script files and run the scripts. When debugging a problem, however, interactive mode can be handy for experimenting.

One of the desirable features of well-written Python is that most things can be tested and demonstrated in small code fragments. Often a single line of easy-to-enter code is the desired style for interesting programming features. Many examples in reference manuals and unit test scripts are simply captures of interactive Python sessions.

Starting and stopping IDLE varies with your operating system. Generally, all of the variations are nearly identical, and differ only in minor details.

Windows. There are several ways to start IDLE in Windows. You can use IDLE (Python GUI) from the Python2.5 menu on the Start menu.

You can also run IDLE from the command prompt. This requires two configuration settings in Windows.

You can quit IDLE by using the Quit menu item under the File menu.

Mac OS. In the Mac OS, if you've done an upgrade, you may find the IDLE program in the Python 2.5 folder in your Applications folder. You can double-click this icon to run IDLE.

You can always find IDLE in the directory /System/Library/Frameworks/Python.framework/Versions/Current/bin. Generally, this is on your PATH, and you can type the command idle in a Terminal window to start IDLE. The idle2.5 icon is a document, not an applicaction, and can't easily be put into your Dock.

You can create your own Applescript icon to run the IDLE shell script. This requires a single line of Applescript:

do shell script "/System/Library/Frameworks/Python.framework/Versions/Current/bin/idle" 

When you run IDLE from the icon, you'll notice that two windows are opened: a Python Shell window and a Console window. The Console window isn't used for much.

When you run IDLE from the Terminal window, no console window is opened. The Terminal window is the Python console.

You can quit IDLE by using the Quit menu item under the File menu. You can also quit by using the Quit Idle menu item under the Idle menu.

Since the Macintosh keyboard has a command key, ⌘, as well as a control key, ctrl, there are two keyboard mappings for IDLE. You can use the Configure IDLE... item under the Options menu to select any of the built-in Key Sets. Selecting the IDLE Classic Mac settings may be more comfortable for Mac OS users.

GNU/Linux. We'll avoid the GNOME and KDE subtleties. Instead, we'll focus on running IDLE from the Terminal tool. Since the file path is rather long, you'll want to edit your .profile (or .bash_profile) to include the following alias definition.

alias idle='env python /usr/lib/python2.5/idlelib/idle.py &'

This allows you to run IDLE by entering the command idle in a Terminal window.

You can quit IDLE by using the Exit menu item under the File menu.

Initially, you'll see the following greeting from IDLE.

Python 2.5.1 (r251:54863, Oct  5 2007, 21:08:09) 
[GCC 4.0.1 (Apple Inc. build 5465)] on darwin
Type "copyright", "credits" or "license()" for more information.

    ****************************************************************
    Personal firewall software may warn about the connection IDLE
    makes to its subprocess using this computer's internal loopback
    interface.  This connection is not visible on any external
    interface and no data is sent to or received from the Internet.
    ****************************************************************
    
IDLE 1.2.1      
>>> 

The personal firewall notification is a reminder that IDLE uses Internetworking Protocols (IP) as part of its debugger. If you have a software firewall on you development computer, and the firewall software complains, you can allow the connection.

IDLE has a simple and relatively standard text editor, which does Python syntax highlighting. It also has a Python Shell window which manages an interactive Python session. You will see that the Python Shell window has a Shell and a Debug menu.

When you use the New menu item in the File menu, you'll see a file window, which has a slightly different menu bar. A file window has name which is a file name (or untitled), and two unique menus, a Run and a Format menu.

Generally, you'll use IDLE in two ways:

The Python Shell window in IDLE presents a >>> prompt. At this prompt, you can enter Python expressions or statements for evaluation. This window has a complete command history, so you can use the up arrow to select a previous statement and make changes.

You can refer back to Command-Line Interaction; those interactions will look and behave the same in IDLE as they do on the command line.

The Shell Window is essentially the command-line interface wrapped in a scrolling window. The IDLE interface, however, provides a consistent working environment, which is independent of each operating system's command-line interface.

The Shell and Debug menus provides functions you'll use when developing larger programs. For our first steps with Python, we won't need either of these menus. We'll talk briefly about the functions, but can't really make use of them until we've learned more of the language.

The Shell Menu. The Shell menu is used to restart the Python interpreter, or scroll back through the shell's log to locate the most recent restart. This is important when you are developing a module that is used as a library. When you change that module, you need to reset the shell so that the previous version is forgotten and the new version can be imported into a fresh, empty interpreter.

Generally, being able to work interactively is the best way to develop working programs. It encourages you to create tidy, simple-looking components which you can exercise directly.

The Debug Menu. The Debug menu provides some handy tools for watching how Python executes a program.

Each file window in IDLE is a simple text editor with two additional menus. The Format menu has a series of items for fairly common source text manipulations. The formatting operations include indenting, commenting, handling tabs and formatting text paragraphs.

The Run menu makes it easy to execute the file you are editing.

The simplest way to execute a script is to provide the script file name as a parameter to the python interpreter. In this style, we explicitly name both the interpreter and the input script. Here's an example.

python example1.py

This will provide the example1.py file to the Python interpreter for execution.

We can streamline the command that starts our application. For POSIX-standard operating systems (GNU/Linux, UNIX and MacOS), we make the script file itself executable and directing the shell to locate the Python interpreter for us. For Windows users, we associate our script file with the python.exe interpreter. There are one or two steps to this.

Now you can run a script in most GNU/Linux environments by saying:

./example1.py

Windows Setup. Windows users will need to be sure that python.exe is on their PATH. This is done with the System control panel. Click on the Advanced tab. Click on the Environment Variables… button. Click on the System variables Path line, and click the Edit… button. This will often have a long list of items, sometimes starting with “%SystemRoot%”. At the end of this list, add “;” and the direction location of Python.exe. On my machine, I put it in C:\Python23.

For Windows programmers, the windows command interpreter uses the last letters of the file name to associate a file with an interpreter. You can have Windows run the python.exe program whenever you double-click a .py file. This is done with the Folder Options control panel. The File Types tab allows you to pair a file type with a program that processes the file.

POSIX Setup. We have to be sure that the Python interpreter is in value of the PATH that our shell uses. We can't delve into the details of each of the available UNIX Shells. However, the general rule is that the person who administers your POSIX computer should have installed Python and updated the /etc/profile to make Python available to all users. If, for some reason that didn't get done, you can update your own .profile to add Python to your PATH variable.

Throughout the rest of this book, we're going to use this script processing mode as the standard way to run Python programs. Many of the examples will be shown as though a file was sent to the interpreter.

For debugging and testing, it is sometimes useful to import the program definitions, and do some manipulations interactively. We'll touch on this in the section called “Hacking Mode”.

Here's a second example. We'll create a new file and write another small Python program. We'll call it example2.py.

#!/usr/bin/env python
"""Compute the odds of spinning red (or black) six times in a row
on an American roulette wheel. """
print (18.0/38.0)**6

This is a one-line Python program with a two line module document string. That's a good ratio to strive for.

After we finish editing, we mark this as executable using chmod +x example2.py. Since this is a property of the file, this is remains true no matter how many times we edit, copy or rename the file.

When we run this, we see the following.

$ ./example2.py
0.0112962280375

Which says that spinning six reds in a row is about a one in eighty-nine probability.

The Komodo Edit is an IDE that is considerably more sophisticated than IDLE. It is — in a way — too sophisticated for this book. Our focus is on the language, not high-powered IDE's. As with IDLE, this is a tool that runs everywhere, so you can move seamlessly from GNU/Linux to Wiundows to the Mac OS with a single, powerful tool.

See www.komodo.com for more information on ordering and downloading.

Windows programmers might want to use a tool like Textpad. See www.textpad.com for information on ordering and downloading. Be sure to also download the python.syn file from www.textpad.com/add-ons, which has a number of Python syntax coloring configurations.

To use Textpad, you have two setup steps. First, you'll need to add the Python document class. Second you'll need to tell Textpad about the Python tool.

The Python Document Class. You need to tell Textpad about the Python document class. Use the Configure menu; the New Document Class… menu item lets you add Python documents to Textpad. Name your new document class Python and click Next. Give your class members named *.py and click Next. Locate your python.syn file and click Next. Check the new Python document class, and click Next if everything looks right to create a new Textpad document class.

The Python Tool. You'll want to add the Python interpreter as a Textpad tool. Use the Configure menu again, this time selecting the Preferences… item. Scroll down the list of preferences on the left and click on Tools. On the right, you'll get a panel with the current set of tools and a prominent Add button on the top right-hand side. Click Add, and select Program… from the menu that appears. You'll get a dialog for locating a file; find the Python.exe file. Click Okay to save this program as a Textpad tool.

You can check this by using Configure menu and Preferences… item again. Scroll down the list to find Tools. Click the + sign and open the list of tools. Click the Python tool and check the following:

You might also want to turn off the Sound Alert option; this will beep when a program finishes running. I find this makes things a little too noisy for most programs.

Macintosh programmers might want to use a tool like BBEdit. BBEdit can also run the programs, saving the output for you. See www.barebones.com for more information on BBEdit.

To use BBEdit, you have two considerations when writing Python programs.

You must be sure to decorate each Python file with the following line: #!/usr/bin/env python. This tells BBEdit that the file should be interpreted by Python. We'll mention this again, when we get to script-writing exericses.

The second thing is to be sure you set the “chdir to Script's Folder” option when you use the the run... item in the #! (“shebang”) menu. Without this, scripts are run in the root directory, not in the directory that contains your script file.

The print statement takes a list of values and, well, prints them. Speaking strictly, it does two things: it converts the objects to strings and puts the characters of those strings on standard output. Generally, standard output is the console window where Python was started, although there are ways to change this that are beyond the scope of this book.

Here's a quick summary of the more important features of print statement syntax. In short, the keyword, print, is followed by a comma-separated list of expressions.

One of the simplest kind of expressions is a quoted string. You can use either apostrophes (') or quotes (") to surround strings. This gives you some flexibility in your strings. You can put an apostrophe into a quoted string, and you can put quotes into an apostrophe'd string without the special escapes that some other languages require. The full set of quoting rules and alternatives, however, will have to wait for Chapter 12, Strings.

For example, the following trivial program prints three strings and two numbers.

print "Hi, Mom", "Isn't it lovely?", 'I said, "Hi".', 42, 91056

Multi-Line Output. Ordinarily, each print statement produces one line of output. You can end the print statement with a trailing , to combine the results of multiple print statements into a single line. Here are two examples.

print "335/113=",
print 335.0/113.0

print "Hi, Mom", "Isn't it lovely?", 
print 'I said, "Hi".', 42, 91056

Since the first print statement ends with a , it does not produce a complete line of output. The second print statement finishes the line of output.

Redirecting Output. The print statement's output goes to the operating system's standard output file. How do we send output to the system's standard error file? This involves some more advanced concepts, so we'll introduce it with a two-part recipe that we need to look at in more depth. We'll revisit these topics in Part IV, “Components, Modules and Packages”.

First, you'll need access to the standard error object; you get this via the following statement.

import sys

Second, there is an unusual piece of syntax called a "chevron print" which can be used to redirect output to standard error.

print >>file, [ expression, ]

The file can be either sys.stdout or sys.stderr. Here is an example of a small script which produces messages on both stderr and stdout.

#!/usr/bin/env python
"""Mixed output in stdout and stderr."""
import sys
print >>sys.stderr, "This is an error message"
print "This is stdout"
print >>sys.stdout, "This is also stdout"

When you run this inside IDLE, you'll notice that the stderr is colored red, where the stdout is colored black. You'll also notice that the order of the output in IDLE doesn't match the order in our program. Most POSIX operating systems buffer stdout, but does not buffer stderr. Consequently, stdout messages don't appear until the buffer is full, or the program exits.

A program produces a number of kinds of output. The print statement is a handy jumping-off point. Generally, we'll replace this with more advanced techiques.

The print statement is a very basic tool for debugging a complex Python program. Feel free to use print statements heavily to create a clear picture of what a program is actually doing. Ultimately, you are likely to replace print statements with other, more sophisticated methods.

Python Enhancement Proposal (PEP) 3105 suggests writing a print function which replaces the irregular print statement syntax with a regular function call. This function can then be altered in simple ways to produce more sophisticated output. We'll provide an example of this approach in the section called “Advanced Parameter Handling For Functions”.

Plain integers are at least 32 bits long. The range is at least -2,147,483,648 to 2,147,483,647 (approximately ±2 billion).

Python represents integers as strings of decimal digits. A number does not include any punctuation, and cannot begin with a leading zero (0). Leading zeros are used for base 8 and base 16 numbers. We'll look at this below.

>>> 255+100
355
>>> 397-42
355
>>> 71*5
355
>>> 355/113
3

While most features of Python correspond with common expectations from mathematics and other programming languages, the division operator, /, poses certain problems. Specifically, the distinction between the algorithm and the data representation need to be made explicit. Division can mean either exact floating-point results or integer results. Mathematicians have evolved a number of ways of describing precisely what they mean when discussing division. We need similar expressive power in Python.We'll look at more details of division operators in the section called “Division Operators”.

Octal and Hexadecimal. For historical reasons, Python supports programming in octal and hexadecimal. I like to think that the early days of computing were dominated by people with 8 or 16 fingers.

A number with a leading 0 (zero) is octal, base 8, and uses the digits 0 to 7. 0123 is octal and equal to 83 decimal.

A number with a leading 0x or 0X is hexadecimal, base 16, and uses the digits 0 through 9, plus a, A, b, B, c, C, d, D, e, E, f, and F. 0x2BC8 is hexadecimal and equal to 11208.

Hex, octal and long notations can be combined. 0x234C678D098BAL, for example is 620976988526778L.

Function Notation. The absolute value operation is done using a slightly different notation than the conventional mathematical operators like + and - that we saw above. It uses functional notation, sometimes called prefix notation. A mathematician would write |n|. Here's the formal Python definition:

This tells us that abs(x) has one parameter that must be a numeric value and it returns a numeric value. It won't work with strings or sequences or any of the other Python data types we'll cover in Chapter 11, Sequences: Strings, Tuples and Lists.

Here's an example using the abs(x) function.

>>> print abs(10-28/2)
4

The expression inside the parenthesis is evaluated first (yielding -4). Then the abs(x) function is applied to -4. This evaluates to 4.

One of the useful data types that Python offers are long integers. Unlike ordinary integers with a limited range, long integers have arbitrary length; they can have as many digits as necessary to represent an exact answer. However, these will operate more slowly than plain integers. Long integers end in L or l. Upper case L is preferred, since the lower-case l looks too much like the digit 1. Python is graceful about converting to long integers when it is necessary.

How many different combinations of 32 bits are there? The answer is there are different combinations of 32 on-off bits. When we try 2**32 in Python, the answer is too large for ordinary integers, and we get an anwer in long integers.

>>> print 2**32
4294967296L

There are about 4 billion ways to arrange 32 bits. How many bits in 1K of memory? 1024×8 bits. How many combinations of bits are possible in 1K of memory?

print 2L**(1024*8)

I won't attempt to reproduce the output from Python. It has 2,467 digits. There are a lot of different combinations of bits in only 1K of memory. The computer I'm using has 256×1024 K of memory; there are a lot of combinations of bits available in that memory.

Python will silently convert between ultra-fast integers and slow-but-large long integers. You can force a conversion using the int or long factory functions.

Python offers floating-point numbers, often implemented as "double-precision" numbers, typically using 64 bits. Floating-point numbers are based on scientific notation, where numbers are written as a mantissa and an exponent. Generally, powers of 10 are used with the exponent, giving us numbers that look like this: .

When we write a number that includes a decimal point, Python uses floating point representation. We can also use a form of scientific notation with an explicit mantissa and exponent. Here are some examples:

.0625
0.0625
6.25E-2
625E-4

The last example isn't properly normalized, since the mantissa isn't between 0 and 10.

Generally, a number, n, is some mantissa, g, and an exponent of c. For human consumption, we use a base of 10.

Equation 4.1. Scientific Notation

Internally, most computers use a base of 2, not 10. This leads to slight errors in converting certain values, which are exact in base 10, to approximations in base 2.

For example, 1/5th doesn't have a precise representation. This isn't generally a problem because we have string formatting operations which can make this tiny representation error invisible to users.

>>> 1./5
0.20000000000000001

Besides plain integers, long integers and floating point numbers, Python also provides for imaginary and complex numbers. These use the European convention of ending with J or j. People who don't use complex numbers should skip this section.

3.14J is an imaginary number = .

A complex number is created by adding a real and an imaginary number: 2 + 14j. Note that Python always prints these in ()'s; for example (2+14j).

The usual rules of complex math work perfectly with these numbers.

>>> print (2+3j)*(4+5j)
(-7+22j)

Python even includes the complex conjugate operation on a complex number. This operation follows the complex number separated by a dot (.). This notation is used because the conjugate is treated like a method function of a complex number object (we'll return to this method and object terminology in Chapter 21, Classes). For example:

>>> print 3+2j.conjugate()
(3-2j)

There are a number of conversions from one numeric type to another.

If this “complex (real, [imag] )” syntax synopsis is confusing, you might want to see Syntax For Newbies.

>>> complex( 2.0, 3.0 )
(2+3j)
>>> complex( 4.0 )
(4+0j)

float (x ) creates a floating point number equal to the string or number x. If a string is given, it must be a valid floating point number: digits, decimal point, and an exponent expression. Examples: float("6.02E24"), float(23). This is handy when doing division to prevent getting the simple integer quotient.

For example:

>>> print float(22)/7, 22/7
3.14285714286 3

int (x ) creates an integer equal to the string or number x. If a string is given, it must be a valid decimal integer string. Examples: int("1243"), int(3.14159).

long (x ) creates a long integer equal to the string or number x. If a string is given, it must be a valid decimal integer. The expression long(2) has the same value as the literal 2L. Examples: long(6.02E23), long(2).

For example:

>>> print long(2)**64
18446744073709551616

This shows the range of values possible with 64-bit integers, available on larger computers.

Complex is not as simple as the others. A complex number has two parts, real and imaginary. Conversion to complex typically involves two parameters.

complex (r, [i] ) creates a complex number with the real part of r; if the second parameter, i, is given, this is the imaginary part of the complex number, otherwise the imaginary part is zero. The string must be a valid complex number. Examples:

>>> print complex(3,2), complex(4), complex("3+4j")
(3+2j) (4+0j) (3+4j)

Note that the second parameter, with the imaginary part of the number, is optional. This leads to a number of different ways to call this function. In the example above, we used three variations: two numeric parameters, one numeric parameter and one string parameter.

The bulk of the math functions are in a separate module, called math, which we will cover in the section called “The math Module”. The formal definitions of mathematical built-in functions are provided below.

The round (number, [ndigits] ) function rounds a number to the nearest whole number. If the n parameter is given, this is the number of decimal places to round to. If n is positive, this is decimal places to the right of the decimal point. If n is negative, this is the number of places to the left of the decimal point. Examples: round(678.456,2) yields 678.46; round(678.456,-1) yields 680.

The cmp(x, y) function is handy for the comparisons used when sorting objects into order. For example, cmp(2,35) yields -1, telling us that the first value is less than the second value.

The string conversion functions provide alternate representations for numeric values. This list expands on the function definitions in the section called “Numeric Conversion Functions”.

The int function has two forms. The int (x) form converts a decimal string, x, to an integer. For example int('25') is 25. The int (x, b) form converts a string, x, in base b to an integer. For example int('010101',2) yields 21. int('321',4) is 57, int('2ac',16) is 684.

The str(x) and repr(x) functions convert any Python object to a string. The str(x) version is typically more readable, where the repr(x) version is an internalized representation. For most garden-variety numeric values, there is no difference. For the more complex data types, however, the resultsof repr and str can be very different. For classes you write (see Chapter 21, Classes), your class definition must provide these string representation functions.

These are two built-in functions which operate on a collection of data elements.

The max and min functions accept any number of values and return the largest or smallest of the values. max(1,2,3) yields 3, min(1,2,3) yields 1.

We create and change variables primarily with the assignment statement. This statement provides an expression and a variable name which will be used to label the value of the expression.

Here's a short script that contains some examples of assignment statements.

#!/usr/bin/env python
# Computer the value of a block of stock
shares= 150
price= 3 + 5.0/8.0
value= shares * price
print value

We have an object, the number 150, which we assign to the variable shares. We have an expression 3+5.0/8.0, which creates a floating-point number, which we save in the variable price. We have another expression, shares * price, which creates a floating-point number; we save this in value so that we can print it. This script created three new variables.

Since this file is new, we'll need to do the chmod +x example3.py once, after we create this file. Then, when we run this progam, we see the following.

$ ./example3.py
543.75
$ 

Any of the usual arithmetic operations can be combined with assignment to create an augmented assignment statement.

For example, look at this augmented assignment statement:

a += v

This statement is a shorthand that means the same thing as the following:

a = a + v

Here's a larger example

#!/usr/bin/env python
# Total value of a portfolio made up of two blocks of stock
portfolio = 0
portfolio += 150 * 2 + 1/4.0
portfolio += 75 * 1 + 7/8.0
print portfolio

First, we'll do the chmod +x portfolio.py on this file. Then, when we run this progam, we see the following.

$ ./portfolio.py
376.125
$ 

The other basic math operations can be used similarly, although the purpose gets obscure for some operations. These include -=, *=, /=, %=, &=, ^=, |=, <<= and >>=.

Here's a lengthy example. This is an extension of Craps Odds in the section called “Numeric Types and Expressions”.

In craps, the first roll of the dice is called the “come out roll”. This roll can be won immediately if one rolls 7 or 11. It can be lost immediately if one roll 2, 3 or 12. The remaining numbers establish a point and the game continues.

#!/usr/bin/env python
# Compute the odds of winning on the first roll
win = 0
win += 6/36.0 # ways to roll a 7
win += 2/36.0 # ways to roll an 11
print "first roll win", win

# Compute the odds of losing on the first roll
lose = 0
lose += 1/36.0 # ways to roll 2
lose += 2/36.0 # ways to roll 3
lose += 1/36.0 # ways to roll 12
print "first roll lose", lose

# Compute the odds of rolling a point number (4, 5, 6, 8, 9 or 10)
point = 1 # odds must total to 1
point -= win # remove odds of winning
point -= lose # remove odds of losting
print "first roll establishes a point", point

There's a 22.2% chance of winning, and a 11.1% chance of losing. What's the chance of establishing a point? One way is to figure that it's what's left after winning or loosing. The total of all probabilities always add to 1. Subtract the odds of winning and the odds of losing and what's left is the odds of setting a point.

Here's another way to figure the odds of rolling 4, 5, 6, 8, 9 or 10.

point = 0
point += 2*3/36.0 # ways to roll 4 or 10
point += 2*4/36.0 # ways to roll 5 or 9
point += 2*5/36.0 # ways to roll 6 or 8
print point

By the way, you can add the statement print win + lose + point to confirm that these odds all add to 1. This means that we have defined all possible outcomes for the come out roll in craps.

As with many things Python, there is some additional subtlety to this, but we'll cover those topics later. For example, multiple-assignment statement is something we'll look into in more deeply in Chapter 13, Tuples.

The first way to get interactive input is the raw_input([prompt]) function. This function accepts a string parameter, which is the user's prompt, written to standard output. The next line available on standard input is returned as the value of the function.

The raw_input([prompt]) function reads from a file often called stdin. When running from the command-line, this will be the keyboard, and what you type will be echoed in the command window or Terminal window. If you try, however, to run these examples from Textpad, you'll see that Textpad doesn't have any place for you to type any input. In BBEdit, you'll need to use the Run In Terminal item in the #! menu.

Here's an example script that uses raw_input([prompt]).

#!/usr/bin/env python
# show how raw_input works
a= raw_input( "yes?" )
print a

When we run this script from the shell prompt, it looks like the following.

MacBook-3:Examples slott$ python rawdemo.py
yes?why not?
why not?
$ 

This program begins by evaluating the raw_input function. When raw_input is applied to the parameter of "yes?", it writes the prompt on standard output, and waits for a line of input. We entered why not?. Once that line was complete, the input string is returned as the value of the function.

The raw_input function's value was assigned to the variable a. The second statement printed that variable.

If we want numeric input, we must convert the resulting string to a number.

#!/usr/bin/env python
# Compute the value of a block of stock
shares = int( raw_input("shares: ") )
price = float( raw_input("dollars: ") )
price += float( raw_input("eights: ") )/8.0
print "value", shares * price

We'll chmod +x stock.py this program; then we can run it as many times as we like to get results.

MacBook-3:Examples slott$ ./stock.py
shares: 150
dollars: 24
eights: 3
value 3656.25
$ 

The raw_input mechanism is very limited. If the string returned by raw_input is not suitable for use by int, an exception is raised and the program stops running. We'll cover exception handling in detail in Chapter 17, Exceptions.

Here's what it looks like.

MacBook-3:Examples slott$ ./stock.py
shares: a bunch


Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "stock.py", line 3, in ?
    shares = int( raw_input("shares: ") )
ValueError: invalid literal for int(): a bunch


MacBook-3:Examples slott$ 

In addition to the raw_input function, which returns the exact string of characters, there is the input([prompt]) function. This also accepts an optional parameter, which is the prompt. It writes the prompt, then reads a line of input. It then applies the Python eval(string) function to evaluate the input. Typically, we expect to decode a string of digits as an integer or floating point number. Actually, it will evaluate any legal Python expression! Of course, illegal expressions will raise an exception and the program will stop running.

The value of the input (p ) function is eval( raw_input(p) ). Here's an example:

#!/usr/bin/env python
shares = input('shares: ')
print shares

When we chmod +x inputdemo.py and run this program, we see the following.

$ ./inputdemo.py
shares: 2+1/2.0
2.5
$ 

In this case, the input function evaluated the expression 2+1/2.0.

The input function is an unreliable tool. For yourself, the author of the program, problems with input are easily solved. For someone else, the vagaries of what is legal and how Python responds to things that are not legal can be frustrating. In Chapter 17, Exceptions, we'll add some sophistication that will solve some of these problems.

Refer back to the exercises in the section called “Numeric Types and Expressions” for formulas and other details. Each of these can be rewritten to use variables and an input conversion. For example, if you want to tackle the Fahrenheit to Celsius problem, you might write something like this:

C = input('Celsius: ')
F = 32+C*float(9/5)
print "celsius",C,"fahrenheit",F

Python represents truth and falsity in a variety of ways.

We try to avoid depending on relatively obscure rules for determining True vs. False. We prefer to use the two explicit keywords, True and False. Note that a previous version of Python didn't have the boolean literals, and some older open-source programs will define these values.

Python provides a factory function to collapse these various forms of truth into one of the two explicit boolean objects.

Python provides three basic logic operators that work on this Boolean domain. Note that this Boolean domain, with just two values, True and False, and these three operators form a complete algebraic system, sometimes called Boolean algebra, after the mathemetician George Boole. The operators supported by Python are not, and and or. We can fully define these operators with rule statements or truth tables.

This truth table shows the evaluation of not x for both vales of x.

print "x", "not x"
print True, not True
print False, not False

This table shows the evaluation of x and y for all combination of True and False.

print "x", "y", "x and y"
print True, True, True and True
print True, False, True and False
print False, True, False and True
print False, False, False and False

An important feature of and is that it does not evaluate all of its parameters before it is applied. If the left-hand side is False or one of the equivalent values, the right-hand side is not evaluated, and the left-hand value is returned. We'll look at some examples of this later.

For now, you can try things like the following.

print False and 23
print 23 and False

This will show you that the first false value is what Python returns for and.

This table shows the evaluation of x or y for all combination of True and False.

Parallel with the and operator, or does not evaluate the right-hand parameter if the left-hand side is True or one of the equivalent values.

As a final note, and is a high priority operator (analogous to multiplication) and or is lower priority (analogous to addition). When evaluating expressions like a or b and c, the and operation is evaluated first, followed by the or operation.

We compare values with the comparison operators. These correspond to the mathematical functions of <, ≤, >, ≥, = and ≠. Conditional expressions are often built using the Python comparison operators: <, <=, >, >=, == and != for less than, less than or equal to, greater than, greater than or equal to, equal to and not equal to.

>>> p1=22./7.
>>> p2=355/113.
>>> p1
3.1428571428571428
>>> p2
3.1415929203539825
>>> p1 < p2
False
>>> p1 >= p2
True

When applying a comparison operator, we see a number of steps.

We call out these three steps explicitly because there are some subtleties in comparison among unlike types of data; we'll come to this later when we cover sequences, mappings and classes in Part II, “Data Structures”. Generally, it doesn't make sense to compare unlike types of data. After all, you can't ask "Which is larger, the Empire State Building or the color green?"

Comparisons can be combined in Python, unlike most other programming languages. We can ask: 0 <= a < 6 which has the usual mathematical meaning. We're not forced to use the longer form: 0 <= a and a < 6 .

>>> 3 < p1 < 3.2
True
>>> 3 < p1 and p1 < 3.2
True

This is useful when a is actually some complex expression that we'd rather not repeat.

Also note that the preceding example had a mixture of integers and floating-point numbers. The integers were coerced to floating-point in order to evaluate the expressions.

We can combine the logic operators, comparisons and math. This allows us to use comparisons and logic to prevent common mathematical blunders like attempting to divide by zero, or attempting to take the square root of a negative number.

For example, let's start with this program that will figure the average of 95, 125 and 132.

sum = 95 + 125 + 132
count = 3
average = float(sum)/count
print average

Initially, we set the variables sum and count. Then we compute the average using sum and count.

Assume that the statement that computes the average (average=...), is part of a long and complex program. Sometimes that long program will try to compute the average of no numbers at all. This has the same effect as the following short example.

sum, count = 0, 0
average = float(sum)/count
print average

In the rare case that we have no numbers to average we don't want to crash when we foolishly attempt to divide by zero. We'd prefer to have some more graceful behavior.

Recall from the section called “Truth and Logic” that the and operator doesn't evaluate the right-hand side unless the left-hand side is True. Stated the other way, the and operator only evaluates the right side if the left side is True. We can guard the division like this:

average = count != 0 and sum/count
print average

This is an example that can simplify certain kinds of complex processing. If the count is non-zero, the left side is true and the right side must be checked. If the count is zero, the left side is False, the result of the complete and operation is False.

This is a consequence of the meaning of the word and. The expression a and b means that a is true as well as b is true. If a is false, the value of b doesn't really matter, since the whole expression is clearly false. A similar analysis holds for the word or. The expression a or b means that one of the two is true; it also means that neither of the two is false. If a is true, then the value of b doesn't change the truth of the whole expression.

The statement “It's cold and rainy” is completely false when it is warm; rain doesn't matter to falsifying the whole statement. Similarly, “I'm stopping for coffee or a newspaper” is true if I've stopped for coffee, irrespective of whether or not I stop for a newspaper.

Exact equality between floating-point numbers is a dangerous concept. After a lengthy computation, round-off errors in floating point numbers may have infinitesimally small differences. The answers are close enough to equal for all practical purposes, but every single one of the 64 bits may not be identical.

The following technique is the appropriate way to do floating point comparisons.

abs(a-b)<0.0001

Rather than ask if the two floating point values are the same, we ask if they're close enough to be considered the same. For example, run the following tiny program.

#!/usr/bin/env python
# Are two floating point values really completely equal?
a,b = 1/3.0, .1/.3
print a,b,a==b
print abs(a-b)<0.00001

When we run this program, we get the following output

$ python floatequal.py
0.333333333333 0.333333333333 False
True
$ 

The two values appear the same when printed. Yet, on most platforms, the == test returns False. They are not precisely the same. This is a consequence of representing real numbers with only a finite amount of binary precision. Certain repeating decimals get truncated, and these truncation errors accumulate in our calculations.

There are ways to avoid this problem; one part of this avoidance is to do the algebra necessary to postpone doing division operations. Division introduces the largest number erroneous bits onto the trailing edge of our numbers. The other part of avoiding the problem is never to compare floating point numbers for exact equality.

The basic form of an if statement provides a condition and a suite of statements that are executed when the condition is true. It looks like this:

The suite is an indented block of statements. Any statement is allowed in the block, including indented if statements. You can use either tabs or spaces for indentation. The usual style is four spaces.

This is our first compound statement. See Python Syntax Rules for some additional guidance on syntax for compound statements.

The if statement evaluates the condition expression first. When the result is True, the suite of statements is executed. Otherwise the suite is skipped.

For example, if two dice show a total of 7 or 11, the throw is a winner.

d1 and d2 are two dice

if d1+d2 == 7 or d1+d2 == 11:
    print "winner", d1+d2

Here we have a typically complex expression. The or operator evaluates the left side first. Python evaluates and applies the high-precendence arithmetic operator before the lower-precendence comparison operator. If the left side is true (d1+d2 is 7), the or expression is true, and the suite is executed. If the left side is false, then the right side is evaluated. If it is true (d1+d2 is 11), the or expression is true, and the suite is executed. Otherwise, the suite is skipped.

a=0
if␣a=0:
␣␣␣␣print␣"a␣is␣zero"
else:
␣␣␣␣print␣"a␣is␣not␣zero"

if␣a%2=0:
⊢print␣"a␣is␣even"
else:
⊢print␣"a␣is␣odd"

Often there are several conditions that need to be handled. This is done by adding elif clauses. This is short for “else-if”. We can add an unlimited number of elif clauses. The elif clause has almost the same syntax as the if clause.

Here is a somewhat more complete rule for the come out roll in a game of craps:

result= None
if d1+d2 == 7 or d1+d2 == 11:
    result= "winner"
elif d1+d2 == 2 or d1+d2 == 3 or d1+d2 == 12:
    result= "loser"
print result

First, we checked the condition for winning; if the first condition is true, the first suite is executed and the entire if statement is complete. If the first condition is false, then the second condition is tested. If that condition is true, the second suite is executed, and the entire if statement is complete. If neither condition is true, the if statement has no effect.

Python also gives us the capability to put a “catch-all” suite at the end for all other conditions. This is done by adding an else clause. The else clause has the following syntax.

Here's the complete come-out roll rule, assuming two values d1 and d2.

point= None
if d1+d2 == 7 or d1+d2 == 11:
    print "winner"
elif d1+d2 == 2 or d1+d2 == 3 or d1+d2 == 12:
    print "loser"
else:
    point= d1+d2
    print  "point is", point

Here, we use the else: suite to handle all of the other possible rolls. There are six different values (4, 5, 6, 8, 9, or 10), a tedious typing exercise if done using or. We summarize this with the else: clause.

While handy in one respect, this else: clause is also dangerous. By not explicitly stating the condition, it is possible to overlook simple logic errors.

Consider the following complete if statement that checks for a winner on a field bet. A field bet wins on 2, 3, 4, 9, 10, 11 or 12. The payout odds are different on 2 and 12.

outcome= 0
if d1+d2 == 2 or d1+d2 == 12:
    outcome= 2
    print "field pays 2:1"
elif d1+d2==4 or d1+d2==9 or d1+d2==10 or d1+d2==11:
    outcome= 1
    print "field pays even money"
else:
    outcome= -1
    print "field loses"

Here we test for 2 and 12 in the first clause; we test for 4, 9, 10 and 11 in the second. It's not obvious that a roll of 3 is missing from the even money pay out. This fragment incorrectly treats 3, 5, 6, 7 and 8 alike in the else:. While the else: clause is used commonly as a catch-all, a more proper use for else: is to raise an exception because a condition was not matched by any of the if or elif clauses.