The Python if statement is typical of most procedural languages. It takes the form of an if test, followed by one or more optional elif tests (meaning “else if”), and ends with an optional else block. Each test and the else have an associated block of nested statements indented under a header line. When the statement runs, Python executes the block of code associated with the first test that evaluates to true, or the else block if all tests prove false. The general form of an if looks like this:

if <test1>:               # if test 
    <statements1>         # Associated block
elif <test2>:             # Optional elifs 
    <statements2>
else:                     # Optional else
    <statements3>

Let’s look at a few simple examples of the if statement at work. All parts are optional except the initial if test and its associated statements; in the simplest case, the other parts are omitted:

>>> if 1:
...     print 'true'
...
true

Notice how the prompt changes to " . . . " for continuation lines in the basic interface used here (in IDLE, you’ll simply drop down to an indented line instead—hit Backspace to back up); a blank line terminates and runs the entire statement. Remember that 1 is Boolean true, so this statement’s test always succeeds; to handle a false result, code the else:

                  >>> if not 1:
                  ...     print 'true'
                  ... else:
                  ...     print 'false'
                  ...
                  false

Now, here’s an example of the most complex kind of if statement—with all its optional parts present:

>>> x = 'killer rabbit'
>>> if x == 'roger':
...     print "how's jessica?"
... elif x == 'bugs':
...     print "what's up doc?"
... else:
...     print 'Run away! Run away!'
...
Run away! Run away!

This multiline statement extends from the if line, through the else block. When run, Python executes the statements nested under the first test that is true, or the else part if all tests are false (in this example, they are). In practice, both the elif and else parts may be omitted, and there may be more than one statement nested in each section. Moreover, the words if, elif, and else are associated by the fact that they line up vertically, with the same indentation.

>>> choice = 'ham'
>>> print {'spam':  1.25,         # A dictionary-based 'switch'
...        'ham':   1.99,         # Use has_key(  ) or get(  ) for default.
...        'eggs':  0.99,
...        'bacon': 1.10}[choice]
1.99

>>> if choice == 'spam':
...     print 1.25
... elif choice == 'ham':
...     print 1.99
... elif choice == 'eggs':
...     print 0.99
... elif choice == 'bacon':
...     print 1.10
... else:
...     print 'Bad choice'
...
1.99

>>> branch = {'spam': 1.25,
...           'ham':  1.99,
...           'eggs': 0.99}

>>> print branch.get('spam', 'Bad choice')
1.25
>>> print branch.get('bacon', 'Bad choice')
Bad choice

Python detects block boundaries automatically, by line indentation— the empty space to the left of your code. All statements indented the same distance to the right belong to the same block of code. In other words, the statements within a block line up vertically. The block ends at a line less indented or the end of the file, and more deeply nested blocks are simply indented further to the right than the statements in the enclosing block.

For instance, Figure 9-1 demonstrates the block structure of the following code:

x = 1
if x:
    y = 2
    if y:
        print 'block2'
    print 'block1'
print 'block0'

Figure 9-1. Nested code blocks

This code contains three blocks: the first (the top-level of the file) is not indented at all; the second (within the outer if statement) is indented four spaces; and the third (the print statement under the nested if) is indented eight spaces.

In general, top-level (unnested) code must start in column 1. Nested blocks can start in any column; indentation may consist of any number of spaces and tabs, as long as it’s the same for all the statements in a given block. That is, Python doesn’t care how you indent your code; it only cares that it’s done consistently. Technically, tabs count for enough spaces to move the current column number up to a multiple of 8, but it’s usually not a good idea to mix tabs and spaces within a block—use one or the other.

Indentation to the left of your code is the only major place in Python where whitespace matters; in most other contexts, space can be coded or not. However, indentation is really part of Python syntax, not just a stylistic suggestion: all the statements within any given single block must be indented the same, or Python reports a syntax error. This is on purpose—because you don’t need to explicitly mark the start and end of a nested block of code, it removes some of the syntactic clutter found in other languages.

This syntax model also enforces indentation consistency, a crucial component of readability in structured programming languages like Python. Python’s syntax is sometimes called the “what you see is what you get” of languages—the indentation of code unambiguously tells readers what it is associated with. Python’s consistent appearance makes code easier to maintain.

Consistently-indented code always satisfies Python’s rules. Moreover, most text editors (including IDLE) make it easy to follow Python’s indentation model, by automatically indenting code as you type it.

Statements normally end at the end of the line they appear on. This covers the vast majority of the Python statements you’ll code. When statements are too long to fit on a single line, though, a few special rules may be used to make them span multiple continuation lines:

Here’s what a continuation line looks like, using the open pairs rule; we can span delimited constructs across any number of lines:

L = ["Good", 
     "Bad", 
     "Ugly"]                    # Open pairs may span lines.

This works for anything in parentheses too: expressions, function arguments, functions headers (see Chapter 12), and so on. If you like using backslashes to continue you can, but it’s not usually necessary:

if a == b and c == d and   
   d == e and f == g:
   print 'olde'                  # Backslashes allow continuations.

Because any expression can be enclosed in parenthesis, you can usually simply wrap something in parenthesis anytime you need to span multiple lines:

if (a == b and c == d and
    d == e and e == f):
    print 'new'                  # But parentheses usually do too.

As a special case, Python allows you to write more than one non-compound statement (i.e., statements without nested statements) on the same line, separated by semicolons. Some coders use this form to save program file real estate, but it usually makes for more readable code if you stick to one statement per line for most of your work:

x = 1; y = 2; print x            # More than one simple statement

And finally, Python lets you move a compound statement’s body up to the header line, provided the body is just a simple (non-compound) statement. You’ll see this most often used for simple if statements with a single test and action:

if 1: print 'hello'              # Simple statement on header line

You can combine some of these special cases to write code that is difficult to read, but we don’t recommend it; as a rule of thumb, try to keep each statement on a line of its own, and indent all except the simplest of blocks. Six months down the road, you’ll be happy you did.