Python输入输出

There are several ways to present the output of a program; data can be printed in a human-readable form, or written to a file for future use. This chapter will discuss some of the possibilities.

这里有几种程序输出的展现方式;数据能够打印成人类可读的形式，或者被写入到文件中。这节我们将讨论这几个问题。

7.1. Fancier Output Formatting

So far we’ve encountered two ways of writing values: expression statements and the print() function. (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.)

到目前为止，我们遇到了两种写值的方式：表达式语句和print()函数。(第三种方式是使用文件对象的write()方法;标准输出文件可以使用sys.stdout.可以参考Python库参考手册)

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 string type has some methods that perform useful operations for padding strings to a given column width; these will be discussed shortly. The second way is to use the str.format() method.

通常，你希望更多的控制输出的格式而不是简单的打印结果。有两种方式可以格式化你的输出，第一种方式是你自己处理所有的字符串，使用字符串的切片和连接操作你可以创造你希望的布局格式。字符串类型有很多方法来执行有用的操作，可以在给定的列宽度填充字符串，这些我们将会简短的讨论。第二种方式是使用str.format()方法。

The string module contains a Template class which offers yet another way to substitute values into strings.

string模块包含了一个Template类，该类提供了另一种方式替换值到字符串中。

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.

还有一个问题，当然：怎么将值转换为字符串类型？幸运的是，Python有种方式可以将任何值转换为字符串：将该值传递个repr()或者str()方法。

 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 no 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, in particular, have two distinct representations.

str()函数返回的字符串的值以更人性化的可读方式呈现，然而repr()函数是以解释器可读的形式呈现出来。对于许多值，其实str()和repr()函数的返回结果是相同的，例如数值或者列表，字典之类的结构。在特殊的情况下，字符串呈现的结果可能有差别，例如：

>>> s = ‘Hello, world.‘
>>> str(s)
‘Hello, world.‘
>>> repr(s)
"‘Hello, world.‘"
>>> str(1/7)
‘0.14285714285714285‘
>>> 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 string 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‘))"

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

下面的例子描述了写一个求正方形面积和体积的表格的两种方式：

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=‘ ‘)
...     # Note use of ‘end‘ on previous line
...     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(‘{0:2d} {1:3d} {2:4d}‘.format(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 in the first example, one space between each column was added by the way print() works: it always adds spaces between its arguments.)

(注意，在第一个例子中，每列中间会增加一个空格，这个空格是print()函数自动增加的:print()函数默认就是在它的参数之间加一个空格)

This example demonstrates the str.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 str.ljust() and str.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].)

这个例子中表明字符串方法rjust()，它的功能是指定给定的宽度右对齐字符串，如果长度不够，则填充空格。这里也有相似的方法，例如：str.ljust()和str.center()。这些方法仅仅是返回一个格式化后的字符串。如果字符串太长，方法并不会截断字符串，而是直接返回该字符串，这可能会搅乱你的列对齐的方式，但通常是比较合适的方式相对于截断来说。

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

这里有另一个方法str.zfill()。它会用0来填充数值字符串。而且可以自动识别加减号：

>>> ‘12‘.zfill(5)
‘00012‘
>>> ‘-3.14‘.zfill(7)
‘-003.14‘
>>> ‘3.14159265359‘.zfill(5)
‘3.14159265359‘

Basic usage of the str.format() method looks like this:

str.format()最基本的使用如下：

>>> print(‘We are the {} who say "{}!"‘.format(‘knights‘, ‘Ni‘))
We are the knights who say "Ni!"

 The brackets and characters within them (called format fields) are replaced with the objects passed into the str.format() method. A number in the brackets can be used to refer to the position of the object passed into the str.format() method.

大括号中的内容会被format指定的列表依次替代。也可以在{}中指定format参数中的位置：

>>> print(‘{0} and {1}‘.format(‘spam‘, ‘eggs‘))
spam and eggs
>>> print(‘{1} and {0}‘.format(‘spam‘, ‘eggs‘))
eggs and spam

If keyword arguments are used in the str.format() method, their values are referred to by using the name of the argument.

如果在str.format()函数中使用关键字参数，那么{}中必须指定参数的名字：

>>> print(‘This {food} is {adjective}.‘.format(
...       food=‘spam‘, adjective=‘absolutely horrible‘))
This spam is absolutely horrible.

Positional and keyword arguments can be arbitrarily combined:

位置传参合关键字参数能够任意组合：

>>> print(‘The story of {0}, {1}, and {other}.‘.format(‘Bill‘, ‘Manfred‘,
                                                       other=‘Georg‘))
The story of Bill, Manfred, and Georg.

 ‘!a‘ (apply ascii()), ‘!s‘ (apply str()) and ‘!r‘ (apply repr()) can be used to convert the value before it is formatted:

‘!a‘(相当于ascii()),‘!s‘(相当于str())‘!r‘(相当于repr())可以在格式化之前转换值的输出形式：

>>> import math
>>> print(‘The value of PI is approximately {}.‘.format(math.pi))
The value of PI is approximately 3.14159265359.
>>> print(‘The value of PI is approximately {!r}.‘.format(math.pi))
The value of PI is approximately 3.141592653589793.

An optional ‘:‘ and format specifier can follow the field name. This allows greater control over how the value is formatted. The following example rounds Pi to three places after the decimal.

一个冒号和指定的格式可以紧跟在字段名后(下面例子中的0就是代表字段名)。这极大的控制了值的格式化输出。下面这个例子格式化的输出PI：

>>> import math
>>> print(‘The value of PI is approximately {0:.3f}.‘.format(math.pi))
The value of PI is approximately 3.142.

Passing an integer after the ‘:‘ will cause that field to be a minimum number of characters wide. This is useful for making tables pretty.

在冒号的后面传递一个数值指明这个列的最小字符宽度是多少。下面这个例子显示了非常漂亮的表格：

>>> table = {‘Sjoerd‘: 4127, ‘Jack‘: 4098, ‘Dcab‘: 7678}
>>> for name, phone in table.items():
...     print(‘{0:10} ==> {1:10d}‘.format(name, phone))
...
Jack       ==>       4098
Dcab       ==>       7678
Sjoerd     ==>       4127

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 simply passing the dict and using square brackets ‘[]‘ to access the keys

如果你想要一个很长的格式化字符串，但是又不想分隔他们，你可以通过名字来引用格式化的变量。这仅仅只需要传一个字典参数，并使用方括号[]访问键值。(下面的0表示变量table，d表示int类型，也可以使e表示指数格式，当然也可以是1,2,3这些数值，表示宽度)

>>> table = {‘Sjoerd‘: 4127, ‘Jack‘: 4098, ‘Dcab‘: 8637678}
>>> print(‘Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; ‘
...       ‘Dcab: {0[Dcab]:d}‘.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

This could also be done by passing the table as keyword arguments with the ‘**’ notation.

也可以传递关键字参数，使用**标记符：

>>> table = {‘Sjoerd‘: 4127, ‘Jack‘: 4098, ‘Dcab‘: 8637678}
>>> print(‘Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}‘.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

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

结合内置函数vars()，这将变得非常有用。vars()函数返回一个字典类型，该字典包含所有本地变量。

For a complete overview of string formatting with str.format(), see Format String Syntax.

想要完全了解字符串的格式化通过str.format()函数，请查阅Format String Syntax。

7.1.1. Old string formatting

The % operator can also be used for string formatting. It 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. For example:

%也可以用于字符串的格式化，例如：

>>> import math
>>> print(‘The value of PI is approximately %5.3f.‘ % math.pi)
The value of PI is approximately 3.142.

7.2. Reading and Writing Files