7. 输入和输出

表示一个程序的输出有几种方法。数据可以以人类可读的方式打印出来，也可以写入一个文件以供将来使用。这一章我们将讨论这些可能性。

7.1 更复杂的输出格式

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

通常情况，你输出格式要比简单的打印出空格隔开的值需要更多的控制。格式化输出一共有两种方式。第一种方式是你自己处理所有的字符串。使用字符串 slice 和串接操作，你可以创建出你想象出的任何输出样式。字符串格式有一些方法，这些方法实现了很实用的把字符串变为给定的列宽。这些一会再讨论。第二种方法是使用 格式化字符串字面量，或者 str.format() 方法。

string 模块包含了一个 Template 类，这个类目前提供了另一种把值替换为字符串的方法。

留下一个问题：你怎样把值转换为字符串？很幸运，Python 有几个把值转化为字符串的方法：把它传递给 repr() 或者 str() 函数。

str() 函数用来返回值的记号，它们是人类可读的，而 repr() 函数用来生成解释器可以读懂的记号 (如果没有相等的语法，就会有一个 语法错误 )。对于那些没有特定的人类可用的记号的对象，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()。这些方法不会写出任何东西，他们仅仅返回一个新的字符串。如果输入的字符串太长，他们不会截断，而是原封不动返回。这就会弄乱你的列样式，但是一般都比可选的好，这种可选的会占一个值。(如果你想阶段，你可以加入一个 slice 操作，就像 x.ljust(n)[:n])

还有另一种方法，str.zfill(),它在左边加上数字字符串 0。它理解加减号。

  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()) 可以用来在格式化之前转换值：

  1. >>> contents = 'eels'
  2. >>> print('My hovercraft is full of {}.'.format(contents))
  3. My hovercraft is full of eels.
  4. >>> print('My hovercraft is full of {!r}.'.format(contents))
  5. My hovercraft is full of 'eels'.

一个可选的 ':' 和格式化说明符可以跟在栏目名后面。这就允许在值如何格式化上有更大的控制。下面的例子把 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

如果你又一个很长的格式化字符串，而你不想把它分开，如果你可以把值引用为通过名字而不是通过位置格式化，这就很棒了。他可以通过简单的传入字典和使用方括号获取 key 来实现。

  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 风格字符串格式化 的章节你可以找到更多信息。