Python输入、输出

格式化输出

输出方法：

1. 表达式语句；

raw_input() :    【推荐使用】
将输入当成一个字符串来看待

a = input():
它希望能够读取一个合法的 python表达式，即一个符合python语法的表达式。
相当于eval(raw_input(prompt))。
例如：当你输入字符串的时候必须使用引号将它括起来，否则它会引发一个SyntaxError。

共同点：都可以读取控制台的输入。

2. print语句；
3. 使用文件对象的 write() 方法；
4. 标准文件输出：sys.stdout

对输出做格式化控制：

    str(): 转为适于人阅读的形式；
    repr(): 转为供解释器读取的形式

方法一：字符串的切割和连接

方法二：str.rjust()、str.ljust() 、str.center()。补充空格，进行对齐

 str.rjust() 它把字符串输出到一列，并通过向左侧填充空格来使其右对齐。
 str.ljust()  左对齐
 str.center() 居中对齐

print repr(x).rjust(2), repr(x*x).rjust(3), 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)

str.zfill() 它用于向数值的字符串表达左侧填充 0。该函数可以正确理解正负号：
'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!"

① 大括号中的数值（定位）指明使用传入 str.format() 方法的对象中的哪一个:

print '{0} and {1}'.format('spam', 'eggs')
输出： spam and eggs

print '{1} and {0}'.format('spam', 'eggs')
输出： eggs and spam

② 使用关键字参数，可以通过参数名来引用值:

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’ (应用 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.

⑤ 字段名后允许可选的 ‘:’ 和格式指令。这允许对值的格式化加以更深入的控制。下例将 Pi 转为三位精度。

import math
print('The value of PI is approximately {0:.3f}.'.format(math.pi))
输出：The value of PI is approximately 3.142.

⑥ 在字段后的 ‘:’ 后面加一个整数会限定该字段的最小宽度，这在美化表格时很有用:

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

方法四： 旧式的字符串格式化（%）

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

输出：The value of PI is approximately 3.142.

文件读写

函数 open() 返回文件对象，通常的用法需要两个参数：open(filename, mode)。
两个参数说明：
① filename：文件路径（eg: /tmp/test.txt）
② mode：文件被使用的模式
     ‘r’，只读；
     ‘w’，只写(对于同名文件，该操作使原有文件被覆盖)；
      ‘a’，以追加方式打开文件；
     ‘r+’，以读写方式打开文件；
     【模式参数是可选的。如果没有指定，默认为 ‘r’ 模式。】
说明：
     在 Windows 平台上，‘b’ 模式以二进制方式打开文件，所以可能会有类似于 ‘rb’， ‘wb’， ‘r+b’ 等等模式组合。
Windows 平台上文本文件与二进制文件是有区别的，读写文本文件时，行尾会自动添加行结束符。这种后台操作方式对 ASCII 文本文件没有什么问题，但是操作 JPEG 或 EXE 这样的二进制文件时就会产生破坏。在操作这些文件时一定要记得以二进制模式打开。
在 Unix 上，加一个 ‘b’ 模式也一样是无害的，所以你可以一切二进制文件处理中平台无关的使用它。

例如，创建文件对象 f ：
f = open('workfile', 'w')

返回： <open file 'workfile', mode 'w' at 80a0960>

读取文件内容

1. f.read(size)：
   size 是可选的数值，指定字符串长度。
   如果没有指定 size 或者指定为负数，就会读取并返回整个文件。
   当文件大小为当前机器内存两倍时，就会产生问题。反之，会尽可能按比较大的 size 读取和返回数据。如果到了文件末尾，f.read() 会返回一个空字符串( ”“ )。
2. f.readline()：
   从文件中读取单独一行，字符串结尾会自动加上一个换行符( \n )，只有当文件最后一行没有以换行符结尾时，这一操作才会被忽略。
3. f.readlines() ：
   返回一个列表，其中包含了文件中所有的数据行。如果给定了 sizehint 参数，就会读入多于一行的比特数，从中返回多行文本。这个功能通常用于高效读取大型行文件，避免了将整个文件读入内存。这种操作只返回完整的行。
4. 一种替代 readlines() 的方法是通过遍历文件对象来读取文件行。这是一种内存高效、快速，并且代码简洁的方式:

for line in f:
    print line,    # 使用逗号来抑制自动生成的换行符号

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

写入文件内容

1. f.write(string) 方法将 string 的内容写入文件，并返回写入字符的长度:

f.write('This is a test\n')
返回： 15

注意： 想要写入其他非字符串内容，首先要将它转换为字符串。

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

2. f.tell() 返回一个整数
   代表文件对象在文件中的指针位置，该数值计量了自文件开头到指针处的比特数。需要改变文件对象指针话话，使用 f.seek(offset,from_what)。指针在该操作中从指定的引用位置移动 offset 比特，引用位置由 from_what 参数指定。
   from_what 值为 0 表示自文件起始处开始，
   1 表示自当前文件指针位置开始，
   2 表示自文件末尾开始。
   from_what 可以忽略，其默认值为零，此时从文件头开始:

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'

在文本文件中(那些没有使用 b 模式选项打开的文件)，只允许从文件头开始计算相对位置(使用 seek(0, 2) 从文件尾计算时就会引发异常)。

当你使用完一个文件时，调用 f.close() 方法就可以关闭它并释放其占用的所有系统资源。在调用 f.close() 方法后，试图再次使用文件对象将会自动失败:

用关键字 with 处理文件对象是个好习惯。
它的先进之处在于文件用完后会自动关闭，就算发生异常也没关系。它是 try-finally 块的简写:

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

使用 json 存储结构化数据

从文件中读写字符串很容易。数值就要多费点儿周折，因为 read() 方法只会返回字符串。

Python 允许你使用常用的数据交换格式 JSON（JavaScript Object Notation）。
标准模块 json 可以接受 Python 数据结构：
序列化： 将Python数据结构转换为字符串表示形式；
反序列化： 从字符串表示形式重新构建数据结构。

序列化和反序列化的过程中，表示该对象的字符串可以存储在文件或数据中，也可以通过网络连接传送给远程的机器。

如果你有一个对象 x，你可以用简单的一行代码查看其 JSON 字符串表示形式:
json.dumps([1, 'simple', 'list'])
'[1, "simple", "list"]'

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

json.dump(x, f)  # 将对象序列化到文件（Python数据结构 -> 字符串）

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

x = json.load(f)  # 解码文件对象（字符串 -> Python数据结构）

这种简单的序列化技术可以处理列表和字典。

pickle - pickle 模块

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