- publishing free software manuals
An Introduction to Python
by Guido van Rossum and Fred L. Drake, Jr.
Paperback (6"x9"), 124 pages
ISBN 0954161769
RRP £12.95 ($19.95)

Sales of this book support the Python Software Foundation! Get a printed copy>>>

7.1 Fancier Output Formatting

So far we've encountered two ways of writing values: expression statements and the print statement. (A third way is using the write() method of file objects; the standard output file can be referenced as sys.stdout. See the Python Library Reference Manual for more information on this.)

Often you'll want more control over the formatting of your output than simply printing space-separated values. There are two ways to format your output; the first way is to do all the string handling yourself; using string slicing and concatenation operations you can create any layout you can imagine. The standard module ‘string’ contains some useful operations for padding strings to a given column width; these will be discussed shortly. The second way is to use the % operator with a string as the left argument. The % operator interprets the left argument much like a sprintf()-style format string to be applied to the right argument, and returns the string resulting from this formatting operation.

One question remains, of course: how do you convert values to strings? Luckily, Python has ways to convert any value to a string: pass it to the repr() or str() functions. Reverse quotes (") are equivalent to repr(), but they are no longer used in modern Python code and will likely not be in future versions of the language.

The str() function is meant to return representations of values which are fairly human-readable, while repr() is meant to generate representations which can be read by the interpreter (or will force a SyntaxError if there is not equivalent syntax). For objects which don't have a particular representation for human consumption, str() will return the same value as repr(). Many values, such as numbers or structures like lists and dictionaries, have the same representation using either function. Strings and floating point numbers, in particular, have two distinct representations.

Some examples:

    >>> s = 'Hello, world.'
    >>> str(s)
    'Hello, world.'
    >>> repr(s)
    "'Hello, world.'"
    >>> str(0.1)
    >>> repr(0.1)
    >>> x = 10 * 3.25
    >>> y = 200 * 200
    >>> s = 'The value of x is ' + repr(x) + ', and y is '
         + repr(y)
    >>> print s
    The value of x is 32.5, and y is 40000
    >>> # The repr() of a string adds quotes and backslashes:
    ... hello = 'hello, world\n'
    >>> hellos = repr(hello)
    >>> print hellos
    'hello, world\n'
    >>> # The argument to repr() may be any Python object:
    ... repr((x, y, ('spam', 'eggs')))
    "(32.5, 40000, ('spam', 'eggs'))"
    >>> # reverse quotes are convenient in interactive
    ... `x, y, ('spam', 'eggs')`
    "(32.5, 40000, ('spam', 'eggs'))"

Here are two ways to write a table of squares and cubes:

    >>> for x in range(1, 11):
    ...     print repr(x).rjust(2),
    ...     print repr(x*x).rjust(3),
    ...     # Note trailing comma on previous lines
    ...     print repr(x*x*x).rjust(4)
     1   1    1
     2   4    8
     3   9   27
     4  16   64
     5  25  125
     6  36  216
     7  49  343
     8  64  512
     9  81  729
    10 100 1000
    >>> for x in range(1,11):
    ...     print '%2d %3d %4d' % (x, x*x, x*x*x)
     1   1    1
     2   4    8
     3   9   27
     4  16   64
     5  25  125
     6  36  216
     7  49  343
     8  64  512
     9  81  729
    10 100 1000

(Note that one space between each column was added by the way print works: it always adds spaces between its arguments.)

This example demonstrates the rjust() method of string objects, which right-justifies a string in a field of a given width by padding it with spaces on the left. There are similar methods ljust() and center(). These methods do not write anything, they just return a new string. If the input string is too long, they don't truncate it, but return it unchanged; this will mess up your column lay-out but that's usually better than the alternative, which would be lying about a value. (If you really want truncation you can always add a slice operation, as in ‘x.ljust(n)[:n]’.)

There is another method, zfill(), which pads a numeric string on the left with zeros. It understands about plus and minus signs:

    >>> '12'.zfill(5)
    >>> '-3.14'.zfill(7)
    >>> '3.14159265359'.zfill(5)

Using the % operator looks like this:

    >>> import math
    >>> print 'PI is approximately %5.3f.' % math.pi
    PI is approximately 3.142.

If there is more than one format in the string, you need to pass a tuple as right operand, as in this example:

    >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
    >>> for name, phone in table.items():
    ...     print '%-10s ==> %10d' % (name, phone)
    Jack       ==>       4098
    Dcab       ==>       7678
    Sjoerd     ==>       4127

Most formats work exactly as in C and require that you pass the proper type; however, if you don't you get an exception, not a core dump. The %s format is more relaxed: if the corresponding argument is not a string object, it is converted to a string using the str() built-in function. Using * to pass the width or precision in as a separate (integer) argument is supported. The C formats %n and %p are not supported.

If you have a really long format string that you don't want to split up, it would be nice if you could reference the variables to be formatted by name instead of by position. This can be done by using the form %(name)format, as shown here:

    >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
    >>> print '%(Jack)d; %(Sjoerd)d; %(Dcab)d' % table
    4098; 4127; 7678

This is particularly useful in combination with the new built-in vars() function, which returns a dictionary containing all local variables.

ISBN 0954161769An Introduction to PythonSee the print edition