小孙那天写了一个文件整理脚本，要把他下载文件夹里的文件按类型分类，移动到对应的子文件夹里。图片进images，文档进documents，压缩包进archives。
他最初的代码大概长这样：
import os
download_dir = "/Users/xiaosun/Downloads"
for filename in os.listdir(download_dir):
full_path = download_dir + "/" + filename
if filename.endswith((".jpg", ".png", ".gif")):
target_dir = download_dir + "/images"
if not os.path.exists(target_dir):
os.makedirs(target_dir)
os.rename(full_path, target_dir + "/" + filename)
elif filename.endswith((".pdf", ".doc", ".docx")):
target_dir = download_dir + "/documents"
if not os.path.exists(target_dir):
os.makedirs(target_dir)
os.rename(full_path, target_dir + "/" + filename)
在自己 Mac 上跑得很好。后来他拿同样的脚本去帮同事整理 Windows 电脑上的文件，把download_dir改成"C:\\Users\\xiaosun\\Downloads"，结果只整理了一半就报错。他花了一个小时才弄明白：target_dir + "/" + filename里用的是正斜杠，而download_dir里是反斜杠，混在一起之后，某些系统调用直接失败了。
他把所有路径拼接都改成了os.path.join：
target_dir = os.path.join(download_dir, "images")
os.makedirs(target_dir, exist_ok=True)
os.rename(full_path, os.path.join(target_dir, filename))
这次跨平台了，但他每次要提取文件名、扩展名、父目录，都得调用不同的os.path函数。代码又长又啰嗦。
同事 review 时说：“你这个用pathlib重写一下会清爽很多。”然后给他看了这样一段代码：
from pathlib import Path
download_dir = Path.home() / "Downloads"
for file in download_dir.iterdir():
if file.suffix in {".jpg", ".png", ".gif"}:
target_dir = download_dir / "images"
target_dir.mkdir(exist_ok=True)
file.rename(target_dir / file.name)
代码短了一半，逻辑一目了然。小孙看完心里犯嘀咕：“pathlib到底是什么？为什么os.path能做的事它也能做？两者到底有什么区别？以后写代码到底该用哪个？”
先看一个最直观的对比
把同样的操作分别用两种方式写出来：
import os
from pathlib import Path
# 拼接路径
p1 = os.path.join("data", "logs", "app.log")
p2 = Path("data") / "logs" / "app.log"
# 提取文件名
name1 = os.path.basename(p1) # "app.log"
name2 = p2.name # "app.log"
# 提取扩展名
ext1 = os.path.splitext(p1)[1] # ".log"
ext2 = p2.suffix # ".log"
# 提取不带扩展名的文件名
stem1 = os.path.splitext(os.path.basename(p1))[0] # "app"
stem2 = p2.stem # "app"
# 提取父目录
parent1 = os.path.dirname(p1) # "data/logs"
parent2 = p2.parent # PosixPath("data/logs")
# 检查是否存在
exists1 = os.path.exists(p1)
exists2 = p2.exists()
功能上完全等价，但写法完全不同。
os.path是一组函数，每个函数接收字符串路径，返回字符串结果。你要拼接路径就调join，要取文件名就调basename，要取扩展名就调splitext。每个功能都是一个独立的工具，互相之间没有关联。
pathlib是一个对象。Path对象自己就知道怎么拼接、怎么取文件名、怎么取扩展名、怎么检查存在。所有操作都是这个对象的方法或属性，彼此关联，围绕同一个路径。
用一个生活场景来理解。你有一把钥匙，要打开一扇门。
os.path的做法是：你手里有一串单独的工具——一把螺丝刀用来拆螺丝，一把锤子用来敲钉子，一把钳子用来夹东西。每个工具独立使用，你要完成一个任务，得自己判断该拿哪个工具。
pathlib的做法是：你手里有一把瑞士军刀。所有工具都集成在一起，你需要什么功能，直接从这把刀上翻出来用。
区别一目了然：一个是一堆散装函数，一个是封装好的对象。
os.path：函数式风格，处理字符串
os.path是 Python 标准库里历史最悠久的路径处理模块。它的所有函数都接收字符串路径，返回字符串结果。
import os
path = "/home/user/data/file.txt"
print(os.path.basename(path)) # "file.txt"
print(os.path.dirname(path)) # "/home/user/data"
print(os.path.splitext(path)) # ("/home/user/data/file", ".txt")
print(os.path.exists(path)) # True/False
print(os.path.isfile(path)) # True/False
print(os.path.isdir(path)) # True/False
os.path的优点是简单直接。每个函数做一件事，输入输出都是字符串，没有额外概念。对于简单的路径操作，用os.path完全够用。
但它的缺点也很明显：字符串没有路径语义。"/home/user"只是一个普通字符串，Python 不知道它是个路径。你可以对它做任何字符串操作，包括那些对路径来说毫无意义的操作：
path = "/home/user"
print(path.upper()) # "/HOME/USER"，可能不是你想要的
print(path * 2) # "/home/user/home/user"，毫无意义
print(path + 123) # TypeError
因为路径就是字符串，你很容易写出“看起来对但实际有坑”的代码：
path = "/home/user"
new_path = path + "data/file.txt" # "/home/userdata/file.txt"，少了斜杠
正确的写法是os.path.join(path, "data", "file.txt")，但很多人会下意识用+拼接，然后在跨平台时出问题。
pathlib：面向对象风格，处理 Path 对象
pathlib是 Python 3.4 引入的模块，用面向对象的方式处理路径。核心是Path类，它表示一个路径，并提供了一堆方法和属性。
from pathlib import Path
p = Path("/home/user/data/file.txt")
print(p.name) # "file.txt"
print(p.stem) # "file"
print(p.suffix) # ".txt"
print(p.parent) # PosixPath("/home/user/data")
print(p.exists()) # True/False
print(p.is_file()) # True/False
print(p.is_dir()) # True/False
Path对象不是字符串。它是一个独立的对象，有自己的方法和属性。字符串上的upper()、*这些操作对它不适用（除非你显式转成字符串）。
pathlib最大的特色是支持/运算符来拼接路径：
from pathlib import Path
base = Path("/home/user")
full = base / "data" / "file.txt"
print(full) # "/home/user/data/file.txt"
这个/运算符会自动处理路径分隔符。在 Windows 上，Path会自动用\；在 Linux/macOS 上，自动用/。你不需要关心平台差异。
Path对象还支持链式调用：
p = Path("/home/user/data/file.txt")
print(p.parent.parent.name) # "home"
print(p.with_suffix(".json")) # "/home/user/data/file.json"
print(p.with_name("other.txt")) # "/home/user/data/other.txt"
这种链式风格在os.path里很难实现，因为每一步都要把结果传给下一个函数。
核心区别一：字符串 vs 对象
这是两者最本质的区别。
os.path的所有操作都基于字符串。路径就是字符串，函数接收字符串、返回字符串。优点是简单，缺点是字符串没有路径语义，容易混入无关的字符串操作。
pathlib的所有操作都基于Path对象。路径是一个有类型的对象，只能做路径该做的事。你不能对Path对象调upper()，也不能用*重复它。这在编译期（或者说在运行时）就阻止了一类错误。
from pathlib import Path
p = Path("/home/user")
p.upper() # AttributeError: 'PosixPath' object has no attribute 'upper'
如果你确实需要字符串，可以显式转换：
s = str(p) # "/home/user"
这种显式转换是一个“减速带”，提醒你“我正在把路径当字符串用，确认一下是否真的需要”。
核心区别二：函数 vs 方法/属性
os.path是一组函数，每个功能都是独立的。pathlib是一个对象，所有功能都是这个对象的方法或属性。
对于简单操作，两者差别不大。但对于复杂操作，pathlib的链式风格更清晰。
比如，你要获取一个文件所在目录的父目录的名字：
# os.path
path = "/home/user/data/file.txt"
parent_name = os.path.basename(os.path.dirname(os.path.dirname(path)))
# 或者
parent_name = os.path.basename(os.path.dirname(path))
# pathlib
p = Path("/home/user/data/file.txt")
parent_name = p.parent.parent.name
pathlib的写法更自然，从左到右读起来就像一句话：“这个文件的父目录的父目录的名字”。
再比如，你要把文件的扩展名从.txt改成.json，并放到另一个目录：
# os.path
old_path = "/home/user/data/file.txt"
base = os.path.splitext(os.path.basename(old_path))[0]
new_path = os.path.join("/home/user/backup", base + ".json")
# pathlib
p = Path("/home/user/data/file.txt")
new_path = Path("/home/user/backup") / p.with_suffix(".json").name
pathlib的with_suffix()直接处理了扩展名替换，不需要手动拆分和拼接。
核心区别三：/ 运算符
pathlib支持用/拼接路径，这是它最显眼的语法特色。
from pathlib import Path
p = Path("data") / "logs" / "app.log"
print(p) # "data/logs/app.log"
这个/运算符是Path.__truediv__方法的重载。它不仅能拼接Path对象，也能拼接字符串：
p = Path("data") / "logs" / "app.log" # 都可以
但要注意：/运算符的右边如果是绝对路径，会丢弃左边的内容。
print(Path("/home/user") / "/etc/passwd") # "/etc/passwd"
这和os.path.join的行为一致，但容易让人意外。
核心区别四：平台透明
os.path在底层使用当前操作系统的路径分隔符。在 Windows 上，os.path.join("a", "b")返回"a\\b"；在 Linux 上返回"a/b"。
pathlib也是平台透明的，但它的透明性更彻底。Path对象在创建时就知道自己是什么类型（PosixPath还是WindowsPath），所有操作都基于这个类型。
from pathlib import Path
p = Path("data/logs/app.log")
print(type(p)) # Linux/macOS: <class 'pathlib.PosixPath'>
# Windows: <class 'pathlib.WindowsPath'>
Path在 Windows 上会自动处理盘符、反斜杠、大小写不敏感等问题：
p = Path("C:/Users/test/file.txt")
print(p) # Windows: "C:\\Users\\test\\file.txt"
而os.path虽然也能跨平台，但它更多是“在运行时根据平台选择分隔符”，对路径的语义理解没有pathlib深。
核心区别五：文件读写
pathlib的Path对象直接提供了文件读写方法，这是os.path没有的。
from pathlib import Path
p = Path("data.txt")
# 读取文本
content = p.read_text(encoding="utf-8")
# 写入文本
p.write_text("hello", encoding="utf-8")
# 读取字节
data = p.read_bytes()
# 写入字节
p.write_bytes(b"hello")
用os.path的话，需要先拼路径，再open：
import os
p = os.path.join("data", "data.txt")
with open(p, "r", encoding="utf-8") as f:
content = f.read()
pathlib的一行read_text()替代了三行open/read/close。对于简单的读写场景，这能省不少代码。
坑一：用字符串拼接路径
这是最经典的坑，也是小孙最初踩的。
# 错误
path = "data" + "/" + "file.txt"
# 错误：在 Windows 上可能出错
path = "data" + "\\" + "file.txt"
# 正确（os.path）
path = os.path.join("data", "file.txt")
# 正确（pathlib）
path = Path("data") / "file.txt"
字符串拼接的问题在于，它依赖你手动写对分隔符。一旦换了平台，或者路径里有特殊字符，就会出问题。永远用os.path.join或Path /来拼接路径。
坑二：os.path.join 遇到绝对路径会丢弃前面的部分
import os
from pathlib import Path
print(os.path.join("/home/user", "/etc/passwd")) # "/etc/passwd"
print(Path("/home/user") / "/etc/passwd") # "/etc/passwd"
两者行为一致，但都容易让人意外。如果第二个参数以/开头，它会被当成绝对路径，前面的部分被丢弃。
如果你不确定参数是不是绝对路径，先检查一下：
from pathlib import Path
def safe_join(base, *parts):
base = Path(base)
result = base
for part in parts:
part = Path(part)
if part.is_absolute():
raise ValueError(f"不能拼接绝对路径: {part}")
result = result / part
return result
坑三：Path 对象不是字符串
很多老代码、老库只接受字符串路径。把Path对象传进去，可能报错。
from pathlib import Path
import json
p = Path("data.json")
data = json.loads(p.read_text()) # 可以，read_text 返回字符串
# 但如果你要把 Path 传给只接受字符串的函数
some_old_function(p) # 可能报错
# 需要显式转换
some_old_function(str(p))
好消息是，从 Python 3.6 开始，open()、os.path的大部分函数、以及很多标准库都接受Path对象（因为它们实现了os.PathLike接口）。但第三方库不一定，遇到报错时，str(path)是万能解法。
坑四：os.makedirs 和 Path.mkdir 的参数不同
import os
from pathlib import Path
# os.makedirs：默认会创建所有中间目录
os.makedirs("a/b/c", exist_ok=True)
# Path.mkdir：默认只创建最后一级，中间目录不存在会报错
Path("a/b/c").mkdir(exist_ok=True) # FileNotFoundError
# 需要显式传 parents=True
Path("a/b/c").mkdir(parents=True, exist_ok=True)
os.makedirs的行为相当于Path.mkdir(parents=True)。用pathlib时忘了parents=True，会在中间目录不存在时直接报错。
坑五：os.listdir 和 Path.iterdir 的区别
import os
from pathlib import Path
# os.listdir：返回文件名列表（字符串）
files = os.listdir("data") # ["a.txt", "b.txt", "subdir"]
# Path.iterdir：返回 Path 对象生成器
for p in Path("data").iterdir():
print(p) # PosixPath("data/a.txt"), ...
# Path.glob：支持模式匹配，返回 Path 对象
for p in Path("data").glob("*.txt"):
print(p) # 只返回 .txt 文件
os.listdir返回字符串列表，Path.iterdir返回Path对象生成器。后者在后续操作中更方便，因为你拿到的直接是Path对象，可以继续调.suffix、.name等属性。
Path.glob比os.listdir加字符串过滤更清晰：
# os.listdir + 过滤
files = [f for f in os.listdir("data") if f.endswith(".txt")]
# Path.glob
files = list(Path("data").glob("*.txt"))
什么时候用 os.path，什么时候用 pathlib？
判断标准：
**新项目、Python 3.4+**：优先用pathlib。代码更简洁，语义更清晰，平台兼容性更好。
需要和老代码、老库交互：如果对方只接受字符串，用os.path更方便，或者用pathlib然后str()转换。
简单的路径拼接：两者都行。Path / "file"比os.path.join("dir", "file")更短。
需要频繁做路径分解、替换、链式操作：用pathlib。p.parent.parent.name比嵌套os.path.dirname清晰得多。
需要遍历目录、模式匹配：用pathlib的iterdir()和glob()。
只需要检查存在、是否是文件：两者都行。os.path.exists()和p.exists()等价。
需要读取/写入小文件：用pathlib的read_text()/write_text()，更简洁。
回到小孙的故事
小孙最终的脚本是这样的：
from pathlib import Path
download_dir = Path.home() / "Downloads"
for file in download_dir.iterdir():
if file.is_file():
if file.suffix.lower() in {".jpg", ".png", ".gif"}:
target_dir = download_dir / "images"
target_dir.mkdir(exist_ok=True)
file.rename(target_dir / file.name)
elif file.suffix.lower() in {".pdf", ".doc", ".docx"}:
target_dir = download_dir / "documents"
target_dir.mkdir(exist_ok=True)
file.rename(target_dir / file.name)
Path.home()自动获取用户主目录，跨平台。/运算符拼接路径，跨平台。file.suffix直接拿扩展名，不需要os.path.splitext。file.rename()直接移动文件，不需要拼完整路径再调os.rename。
他后来在团队文档里写了一条：“新代码用pathlib。路径拼接用/，别用+。提取文件名用.name，扩展名用.suffix，父目录用.parent。需要字符串时用str(p)转换。mkdir记得加parents=True。”
这个区分看起来简单，但真到写代码的时候，很多人会习惯性地写os.path.join，然后在需要提取文件名、扩展名、父目录时，写出一长串嵌套函数调用。或者用字符串拼接路径，然后在跨平台时突然出错。
记住那个瑞士军刀的比喻：os.path是一堆散装工具，每个工具独立工作；pathlib是一把集成的瑞士军刀，所有功能都在一个对象上。你要做什么，直接从对象上找对应的方法或属性就行。
文件路径本身不难，难的是想清楚“这个路径需要做多少种操作、要不要跨平台、要不要和老代码交互”。想清楚了，os.path和pathlib就不再是坑，而是两个各有适用场景的工具。新代码优先pathlib，老代码维护用os.path，混用时记得str()转换，路径拼接永远别用+。
