Python3 入门教程｜｜Python3 输入和输出｜｜Python3 File 方法

Posted 2023-04-04 爱编程的鱼

Python3 输入和输出

在前面几个章节中，我们其实已经接触了 Python 的输入输出的功能。本章节我们将具体介绍 Python 的输入输出。

---

输出格式美化

Python 两种输出值的方式: 表达式语句和 print() 函数。(第三种方式是使用文件对象的 write() 方法; 标准输出文件可以用 sys.stdout 引用。) 

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

str() 函数返回一个用户易读的表达形式。 

repr() 产生一个解释器易读的表达形式。 

例如 

>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'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...
>>> #  repr() 函数可以转义字符串中的特殊字符
... hello = 'hello, world\\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"

这里有两种方式输出一个平方与立方的表: 

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # 注意前一行 'end' 的使用
...     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

注意：在第一个例子中, 每列间的空格由 print() 添加。

这个例子展示了字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。

还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。

另一个方法 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!"

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。 

在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：

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

如果在 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.

'!a' (使用 ascii()), '!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

如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。 

最简单的就是传入一个字典, 然后使用方括号 '[]' 来访问键值 :

>>> 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 变量前使用 '**' 来实现相同的功能：

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

---

旧式字符串格式化

% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如: 

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

因为 str.format() 比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format(). 

---

读和写文件 

open() 将会返回一个 file 对象，基本语法格式如下: 

open(filename, mode)

实例:

>>> f = open('/tmp/workfile', 'w')

• 第一个参数为要打开的文件名。 
• 第二个参数描述文件如何使用的字符。 mode 可以是 'r' 如果文件只读, 'w' 只用于写 (如果存在同名文件则将被删除), 和 'a' 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. 'r+' 同时用于读写。 mode 参数是可选的； 'r' 将是默认值。 

---

文件对象的方法

本节中剩下的例子假设已经创建了一个称为 f 的文件对象。 

f.read()

为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

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

f.readline()

f.readline() 会从文件中读取单独的一行。换行符为 '\\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

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

f.readlines()

f.readlines() 将返回该文件中包含的所有行。 

如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。 

>>> f.readlines()
['This is the first line of the file.\\n', 'Second line of the file\\n']

另一种方式是迭代一个文件对象然后读取每行: 

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

这个方法很简单, 但是并没有提供一个很好的控制。 因为两者的处理机制不同, 最好不要混用。 

f.write()

f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。 

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

如果要写入一些不是字符串的东西, 那么将需要先进行转换: 

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

f.tell()

f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。 

f.seek()

如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

• seek(x, 0) ： 从起始位置即文件首行首字符开始移动 x 个字符
• seek(x, 1) ： 表示从当前位置往后移动x个字符
• seek(-x, 2)：表示从文件的结尾往前移动x个字符 

from_what 值为默认为 0，即文件开头。下面给出一个完整的例子：

>>> f = open('/tmp/workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'

f.close()

在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file
<pre>
<p>
当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:</p>
<pre>
>>> with open('/tmp/workfile', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用。

---

pickle 模块 

Python 的 pickle 模块实现了基本的数据序列和反序列化。

通过 pickle 模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过 pickle 模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。 

基本接口： 

pickle.dump(obj, file, [,protocol])

有了 pickle 这个对象, 就能对 file 以读取的形式打开: 

x = pickle.load(file)

注解：从 file 中读取一个字符串，并将它重构为原来的 Python 对象。

file: 类文件对象，有read() 和 readline() 接口。

实例 1：

#使用pickle模块将数据对象保存到文件

import pickle

data1 = 'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None

selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)

output.close()

实例 2：

#使用pickle模块从文件中重构python对象

import pprint, pickle

pkl_file = open('data.pkl', 'rb')

data1 = pickle.load(pkl_file)
pprint.pprint(data1)

data2 = pickle.load(pkl_file)
pprint.pprint(data2)

pkl_file.close()

Python3 File 方法

file 文件对象使用 open 函数来创建，下表列出了 file 文件对象常用的函数：

序号	方法及描述
1	file.close() 关闭文件。关闭后文件不能再进行读写操作。
2	file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno() 返回一个整型的文件描述符 (file descriptor FD 整型), 可以用在如 os 模块的 read 方法等一些底层操作上。
4	file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next() 返回文件下一行。
6	file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。
7	file.readline([size]) 读取整行，包括 "\\n" 字符。
8	file.readlines([sizehint]) 读取所有行并返回列表，若给定 sizeint>0，返回总和大约为 sizeint 字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9	file.seek(offset[, whence]) 设置文件当前位置
10	file.tell() 返回文件当前位置。
11	file.truncate([size]) 截取文件，截取的字节通过 size 指定，默认为当前文件位置。
12	file.write(str) 将字符串写入文件，返回的是写入的字符长度。
13	file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

Python 极简教程输入输出

输入函数，用于接收键盘输入。主要用于在学习和练习过程中，增加练习的乐趣。让我们的程序相对完整和具备简单的交互能力。
输出函数，将代码运行结果打印在控制台上，同样也能让我们观察程序运行的结果。也是为了增加练习程序的交互能力。以后在实际编码过程中，如果遇到问题需要调试的时候，也可以使用输出函数将代码运行过程中的产生的中间值打印出来，能够帮我们更好的定位问题。

输入函数 input()

从键盘接收输入的函数是 input()，名称后面带括号，叫做函数调用，必须有括号，括号同样用来为函数接收参数。
input() 函数运行后会展示括号中传入的内容，然后光标会在末尾等待用户输入。用户输入内容后需要按回车键结束输入。

>>> name = input("请输入你的名字：")   # input函数括号中接收的参数用于在屏幕上打印输入提示
请输入你的名字: nemo                   # 这是运行上一句代码展示的内容，光标会在冒号后面等待输入
>>> name
nemo

注意，从键盘接收的输入始终为字符串类型。

>>> num = input("请输入一个数字：")
请输入一个数字：5
>>> num
‘5‘                            # 注意，这里有引号，说明是个字符串
>>>num + 5
TypeError: must be str, not int    # 报错，字符串和数字不能相加
>>>type(num)
<class ‘str‘>

另外，在很多时候也可以用 input()函数来中断程序运行：

print(‘正在执行...‘)
input(‘请按回车继续...‘)   # 代码执行到这里会等待用户按回车
print(‘继续执行...‘)

输出函数 print()

print()函数是非常常见的一个函数。

print 函数的原型为 print(*args, seq=‘ ‘, end=‘
‘)
*args: 用于接收任意多个打印内容
sep：用于决定使用何种分隔符来分隔多个打印内容
end：用于决定使用何种结束符

先来看一个经典的例子：

>>> print(‘Hello world!‘)
Hello world!

print()可以接收多个需要打印的内容，用逗号隔开。

>>> print(‘我‘, ‘是‘, ‘Nemo‘)
我 是 Nemo                      # 多个打印内容，默认会用空格隔开

如果要改变隔开的字符，可以修改sep参数。

>>> print(‘我‘, ‘是‘, ‘Nemo‘, sep=‘|‘)   # 用竖线分隔
我|是|Nemo

print()还有一个默认的结束字符是换行符 ，也就是每次打印后都会换行，如果你不想换行，可以改变 end参数。

>>> print(‘我‘, ‘是‘, ‘Nemo‘, sep=‘|‘, end=‘*‘)
我|是|Nemo*

注意， sep 和 end 必须写在最后！

本节思考
如何处理 input() 函数接收的数字，使它可以正常与整数进行加减运算？