在计算机的三层体系结构中，最上层是用户/应用程序，中间层是操作程序，最底层是计算机硬件（cpu/内存/硬盘）。我们位于用户/应用程序那一层，我们平时使用应用程序（eg 文本编辑器和python解释器）写入的内容（eg 变量）最开始存储在内存中，当我们点击保存时，内存中的文件被写入硬盘过程中，因为计算机识别不了字符，只能识别二进制数/八进制数/十六进制数，所以不管是我们在应用程序中书写的人类的字符还是我们在屏幕上看到的显示出来的字符，在存入内存/硬盘和从内存/硬盘中读出时，都涉及到将字符翻译成二进制数，即编码，和把二进制数翻译成字符，即解码。这是我们今天内容之一——字符编码。
文件是操作系统提供给用户操作计算机硬件的一种功能。实现不同功能也就产生了不同类型的文件。如果想永久保存数据，必须把代码/数据写入文件保存在文件中。这是我们内容之二——文件管理。
零. 引入
字符串类型、文本文件的内容都是由字符组成的，但凡是涉及到字符的存取，都需要考虑字符编码这个问题。
字符编码这个知识点的典型特征就是理论多、结论少，但对于开发而言只需要记住结论即可。
一. 字符编码
1.1 储备知识
-
软件运行前，软件的代码及其相关数据都是存放于硬盘中的
-
任何软件的启动都是将数据从硬盘中读入内存，然后cpu从内存中取出指令并执行
-
软件运行过程中产生的数据最先都是存放于内存中的，若想永久保存软件产生的数据，则需要将数据由内存写入硬盘
运行文本文件的三个步骤：
1. 启动一个文件编辑器（文本编辑器如nodepad++，pycharm，word）
2. 给操作系统发送系统调用，文件编辑器会将文件内容从硬盘读入内存
3. 文本编辑器会将刚刚读入内存中的内容显示到屏幕上
运行python程序的三个步骤：
1. 启动python解释器
2. 给操作系统发送系统调用，将文本文件从硬盘加载到内存中
3. python解释器从内存中读取文件，检查语法规范
总结：
python解释器与文本编辑器的异同如下：
1、相同点：前两个阶段二者完全一致，都是将硬盘中文件的内容读入内存，详解如下
python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样
2、不同点：在阶段3时，针对内存中读入的内容处理方式不同，详解如下
文本编辑器将文件内容读入内存后，是为了显示或者编辑，根本不去理会python的语法，而python解释器将文件内容读入内存后，可不是为了给你瞅一眼python代码写的啥，而是为了执行python代码、会识别python语法）
1.2 什么是字符编码
人类在于计算机交互时，用的都人类能读懂的字符，如英文字符、中文字符、日文字符等。而计算机只能识别二进制，详解如下：
二进制数即由0/1组成，例如010010101010。计算机是基于电工作的，电的特性即高低电平，人类从逻辑层面将高电平对应为数字1,低电平对应为数字0，这直接决定了计算机可以识别的是由0和1组成的数字。
毫无疑问，由人类的字符到计算中的数字，必须经历一个过程，如下：
文件中的字符————>字符编码表————>二进制数
# 翻译的过程必须参照一个特定的标准，该标准称为字符编码表，该表上存放的就是字符与数字的一一对应的关系。字符编码中的编码指的是翻译或者转换的意思，即将人能理解的字符翻译成计算机能识别的数字。
编码
文件中的字符<————字符编码表<————二进制数
解码
为了解决运行python程序的2，3阶段可能会出现的乱码问题，学习字符编码表十分重要。
1.3 字符编码表的发展史（了解）
阶段一：一家独大
ASCII码表：只能识别英文字符
8位二进制数bits/1bytes代表一个英文字符
阶段二：百家争鸣
GBK：识别中文和英文字符
16位二进制数bits/1bytes代表一个字符
shift-jis：识别日文和英文字符
......
文本文件内容全都为字符，无论存取都是涉及到字符编码问题
- 存文本文件
人类通过文本编辑器输入的字符会被转化成ASCII格式的二进制存放于内存中，如果需要永久保存，则直接将内存中的ASCII格式的二进制写入硬盘- 读文本文件
直接将硬盘中的ASCII格式的二进制读入内存，然后通过ASCII表反解成英文字符
阶段三：一统江湖
unicode：识别万国字符
16位二进制数bits/2bytes代表一个字符，不常见字符用4bytes代表。
特点：定长字符（不管任何字符都用2bytes代替）
utf-8：unicode的其中一种精简版本。
1bytes代表英文字符，3bytes代表中文字符
特点：变长字符
很多地方或老的系统、应用软件仍会采用各种各样传统的编码，这是历史遗留问题。此处需要强调：软件是存放于硬盘的，而运行软件是要将软件加载到内存的，面对硬盘中存放的各种传统编码的软件，想让我们的计算机能够将它们全都正常运行而不出现乱码，内存中必须有一种兼容万国的编码，并且该编码需要与其他编码有相对应的映射/转换关系，这就是unicode的第二大特点产生的缘由。
unicode的出现有两个历史使命。一.兼容万国字符。二.兼容各种字符编码表
1.4 在存储过程不同位置的存储格式
| cpu | 内存 | 硬盘 |
|---|---|---|
| 英文字符（阶段一） | ASCII格式的二进制 | ASCII格式的二进制 |
| 中文和英文字符（阶段二） | gbk格式的二进制 | gbk格式的二进制 |
| 万国字符（阶段三） | unicode格式的二进制 | utf-8格式的二进制 |
现在计算机中，万国字符都会以unicode存储在内存中，这不可更改。像python解释器和文本编辑器中，可以更改的编码格式是从内存存往硬盘的编码格式。
1.5 常见的文件乱码的两种原因及解决方法
1.文件中包含了指定字符编码不能识别的字符
eg.使用文本文件编写包含日文，中文和英文的内容。写入内存时计算机指定unicode编码，可以识别万国字符，不会出现问题。但是当写入硬盘时，由于windows默认使用gbk字符编码（linuxs和mac os默认utf-8字符编码），gbk可以识别中文和英文字符，但是无法识别日文字符，因此写入硬盘的瞬间文件中的日文字符无法被字符编码表中的内容匹配，计算机会随便匹配，这些日文书写的内容保存即丢失。
解决方法：保存文件时选用utf-8编码格式。已乱码的数据无法恢复。
2.读取文件的字符编码表与写文件的字符编码表不是同一张
eg.这种情况存入内盘和硬盘时都没有问题，数据也没有丢失。只是解码的时候，拿到的字符编码表与编码时候的字符编码表不是同一张。
解决方法：试错试出当时保存数据时选择的字符编码表。
1.6 python解释器默认读文件的编码
python3默认：utf-8
python2默认：ASCII
1.6.1 python解释器执行文件的前两个阶段
执行python文件的前两个阶段就是python解释器读文本文件的过程，与文本解释器读文本文件的前两个阶段没有任何区别，要保证不乱码，则必须将python解释器读文件时采用的编码方式设置为文件当初写入硬盘时的编码格式，如果没有设置，python解释器则采用默认的编码方式，python3采用utf-8，python2采用ASCII，我们可以通过指定文件头来修改默认的编码。
指定文件头修改默认的编码：
在python 文件的首行：
#coding:文件写入硬盘时的字符编码格式
这行代码管的是读文件的字符编码格式，存文件的字符编码格式是IDE控制的。
1.6.2 python解释器执行文件的第三个阶段
设置文件头的作用时保证运行python程序的前两个阶段不乱码，经过前两个阶段后python文件的内容都会以unicode格式存放于内存中。
在经历第三个阶段时开始识别python语法，当遇到特定的语法name='上'（代码本身也都全都是以unicode格式存储的）时，需要申请内存空间来存储字符串'上'，这就又涉及到应该以什么编码存储'上'的问题了。
在python3中，字符串类的值都是使用unicode格式来存储的。
由于python2的盛行要早于unicode的，因此在python2中是按照文件头指定的编码来存储字符串类型的值的（如果文件头中没有指定编码，那么解释器会按照它自己默认得编码方式来存储’上’），所以，这就可能导致乱码问题。
# coding:utf-8
x = '上' # x的值为untf-8格式的二进制
print(x) # 打印操作是将x的值，即utf-8格式的二进制交给终端，当终端收到后发现并不是unicode（只有unicode才与字符有对应关系），所以终端会执行操作：utf-8二进制---解码-->unicode格式的二进制，解码的过程终端会采用自己默认的编码，而在pycharm的终端默认编码为utf-8、windows下的cmd终端的默认编码为gbk，所以该打印操作在pycharm中显示正常，而在windows下的cmd中则乱码
# 在windows下的cmd中运行效果如下
C:\Users\Administrator>python2 E:\aaa.py
涓
python2后推出了一种补救措施，就是在字符串类型前加u，则会将字符串类型强制存储unicode，这就与pyhton3保持一致了，对于unicode格式无论丢给任何终端进行打印，都可以直接对应字符不会出现乱码问题。
# coding:utf-8
x = u'上' # 即便文件头为utf-8，x的值依然存成unicode
1.7 编码与解码
# 1、unicode格式------编码encode-------->其它编码格式
>>> x='上' # 在python3在'上'被存成unicode
>>> res=x.encode('utf-8')
>>> res,type(res) # unicode编码成了utf-8格式，而编码的结果为bytes类型，可以当作直接当作二进制去使用
(b'\xe4\xb8\x8a', <class 'bytes'>)
# 2、其它编码格式------解码decode-------->unicode格式
>>> res.decode('utf-8')
'上'
二. 文件管理
2.0 引入
应用程序运行过程中产生的数据最先存放于内存中，若想永久保存下来，必须要保存于硬盘中。应用程序若想操作硬件必须通过操作系统，而文件就是操作系统提供给应用程序来操作硬盘的虚拟概念，用户或应用程序对文件的操作，就是向操作系统发起调用，然后由操作系统完成对硬盘的具体操作。
2.1 基本操作
对于文件的操作无非就是打开文件，读取文件，写入文件，关闭文件四种基本操作。我们先进行打开文件，读取文件和关闭文件三种操作。写入文件稍后在2.3详解。
-
打开文件
先拿rt模式做示例：# 打开文件，由应用程序向操作系统发起系统调用open(...)，操作系统打开该文件，对应一块硬盘空间，并返回一个文件对象赋值给一个变量f f = open(r'文件路径',mode='rt',encoding='utf-8) # f得值是一种变量，占用的是应用程序的内存空间
文件路径分为相对路径和绝对路径。
相对路径是相对于当前文件所在文件夹进行搜索，搜索不到则报错。
绝对路径对于windows来说是从盘符开始的，对linux和mac来说是从\开始的。因为在python解释器中/和\可能有别的含义，有两个方法解决这个问题。方法一，在整个路径的字符串前加r，可以作为纯字符串被读取。方法二，重复一下\。而mode会在2.3详细解释。
-
读取文件
# 调用文件对象下的读/写方法，会被操作系统转换为读/写硬盘的操作 res=f.read() print(res) -
关闭文件
# 向操作系统发起关闭文件的请求，回收系统资源（但没有回收内存资源） f.close()
打开文件完成读/写操作后，需要关闭文件。
整个打开文件的过程是这样的：
当python中写下open代码，必须填写的参数有文件路径和mode。当运行这段代码的时候，python应用程序会像操 作系统发送请求，请求打开这个文件路径对应的硬盘上的硬盘空间，打开的模式就是指定的mode。然后操作系统根据具体的文件路径去硬盘空间上找到对应的空间，把空间里面的内容读入内存中，在操作系统中产生一个与文件名相同的文件，同时返回给应用程序一个文件对象f（类似遥控器）。
(open命令设计了两方面的资源，应用程序向操作系统发送请求，操作系统拿到请求后转换成对于硬盘的操作)
当执行read操作时，相当于按下了遥控器上的read按钮，马上对操作系统发送请求，具体的要求被操作系统转换成了具体操作对计算机硬件执行相对操作。当执行read操作的时候（点击了遥控器上的‘read’按钮），但是数据在硬盘和内存中是以不同编码格式的二进制的，需要把二进制翻译成字符串，而编码格式在open时已经指定了。
当执行close操作时，相当于点击了遥控器上的关机按钮，即对操作系统发送指令关闭操作系统打开的文件。而应用程序的文件对象（遥控器），没有对应的文件，即被内存回收机制回收。
2.2 上下文管理with
为了防止程序猿打开文件后忘记关闭，一直占用计算机内存中的资源。python解释器提供了一种更方便的语法。即上下文管理操作：
with open(r'a.txt',mode='rt',encoding='utf-8') as f:
f.read()
这样的语法在with后面缩进的代码块内容执行完后会自动关闭打开访问的文件，防止了内存的过度占用。
2.3 管理文件的模式
2.3.1 三种管理模式 r/w/a
对文件的基本操作无非就是读写。读只有一种模式，即只读。写有两种模式，分别为只写和只追加写。具体各种模式的差异可以看表。
| 模式 | 可以执行的操作 | 文件不存在时 | 文件存在时 |
|---|---|---|---|
| r模式 只读 | f.read(字符数),f.readlines(),f.readline() | 报错 | 打开文件并把指针移动到文件开头 |
| w模式 只写 | f.write(写入内容),f.writelines(可迭代数据) | 创建新文件 | 清空文件内容，将指针移到开头 |
| a模式 只追加写 | f.write(写入内容)，f.writelines(可迭代元素) | 创建新文件 | 打开文件，并把指针移到文件末尾 |
2.3.1.1 r模式的使用
# r只读模式: 在文件不存在时则报错,文件存在文件内指针直接跳到文件开头
with open('a.txt',mode='r',encoding='utf-8') as f:
res=f.read() # 会将文件的内容由硬盘全部读入内存，赋值给res
# 小练习：实现用户认证功能
inp_name=input('请输入你的名字: ').strip()
inp_pwd=input('请输入你的密码: ').strip()
with open(r'db.txt',mode='r',encoding='utf-8') as f:
for line in f:
# 把用户输入的名字与密码与读出内容做比对
u,p=line.strip('\n').split(':')
if inp_name == u and inp_pwd == p:
print('登录成功')
break
else:
print('账号名或者密码错误')
2.3.1.2 w模式的使用
# w只写模式: 在文件不存在时会创建空文档,文件存在会清空文件,文件指针跑到文件开头
with open('b.txt',mode='w',encoding='utf-8') as f:
f.write('你好\n')
f.write('我好\n')
f.write('大家好\n')
f.write('111\n222\n333\n')
#强调：
# 1 在文件不关闭的情况下,连续的写入，后写的内容一定跟在前写内容的后面
# 2 如果重新以w模式打开文件，则会清空文件内容
2.3.1.3 a模式的使用
# a只追加写模式: 在文件不存在时会创建空文档,文件存在会将文件指针直接移动到文件末尾
with open('c.txt',mode='a',encoding='utf-8') as f:
f.write('44444\n')
f.write('55555\n')
#强调 w 模式与 a 模式的异同：
# 1 相同点：在打开的文件不关闭的情况下，连续的写入，新写的内容总会跟在前写的内容之后
# 2 不同点：以 a 模式重新打开文件，不会清空原文件内容，会将文件指针直接移动到文件末尾，新写的内容永远写在最后
# 小练习：实现注册功能:
name=input('username>>>: ').strip()
pwd=input('password>>>: ').strip()
with open('db1.txt',mode='a',encoding='utf-8') as f:
info='%s:%s\n' %(name,pwd)
f.write(info)
案例：写一个文本文件copy工具
with open(r'a.txt',mode='rt',encoding='utf-8') as f1:
res=f1.read()
with open(r'a.txt',mode='wt',encoding='utf-8') as f2:
f2.write(res)
但如果文本文件过大时可能会出现运行速度缓慢的情况，因此也可以一行一行读入或者每次控制读入的数据字符数：
with open(r'a.txt',mode='rt',encoding='utf-8') as f1,\
open(r'b.txt',mode='wt',encoding='utf-8') as f2:
for line in f1:
f2.write(line)
2.3.2 管理内容的两种模式 t/b
在学习t模式和b模式之前，首先要了解一下什么是bytes类型数据。
字符数据在内存中是以字符串形式呈现在屏幕上的，但是在内存和硬盘上都是以二进制数形式存在的，但是存放在不同位置的二进制数
可能会有不同的格式。根据前面字符编码的知识，内存中的二进制数是以unicode格式编码的，而硬盘中的二进制数是以utf-8格式和其他
老字符编码格式存在的。在unicode中，一个常用字符是两个字节，在utf-8中，一个英文字符是一个字节，一个中文字符是三个字节。
因此，在t模式下，读操作是按照字符为单位读出的，而b模式下，读操作是以字节为单位的，当读一个字节时，可以读出一个英文字符，
读三个字节时才能读出一个中文字符。
t模式和b模式不是独立存在的，他们需要与r/w/a模式联用。
| 模式 | 读写单位 | 特点 |
|---|---|---|
| t模式 | 字符 | 1.针对文本文件 2.必须指定encoding |
| b模式 | 字节 | 1.针对任何文件 2.不能指定encoding |
| 模式组合 | 含义 | 可执行的操作 |
|---|---|---|
| rt | 以只读方式打开文件，读取单位是字符。读出来的内容和文件的内容一模一样，eg egon:123 | f.read(字符数),f.readlines(),f.readline() |
| rb | 以只读方式打开文件，读取单位是字节byte。读出来的内容和文件的内容一模一样，但是前面有b，且文字内容写在‘’内，eg b’egon:123\r\n’。当读入内容不足一个中文字符的三个字节时，会显示十六进制数 | f.read(字节数),f.readlines(),f.readline() |
| wt | 以只写模式打开文件，写入的单位是字符 | f.write(写入内容),f.writelines(可迭代数据) |
| wb | 以只写模式打开文件，写入的单位是字节 | f.write('中文字符'.encode('utf-8')),f.writelines(b'英文字符') |
| at | 以只追加写模式打开文件，写入的单位是字符 | f.write(写入内容),f.writelines(可迭代数据) |
| wb | 以只写模式打开文件，写入的单位是字节 | f.write('中文字符'.encode('utf-8')),f.writelines(b'英文字符') |
2.3.2.1 t模式
# t 模式：如果我们指定的文件打开模式为r/w/a，其实默认就是rt/wt/at
with open('a.txt',mode='rt',encoding='utf-8') as f:
res=f.read()
print(type(res)) # 输出结果为：<class 'str'>
with open('a.txt',mode='wt',encoding='utf-8') as f:
s='abc'
f.write(s) # 写入的也必须是字符串类型
#强调：t 模式只能用于操作文本文件,无论读写，都应该以字符串为单位，而存取硬盘本质都是二进制的形式，当指定 t 模式时，内部帮我们做了编码与解码
2.3.2.2 b模式
b模式才是操作文件最基本的方式，因为它显示文件中数据的格式才是真正数据存储在硬盘中的方式。而t模式只是方便操作文本文件的最基本格式。
# b: 读写都是以二进制位单位
with open('1.mp4',mode='rb') as f:
data=f.read()
print(type(data)) # 输出结果为：<class 'bytes'>
with open('a.txt',mode='wb') as f:
msg="你好"
res=msg.encode('utf-8') # res为bytes类型
f.write(res) # 在b模式下写入文件的只能是bytes类型
#强调：b模式对比t模式
1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码，所以此时t模式更为方便
2、针对非文本文件（如图片、视频、音频等）只能使用b模式
# 小练习： 编写拷贝工具
src_file=input('源文件路径: ').strip()
dst_file=input('目标文件路径: ').strip()
with open(r'%s' %src_file,mode='rb') as read_f,open(r'%s' %dst_file,mode='wb') as write_f:
for line in read_f:
# print(line)
write_f.write(line)
循环读取文件
# 方式一：while 循环，自己控制每次读取的数据的数据量。
with open(文件,mode='rb') as f:
while True:
res=f.read(1024)
if len(res) == 0:
break
# 方式二：for 循环，以行为单位读，当一行内容过长时导致一次性读入内容的数据量过大
with open(文件,mode='rb') as f:
for line in f:
print(line)
可能会存在单行文件字符数量过多的情况，因此，选择方式一要更为合适。
得到bytes类型的三种方式：
-
字符串编码之后的结果
'上'.encode('utf-8') bytes('上',encoding='utf-8') -
b''转换的必须是纯英文字符 -
b模式下打开文件，
f.read()读出的内容
2.4 对文件操作的进一步讲解
在t模式下以下三种读操作读出来的是字符，可以指定字符个数。在b模式下读出来的是字节，如果是windows系统，需要在读出来的内容后面加.decode('gbk')，如果是linux/mac os需要在读出来的内容后面加.decode('utf-8')来获取原来写入的内容。
f.read()
如果括号没有任何指定，则默认读出所有数据。括号内可以指定字符/字节个数。f.readlines()
和f.read()没有什么区别，一次性读出所有数据。将读出的内容按行划分放入一个列表中。f.readline()
每次只读一行，碰到换行符即停止读入。
在t模式写写入数据时只需要将需要写入字符放入括号内，在b模式下写入数据时有两种方法。方法一：‘中文字符/英文字符’.encode('utf-8')。方法二：b‘英文字符’
f.write()f.writelines(可迭代元素)
除此之外，如果是需要立刻检查或者数据十分重要的情况下，需要立即写入的话：
f.flush
2.5 指针的移动
指针和光标不是一样的概念。可以理解成打印文件时的操作，我们在完成文件修改后，光标可能位于文件末尾，但当我们执行文件打印操作时，指针位于文件开头，将文件所有内容都打印出来了，而不是从末尾开始打印。
控制文件指针移动的三种模式：
f.seek(移动指针步数,指针模式)
-
0模式
从文件起始位置/开头开始移动指针。# a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节） abc你好 # 0模式的使用 with open('a.txt',mode='rt',encoding='utf-8') as f: f.seek(3,0) # 参照文件开头移动了3个字节 print(f.tell()) # 查看当前文件指针距离文件开头的位置，输出结果为3 print(f.read()) # 从第3个字节的位置读到文件末尾，输出结果为：你好 # 注意：由于在t模式下，会将读取的内容自动解码，所以必须保证读取的内容是一个完整中文数据，否则解码失败 with open('a.txt',mode='rb') as f: f.seek(6,0) print(f.read().decode('utf-8')) #输出结果为: 好 -
1模式
从指针当前位置开始移动。# 1模式的使用 with open('a.txt',mode='rb') as f: f.seek(3,1) # 从当前位置往后移动3个字节，而此时的当前位置就是文件开头 print(f.tell()) # 输出结果为：3 f.seek(4,1) # 从当前位置往后移动4个字节，而此时的当前位置为3 print(f.tell()) # 输出结果为：7 -
2模式
从文件末尾开始移动指针。# a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节） abc你好 # 2模式的使用 with open('a.txt',mode='rb') as f: f.seek(0,2) # 参照文件末尾移动0个字节， 即直接跳到文件末尾 print(f.tell()) # 输出结果为：9 f.seek(-3,2) # 参照文件末尾往前移动了3个字节 print(f.read().decode('utf-8')) # 输出结果为：好 # 小练习：实现动态查看最新一条日志的效果 import time with open('access.log',mode='rb') as f: f.seek(0,2) while True: line=f.readline() if len(line) == 0: # 没有内容 time.sleep(0.5) else: print(line.decode('utf-8'),end='')
在学习了文件指针后，我们可以写一个对于文件的动态监测程序，监测新写入文件的内容。
需求分析：不停读目标文件的最后一行，如果发现写入了新的内容，则在这边输出出来。
src_file=input('您想要监测的文件路径： ').strip()
with open(r'src_file',mode='rt',encoding='utf-8'):
f.seek(0,2)
while True:
res=f.read()
if len(res)==0:
...
else:
print(res)
2.6 文件的修改
我们在对文本文件进行修改时，发现是可以在字符之间插入某些其他字符的，但是在我们尝试在文件内移动指针想要写入新的数据时，发现新写入的内容覆盖了原文件的内容。这是为什么呢？
原因是这样的，当我们对文本文件进行操作时，只是在内存中修改字符（实际上内存中存储的是字符对应的unicode格式的二进制数。但由于编码和转码过快，让我们以为我们写入的字符就是以字符的形式存在于内存中的），并没有保存到硬盘中。内存中的数据可以随便修改，而硬盘中数据是只能覆盖的，不能在磁道上插入数据。所以当在python解释器中，执行完写入操作时，发现文件原位置的数据被覆盖掉了。
因此对于文件的修改有两种方式，如下：
方式一：耗内存节省硬盘
1.先将全部数据读入内存
2.在内存中完成修改
3.修改后的文件全部覆盖原文件
with open('a.txt',mode='rt',encoding='utf-8') as f:
data=f.read()
with open('a.txt',mode='wt',encoding='utf-8') as f1:
f1.write(data.调相应字符串操作完成需要的功能)
方式二：耗硬盘节约内存
1.以读的方式打开原文件，然后以写的方式打开一个临时文件
2.读原文件中每一行数据，完成修改后写入新文件，直到循环读完所有行的数据
3.删除原文件，将临时文件命名为原文件
import os
with open(r'a.txt',mode='rt',encoding='utf-8') as f,\
open(r'a.txt.copy',mode='wt',encoding='utf-8') as f1:
for line in f:
data=line.调相应字符串操作完成需要的功能
f1.write(data)
os.remove('a.txt')
os.rename('a.txt.copy','a.txt')
扫一扫
485
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
