原文件内容： ABCDEFG

模式 w（从头覆盖）:
[新内容: 123] → 文件变成: 123

模式 a（追加到末尾）:
原内容: ABCDEFG → 追加后: ABCDEFG123

模式 r+（从开头覆盖，不截断）:
原内容: ABCDEFG → 写入 123 → 文件变成: 123DEFG

# 示例1：只读模式（文件必须存在）
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# 示例2：写入模式（会自动创建文件，也会清空已有内容！）
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello, Python!\n")
    f.write("这是第二行。\n")

# 示例3：追加模式（不会清空，新内容加在末尾）
with open("output.txt", "a", encoding="utf-8") as f:
    f.write("这是追加的一行。\n")

# 示例4：二进制模式（读取图片）
with open("photo.jpg", "rb") as f:
    image_data = f.read()
    print(f"图片大小：{len(image_data)} 字节")

# 完整语法
f = open(
    file="文件名",           # 文件路径（字符串）
    mode="r",               # 打开模式
    buffering=-1,           # 缓冲策略（一般不用改）
    encoding=None,          # 编码格式（文本模式专用）
    errors=None,            # 编码错误处理
    newline=None,           # 换行符处理
    closefd=True,           # 是否关闭底层文件描述符
)

f = open("data.txt", "r", encoding="utf-8")

# 不用 with 的写法（不推荐！容易忘记关闭）
f = open("data.txt", "r", encoding="utf-8")
content = f.read()
f.close()  # 容易忘记写这行！
# 如果 read() 中间出错，close() 根本不会执行 → 资源泄漏

# 用 with 的写法（推荐！自动关闭）
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()
# 出了 with 块，文件自动关闭，即使中间出错也会关

with open("poem.txt", "r", encoding="utf-8") as f:
    # 方法1：一次性读取全部内容（适合小文件）
    all_text = f.read()
    print("=== read() 全部内容 ===")
    print(all_text)

# 每次 open 有独立的文件指针，推荐分开写
with open("poem.txt", "r", encoding="utf-8") as f:
    # 方法2：按行读取，返回列表（每行是一个元素）
    lines = f.readlines()
    print("=== readlines() 按行 ===")
    for line in lines:
        print(line, end="")  # line 已含 \n，所以 end=""

with open("poem.txt", "r", encoding="utf-8") as f:
    # 方法3：逐行读取（最省内存，适合大文件！）
    print("=== 逐行遍历 ===")
    for line in f:
        print(line.strip())  # strip() 去掉首尾空白和换行

with open("poem.txt", "r", encoding="utf-8") as f:
    # 方法4：只读一行
    first_line = f.readline()
    print(f"第一行：{first_line.strip()}")

content = """静夜思
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。"""

# 写入文件
with open("静夜思.txt", "w", encoding="utf-8") as f:
    f.write(content)           # 写入字符串
    # f.writelines(["行1\n", "行2\n"])  # 写入字符串列表

# 验证：读出来看看
with open("静夜思.txt", "r", encoding="utf-8") as f:
    print(f.read())

# 场景：在一个文件中写入中文

# 错误做法（Windows 上可能乱码！）
with open("test.txt", "w") as f:      # 没指定 encoding！
    f.write("你好，世界！")

# 正确做法
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("你好，世界！")

# 读取时的编码必须和写入时一致
with open("test.txt", "r", encoding="utf-8") as f:
    print(f.read())

# 文件来自不确定的来源？尝试常见编码
encodings_to_try = ["utf-8", "gbk", "gb2312", "latin-1"]
for enc in encodings_to_try:
    try:
        with open("unknown.txt", "r", encoding=enc) as f:
            print(f"使用 {enc} 编码读取成功：")
            print(f.read()[:100])  # 只打前100个字符
        break
    except (UnicodeDecodeError, FileNotFoundError):
        print(f"使用 {enc} 编码失败，尝试下一个...")

from io import StringIO

# === 写入 StringIO ===
sio = StringIO()
sio.write("第一行内容\n")
sio.write("第二行内容\n")
sio.write("第三行内容\n")

# 获取当前写入的全部内容
print("=== 获取 StringIO 中的内容 ===")
print(sio.getvalue())  # 获取全部已写入的字符串
# 此时指针在末尾

# === 从 StringIO 读取 ===
sio.seek(0)            # 把指针移到开头，否则读不到内容！
print("=== 逐行读取 ===")
for line in sio:
    print(line.strip())

sio.close()            # 用完关闭（虽然程序结束时也会自动释放）


# === 从已有字符串创建 StringIO ===
text = "Hello\nWorld\nPython"
sio2 = StringIO(text)  # 直接传入初始内容
print(sio2.read())     # 可以直接读
sio2.close()

from io import BytesIO

# === 写入二进制数据 ===
bio = BytesIO()
bio.write("你好".encode("utf-8"))  # 把字符串编码成 bytes 再写入
bio.write(b" World")               # 直接写入 bytes（注意前缀 b）

bio.seek(0)
data = bio.read()
print(f"二进制数据：{data}")
print(f"解码后：{data.decode('utf-8')}")
bio.close()


# === 处理图片（模拟：下载后不存盘直接处理） ===
# 假设 image_bytes 是从网络下载的图片数据
image_bytes = b'\x89PNG\r\n...'  # 模拟的 PNG 二进制数据

bio2 = BytesIO(image_bytes)   # 从二进制数据创建 BytesIO
# 可以直接传给 PIL 等库：
# from PIL import Image
# img = Image.open(bio2)
bio2.close()

import os

# === 文件操作 ===

# 重命名文件
os.rename("old_name.txt", "new_name.txt")

# 删除文件（不存在会报错，需先检查）
if os.path.exists("temp.txt"):
    os.remove("temp.txt")
else:
    print("文件不存在，无需删除")

# 检查文件/目录是否存在
print(os.path.exists("data.txt"))   # 是否存在
print(os.path.isfile("data.txt"))   # 是否存在且是文件
print(os.path.isdir("my_folder"))   # 是否存在且是目录

# 获取文件大小（字节）
size = os.path.getsize("data.txt")
print(f"文件大小：{size} 字节")

# === 目录操作 ===

# 创建单个目录（父目录不存在会报错）
os.mkdir("new_folder")

# 递归创建多层目录（推荐！父目录不存在自动创建）
os.makedirs("a/b/c/d", exist_ok=True)  # exist_ok=True：已存在不报错

# 列出目录内容（只返回名字）
items = os.listdir(".")  # "." 表示当前目录
print("当前目录内容：")
for item in items:
    print(f"  {item}")

# 递归遍历目录树
print("\n=== 递归遍历 ===")
for root, dirs, files in os.walk("."):
    # root: 当前目录路径
    # dirs: 当前目录下的子目录列表
    # files: 当前目录下的文件列表
    for file in files:
        print(os.path.join(root, file))

# 删除空目录（目录不为空会报错）
os.rmdir("empty_folder")

# 获取当前工作目录
print(f"当前工作目录：{os.getcwd()}")

# 切换工作目录
# os.chdir("another_folder")

from pathlib import Path

# === 创建 Path 对象 ===
p = Path("data") / "subfolder" / "file.txt"  # 用 / 拼接路径！
print(p)  # data/subfolder/file.txt (Linux) 或 data\subfolder\file.txt (Windows)

# === 文件操作 ===

# 检查
print(p.exists())      # 是否存在
print(p.is_file())     # 是否是文件
print(p.is_dir())      # 是否是目录

# 获取属性
print(p.name)          # "file.txt"（文件名）
print(p.stem)          # "file"（不含后缀）
print(p.suffix)        # ".txt"（后缀）
print(p.parent)        # data/subfolder（父目录）
print(p.stat().st_size)  # 文件大小（字节）

# 读取和写入（直接一行搞定！）
# Path("hello.txt").write_text("你好，Pathlib！", encoding="utf-8")
# content = Path("hello.txt").read_text(encoding="utf-8")

# === 目录操作 ===

# 创建目录（exist_ok=True 表示已存在不报错）
Path("my_project/data").mkdir(parents=True, exist_ok=True)

# 遍历目录
print("当前目录内容：")
for item in Path(".").iterdir():
    if item.is_file():
        print(f"  [文件] {item.name}")
    elif item.is_dir():
        print(f"  [目录] {item.name}")

# 通配符匹配（类似正则但更简单）
print("\n所有 .txt 文件：")
for txt_file in Path(".").glob("*.txt"):
    print(f"  {txt_file}")

# 递归匹配（** 表示任意层级）
print("\n所有 .py 文件（递归）：")
for py_file in Path(".").rglob("*.py"):
    print(f"  {py_file}")

import os

# 拼接路径（自动用正确的分隔符！）
path = os.path.join("folder", "subfolder", "file.txt")
print(f"拼接结果：{path}")
# Windows: folder\subfolder\file.txt
# Linux:   folder/subfolder/file.txt

# 拆分路径
dir_part = os.path.dirname("/home/user/file.txt")   # /home/user
base_part = os.path.basename("/home/user/file.txt")  # file.txt
name, ext = os.path.splitext("document.pdf")         # ('document', '.pdf')
print(f"目录部分：{dir_part}")
print(f"文件名：{base_part}")
print(f"主名：{name}，后缀：{ext}")

# 获取绝对路径
abs_path = os.path.abspath(".")  # 当前目录的绝对路径
print(f"当前目录绝对路径：{abs_path}")

# 路径规范化（把 / 和 \ 统一成系统格式）
normalized = os.path.normpath("a/b/../c/./d")
print(f"规范化后：{normalized}")  # a\c\d (Windows) 或 a/c/d (Linux)

# 判断路径类型
path = "data.txt"
print(os.path.exists(path))     # 是否存在
print(os.path.isfile(path))     # 是否文件
print(os.path.isdir(path))      # 是否目录
print(os.path.isabs(path))      # 是否绝对路径

from pathlib import Path

# 创建路径对象
home = Path.home()           # 用户主目录
cwd = Path.cwd()             # 当前工作目录
data = Path("data") / "subfolder" / "file.txt"  # 优雅拼接

print(f"用户主目录：{home}")
print(f"当前目录：{cwd}")
print(f"拼接路径：{data}")

# === 路径信息 ===
p = Path("C:/Users/小明/Documents/report.pdf")
print(f"文件名：{p.name}")            # report.pdf
print(f"不含后缀：{p.stem}")          # report
print(f"后缀：{p.suffix}")            # .pdf
print(f"后缀列表：{p.suffixes}")       # ['.pdf']
print(f"父目录：{p.parent}")          # C:\Users\小明\Documents
print(f"所有父目录：{list(p.parents)}") # 从近到远的所有父级

# === 路径转换 ===
print(f"绝对路径：{p.absolute()}")     # 转绝对路径
print(f"解析符号链接：{p.resolve()}")   # 绝对路径 + 解析所有符号链接
print(f"转 string：{str(p)}")          # 转为普通字符串

# === 路径判断 ===
target = Path("data.txt")
print(target.exists())         # 存在？
print(target.is_file())        # 是文件？
print(target.is_dir())         # 是目录？

# === 读取和写入（pathlib 超便捷功能） ===
# 读取整个文本文件
# content = Path("config.json").read_text(encoding="utf-8")
# 写入整个文本文件
# Path("output.txt").write_text("新内容", encoding="utf-8")
# 读取二进制文件
# data = Path("image.png").read_bytes()
# 写入二进制文件
# Path("copy.png").write_bytes(data)

from pathlib import Path

# 不要这样写（不跨平台）：
# path = "data\images\photo.jpg"        # Windows only!

# 这样写（跨平台，推荐）：
path = Path("data") / "images" / "photo.jpg"
# 或者：
# path = Path("data", "images", "photo.jpg")

# 构建输出路径
input_file = Path("data") / "raw" / "input.csv"
output_dir = Path("output") / "results"
output_dir.mkdir(parents=True, exist_ok=True)  # 确保目录存在
output_file = output_dir / "processed.csv"

import pickle

# === 序列化（存到文件） ===
data = {
    "name": "小明",
    "age": 18,
    "scores": [85, 90, 78],
    "is_student": True
}

# 把字典写入文件
with open("student.pkl", "wb") as f:  # 注意：必须用 wb 二进制模式！
    pickle.dump(data, f)

# === 反序列化（从文件读回来） ===
with open("student.pkl", "rb") as f:  # 注意：必须用 rb 二进制模式！
    loaded_data = pickle.load(f)

print(loaded_data)
# {'name': '小明', 'age': 18, 'scores': [85, 90, 78], 'is_student': True}
print(type(loaded_data))  # <class 'dict'>


# === 序列化为内存中的 bytes（不发文件） ===
bytes_data = pickle.dumps(data)
print(f"字节长度：{len(bytes_data)}")

# 反序列化回来
restored_data = pickle.loads(bytes_data)
print(restored_data["name"])  # 小明


# === 自定义对象的序列化 ===
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Student(name='{self.name}', age={self.age})"

# 保存自定义对象
s1 = Student("小红", 20)
with open("student_obj.pkl", "wb") as f:
    pickle.dump(s1, f)

# 读取自定义对象
with open("student_obj.pkl", "rb") as f:
    s2 = pickle.load(f)

print(s2)  # Student(name='小红', age=20)
print(f"姓名：{s2.name}，年龄：{s2.age}")

import json

# === 序列化（Python → JSON 字符串） ===
data = {
    "name": "小明",
    "age": 18,
    "scores": [85, 90, 78],
    "is_student": True,
    "address": None
}

# 写入 JSON 文件
with open("student.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
    # ensure_ascii=False：中文正常显示，不转成 \uXXXX
    # indent=2：格式化缩进，让文件好看

# 转成 JSON 字符串（不发文件）
json_str = json.dumps(data, ensure_ascii=False, indent=2)
print(json_str)


# === 反序列化（JSON → Python） ===

# 从文件读取
with open("student.json", "r", encoding="utf-8") as f:
    loaded = json.load(f)

print(loaded["name"])  # 小明

# 从字符串解析
json_text = '{"name": "小红", "age": 20}'
parsed = json.loads(json_text)
print(parsed["name"])  # 小红

import json
from datetime import datetime

# 错误场景 1：序列化 datetime 对象
try:
    data = {"time": datetime.now()}
    json.dumps(data)
except TypeError as e:
    print(f"错误：{e}")
    # 错误：Object of type datetime is not JSON serializable

# 解决方案：自定义编码器
class DateTimeEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.strftime("%Y-%m-%d %H:%M:%S")
        return super().default(obj)

data = {"time": datetime.now()}
json_str = json.dumps(data, cls=DateTimeEncoder, ensure_ascii=False)
print(json_str)
# {"time": "2026-07-01 14:30:00"}


# 错误场景 2：序列化 set/tuple 等类型
try:
    json.dumps({"tags": {"python", "java"}})  # set 不能直接序列化
except TypeError as e:
    print(f"错误：{e}")
    # 错误：Object of type set is not JSON serializable

# 解决方案：转为 list
data = {"tags": list({"python", "java"})}
json_str = json.dumps(data, ensure_ascii=False)
print(json_str)  # {"tags": ["python", "java"]}


# 错误场景 3：反序列化时 JSON 格式不对
try:
    json.loads('{name: 小明}')  # 键和字符串值必须用双引号！
except json.JSONDecodeError as e:
    print(f"JSON 格式错误：{e}")

# 错误写法
f = open("data.txt", "r")
content = f.read()
# 忘了 f.close()！文件一直处于打开状态

# 正确写法
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()
# with 自动关闭，安全又省心

# 错误写法（Windows only）
path = "data\images\photo.jpg"  # \i 被当成转义符！

# 正确写法（跨平台）
from pathlib import Path
path = Path("data") / "images" / "photo.jpg"
# 或者
import os
path = os.path.join("data", "images", "photo.jpg")

# 错误写法
with open("data.txt", "w") as f:           # 写入时没指定编码
    f.write("你好")
with open("data.txt", "r", encoding="gbk") as f:  # 读取时用了不同编码
    print(f.read())  # 乱码！

# 正确写法：写入和读取用同一种编码
with open("data.txt", "w", encoding="utf-8") as f:
    f.write("你好")
with open("data.txt", "r", encoding="utf-8") as f:
    print(f.read())  # 你好

# 错误写法：本想往文件里加内容，结果把原内容清空了
with open("important.txt", "w") as f:
    f.write("新增内容")  # 原来的内容被清空了！

# 正确写法：用 "a" 追加模式
with open("important.txt", "a", encoding="utf-8") as f:
    f.write("新增内容")  # 追加在末尾，不丢失原内容

# 错误写法（文件 2GB，内存只有 4GB）
with open("huge_file.log", "r") as f:
    content = f.read()  # 一次性读入内存，可能撑爆

# 正确写法：逐行读取
with open("huge_file.log", "r", encoding="utf-8") as f:
    for line in f:
        process(line)  # 每次只处理一行，内存友好

# 错误写法
with open("data.pkl", "w") as f:  # 文本模式！会报错
    pickle.dump(data, f)

# 正确写法：pickle 必须用二进制模式
with open("data.pkl", "wb") as f:
    pickle.dump(data, f)

import json

# 错误写法
data = {"created_at": datetime.now(), "tags": {"a", "b"}}
json.dumps(data)  # TypeError!

# 正确写法：先转换为 JSON 支持的类型
data = {
    "created_at": datetime.now().isoformat(),  # datetime → 字符串
    "tags": list({"a", "b"})                   # set → list
}
json.dumps(data)

# 错误写法：父目录 a 不存在
os.mkdir("a/b/c")  # FileNotFoundError!

# 正确写法
os.makedirs("a/b/c", exist_ok=True)
# 或
from pathlib import Path
Path("a/b/c").mkdir(parents=True, exist_ok=True)

from io import StringIO

sio = StringIO("Hello World")
print(sio.read())   # Hello World（光标在末尾了）
print(sio.read())   # 空字符串！（光标在末尾，没内容了）

# 正确做法：seek(0) 重置光标
sio.seek(0)
print(sio.read())   # Hello World

# 错误写法：每次循环都 open/close，性能极差
for i in range(10000):
    with open("log.txt", "a") as f:
        f.write(f"行 {i}\n")

# 正确写法：打开一次，写多次
with open("log.txt", "a") as f:
    for i in range(10000):
        f.write(f"行 {i}\n")

文件 IO 学习路线图：

1. 打开文件        →  open("文件名", "模式", encoding="utf-8")
2. 安全读写        →  with 语句自动管理资源
3. 内存临时文件    →  StringIO（文本）、BytesIO（二进制）
4. 文件目录操作    →  os 模块（传统）或 pathlib 模块（推荐）
5. 跨平台路径      →  Path("a") / "b" / "c" 代替字符串拼接
6. 数据持久化      →  json（通用）、pickle（Python 专属）

记住三句话：
- 读写文本别忘了 encoding="utf-8"
- 打开文件别忘了用 with
- 路径拼接别忘了用 Path 或 os.path.join