7. 输入和输出

展现程序的输出有多种方法；可以打印成人类可读的形式，也可以写入到文件以便后面使用。本章将讨论其中的几种方法。

7.1. 格式化输出

到目前为止我们遇到过两种输出值的方法：表达式语句和print()函数。（第三个方式是使用文件对象的write()方法；标准输出文件可以引用 sys.stdout。详细内容参见库参考手册。）

通常你会希望更好地控制输出的格式而不是简单地打印用空格分隔的值。有两种方法来设置输出格式；第一种方式是自己做所有的字符串处理；使用字符串切片和连接操作，你可以创建任何你能想象到的布局。字符串类型有一些方法，用于执行将字符串填充到指定列宽度的有用操作；这些稍后将讨论。第二种方法是使用str.format()方法。

string模块包含一个Template类，提供另外一种向字符串代入值得方法。

当然还有一个问题：如何将值转换为字符串？幸运的是，Python 有方法将任何值转换为字符串：将它传递给repr()或str()函数。

str()函数的用意在于返回人类可读的表现形式，而repr()的用意在于生成解释器可读的表现形式（如果没有等价的语法将会引发SyntaxError异常）。对于对人类并没有特别的表示形式的对象，str()和repr()将返回相同的值。许多值，例如数字或者列表和字典这样的结构，使用这两个函数中的任意一个都具有相同的表示形式。字符串，特殊一些，有两种不同的表示形式。

一些例子：

  1. >>> s = 'Hello, world.'
  2. >>> str(s)
  3. 'Hello, world.'
  4. >>> repr(s)
  5. "'Hello, world.'"
  6. >>> str(1/7)
  7. '0.14285714285714285'
  8. >>> x = 10 * 3.25
  9. >>> y = 200 * 200
  10. >>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
  11. >>> print(s)
  12. The value of x is 32.5, and y is 40000...
  13. >>> # The repr() of a string adds string quotes and backslashes:
  14. ... hello = 'hello, world\n'
  15. >>> hellos = repr(hello)
  16. >>> print(hellos)
  17. 'hello, world\n'
  18. >>> # The argument to repr() may be any Python object:
  19. ... repr((x, y, ('spam', 'eggs')))
  20. "(32.5, 40000, ('spam', 'eggs'))"

这里用两种方法输出平方和立方表：

  1. >>> for x in range(1, 11):
  2. ...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
  3. ...     # Note use of 'end' on previous line
  4. ...     print(repr(x*x*x).rjust(4))
  5. ...
  6.  1   1    1
  7.  2   4    8
  8.  3   9   27
  9.  4  16   64
  10.  5  25  125
  11.  6  36  216
  12.  7  49  343
  13.  8  64  512
  14.  9  81  729
  15. 10 100 1000
  17. >>> for x in range(1, 11):
  18. ...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
  19. ...
  20.  1   1    1
  21.  2   4    8
  22.  3   9   27
  23.  4  16   64
  24.  5  25  125
  25.  6  36  216
  26.  7  49  343
  27.  8  64  512
  28.  9  81  729
  29. 10 100 1000

（注意在第一个示例中，每列之间的一个空格由print()自动添加：它总会在它的参数之间添加空格。)

上面的例子演示了字符串对象的str.rjust()方法，它通过在左侧填充空格使字符串在给定宽度的列右对齐。类似的方法还有str.ljust()和str.center()。这些方法不会输出任何内容，它们只返回新的字符串。如果输入的字符串太长，它们不会截断字符串，而是保持原样返回；这会使列的格式变得混乱，但是通常好于另外一种选择，那可能是一个错误的值。（如果你真的想要截断，可以加上一个切片操作，例如x.ljust(n)[:n]。)

另外一种方法 str.zfill()，它向数值字符串左侧填充零。该函数可以正确识别正负号：

  1. >>> '12'.zfill(5)
  2. '00012'
  3. >>> '-3.14'.zfill(7)
  4. '-003.14'
  5. >>> '3.14159265359'.zfill(5)
  6. '3.14159265359'

str.format()方法的基本用法如下所示：

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

花括号及其中的字符（称为格式字段）将被替换为传递给str.format()方法的对象。可以用括号中的数字指定传递给str.format()方法的对象的位置。

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

如果str.format()方法使用关键字参数，那么将通过参数名引用它们的值。

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

位置参数和关键字参数可以随意组合：

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

'!a'（用于ascii()），'!s'（用于str()）和'!r'（用于repr()）可以用来格式化之前对值进行转换。

  1. >>> import math
  2. >>> print('The value of PI is approximately {}.'.format(math.pi))
  3. The value of PI is approximately 3.14159265359.
  4. >>> print('The value of PI is approximately {!r}.'.format(math.pi))
  5. The value of PI is approximately 3.141592653589793.

字段名后允许可选的': '和格式指令。这允许更好地控制如何设置值的格式。下面的例子将 Pi 转为三位精度。

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

':'后面紧跟一个整数可以限定该字段的最小宽度。这在美化表格时很有用。

  1. >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
  2. >>> for name, phone in table.items():
  3. ...     print('{0:10} ==> {1:10d}'.format(name, phone))
  4. ...
  5. Jack       ==>       4098
  6. Dcab       ==>       7678
  7. Sjoerd     ==>       4127

如果你有一个实在是很长的格式字符串但又不想分开写，要是可以按照名字而不是位置引用变量就好了。有个简单的方法，可以传入一个字典，然后使用'[]'访问。

  1. >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
  2. >>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
  3. ...       'Dcab: {0[Dcab]:d}'.format(table))
  4. Jack: 4098; Sjoerd: 4127; Dcab: 8637678

这也可以用 ‘**’ 标志将这个字典以关键字参数的方式传入。

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

这种方式与内置函数vars()组合起来将更加有用，该函数返回一个包含所有局部变量的字典。

关于str.format()完整的描述，请参见格式字符串语法。

7.1.1. 旧式的字符串格式

%运算符也可以用于字符串格式化。它将左边类似sprintf()-风格的参数应用到右边的参数，然后返回这种格式化操作生成的字符串。例如：

  1. >>> import math
  2. >>> print('The value of PI is approximately %5.3f.' % math.pi)
  3. The value of PI is approximately 3.142.

在printf-style String Formatting一节，可以找到更多的信息。

7.2. 读写文件

open()返回一个文件对象，最常见的用法带有两个参数：open(filename,mode)。

  1. >>> f = open('workfile', 'w')

第一个参数是一个含有文件名的字符串。第二个参数也是一个字符串，含有描述如何使用该文件的几个字符。mode为'r'时表示只是读取文件；w 表示只是写入文件（已经存在的同名文件将被删掉）；'a'表示打开文件进行追加，写入到文件中的任何数据将自动添加到末尾。'r+'表示打开文件进行读取和写入。mode 参数是可选的，默认为'r'。

通常，文件以文本打开，这意味着，你从文件读出和向文件写入的字符串会被特定的编码方式（默认是UTF-8）编码。模式后面的'b'以二进制模式打开文件：数据会以字节对象的形式读出和写入。这种模式应该用于所有不包含文本的文件。

在文本模式下，读取时默认会将平台有关的行结束符（Unix上是\n, Windows上是\r\n）转换为\n。在文本模式下写入时，默认会将出现的\n转换成平台有关的行结束符。这种暗地里的修改对 ASCII 文本文件没有问题，但会损坏JPEG或EXE这样的二进制文件中的数据。使用二进制模式读写此类文件时要特别小心。

7.2.1. 文件对象的方法

本节中的示例将假设文件对象f已经创建。

要读取文件内容，可以调用f.read(size) ，该方法读取若干数量的数据并以字符串或字节对象返回。size 是可选的数值参数。当 size 被省略或者为负数时，将会读取并返回整个文件；如果文件大小是你机器内存的两倍时，就是你的问题了。否则，至多读取和返回 size 大小的字节数据。如果到了文件末尾，f.read() 会返回一个空字符串('')。

  1. >>> f.read()
  2. 'This is the entire file.\n'
  3. >>> f.read()
  4. ''

f.readline()从文件读取一行数据；字符串结尾会带有一个换行符 (\n) ，只有当文件最后一行没有以换行符结尾时才会省略。这样返回值就不会有混淆，如果 f.readline()返回一个空字符串，那就表示已经达到文件的末尾，而如果返回一个只包含一个换行符的字符串'\n'，则表示遇到一个空行。

  1. >>> f.readline()
  2. 'This is the first line of the file.\n'
  3. >>> f.readline()
  4. 'Second line of the file\n'
  5. >>> f.readline()
  6. ''

你可以循环遍历文件对象来读取文件中的每一行。这是既省内存又非常快的简单代码：

  1. >>> for line in f:
  2. ...     print(line, end='')
  3. ...
  4. This is the first line of the file.
  5. Second line of the file

如果你想把文件中的所有行读到一个列表中，你也可以使用list(f)或f.readlines()。

f.write(string)将 string 的内容写入文件中并返回写入的字节的数目。

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

如果想写入字符串以外的数据，需要先将它转换为一个字符串：

  1. >>> value = ('the answer', 42)
  2. >>> s = str(value)
  3. >>> f.write(s)
  4. 18

f.tell()返回一个给出文件对象在文件中当前位置的整数，在二进制模式下表示自文件开头的比特数，在文本模式下是一个无法理解的数。

若要更改该文件对象的位置，可以使用f.seek(offset,fromwhat)。新的位置由参考点加上 _offse 计算得来，参考点的选择则来自于 from_what 参数。from_what 值为 0 表示以文件的开始为参考点，1 表示以当前的文件位置为参考点，2 表示以文件的结尾为参考点。from_what 可以省略，默认值为 0，表示以文件的开始作为参考点。

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

在文本文件中（没有以b模式打开），只允许从文件头开始寻找（有个例外是用seek(0,2)寻找文件的最末尾处）而且合法的偏移值只能是f.tell()返回的值或者是零。其它任何偏移 值都会产生未定义的行为。

使用完一个文件后，调用f.close()可以关闭它并释放其占用的所有系统资源。调用f.close()后，再尝试使用该文件对象将失败。

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

处理文件对象时使用with关键字是很好的做法。这样做的好处在于文件用完后会自动关闭，即使过程中发生异常也没关系。它还比编写一个等同的try-finally语句要短很多：

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

文件对象还有一些不太常用的方法，例如isatty()和truncate()；有关文件对象的完整指南，请参阅 Python 库参考手册。

7.2.2. 使用json存储结构化数据

从文件中读写字符串很容易。数值就要多费点儿周折，因为read ()方法只会返回字符串，应将其传入int()这样的函数，就可以将'123'这样的字符串转换为对应的数值 123。当你想要保存更为复杂的数据类型，例如嵌套的列表和字典，手工解析和序列化它们将变得更复杂。

好在用户不是非得自己编写和调试保存复杂数据类型的代码，Python 允许你使用常用的数据交换格式JSON（JavaScript Object Notation）。标准模块json可以接受 Python 数据结构，并将它们转换为字符串表示形式；此过程称为序列化。从字符串表示形式重新构建数据结构称为反序列化。序列化和反序列化的过程中，表示该对象的字符串可以存储在文件或数据中，也可以通过网络连接传送给远程的机器。

注意

JSON 格式经常用于现代应用程序中进行数据交换。许多程序员都已经熟悉它了，使它成为相互协作的一个不错的选择。

如果你有一个对象x，你可以用简单的一行代码查看其 JSON 字符串表示形式：

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

dumps()函数的另外一个变体dump()，直接将对象序列化到一个文本文件。所以如果f是为写入而打开的一个文本文件对象，我们可以这样做：

  1. json.dump(x, f)

为了重新解码对象，如果f是为读取而打开的文本文件对象：

  1. x = json.load(f)

这种简单的序列化技术可以处理列表和字典，但序列化任意类实例为 JSON 需要一点额外的努力。Json模块的手册对此有详细的解释。

另请参阅

pickle - pickle模块

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

原文: https://wizardforcel.gitbooks.io/python-doc-27-34/content/Text/4.7.html