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.

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

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: