本文目录一览：

1. [io.UnsupportedOperation: not readable python编程中老是这情况，，新人求解救](#io.UnsupportedOperation: not readable python编程中老是这情况，，新人求解救)
2. [python 基础教程](#python 基础教程)
3. python中怎么输入输出文件
4. 如何用Python打开指定的某个文件夹？比如我要用Python打开D盘里的一个普通文件，该怎么做？
5. python的编写格式
6. [Python其实很简单 第十五章 文件操作](#Python其实很简单 第十五章 文件操作)

io.UnsupportedOperation: not readable python编程中老是这情况，，新人求解救

io.UnsupportedOperation: not readable 是因为代码中有两处错误：

1. 使用 open 打开一个文件时调用的是 w 写入模式，下面使用 read 是没有权限的。
2. 使用 write 写入一个字符 s，但此时并没有真正的写入，而是还存在与内存中。此时执行 read 读取的为空字符。需要先执行 a.close() 关闭文件，再使用 a = open("D://2.txt")，最后再用 a.read() 打开文件读入。 修改后的代码：

a = open("D://2.txt", "w")
a.write("s")
a.close()
a = open("D://2.txt", "r")
print(a.read())

参数说明：

1. name：一个包含了你要访问的文件名称的字符串值。
2. mode：决定了打开文件的模式：只读、写入、追加等。
3. buffering：如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。

python 基础教程

运算

a = 21
b = 10
c = 0
c = a + b
print "1 - c 的值为：", c
c = a - b
print "2 - c 的值为：", c
c = a * b
print "3 - c 的值为：", c
c = a / b
print "4 - c 的值为：", c
c = a % b
print "5 - c 的值为：", c
a = 2
b = 3
c = a**b
print "6 - c 的值为：", c
a = 10
b = 5
c = a//b
print "7 - c 的值为：", c

比较

a = 21
b = 10
c = 0
if (a == b):
    print "1 - a 等于 b"
else:
    print "1 - a 不等于 b"
if (a != b):
    print "2 - a 不等于 b"
else:
    print "2 - a 等于 b"
if (a < b):
    print "3 - a 小于 b"
else:
    print "3 - a 大于等于 b"
if (a > b):
    print "4 - a 大于 b"
else:
    print "4 - a 小于等于 b"
if (a <= b):
    print "5 - a 小于等于 b"
else:
    print "5 - a 大于 b"
a = 5
b = 20
if (a <= b):
    print "6 - a 小于等于 b"
else:
    print "6 - a 大于 b"
if (b >= a):
    print "7 - b 大于等于 a"
else:
    print "7 - b 小于 a"

赋值

a = 21
b = 10
c = 0
c = a + b
print "1 - c 的值为：", c
c += a
print "2 - c 的值为：", c
c *= a
print "3 - c 的值为：", c
c /= a
print "4 - c 的值为：", c
c = 2
c %= a
print "5 - c 的值为：", c
c **= a
print "6 - c 的值为：", c
c //= a
print "7 - c 的值为：", c

逻辑运算符

a = 10
b = 20
if (a and b):
    print "1 - 变量 a 和 b 都为 true"
else:
    print "1 - 变量 a 和 b 有一个不为 true"
if (a or b):
    print "2 - 变量 a 和 b 都为 true，或其中一个变量为 true"
else:
    print "2 - 变量 a 和 b 都不为 true"
a = 0
if (a and b):
    print "3 - 变量 a 和 b 都为 true"
else:
    print "3 - 变量 a 和 b 有一个不为 true"
if (a or b):
    print "4 - 变量 a 和 b 都为 true，或其中一个变量为 true"
else:
    print "4 - 变量 a 和 b 都不为 true"
if not (a and b):
    print "5 - 变量 a 和 b 都为 false，或其中一个变量为 false"
else:
    print "5 - 变量 a 和 b 都为 true"

in, not in

a = 10
b = 20
list = [1, 2, 3, 4, 5]
if (a in list):
    print "1 - 变量 a 在给定的列表中 list 中"
else:
    print "1 - 变量 a 不在给定的列表中 list 中"
if (b not in list):
    print "2 - 变量 b 不在给定的列表中 list 中"
else:
    print "2 - 变量 b 在给定的列表中 list 中"
a = 2
if (a in list):
    print "3 - 变量 a 在给定的列表中 list 中"
else:
    print "3 - 变量 a 不在给定的列表中 list 中"

条件

flag = False
name = 'luren'
if name == 'python':  # 判断变量是否为'python'
    flag = True  # 条件成立时设置标志为真
    print 'welcome boss'  # 并输出欢迎信息
else:
    print name
num = 5
if num == 3:  # 判断num的值
    print 'boss'
elif num == 2:
    print 'user'
elif num == 1:
    print 'worker'
elif num < 0:  # 值小于零时输出
    print 'error'
else:
    print 'roadman'  # 条件均不成立时输出

循环语句

count = 0
while (count < 9):
    print 'The count is:', count
    count = count + 1
print "Good bye!"
i = 1
while i < 10:
    i += 1
    if i % 2 != 0:  # 非双数时跳过输出
        continue
    print i  # 输出双数2、4、6、8、10
i = 1
while 1:  # 循环条件为1必定成立
    print i  # 输出1~10
    i += 1
    if i > 10:  # 当i大于10时跳出循环
        break
for letter in 'Python':  # 第一个实例
    print '当前字母 :', letter
fruits = ['banana', 'apple', 'mango']
for fruit in fruits:  # 第二个实例
    print '当前水果 :', fruit
print "Good bye!"

获取用户输入: raw_input

var = 1
while var == 1:  # 该条件永远为true，循环将无限执行下去
    num = raw_input("Enter a number :")
    print "You entered: ", num
print "Good bye!"

range, len

fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
    print '当前水果 :', fruits[index]
print "Good bye!"

Python数学函数

abs, cell, cmp, exp, fabs, floor, log, log10, max, min, mod, pow, round, sqrt, randrange

访问字符串的值

var1 = 'Hello World!'
var2 = "Python Runoob"
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

转义字符

格式化输出

print "My name is %s and weight is %d kg!" % ('Zara', 21)

字符串函数

添加元素

list = []  # 空列表
list.append('Google')  # 使用 append() 添加元素
list.append('Runoob')
print list

删除元素

list1 = ['physics', 'chemistry', 1997, 2000]
print list1
del list1[2]
print "After deleting value at index 2 : "
print list1

列表操作

列表方法

删除字典

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
del dict['Name'];  # 删除键是'Name'的条目
dict.clear();  # 清空词典所有条目
del dict;  # 删除词典
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];

字典的函数

当前时间戳

import time
time.time()

格式化日期输出

import time
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
a = "Sat Mar 28 22:24:24 2016"
print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))

获取某个月日历：calendar

import calendar
cal = calendar.month(2016, 1)
print "以下输出2016年1月份的日历:"
print cal

当前日期和时间

import datetime
i = datetime.datetime.now()
print ("当前的日期和时间是 %s" % i)
print ("ISO格式的日期和时间是 %s" % i.isoformat() )
print ("当前的年份是 %s" %i.year)
print ("当前的月份是 %s" %i.month)
print ("当前的日期是 %s" %i.day)
print ("dd/mm/yyyy 格式是 %s/%s/%s" % (i.day, i.month, i.year) )
print ("当前小时是 %s" %i.hour)
print ("当前分钟是 %s" %i.minute)
print ("当前秒是 %s" %i.second)

不定长参数：*

lambda：匿名函数

def....

python模块搜索路径

获取用户输入

str = raw_input("请输入：")
print "你输入的内容是: ", str

input可以接收表达式

open参数

write要自己添加换行符

读取10个字符

重命名：os.rename

os.remove

os.mkdir os.chdir

os.getcwd

os.rmdir

open参数

file的方法

异常

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()
try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print "Error: 没有找到文件或读取文件失败"

用户自定义异常

os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：

序号	方法及描述
1	os.access(path, mode) 检验权限模式
2	os.chdir(path) 改变当前工作目录
3	os.chflags(path, flags) 设置路径的标记为数字标记。
4	os.chmod(path, mode) 更改权限
5	os.chown(path, uid, gid) 更改文件所有者
6	os.chroot(path) 改变当前进程的根目录
7	os.close(fd) 关闭文件描述符 fd
8	os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9	os.dup(fd) 复制文件描述符 fd
10	os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
11	os.fchdir(fd) 通过文件描述符改变当前工作目录
12	os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13	os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14	os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15	os.fdopen(fd[, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16	os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17	os.fstat(fd) 返回文件描述符fd的状态，像stat()。
18	os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，像 statvfs()
19	os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。
20	os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21	os.getcwd() 返回当前工作目录
22	os.getcwdu() 返回一个当前工作目录的Unicode对象
23	os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24	os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25	os.lchmod(path, mode) 修改连接文件权限
26	os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
27	os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
28	os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
29	os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30	os.lstat(path) 像stat(),但是没有软链接
31	os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32	os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
33	os.makedirs(path[, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34	os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35	os.mkdir(path[, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36	os.mkfifo(path[, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制)
37	os.mknod(filename[, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38	os.open(file, flags[, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
39	os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40	os.pathconf(path, name) 返回相关文件的系统配置信息。
41	os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42	os.popen(command[, mode[, bufsize]]) 从一个 command 打开一个管道
43	os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44	os.readlink(path) 返回软链接所指向的文件
45	os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46	os.removedirs(path) 递归删除目录。
47	os.rename(src, dst) 重命名文件或目录，从 src 到 dst
48	os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
49	os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50	os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51	os.stat_float_times([newvalue]) 决定stat_result是否以float对象显示时间戳
52	os.statvfs(path) 获取指定路径的文件系统统计信息
53	os.symlink(src, dst) 创建一个软链接
54	os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55	os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56	os.tempnam([dir[, prefix]]) 返回唯一的路径名用于创建临时文件。
57	os.tmpfile() 返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58	os.tmpnam() 为创建一个临时文件返回一个唯一的路径
59	os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
60	os.unlink(path) 删除文件路径
61	os.utime(path, times) 返回指定的path文件的访问和修改的时间。
62	os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。
63	os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度

python中怎么输入输出文件

1. 打开和关闭文件（open(), file(), close()）

有两种内建函数可以获取文件对象：open 和 file。他们的用法完全一样。下面只以 open() 为例子讲解。

fileObj = open(filename, access_mode='r', buffering=-1)

常用的模式如下表所示：

文件模式	解释
r	以只读方式打开
w	以写方式打开，文件不为空时清空文件；文件不存在时新建文件。
a	追加模式，没有则创建
r+, w+, a+	以读写模式打开，参见w, a
第三个参数不经常用到，标识访问文件的缓冲方式，0代表不缓冲，1代表缓冲一行，-1代表使用系统默认缓冲方式。只要使用系统默认就好。
一些例子：

f = open('/etc/passwd', 'r')
f1 = open('/etc/test', 'w')

使用完文件后，一定要记得关闭文件：

f.close()

2. 文件读入

2.1. file.read(size = -1)

读取从当前文件游标起 size 个字节的文件内容。如果 size = -1，则读取所有剩余字节。

f = open('/etc/passwd')
f.read(100)

2.2. file.readline(size=-1)

读取并返回一行（包括行结束符），或返回最大 size 个字符。

f.readline()
f.readline(1)

2.3. file.readlines(sizhint=0)

读取文件所有的行，并作为一个列表返回（包括行结束符），如果 sizhint > 0 则返回总和大约 sizhint 字节的行（具体由缓冲区大小决定）。

f.readlines()

3. 文件输出

3.1. file.write(str)

向文件中写入指定的字符串。

f = file('/root/test.py', 'w+')
f.write("print 'hello,world'")
f.read()
f.close()
file('/root/test.py', 'r').read()

3.2. file.writelines(seq)

向文件写入字符串序列 seq。seq 是任何返回字符串的可迭代对象。

f = file('/root/test.py', 'a+')
codelst = ['\n', 'import os\n', "os.popen('ls').read()\n"]
f.writelines(codelst)
f.close()
file('/root/test.py', 'r').read()

注意，文件写入的时候，不会自动加上换行符，必须手动加上。

如何用Python打开指定的某个文件夹？比如我要用Python打开D盘里的一个普通文件，该怎么做？

操作系统一般不允许程序直接操作磁盘文件的，文件在磁盘上的读写都是由操作系统提供的，文件操作包括创建、删除、修改权限、读取、写入等。要想实现对文件的操作就需要请求操作系统打开一个文件对象，然后通过操作系统提供的接口来实现对文件读写操作。读写文件是最常见的 I/O 操作，Python 内置相关 API 可以帮助我们快速的实现文件读写操作。

文件对象

Python 内置的 open() 函数可以用于打开指定文件，该函数会返回一个文件对象（该对象包含了当前文件拥有的属性信息，相当于文件句柄）。参数 file 为要创建或打开文件的文件名称，参数 mode 用于指定文件的打开模式（可选），参数 buffering 用于指定对文件做读写操作时是否使用缓冲区。在打开文件之后就可调用文件对象的属性和方法，完成对文件的读/写操作之后最后需要关闭该文件，通过文件对象的 close() 函数来实现即可。

打开模式

文件打开是可以指定其打开的模式，该参数通过 mode 来指定【默认模式为只读(r)】。选择不同的打开模式决定了后续可以对文件进行操作，如果使用 r 模式打开的文件则只能读取文件而无法修改文件内容。open() 提供了多种打开模式，下面列出了对应的打开模式和说明：

python的编写格式

读取键盘输入【raw_input( )或者input( )】

demo = raw_input('INPUT:');
print "content is", demo

打开或关闭文件

这里要用 Python 的内置函数 open()，然后创建一个 file 对象。

Python 打开文件的模式：

• r 以只读模式打开文件。
• w 以只写模式打开文件，且先把文件内容清空（truncate the file first）
• wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
• a 以添加模式打开文件，写文件的时候总是写到文件末尾，用 seek 也无用。打开的文件也是不能读的。
• r+ 以读写方式打开文件，文件可读可写，可写到文件的任何位置。
• w+ 和 r+ 不同的是，它会 truncate the file first。
• a+ 和 r+ 不同的是，它只能写到文件末尾。

一个文件被打开后，有一个 file 对象，可以得到有关该文件的各种信息：

• file.closed 返回 true 如果文件已被关闭，否则返回 false。
• file.mode 返回被打开文件的访问模式。
• file.name 返回文件的名称。
• file.softspace 如果用 print 输出后，必须跟一个空格符，则返回 false。否则返回 true。

举个例子

demo = open("MOMO.txt", "wb")
print u'是否关闭：', demo.closed
print u'访问模式:', demo.mode
print u'文件名称：', demo.name
print u'末尾是否加空格：', demo.softspace

Python其实很简单 第十五章 文件操作

在各种变量中保存的数据都是临时的，随着程序运行结束都会丢失。要做到数据长期有效，必须建立在磁盘中建立文件，将数据输入到文件中并保存。需要获取数据时需要打开文件读取。 而我们自己建立的程序都是应用程序，从本质上讲，应用程序是无法直接操作计算机的硬件的，譬如读写磁盘中文件，这就需要调用操作系统中的相应命令。接下来我们使用的 Python 内置函数 open()、write() 都是通过调用操作系统的相关命令才实现文件读写的，至于其中的细节，我们就不需要考虑了。

15.1 创建和打开文件

在 Python 中创建或打开文件，实际上是建立一个对象，该对象通过调用内置的 open() 函数创建或打开一个文件。

语法：

file_object = open(filename [, mode][, buffering])

参数说明如下：

• filename：file_name 变量是一个包含了你要访问的文件名称的字符串值；
• mode：mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
• Buffering：如果 buffering 的值被设为 0，就不会有寄存；如果 buffering 的值取 1，访问文件时会寄存行；如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小；如果取负值，寄存区的缓冲大小则为系统默认。

mode 参数的参数值及说明

对于其中最难区别的 r、r+、w、w+、a、a+ 几个参数的区别总结如下，要特别注意指针的位置： 下面举例说明 open() 函数的使用方法。

例1：

file = open('1.py')

如果文件“1.py”存在，则可以打开此文件；如果文件“1.py”不存在，则会出现如下提示：

Traceback (most recent call last):
File " ", line 1, in
file = open('1.py')
FileNotFoundError: [Errno 2] No such file or directory: '1.py'

例2：

file = open('4.py', 'a+')

虽然文件“4.py”不存在，但运行并未出现错误，参见上表，“a+”的含义是以读写模式打开文件，如果该文件已经存在，新内容将以追加方式写入；如果该文件不存在，则新建文件用于写入。查看文件夹，发现已经生成了一个新的文件 4.py。

例3：

file = open('python.png', 'rb')
print(file)

运行结果： 这就是说，虽然 Python 可以打开一个图片格式的文件，但 print() 并不能将其输出，还需要第三方库中模块的相应方法去处理，如 PIL 中的 open() 方法。

例4：

file = open("f.txt", "w", encoding='utf-8')
# 以只写模式打开文件 f.txt，编码方式为 utf-8
print("文件名: ", file.name)  # 输出文件名
print("是否已关闭 : ", file.closed)  # 文件是否打开
print("访问模式 : ", file.mode)  # 文件访问模式

运行结果：

文件名: f.txt
是否已关闭 : False
访问模式 : w

例5：

15.2 关闭文件

打开文件使用后要及时关闭，以免造成不必要的破坏，同时也可以释放内存。在 Python 中使用 close() 方法可以关闭文件。

语法格式：

file.close()

其中，file 为文件对象。

15.3 with 语句

with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等。

with 语句的语法格式如下：

with expression as target:
    with-body

其中，expression 用于指定一个表达式，譬如打开文件的 open() 函数。target 用于指定一个变量，并且将 expression 的结果保存到该变量中，譬如文件对象 file。with-body 用于指定 with 语句体，譬如一些文件操作的相关语句，如果没有要执行的语句体，则直接用 pass 语句代替。 假设 Python 当前目录下存在一个 test.txt 文件，其内容如下：

Python 是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于 PHP 和 Perl 语言。
Python 是交互式语言：这意味着，您可以在一个 Python 提示符 后直接执行代码。
Python 是面向对象语言: 这意味着 Python 支持面向对象的风格或代码封装在对象的编程技术。
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。

举例如下：

with open('test.txt', 'r', encoding='utf-8') as file:
    line = file.readline()  # readline() 方法可以读取文件一行数据，接下来就会讲到。
    print(line)

运行结果如下：

Python 是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于 PHP 和 Perl 语言。

而此时，我们给该段代码 with 语句之外再增加一个读取文件的语句，代码如下：

with open('test.txt', 'r', encoding='utf-8') as file:
    line = file.readline()
    print(line)
    line2 = file.readline()
    print(line2)

发现出现了如下错误提示：

Traceback (most recent call last):
File "C:/Users/zym/AppData/Local/Programs/Python/Python39/3.py", line 5, in
line2 = file.readline()
ValueError: I/O operation on closed file.

意思是要读取的文件已经被关闭了。 由此可知，当 with 语句运行结束后，被打开的 test.txt 文件就自动关闭了。

15.4 读取文件

在 Python 中读取文件的方法有：

1. 读取指定个数的字符

格式如下：

File.read([size])

其中，file 为打开的文件对象。size 为可选参数，可以指定要读取的字符个数，省缺表示读取所有内容。 在调用 read() 方法读取文件内容时，文件必须是以 r（只读）或者 r+（读写）方式打开。 如：

with open('test.txt', 'r', encoding='utf-8') as file:
    txt = file.read()  # 或 txt = file.read(10)
    print(txt)

将读取、输出 test.txt 文件的全部内容（或前 10 个字符）。

2. 移动文件的指针

对于刚打开的文件，文件指针总是指向文件头的。也可以通过 seek() 方法将文件的指针移动到新的位置。 格式如下：

file.seek(offset[, whence])

其中，file 表示已经打开的文件对象；offset 用于指定移动的字符个数；whence 表示从哪个位置起始计算个数，其值为 0 表示从文件头开始计算，其值为 1 表示从当前位置开始计算，其值为 2 表示从文件尾开始计算，默认值为 0。 例如：

with open('test.txt', 'r', encoding='utf-8') as file:
    string = file.read(9)
    print('取9个字符： ' + string)
    file.seek(2)  # 指针从文件头开始移动2个字符
    string = file.read(9)  # 从当前位置读取10个字符

输出结果：

取9个字符：
Python是一种
取9个字符：
thon是一种解释

而下面的代码会抛出错误：

with open('test.txt', 'r', encoding='utf-8') as file:
    file.seek(2, 1)  # 指针从当前位置开始移动2个字符
    string = file.read(10)  # 从当前位置读取10个字符
    print('取10个字符： ' + string)

错误提示为：

Traceback (most recent call last):
File "C:UserszymAppDataLocalProgramsPythonPython393.py", line 7, in
file.seek(2, 1)  # 指针从当前位置开始移动2个字符
io.UnsupportedOperation: can't do nonzero cur-relative seeks

原因在于，必须使用 b 模式（即 rb）打开文件，才能使用 whence 参数。但是，b 模式（二进制）不适合文本文件。对于 test.txt 这样的文本文件，为了解决通过改变指针读取任意位置字符，可以采用加一个位置变量的方法来存储指针的值。 例如：

with open('test.txt', 'r', encoding='utf-8') as file:
    # utf-8汉字与英文字符都占一个字符
    string = ''  # 设置一个空字符串
    pointer = 0  # 当前指针为0
    str1 = file.read(6)  # 读取6个字符
    pointer += 6  # 指针变量后移6个字符
    string += str1  # string 用来存放已读取的字符
    print('取6个字符： ', str1)
    file.seek(pointer)  # 指针从文件头开始移动2个字符
    str1 = file.read(8)  # 从当前位置读取10个字符
    pointer += 8  # 指针跳过已读取的字符
    string += str1
    print('再取8个字符： ', str1)
    print('所有读取的字符： ', string)
    print('当前指针所处的位置： ', pointer)
    str1 = file.read(1)
    print('当前指针所处的字符： ', str1)

运行结果如下：

取6个字符：
Python
再取8个字符：
是一种解释型语言
所有读取的字符：
Python是一种解释型语言
当前指针所处的位置：
14
当前指针所处的字符：
：

3. 读取一行数据 readline() 方法

语法格式：

file.readline()

例：

with open('test.txt', 'r', encoding='utf-8') as f:
    string = f.read(1)  # 读取文件的第一个字符
    if string != '':  # 防止文件为空文件
        lineno = 0
        while True:
            line = f.readline()
            if line != '':
                lineno += 1
                print('第' + str(lineno) + '行：' + line, end='')
                # 因为每行都有自带的分行符，print()语句不允许换行
            else:
                break  # 出现空行时停止读取
    else:
        print('要读取的文件为空文件！')

运行结果：

第1行：ython是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于 PHP 和 Perl 语言。
第2行：Python 是交互式语言：这意味着，您可以在一个 Python 提示符 后直接执行代码。
第3行：Python 是面向对象语言: 这意味着 Python 支持面向对象的风格或代码封装在对象的编程技术。
第4行：Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。

4. 读取全部行命令 readlines() 方法

语法格式：

File.readlines()

该方法与 read() 方法一样，在调用 read() 方法读取文件内容时，文件必须是以 r（只读）或者 r+（读写）方式打开。 例：

with open('test.txt', 'r', encoding='utf-8') as f:
    txt = f.readlines()
    print(txt)

运行结果：

['Python 是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于 PHP 和 Perl 语言。 ', 'Python 是交互式语言：这意味着，您可以在一个 Python 提示符 后直接执行代码。 ', 'Python 是面向对象语言: 这意味着 Python 支持面向对象的风格或代码封装在对象的编程技术。 ', 'Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。 ']

从上面的运行结果可以看出，readlines() 方法的返回值为一个字符串列表。所以，也可以以读取列表元素的方法输出。如下所示：

with open('test.txt', 'r', encoding='utf-8') as f:
    txt = f.readlines()
    for line in txt:
        print(line, end='')

运行结果：

Python 是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于 PHP 和 Perl 语言。
Python 是交互式语言：这意味着，您可以在一个 Python 提示符 后直接执行代码。
Python 是面向对象语言: 这意味着 Python 支持面向对象的风格或代码封装在对象的编程技术。
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。

15.5 写入文件内容

语法格式如下：

file.write(string)

其中，file 为打开的文件对象，string 为要写入的字符串。 写入文件内容时，文件必须以 w（可写）或 a（追加）模式打开。否则，会抛出如下异常提示：

Traceback (most recent call last):
File "C:UsersAdministratorAppDataLocalProgramsPythonPython383.py", line 2, in
f.write('人生苦短，我用Python！')
io.UnsupportedOperation: not writable

关于 write() 方法的用法举例如下：

with open('test.txt', 'a', encoding='utf-8') as f:
    f.write('人生苦短，我用Python！')
with open('test.txt', 'r', encoding='utf-8') as f:
    txt = f.read()
    print(txt)

运行结果：

Python 是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于 PHP 和 Perl 语言。
Python 是交互式语言：这意味着，您可以在一个 Python 提示符 后直接执行代码。
Python 是面向对象语言: 这意味着 Python 支持面向对象的风格或代码封装在对象的编程技术。
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发。
人生苦短，我用Python！

可以看出，由于文件的打开方式为 a 模式（追加模式），写入的内容被写入到文件的末尾。 在 Python 中，文件操作方法里没有类似于字符串内的计算长度、查找、替换、截取、分隔等方法，为什么没有？原因可能是文件的类型太复杂，譬如说二进制文件，上述操作的意义不大。如果仅仅要对文本