os.path.join(path, *paths)

os.path.join(path, *paths) 是 Python 标准库中 os.path 模块的一个函数，用于连接一个或多个路径组件。它的主要作用是以一种跨平台（操作系统无关）的方式合并路径。

函数 os.path.join 接受一个或多个字符串作为参数，并返回一个表示合并路径的字符串。在 Windows 系统中，路径组件之间使用反斜杠 \ 分隔，而在 Unix-like 系统（如 Linux 和 macOS）中，使用正斜杠 / 分隔。os.path.join 会根据运行代码的操作系统自动选择正确的分隔符。

这里是一些使用 os.path.join 的例子：

import os# 假设当前操作系统是 Windows
# os.path.join('C:\\', 'path', 'to', 'file.txt') 将返回 'C:\\path\\to\\file.txt'# 假设当前操作系统是 Unix-like (如 Linux 或 macOS)
# os.path.join('/home', 'user', 'file.txt') 将返回 '/home/user/file.txt'# 使用变量
base_path = '/home/user'
file_name = 'file.txt'
full_path = os.path.join(base_path, file_name)
print(full_path)  # 输出: /home/user/file.txt# 使用可变数量的路径组件
components = ['/home', 'user', 'documents', '2023', 'report.docx']
full_path = os.path.join(*components)
print(full_path)  # 输出: /home/user/documents/2023/report.docx

在上面的例子中，*components 表示将 components 列表中的所有元素作为单独的参数传递给 os.path.join 函数。

使用 os.path.join 的一个主要好处是，你不需要担心在不同的操作系统上路径分隔符的差异。你的代码可以更加可移植，并且更容易维护。

os.path.normcase(path)

os.path.normcase(path) 是 Python 标准库中 os.path 模块的一个函数，用于将路径字符串转换成操作系统所使用的标准形式。这在需要处理跨平台路径时特别有用，因为不同的操作系统使用不同的路径分隔符和大小写敏感性。

在 Windows 系统中，路径通常使用反斜杠 \ 作为分隔符，并且文件名是大小写不敏感的。而在 Unix-like 系统（如 Linux 和 macOS）中，路径使用正斜杠 / 作为分隔符，并且文件名通常是大小写敏感的。os.path.normcase 函数会根据运行代码的操作系统自动调整路径字符串的格式。

例如：

import os# 在 Windows 上运行
path = "/home/user/documents/report.txt"
normalized_path = os.path.normcase(path)
print(normalized_path)  # 输出可能是：'\home\user\documents\report.txt'# 在 Unix-like 系统上运行
path = "/home/user/documents/report.txt"
normalized_path = os.path.normcase(path)
print(normalized_path)  # 输出仍然是：'/home/user/documents/report.txt'

在 Windows 上，os.path.normcase 通常会将正斜杠 / 转换成反斜杠 \，并将路径字符串中所有字符转换成小写（因为 Windows 文件系统通常是大小写不敏感的）。而在 Unix-like 系统上，os.path.normcase 通常不会改变路径字符串，因为它已经是标准形式。

这个函数在处理需要跨平台兼容性的代码时非常有用，特别是当你需要将路径与文件系统进行交互时。通过先使用 os.path.normcase 标准化路径，你可以减少由于路径格式不同而导致的问题。

os.path.normpath(path)

os.path.normpath(path) 是 Python 标准库中 os.path 模块的一个函数，用于规范化路径字符串，消除其中的冗余元素，如 .（代表当前目录）和 …（代表父目录）。这个函数返回一个规范化后的路径字符串，使得该路径指向与原始路径相同的位置，但表示形式更加简洁。

os.path.normpath 主要处理以下几种情况：

• 消除单个点 . 表示的当前目录。
• 消除双点 … 表示的父目录，并将其替换为上一级目录的路径。
• 消除路径中的斜杠 / 或反斜杠 \，根据操作系统的不同使用相应的路径分隔符。
• 消除路径中连续的路径分隔符。

下面是一些使用 os.path.normpath 的例子：

import os# 示例路径
path = "/home//user/./documents/../pictures/./image.jpg"# 规范化路径
normalized_path = os.path.normpath(path)# 输出规范化后的路径
print(normalized_path)  # 输出: '/home/user/pictures/image.jpg'

在这个例子中，os.path.normpath 删除了 . 表示的当前目录，以及 …/ 表示的上一级目录，并消除了多余的斜杠。

请注意，os.path.normpath 并不检查路径是否真的存在，它只是简单地规范化路径字符串。这意味着，即使规范化后的路径看起来是有效的，也不代表在文件系统中真的存在这样一个路径。

此外，os.path.normpath 也不会处理符号链接（在 Unix-like 系统中）或网络路径（如 UNC 路径在 Windows 中）。如果你需要处理这些复杂的路径情况，可能需要使用更高级的库或函数，如 os.path.realpath（用于解析符号链接并返回真实路径）或 os.path.abspath（用于返回当前工作目录的绝对路径）。

os.path.realpath(path, *, strict=False)

os.path.realpath(path, *, strict=False) 是 Python 标准库中 os.path 模块的一个函数，用于解析路径中的符号链接（在 Unix-like 系统中）并返回真实路径的绝对版本。

当 path 指向一个符号链接时，os.path.realpath 会返回该链接指向的原始文件或目录的绝对路径。这在需要知道文件或目录在文件系统中的真实位置时非常有用，尤其是当路径可能包含符号链接时。

参数 strict 是一个布尔值，默认为 False。当 strict 为 True 时，如果路径不存在，os.path.realpath 将引发 FileNotFoundError 异常。如果 strict 为 False（默认值），则即使路径不存在，该函数也不会引发异常，而是返回原始路径。

下面是一些使用 os.path.realpath 的例子：

import os# 假设 /real/path/to/file 是 /path/to/symlink 的真实路径
symlink_path = '/path/to/symlink'# 获取真实路径
real_path = os.path.realpath(symlink_path)
print(real_path)  # 输出: /real/path/to/file# 如果路径不存在且 strict=True，则会引发异常
try:real_path = os.path.realpath('/nonexistent/path', strict=True)
except FileNotFoundError:print("Path does not exist.")# 如果路径不存在且 strict=False，则返回原始路径
real_path = os.path.realpath('/nonexistent/path', strict=False)
print(real_path)  # 输出: /nonexistent/path

请注意，os.path.realpath 在 Windows 系统上可能不会解析某些类型的符号链接（如快捷方式），因为这些类型的符号链接在 Windows 文件系统中有不同的实现方式。在 Windows 上，os.path.realpath 主要用于解析硬链接和目录连接点（junction points）。

此外，os.path.realpath 不会检查文件或目录是否实际存在，除非 strict 参数设置为 True。

os.path.relpath(path, start=os.curdir)

os.path.relpath(path, start=os.curdir) 是 Python 标准库中 os.path 模块的一个函数，用于返回一个相对于指定起始路径 start 的相对路径。如果未指定 start，则默认为当前工作目录（os.curdir）。

这个函数对于在构建应用程序或脚本时，需要表示文件或目录之间的相对关系非常有用。它可以帮助你生成可移植的、不依赖于特定工作目录的文件路径。

下面是一些使用 os.path.relpath 的例子：

import os# 假设当前工作目录是 /home/user
# 我们想要获取相对于当前工作目录的 /home/user/documents/report.txt 的相对路径
abs_path = "/home/user/documents/report.txt"
rel_path = os.path.relpath(abs_path)print(rel_path)  # 输出: documents/report.txt# 我们可以指定一个不同的起始路径
start_path = "/home/user/projects"
rel_path_from_projects = os.path.relpath(abs_path, start_path)print(rel_path_from_projects)  # 输出: ../documents/report.txt

在这个例子中，os.path.relpath 返回了从当前工作目录到 /home/user/documents/report.txt 的相对路径，即 documents/report.txt。当我们指定一个不同的起始路径 /home/user/projects 时，它返回了从那个起始路径到目标文件的相对路径，即 …/documents/report.txt。

请注意，os.path.relpath 返回的路径中的目录分隔符会根据操作系统的不同而变化。在 Windows 上，它可能会使用反斜杠 \，而在 Unix-like 系统上，它可能会使用正斜杠 /。

此外，os.path.relpath 还考虑了符号链接（在支持的系统上）和当前目录 . 与父目录 … 的特殊情况，以确保生成的相对路径尽可能简洁和准确。

os.path.samefile(path1, path2)

os.path.samefile(path1, path2) 是 Python 标准库中 os.path 模块的一个函数，用于检查两个路径是否指向文件系统中的同一个文件或目录。这个函数通过比较两个路径的底层设备号和节点号（在 Unix-like 系统中）或卷标和路径名（在 Windows 上）来确定它们是否相同。

如果 path1 和 path2 指向相同的文件或目录，则 os.path.samefile(path1, path2) 返回 True，否则返回 False。

这个函数在处理硬链接时特别有用，因为硬链接是文件系统中的不同路径名，但它们都指向同一个文件。在这种情况下，os.path.samefile 会返回 True，而简单的字符串比较或 os.path.exists 检查则可能会给出误导性的结果。

下面是一些使用 os.path.samefile 的例子：

import os# 假设 /path/to/file1 和 /path/to/file2 是同一个文件的两个不同路径
path1 = "/path/to/file1"
path2 = "/path/to/file2"# 检查两个路径是否指向同一个文件
if os.path.samefile(path1, path2):print("The paths refer to the same file.")
else:print("The paths do not refer to the same file.")# 假设 /path/to/dir1 和 /path/to/dir2 是两个不同的目录
dir1 = "/path/to/dir1"
dir2 = "/path/to/dir2"# 检查两个路径是否指向同一个目录
if os.path.samefile(dir1, dir2):print("The paths refer to the same directory.")
else:print("The paths do not refer to the same directory.")

需要注意的是，os.path.samefile 的行为可能因操作系统的不同而有所差异。在 Unix-like 系统中，它依赖于底层文件系统的设备号和节点号来确定路径是否相同。在 Windows 上，它依赖于卷标和路径名的比较。因此，这个函数在不同的操作系统上可能会有不同的表现。

os.path.sameopenfile(fp1, fp2)

os.path.sameopenfile(fp1, fp2) 是 Python 标准库中 os.path 模块的一个函数，用于检查两个文件对象 fp1 和 fp2 是否指向同一个文件。

当两个文件对象都打开同一个文件时，os.path.sameopenfile(fp1, fp2) 会返回 True。如果两个文件对象打开的是不同的文件，或者其中任何一个文件对象已经关闭，那么该函数会返回 False。

这个函数对于确定两个文件对象是否共享同一个文件描述符非常有用。例如，在某些情况下，你可能需要确保两个文件对象都操作的是同一个文件，以避免不必要的数据复制或潜在的竞争条件。

请注意，os.path.sameopenfile 只能用于比较通过标准文件打开函数（如 open()）打开的文件对象。它不适用于其他方式创建的文件对象，比如使用低级文件描述符或其他库创建的文件对象。

下面是一个使用 os.path.sameopenfile 的例子：

import os# 打开同一个文件的两个文件对象
with open('example.txt', 'r') as file1:with open('example.txt', 'r') as file2:# 检查两个文件对象是否指向同一个文件if os.path.sameopenfile(file1, file2):print("The two file objects refer to the same file.")else:print("The two file objects do not refer to the same file.")# 尝试比较已关闭的文件对象
file1.close()
if os.path.sameopenfile(file1, file2):print("Both file objects are still open and refer to the same file.")
else:print("One of the file objects is closed.")

在这个例子中，file1 和 file2 都打开了同一个文件 ‘example.txt’，因此 os.path.sameopenfile(file1, file2) 会返回 True。当 file1 关闭后，再次调用 os.path.sameopenfile(file1, file2) 将返回 False，因为 file1 不再是一个有效的文件对象。

os.path.samestat(stat1, stat2)

os.path.samestat(stat1, stat2) 是 Python 的 os.path 模块中的一个函数，用于比较两个 os.stat_result 对象（通常是通过 os.stat(), os.lstat(), 或 os.fstat() 函数得到的文件或目录的状态信息）是否表示同一个文件或目录的状态。

当 stat1 和 stat2 包含相同的设备号、节点号（inode number）以及文件类型时，os.path.samestat(stat1, stat2) 会返回 True。否则，返回 False。

这个函数特别在比较通过不同方法（如 os.stat() 和 os.lstat()）得到的文件状态时有用，因为这两个函数在处理符号链接时表现不同：os.stat() 返回符号链接指向的文件的状态，而 os.lstat() 返回符号链接本身的状态。

下面是一个使用 os.path.samestat 的例子：

import os# 假设我们有一个文件和一个指向该文件的符号链接
file_path = 'example.txt'
link_path = 'link_to_example.txt'# 创建符号链接
os.symlink(file_path, link_path)# 获取文件和符号链接的状态
file_stat = os.stat(file_path)
link_stat = os.lstat(link_path)# 检查两个状态对象是否相同
if os.path.samestat(file_stat, link_stat):print("The states of the file and the symlink are the same.")
else:print("The states of the file and the symlink are different.")# 清理
os.remove(link_path)

在这个例子中，os.path.samestat(file_stat, link_stat) 将会返回 False，因为 file_stat 是文件 example.txt 的状态，而 link_stat 是符号链接 link_to_example.txt 的状态，它们指向的是不同的文件系统对象。

需要注意的是，os.path.samestat() 依赖于底层文件系统的特性，因此在某些文件系统上可能无法正确工作。此外，由于它比较的是 os.stat_result 对象，因此不能直接用于比较文件路径字符串；对于这些情况，应该使用 os.path.samefile() 或 os.path.sameopenfile()。

os.path.split(path)

os.path.split(path) 是 Python 的 os.path 模块中的一个函数，用于将给定的文件路径 path 分割成两部分：目录路径和文件名。

这个函数返回一个包含两个元素的元组 (head, tail)。head 是除最后一个路径分量外的所有路径，tail 是最后一个路径分量。这通常对应于目录和文件名。如果 path 只包含一个路径分量（即没有目录部分），那么 head 会是一个空字符串，而 tail 会是 path 本身。

这里有一些使用 os.path.split 的例子：

import os# 示例路径
path1 = "/home/user/documents/file.txt"
path2 = "file.txt"
path3 = "/var/log/"# 分割路径
head1, tail1 = os.path.split(path1)
head2, tail2 = os.path.split(path2)
head3, tail3 = os.path.split(path3)# 输出结果
print(head1, tail1)  # 输出: /home/user/documents file.txt
print(head2, tail2)  # 输出:  file.txt
print(head3, tail3)  # 输出: /var/log  (注意，tail3 是一个空字符串)

在上面的例子中，os.path.split 函数将每个路径分割成了目录部分和文件名部分。对于 path1，目录部分是 /home/user/documents，文件名部分是 file.txt。对于 path2，因为没有明确的目录部分，所以目录部分是一个空字符串，文件名部分是 file.txt。对于 path3，它是一个目录路径，因此目录部分是 /var/log，而文件名部分是一个空字符串。

这个函数在处理文件路径时非常有用，特别是当你需要分别获取目录和文件名时。

os.path.splitdrive(path)

os.path.splitdrive(path) 是 Python 的 os.path 模块中的一个函数，用于在 Windows 系统上分割驱动器号和路径。在 Windows 系统中，文件路径经常以驱动器号（如 C:）开头，后面跟着一个冒号和一个反斜杠。os.path.splitdrive 函数用于将这个驱动器号从完整的文件路径中分割出来。

这个函数返回一个包含两个元素的元组 (drive, path)。drive 是包含驱动器号和冒号的字符串（如果存在的话），path 是从原始路径中去除驱动器号后的剩余部分。如果路径中没有驱动器号，drive 将是一个空字符串，而 path 将是原始路径。

下面是一些使用 os.path.splitdrive 的例子：

import os# Windows 路径示例
path1 = "C:\\Users\\Username\\Documents\\file.txt"
path2 = "\\\\Server\\Share\\file.txt"  # 网络路径，没有驱动器号
path3 = "file.txt"  # 只有文件名，没有路径# 分割驱动器号和路径
drive1, path1 = os.path.splitdrive(path1)
drive2, path2 = os.path.splitdrive(path2)
drive3, path3 = os.path.splitdrive(path3)# 输出结果
print(drive1, path1)  # 输出: C: \\Users\\Username\\Documents\\file.txt
print(drive2, path2)  # 输出:  \\\\Server\\Share\\file.txt
print(drive3, path3)  # 输出:  file.txt

在这个例子中，path1 是一个包含驱动器号的 Windows 路径，os.path.splitdrive 将其分割成了驱动器号 C: 和剩余路径 \Users\Username\Documents\file.txt。path2 是一个网络路径，没有驱动器号，因此 drive2 是一个空字符串，而 path2 保持不变。path3 只是一个文件名，没有路径，所以 drive3 和 path3 也分别是空字符串和原始文件名。

请注意，os.path.splitdrive 函数只在 Windows 平台上有效。在其他操作系统上，这个函数可能不会返回有意义的结果。

os.path.splitroot(path)

os.path.splitroot(path) 是 Python 的 os.path 模块中的一个函数，用于分割文件路径的根和其余部分。这个函数在处理那些包含盘符（如 Windows 系统中的 C:\）或者类似网络路径的根（如 \server\share）时特别有用。

os.path.splitroot 返回一个包含两个元素的元组 (root, path)。root 是路径的根部分，path 是从根开始的剩余路径。如果路径没有根，root 将是一个空字符串，而 path 将是原始路径。

下面是一些使用 os.path.splitroot 的例子：

import os# Windows 路径示例
path1 = "C:\\Users\\Username\\Documents\\file.txt"# 网络路径示例
path2 = "\\\\Server\\Share\\file.txt"# 只有一个文件名的路径
path3 = "file.txt"# 分割根和路径
root1, path1 = os.path.splitroot(path1)
root2, path2 = os.path.splitroot(path2)
root3, path3 = os.path.splitroot(path3)# 输出结果
print(root1, path1)  # 输出: C:\ Users\Username\Documents\file.txt
print(root2, path2)  # 输出: \\Server\Share\file.txt
print(root3, path3)  # 输出:  file.txt

在这个例子中，path1 是一个 Windows 路径，os.path.splitroot 将盘符 C:\ 作为根，剩余部分作为路径。path2 是一个网络路径，由于它本身就是一个根，所以 root2 就是 \Server\Share，而 path2 是从该根开始的剩余部分。path3 只是一个文件名，没有根，所以 root3 是一个空字符串，而 path3 是原始的文件名。

需要注意的是，os.path.splitroot 主要用于 Windows 和网络路径。在其他操作系统（如 Unix 或 Linux）上，由于路径结构不同，这个函数可能不会返回有意义的结果。在这些系统上，路径通常没有明确的“根”和“其余部分”的分割，因为整个文件系统结构被视为一个单一的树状结构。

os.path.splitext(path)

os.path.splitext(path) 是 Python 的 os.path 模块中的一个函数，用于将文件路径 path 分割成两部分：文件的基本名称和扩展名。

这个函数返回一个包含两个元素的元组 (root, ext)。root 是文件的基本名称，它包含路径中的所有内容，但不包括最后一个点（.）及其后面的内容。ext 是文件的扩展名，即从最后一个点开始到路径结束的部分。如果文件没有扩展名，ext 将是一个空字符串。

以下是一些使用 os.path.splitext 的例子：

import os# 示例路径
path1 = "example.txt"
path2 = "file"
path3 = "dir/subdir/file.jpg"
path4 = "dir/subdir/file."  # 注意这里的点号# 分割路径
root1, ext1 = os.path.splitext(path1)
root2, ext2 = os.path.splitext(path2)
root3, ext3 = os.path.splitext(path3)
root4, ext4 = os.path.splitext(path4)# 输出结果
print(root1, ext1)  # 输出: example .txt
print(root2, ext2)  # 输出: file
print(root3, ext3)  # 输出: dir/subdir/file .jpg
print(root4, ext4)  # 输出: dir/subdir/file .

在这个例子中，os.path.splitext 函数将每个路径分割成了基本名称和扩展名。对于 path1，基本名称是 example，扩展名是 .txt。对于 path2，由于没有扩展名，所以基本名称是 file，扩展名是一个空字符串。对于 path3，基本名称是 dir/subdir/file，扩展名是 .jpg。对于 path4，即使扩展名只有一个点号，os.path.splitext 也会正确地将路径分割成 dir/subdir/file 和 .。

这个函数在处理文件路径时非常有用，特别是当你需要单独操作文件名（不包括扩展名）或扩展名时。

os.path.supports_unicode_filenam

os.path.supports_unicode_filenames是Python中的一个不可调用对象，用于检查操作系统是否支持使用任意Unicode字符串作为文件名1。

如果操作系统支持使用非ASCII字符编码的文件名，则os.path.supports_unicode_filenames返回True；否则返回False2。例如在除Darwin之外的posix系统上，os.path.supports_unicode_filenames总是返回False，因为posix系统不关心文件名的编码1。