第7章 文件及其应用
7.2 文本文件的操作
📖 本节导读
在上一节（7.1）中，我们学习了文件的基本知识，包括文件的概念、文件的类型（文本文件和二进制文件）、文件名、文件路径，以及文件的打开与关闭操作。我们知道了文件操作的”三步流程”：打开文件 → 读/写文件 → 关闭文件，并且详细学习了第一步（open() 函数）和第三步（close() 方法）。
本节我们将深入学习这”三步流程”中最核心的第二步——如何对文本文件进行读操作和写操作。这是文件操作中最重要的部分，也是我们日常编程中最常用的文件处理技能。
本节内容安排： - 7.2.1 文本文件写操作：学习如何将数据从程序写入到文本文件中 - 7.2.2 文本文件读操作：学习如何从文本文件中读取数据到程序中
💡 知识串联回忆： 在第2章”简单程序设计”中，我们学习了 print() 函数将数据输出到屏幕，以及 input() 函数从键盘读取数据。本节我们要学习的文件写操作和读操作，本质上就是把 print() 的”目的地”从屏幕换成文件，把 input() 的”来源”从键盘换成文件。理解了这个类比，文件读写操作就很容易掌握了。
7.2.1 文本文件写操作
一、文本文件的概念（回顾与深化）
在7.1.1节中，我们已经初步了解了文本文件的概念。现在，在我们正式学习文本文件的写操作之前，让我们先对文本文件做一个更深入的理解。
1. 什么是文本文件
文本文件是以字符编码（如 ASCII、UTF-8、GBK 等）形式存储数据的文件。在文本文件中，每一个字节（或几个字节）对应一个可读的字符，我们可以直接用文本编辑器（如记事本、VS Code、Jupyter Notebook 等）打开并阅读其中的内容。
文本文件的核心特征： - 存储的是字符（文字、数字、符号等），而不是二进制数据 - 使用字符编码将字符转换为字节进行存储 - 可以用任何文本编辑器直接打开阅读 - 文件中的内容对人类来说是可读的
💡 知识串联回忆： 回忆第2章”字符串类型及其处理”中，我们学习了字符串（str）类型。字符串就是由字符组成的序列，而文本文件中存储的内容本质上就是一串字符。因此，向文本文件写入数据，实际上就是将字符串写入文件。这就是为什么文本文件的写操作方法 write() 只接受字符串类型的参数。
2. 文本文件中的编码
在写入文本文件时，编码是一个非常重要的概念。不同的编码方式决定了字符如何被转换为字节存储到文件中。
编码方式 | 说明 | 支持中文 | 常用场景 |
UTF-8 | 可变长Unicode编码，全球通用 | 支持（推荐） | 国际化项目、网页、Python默认推荐 |
GBK | 中文国标编码 | 支持 | 中文Windows系统默认 |
ASCII | 美国标准信息交换码 | 不支持 | 英文环境 |
GB2312 | 简体中文编码 | 支持（汉字较少） | 早期中文系统 |
⚠️ 重要提醒： 在 Python 中打开文件时，强烈建议始终指定 encoding="utf-8"。这样可以确保中文内容被正确编码和解码，避免出现乱码问题。在之前的7.1节中，我们所有的文件操作示例都使用了 encoding="utf-8"，请大家养成这个好习惯。
3. 文本文件中的换行符
在向文本文件写入多行内容时，我们需要使用换行符来分隔不同的行。
换行符 | 说明 | 适用系统 |
\n | 换行（Line Feed，LF） | Linux、Mac、Python通用 |
\r\n | 回车+换行（CRLF） | Windows系统 |
💡 实用知识： Python 在处理文本文件时会自动处理换行符的转换。当我们在 Python 中使用 \n 写入换行时，Python 会根据操作系统自动进行转换。因此，在 Python 代码中统一使用 \n 即可，不需要关心操作系统的差异。
二、文本文件写操作的方法——write()
1. write() 方法的基本语法
文本文件的写操作通过文件对象的 write() 方法来实现。write() 是文件对象的内置方法，它的语法格式如下：
语法解析：
组成部分 | 说明 | 示例 |
文件变量名 | 通过 open() 函数获得的文件对象 | f、file_obj、fw 等 |
. | 成员访问运算符，用于调用对象的方法 | — |
write | 方法名，表示”写入” | — |
(字符串对象) | 参数，要写入文件的内容，必须是字符串类型 | "Hello"、"重庆CK学校\n" |
返回值：write() 方法会返回一个整数，表示成功写入的字符个数。
💡 知识串联回忆： 回忆第2章”数据类型与变量”中，我们学习了 int（整型）、float（浮点型）、str（字符串型）、bool（布尔型）等数据类型。write() 方法的返回值就是一个 int 类型的整数，表示写入的字符数。我们可以用一个变量来接收这个返回值，也可以忽略它。
2. write() 方法的作用
write() 方法的作用是：将参数中指定的字符串对象的内容写入到文件变量所指向的文件中。
具体来说： - write() 方法会将字符串中的每一个字符按照指定的编码方式（如 UTF-8）转换为字节，然后写入到文件中 - 写入的位置从当前文件指针的位置开始（回忆7.1.2节中提到的文件指针概念） - 写入完成后，文件指针会自动移动到写入内容之后的位置 - write() 方法不会自动添加换行符，如果需要换行，需要手动在字符串末尾添加 \n
💡 关键理解：write() 方法就像是一支”笔”，它把字符串的内容”写”到文件这个”纸”上。但和我们在纸上写字不同，write() 不会自动换行——如果你不写 \n，所有内容都会连在一起。
3. write() 方法的基本使用示例
让我们通过一个最简单的示例来学习 write() 方法的基本用法：
# ===== write()方法的基本使用 =====# 第一步：以写入模式打开文件# 回忆7.1.2节：open()函数的"w"模式会创建新文件或清空已有文件f = open("ck_hello.txt", "w", encoding="utf-8")# 第二步：使用write()方法写入字符串# 注意：write()的参数必须是字符串类型result1 = f.write("Hello, CK学校！\n")print(f"第一次write()写入了 {result1} 个字符")result2 = f.write("欢迎学习Python文件操作！\n")print(f"第二次write()写入了 {result2} 个字符")result3 = f.write("文本文件写操作是文件操作的基础。\n")print(f"第三次write()写入了 {result3} 个字符")# 第三步：关闭文件# 回忆7.1.2节：close()方法释放系统资源f.close()print("\n文件写入完成！")
运行结果：
第一次write()写入了 12 个字符第二次write()写入了 18 个字符第三次write()写入了 16 个字符
文件写入完成！
💡 知识说明： 从上面的运行结果可以看到，write() 方法返回的是写入的字符个数（不是字节数）。例如 "Hello, CK学校！\n" 包含12个字符（包括 \n 换行符算1个字符）。注意，在 UTF-8 编码下，一个中文字符在文件中占3个字节，但 write() 返回的是字符数而非字节数。
4. 验证写入结果
写入完成后，我们可以通过读取文件来验证写入的内容是否正确：
# ===== 验证写入结果 =====# 以只读模式打开文件f = open("ck_hello.txt", "r", encoding="utf-8")# 读取全部内容content = f.read()# 关闭文件f.close()# 打印文件内容print("文件 ck_hello.txt 的内容如下：")print("-" * 40)print(content)print("-" * 40)
运行结果：
文件 ck_hello.txt 的内容如下：----------------------------------------Hello, CK学校！欢迎学习Python文件操作！文本文件写操作是文件操作的基础。----------------------------------------
三、write() 方法的注意事项
注意事项一：write() 只接受字符串类型
这是 write() 方法最重要的注意事项：write() 方法的参数必须是字符串（str）类型。如果传入其他类型的数据（如整数、浮点数、列表、字典等），Python 会抛出 TypeError 异常。
【错误演示】
# ===== 错误演示：向write()传入非字符串类型 =====f = open("ck_error_demo.txt", "w", encoding="utf-8")# 尝试写入整数 —— 会报错！f.write(123)
---------------------------------------------------------------------------TypeErrorTraceback (most recent call last)in3 f = open("ck_error_demo.txt", "w", encoding="utf-8")4 5 # 尝试写入整数 —— 会报错！----> 6 f.write(123)TypeError: write() argument must be str, not int
💡 知识串联回忆： 回忆第3章”复杂分支程序设计”中，我们学习了 try-except 异常处理。上面的 TypeError 就是一种异常。在实际编程中，我们可以使用 try-except 来捕获并处理这种错误。
【正确做法：使用 str() 进行类型转换】
如果需要将非字符串类型的数据写入文件，必须先使用 str() 函数将其转换为字符串：
# ===== 正确做法：使用str()转换类型后写入 =====f = open("ck_type_convert.txt", "w", encoding="utf-8")# 回忆第2章：str()函数将其他类型转换为字符串# 写入整数num = 2025f.write(str(num) + "\n") # 将整数转为字符串后写入print(f"写入整数 {num}，转换后为 '{str(num)}'")# 写入浮点数pi = 3.14159f.write(str(pi) + "\n") # 将浮点数转为字符串后写入print(f"写入浮点数 {pi}，转换后为 '{str(pi)}'")# 写入布尔值flag = Truef.write(str(flag) + "\n") # 将布尔值转为字符串后写入print(f"写入布尔值 {flag}，转换后为 '{str(flag)}'")# 写入列表scores = [92, 85, 78, 95, 63]f.write(str(scores) + "\n") # 将列表转为字符串后写入print(f"写入列表 {scores}，转换后为 '{str(scores)}'")# 写入字典student = {"name": "张三", "score": 92}f.write(str(student) + "\n") # 将字典转为字符串后写入print(f"写入字典 {student}，转换后为 '{str(student)}'")f.close()print("\n所有数据写入完成！")
运行结果：
写入整数 2025，转换后为 '2025'写入浮点数 3.14159，转换后为 '3.14159'写入布尔值 True，转换后为 'True'写入列表 [92, 85, 78, 95, 63]，转换后为 '[92, 85, 78, 95, 63]'写入字典 {'name': '张三', 'score': 92}，转换后为 "{'name': '张三', 'score': 92}"所有数据写入完成！
💡 知识串联回忆： 上面的代码中用到了 str() 函数，这是我们在第2章”5个常用内置函数”中学过的。str() 可以将整数、浮点数、布尔值等类型转换为字符串。此外，代码中还用到了字符串的 + 运算符进行拼接（回忆第2章”字符串类型及其处理”）。
【更优雅的做法：使用 f-string 格式化】
在实际编程中，我们更推荐使用 f-string（格式化字符串字面量）来将各种类型的数据组合成字符串后再写入文件：
# ===== 使用f-string格式化后写入文件 =====f = open("ck_fstring_demo.txt", "w", encoding="utf-8")# 回忆第2章：f-string格式化字符串# f-string可以方便地将各种类型的数据嵌入到字符串中name = "张三"age = 20score = 92.5passed = True# 使用f-string直接将变量嵌入字符串f.write(f"姓名：{name}\n")f.write(f"年龄：{age}\n")f.write(f"成绩：{score}\n")f.write(f"是否及格：{passed}\n")# f-string还支持格式控制# 回忆第2章：格式化字符串的格式控制f.write(f"成绩保留两位小数：{score:.2f}\n")f.write(f"年龄占8个字符宽度：{age:>8}\n")f.close()# 验证写入结果f = open("ck_fstring_demo.txt", "r", encoding="utf-8")print(f.read())f.close()
运行结果：
姓名：张三年龄：20成绩：92.5是否及格：True成绩保留两位小数：92.50年龄占8个字符宽度：20
💡 知识串联回忆：f-string 是我们在第2章”数据输入输出”中学过的重要知识点。它使用大括号 {} 来嵌入变量和表达式，支持丰富的格式控制（如 :.2f 保留两位小数、:>8 右对齐占8个字符宽度等）。在文件写操作中，f-string 是构建写入内容的首选方式。
注意事项二：write() 不会自动添加换行符
write() 方法不会自动在写入内容的末尾添加换行符。这意味着，如果你连续调用多次 write() 而不在字符串中包含 \n，所有内容会连在一起。
【对比演示】
# ===== write()不自动换行的对比演示 =====# --- 情况1：不添加换行符 ---f1 = open("ck_no_newline.txt", "w", encoding="utf-8")f1.write("重庆")f1.write("CK学校")f1.write("数字经济专业")f1.close()f1 = open("ck_no_newline.txt", "r", encoding="utf-8")print("不添加换行符的结果：")print(f1.read())f1.close()print("-" * 40)# --- 情况2：添加换行符 ---f2 = open("ck_with_newline.txt", "w", encoding="utf-8")f2.write("重庆\n")f2.write("CK学校\n")f2.write("数字经济专业\n")f2.close()f2 = open("ck_with_newline.txt", "r", encoding="utf-8")print("添加换行符的结果：")print(f2.read())f2.close()
运行结果：
不添加换行符的结果：重庆CK学校数字经济专业----------------------------------------添加换行符的结果：重庆CK学校数字经济专业
💡 对比理解： 从上面的对比可以清楚地看到，如果不手动添加 \n，三次 write() 的内容会全部连成一行。因此，在每次 write() 写入一行内容后，记得在字符串末尾加上 \n。
💡 知识串联回忆： 这和 print() 函数的行为不同。回忆第2章学过的 print() 函数，它默认会在输出内容后面自动添加一个换行符（即 end='\n'）。但 write() 方法没有这个默认行为，需要我们手动添加。
注意事项三：使用 “w” 模式会清空原有内容
我们在7.1.2节中已经学习过，"w" 模式会清空文件中的原有内容。这里再次强调，因为这是初学者最容易犯的错误之一。
【错误场景演示】
# ===== "w"模式清空文件的演示 =====# 第一次写入f = open("ck_important.txt", "w", encoding="utf-8")f.write("第一条重要数据：CK学校2025年招生计划\n")f.write("第二条重要数据：数字经济专业课程安排\n")f.write("第三条重要数据：期末考试时间表\n")f.close()print("第一次写入完成，文件内容：")f = open("ck_important.txt", "r", encoding="utf-8")print(f.read())f.close()print("=" * 50)# 第二次以"w"模式打开同一个文件 —— 原有内容全部被清空！f = open("ck_important.txt", "w", encoding="utf-8")f.write("新的内容覆盖了之前所有的重要数据！\n")f.close()print("第二次以'w'模式写入后，文件内容：")f = open("ck_important.txt", "r", encoding="utf-8")print(f.read())f.close()
运行结果：
第一次写入完成，文件内容：第一条重要数据：CK学校2025年招生计划第二条重要数据：数字经济专业课程安排第三条重要数据：期末考试时间表==================================================第二次以'w'模式写入后，文件内容：新的内容覆盖了之前所有的重要数据！
⚠️ 重要警告： 可以看到，第二次以 "w" 模式打开文件后，之前写入的三条重要数据全部消失了！在实际编程中，如果你需要保留原有内容并在后面添加新内容，应该使用 "a"（追加）模式，而不是 "w" 模式。
【正确做法：需要追加时使用 “a” 模式】
# ===== 使用"a"模式追加内容 =====# 先写入初始内容f = open("ck_append_demo.txt", "w", encoding="utf-8")f.write("=== CK学校活动记录 ===\n")f.write("2025-03-01 新学期开学\n")f.close()# 使用"a"模式追加新内容（不会清空原有内容）f = open("ck_append_demo.txt", "a", encoding="utf-8")f.write("2025-04-15 Python期中考试\n")f.write("2025-05-05 学习文件操作\n")f.close()# 验证：原有内容 + 新追加的内容f = open("ck_append_demo.txt", "r", encoding="utf-8")print(f.read())f.close()
运行结果：
=== CK学校活动记录 ===2025-03-01 新学期开学2025-04-15 Python期中考试2025-05-05 学习文件操作
注意事项四：write() 写入的是字符，不是字节
当以文本模式（不带 "b"）打开文件时，write() 方法写入的是字符，Python 会自动根据指定的编码方式（如 UTF-8）将字符转换为字节后存储到文件中。我们不需要手动进行编码转换。
# ===== write()写入字符的编码演示 =====f = open("ck_encoding_demo.txt", "w", encoding="utf-8")# 写入中文（Python自动将中文字符编码为UTF-8字节）f.write("重庆CK学校\n")# 写入英文f.write("Chongqing CK School\n")# 写入特殊符号f.write("★ ☆ ♠ ♣ ♥ ♦\n")# 写入数字字符串f.write("2025年5月5日\n")f.close()# 验证文件大小（了解编码后的字节数）import ossize = os.path.getsize("ck_encoding_demo.txt")print(f"文件大小：{size} 字节")# 读取并显示内容f = open("ck_encoding_demo.txt", "r", encoding="utf-8")print("文件内容：")print(f.read())f.close()
运行结果：
文件大小：72 字节文件内容：重庆CK学校Chongqing CK School★ ☆ ♠ ♣ ♥ ♦2025年5月5日
💡 知识说明： 上面的文件大小为72字节。其中”重庆CK学校”6个中文字符在 UTF-8 编码下每个占3字节，共18字节；“Chongqing CK School”19个英文字符每个占1字节，共19字节（加上换行符1字节=20字节）；特殊符号行和日期行类似。Python 自动帮我们完成了字符到字节的编码转换。
四、文本文件写操作的完整程序示例
示例一：CK 学校学生成绩单生成器
这个示例综合运用了 write() 方法、f-string 格式化、for 循环、if-elif-else 分支等知识，生成一份格式化的成绩单文件。
# ===== 示例一：CK学校学生成绩单生成器 =====def generate_score_report(): """生成CK学校Python课程成绩单""" # 学生数据（使用列表存储字典） # 回忆第5章：列表和字典的组合使用 students = [ {"id": "2025001", "name": "张三", "daily": 88, "midterm": 82, "final": 91}, {"id": "2025002", "name": "李四", "daily": 92, "midterm": 88, "final": 85}, {"id": "2025003", "name": "王五", "daily": 75, "midterm": 70, "final": 78}, {"id": "2025004", "name": "赵六", "daily": 95, "midterm": 93, "final": 98}, {"id": "2025005", "name": "钱七", "daily": 60, "midterm": 55, "final": 50}, {"id": "2025006", "name": "孙八", "daily": 80, "midterm": 76, "final": 83}, ] # 打开文件（使用"w"模式创建新文件） # 回忆7.1.2节：open()函数和文件打开模式 f = open("ck_score_report.txt", "w", encoding="utf-8") # 写入文件标题 # 回忆第2章：字符串的乘法操作 f.write("=" * 60 + "\n") f.write(" CK学校 数字经济专业\n") f.write(" Python基础及应用 课程成绩单\n") f.write("=" * 60 + "\n") f.write("\n") # 写入表头 # 回忆第2章：f-string格式化字符串的对齐控制 # < 表示左对齐，> 表示右对齐，数字表示字段宽度 header = f"{'学号':<12}{'姓名':<8}{'平时分':<10}{'期中分':<10}{'期末分':<10}{'总评':<8}{'等级':<6}\n" f.write(header) f.write("-" * 60 + "\n") # 逐个写入学生成绩 # 回忆第4章：for循环遍历列表 total_daily = 0 # 平时分总和 total_midterm = 0 # 期中分总和 total_final = 0 # 期末分总和 for stu in students: # 计算总评成绩（平时30% + 期中30% + 期末40%） # 回忆第2章：数值型数据的运算 total = stu["daily"] * 0.3 + stu["midterm"] * 0.3 + stu["final"] * 0.4 total = round(total) # 回忆第2章：round()四舍五入函数 # 判断等级 # 回忆第3章：if-elif-else多路分支语句 if total >= 90: grade = "优秀" elif total >= 80: grade = "良好" elif total >= 70: grade = "中等" elif total >= 60: grade = "及格" else: grade = "不及格" # 使用f-string格式化后写入 line = f"{stu['id']:<12}{stu['name']:<8}{stu['daily']:<10}{stu['midterm']:<10}{stu['final']:<10}{total:<8}{grade:<6}\n" f.write(line) # 累加分数用于计算平均分 total_daily += stu["daily"] total_midterm += stu["midterm"] total_final += stu["final"] # 写入分隔线 f.write("-" * 60 + "\n") # 计算并写入班级平均分 # 回忆第2章：len()函数获取列表长度 n = len(students) avg_daily = round(total_daily / n, 1) avg_midterm = round(total_midterm / n, 1) avg_final = round(total_final / n, 1) f.write(f"{'班级平均分':<12}{'':<8}{avg_daily:<10}{avg_midterm:<10}{avg_final:<10}\n") f.write("=" * 60 + "\n") # 写入统计信息 f.write(f"\n共计 {n} 名学生\n") # 统计各等级人数 # 回忆第5章：字典的使用 grade_count = {"优秀": 0, "良好": 0, "中等": 0, "及格": 0, "不及格": 0} for stu in students: total = stu["daily"] * 0.3 + stu["midterm"] * 0.3 + stu["final"] * 0.4 total = round(total) if total >= 90: grade_count["优秀"] += 1 elif total >= 80: grade_count["良好"] += 1 elif total >= 70: grade_count["中等"] += 1 elif total >= 60: grade_count["及格"] += 1 else: grade_count["不及格"] += 1 f.write("等级分布：") # 回忆第5章：字典的items()方法 for g, count in grade_count.items(): f.write(f" {g}{count}人") f.write("\n") # 关闭文件 f.close() print("成绩单已生成：ck_score_report.txt")# 调用函数生成成绩单generate_score_report()# 读取并显示生成的成绩单print("\n生成的成绩单内容如下：")print()f = open("ck_score_report.txt", "r", encoding="utf-8")print(f.read())f.close()
运行结果：
成绩单已生成：ck_score_report.txt生成的成绩单内容如下：============================================================CK学校 数字经济专业Python基础及应用 课程成绩单============================================================学号姓名平时分期中分期末分总评等级------------------------------------------------------------2025001张三88829188良好2025002李四92888588良好2025003王五75707875中等2025004赵六95939896优秀2025005钱七60555054不及格2025006孙八80768380良好------------------------------------------------------------班级平均分81.777.380.8============================================================共计 6 名学生等级分布： 优秀 1人 良好 3人 中等 1人 及格 0人 不及格 1人
💡 知识串联总结： 这个成绩单生成器综合运用了以下知识点：
·第2章：f-string 格式化字符串（对齐控制）、round() 函数、len() 函数、数值运算
·第3章：if-elif-else 多路分支语句判断成绩等级
·第4章：for 循环遍历学生列表
·第5章：列表存储字典数据、字典的 items() 方法
·第6章：函数的定义和调用（generate_score_report 函数）
·第7章：open() 函数、write() 方法、close() 方法
示例二：CK 学校课程表生成器
这个示例展示了如何使用 write() 方法生成一份格式化的课程表文件。
# ===== 示例二：CK学校课程表生成器 =====def generate_schedule(): """生成CK学校数字经济专业课程表""" # 课程数据（使用嵌套列表存储） # 回忆第5章：列表的嵌套 # 每个内层列表代表一天的课程：[节次, 星期一, 星期二, 星期三, 星期四, 星期五] schedule = [ ["第1-2节", "Python基础", "高等数学", "Python基础", "经济学原理", "英语"], ["第3-4节", "经济学原理", "Python基础", "英语", "高等数学", "体育"], ["第5-6节", "高等数学", "数据结构", "创新创业", "Python基础", ""], ["第7-8节", "", "体育", "", "数据结构", ""], ] # 打开文件 f = open("ck_schedule.txt", "w", encoding="utf-8") # 写入标题 f.write(" CK学校 数字经济专业 2025年春季学期课程表\n") f.write("=" * 65 + "\n\n") # 写入表头 # 回忆第2章：f-string格式化 week_header = f"{'节次':<10}{'星期一':<12}{'星期二':<12}{'星期三':<12}{'星期四':<12}{'星期五':<12}\n" f.write(week_header) f.write("-" * 65 + "\n") # 写入每天的课程 # 回忆第4章：for循环遍历嵌套列表 for day_schedule in schedule: # day_schedule[0]是节次，day_schedule[1]~day_schedule[5]是周一到周五的课程 line = f"{day_schedule[0]:<10}" # 回忆第4章：使用for循环和切片处理列表 for course in day_schedule[1:]: if course == "": line += f"{'(空)':<12}" else: line += f"{course:<12}" line += "\n" f.write(line) # 写入底部信息 f.write("-" * 65 + "\n") f.write("上课时间：第1-2节 08:00-09:40 第3-4节 10:00-11:40\n") f.write(" 第5-6节 14:00-15:40 第7-8节 16:00-17:40\n") f.write("上课地点：CK学校教学楼A栋\n") f.close() print("课程表已生成：ck_schedule.txt")# 调用函数generate_schedule()# 读取并显示f = open("ck_schedule.txt", "r", encoding="utf-8")print(f.read())f.close()
运行结果：
CK学校数字经济专业 2025年春季学期课程表=================================================================节次星期一星期二星期三星期四星期五---------------------------------------------------------------------第1-2节Python基础高等数学Python基础经济学原理英语第3-4节经济学原理Python基础英语高等数学体育第5-6节高等数学数据结构创新创业Python基础(空)第7-8节(空)体育(空)数据结构(空)---------------------------------------------------------------------上课时间：第1-2节 08:00-09:40第3-4节 10:00-11:40第5-6节 14:00-15:40第7-8节 16:00-17:40上课地点：CK学校教学楼A栋
💡 知识串联总结： 这个课程表生成器综合运用了：
·第2章：f-string 格式化字符串（字段宽度控制）
·第4章：for 循环遍历嵌套列表、列表切片 day_schedule[1:]
·第5章：嵌套列表的使用
·第6章：函数的定义和调用
·第7章：write() 方法写入格式化文本
示例三：使用函数封装文件写入操作
这个示例展示了如何将文件写入操作封装为函数，提高代码的复用性。
# ===== 示例三：使用函数封装文件写入操作 =====def write_line(f, content, width=50): """ 向文件写入一行格式化的内容 参数： f - 文件对象 content - 要写入的内容 width - 每行总宽度（默认50） """ # 回忆第2章：len()函数获取字符串长度 # 回忆第2章：字符串的center()方法（居中对齐） f.write(content.center(width) + "\n")def write_separator(f, char="-", width=50): """ 向文件写入一行分隔符 参数： f - 文件对象 char - 分隔符字符（默认"-"） width - 分隔符总宽度（默认50） """ # 回忆第2章：字符串的乘法操作 f.write(char * width + "\n")def create_student_card(student_info, filename="ck_student_card.txt"): """ 为学生生成一张信息卡并写入文件 参数： student_info - 字典，包含学生信息 filename - 输出文件名 """ # 回忆第6章：函数的定义和参数传递 with open(filename, "w", encoding="utf-8") as f: write_separator(f, "=", 40) write_line(f, "CK学校 学生信息卡", 40) write_separator(f, "=", 40) f.write("\n") # 回忆第5章：字典的键访问 f.write(f" 姓 名：{student_info['name']}\n") f.write(f" 学 号：{student_info['id']}\n") f.write(f" 性 别：{student_info['gender']}\n") f.write(f" 年 龄：{student_info['age']}\n") f.write(f" 专 业：{student_info['major']}\n") f.write(f" 籍 贯：{student_info['hometown']}\n") f.write(f" 联系电话：{student_info['phone']}\n") f.write("\n") write_separator(f, "-", 40) write_line(f, "学习情况", 40) write_separator(f, "-", 40) f.write(f" Python成绩：{student_info['python_score']}\n") f.write(f" 学习评价：{student_info['comment']}\n") f.write("\n") write_separator(f, "=", 40) print(f"学生信息卡已生成：{filename}")# 创建多个学生的信息卡# 回忆第5章：列表存储字典students = [ { "name": "张三", "id": "2025001", "gender": "男", "age": 20, "major": "数字经济", "hometown": "重庆", "phone": "138****1234", "python_score": 92, "comment": "学习认真，编程能力强" }, { "name": "李四", "id": "2025002", "gender": "女", "age": 19, "major": "数字经济", "hometown": "成都", "phone": "139****5678", "python_score": 88, "comment": "思维活跃，善于合作" },]# 回忆第4章：for循环遍历列表for i, stu in enumerate(students): # 回忆第2章：enumerate()不是内置函数，但可以用range+索引代替 # 这里使用字符串格式化生成不同的文件名 filename = f"ck_student_card_{stu['id']}.txt" create_student_card(stu, filename)# 读取并显示第一个学生的信息卡print("\n学生信息卡内容预览：\n")f = open("ck_student_card_2025001.txt", "r", encoding="utf-8")print(f.read())f.close()
运行结果：
学生信息卡已生成：ck_student_card_2025001.txt学生信息卡已生成：ck_student_card_2025002.txt学生信息卡内容预览：========================================CK学校 学生信息卡========================================姓名：张三学号：2025001性别：男年龄：20专业：数字经济籍贯：重庆联系电话：138****1234----------------------------------------学习情况----------------------------------------Python成绩：92学习评价：学习认真，编程能力强========================================
💡 知识串联总结： 这个示例展示了如何将文件写入操作模块化：
·第2章：len() 函数、字符串的 center() 方法、字符串乘法
·第4章：for 循环遍历列表
·第5章：列表存储字典、字典的键访问
·第6章：函数的定义、参数传递（位置参数和默认参数）、with 语句
·第7章：write() 方法、open() 函数
五、本节知识点总结
7.2.1 文本文件写操作│├── 文本文件的概念│├── 以字符编码存储的文件│├── 可用文本编辑器直接阅读│├── 编码方式：UTF-8（推荐）、GBK、ASCII等│└── 换行符：\n（Python中统一使用）│├── write()方法│├── 语法：文件变量名.write(字符串对象)│├── 作用：将字符串内容写入文件│├── 返回值：写入的字符个数（整数）│└── 不会自动添加换行符│└── 四大注意事项├── ① write()只接受字符串类型（用str()转换）├── ② write()不会自动换行（需手动添加\n）├── ③ "w"模式会清空原有内容（追加用"a"模式）└── ④ write()写入字符，Python自动处理编码
🤖 AI辅助学习小节（7.2.1）
同学们，学完了文本文件的写操作后，如何利用AI工具来巩固和加深对本节知识的理解呢？下面是为你精心设计的AI互动练习方案！
练习一：用AI帮你生成一份”重庆旅游攻略”文件
练习目标： 综合运用 write() 方法、f-string 格式化和循环结构，创建一份格式化的旅游攻略文件。
AI提示词（直接复制发送给AI）：
我是一个Python初学者，正在学习文件写操作（write()方法）。请帮我编写一个Python程序，完成以下任务：1. 创建一个名为"chongqing_travel_guide.txt"的文本文件2. 写入一份重庆旅游攻略，包含以下内容：- 标题："重庆三日游攻略"- 每天的行程安排（至少3个景点/天），包含景点名称、推荐活动、预计花费- 美食推荐（至少5种重庆特色美食及推荐餐厅）- 住宿建议- 交通指南3. 使用f-string格式化字符串，让内容整齐美观4. 使用列表和字典来组织数据5. 使用for循环来批量写入行程信息6. 代码要有详细的中文注释要求：代码要简洁易懂，适合初学者理解。只使用write()方法写入，不要使用其他文件写入方法。
学习要点： 通过这个练习，你将巩固 write() 方法的使用、f-string 格式化技巧、以及如何用循环和列表来批量生成文件内容。
练习二：用AI帮你制作一个”ASCII艺术爱心”文件
练习目标： 将字符串知识和文件写入结合，创建一个有趣的ASCII艺术文件。
AI提示词（直接复制发送给AI）：
请帮我用Python的write()方法创建一个文本文件，文件中包含一个用ASCII字符绘制的大爱心图案。要求：1. 使用Python字符串来绘制爱心图案（用*号或其他字符）2. 将图案写入到名为"love.txt"的文本文件中3. 爱心图案要尽量大且美观，至少15行以上4. 在爱心图案下方写一句表白的话5. 只使用write()方法来写入文件6. 代码要有详细注释，解释每一步的作用注意：我只学过write()方法，请不要使用writelines()等其他文件方法。
学习要点： 通过这个有趣的练习，你将发现 write() 方法不仅可以写入普通文本，还可以用来保存各种创意内容。同时复习多行字符串（三引号 """..."""）的使用方法。
练习三：用AI帮你设计一个”个人记账本”文件生成器
练习目标： 综合运用 write() 方法、用户交互（input()）和分支判断，创建一个记账本文件。
AI提示词（直接复制发送给AI）：
请帮我编写一个Python"个人记账本"程序，将账目信息写入文件：功能要求：1. 程序运行时，提示用户输入今天的收支记录（至少3笔）- 每笔记录包含：日期、类型（收入/支出）、金额、备注2. 将所有记录格式化后写入到"my_account.txt"文件中3. 文件内容要求：- 有标题和分隔线- 每笔记录一行，格式对齐- 最后统计总收入、总支出和结余4. 使用write()方法写入文件5. 使用f-string格式化字符串6. 使用if-else判断收入和支出类型要求：代码适合初学者，有详细中文注释。背景设定为CK学校学生的日常消费场景。
学习要点： 通过这个练习，你将巩固 input() 获取用户输入、write() 写入文件、if-else 分支判断以及 f-string 格式化输出的综合运用能力。
练习四：用AI帮你创建一个”Python学习笔记模板”文件
练习目标： 综合运用 write() 方法和函数封装，创建一个可复用的学习笔记模板。
AI提示词（直接复制发送给AI）：
请帮我编写一个Python程序，生成一个"Python学习笔记"模板文件：功能要求：1. 定义一个函数 create_note_template(filename, chapter, topics)- filename：文件名- chapter：章节名称（如"第7章 文件及其应用"）- topics：知识点列表（如["文件概念", "文件类型", "文件路径"]）2. 函数内部使用write()方法将以下内容写入文件：- 笔记标题（居中显示）- 日期- 每个知识点后面留出空白区域供手写笔记- 底部有"学习总结"区域3. 调用该函数，生成两份不同章节的笔记模板4. 使用f-string格式化，让模板整齐美观要求：代码有详细中文注释，适合初学者理解。只使用write()方法写入文件。
学习要点： 通过这个练习，你将学习如何将文件写入操作封装为函数，提高代码的复用性。同时复习第6章的函数定义和参数传递知识。
📝 自学检查清单
完成以上AI辅助练习后，请对照以下清单检查自己对7.2.1节的掌握情况：
☐我能说出 write() 方法的完整语法格式
☐我知道 write() 方法的参数必须是字符串类型
☐我能使用 str() 函数将其他类型转换为字符串后写入文件
☐我能使用 f-string 格式化字符串后写入文件
☐我知道 write() 方法不会自动添加换行符
☐我知道 "w" 模式会清空文件原有内容，需要追加时使用 "a" 模式
☐我能综合运用 write() 方法和 for 循环批量写入数据
☐我能将文件写入操作封装为函数，提高代码复用性
7.2.2 文本文件读操作
📖 本节导读
在上一小节（7.2.1）中，我们学习了如何使用 write() 方法将数据从程序写入到文本文件中。现在，我们将学习文件操作的另一个方向——如何从文本文件中读取数据到程序中。
如果说写操作是把程序中的数据”保存”到文件中，那么读操作就是把文件中的数据”加载”到程序中。两者是互逆的操作，掌握了读操作，我们就能实现”写入数据 → 关闭程序 → 重新打开程序 → 读取数据”的完整数据持久化流程。
💡 知识串联回忆： 在第2章”数据输入输出”中，我们学习了 input() 函数从键盘读取用户输入。文件读操作和 input() 有相似之处——它们都是从”外部”获取数据到程序中。不同的是，input() 每次只能读取一行用户输入，而文件读操作可以一次性读取大量数据。
一、文件指针——理解读操作的前提
在学习具体的读操作方法之前，我们需要先理解一个重要的概念：文件指针（File Pointer）。
1. 什么是文件指针
文件指针是文件对象内部维护的一个位置标记，它指向文件中当前读/写操作的位置。你可以把它想象成阅读一本书时的”手指”——你的手指指到哪一行，你就在读哪一行。
文件内容：Hello,CK学校！\n位置编号：01234567891011↑文件指针（当前位置）
文件指针的重要特性： - 当文件刚被打开时，文件指针位于文件开头（位置0） - 每次读取操作后，文件指针会自动向后移动到已读取内容之后的位置 - 当文件指针到达文件末尾时，继续读取会得到空字符串"" - 我们可以使用 seek() 方法手动移动文件指针到指定位置
2. 文件指针的移动演示
让我们通过代码来直观感受文件指针的移动过程：
# ===== 文件指针移动演示 =====# 先创建一个测试文件f = open("ck_pointer_test.txt", "w", encoding="utf-8")f.write("ABCDEFGHIJ")f.close()# 以只读模式打开文件f = open("ck_pointer_test.txt", "r", encoding="utf-8")# 查看当前文件指针位置# tell()方法返回当前文件指针的位置（从0开始计数）pos = f.tell()print(f"刚打开文件时，指针位置：{pos}")# 读取3个字符data1 = f.read(3)print(f"读取了 '{data1}'，共 {len(data1)} 个字符")pos = f.tell()print(f"读取后，指针位置：{pos}")# 再读取4个字符data2 = f.read(4)print(f"读取了 '{data2}'，共 {len(data2)} 个字符")pos = f.tell()print(f"读取后，指针位置：{pos}")# 继续读取剩余内容data3 = f.read()print(f"读取了 '{data3}'，共 {len(data3)} 个字符")pos = f.tell()print(f"读取后，指针位置：{pos}")# 指针到达末尾后，继续读取得到空字符串data4 = f.read()print(f"继续读取：'{data4}'（空字符串）")f.close()
运行结果：
刚打开文件时，指针位置：0读取了 'ABC'，共 3 个字符读取后，指针位置：3读取了 'DEFG'，共 4 个字符读取后，指针位置：7读取了 'HIJ'，共 3 个字符读取后，指针位置：10继续读取：''（空字符串）
💡 关键理解： 从上面的演示可以看到，文件指针就像一个”游标”，每次读取后都会自动向后移动。当指针到达文件末尾时，read() 返回空字符串 ""。这个特性非常重要，后面我们会利用它来判断是否已经读完了整个文件。
二、四个常用读操作方法
Python 提供了四个常用的文本文件读操作方法，它们各有不同的特点和适用场景：
方法 | 功能 | 参数 | 返回值 |
f.read(n) | 读取指定数量的字符 | n：要读取的字符数（省略则读取全部） | 字符串 |
f.readline(n) | 读取一行内容 | n：要读取的字符数（省略则读取整行） | 字符串（含换行符） |
f.readlines() | 读取所有行 | 无 | 列表（每个元素是一行） |
f.seek(k) | 移动文件指针 | k：目标位置（从0开始） | 无 |
下面我们逐一详细学习这四个方法。
方法一：f.read(n) —— 读取指定数量的字符
1. 基本语法
参数说明： - n：要读取的字符个数（注意是字符数，不是字节数） - 如果省略 n，则读取整个文件的全部内容
返回值： - 返回一个字符串，包含从当前文件指针位置开始的 n 个字符 - 如果从当前位置到文件末尾不足 n 个字符，则返回剩余的所有字符 - 如果文件指针已在文件末尾，返回空字符串""
2. 读取全部内容（不传参数）
当 read() 不传参数时，它会一次性读取文件的全部内容：
# ===== read()读取全部内容 =====# 先创建一个测试文件f = open("ck_read_all.txt", "w", encoding="utf-8")f.write("重庆是一座美丽的山城\n")f.write("CK学校位于重庆永川\n")f.write("数字经济专业欢迎你\n")f.close()# 使用read()读取全部内容f = open("ck_read_all.txt", "r", encoding="utf-8")content = f.read()f.close()# 查看读取结果print(f"读取到的内容类型：{type(content)}")print(f"读取到的内容：\n{content}")
运行结果：
读取到的内容类型：读取到的内容：重庆是一座美丽的山城CK学校位于重庆永川数字经济专业欢迎你
💡 知识串联回忆：read() 方法返回的是一个字符串（str）类型。回忆第2章学过的字符串操作，我们可以对读取到的内容使用 split()、upper()、replace() 等各种字符串方法进行处理。
3. 读取指定数量的字符（传入参数n）
当 read(n) 传入参数 n 时，它只读取 n 个字符：
# ===== read(n)读取指定数量的字符 =====f = open("ck_read_all.txt", "r", encoding="utf-8")# 每次读取5个字符# 回忆第4章：while循环while True: chunk = f.read(5) if chunk == "": # 读取到空字符串，说明文件已读完 break # 回忆第4章：break语句退出循环 print(f"读取到：'{chunk}'")f.close()
运行结果：
读取到：'重庆是一座美'读取到：'丽的山城\n'读取到：'CK学校位于'读取到：'重庆永川\n'读取到：'数字经济专'读取到：'业欢迎你\n'
💡 知识说明： 从上面的结果可以看到，read(5) 每次读取5个字符（不是5个字节）。中文字符和英文字符在 read() 中都算作1个字符。注意，\n 换行符也算1个字符。
💡 知识串联总结： 上面的代码综合运用了： - 第3章：if 分支语句判断是否读完 - 第4章：while True 无限循环、break 语句退出循环 - 第7章：read(n) 方法、文件指针的自动移动
4. read() 方法的适用场景
场景 | 推荐用法 | 说明 |
文件较小，需要一次性读取全部内容 | f.read() | 简单直接 |
文件较大，需要分批读取 | f.read(n) + 循环 | 避免内存不足 |
需要统计文件字符数 | content = f.read(); len(content) | 先读取再统计 |
⚠️ 注意： 如果文件非常大（比如几百MB甚至几GB），使用 f.read() 一次性读取全部内容可能会导致内存不足。在这种情况下，应该使用 f.read(n) 分批读取，或者使用 f.readline() 逐行读取。
方法二：f.readline(n) —— 读取一行内容
1. 基本语法
参数说明： - n：要读取的字符个数（可选） - 如果省略 n，则读取当前行的全部内容（包括行尾的换行符 \n） - 如果指定了 n，则最多读取 n 个字符（如果还没到行尾就先返回）
返回值： - 返回一个字符串，包含当前行的内容 - 如果文件指针已在文件末尾，返回空字符串""
2. 读取一行的基本用法
# ===== readline()读取一行 =====f = open("ck_read_all.txt", "r", encoding="utf-8")# 读取第一行line1 = f.readline()print(f"第一行：{repr(line1)}")# 读取第二行line2 = f.readline()print(f"第二行：{repr(line2)}")# 读取第三行line3 = f.readline()print(f"第三行：{repr(line3)}")# 继续读取（已到文件末尾）line4 = f.readline()print(f"第四行：{repr(line4)}")f.close()
运行结果：
第一行：'重庆是一座美丽的山城\n'第二行：'CK学校位于重庆永川\n'第三行：'数字经济专业欢迎你\n'第四行：''
💡 关键细节： 注意观察上面的输出，readline() 返回的字符串包含行尾的换行符 \n。最后一行如果文件末尾没有换行符，则返回的字符串不包含 \n。当读取到文件末尾时，返回空字符串 ""。
💡 知识串联回忆： 上面的代码中使用了 repr() 函数来显示字符串。回忆第2章学过的内置函数，repr() 会以字符串的字面量形式显示内容，包括转义字符（如 \n 会被显示为 \n 而不是实际的换行）。这在调试时非常有用。
3. 去除行尾换行符
在实际使用中，我们通常不需要行尾的换行符。可以使用字符串的 strip() 方法来去除：
# ===== 去除readline()的换行符 =====f = open("ck_read_all.txt", "r", encoding="utf-8")# 回忆第2章：字符串的strip()方法去除首尾空白字符while True: line = f.readline() if line == "": # 文件读完 break # 使用strip()去除行尾的换行符 clean_line = line.strip() print(f"读取到：'{clean_line}'，原始长度：{len(line)}，去除后长度：{len(clean_line)}")f.close()
运行结果：
读取到：'重庆是一座美丽的山城'，原始长度：11，去除后长度：10读取到：'CK学校位于重庆永川'，原始长度：12，去除后长度：11读取到：'数字经济专业欢迎你'，原始长度：10，去除后长度：9
💡 知识串联回忆：strip() 是我们在第2章”字符串处理函数与方法”中学过的方法。它可以去除字符串首尾的空白字符（包括空格、\n、\t 等）。在处理文件读取结果时，strip() 是最常用的方法之一。
4. readline(n) 带参数的用法
当传入参数 n 时，readline(n) 最多读取 n 个字符。如果当前行剩余字符不足 n 个，则读取到行尾为止：
# ===== readline(n)带参数的用法 =====f = open("ck_read_all.txt", "r", encoding="utf-8")# 每次最多读取8个字符chunk1 = f.readline(8)print(f"readline(8)：{repr(chunk1)}")# 继续读取（从上次停止的位置继续）chunk2 = f.readline(8)print(f"readline(8)：{repr(chunk2)}")# 继续读取chunk3 = f.readline(8)print(f"readline(8)：{repr(chunk3)}")f.close()
运行结果：
readline(8)：'重庆是一座美丽的山'readline(8)：'城\n'readline(8)：'CK学校位于重庆永川\n'
💡 知识说明： 从上面的结果可以看到，readline(8) 第一次读取了8个字符（“重庆是一座美丽的山”），因为还没到行尾，所以不会返回。第二次继续读取，遇到了换行符 \n，于是连同换行符一起返回（共2个字符）。第三次读取新的一行，这一行只有11个字符（含 \n），不足8个的限制已经超过，所以整行返回。
方法三：f.readlines() —— 读取所有行
1. 基本语法
参数说明： 无参数
返回值： - 返回一个列表（list），列表中的每个元素是文件中的一行（字符串） - 每个字符串元素包含行尾的换行符 \n - 如果文件为空，返回空列表 []
2. 基本用法
# ===== readlines()读取所有行 =====f = open("ck_read_all.txt", "r", encoding="utf-8")# 读取所有行lines = f.readlines()f.close()# 查看返回结果的类型和内容print(f"返回类型：{type(lines)}")print(f"行数：{len(lines)}")print(f"内容：{lines}")
运行结果：
返回类型：行数：3内容：['重庆是一座美丽的山城\n', 'CK学校位于重庆永川\n', '数字经济专业欢迎你\n']
💡 知识串联回忆：readlines() 返回的是一个列表（list）。回忆第5章”列表及其应用”，我们可以使用 for 循环遍历列表、使用索引访问列表元素、使用 len() 获取列表长度等。这意味着，读取文件后，我们可以用之前学过的所有列表操作方法来处理文件内容。
3. 遍历 readlines() 返回的列表
# ===== 遍历readlines()的结果 =====f = open("ck_read_all.txt", "r", encoding="utf-8")lines = f.readlines()f.close()# 方法1：使用for循环遍历（推荐）# 回忆第4章：for循环遍历列表print("--- 方法1：for循环遍历 ---")for i, line in enumerate(lines): # 回忆第2章：strip()去除换行符 print(f"第{i+1}行：{line.strip()}")print()# 方法2：使用索引访问# 回忆第5章：列表的索引访问print("--- 方法2：索引访问 ---")print(f"第一行：{lines[0].strip()}")print(f"最后一行：{lines[-1].strip()}") # 回忆第5章：负索引print(f"总行数：{len(lines)}")
运行结果：
--- 方法1：for循环遍历 ---第1行：重庆是一座美丽的山城第2行：CK学校位于重庆永川第3行：数字经济专业欢迎你--- 方法2：索引访问 ---第一行：重庆是一座美丽的山城最后一行：数字经济专业欢迎你总行数：3
4. readlines() 的适用场景
readlines() 适合在以下场景中使用： - 文件不大，可以一次性读取所有行到内存 - 需要对文件的每一行进行处理（如搜索、替换、统计等） - 需要随机访问文件的某一行（通过列表索引）
⚠️ 注意： 和 read() 一样，如果文件非常大，readlines() 也可能导致内存不足。对于大文件，推荐使用 readline() 逐行读取。
方法四：f.seek(k) —— 移动文件指针
1. 基本语法
参数说明： - k：目标位置（从文件开头算起的字符偏移量，从0开始）
返回值： - 返回新的文件指针位置
作用： - 将文件指针移动到指定的位置 - 移动后，后续的读/写操作将从新位置开始
2. 基本用法
# ===== seek()移动文件指针 =====f = open("ck_seek_test.txt", "w", encoding="utf-8")f.write("ABCDEFGHIJ")f.close()f = open("ck_seek_test.txt", "r", encoding="utf-8")# 读取前3个字符print(f"初始位置：{f.tell()}，读取：{f.read(3)}")# 将指针移回开头（位置0）f.seek(0)print(f"seek(0)后位置：{f.tell()}，读取：{f.read(3)}")# 将指针移到位置5f.seek(5)print(f"seek(5)后位置：{f.tell()}，读取：{f.read(3)}")# 将指针移到位置2f.seek(2)print(f"seek(2)后位置：{f.tell()}，读取：{f.read(5)}")f.close()
运行结果：
初始位置：0，读取：ABCseek(0)后位置：0，读取：ABCseek(5)后位置：5，读取：FGHseek(2)后位置：2，读取：CDEFG
💡 关键理解：seek(0) 是最常用的操作，它将文件指针移回文件开头。这在需要多次读取同一文件的场景中非常有用——先读取一次，然后用 seek(0) 重置指针，再读取一次。
3. seek() 的实际应用场景
场景：先读取文件统计信息，再读取文件内容
# ===== seek()的实际应用 =====# 创建一个包含学生成绩的文件f = open("ck_seek_demo.txt", "w", encoding="utf-8")f.write("张三,92\n")f.write("李四,85\n")f.write("王五,78\n")f.write("赵六,95\n")f.write("钱七,63\n")f.close()f = open("ck_seek_demo.txt", "r", encoding="utf-8")# 第一步：读取全部内容，统计行数（即学生人数）content = f.read()# 回忆第2章：字符串的split()方法，按换行符分割lines = content.split("\n")# 去掉最后的空行# 回忆第5章：列表的切片操作lines = lines[:-1] if lines[-1] == "" else linesstudent_count = len(lines)print(f"学生人数：{student_count}")# 第二步：使用seek(0)将指针移回开头f.seek(0)print("指针已移回开头")# 第三步：重新逐行读取并处理print("\n学生成绩详情：")# 回忆第4章：for循环for line in f: # 去除换行符后按逗号分割 # 回忆第2章：字符串的strip()和split()方法 clean_line = line.strip() if clean_line: # 跳过空行 parts = clean_line.split(",") name = parts[0] score = int(parts[1]) # 回忆第2章：int()类型转换 print(f" {name}：{score}分")f.close()
运行结果：
学生人数：5指针已移回开头学生成绩详情：张三：92分李四：85分王五：78分赵六：95分钱七：63分
💡 知识串联总结： 上面的代码综合运用了： - 第2章：split() 分割字符串、strip() 去除空白、int() 类型转换 - 第4章：for 循环遍历文件对象 - 第5章：列表切片、len() 获取长度 - 第7章：read() 读取全部内容、seek(0) 重置指针
三、四个读操作方法的对比总结
方法 | 读取单位 | 返回类型 | 是否移动指针 | 适用场景 |
f.read() | 整个文件 | 字符串 | 是（移到末尾） | 小文件一次性读取 |
f.read(n) | n个字符 | 字符串 | 是（向后移动n位） | 大文件分批读取 |
f.readline() | 一行 | 字符串（含\n） | 是（移到下一行开头） | 逐行处理 |
f.readlines() | 所有行 | 列表 | 是（移到末尾） | 需要按行索引访问 |
f.seek(k) | — | — | 是（移到位置k） | 重置读取位置 |
💡 实践建议：
·小文件（几KB到几MB）：推荐使用 f.read() 一次性读取，代码最简洁
·大文件或需要逐行处理：推荐使用 for line in f 直接遍历文件对象（下面会详细讲解）
·需要多次读取同一文件：使用 f.seek(0) 重置指针
·需要按行索引访问：使用 f.readlines() 获取列表后通过索引访问
四、使用四个方法读取数据的程序示例
示例一：使用 read() 读取CK学校简介文件
# ===== 示例一：使用read()读取学校简介 =====# 先创建学校简介文件f = open("ck_intro.txt", "w", encoding="utf-8")f.write("""CK学校简介CK学校是一所以应用型人才培养为目标的高等院校，位于美丽的山城重庆。学校设有经济管理学院等多个学院，数字经济专业是经济管理学院的重点专业之一。本专业致力于培养具有扎实经济学基础和较强数据分析能力的复合型人才。欢迎同学们加入CK学校数字经济专业！""")f.close()# 使用read()读取全部内容f = open("ck_intro.txt", "r", encoding="utf-8")content = f.read()f.close()# 对读取的内容进行字符串处理# 回忆第2章：字符串处理方法print(f"文件总字符数：{len(content)}")print(f"文件总行数：{content.count(chr(10))}") # chr(10)就是\n# 使用split()按行分割# 回忆第2章：字符串的split()方法lines_list = content.split("\n")print(f"分割后的行数：{len(lines_list)}")# 统计中文字符数# 回忆第4章：for循环遍历字符串chinese_count = 0for char in content: # 回忆第2章：字符串的比较运算 # 中文字符的Unicode编码范围 if '\u4e00' <= char <= '\u9fff': chinese_count += 1print(f"中文字符数：{chinese_count}")# 查找包含"重庆"的行# 回忆第2章：字符串的in成员运算print("\n包含'重庆'的行：")for line in lines_list: if "重庆" in line and line.strip(): # 回忆第3章：逻辑运算and print(f" {line.strip()}")
运行结果：
文件总字符数：147文件总行数：9分割后的行数：10中文字符数：108包含'重庆'的行：位于美丽的山城重庆。
💡 知识串联总结： 这个示例展示了读取文件后如何利用第2章学过的字符串处理方法来分析文件内容： - len() 获取字符串长度 - count() 统计子串出现次数 - split() 按分隔符分割字符串 - in 成员运算判断子串是否存在 - strip() 去除首尾空白字符
示例二：使用 readline() 逐行读取并处理成绩数据
# ===== 示例二：使用readline()逐行读取成绩 =====# 先创建成绩文件f = open("ck_scores_data.txt", "w", encoding="utf-8")f.write("学号,姓名,平时分,期中分,期末分\n")f.write("2025001,张三,88,82,91\n")f.write("2025002,李四,92,88,85\n")f.write("2025003,王五,75,70,78\n")f.write("2025004,赵六,95,93,98\n")f.write("2025005,钱七,60,55,50\n")f.write("2025006,孙八,80,76,83\n")f.close()# 使用readline()逐行读取f = open("ck_scores_data.txt", "r", encoding="utf-8")# 读取表头（第一行）header = f.readline().strip()# 回忆第2章：字符串的split()方法headers = header.split(",")print(f"表头：{headers}")print()# 逐行读取数据print("学生成绩信息：")print("-" * 55)# 回忆第4章：while循环line_num = 0 # 数据行计数器total_score = 0 # 总分累加器while True: line = f.readline() if line == "": # 文件读完 break line = line.strip() if not line: # 跳过空行 continue # 回忆第4章：continue语句 line_num += 1 # 按逗号分割字段 parts = line.split(",") student_id = parts[0] name = parts[1] daily = int(parts[2]) midterm = int(parts[3]) final = int(parts[4]) # 计算总评 # 回忆第2章：数值运算 total = round(daily * 0.3 + midterm * 0.3 + final * 0.4) total_score += total # 判断等级 # 回忆第3章：if-elif-else分支 if total >= 90: grade = "优秀" elif total >= 80: grade = "良好" elif total >= 70: grade = "中等" elif total >= 60: grade = "及格" else: grade = "不及格" # 输出 print(f" {student_id}{name} 平时:{daily} 期中:{midterm} 期末:{final} 总评:{total}{grade}")f.close()# 输出统计信息print("-" * 55)# 回忆第2章：数值运算和round()函数avg_score = round(total_score / line_num, 1)print(f" 共 {line_num} 名学生，班级平均分：{avg_score}")
运行结果：
表头：['学号', '姓名', '平时分', '期中分', '期末分']学生成绩信息：-------------------------------------------------------2025001张三平时:88期中:82期末:91总评:88良好2025002李四平时:92期中:88期末:85总评:88良好2025003王五平时:75期中:70期末:78总评:75中等2025004赵六平时:95期中:93期末:98总评:96优秀2025005钱七平时:60期中:55期末:50总评:54不及格2025006孙八平时:80期中:76期末:83总评:80良好-------------------------------------------------------共 6 名学生，班级平均分：80.2
💡 知识串联总结： 这个示例综合运用了： - 第2章：split() 分割字符串、int() 类型转换、round() 四舍五入、数值运算 - 第3章：if-elif-else 分支判断等级 - 第4章：while True 循环、break 退出循环、continue 跳过空行 - 第7章：readline() 逐行读取
示例三：使用 readlines() 读取并分析数据
# ===== 示例三：使用readlines()读取并分析 =====# 先创建一个重庆各区GDP数据文件f = open("ck_chongqing_gdp.txt", "w", encoding="utf-8")f.write("渝北区,2200\n")f.write("九龙坡区,1600\n")f.write("渝中区,1400\n")f.write("江北区,1300\n")f.write("南岸区,900\n")f.write("沙坪坝区,1000\n")f.write("巴南区,800\n")f.write("北碚区,700\n")f.close()# 使用readlines()读取所有行f = open("ck_chongqing_gdp.txt", "r", encoding="utf-8")lines = f.readlines()f.close()# 回忆第5章：使用列表存储处理后的数据districts = [] # 存储区名gdp_values = [] # 存储GDP值# 回忆第4章：for循环遍历列表for line in lines: line = line.strip() if line: parts = line.split(",") districts.append(parts[0]) # 回忆第5章：列表的append()方法 gdp_values.append(int(parts[1]))# 计算统计数据# 回忆第2章：sum()、max()、min()内置函数total_gdp = sum(gdp_values)max_gdp = max(gdp_values)min_gdp = min(gdp_values)avg_gdp = round(total_gdp / len(gdp_values), 1)# 找到GDP最高和最低的区# 回忆第5章：列表的index()方法max_index = gdp_values.index(max_gdp)min_index = gdp_values.index(min_gdp)# 输出统计结果print("=" * 45)print(" 重庆市部分区GDP数据统计")print("=" * 45)print(f" 统计区县数量：{len(districts)} 个")print(f" GDP总计：{total_gdp} 亿元")print(f" GDP平均：{avg_gdp} 亿元")print(f" GDP最高：{districts[max_index]}（{max_gdp} 亿元）")print(f" GDP最低：{districts[min_index]}（{min_gdp} 亿元）")print()# 按GDP从高到低排序输出# 回忆第5章：列表的sort()方法（这里使用简单的冒泡排序）# 回忆第4章：嵌套循环n = len(gdp_values)for i in range(n - 1): for j in range(n - 1 - i): if gdp_values[j] < gdp_values[j + 1]: # 交换GDP值 gdp_values[j], gdp_values[j + 1] = gdp_values[j + 1], gdp_values[j] # 同时交换对应的区名 districts[j], districts[j + 1] = districts[j + 1], districts[j]print("GDP排名（从高到低）：")# 回忆第4章：使用range()和索引遍历for i in range(len(districts)): # 回忆第2章：字符串乘法 bar = "█" * (gdp_values[i] // 100) # 用方块表示GDP大小 print(f" 第{i+1}名 {districts[i]:<6}{gdp_values[i]:>5}亿元 {bar}")
运行结果：
=============================================重庆市部分区GDP数据统计=============================================统计区县数量：8 个GDP总计：9900 亿元GDP平均：1237.5 亿元GDP最高：渝北区（2200 亿元）GDP最低：北碚区（700 亿元）GDP排名（从高到低）：第1名渝北区2200亿元████████████████████第2名九龙坡区1600亿元████████████████第3名渝中区1400亿元██████████████第4名江北区1300亿元█████████████第5名沙坪坝区1000亿元██████████第6名南岸区900亿元█████████第7名巴南区800亿元████████第8名北碚区700亿元███████
💡 知识串联总结： 这个示例是一个非常综合的案例，运用了： - 第2章：sum()、max()、min() 内置函数、int() 类型转换、round() 四舍五入、字符串乘法 - 第4章：for 循环、range() 函数、嵌套循环（冒泡排序） - 第5章：列表的 append()、index() 方法、列表元素交换 - 第7章：readlines() 读取所有行
示例四：使用 seek() 实现文件的多次读取
# ===== 示例四：使用seek()多次读取文件 =====# 创建一个包含多种信息的文件f = open("ck_multi_read.txt", "w", encoding="utf-8")f.write("CK学校数字经济专业课程信息\n")f.write("================================\n")f.write("课程名称：Python基础及应用\n")f.write("学分：3学分\n")f.write("学时：48学时\n")f.write("授课教师：李老师\n")f.write("上课地点：教学楼A栋305\n")f.close()f = open("ck_multi_read.txt", "r", encoding="utf-8")# 第一次读取：读取全部内容并显示print("=== 第一次读取：全部内容 ===")content = f.read()print(content)# 第二次读取：使用seek(0)重置指针后重新读取print("=== 第二次读取：重置后逐行读取 ===")f.seek(0) # 将指针移回开头line_count = 0while True: line = f.readline() if line == "": break line_count += 1 # 只显示包含"课程"或"教师"的行 # 回忆第2章：字符串的find()方法 if "课程" in line or "教师" in line: print(f" 第{line_count}行：{line.strip()}")# 第三次读取：使用seek(0)后按行读取到列表print("\n=== 第三次读取：读取到列表后按索引访问 ===")f.seek(0)all_lines = f.readlines()# 回忆第5章：列表的索引访问print(f" 总行数：{len(all_lines)}")print(f" 第1行：{all_lines[0].strip()}")print(f" 最后一行：{all_lines[-1].strip()}") # 回忆第5章：负索引# 使用seek移动到特定位置print("\n=== 第四次读取：从特定位置开始 ===")f.seek(0)# 先读取2行（跳过标题和分隔线）f.readline()f.readline()# 然后读取剩余内容remaining = f.read()print(f" 跳过前两行后的内容：")for line in remaining.split("\n"): if line.strip(): print(f" {line.strip()}")f.close()
运行结果：
=== 第一次读取：全部内容 ===CK学校数字经济专业课程信息================================课程名称：Python基础及应用学分：3学分学时：48学时授课教师：李老师上课地点：教学楼A栋305=== 第二次读取：重置后逐行读取 ===第1行：CK学校数字经济专业课程信息第3行：课程名称：Python基础及应用第5行：授课教师：李老师=== 第三次读取：读取到列表后按索引访问 ===总行数：7第1行：CK学校数字经济专业课程信息最后一行：上课地点：教学楼A栋305=== 第四次读取：从特定位置开始 ===跳过前两行后的内容：课程名称：Python基础及应用学分：3学分学时：48学时授课教师：李老师上课地点：教学楼A栋305
💡 知识串联总结： 这个示例展示了 seek() 的实际应用场景——对同一文件进行多次不同方式的读取。综合运用了： - 第2章：in 成员运算、split() 分割字符串、strip() 去除空白 - 第4章：while 循环、break 退出循环 - 第5章：列表索引（正索引和负索引）、len() 获取长度 - 第7章：read()、readline()、readlines()、seek(0) 四个方法
五、遍历文本文件内容
除了上面介绍的四个方法之外，Python 还提供了一种更加简洁优雅的方式来遍历文件内容——直接使用 for 循环遍历文件对象。
1. for循环直接遍历文件对象
# ===== for循环直接遍历文件对象 =====# 语法格式：# for 变量 in 文件对象:# 处理每一行f = open("ck_read_all.txt", "r", encoding="utf-8")# 直接用for循环遍历文件对象# 回忆第4章：for循环print("使用for循环遍历文件：")for line in f: # 每次迭代，line变量获取文件中的一行（包含换行符\n） print(f" -> {line.strip()}")f.close()
运行结果：
使用for循环遍历文件：-> 重庆是一座美丽的山城-> CK学校位于重庆永川-> 数字经济专业欢迎你
💡 推荐方式：for line in f 是 Python 中最推荐的逐行读取文件的方式。它简洁、高效、内存友好（每次只读取一行到内存），并且代码可读性很好。
2. for循环遍历与 readline() 的对比
# ===== for循环遍历 vs readline()对比 =====# --- 方式1：for循环遍历（推荐） ---print("--- 方式1：for循环遍历 ---")f = open("ck_read_all.txt", "r", encoding="utf-8")for line in f: print(line.strip())f.close()print()# --- 方式2：readline() + while循环 ---print("--- 方式2：readline() + while循环 ---")f = open("ck_read_all.txt", "r", encoding="utf-8")while True: line = f.readline() if line == "": break print(line.strip())f.close()
运行结果：
--- 方式1：for循环遍历 ---重庆是一座美丽的山城CK学校位于重庆永川数字经济专业欢迎你--- 方式2：readline() + while循环 ---重庆是一座美丽的山城CK学校位于重庆永川数字经济专业欢迎你
💡 对比总结： 两种方式的效果相同，但 for line in f 更加简洁，不需要手动判断文件是否读完。在实际编程中，推荐优先使用 for line in f。
3. 遍历文件内容的综合案例——CK学校食堂菜单分析
# ===== 综合案例：CK学校食堂菜单分析 =====# 先创建食堂菜单文件f = open("ck_canteen_menu.txt", "w", encoding="utf-8")f.write("菜品名称,价格,类型,评分\n")f.write("重庆小面,8,主食,4.8\n")f.write("麻辣烫,15,主食,4.5\n")f.write("酸辣粉,10,小吃,4.6\n")f.write("毛血旺,25,炒菜,4.7\n")f.write("水煮鱼,32,炒菜,4.9\n")f.write("蛋炒饭,10,主食,4.3\n")f.write("豆花饭,8,主食,4.4\n")f.write("冰粉,5,甜品,4.8\n")f.write("凉糕,5,甜品,4.6\n")f.write("辣子鸡,28,炒菜,4.7\n")f.close()# ===== 分析菜单数据 =====# 使用for循环遍历文件f = open("ck_canteen_menu.txt", "r", encoding="utf-8")# 跳过表头header = f.readline()print(f"表头：{header.strip()}")print("=" * 55)# 回忆第5章：使用字典来分类统计type_count = {} # 按类型统计菜品数量type_prices = {} # 按类型统计价格列表# 回忆第5章：使用列表存储所有菜品信息all_dishes = []for line in f: line = line.strip() if not line: continue parts = line.split(",") name = parts[0] price = float(parts[1]) # 回忆第2章：float()类型转换 dish_type = parts[2] rating = float(parts[3]) # 存储菜品信息（使用字典） # 回忆第5章：列表的append()方法 all_dishes.append({ "name": name, "price": price, "type": dish_type, "rating": rating }) # 按类型统计 # 回忆第5章：字典的操作 if dish_type not in type_count: type_count[dish_type] = 0 type_prices[dish_type] = [] type_count[dish_type] += 1 type_prices[dish_type].append(price)f.close()# 输出所有菜品信息print("\n所有菜品：")for dish in all_dishes: # 使用f-string格式化输出 print(f" {dish['name']:<8}{dish['price']:>5}元 {dish['type']:<6}{'★' * int(dish['rating'])}{'☆' * (5 - int(dish['rating']))}")# 输出分类统计print("\n" + "=" * 55)print("分类统计：")for dish_type, count in type_count.items(): # 回忆第2章：sum()函数求和 avg_price = round(sum(type_prices[dish_type]) / count, 1) print(f" {dish_type}：{count}道菜，平均价格{avg_price}元")# 找出最贵的菜品和评分最高的菜品# 回忆第5章：列表的操作max_price_dish = all_dishes[0]max_rating_dish = all_dishes[0]for dish in all_dishes: if dish["price"] > max_price_dish["price"]: max_price_dish = dish if dish["rating"] > max_rating_dish["rating"]: max_rating_dish = dishprint(f"\n最贵菜品：{max_price_dish['name']}（{max_price_dish['price']}元）")print(f"最高评分：{max_rating_dish['name']}（{max_rating_dish['rating']}分）")
运行结果：
表头：菜品名称,价格,类型,评分=======================================================所有菜品：重庆小面8.0元主食★★★★☆麻辣烫15.0元主食★★★★☆酸辣粉10.0元小吃★★★★☆毛血旺25.0元炒菜★★★★☆水煮鱼32.0元炒菜★★★★★蛋炒饭10.0元主食★★★★☆豆花饭8.0元主食★★★★☆冰粉5.0元甜品★★★★☆凉糕5.0元甜品★★★★☆辣子鸡28.0元炒菜★★★★☆=======================================================分类统计：主食：4道菜，平均价格10.2元小吃：1道菜，平均价格10.0元炒菜：3道菜，平均价格28.3元甜品：2道菜，平均价格5.0元最贵菜品：水煮鱼（32.0元）最高评分：水煮鱼（4.9分）
💡 知识串联总结： 这个食堂菜单分析案例是一个高度综合的程序，运用了： - 第2章：float() 类型转换、sum() 求和、int() 取整、字符串格式化 - 第4章：for 循环遍历文件对象和列表 - 第5章：列表存储字典、字典的分类统计、append() 方法、items() 方法、not in 成员运算 - 第7章：readline() 跳过表头、for line in f 遍历文件内容
六、本节知识点总结
7.2.2 文本文件读操作│├── 文件指针│├── 标记当前读/写位置│├── 读取后自动向后移动│├── 到达末尾后继续读取返回空字符串""│└── tell()查看位置，seek(k)移动位置│├── 四个常用方法│├── f.read(n)││├── 不传n：读取全部内容，返回字符串││└── 传n：读取n个字符，返回字符串│├── f.readline(n)││├── 不传n：读取一行（含\n），返回字符串││└── 传n：最多读取n个字符│├── f.readlines()││└── 读取所有行，返回列表（每个元素是一行）│└── f.seek(k)│└── 移动文件指针到位置k│└── 遍历文件├── for line in f（推荐方式）├── 每次迭代获取一行└── 自动处理文件结束
🤖 AI辅助学习小节（7.2.2）
同学们，学完了文本文件的读操作后，如何利用AI工具来巩固和加深对本节知识的理解呢？下面是为你精心设计的AI互动练习方案！
练习一：用AI帮你制作一个”重庆地铁线路图”文本文件
练习目标： 综合运用文件写操作和读操作，创建一个有趣的地铁线路信息文件。
AI提示词（直接复制发送给AI）：
我是一个Python初学者，正在学习文件的读操作（read()、readline()、readlines()、seek()）。请帮我完成以下任务：1. 先用write()方法创建一个名为"chongqing_metro.txt"的文件，内容是重庆地铁的部分线路信息：- 每条线路一行，格式为：线路号,线路名称,颜色,站数,代表性站点- 至少包含5条线路（如1号线红色、2号线绿色、3号线蓝色等）- 站点信息要真实（如1号线有朝天门、小什字、较场口等站）2. 然后用read()方法读取全部内容并打印3. 再用seek(0)重置指针后，用readline()逐行读取，只打印站数超过20站的线路4. 最后用readlines()读取到列表，统计总线路数和总站点数要求：代码有详细中文注释，只使用本章学过的文件操作方法。
学习要点： 通过这个练习，你将综合运用 write()、read()、readline()、readlines()、seek() 五个方法，体验它们的不同用途。
练习二：用AI帮你创建一个”文本柱状图”生成器
练习目标： 将文件读取和字符串处理结合，生成一个可视化的文本柱状图。
AI提示词（直接复制发送给AI）：
请帮我编写一个Python程序，实现"文本柱状图"功能：1. 先用write()方法创建一个数据文件"ck_data_chart.txt"，包含CK学校各社团人数：- Python编程社,45人- 篮球社,38人- 摄影社,22人- 音乐社,30人- 志愿者协会,50人- 文学社,18人2. 用readlines()读取文件数据3. 根据数据生成一个文本柱状图，写入到"ck_bar_chart.txt"文件中：- 每个社团一行- 用"█"字符表示人数（1人=1个█）- 社团名称左对齐，柱状图右对齐- 在底部显示总人数4. 最后读取柱状图文件并打印显示要求：代码有详细注释，使用f-string格式化。只使用本章学过的知识。
学习要点： 通过这个练习，你将体验”读取数据文件 → 处理数据 → 生成结果文件”的完整流程，这是数据处理程序的基本模式。
练习三：用AI帮你设计一个”文件内容搜索器”
练习目标： 综合运用文件读取和字符串处理，实现文件内容搜索功能。
AI提示词（直接复制发送给AI）：
请帮我编写一个Python"文件内容搜索器"程序：功能要求：1. 先用write()方法创建一个名为"ck_python_notes.txt"的文件，内容是Python学习笔记（至少10行），包含以下关键词：变量、循环、函数、文件、列表、字典等2. 程序运行时，提示用户输入要搜索的关键词3. 使用readlines()读取文件所有行4. 遍历每一行，找出包含关键词的行（不区分大小写）- 提示：使用字符串的lower()方法统一转为小写后比较5. 输出搜索结果：- 显示匹配的行号和内容- 统计匹配的行数- 如果没有匹配，显示"未找到"6. 使用while循环让用户可以多次搜索，输入"退出"时结束要求：代码有详细中文注释，使用try-except处理文件不存在的异常。只使用本章和之前章节学过的知识。
学习要点： 通过这个练习，你将巩固 readlines() 读取文件、字符串的 lower() 和 in 方法、while 循环以及 try-except 异常处理的综合运用。
练习四：用AI帮你制作一个”密码保险箱”程序
练习目标： 综合运用文件读写操作，创建一个简单的密码管理程序。
AI提示词（直接复制发送给AI）：
请帮我编写一个Python"密码保险箱"程序，将密码信息保存到文件中：功能要求：1. 程序提供以下菜单（使用while循环）：- 1. 添加密码（写入文件）- 2. 查看所有密码（读取文件）- 3. 搜索密码（按网站名搜索）- 4. 退出2. 添加密码功能：- 用户输入网站名、用户名、密码- 使用write()方法以追加模式("a")写入到"passwords.txt"文件- 格式：网站名,用户名,密码3. 查看所有密码功能：- 使用readlines()读取文件所有行- 格式化显示所有密码信息4. 搜索密码功能：- 用户输入网站名- 使用readline()逐行读取，找到匹配的行后显示- 使用字符串的find()或in方法进行匹配5. 使用函数封装每个功能要求：代码有详细中文注释，背景设定为CK学校学生的常用网站。只使用本章和之前章节学过的知识，不要使用后续章节的内容。
学习要点： 通过这个练习，你将体验一个完整的”文件读写综合应用”程序，巩固文件的写操作（"a" 模式追加）和读操作（readlines()、readline()）在实际场景中的运用。
练习五：用AI帮你生成一个”ASCII艺术图案”文件集
练习目标： 发挥创意，用文件操作生成多个有趣的ASCII艺术文件。
AI提示词（直接复制发送给AI）：
请帮我用Python的文件操作生成3个ASCII艺术文本文件：文件1："ck_pyramid.txt" —— 用*号绘制一个金字塔图案* ************************（至少10层高）文件2："ck_diamond.txt" —— 用*号绘制一个菱形图案********* **************** ****************（至少9层高）文件3："ck_wave.txt" —— 用~符号绘制波浪图案~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~（至少8行，有起伏感）要求：1. 使用write()方法写入文件2. 使用for循环和字符串乘法来生成图案3. 每个文件写入完成后，立即用read()读取并打印验证4. 代码有详细中文注释注意：只使用write()方法写入，使用read()方法读取验证。
学习要点： 通过这个有趣的练习，你将发现文件操作可以用来保存各种创意内容。同时复习 for 循环、range() 函数、字符串乘法等基础知识。
📝 自学检查清单
完成以上AI辅助练习后，请对照以下清单检查自己对7.2.2节的掌握情况：
☐我能解释什么是文件指针，以及它的移动规律
☐我能使用 f.read() 读取文件全部内容
☐我能使用 f.read(n) 读取指定数量的字符
☐我能使用 f.readline() 逐行读取文件内容
☐我知道 readline() 返回的字符串包含行尾的换行符 \n
☐我能使用 strip() 去除行尾的换行符
☐我能使用 f.readlines() 读取所有行到列表
☐我能使用 f.seek(0) 将文件指针移回开头
☐我能使用 for line in f 直接遍历文件内容
☐我能根据不同的需求选择合适的读取方法
☐我能综合运用文件读写操作完成实际的数据处理任务
📚 7.2节完整知识点总结
7.2 文本文件的操作│├── 7.2.1 文本文件写操作│├── 文本文件概念（字符编码、UTF-8、换行符\n）│├── write()方法││├── 语法：文件变量名.write(字符串对象)││├── 作用：将字符串写入文件││└── 返回值：写入的字符个数│├── 注意事项││├── ① 只接受字符串类型（用str()转换）││├── ② 不自动换行（需手动添加\n）││├── ③ "w"模式清空原有内容││└── ④ Python自动处理编码│└── 程序示例│├── 成绩单生成器│├── 课程表生成器│└── 函数封装写入操作│└── 7.2.2 文本文件读操作├── 文件指针（位置标记、自动移动、tell()、seek()）├── 四个常用方法│├── f.read(n) —— 读取n个字符（或全部）│├── f.readline(n) —— 读取一行│├── f.readlines() —— 读取所有行到列表│└── f.seek(k) —— 移动文件指针├── 遍历文件│└── for line in f（推荐方式）└── 程序示例├── read()读取学校简介├── readline()逐行读取成绩├── readlines()分析GDP数据├── seek()多次读取└── 食堂菜单分析（综合案例）
10个月宝宝每天需要喝多少奶粉？
