『无为则无心』Python基础 — 42、Python中文件的读写操作（二）

目录

• （5）文件对象方法（重点）
  • 1）写方法
  • 2）读方法
  • 3）seek()方法
  • 4）tell()方法
• （6）关闭
• （7）综合练习：读取大文件

（5）文件对象方法（重点）

1）写方法

@1.语法

对象对象.write('内容')

@2.示例

# 1. 打开文件
f = open('test.txt', 'w')

# 2.文件写入
f.write('hello world')

# 3. 关闭文件
# 只要控制台显示Process finished with exit code 0
# 证明进程已经结束，代码执行完成。
f.close()

注意：

1. w 和a模式：
   
   如果文件不存在则创建该文件；
   
   如果文件存在，w模式先清空再写入，a模式直接末尾追加。
2. r模式：如果文件不存在则报错。

@3.练习说明

"""
测试目标
1. 访问模式对文件的影响
2. 访问模式对write()的影响
3. 访问模式是否可以省略
"""

# 访问模式参数可以省略, 如果省略表示访问模式为r（只读）

"""
1.r-只读模式打开文件:
1.1如果文件不存在，报错。
1.2不支持写入操作，表示只读。
"""
# 如果文件不存在，报错
# 结果：FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'
f = open('test.txt', 'w')

# 文件存在，但不支持写入操作，表示只读。
f = open('test.txt', 'r')
# io.UnsupportedOperation: not writable
f.write('aa')
f.close()

"""
2.w-写入模式打开文件：
2.1如果文件不存在，新建文件
2.2执行写入，会覆盖原有内容
"""
# 文件存在则直接打开文件，文件不存在则创建该文件
f = open('1.txt', 'w')
# 写入内容直接覆盖原文件内容。
f.write('bbb')
f.close()

"""
3.a-添加模式打开文件：
3.1如果文件不存在，新建文件
3.2在文件原有内容基础上，追加新内容
"""
# 文件存在则直接打开文件，文件不存在则创建该文件
f = open('2.txt', 'a')
# 在文件原有内容基础上，追加新内容
f.write('xyz')
f.close()

"""
4.运行一次程序，write()方法会可以分多次向文件中写入内容
一次运行中，重复的调用write()向文件中写入内容，
不会进行覆盖。
单独调用两次，第二次的内容会覆盖第一次的内容。

`with...as...`写法看 <6、关闭>中有讲解
"""
file_name = 'demo.txt'

with open(file_name, 'w', encoding='utf-8') as file_obj:
    file_obj.write('aaa\n')
    file_obj.write('bbb\n')
    file_obj.write('ccc\n')
"""
文件内容：
aaa
bbb
ccc
"""

"""
5.write('内容')方法中的内容，只能是字符串，
如果向输入一个数值型，需要进行类型转换，否则会报错：
TypeError: write() argument must be str, not int
"""
# 代码片段如下：
file_obj.write(str(123))

"""
6.write()方法有返回值，
会返回写入的字符的个数
"""
# 代码片段如下：
r = file_obj.write('今天天气真不错')
print(r)  # 7

2）读方法

@1.read()方法

read()方法，用来读取文件中的内容，它会将内容全部保存为一个字符串返回。

文件对象.read(num)

num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据。

示例：

"""
文件内容如果有换行，底层是\n换行，会占用1个字节，
导致read()方法填写的参数与读取出来的数据不匹配.
"""
f = open('test.txt', 'r')

# read不写参数表示读取所有；
# print(f.read())
print(f.read(10))

f.close()

@2.readlines()方法

readlines()方法可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据（包括换行符）为一个元素。

f = open('test.txt')
content = f.readlines()

# ['hello world\n', 'abcdefg\n', 'aaa\n', 'bbb\n', 'ccc']
print(content)

# 关闭文件
f.close()

@3.readline()方法

readline()方法一次读取一行内容。

f = open('test.txt')  # 只读方式打开

# 第一次调用`readline( )`方法方法，即读取文件第一行内容
content = f.readline()
print(f'第一行：{content}')

# 第二次调用`readline( )`方法方法，即读取文件第二行内容
# 以此类推
content = f.readline()
print(f'第二行：{content}')

# 关闭文件
f.close()

"""
输出结果：
第一行：abcde

第二行：12345
"""

@4.for循环方式读取文件内容

# 定义文件名
file_name = 'demo.txt'

# 循环读取文件内容，变量t就文件内的一行内容
# 遍历一次，读取一行。
with open(file_name, encoding='utf-8') as file_obj:
    for t in file_obj:
        print(t)

@5.注意：

我们上边的练习都是以只读的方法打开文件，然后在读取数据。以只读的方式打开文件，光标默认是在文件的开头，所致使用read()等方法我们能看到读取的结果。

但是写入的方式打开文件如w，a：

• w：打开文件后，光标是在文件的开头，但是以w方式打开文件会自动清空文件数据，所以我们在调用读取方法，我们依然看不到任何数据。
• a：打开文件后，光标是在文件内容的末尾的，所以我们在调用读取方法，我们也依然会看不到任何数据。

3）seek()方法

打开文件后，文件指针的位置会影响读取文件的数据。

seek()方法的作用：用来移动文件指针。

语法如下：

文件对象.seek(偏移量, 起始位置)

起始位置：

• 0：文件开头
• 1：当前位置
• 2：文件结尾

示例：

"""
语法： 文件对象.seek(偏移量, 起始位置)
0开头 1当前 2结尾
偏移量:要切换到的位置
"""
# 示例1:r打开文件
# 改变读取数据开始位置
f = open('test.txt', 'r+')

# 1.改变读取数据开始位置,开头偏移两位
f.seek(2, 0)

# 2.文件指针放到内容结尾
# f.seek(0, 2)

# 读取文件
con = f.read()
print(con)
# 关闭文件
f.close()
"""
输出结果
cde
12345
abcde
abcde
"""

# 示例2:a打开文件
f = open('test.txt', 'a+')

# 文件指针放到文件开头
# 当参数为两个0的时候，可以简写成一个0
# 表示不偏移，起始位置是开头。
# f.seek(0, 0)
# f.seek(0)

# 读取文件
con = f.read()
print(con)
# 关闭文件
f.close()
"""
输出结果：
abcde
12345
abcde
abcde
"""

# 示例3.可以只写偏移量，
# 起始位置默认是0，开头
file_obj.seek(55)

# 从开头向后偏移80位
# file_obj.seek(80,0)
# 从当前位置向后偏移70位
# file_obj.seek(70,1)

# io.UnsupportedOperation: can't do nonzero end-relative seeks
# file_obj.seek(-10,2)

4）tell()方法

# tell() 方法用来查看当前读取的位置(光标的位置)

示例

with open('demo2.txt','rt' , encoding='utf-8') as file_obj:
    # print(file_obj.read(100))
    # print(file_obj.read(30))

    # seek() 可以修改当前读取的位置
    # 中文一个字符代表三个字节，截取两个字节打印就会报错
    file_obj.seek(9)
    # seek()需要两个参数
    #   第一个 是要切换到的位置
    #   第二个 计算位置方式
    #       可选值：
    #           0 从头计算，默认值
    #           1 从当前位置计算
    #           2 从最后位置开始计算

    print(file_obj.read())

    # tell() 方法用来查看当前读取的位置
    print('当前读取到了 -->',file_obj.tell())

（6）关闭

文件对象.close()

而我们在工作中对文件的标准处理格式为使用with...as...

# with ... as 语句用法
"""
#with open(file_name) as file_obj 和 file_obj = open(file_name) 是一样的
#open(file_name)的返回值赋值给了file_obj
with open(file_name) as file_obj :
    # 在with语句中可以直接使用file_obj来做文件操作
    # 此时这个文件只能在with中使用，一旦with结束则文件会自动close()
    print(file_obj.read())
"""

标准写法

# 确定文件名
file_name = 'hello'

try:
    # 打开文件
    with open(file_name) as file_obj :
        # 对文件进行处理
        print(file_obj.read())
except FileNotFoundError:
    # 文件不存在进行异常处理
    print(f'{file_name} 文件不存在~~')

（7）综合练习：读取大文件

需求：读取大文件

# 确定文件名
file_name = 'demo.txt'

try:
    # 调用open()方法来打开一个文件，可以将文件分成两种类型
    # 一种，是纯文本文件（使用utf-8等编码编写的文本文件）
    # 一种，是二进制文件（图片、mp3、ppt等这些文件）
    # open()方法打开文件时，默认是以文本文件的形式打开的，
    # 但是open()方法默认的编码为None，
    # 所以处理文本文件时，必须要指定文件的编码。
    with open(file_name,encoding='utf-8') as file_obj:
        # 通过 read() 来读取文件中的内容
        # 如果直接调用read()它会将文本文件的所有内容全部都读取出来，
        # 如果要读取的文件较大的话，会一次性将文件的内容加载到内存中，
        # 容易导致内存泄漏（溢出）。
        # 所以对于较大的文件，不要直接调用read()方法读取文件。
        #
        # read()可以接收一个size作为参数，
        # 该参数用来指定调用一次read()方法读取的字符的数量。
        # 默认值为-1，它会读取文件中的所有字符。
        # 可以为size指定一个值，这样read()方法会读取指定数量的字符，
        # 每一次读取都是从上次读取到位置开始读取的，
        # 如果字符的数量小于size，则会读取剩余所有的，
        # 如果已经读取到了文件的最后了，则会返回''空串，
        # content = file_obj.read(-1)
        content = file_obj.read(6)

        """
        这里可以换成上边循环的方法，读取内容，
        也可以换成其他的读取方法。

        # 定义一个变量，来指定每次读取的大小
        chunk = 100
        # 创建一个循环来读取文件内容
        while True:
            # 读取chunk大小的内容
            content = file_obj.read(chunk)

            # 检查是否读取到了内容
            # content 空串为false
            if not content:
                # 内容读取完毕，退出循环
                break

            # 输出内容
            # print(content,end='')
        """
except FileNotFoundError :
    print(f'{file_name} 这个文件不存在！')