GNU Info

(python2.1-ref.info)Indentation

---

Next: Whitespace between tokens Prev: Blank lines blank line
Up: Line structure

---

Enter node , (file) or (file)node

Indentation
-----------

Leading whitespace (spaces and tabs) at the beginning of a logical line
is used to compute the indentation level of the line, which in turn is
used to determine the grouping of statements.

First, tabs are replaced (from left to right) by one to eight spaces
such that the total number of characters up to and including the
replacement is a multiple of eight (this is intended to be the same
rule as used by UNIX).  The total number of spaces preceding the first
non-blank character then determines the line's indentation.
Indentation cannot be split over multiple physical lines using
backslashes; the whitespace up to the first backslash determines the
indentation.

*Cross-platform compatibility note:* because of the nature of text
editors on non-UNIX platforms, it is unwise to use a mixture of spaces
and tabs for the indentation in a single source file.

A formfeed character may be present at the start of the line; it will
be ignored for the indentation calculations above.  Formfeed characters
occurring elsewhere in the leading whitespace have an undefined effect
(for instance, they may reset the space count to zero).

The indentation levels of consecutive lines are used to generate INDENT
and DEDENT tokens, using a stack, as follows.

Before the first line of the file is read, a single zero is pushed on
the stack; this will never be popped off again.  The numbers pushed on
the stack will always be strictly increasing from bottom to top.  At
the beginning of each logical line, the line's indentation level is
compared to the top of the stack.  If it is equal, nothing happens.  If
it is larger, it is pushed on the stack, and one INDENT token is
generated.  If it is smaller, it _must_ be one of the numbers occurring
on the stack; all numbers on the stack that are larger are popped off,
and for each number popped off a DEDENT token is generated.  At the end
of the file, a DEDENT token is generated for each number remaining on
the stack that is larger than zero.

Here is an example of a correctly (though confusingly) indented piece
of Python code:

     def perm(l):
             # Compute the list of all permutations of l
         if len(l) <= 1:
                       return [l]
         r = []
         for i in range(len(l)):
                  s = l[:i] + l[i+1:]
                  p = perm(s)
                  for x in p:
                   r.append(l[i:i+1] + x)
         return r

The following example shows various indentation errors:

          def perm(l):                       # error: first line indented
         for i in range(len(l)):             # error: not indented
             s = l[:i] + l[i+1:]
                 p = perm(l[:i] + l[i+1:])   # error: unexpected indent
                 for x in p:
                         r.append(l[i:i+1] + x)
                     return r                # error: inconsistent dedent

(Actually, the first three errors are detected by the parser; only the
last error is found by the lexical analyzer -- the indentation of
`return r' does not match a level popped off the stack.)