Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Programming
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Databases
Mail Systems
openSolaris
Eclipse Documentation
Techotopia.com
Virtuatopia.com

How To Guides
Virtualization
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Windows
Problem Solutions
Privacy Policy

  




 

 

9.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 Library Reference 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 lay-out 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, or just write the value between reverse quotes (", equivalent to repr()).

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.'
    >>> `s`
    "'Hello, world.'"
    >>> str(0.1)
    '0.1'
    >>> `0.1`
    '0.10000000000000001'
    >>> x = 10 * 3.25
    >>> y = 200 * 200
    >>> s = 'The value of x is ' + `x` + ', and y is ' + `y`
    >>> print s
    The value of x is 32.5, and y is 40000
    >>> # Reverse quotes work on other types besides numbers:
    ... p = [x, y]
    >>> ps = repr(p)
    >>> ps
    '[32.5, 40000]'
    >>> # Converting a string adds quotes and backslashes:
    ... hello = 'hello, world\n'
    >>> hellos = `hello`
    >>> print hellos
    'hello, world\n'
    >>> # The argument of reverse quotes may be a tuple:
    ... `x, y, ('spam', 'eggs')`
    "(32.5, 40000, ('spam', 'eggs'))"

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

    >>> import string
    >>> for x in range(1, 11):
    ...     print string.rjust(`x`, 2), 
    ...     print string.rjust(`x*x`, 3),
    ...     # Note trailing comma on previous lines
    ...     print string.rjust(`x*x*x`, 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 function string.rjust(), which right-justifies a string in a field of a given width by padding it with spaces on the left. There are similar functions string.ljust() and string.center(). These functions 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 ‘string.ljust(x,n)[0:n]’.)

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

    >>> import string
    >>> string.zfill('12', 5)
    '00012'
    >>> string.zfill('-3.14', 7)
    '-003.14'
    >>> string.zfill('3.14159265359', 5)
    '3.14159265359'

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.


 
 
  Published under the terms of the Python License Design by Interspire