7. 输入输出
***********

有几种方法可以显示程序的输出；数据可以以人类可读的形式打印出来，或者写
入文件以供将来使用。本章将讨论一些可能性。


7.1. 更漂亮的输出格式
=====================

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
layout you can imagine.  The string types have 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.

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

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.

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 and floating point
numbers, in particular, have two distinct representations.

几个例子:

   >>> s = 'Hello, world.'
   >>> str(s)
   'Hello, world.'
   >>> repr(s)
   "'Hello, world.'"
   >>> str(1.0/7.0)
   '0.142857142857'
   >>> repr(1.0/7.0)
   '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),
   ...     # Note trailing comma 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: by default it adds spaces between its
arguments.)

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]".)

还有另外一个方法，"str.zfill()" ，它会在数字字符串的左边填充零。它能识
别正负号:

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

"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 refers to the position of the object passed
into the "str.format()" method.

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

如果在 "str.format()" 方法中使用关键字参数，则使用参数的名称引用它们的
值。:

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

位置和关键字参数可以任意组合:

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

"'!s'" (apply "str()") and "'!r'" (apply "repr()") can be used to
convert the value before it is formatted.

   >>> 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.

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

如果你有一个非常长的格式字符串，你不想把它拆开，那么你最好按名称而不是
位置引用变量来进行格式化。这可以通过简单地传递字典和使用方括号 "'[]'"
访问键来完成:

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

这也可以通过使用 ‘**’ 符号将表作为关键字参数传递。:

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

这在与内置函数 "vars()" 结合使用时非常有用，它会返回包含所有局部变量的
字典。

关于使用 "str.format()" 进行字符串格式化的完整概述，请参阅 Format
String Syntax 。


7.1.1. 旧的字符串格式化方法
---------------------------

"%" 操作符也可以用作字符串格式化。它将左边的参数解释为一个很像
"sprintf()" 风格 的格式字符串，应用到右边的参数，并返回一个由此格式化
操作产生的字符串。例如:

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

More information can be found in the String Formatting Operations
section.


7.2. 读写文件
=============

"open()" returns a file object, and is most commonly used with two
arguments: "open(filename, mode)".

   >>> f = open('workfile', 'w')
   >>> print f
   <open file 'workfile', mode 'w' at 80a0960>

第一个参数是包含文件名的字符串。第二个参数是另一个字符串，其中包含一些
描述文件使用方式的字符。*mode* 可以是 "'r'" ，表示文件只能读取，"'w'"
表示只能写入（已存在的同名文件会被删除），还有 "'a'" 表示打开文件以追
加内容；任何写入的数据会自动添加到文件的末尾。"'r+'" 表示打开文件进行
读写。*mode* 参数是可选的；省略时默认为 "'r'"。

On Windows, "'b'" appended to the mode opens the file in binary mode,
so there are also modes like "'rb'", "'wb'", and "'r+b'".  Python on
Windows makes a distinction between text and binary files; the end-of-
line characters in text files are automatically altered slightly when
data is read or written.  This behind-the-scenes modification to file
data is fine for ASCII text files, but it’ll corrupt binary data like
that in "JPEG" or "EXE" files.  Be very careful to use binary mode
when reading and writing such files.  On Unix, it doesn’t hurt to
append a "'b'" to the mode, so you can use it platform-independently
for all binary files.


7.2.1. 文件对象的方法
---------------------

本节中剩下的例子将假定你已创建名为 "f" 的文件对象。

To read a file’s contents, call "f.read(size)", which reads some
quantity of data and returns it as a string.  *size* is an optional
numeric argument.  When *size* is omitted or negative, the entire
contents of the file will be read and returned; it’s your problem if
the file is twice as large as your machine’s memory. Otherwise, at
most *size* bytes are read and returned.  If the end of the file has
been reached, "f.read()" will return an empty string ("""").

   >>> f.read()
   'This is the entire file.\n'
   >>> f.read()
   ''

"f.readline()" reads a single line from the file; a newline character
("\n") is left at the end of the string, and is only omitted on the
last line of the file if the file doesn’t end in a newline.  This
makes the return value unambiguous; if "f.readline()" returns an empty
string, the end of the file has been reached, while a blank line is
represented by "'\n'", a string containing only a single newline.

   >>> f.readline()
   'This is the first line of the file.\n'
   >>> f.readline()
   'Second line of the file\n'
   >>> f.readline()
   ''

要从文件中读取行，你可以循环遍历文件对象。这是内存高效，快速的，并简化
代码:

   >>> for line in f:
           print line,

   This is the first line of the file.
   Second line of the file

如果你想以列表的形式读取文件中的所有行，你也可以使用 "list(f)" 或
"f.readlines()"。

"f.write(string)" writes the contents of *string* to the file,
returning "None".

   >>> f.write('This is a test\n')

To write something other than a string, it needs to be converted to a
string first:

   >>> value = ('the answer', 42)
   >>> s = str(value)
   >>> f.write(s)

"f.tell()" returns an integer giving the file object’s current
position in the file, measured in bytes from the beginning of the
file.  To change the file object’s position, use "f.seek(offset,
from_what)".  The position is computed from adding *offset* to a
reference point; the reference point is selected by the *from_what*
argument.  A *from_what* value of 0 measures from the beginning of the
file, 1 uses the current file position, and 2 uses the end of the file
as the reference point.  *from_what* can be omitted and defaults to 0,
using the beginning of the file as the reference point.

   >>> f = open('workfile', 'r+')
   >>> f.write('0123456789abcdef')
   >>> f.seek(5)      # Go to the 6th byte in the file
   >>> f.read(1)
   '5'
   >>> f.seek(-3, 2)  # Go to the 3rd byte before the end
   >>> f.read(1)
   'd'

When you’re done with a file, call "f.close()" to close it and free up
any system resources taken up by the open file.  After calling
"f.close()", attempts to use the file object will automatically fail.

   >>> f.close()
   >>> f.read()
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   ValueError: I/O operation on closed file

It is good practice to use the "with" keyword when dealing with file
objects.  This has the advantage that the file is properly closed
after its suite finishes, even if an exception is raised on the way.
It is also much shorter than writing equivalent "try"-"finally"
blocks:

   >>> with open('workfile', 'r') as f:
   ...     read_data = f.read()
   >>> f.closed
   True

文件对象有一些额外的方法，例如 "isatty()" 和 "truncate()" ，它们使用频
率较低；有关文件对象的完整指南请参阅库参考。


7.2.2. 使用 "json" 保存结构化数据
---------------------------------

字符串可以很轻松地写入文件并从文件中读取出来。数字可能会费点劲，因为
"read()" 方法只能返回字符串，这些字符串必须传递给类似 "int()" 的函数，
它会接受类似 "'123'" 这样的字符串并返回其数字值 123。当你想保存诸如嵌
套列表和字典这样更复杂的数据类型时，手动解析和序列化会变得复杂。

Python 允许你使用称为  JSON (JavaScript Object Notation) 的流行数据交
换格式，而不是让用户不断的编写和调试代码以将复杂的数据类型保存到文件中
。名为 "json" 的标准模块可以采用 Python 数据层次结构，并将它们转化为字
符串表示形式；这个过程称为 *serializing* 。从字符串表示中重建数据称为
*deserializing* 。在序列化和反序列化之间，表示对象的字符串可能已存储在
文件或数据中，或通过网络连接发送到某个远程机器。

注解: JSON格式通常被现代应用程序用于允许数据交换。许多程序员已经熟悉
  它，这 使其成为互操作性的良好选择。

如果你有一个对象 "x" ，你可以用一行简单的代码来查看它的 JSON 字符串表
示:

   >>> import json
   >>> json.dumps([1, 'simple', 'list'])
   '[1, "simple", "list"]'

Another variant of the "dumps()" function, called "dump()", simply
serializes the object to a file.  So if "f" is a *file object* opened
for writing, we can do this:

   json.dump(x, f)

To decode the object again, if "f" is a *file object* which has been
opened for reading:

   x = json.load(f)

这种简单的序列化技术可以处理列表和字典，但是在JSON中序列化任意类的实例
需要额外的努力。 "json" 模块的参考包含对此的解释。

参见: "pickle" - 封存模块

  与 JSON 不同，*pickle* 是一种允许对任意复杂 Python 对象进行序列化的
  协议。因此，它为 Python 所特有，不能用于与其他语言编写的应用程序通信
  。默认情况下它也是不安全的：如果数据是由熟练的攻击者精心设计的，则反
  序列化来自不受信任来源的 pickle 数据可以执行任意代码。
