python：文件处理之TXT

文件读写

1、读写文件是最常见的IO操作。Python内置了读写文件的函数，用法和C是兼容的

2、读写文件前，我们先必须了解一下：在磁盘上读写文件的功能都是由操作系统提供的，现代操作系统不允许普通的程序直接操作磁盘
    ⑴所以，读写文件就是请求操作系统打开一个文件对象(通常称为文件描述符)
    ⑵然后，通过操作系统提供的接口从这个文件对象中读取数据(读文件)，或者把数据写入这个文件对象(写文件)

3、这里说的文件并不是专指TXT文件，而是任意后缀名的文件。如sql文件(.sql)、json(.json)文件、Xml(.xml)文件等等

获取文件对象

1、前面介绍了：读写文件就是请求操作系统打开一个文件对象，然后通过接口操作这个文件对象进行读写操作

2、在python内置函数中提供了open()函数来获取一个文件对象
    ⑴其基本语法如下：open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)

3、open()函数参数说明：
    ⑴file: 必填参数，所要操作的文件的绝对路径或相对路径(包括文件名)
    ⑵mode: 默认参数，mode决定了打开文件的模式：只读，写入，追加等，默认文件访问模式为只读(r)
    ⑶buffering: 设置缓冲
    ⑷encoding: 设置返回字符串编码，一般使用utf-8
    ⑸errors: 报错级别
    ⑹newline: 区分换行符
    ⑺closefd: 传入的file参数类型

4、open()函数返回值：
    ⑴正常找到参数文件时：其返回值是一个文件对象(File)
    ⑵未找到参数文件时：触发FileNotFoundError异常

5、Python中一切皆对象：这里的文件对象就像我们熟悉的列表和字典等数据类型一样(都是对象)
    ⑴一个对象就会存在自己的属性、方法：文件对象的属性、方法后面介绍

例1：正常找到文件时

file = open("F:\\data.txt")

print(file)
print(type(file))

"""
<_io.TextIOWrapper name='F:\\data.txt' mode='r' encoding='cp936'>
 # 可以看到open()函数返回的是一个对象
"""

例1_1：未找到文件时

file = open("F:\\data1.txt")

print(file)

"""
FileNotFoundError: [Errno 2] No such file or directory: 'F:\\data1.txt'
"""

打开文件模式

1、文件模式表示：我们能对打开的文件(文件对象)做哪些操作，操作以什么形式进行

2、当open()函数只传入必填参数(文件路径)时，默认打开的文件模式为只读(r)

3、对于一个文件对象，还支持以下模式，即参数mode值

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。如果该文件不存在则触发FileNotFoundError异常
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入
r+	打开一个文件用于读写。文件指针将会放在文件的开头。如果该文件不存在则触发FileNotFoundError异常
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。如果该文件不存在则触发FileNotFoundError异常
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。如果该文件不存在则触发FileNotFoundError异常
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写

注：
1、b代表以二进制形式，+表示可读可写模式，b与+可以与其他三种模式组合使用(r表示读，w表示写，a表示加)

2、如果目标文件存在时，明确指定读模式和什么模式都不指定都是一样的

3、如果目标文件不存在时，最好指定"w+"模式(打开的文件不存在时使用w+：表示先创建再打开)

4、需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字

例2：

"""
以读写模式打开一个文件：可读、可写
    文件存在时正常返回文件对象
    文件不存在时，先创建文件，在返回文件对象
"""
file = open("F:\\data1.txt",mode='w+')
print(file)

"""
<_io.TextIOWrapper name='F:\\data1.txt' mode='w+' encoding='cp936'>
"""

文件操作

1、对于一个文件对象(open函数返回值)来说，其操作主要就两个：读、写

2、Python提供了不同方式的读、写操作，我们可以根据实际需要进行不同方式的读写

读操作

1、对于文件的读操作来说，Python提供了三种方式的读：
    ⑴read()：读取指定字符数(按字符数读取内容)
    ⑵readline()：读取指定行数(按行数读取内容)
    ⑶readlines()：按行数读取全部内容

2、以下例子基本上都基于下面内容

 read()函数

1、read()方法从一个打开的文件中读取指定字符数(按字符数读取内容)，其返回值为字符串
    ⑴该函数传入参数时：表示读取指定数的内容
    ⑵该函数未传入参数时：表示读取整个文件(一次性读取整个文件：一次性全部返回)

2、语法：fileObject.read([count])
    ⑴fileObject：为open()函数返回的File对象
    ⑵count参数：要从已打开文件中读取的字节计数
        ①从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾

例3：读取部分内容

# 打开文件时最好指明文件打开编码(UTF-8),避免乱码
file = open("F:\\data.txt",mode='r',encoding="UTF-8")

# 读取部分字符：传入read()方法参数
content = file.read(10)
print(content)

# 混沌未分天地乱，茫茫

例3_1：读取全部内容

# 打开文件时最好指明文件打开编码(UTF-8),避免乱码
file = open("F:\\data.txt",mode='r',encoding="UTF-8")

# 读取全部字符：不传入read()方法参数
allContent = file.read()
print(allContent)
print(type(allContent))

"""
混沌未分天地乱，茫茫渺渺无人见。
自从盘古破鸿蒙，开辟从兹清浊辨。
覆载群生仰至仁，发明万物皆成善。
欲知造化会元功，须看西游释厄传

"""

注：
1、如果read()函数后面带了参数时，就只会读取指定的字节数(空格和符号也算)

2、若没有指定参数时，就会读取文件中的全部字符串(全部内容)

例3_2：

file = open("F:\\data.txt",mode='r',encoding="UTF-8")

while True:
    content = file.read(1)# 指定每次只读取一个字符
    if content:
        print(content)
    else:
        break
# 或
while True:
    str = file.read(1)  
    if not str:
        break
    print(str)
    
"""
1、循环读取文件中的一个字符，无字符时跳出循环
    当读取完最后一个字符后，read()函数返回的是空字符串，表示False
    if not...的意思为not后面的条件为假(即：not...整个为True)时才会执行该语句
    if后面的条件为真True时才执行if语句块，not表示相反，因此只有not后面为Flase时，整个not...才为True
2、之所以能实现这种循环是因为：在同一次打开的文件中，第一次读取部分后，下一次读取是从上一次读取结束的位置开始的(这就是文件的指针)
"""

readline()函数

1、作用：readline方法会从文件中读取指定行数的内容，以换行符(\n)为结束点，其返回值为字符串
    ⑴readline方法如果返回一个空字符串，说明已经读取到了最后一行

2、readline()方法也可以像read()方法一样：
    ⑴不传入参数：读取第一行
    ⑵传入参数且参数为正整数：读取对应字符数的内容
    ⑶传入参数且参数为负数：读取第一行

3、语法：file.readline([size])

例4：

file = open("F:\\data.txt",mode='r',encoding="UTF-8")

# 无参数时：读取第一行
content = file.readline()
print(content)

# 混沌未分天地乱，茫茫渺渺无人见。

例4_1：
file = open("F:\\data.txt",mode='r',encoding="UTF-8")

# 有参数且参数为正整数：读取指定字符数内容
content = file.readline(10)
print(content)

# 混沌未分天地乱，茫茫

例4_2：

file = open("F:\\Pycharm_project\\text\\test_1.txt","r")

while True:
    file_each_line = file.readline()
    if file_each_line != "":
        print(file_each_line)
    else:
        break

#之所以能实现这种循环是因为：在同一次打开的文件中，第一次读取部分后，下一次读取是从上一次读取结束的位置开始的(文件的指针)

"""
file = open("F:\\Pycharm_project\\text\\test_1.txt","r")

while True:
    file_each_line = file.readline()
    print(file_each_line)

    if not file_each_line:#file_each_line为空时为False
        break

#if not...的意思为not后面的条件为假时才会执行该语句(not file_each_line为真时才会执行)
#if后面的条件为真True时才执行if语句块，not表示相反，因此只有not后面为Flase时，整个not...才为True
#依次输出文件中的每一行，无内容时跳出循环
"""

readlines()函数

1、作用：readlines方法会从文件中按行读取全部内容，其返回值为一个列表
    ⑴列表中的每个元素就是文件中的每一行，换行符也会被输出

2、readlines方法可以传入参数
    ⑴未传入参数时：按行读取全部内容
    ⑶有参数值且值小于行长度时：该行被读取
    ⑷当传入小于等于0的数值时：按行读取全部内容

3、语法如下：file.readlines([sizeint])

例5：

# 打开文件时最好指明文件打开编码(UTF-8),避免乱码
file = open("F:\\data.txt",mode='r',encoding="UTF-8")

# 无参数时：按行读取全部内容
content = file.readlines()
print(content)

# ['混沌未分天地乱，茫茫渺渺无人见。\n', '自从盘古破鸿蒙，开辟从兹清浊辨。\n', '覆载群生仰至仁，发明万物皆成善。\n', '欲知造化会元功，须看西游释厄传']

例5_1：

file = open("F:\\data.txt",mode='r',encoding="UTF-8")

# 有参数值且值小于行长度时：该行被读取
content = file.readlines(16)
print(content)

# ['混沌未分天地乱，茫茫渺渺无人见。\n']

例5_2：

# 打开文件时最好指明文件打开编码(UTF-8),避免乱码
file = open("F:\\data.txt",mode='r',encoding="UTF-8")

# 有参数值且值为0或负数：按行读取全部内容
content = file.readlines(-1)
print(content)

# ['混沌未分天地乱，茫茫渺渺无人见。\n', '自从盘古破鸿蒙，开辟从兹清浊辨。\n', '覆载群生仰至仁，发明万物皆成善。\n', '欲知造化会元功，须看西游释厄传']

# 遍历列表
for i in content:
    print(i)

"""
混沌未分天地乱，茫茫渺渺无人见。

自从盘古破鸿蒙，开辟从兹清浊辨。

覆载群生仰至仁，发明万物皆成善。

欲知造化会元功，须看西游释厄传
"""

写操作

1、前面介绍了文件的读操作：
    ⑴按字符读取全部、部分内容
    ⑵按行读取全部、部分内容

2、对应的写操作也是：可以按字符数写入，也可以按列表写入

write()函数

1、write()方法可将任何字符串写入一个打开的文件
    ⑴需要注意的是，Python字符串可以是二进制数据，而不是仅仅是文字
    ⑵文件存在时，直接返回对应的文件对象；若文件不存在时则会先创建文件再返回对应的文件对象

2、write()方法不会在字符串的结尾添加换行符('\n')，因此换行符需要我们自己添加到字符串中

3、在文件写入时，文件有两种打开模式：w模式和a模式
    ⑴w模式：从开头开始编辑，即原有内容会被删除
    ⑵a模式：新的内容将会被写入到已有内容之后

4、其语法如下：fileObject.write(string)

例6：

# 文件中已存在内容、W模式打开：覆盖原来内容，写入新内容
file = open("F:\\data.txt",mode='w',encoding="UTF-8")

content = """感盘古开辟，三皇治世，五帝定伦，世界之间，遂分为四大部洲：曰东胜神洲，曰西牛贺洲，曰南赡部洲，曰北俱芦洲。\n
这部书单表东胜神洲。海外有一国土，名曰傲来国。\n
国近大海，海中有一座山，唤为花果山。\n
此山乃十洲之祖脉，三岛之来龙，自开清浊而立，鸿蒙判后而成"""
# 将字符串整体写入文件
file.write(content)

例6_1：

# 文件中已存在内容、A模式打开：在原有内容后新增
file = open("F:\\data.txt",mode='a',encoding="UTF-8")

content = """感盘古开辟，三皇治世，五帝定伦，世界之间，遂分为四大部洲：曰东胜神洲，曰西牛贺洲，曰南赡部洲，曰北俱芦洲。\n
这部书单表东胜神洲。海外有一国土，名曰傲来国。\n
国近大海，海中有一座山，唤为花果山。\n
此山乃十洲之祖脉，三岛之来龙，自开清浊而立，鸿蒙判后而成"""
# 将字符串整体写入文件
file.write(content)

注：
1、只打开一次文件时不能同时进行读和写操作(即使用了a+模式)，若要同时进行读写操作时，需要在执行一项后再次打开文件并执行下一项

2、使用w(写)模式时，在写入字符串时会覆盖文件内已有的内容；若不想覆盖已有的内容则可以使用a(加)模式

3、如果打开的文件不存在，w模式和a模式就会创建一个新的空文件，然后执行写入或追加

4、在python中，用\n表示换行，若需要追加的内容在下一行，可以使用\n的方法

5、若需要读写特定编码方式的文本，则需要给open()函数传入encoding参数
    ⑴如需要读取GBK编码的文件时，则前面示例可以改为encoding = "gbk"

writelines()函数

1、该函数接受任意一个可迭代对象参数(如列表等序列)，表示将对象中的内容写入文件

2、writelines方法与readlines方法相反，传给他一个字符串列表(任何序列或可迭代对象)，它会把所有字符串写入文件

3、语法如下：fileObject.writelines()

例8：

# 文件中已存在内容、A模式打开：在原有内容后新增
file = open("F:\\data.txt",mode='a',encoding="UTF-8")

content1 = ["混沌未分天地乱，","茫茫渺渺无人见。\n","自从盘古破鸿蒙，","开辟从兹清浊辨。\n","覆载群生仰至仁，","发明万物皆成善。\n"]
content2 = ("须看西游释厄传，","须看西游释厄传。\n")
content3 = """\n感盘古开辟，三皇治世，五帝定伦，世界之间，遂分为四大部洲：曰东胜神洲，曰西牛贺洲，曰南赡部洲，曰北俱芦洲"""

file.writelines(content1)  #按列表写入
file.writelines(content2)  #按元组写入
file.writelines(content3)  #按字符串写入

关闭文件

1、不管是对文件进行读操作还是写操作，在操作完文件后都需要对文件进行关闭操作
    ⑴特别是文件写操作，只有进行关闭文件操作后，才能保证写入的内容正常被保存

2、当我们写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入
    ⑴只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘
    ⑵忘记调用close()的后果是数据可能只写了一部分到磁盘，剩下的丢失了

3、由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用
    ⑴所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现

4、其语法如下：fileObject.close()

例9：

# 读文件时关闭文件
file = None
try:
    file = open("F:\\data.txt",encoding="utf-8")
    print(file.readline())
except:
    raise FileNotFoundError("未找到对应文件")
finally:
        file.close()

例9_1：

# 写文件时关闭文件
file = None
try:
    content = "势镇汪洋，威宁瑶海。势镇汪洋，潮涌银山鱼入穴"
    file = open("F:\\data.txt",mode="a",encoding="utf-8")
    file.write(content)
except:
    raise FileNotFoundError("未找到对应文件")
finally:
        file.close()

其他打开文件方式

1、前面介绍了使用open()函数来打开一个文件：在使用open()函数打开文件时在操作完文件后必须使用close()方法来关闭文件
    ⑴这样每次都必须手动去调用close()方法，就会显得很麻烦

2、python中引入了with语句自动帮我们调用close()方法。这样就不需要我们再手动去调用close()方法了

例10：

# 读取文件
with open("F:\\data.txt",mode="r",encoding="utf-8") as file:
    content = file.read()
    print(content)

"""
1、实际还是使用的是open()函数来打开文件，但结合了with...as...
    变量file：表示open()函数的返回值，文件对象
2、这种写法就不需要我们手动调用close()方法来关闭文件了
"""

例10_1：

# 写文件
with open("F:\\data.txt",mode="w",encoding="utf-8") as file:
    content = "威宁瑶海，波翻雪浪蜃离渊。木火方隅高积上，东海之处耸崇巅。丹崖怪石，削壁奇峰"
    file.write(content)

文件迭代器

1、从python2.2版本开始后，文件对象是可迭代的，这意味着可以直接在for循环中使用文件对象，从而进行迭代

2、对一个文件对象进行遍历，每次遍历出其每一行(跟前面的readlines()方法差不多)

例11：

with open("F:\\data.txt",mode="r",encoding="utf-8") as file:
    for eachLine in file:
        print(eachLine)

"""
混沌未分天地乱，茫茫渺渺无人见。
自从盘古破鸿蒙，开辟从兹清浊辨。
覆载群生仰至仁，发明万物皆成善。
欲知造化会元功，须看西游释厄传。
"""

例11_1：

with open("F:\\data.txt",mode="r",encoding="utf-8") as file:
    content = file.readlines()
    print(content)
    for i in content:
        print(i)

"""
['混沌未分天地乱，茫茫渺渺无人见。\n', '自从盘古破鸿蒙，开辟从兹清浊辨。\n', '覆载群生仰至仁，发明万物皆成善。\n', '欲知造化会元功，须看西游释厄传。']
混沌未分天地乱，茫茫渺渺无人见。
自从盘古破鸿蒙，开辟从兹清浊辨。
覆载群生仰至仁，发明万物皆成善。
欲知造化会元功，须看西游释厄传。
"""

文件对象的属性

1、Python一切皆对象：一个对象就会有自己的方法或属性。前面介绍了文件对象的方法，这里介绍下文件对象的属性

2、以下是和file对象相关的所有属性的列表：

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

例12：

file = open("F:\\python\\test_file.txt","r")
print(file.closed)
print(file.mode)
print(file.name)

"""
False
r
F:\python\test_file.txt
"""

文件的读取和定位

1、我们先来看一个例子

例13：

with open("F:\\data.txt",mode="r",encoding="utf-8") as file:
    content1 = file.read(5)
    print("第一次读取文件内容：",content1)
    content2 = file.read(7)
    print("第二次读取文件内容：",content2)


"""
原文：混沌未分天地乱，茫茫渺渺无人见。
输出：
第一次读取文件内容： 混沌未分天
第二次读取文件内容： 地乱，茫茫渺渺
"""

注：
1、从上面例子可以看出：在同一次打开文件，进行多次读取文件内容时，后一次读取的内容的开始是基于上一次读取的结束位置的
    ⑴那程序是怎么知道第二次该从内容哪个位置开始读呢？

2、这就是这里要说明的一个概念：
    ⑴文件对象中的每个字符都是有位置的(这个位置可以叫做"文件指针位置")，文件对象可以根据当前指针的位置开始读取。这就有了tell()方法和seek()方法
    ⑵位置是按字节算的

3、tell()方法：告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后
4、seek(offset [,from])方法：改变当前文件指针的位置。
    ⑴Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置
        ①如果from被设为0，这意味着将文件的开头作为移动字节的参考位置
        ②如果设为1，则使用当前的位置作为参考位置
        ③如果它被设为2，那么该文件的末尾将作为参考位置
    ⑵该方法可以让我们从文件内容任意位置开始读取并读取到任意位置(就不需要从开始读到结束了)
        ①不过试了下，并不能在指定偏移量处写文件(可以使用其他方法)

例13_1：

with open("F:\\data.txt",mode="r",encoding="utf-8") as file:
    content1 = file.read(5)
    print("第一次读取文件内容：", content1)
    print("此时文件指针的位置：",file.tell())
    # 移动指针位置,注意偏移量必须是字节数的整数倍
    file.seek(18,0)
    # 相当于跳过1个中文字符，继续读7个字符
    content2 = file.read(7)
    print("第二次读取文件内容：",content2)

"""
原文：混沌未分天地乱，茫茫渺渺无人见。
输出：
第一次读取文件内容： 混沌未分天
此时文件指针的位置： 15
第二次读取文件内容： 乱，茫茫渺渺无
"""

例13_2：

# 先读取文件内容：
    # 只打开一次文件时不能同时进行读和写操作(即使用了a+模式)，
    # 若要同时进行读写操作时，需要在执行一项后再次打开文件并执行下一项
with open("F:\\data.txt",mode="r",encoding="utf-8") as file:
    content =file.read()

# 修改文件内容后再写入文件
with open("F:\\data.txt",mode="w",encoding="utf-8") as file1:
    contentList = list(content)
    contentList.insert(4,"自从盘古破鸿蒙，开辟从兹清浊辨.")
    string = "".join(contentList)
    file1.write(str(string))

"""
在Python中，字符串是不可变的，而列表是可变的。
字符串无法直接删除、插入字符串之间的特定字符，
所以将字符串转变为列表，就可以实现对字符串中特定字符的操作。
"""

注：
1、文件指针相当于一个"书签"，起到定位的作用

2、在UTF-8编码中：
    ⑴一个中文等于三个字节，中文标点占三个字节
    ⑵一个英文字符等于一个字节，英文标点占一个字节；
    ⑷一个数字符号等于一个字节

3、在Unicode编码：
    ⑴一个中文(含繁体)等于两个字节，中文标点占两个字节
    ⑵一个英文等于两个字节，英文标点占一个字节
    ⑷一个数字符号等于一个字节

 

拓展

循环遍历多个文件中的内容

例14：

import os,fileinput

path = str(input("请输入文件路径："))

#获取指定文件夹下的文件,返回一个由文件绝对路径组成的列表
def get_file(path):
    File_List = []
    File_Dir = os.listdir(path)
    for File in File_Dir:
        Get_File_path = path + "\\" + File
        if os.path.isfile(Get_File_path) == True:
            File_List.append(Get_File_path)


        elif os.path.isdir(Get_File_path) == True:
                print(Get_File_path + "为文件夹，无法读取内容")
    return File_List
    #return如果属于for循环代码块时，就只会迭代出第一个元素(与break差不多)

#读取所有文件中的内容
def get_each_line(File_List):
    for each_path in File_List:
        print("当前处理的文件名为：",each_path)
        file = open(each_path,"r",encoding='utf-8')
        for each_line in file:
            print(each_line)
        close_file(file)

def close_file(file):
    file.close()


File_List = get_file(path)
file = get_each_line(File_List)

 

统计文件中某个字或单词出现的次数

1、collections模块包含除内置list,dict,tuple 以外的其它容器数据类型。counter作为一个容器，可以跟踪相同的值增加了多少次。

2、counter支持三种形式的初始化，用counter的构造函数时可以提供一个元素序列或者一个包含键和计数的字典，还可以使用关键字参数将字符串名映射到计数。

例15：

import collections

file = open("F:\\python\\test_file.txt","r")

world = file.read().split('\n')  #以换行符切片标准

m = collections.Counter(world)

print (world)
print (m)
print (m['lovetutu'])#字符a出现的次数

"""
['大家知道', '中国这些，', '你说什么', 'lovetutu', 'lovetutu']
Counter({'lovetutu': 2, '大家知道': 1, '中国这些，': 1, '你说什么': 1})
2
"""

 

文件重命名

1、python的OS模块提供了rename方法，即文件重命名

2、rename()方法语法格式如下：

os.rename(src, dst)
参数
src -- 修改前的名称，若文件不在当前目录，则文件需要带上绝对路径
dst -- 修改后的名称
返回值
该方法没有返回值

例16：

def Change_File_Name(path):
    count = 1
    file_list = os.listdir(path)  #获取路径下的文件或文件夹，返回类型为列表
    for file in file_list:
        old_name = path + "\\" + file
        if os.path.isfile(old_name) == True: #如果为文件才执行改名
            new_name = path + "\\" + "test_" + str(count) + ".txt"
            os.rename(old_name, new_name)
            count += 1
        elif os.path.isdir( old_name) == True:
            print("此为文件夹")

Change_File_Name(path)

fileinput模块

fileinput模块可以对一个或多个文件中的内容进行迭代、遍历等操作。该模块的input()函数有点类似文件readlines()方法，区别在于前者是一个迭代对象，需要用for循环迭代，后者是一次性读取所有行。用fileinput对文件进行循环遍历，格式化输出，查找、替换等操作，非常方便

【默认格式】
fileinput.input (files='filename', inplace=False, backup='', bufsize=0, mode='r', openhook=None)

files	文件的路径列表，默认是stdin方式，多文S件['1.txt','2.txt',...]
inplace	是否将标准输出的结果写回文件，默认不取代
backup	备份文件的扩展名，只指定扩展名，如.bak。如果该文件的备份文件已存在，则会自动覆盖
bufsize	缓冲区大小，默认为0，如果文件很大，可以修改此参数，一般默认即可
mode	读写模式，默认为只读
openhook	该钩子用于控制打开的所有文件，比如说编码方式等

【常用函数】

fileinput.input()	返回能够用于for循环遍历的对象
fileinput.filename()	返回当前文件的名称
fileinput.lineno()	返回当前已经读取的行的数量（或者序号）
fileinput.filelineno()	返回当前读取的行的行号
fileinput.isfirstline()	检查当前行是否是文件的第一行
fileinput.isstdin()	判断最后一行是否从stdin中读取
fileinput.close()	关闭队列

在打开文件时可以设置文件打开方式的编码

import requests
import codecs

def get_url(url,cookie):
    response = requests.get(url=url,cookies=cookie)
    response.encoding = "utf-8"
    response_txt = response.text
    print(response_txt)
    return response_txt

def write_html_to_txt(file_path):
    with codecs.open(file_path,"w",encoding='utf-8') as html_file:   #设置编码
        html_file.write(response_txt)
        return html_file

if __name__ == "__main__":
    aims_url = "https://blog.csdn.net/qq_39314932"
    cookie_value = None
    response_txt = get_url(aims_url,cookie_value)
    html_file = write_html_to_txt(".\\HTML_txt.txt")
    

#file = open("",encoding="utf-8")也可以使用这种

2、读取指定文件夹下的TXT文件、在指定目录下生成TXT文件

import os
import datetime,time

class GetSourceFile():
    """获取源文件类，path为源文件夹路径"""
    def __init__(self,path):
        self.path = path
    #获取待翻译文件：指定目录下的所有TXT文件
    def get_source_file(self):
        if os.path.exists(self.path) == True:
            for each_file in os.listdir(self.path):
                if each_file.endswith(".txt") == True:#判断文件类型是否为TXT
                    txt_path = self.path + os.path.sep + each_file
                    #print(txt_path)
                    with open(txt_path,encoding="utf-8") as file:
                        """
                        for each_line in file:
                            print(each_line)
                        """
                        each_line = file.readlines()
                        return each_line
        else:
            print("文件路径错误")

class GreatLogFile():
    """在该脚本路径下生成结果文件路径"""
    def get_log_path(self):
        script_path,file_name= os.path.split(os.path.realpath(__file__))
        dir_path = script_path + os.path.sep + "translation_result"#根据脚本路径拼接出结果路径
        log_file_name = str(datetime.datetime.now().year) + "_" + str(datetime.datetime.now().month) + "_" \
                        + str(datetime.datetime.now().day) + ".txt"#根据时间生成文件名
        if os.path.exists(dir_path) == True:
            translation_txt_path = dir_path + os.path.sep + log_file_name
            return translation_txt_path,dir_path
        else:
            os.mkdir(dir_path)
            translation_txt_path = dir_path + os.path.sep + log_file_name
            return translation_txt_path,dir_path

    #将结果写入指定txt
    def write_result_to_txt(self,result):
        translation_txt_path,dir_path = self.get_log_path()
        with open(translation_txt_path,"a",encoding="utf-8") as result_txt:
            result_txt.writelines(result)


if __name__ == "__main__":

    #脚本测试代码
    source_file = GetSourceFile("F:\\")
    file = source_file.get_source_file()
    for i in file:
        result_path = GreatLogFile()
        translation_txt_path,dir_path = result_path.get_log_path()
        log_file = open(translation_txt_path, "a")
        result_path.write_result_to_txt(i)