7. 输入和输出¶

    我们有两种大相径庭的输出值方法：表达式语句和 print 语句。(第三种方法是使用文件对象的 方法，标准文件输出可以参考 sys.stdout，详细内容参见库参考手册。)

    通常，你想要对输出做更多的格式控制，而不是简单的打印使用空格分隔的值。有两种方法可以格式化你的输出：第一种方法是由你自己处理整个字符串，通过使用字符串切割和连接操作可以创建任何你想要的输出形式。string 类型包含一些将字符串填充到指定列宽度的有用操作，随后就会讨论这些。第二种方法是使用 方法。

    标准模块 string 包括了一些操作，将字符串填充入给定列时，这些操作很有用。随后我们会讨论这部分内容。第二种方法是使用 方法。

    当然，还有一个问题，如何将值转化为字符串？很幸运，Python 有办法将任意值转为字符串：将它传入 repr() 或 函数。

    函数 str() 用于将值转化为适于人阅读的形式，而 转化为供解释器读取的形式(如果没有等价的语法，则会发生 SyntaxError 异常)某对象没有适于人阅读的解释形式的话， 会返回与 repr() 等同的值。很多类型，诸如数值或链表、字典这样的结构，针对各函数都有着统一的解读方式。字符串和浮点数，有着独特的解读方式。

    下面有些例子:

    有两种方式可以写平方和立方表:

    1. >>> for x in range(1, 11):
    2. ...     print repr(x).rjust(2), repr(x*x).rjust(3)
    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
    16.  
    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

    (注意第一个例子， 在每列之间加了一个空格，它总是在参数间加入空格。)

    以上是一个 str.rjust() 方法的演示，它把字符串输出到一列，并通过向左侧填充空格来使其右对齐。类似的方法还有 和 str.center()。这些函数只是输出新的字符串，并不改变什么。如果输出的字符串太长，它们也不会截断它，而是原样输出，这会使你的输出格式变得混乱，不过总强过另一种选择(截断字符串)，因为那样会产生错误的输出值(如果你确实需要截断它，可以使用切割操作，例如：x.ljust(n)[:n]）。

    还有另一个方法， 它用于向数值的字符串表达左侧填充 0。该函数可以正确理解正负号:

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

    方法 str.format() 的基本用法如下:

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

    大括号和其中的字符会被替换成传入 的参数。大括号中的数值指明使用传入 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

    如果在 调用时使用关键字参数，可以通过参数名来引用值:

    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.

    '!s' (应用 str() )和 '!r' (应用 )可以在格式化之前转换值:

    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. >>> 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() 组合使用非常有效。该函数返回包含所有局部变量的字典。

    要进一步了解字符串格式化方法 ，参见 Format String Syntax。

    操作符 % 也可以用于字符串格式化。它以类似 sprintf()-style 的方式解析左参数，将右参数应用于此，得到格式化操作生成的字符串，例如:

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

    进一步的信息可以参见 一节。

    7.2. 文件读写¶

    函数 返回文件对象，通常的用法需要两个参数：open(filename, mode)。

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

    第一个参数是一个标识文件名的字符串。第二个参数是由有限的字母组成的字符串，描述了文件将会被如何使用。可选的 模式 有：'r'，此选项使文件只读；'w'，此选项使文件只写(对于同名文件，该操作使原有文件被覆盖)；'a'，此选项以追加方式打开文件；，此选项以读写方式打开文件；模式参数是可选的。如果没有指定，默认为 'r' 模式。

    在 Windows 平台上，'b' 模式以二进制方式打开文件，所以可能会有类似于 'rb'， 'wb'， 'r+b' 等等模式组合。Windows 平台上文本文件与二进制文件是有区别的，读写文本文件时，行尾会自动添加行结束符。这种后台操作方式对 ASCII 文本文件没有什么问题，但是操作 JPEG 或 EXE 这样的二进制文件时就会产生破坏。在操作这些文件时一定要记得以二进制模式打开。在 Unix 上，加一个 'b' 模式也一样是无害的，所以你可以一切二进制文件处理中平台无关的使用它。

    本节中的示例都默认文件对象 f 已经创建。

    要读取文件内容，需要调用 f.read(size)，该方法读取若干数量的数据并以字符串形式返回其内容，size 是可选的数值，指定字符串长度。如果没有指定 size 或者指定为负数，就会读取并返回整个文件。当文件大小为当前机器内存两倍时，就会产生问题。反之，会尽可能按比较大的 size 读取和返回数据。如果到了文件末尾，f.read() 会返回一个空字符串( ”“ ):

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

    f.readline() 从文件中读取单独一行，字符串结尾会自动加上一个换行符( )，只有当文件最后一行没有以换行符结尾时，这一操作才会被忽略。这样返回值就不会有混淆，如果如果 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. ''

    f.readlines() 返回一个列表，其中包含了文件中所有的数据行。如果给定了 sizehint 参数，就会读入多于一行的比特数，从中返回多行文本。这个功能通常用于高效读取大型行文件，避免了将整个文件读入内存。这种操作只返回完整的行。

    一种替代的方法是通过遍历文件对象来读取文件行。这是一种内存高效、快速，并且代码简洁的方式:

    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

    虽然这种替代方法更简单，但并不具备细节控制能力。因为这两种方法处理行缓存的方式不同，千万不能搞混。

    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)。指针在该操作中从指定的引用位置移动 _offset 比特，引用位置由 from_what 参数指定。 from_what 值为 0 表示自文件起始处开始，1 表示自当前文件指针位置开始，2 表示自文件末尾开始。from_what 可以忽略，其默认值为零，此时从文件头开始:

    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.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 处理文件对象是个好习惯。它的先进之处在于文件用完后会自动关闭，就算发生异常也没关系。它是 -finally 块的简写:

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

    文件对象还有一些不太常用的附加方法，比如 和 truncate() 在库参考手册中有文件对象的完整指南。

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

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

    Note

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

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

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

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

    为了重新解码对象，如果f是为读取而打开的 :

    1. x = json.load(f)

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

    See also

    - pickle 模块

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