try:
    with open("output.txt", "x") as f:
        f.write("新内容")
except FileExistsError:
    print("文件已存在，不会覆盖")

# ❌ 不推荐 — 容易忘记关闭文件
f = open("data.txt", "r")
content = f.read()
f.close()  # 如果中间发生异常，这行不会执行！

# ✅ 推荐 — 自动关闭
with open("data.txt", "r") as f:
    content = f.read()
# 离开缩进块后自动调用 f.close()

# with 语句的等价实现
f = open("data.txt", "r")  # __init__
try:
    f.__enter__()           # 进入上下文
    content = f.read()
finally:
    f.__exit__(...)         # 发生异常也会执行

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()
        return False

with FileManager("data.txt", "r") as f:
    print(f.read())

from contextlib import contextmanager

@contextmanager
def open_file(filename, mode):
    f = open(filename, mode)
    try:
        yield f
    finally:
        f.close()

with open_file("data.txt", "r") as f:
    content = f.read()

# 读取图片 → 必须用二进制
with open("photo.jpg", "rb") as f:
    data = f.read()  # bytes 对象

# 读取 JSON → 用文本（默认）
with open("data.json", "r", encoding="utf-8") as f:
    data = json.load(f)  # str 对象

# 处理压缩文件 → 二进制
import gzip
with gzip.open("archive.gz", "rb") as f:
    content = f.read()

---

## 四、文件指针与 seek/tell

### 4.1 文件指针概念

文件指针（文件位置指示器）记录当前读写位置。每次读写操作后，指针自动向后移动。

f.seek(offset, whence)

# whence 参数:
#   os.SEEK_SET (0) — 从文件开头计算 (默认)
#   os.SEEK_CUR (1) — 从当前位置计算
#   os.SEEK_END (2) — 从文件末尾计算

with open("data.txt", "r") as f:
    f.seek(10)              # 移动到第10个字符
    print(f.read(5))        # 读取5个字符

    f.seek(0, os.SEEK_SET)  # 回到开头
    print(f.read(5))        # 重新读取前5个字符

    f.seek(-5, os.SEEK_END) # 移动到末尾前5个字符
    print(f.read())         # 读取最后5个字符

with open("data.bin", "rb") as f:
    # 末尾前10字节
    f.seek(-10, 2)        # 2 = SEEK_END
    print(f.read())

    # 当前位置后移20字节
    f.seek(20, 1)         # 1 = SEEK_CUR

# 编码不匹配 → UnicodeDecodeError
with open("chinese.txt", "r", encoding="ascii") as f:
    content = f.read()
# UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4

# 指定正确编码 → 正常工作
with open("chinese.txt", "r", encoding="utf-8") as f:
    content = f.read()

# 读取未知编码的文件 → 尝试推断
import chardet
with open("unknown.txt", "rb") as f:
    raw = f.read()
    result = chardet.detect(raw)
    encoding = result["encoding"]
    content = raw.decode(encoding)

# 严格模式（默认）— 遇到非法编码抛出异常
with open("data.txt", "r", encoding="utf-8", errors="strict") as f:
    pass

# 忽略模式 — 跳过无法解码的字符（可能丢失数据！）
with open("data.txt", "r", encoding="utf-8", errors="ignore") as f:
    pass

# 替换模式 — 用 ? 替换无法解码的字符
with open("data.txt", "r", encoding="utf-8", errors="replace") as f:
    pass

# 编码时替代
with open("output.txt", "w", encoding="ascii", errors="xmlcharrefreplace") as f:
    f.write("你好")  # 写入 你好

# 跳过 BOM 读取
import codecs
with open("bom_file.txt", "r", encoding="utf-8-sig") as f:
    content = f.read()  # BOM 自动被移除

---

## 六、常见文件操作陷阱与避坑

### 🚫 陷阱 1：大文件直接读取

```python
# ❌ 不要这样！内存会爆
with open("huge_file.txt") as f:
    content = f.read()  # 整个文件读入内存

# ✅ 逐行/逐块读取
with open("huge_file.txt") as f:
    for line in f:          # 迭代器方式，只存一行在内存
        process(line)

# 或分块读取
with open("huge_file.bin", "rb") as f:
    while chunk := f.read(8192):  # 每次读 8KB
        process(chunk)

# 在 Windows 上用二进制模式写入文本
with open("data.txt", "wb") as f:
    f.write("line1\nline2\n".encode())  # ❌ Windows 上可能显示为单行

# ✅ 用文本模式让 Python 处理换行符
with open("data.txt", "w") as f:
    f.write("line1\nline2\n")  # Windows → \r\n, Linux → \n

# ❌ 依赖默认编码（不同系统可能不同）
with open("data.txt") as f:     # Windows: gbk, Linux: utf-8
    ...

# ✅ 显式指定编码
with open("data.txt", encoding="utf-8") as f:
    ...

# ❌ 写入后指针在末尾，读取不到内容
with open("data.txt", "w+") as f:
    f.write("Hello")
    content = f.read()  # 空字符串！

# ✅ 写入后 seek 到开头
with open("data.txt", "w+") as f:
    f.write("Hello")
    f.seek(0)
    content = f.read()  # "Hello"

# 使用文件锁防止并发写入
import fcntl

with open("shared.log", "a") as f:
    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
    f.write("important data\n")
    fcntl.flock(f.fileno(), fcntl.LOCK_UN)

import time

# 测试文件：100MB 文本
filename = "test_100mb.txt"

# 方法 1：read() 全量读取
start = time.time()
with open(filename) as f:
    data = f.read()
print(f"read() 全量: {time.time()-start:.3f}s")

# 方法 2：readlines()
start = time.time()
with open(filename) as f:
    lines = f.readlines()
print(f"readlines(): {time.time()-start:.3f}s")

# 方法 3：逐行迭代
start = time.time()
with open(filename) as f:
    for line in f:
        pass
print(f"迭代器: {time.time()-start:.3f}s")

# 方法 4：分块读取
start = time.time()
with open(filename) as f:
    while chunk := f.read(65536):
        pass
print(f"64KB 块: {time.time()-start:.3f}s")