
import os
 
# 分割路径名
dirname, basename = os.path.split('/home/user/file.txt')
print('Directory:', dirname)  # 输出：/home/user
print('File:', basename)  # 输出：file.txt
 
# 检查路径名是否存在
print(os.path.exists('/home/user'))  # 输出：True 或 False
 
# 检查路径名是否是一个文件
print(os.path.isfile('/home/user/file.txt'))  # 输出：True 或 False
 
# 检查路径名是否是一个目录
print(os.path.isdir('/home/user'))  # 输出：True 或 False

2、os.access(path, mode, , dir_fd=None, effective_ids=False, follow_symlinks=True*)

作用：检查当前用户是否可以访问指定的路径。

详解：用于检查当前用户是否有权访问指定的路径。

- `path` 是要检查的文件或目录的路径。
- `mode` 是一个表示访问模式的整数，可以是 `os.F_OK`（检查文件是否存在）、`os.R_OK`（检查读权限）、`os.W_OK`（检查写权限）和 `os.X_OK`（检查执行权限）的组合。
- `dir_fd`、`effective_ids` 和 `follow_symlinks` 是可选参数，分别用于支持路径查找、检查真实用户/组ID，以及指定是否跟随符号链接。

`os.access()` 函数返回的是一个布尔值，如果当前用户有权访问指定的路径，那么返回 `True`；否则返回 `False`。

示例代码：


import os
 
# 检查当前用户是否有权访问指定的文件
accessible = os.access("test.txt", os.R_OK)
 
# 输出结果
print("Accessible:", accessible)

3、os.chmod(path, mode, *, dir_fd=None, follow_symlinks=True)

作用：更改指定路径的权限模式。

详解：

- `path` 是要更改权限模式的文件或目录的路径。
- `mode` 是一个表示权限模式的整数，可以是 `os.R_OK`（读权限）、`os.W_OK`（写权限）和 `os.X_OK`（执行权限）的组合。
- `dir_fd` 和 `follow_symlinks` 是可选参数，分别用于支持路径查找和指定是否跟随符号链接。

示例代码：


import os
 
# 更改指定文件的权限模式
os.chmod("test.txt", os.R_OK)
 
# 输出结果
print("Permissions changed for test.txt")

4、os.getcwdb()

作用：获取当前工作目录的字节对象。

详解：这个函数和 `os.getcwd()` 相似，但返回的是字节对象而不是字符串。

示例代码：


import os
 
# 获取当前工作目录的字节对象
cwd = os.getcwdb()
 
# 输出当前工作目录
print("Current working directory:", cwd)

注意：这个函数返回的字节对象可以在包含非Unicode字符的文件路径中使用。

5、os.link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)

作用：创建硬链接。

详解：用于创建硬链接，链接 `src` 文件到 `dst`。

- `src` 和 `dst` 是源文件和目标文件的路径，分别表示硬链接的源文件和目标文件。
- `src_dir_fd`、`dst_dir_fd` 和 `follow_symlinks` 是可选参数，分别用于支持路径查找和指定是否跟随符号链接。

示例代码：


import os
 
# 创建硬链接
os.link("src.txt", "dst.txt")
 
# 输出结果
print("Hard link created from src.txt to dst.txt")

请注意，创建硬链接可能需要适当的操作系统权限。

6、os.listdir(path='.')

详解：用于列出指定目录的所有文件和子目录。

- `path` 是要列出文件和子目录的目录的路径。如果省略 `path` 参数或者设置为 `'.'`，那么将列出当前工作目录的所有文件和子目录。

`os.listdir()` 函数返回的是一个列表，其中包含指定目录中的所有文件和子目录的名称。

示例代码：


import os
 
# 列出指定目录的所有文件和子目录
files = os.listdir('/')
 
# 输出文件和子目录列表
print("Files and directories in '/':", files)

7、os.lstat(path, *, dir_fd=None)

作用：获取文件或目录的状态信息。

详解：用于获取文件或目录的状态信息。这个函数和 `os.stat()` 函数类似，但如果 `path` 是一个符号链接，那么 `os.lstat()` 将返回符号链接本身的状态信息，而 `os.stat()` 将返回符号链接指向的文件的状态信息。

- `path` 是要获取状态信息的文件或目录的路径。
- `dir_fd` 是可选参数，用于支持路径查找。

`os.lstat()` 函数返回的是一个 `os.stat_result` 对象，它包含了文件或目录的所有状态信息，例如大小、权限、最后修改时间等。

示例代码：


import os
 
# 获取文件或目录的状态信息
stat_info = os.lstat("test.txt")
 
# 输出状态信息
print("File size:", stat_info.st_size)
print("Last modified:", stat_info.st_mtime)

8、os.mkdir(path, mode=0o777, *, dir_fd=None)

作用：创建目录。

详解：函数用于创建一个目录。

- `path` 是要创建的目录的路径。
- `mode` 是可选参数，用于设置新创建的目录的权限，默认为 `0o777`。
- `dir_fd` 是一个可选的文件描述符，用于支持路径查找。如果提供了这个参数，它应该是一个打开的目录的文件描述符。

示例代码：


import os
 
# 创建一个目录
os.mkdir('new_directory')
 
# 输出结果
print("Directory 'new_directory' created")

注意：如果指定的 `path` 已经存在，或者它的父目录不存在，这个函数会抛出一个 `FileExistsError` 或 `FileNotFoundError` 异常。

9、os.makedirs(name, mode=0o777, exist_ok=False)

作用：递归创建目录。

详解：函数用于递归地创建目录。这意味着如果中间的某个目录不存在，这个函数将自动创建它。

- `name` 是要创建的目录的路径。
- `mode` 是可选参数，用于设置新创建的目录的权限，默认为 `0o777`。
- `exist_ok` 是可选参数，用于指定当目录已存在时是否抛出异常。如果 `exist_ok` 为 `False`（默认值），当目录已存在时，函数将抛出一个 `FileExistsError` 异常。如果 `exist_ok` 为 `True`，当目录已存在时，函数不会做任何事情。

示例代码：


import os
 
# 递归创建目录
os.makedirs('new_directory/sub_directory')
 
# 输出结果
print("Directory 'new_directory/sub_directory' created")

注意：如果指定的 `name` 已经存在，并且 `exist_ok` 为 `False`，这个函数会抛出一个 `FileExistsError` 异常。如果 `name` 的父目录不存在，这个函数将自动创建它。

10、os.remove(path, *, dir_fd=None)

作用：删除指定的文件。

详解：函数用于删除指定的文件。

- `path` 是要删除的文件的路径。
- `dir_fd` 是一个可选的文件描述符，用于支持路径查找。如果提供了这个参数，它应该是一个打开的目录的文件描述符。

示例代码：


import os
 
# 删除一个文件
os.remove('test_file.txt')
 
# 输出结果
print("File 'test_file.txt' removed")

注意：这个函数不能删除目录，只能删除文件。如果指定的 `path` 是一个目录，这个函数会抛出一个 `IsADirectoryError` 异常。如果文件不存在，会抛出 `FileNotFoundError` 异常。

11、os.removedirs(name)

作用：递归删除空目录。

详解：函数用于递归地删除空目录。从指定的目录开始，逐级向上删除目录，直到遇到一个非空目录或根目录。如果指定的目录或其父目录非空，它们将不会被删除。

- `name` 是要删除的目录的路径。

示例代码：


import os
 
# 创建空目录
os.makedirs('empty_directory/sub_directory')
 
# 删除空目录
os.removedirs('empty_directory/sub_directory')
 
# 输出结果
print("Empty directories removed")

注意：这个函数只能删除空目录。如果指定的目录或其任何父目录非空，它们将不会被删除。如果指定的目录不存在，这个函数会抛出一个 `FileNotFoundError` 异常。

12、os.rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)

作用：重命名文件或目录。

详解：函数用于重命名文件或目录。源文件或目录将被重命名为目标名称。如果目标文件或目录已经存在，它将被替换。

- `src` 是要重命名的源文件或目录的路径。
- `dst` 是新的文件或目录名称。
- `src_dir_fd` 和 `dst_dir_fd` 是可选的文件描述符，用于支持路径查找。如果提供了这些参数，它们应该是一个打开的目录的文件描述符。

示例代码：


import os
 
# 创建一个文件
with open('original_file.txt', 'w') as f:
    f.write('This is a test file.')
 
# 重命名文件
os.rename('original_file.txt', 'renamed_file.txt')
 
# 输出结果
print("File 'original_file.txt' renamed to 'renamed_file.txt'")

注意：如果目标文件或目录已经存在，它将被替换。在某些情况下，重命名操作可能需要适当的操作系统权限。

13、os.renames(old, new)

作用：递归地重命名文件或目录。

详解：用于递归地重命名文件或目录。这个函数类似于 `os.rename()`，但它会自动创建所有必要的中间目录，并且在重命名之后，如果原始目录为空，它将被删除。

- `old` 是要重命名的源文件或目录的路径。
- `new` 是新的文件或目录路径。

示例代码：


import os
 
# 创建一个文件在子目录中
os.makedirs('old_directory')
with open('old_directory/old_file.txt', 'w') as f:
    f.write('This is a test file.')
 
# 重命名文件，包含目录
os.renames('old_directory/old_file.txt', 'new_directory/new_file.txt')
 
# 输出结果
print("File 'old_directory/old_file.txt' renamed to 'new_directory/new_file.txt'")

注意：如果新的文件或目录路径的任何中间目录不存在，这个函数将自动创建它们。在重命名之后，如果原始目录为空，它将被删除。

14、os.replace(src, dst, *, src_dir_fd=None, dst_dir_fd=None)

作用：替换文件或目录。

详解：用于替换文件或目录。这个函数类似于 `os.rename()`，但如果目标文件或目录已经存在，它不会失败，而是替换它。

- `src` 是要替换的源文件或目录的路径。
- `dst` 是新的文件或目录名称。
- `src_dir_fd` 和 `dst_dir_fd` 是可选的文件描述符，用于支持路径查找。如果提供了这些参数，它们应该是一个打开的目录的文件描述符。

示例代码：


import os
 
# 创建两个文件
with open('original_file.txt', 'w') as f:
    f.write('This is the original file.')
with open('new_file.txt', 'w') as f:
    f.write('This is the new file.')
 
# 替换文件
os.replace('new_file.txt', 'original_file.txt')
 
# 输出结果
print("File 'new_file.txt' replaced 'original_file.txt'")

注意：如果目标文件或目录已经存在，它将被替换。在某些情况下，替换操作可能需要适当的操作系统权限。

15、os.rmdir(path, *, dir_fd=None)

作用：删除空目录。

详解：用于删除空目录。

- `path` 是要删除的目录的路径。
- `dir_fd` 是一个可选的文件描述符，用于支持路径查找。如果提供了这个参数，它应该是一个打开的目录的文件描述符。

示例代码：


import os
 
# 创建一个空目录
os.mkdir('empty_directory')
 
# 删除空目录
os.rmdir('empty_directory')
 
# 输出结果
print("Directory 'empty_directory' removed")

注意：这个函数只能删除空目录。如果指定的目录非空，这个函数会抛出一个 `OSError` 异常。如果目录不存在，会抛出 `FileNotFoundError` 异常。

16、os.scandir(path='.')

作用：返回给定路径中所有条目的迭代器。

详解：用于返回给定路径中所有条目（文件、子目录等）的迭代器。每个条目由一个 `os.DirEntry` 对象表示，该对象具有许多有用的方法和属性，包括 `name`（条目的基础名称）、`path`（条目的全路径）、`is_file()`（如果条目是文件则返回True）、`is_dir()`（如果条目是目录则返回True）等。

- `path` 是要扫描的目录的路径。默认值是当前工作目录。

示例代码：


import os
 
# 获取当前目录下的所有条目
entries = os.scandir()
 
# 打印每个条目的名称
for entry in entries:
    print(entry.name)

注意：`os.scandir()` 返回的迭代器在使用完成后需要关闭，以释放相关的系统资源。可以使用 `with` 语句来自动处理这个问题，例如：


with os.scandir() as entries:
    for entry in entries:
        print(entry.name)

17、os.stat(path, *, dir_fd=None, follow_symlinks=True)

作用：获取文件或目录的状态信息。

详解：用于获取文件或目录的状态信息。这个函数返回一个 `os.stat_result` 对象，它具有一些属性可以用来获取文件或目录的信息，比如 `st_size`（文件的大小，以字节为单位）、`st_mtime`（文件的最后修改时间）、`st_mode`（文件的权限）等。

- `path` 是要获取状态信息的文件或目录的路径。
- `dir_fd` 是一个可选的文件描述符，用于支持路径查找。如果提供了这个参数，它应该是一个打开的目录的文件描述符。
- `follow_symlinks` 是一个可选参数，表示是否跟随符号链接。如果设为 `True`（默认值），那么在遇到符号链接时，将返回指向文件的状态信息。如果设为 `False`，那么将返回符号链接本身的状态信息。

示例代码：


import os
 
# 获取文件的状态信息
file_stat = os.stat('example.txt')
 
# 打印文件的大小
print('File size:', file_stat.st_size)
 
# 打印文件的最后修改时间
print('Last modified:', file_stat.st_mtime)
 
# 打印文件的权限
print('Permissions:', oct(file_stat.st_mode))

注意：获取文件或目录的状态信息可能需要适当的操作系统权限。如果指定的文件或目录不存在，这个函数会抛出一个 `FileNotFoundError` 异常。

17.1、使用 `os.stat()` 函数返回的 `os.stat_result` 对象，可以获取到以下一些属性

1. `st_mode`：保护位，描述文件类型和文件模式位（权限）。
2. `st_ino`：i节点号。
3. `st_dev`：设备。
4. `st_nlink`：链接数。
5. `st_uid`：用户ID。
6. `st_gid`：组ID。
7. `st_size`：文件大小，以字节为单位。
8. `st_atime`：最后访问时间。
9. `st_mtime`：最后修改时间。
10. `st_ctime`：在某些系统上（如Unix）是最新的元数据更改的时间，在其他系统上（如Windows）是创建时间。

每个时间的属性都以时间戳的形式返回，可以使用python的 `datetime` 模块将其转换为更易读的格式。例如：


import os
import datetime
 
file_stat = os.stat('example.txt')
print('Last modified:', datetime.datetime.fromtimestamp(file_stat.st_mtime))

这段代码将输出文件的最后修改时间。

18、os.supports_fd

作用：表示操作系统支持哪些文件描述符相关的功能。

详解：`os.supports_fd` 是一个Python的内置集合，描述了当前操作系统支持哪些与文件描述符相关的功能。这些功能包括：`os.open`、`os.read`、`os.write`、`os.close`、`os.dup`等。这个集合包含了所有在当前操作系统上可用的文件描述符相关的功能。

示例代码：


import os
 
# 检查操作系统是否支持某个文件描述符功能
if 'os.open' in os.supports_fd:
    print('os.open is supported')
else:
    print('os.open is not supported')

注意：`os.supports_fd` 集合只包含在当前操作系统上可用的文件描述符操作。不同操作系统可能支持不同的功能，因此在编写可移植的代码时，建议使用此集合来确定当前操作系统支持哪些功能。

19、os.supports_follow_symlinks

作用：表示操作系统支持哪些遵循符号链接的函数。

详解：`os.supports_follow_symlinks` 是一个Python的内置集合，描述了当前操作系统支持哪些遵循符号链接的函数。这些函数包括：`os.chflags`、`os.lchflags`、`os.lchmod`等。这个集合包含了所有在当前操作系统上可用的遵循符号链接的函数。

示例代码：


import os
 
# 检查操作系统是否支持某个遵循符号链接的函数
if 'os.chflags' in os.supports_follow_symlinks:
    print('os.chflags is supported')
else:
    print('os.chflags is not supported')

注意：`os.supports_follow_symlinks` 集合只包含在当前操作系统上可用的遵循符号链接的函数。不同操作系统可能支持不同的函数，因此在编写可移植的代码时，建议使用此集合来确定当前操作系统支持哪些函数。

20、os.symlink(src, dst, target_is_directory=False, , dir_fd=None*)

作用：创建一个符号链接。

详解：用于在文件系统中创建一个符号链接。符号链接是一个特殊类型的文件，它指向另一个文件或目录。当访问符号链接时，操作系统会将访问重定向到指向的文件或目录。

- `src` 是被链接文件或目录的路径。
- `dst` 是要创建的符号链接的路径。
- `target_is_directory` 是一个可选参数，表示目标是否是一个目录。如果设为 `True`，那么将创建一个指向目录的符号链接。默认值是 `False`。
- `dir_fd` 是一个可选的文件描述符，用于支持路径查找。如果提供了这个参数，它应该是一个打开的目录的文件描述符。

示例代码：


import os
 
# 创建一个指向文件的符号链接
os.symlink('source_file.txt', 'symbolic_link.txt')
 
# 创建一个指向目录的符号链接
os.symlink('source_directory', 'symbolic_directory', target_is_directory=True)

注意：创建符号链接可能需要适当的操作系统权限。在某些操作系统（如Windows）上，创建符号链接可能需要管理员权限。如果指定的源文件或目录不存在，或者目标符号链接已经存在，这个函数会抛出一个异常。

21、os.truncate(path, length)

作用：重设文件大小。

详解：用于重设指定文件的大小。如果指定的新大小小于当前文件大小，那么文件将被截断，多余的部分将被删除。如果指定的新大小大于当前文件大小，那么文件将被扩展，新增的部分将被填充为空字节。

- `path` 是要重设大小的文件的路径。
- `length` 是文件的新大小，以字节为单位。

示例代码：


import os
 
# 创建一个新文件
with open('example.txt', 'w') as f:
    f.write('Hello, world!')
 
# 重设文件大小
os.truncate('example.txt', 5)
 
# 输出文件内容
with open('example.txt', 'r') as f:
    print(f.read())  # 输出：'Hello'

注意：重设文件大小可能需要适当的操作系统权限。如果指定的文件不存在，这个函数会抛出一个 `FileNotFoundError` 异常。如果指定的新大小为负数，这个函数会抛出一个 `ValueError` 异常。

22、os.utime(path, times=None, , [ns, ]dir_fd=None, follow_symlinks=True*)

作用：改变文件的访问和修改时间。

详解：用于改变指定文件的访问时间和修改时间。

- `path` 是要改变时间的文件的路径。
- `times` 是一个可选参数，表示新的访问时间和修改时间。它应该是一个包含两个元素的元组，第一个元素是访问时间，第二个元素是修改时间，都以秒为单位。如果省略这个参数，或者设为 `None`，那么访问时间和修改时间都将被设为当前时间。
- `ns` 是一个可选参数，表示新的访问时间和修改时间，以纳秒为单位。它应该是一个包含两个元素的元组，第一个元素是访问时间，第二个元素是修改时间。如果既提供了 `times` 又提供了 `ns`，那么 `ns` 将被忽略。
- `dir_fd` 和 `follow_symlinks` 参数的含义与前面的函数相同。

示例代码：


import os
import time
 
# 获取当前时间
current_time = time.time()
 
# 改变文件的访问和修改时间
os.utime('example.txt', (current_time, current_time))

注意：改变文件的访问和修改时间可能需要适当的操作系统权限。如果指定的文件不存在，这个函数会抛出一个 `FileNotFoundError` 异常。

23、os.walk(top, topdown=True, οnerrοr=None, followlinks=False)

作用：遍历一个目录树。

详解：用于遍历一个目录树。它生成一个三元组 `(dirpath, dirnames, filenames)`。

- `top` 是根目录下的每一个文件夹(包含它自己)，产生3个元组，('目录路径'，'该路径下面的目录名'，'该路径下面的文件名')。
- `topdown` 是一个可选参数，表示遍历的顺序。如果设为 `True`，那么先遍历顶层目录，然后遍历子目录（这是默认的行为）。如果设为 `False`，那么先遍历子目录，然后遍历顶层目录。
- `onerror` 是一个可选参数，表示一个错误处理函数。如果提供了这个参数，那么当发生错误时，将调用这个函数。如果没有提供这个参数，那么将忽略错误。
- `followlinks` 是一个可选参数，表示是否遵循符号链接。如果设为 `True`，那么将遍历符号链接指向的目录。默认值是 `False`。

示例代码：


import os
 
# 遍历当前目录
for dirpath, dirnames, filenames in os.walk('.'):
    print('Directory:', dirpath)
    print('Subdirectories:', dirnames)
    print('Files:', filenames)
    print()

这段代码将打印出当前目录及其所有子目录中的所有文件和子目录。

操作当前进程和用户的信息

1、os.environ

作用：获取或设置环境变量。

详解：用于获取或设置环境变量。这个字典在需要与环境变量交互时非常有用。

你可以像操作普通的Python字典那样操作 `os.environ`。例如，你可以使用 `os.environ[key]` 来获取名为 `key` 的环境变量的值，或者使用 `os.environ[key] = value` 来设置环境变量的值。

以下是一个使用的例子：


import os
 
# 获取一个环境变量
path = os.environ["PATH"]
print(path)
 
# 设置一个环境变量
os.environ["MY_VARIABLE"] = "my value"
 
# 现在 MY_VARIABLE 环境变量已经被设置，可以在当前进程或其子进程中使用它

需要注意，对 `os.environ` 的修改只会影响到当前进程和由当前进程创建的子进程，不会影响到其他的进程。另外，环境变量的名称和值必须是字符串，如果尝试使用非字符串的名称或值，将会引发 TypeError 异常。

2、os.chdir(path)

作用：更改当前工作目录。

详解：用于更改当前工作目录。这个函数在需要改变当前工作目录时非常有用。

参数 `path` 是一个字符串，表示新的工作目录。如果 `path` 是一个相对路径，那么它将相对于当前工作目录进行解析。

以下是一个使用的例子：


import os
 
# 更改当前工作目录
os.chdir("/path/to/directory")
 
# 现在当前工作目录已经被改变，可以使用 os.getcwd() 来确认
print(os.getcwd())  # 输出 "/path/to/directory"

需要注意，尝试更改到不存在的目录，或者没有权限访问的目录，都会引发 OSError 异常。另外，即使成功更改了当前工作目录，这个改变也只会影响到当前进程，不会影响到其他的进程。

3、os.getcwd()

输出当前工作目录


import os
 
# 获取并打印当前工作目录
print(os.getcwd())

如果你的当前工作目录是"/home/user", 那么上述代码的输出就会是"/home/user"。

注意，当前工作目录是指你的Python脚本当前的操作目录，它可能与你的Python脚本的物理位置不同。例如，如果你在"/home/user"目录下运行一个位于"/home/user/scripts"目录下的脚本，那么os.getcwd()返回的将是"/home/user"，而不是"/home/user/scripts"。

如果你需要获取脚本自身的路径，你可以使用__file__变量，如下所示：


import os
 
# 获取并打印脚本的路径
print(os.path.abspath(__file__))

这将会打印出脚本的绝对路径，而不论你在何处运行这个脚本。

4、os.fsencode(filename)

作用：对文件名进行编码

详解:这个函数主要用于处理包含特殊字符的文件名。这些特殊字符可能是非ASCII字符，例如中文字符、日文字符、特殊符号等。这些字符在默认的ASCII编码中并不存在，因此需要使用特定的编码方式（如UTF-8）来进行编码。


import os
 
# 文件名包含中文字符
filename = '文件.txt'
 
# 使用os.fsencode()将文件名转换为字节串
encoded_filename = os.fsencode(filename)
 
# 打印转换后的结果
print(encoded_filename)  # 输出：b'\xe6\x96\x87\xe4\xbb\xb6.txt'

使用场景：

1. 文件名包含非ASCII字符，例如中文、日文、阿拉伯文等。如 "测试.txt"，"例子.dat"，"データ.txt" 等。

2. 文件名包含特殊字符或者符号，例如 "file@#$.txt"，"№;%:?*dat" 等。

3. 文件名包含在某些操作系统下可能引起问题的字符，例如在Windows中，文件名不能包含 \/:*?"<>| 这些字符，如果文件名包含这些字符，需要使用`os.fsencode()`处理。

在这些情况下，直接使用原始的文件名可能会导致错误或者异常，使用`os.fsencode()`能够把这些文件名转换为适合用作文件系统接口参数的形式。

5、os.fsdecode(filename)

作用：对文件名进行解码，与os.fsencode(filename)作用正好相反

详解：如果输入是 bytes 类型，它会被解码为 str 类型，但如果输入已经是 str 类型，那么就直接返回，不会有任何变化。

这个函数在处理从文件系统接口（如 os.listdir() ）返回的文件名时非常有用，因为这些接口可能返回 str 或 bytes 类型的文件名，而你可能需要统一处理为 str 类型。


import os
 
filename = b'\xe6\xb5\x8b\xe8\xaf\x95.txt'  # 这是一个 bytes 类型的文件名，内容是 "测试.txt"
filename_str = os.fsdecode(filename)  # 使用 os.fsdecode() 将其解码为 str 类型
print(filename_str)  # 输出 "测试.txt"

6、os.fspath(path)

作用：将给定的路径转换为适合文件系统操作的字符串或字节字符串。

详解：这个函数可以接受字符串或字节字符串，并返回一个与输入类型相同的对象，该对象表示与传入对象相同的文件系统路径。如果传入的是一个实现了__fspath__() 方法的对象，那么这个方法的返回值将被直接返回。这个方法的主要作用是为了支持pathlib.Path 或os.DirEntry 这样的路径对象。

os.fspath()函数在处理文件系统路径名时非常有用，因为有些接口可能接受 str 或 bytes 类型的路径，而你可能需要将路径对象转换为这些类型。

以下是一个使用的例子：


import os
from pathlib import Path
 
path = Path('/home/user/test.txt')  # 这是一个 pathlib.Path 类型的路径
path_str = os.fspath(path)  # 使用 os.fspath() 将其转换为 str 类型
print(path_str)  # 输出 "/home/user/test.txt"

7、os.getenv(key, default=None)

作用：获取环境变量中指定名称的值。

详解：`os.getenv(key, default=None)` 是 Python os 模块中的一个函数，用于获取指定名称的环境变量的值。如果环境变量存在，那么返回其值；如果环境变量不存在，那么返回 `default` 参数指定的值。如果 `default` 参数没有指定（默认为 None），那么在环境变量不存在的情况下，函数返回 None。

这个函数在你需要从环境变量中读取配置信息时非常有用。

以下是一个使用的例子：


import os
 
# 获取名为 "PATH" 的环境变量的值
path = os.getenv("PATH")
print(path)
 
# 如果尝试获取一个不存在的环境变量，那么返回默认值
value = os.getenv("NO_SUCH_VARIABLE", "default_value")
print(value)  # 输出 "default_value"

8、os.get_exec_path(env=None)

作用：返回一个列表，包含可以用来查找可执行文件的目录名。

详解：用于在系统已经定义的环境变量的目录下获取系统的可执行文件路径。列表中的目录名根据它们在环境变量 PATH 中出现的顺序排列。

如果提供了 `env` 参数（应该是一个环境变量字典），那么函数会使用这个字典中的 PATH 变量，以这个变量作为目录名进行查找。如果没有提供 `env` 参数，那么函数会使用当前进程的环境。

这个函数在你需要确定在哪些目录中系统会查找可执行文件时非常有用。

以下是一个使用的例子：


import os
 
# 获取可执行文件搜索路径
exec_path = os.get_exec_path()
print(exec_path)  # 输出类似 ['/usr/local/bin', '/usr/bin', '/bin'] 的结果

9、os.getlogin()

作用：返回当前登录到终端的用户的名字。

详解：用于获取当前登录到终端的用户的登录名。这个函数没有参数。

需要注意的是，这个函数并不总是返回当前运行程序的用户的名字，因为一个用户可以在登录后切换到另一个用户（例如，使用 `su` 或 `sudo` 命令）。在这种情况下，`os.getlogin()` 仍然返回原始登录的用户的名字。

这个函数在你需要知道哪个用户登录到终端时非常有用。

以下是一个使用的例子：


import os
 
# 获取当前登录的用户的名字
login_name = os.getlogin()
print(login_name)

10、 os.getpid()

作用：返回当前进程的进程 ID。

详解：用于获取当前运行的进程的进程 ID，也就是 PID。这个函数没有参数。PID 是每个进程在操作系统中的唯一标识。这个函数在需要跟踪或管理特定进程时非常有用。

以下是一个使用的例子：


import os
 
# 获取当前进程的 PID
pid = os.getpid()
print(pid)

每次你运行这个程序，都可能会得到一个不同的 PID，因为每个新的进程都会得到一个新的 PID。

11、os.getppid()

作用：返回当前进程的父进程的进程 ID。

详解：用于获取当前运行的进程的父进程的进程 ID，也就是 PPID。这个函数没有参数。PPID 是创建当前进程的进程在操作系统中的唯一标识。这个函数在需要跟踪或管理特定进程的父进程时非常有用。

以下是一个使用的例子：


import os
 
# 获取当前进程的父进程的 PID
ppid = os.getppid()
print(ppid)

每次你运行这个程序，都可能会得到一个不同的 PPID，因为每个新的进程都会由一个不同的父进程创建。

12、 os.putenv(key, value, /)

作用：将一个环境变量设置为指定的值。

详解：用于将名为 `key` 的环境变量设置为 `value`。这个函数在需要修改环境变量时非常有用。

需要注意的是，这个函数只会修改当前进程和其子进程的环境，而不会影响到当前用户的其他进程，也不会影响到其他用户的进程。

值得一提的是，修改环境变量的改变并不总是立即对当前进程可见，具体取决于操作系统的具体实现。因此，如果你需要立即在同一进程中使用新的环境变量值，建议使用 os.environ 字典，而不是 os.putenv() 函数。

以下是一个使用的例子：


import os
 
# 设置一个环境变量
os.putenv("MY_VARIABLE", "my value")
 
# 现在 MY_VARIABLE 环境变量已经被设置，可以在当前进程或其子进程中使用它

需要注意，不同的操作系统可能有不同的限制，例如环境变量的名称和值的长度可能受到限制，环境变量的名称可能不能包含等号（'='）等。具体细节请参考你的操作系统的文档。

引发一个审计事件 os.putenv，附带参数 key, value。

13、os.strerror(code, /)

作用：返回对应于错误代码的字符串。

详解：用于返回对应于错误代码的字符串。这个函数在需要解释错误代码时非常有用。

参数 `code` 是一个整数，表示错误代码。错误代码通常来自于系统调用或库函数的返回值。

这个函数将错误代码转换为人类可读的字符串，这样你就可以更容易地理解错误的原因。这个字符串通常是英文的，但可能会根据系统的语言设置而变化。

以下是一个使用的例子：


import os
 
# 获取一个错误代码对应的字符串
s = os.strerror(2)
print(s)  # 输出 "No such file or directory"

需要注意的是，不同的操作系统可能有不同的错误代码和对应的字符串，因此这个函数的输出可能会因操作系统而异。在某些情况下，如果错误代码无效，这个函数可能会引发 ValueError 异常。

14、 os.supports_bytes_environ

作用：检查操作系统是否支持以字节串形式访问环境变量。

详解：`os.supports_bytes_environ` 是Python os模块中的一个预先定义好的布尔值，而不是函数。如果这个值为真（True），那么表示操作系统支持以字节串形式访问环境变量，可以使用 `os.environb` 来获取和修改环境变量。如果这个值为假（False），那么表示操作系统不支持，尝试访问 `os.environb` 会引发 AttributeError 异常。

以下是一个使用的例子：


import os
 
# 检查操作系统是否支持以字节串形式访问环境变量
if os.supports_bytes_environ:
    print("This system supports bytes environ")
else:
    print("This system does not support bytes environ")

`os.supports_bytes_environ` 的值取决于操作系统和Python的版本。在某些旧版本的Python或某些特定的操作系统中，这个值可能为假。

15、 os.unsetenv(key, /)

作用：删除指定的环境变量。

详解：用于删除名为 `key` 的环境变量。这个函数在需要删除环境变量时非常有用。

需要注意的是，这个函数只会删除当前进程和其子进程的环境变量，而不会影响到当前用户的其他进程，也不会影响到其他用户的进程。

值得一提的是，删除环境变量的改变并不总是立即对当前进程可见，具体取决于操作系统的具体实现。因此，如果你需要立即在同一进程中使用新的环境变量值，建议使用 os.environ 字典，而不是 os.unsetenv() 函数。

以下是一个使用的例子：


import os
 
# 删除一个环境变量
os.unsetenv("MY_VARIABLE")

需要注意，不同的操作系统可能有不同的限制，例如环境变量的名称可能不能包含等号（'='）等。具体细节请参考你的操作系统的文档。

16、os.name

`os.name` 是Python的os模块中的一个常量，它的值表示你正在使用的平台。具体来说：

- 在Windows平台，`os.name` 的值是 `'nt'`。
- 在Linux/Unix平台，`os.name` 的值是 `'posix'`。
- 在Mac平台，`os.name` 的值也是 `'posix'`。
- 在Java平台(Jython)，`os.name` 的值是 `'java'`。

`os.name` 常用于需要根据不同平台编写不同代码的情况。例如：


import os
 
if os.name == 'nt':
    print('You are using Windows.')
elif os.name == 'posix':
    print('You are using Unix/Linux/Mac.')
else:
    print('You are using an unknown platform.')

这段代码将根据 `os.name` 的值打印出你正在使用的平台的信息。

创建文件对象

1、os.fdopen(fd, *args, **kwargs)

作用：将一个文件描述符转换为文件对象。

详解：用于将一个文件描述符转换为文件对象。这个函数在需要使用文件对象接口操作文件描述符时非常有用。

参数 `fd` 是一个整数，表示文件描述符。其他的参数 `*args` 和 `**kwargs` 和内置的 `open()` 函数接受的参数相同，例如 'r'、'w'、'b' 等。

以下是一个使用的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("/path/to/file", os.O_RDONLY)
 
# 将文件描述符转换为文件对象
f = os.fdopen(fd, 'r')
 
# 现在可以使用文件对象接口读取文件
data = f.read()
 
# 记得关闭文件
f.close()

需要注意，`os.fdopen()` 返回的文件对象在关闭时会同时关闭底层的文件描述符。如果你不希望这样，可以使用 `os.dup()` 函数复制一个文件描述符，然后将复制的文件描述符传递给 `os.fdopen()`。

1.1、在Windows操作系统上，将文件描述符转换为文件对象的作用主要体现在以下两个方面：

1. 使得文件操作更加Pythonic：Python的文件对象提供了一种更高级、更易于使用的接口来进行文件操作，如read(), write(), readlines(), writelines()等方法，这些方法都比底层的os模块提供的原生文件描述符操作要方便得多。

2. 提供了缓冲机制：Python的文件对象提供了缓冲机制，可以减少对底层系统调用的次数，从而提高文件读写的效率。特别是在进行大量小的读写操作时，缓冲机制的效率提升会非常显著。

例如：


import os
 
# 用os模块打开一个文件描述符
fd = os.open('C:\\path\\to\\file', os.O_RDWR|os.O_CREAT)
 
# 用os.fdopen将文件描述符转换为文件对象
f = os.fdopen(fd, 'w+')
 
# 现在可以使用文件对象的方法进行文件操作
f.write('Hello, world!')
 
# 关闭文件对象，同时也会关闭底层的文件描述符
f.close()

在这个例子中，我们首先用os模块打开一个文件描述符，然后用os.fdopen将文件描述符转换为文件对象，接着我们就可以使用文件对象的方法进行文件操作了。在我们关闭文件对象时，底层的文件描述符也会被关闭。

1.2、os.open和os.fdopen

os.open和os.fdopen都是Python的os模块中用于文件操作的函数，但它们的作用和使用方式有一些不同。

1. os.open：这个函数用于打开一个文件，并返回一个文件描述符。它的参数包括文件的路径和一组表示打开方式的标志（例如，是否以读方式打开，是否以写方式打开等）。这个函数是比较底层的文件操作函数，其返回的文件描述符需要配合如`os.read`,`os.write`,`os.close`等函数来进行文件读写操作。


import os
 
fd = os.open("/path/to/file", os.O_RDONLY)
data = os.read(fd, 1024)
os.close(fd)

2. `os.fdopen`：这个函数用于将一个已经打开的文件描述符转换为一个文件对象，文件对象提供了一种更高级、更易于使用的接口来进行文件操作（例如，read方法，write方法等）。`os.fdopen`通常与`os.open`配合使用，首先使用`os.open`打开一个文件并获取文件描述符，然后使用`os.fdopen`将文件描述符转换为文件对象。


import os
 
fd = os.open("/path/to/file", os.O_RDONLY)
f = os.fdopen(fd, 'r')
data = f.read()
f.close()

总结来说，`os.open`和`os.fdopen`的主要区别在于：`os.open`提供了一种底层的方式来打开和操作文件，而`os.fdopen`则提供了一种将底层的文件描述符转换为更易用的文件对象的方式。

文件IO操作

1、os.close(fd)

作用：关闭一个文件描述符。

详解：用于关闭一个已经打开的文件描述符。这个函数在完成文件操作后，需要关闭文件时非常有用。

参数 `fd` 是一个整数，表示需要关闭的文件描述符。

以下是一个使用的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("/path/to/file", os.O_RDONLY)
 
# 完成文件操作后，关闭文件描述符
os.close(fd)

需要注意，尝试关闭一个已经关闭的文件描述符，或者一个无效的文件描述符，都会引发 OSError 异常。另外，一般来说，在关闭文件描述符后，再次使用这个文件描述符进行文件操作是不安全的，因为操作系统可能将这个文件描述符分配给其他的文件。

2、os.closerange(fd_low, fd_high)

作用：关闭所有文件描述符从 `fd_low` (包含) 到 `fd_high` (不包含), 错误会被忽略。

详解：用于关闭一个范围内的所有文件描述符。对于操作系统资源有限或者需要打开大量文件的情况，可以有效地关闭一系列文件描述符，而不需要逐一关闭。

参数 `fd_low` 和 `fd_high` 都是整数，表示需要关闭的文件描述符的范围。

以下是一个使用的例子：


import os
 
# 打开一些文件并获取其文件描述符
fd1 = os.open("/path/to/file1", os.O_RDONLY)
fd2 = os.open("/path/to/file2", os.O_RDONLY)
fd3 = os.open("/path/to/file3", os.O_RDONLY)
 
# 完成文件操作后，关闭这些文件描述符
os.closerange(fd1, fd3 + 1)

在这个例子中，`os.closerange(fd1, fd3 + 1)` 将关闭从 `fd1` 到 `fd3` 的所有文件描述符。需要注意，`fd_high` 是不包含在内的，所以这里需要加 1。

3、os.device_encoding(fd)

作用：返回打开的文件描述符fd的设备编码，如果设备没有特定编码则返回None。

详解：这个函数用于查询给定文件描述符对应的设备的编码。这在处理需要特定编码的设备如终端或特定类型的文件时非常有用。

参数 `fd` 是一个整数，表示需要获取设备编码的文件描述符。

以下是一个使用的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("/path/to/file", os.O_RDONLY)
 
# 获取文件描述符的设备编码
encoding = os.device_encoding(fd)
 
print("Device encoding:", encoding)

4、os.dup(fd)

作用：复制文件描述符 `fd`。

详解：`os.dup(fd)` 是用来复制文件描述符的函数。这在需要在不同的上下文中使用同一个文件，但需要保持原文件描述符不变的情况下非常有用。

参数 `fd` 是一个整数，表示需要复制的文件描述符。

以下是一个使用的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("/path/to/file", os.O_RDONLY)
 
# 复制文件描述符
dup_fd = os.dup(fd)
 
print("Original file descriptor:", fd)
print("Duplicated file descriptor:", dup_fd)

在这个例子中，`os.dup(fd)` 用于复制文件描述符 `fd`。这样，`dup_fd` 和 `fd` 就可以指向同一个文件，但它们是两个不同的文件描述符。

5、os.dup2(fd, fd2, inheritable=True)

作用：将一个文件描述符 fd 复制到另一个 fd2，如果 fd2 已经存在，将会先关闭。

详解：`os.dup2(fd, fd2)` 是用来将一个文件描述符复制到另一个指定的文件描述符上。如果目标文件描述符已经存在，它会首先被关闭。这在需要重定向输入/输出流，或者复用文件描述符的场景中非常有用。

参数 `fd` 是一个整数，表示需要复制的源文件描述符。`fd2` 也是一个整数，表示目标文件描述符。如果 `fd2` 已经存在，则 `os.dup2(fd, fd2)` 会先关闭 `fd2`。`inheritable` 参数决定复制后的文件描述符是否可以被子进程继承，默认为 True。

以下是一个使用的例子：


import os
 
# 打开两个文件并获取其文件描述符
fd1 = os.open("/path/to/file1", os.O_RDONLY)
fd2 = os.open("/path/to/file2", os.O_RDONLY)
 
# 将 fd1 复制到 fd2
os.dup2(fd1, fd2)
 
print("File descriptor fd1:", fd1)
print("File descriptor fd2:", fd2)

在这个例子中，`os.dup2(fd1, fd2)` 将 `fd1` 复制到 `fd2`，`fd2` 对应的原文件会被 `fd1` 对应的文件替换。

6、os.fstat(fd)

作用：返回文件描述符fd的状态，类似于`stat()`。

详解：`os.fstat(fd)` 是用来获取一个打开的文件描述符的状态信息。它返回一个 `os.stat_result` 对象，该对象包含了文件的各种属性，如文件大小、文件的最后访问/修改/创建时间等。

参数 `fd` 是一个整数，表示需要获取状态信息的文件描述符。

以下是一个使用的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("/path/to/file", os.O_RDONLY)
 
# 获取文件描述符的状态信息
stat_info = os.fstat(fd)
 
print("File size:", stat_info.st_size)
print("Last modified time:", stat_info.st_mtime)

在这个例子中，`os.fstat(fd)` 获取了文件描述符 `fd` 对应的文件的状态信息。然后我们可以打印出文件的大小和最后修改时间。所返回的 `os.stat_result` 对象还包含很多其他的文件属性，可以根据需要使用。

os.fstat(fd) 返回的 os.stat_result 对象包含以下属性：

st_mode：保护位，描述文件的类型和文件的访问权限。
st_ino：inode number，文件在文件系统中的编号。
st_dev：设备标识符，定义了文件所在的设备。
st_nlink：链接数，表示文件名和实际文件之间的链接数。
st_uid：用户ID，文件所有者的用户ID。
st_gid：组ID，文件所有者的组ID。
st_size：文件的大小，以字节为单位。
st_atime：最后访问时间，文件最后一次被访问或运行的时间。
st_mtime：最后修改时间，文件数据最后一次被修改的时间。
st_ctime：创建时间，在某些系统上（如Unix）是文件状态最后一次改变的时间，在其他系统（如Windows）是文件创建时间。
st_blocks：文件的数据块数，不在所有的系统上都可用。
st_blksize：文件系统的I/O优化的块大小。

7、os.fsync(fd)

作用：强制将文件描述符为fd的文件写入硬盘。

详解：`os.fsync(fd)` 用于确保对文件描述符 `fd` 的所有写入操作都已经传输到硬盘。在默认情况下，写入文件的操作可能首先被操作系统缓存，而不是立即写入硬盘。`fsync` 函数可以确保所有的写入操作都已经完成，这对于需要确保数据安全性的应用是非常重要的。

参数 `fd` 是一个整数，表示需要进行同步操作的文件描述符。

以下是一个使用的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("/path/to/file", os.O_RDWR)
 
# 写入一些数据
os.write(fd, b"Hello, world!")
 
# 强制将数据写入硬盘
os.fsync(fd)

在这个例子中，`os.fsync(fd)` 确保了对文件描述符 `fd` 的写入操作都已经完成，所有的数据都已经被写入硬盘。

8、os.ftruncate(fd, length)

作用：将文件描述符fd的文件大小重设为length字节。

详解：`os.ftruncate(fd, length)` 用于将一个打开的文件的大小设置为特定的长度。如果文件原来的大小大于 `length`，则超过的部分将会被丢弃。如果文件原来的大小小于 `length`，则文件将会被扩展，新增的部分的内容依赖于操作系统的实现（在某些系统上，新增的部分可能会被填充为0）。

参数 `fd` 是一个整数，表示需要进行截断操作的文件描述符。`length` 也是一个整数，表示文件新的大小。

以下是一个使用的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("/path/to/file", os.O_RDWR)
 
# 截断文件到 100 字节
os.ftruncate(fd, 100)

在这个例子中，`os.ftruncate(fd, 100)` 将文件描述符 `fd` 对应的文件的大小设置为 100 字节。如果文件原来的大小大于 100 字节，超过的部分将会被丢弃。如果文件原来的大小小于 100 字节，文件将会被扩展，新增的部分的内容依赖于操作系统的实现。

引发一个审计事件 os.truncate，附带参数 fd, length。

9、os.isatty(fd)

作用：检查文件描述符fd是否连接到一个终端设备。

详解：`os.isatty(fd)` 用来检查一个文件描述符是否连接到一个终端设备。这在需要确定一个文件描述符是否可以进行交互式I/O操作时很有用。例如，在一个脚本中，你可能需要确定是否可以向用户显示一些提示信息，或者是否可以从用户那里获取一些交互式的输入。在这些情况下，你可以使用 `os.isatty()` 来检查标准输入/输出/错误流是否连接到一个终端设备。

参数 `fd` 是一个整数，表示需要检查的文件描述符。

以下是一个使用的例子：


import os
import sys
 
# 获取标准输入的文件描述符
fd = sys.stdin.fileno()
 
# 检查文件描述符是否连接到一个终端设备
if os.isatty(fd):
    print("fd is connected to a terminal device")
else:
    print("fd is not connected to a terminal device")

在这个例子中，`os.isatty(fd)` 检查标准输入（通常是键盘）是否连接到一个终端设备。如果连接到一个终端设备，它将打印 "fd is connected to a terminal device"；否则，它将打印 "fd is not connected to a terminal device"。

10、os.lseek(fd, pos, whence)

作用：改变文件描述符fd的读写位置。

详解：`os.lseek(fd, pos, whence)`方法用于移动文件描述符fd的读写位置。这是通过添加一个偏移量pos到一个参考点来实现的，这个参考点由whence参数决定。

- `fd`是文件描述符，一个整数，它代表了一个已打开的文件。
- `pos`是偏移量，一个整数，它表示从参考点移动的字节数量。pos可以是负数，这表示从参考点向后移动。
- `whence`参数是一个整数，用于选择参考点。它有三个可能的值：`os.SEEK_SET`（或0）表示文件的开头；`os.SEEK_CUR`（或1）表示当前的读写位置；`os.SEEK_END`（或2）表示文件的结尾。

以下是在Windows中使用`os.lseek()`的一个例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("test.txt", os.O_RDWR)
 
# 从文件的开始位置向后移动10个字节
os.lseek(fd, 10, os.SEEK_SET)
 
# 从当前位置向后移动2个字节
os.lseek(fd, 2, os.SEEK_CUR)
 
# 从文件的结尾位置向前移动5个字节
os.lseek(fd, -5, os.SEEK_END)

在这个例子中，我们首先打开了一个名为"test.txt"的文件，然后使用`os.lseek()`函数移动了文件的读写位置。

11、os.SEEK_SET、os.SEEK_CUR、os.SEEK_END

os.SEEK_SET、os.SEEK_CUR和os.SEEK_END分别是操作系统`os`模块中定义的三个常量，用于在调用`os.lseek()`函数时指定偏移量的基点。

1、os.SEEK_SET

值：0

作用：将文件的指针位置设置为距离文件开始位置`pos`个字节。

2、os.SEEK_CUR

值：1

作用：将文件的指针位置设置为当前位置加上`pos`个字节。`pos`可以为负，这表示从当前位置向前移动。

3、os.SEEK_END

值：2

作用：将文件的指针位置设置为文件的结尾加上`pos`个字节。`pos`通常为负，这表示从文件的结尾向前移动，`pos`为0时表示移动到文件的末尾。

例如，在Windows中，可以这样使用：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("test.txt", os.O_RDWR)
 
# 将文件指针移动到文件开始位置后的10个字节处
os.lseek(fd, 10, os.SEEK_SET)
 
# 将文件指针从当前位置向后移动2个字节
os.lseek(fd, 2, os.SEEK_CUR)
 
# 将文件指针移动到文件结束位置之前的5个字节处
os.lseek(fd, -5, os.SEEK_END)

在这个例子中，我们首先打开了一个名为"test.txt"的文件，然后使用`os.lseek()`函数移动了文件的读写位置。

12、os.open(path, flags, mode=0o777, , dir_fd=None*)

作用：打开文件，并返回一个文件描述符。

详解：`os.open()` 函数用于打开一个文件，并返回一个文件描述符，该文件描述符后续可用于对文件进行读写操作。

- `path` 是一个字符串，表示要打开的文件的路径。
- `flags` 是一个整数，表示打开文件的方式和模式。这个参数可以是以下值或其组合：
- `os.O_RDONLY`：以只读方式打开文件。
- `os.O_WRONLY`：以只写方式打开文件。
- `os.O_RDWR`：以读写方式打开文件。
- `os.O_CREAT`：如果文件不存在，则创建新文件。
- `os.O_TRUNC`：如果文件已存在，并且以写方式打开，则清空文件内容。
- `mode` 是一个可选参数，表示文件的权限。默认值为 `0o777`。只有在`flags`参数包含`os.O_CREAT`时，`mode`参数才会生效。
- `dir_fd` 是一个可选参数，它是一个文件描述符，用于指定查找开始的目录。默认值为 `None`，表示使用当前工作目录作为开始目录。

以下是在Windows中使用`os.open()`的一个例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("test.txt", os.O_RDWR | os.O_CREAT)
 
# 使用文件描述符fd进行后续的文件操作...

在这个例子中，我们打开了一个名为 "test.txt" 的文件，如果文件不存在，则创建新文件。然后，我们可以使用返回的文件描述符 `fd` 来进行后续的文件操作。

13、os.pipe()

作用：创建一个管道，并返回一个包含两个文件描述符的元组。

详解：`os.pipe()` 函数用于创建一个管道，它返回一个包含两个文件描述符的元组：`(read_fd, write_fd)`。一个进程可以通过 `read_fd` 文件描述符从管道中读取数据，而另一个进程可以通过 `write_fd` 文件描述符向管道中写入数据。这种机制通常用于进程间通信（IPC）。

以下是一个使用 `os.pipe()` 的例子：


import os
 
# 创建一个管道
read_fd, write_fd = os.pipe()
 
# 通过 write_fd 向管道写入数据
os.write(write_fd, b"Hello, Pipe!")
 
# 通过 read_fd 从管道读取数据
data = os.read(read_fd, 1024)
 
# 输出读取到的数据
print("Data from pipe:", data)
 
# 关闭管道的读写端
os.close(read_fd)
os.close(write_fd)

在这个例子中，我们首先使用 `os.pipe()` 函数创建了一个管道，并获取了相应的读写文件描述符。然后，我们通过 `write_fd` 向管道写入了一些数据，接着通过 `read_fd` 从管道中读取了数据。最后，我们关闭了管道的读写端。

14、os.read(fd, n)

作用：从文件描述符fd所引用的文件中读取最多n个字节，并返回一个包含读取字节的字节字符串。

详解：`os.read(fd, n)` 函数用于从文件或者管道中读取数据。它返回的是一个字节字符串，包含了读取到的数据。

- `fd` 是一个文件描述符，它引用了一个已打开的文件或者管道。
- `n` 是一个整数，表示要读取的最大字节数。

如果文件中的可用字节少于 `n`，或者到达了文件的末尾，那么 `os.read()` 将返回实际读取到的字节。

以下是一个使用 `os.read()` 的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("test.txt", os.O_RDONLY)
 
# 从文件中读取数据
data = os.read(fd, 1024)
 
# 输出读取到的数据
print("Data from file:", data)
 
# 关闭文件
os.close(fd)

在这个例子中，我们首先打开了一个名为 "test.txt" 的文件，并获取了相应的文件描述符。然后，我们使用 `os.read()` 函数从文件中读取了最多1024个字节的数据。最后，我们关闭了文件。

15、os.set_blocking(fd, blocking)

作用：设置文件描述符fd的阻塞或非阻塞模式。

详解：`os.set_blocking(fd, blocking)` 函数用于设置文件描述符的阻塞或非阻塞模式。

- `fd` 是一个文件描述符，它引用了一个已打开的文件或者管道。
- `blocking` 是一个布尔值。如果为 `True`，则设置文件描述符为阻塞模式；如果为 `False`，则设置文件描述符为非阻塞模式。

在阻塞模式下，当调用 `os.read()` 或 `os.write()` 函数时，如果数据不能立即被读取或写入，那么这些函数将会阻塞，直到数据可用或者空间可用。在非阻塞模式下，如果数据不能立即被读取或写入，那么这些函数将立即返回，并可能抛出一个 `BlockingIOError` 异常。

以下是一个使用 `os.set_blocking()` 的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("test.txt", os.O_RDWR)
 
# 设置文件描述符为非阻塞模式
os.set_blocking(fd, False)
 
# 使用文件描述符fd进行后续的文件操作...
 
# 关闭文件
os.close(fd)

在这个例子中，我们首先打开了一个名为 "test.txt" 的文件，并获取了相应的文件描述符。然后，我们使用 `os.set_blocking()` 函数将文件描述符设置为非阻塞模式。最后，我们关闭了文件。

16、os.write(fd, str)

作用：向文件描述符fd所引用的文件写入字节字符串str，并返回实际写入的字节数。

详解：`os.write(fd, str)` 函数用于向文件或者管道写入数据。它接受一个字节字符串作为参数，并将这个字节字符串写入到文件或者管道中。

- `fd` 是一个文件描述符，它引用了一个已打开的文件或者管道。
- `str` 是一个字节字符串，表示要写入的数据。

`os.write()` 函数返回的是实际写入的字节数。注意，这个数值可能少于 `str` 的长度，这表示只有部分数据被写入。这种情况通常发生在磁盘空间不足或者达到了文件大小限制时。

以下是一个使用 `os.write()` 的例子：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("test.txt", os.O_WRONLY)
 
# 向文件中写入数据
n = os.write(fd, b"Hello, World!")
 
# 输出实际写入的字节数
print("Number of bytes written:", n)
 
# 关闭文件
os.close(fd)

在这个例子中，我们首先打开了一个名为 "test.txt" 的文件，并获取了相应的文件描述符。然后，我们使用 `os.write()` 函数向文件中写入了一些数据，并打印出实际写入的字节数。最后，我们关闭了文件。

17、os.popen()

`os.popen()` 是Python的os模块中的一个函数，用于从一个 shell 命令打开一个管道。这个函数创建一个子进程，执行命令，然后返回一个连接到子进程的标准输入、输出或错误管道的文件对象。

`os.popen()` 的语法是：

os.popen(command[, mode[, bufsize]])

参数：

- `command`: shell命令字符串
- `mode`: 模式字符串，可选，默认为 'r'。'r' 表示读，'w' 表示写。
- `bufsize`: 缓冲区大小，可选。0表示无缓冲；1表示行缓冲；其他正数表示使用参数作为缓冲区大小；负数表示使用系统默认缓冲。

返回值：返回一个文件对象，这个文件对象连接到命令在子进程中的标准输入，输出或者错误流。

示例代码：


import os
 
# 执行命令，并获取命令的输出
output = os.popen('dir').read()
print(output)

上述代码在Windows平台下执行'dir'命令，然后读取并打印命令的输出。在Unix/Linux平台下，你可以用'ls'命令代替'dir'。

需要注意的是，`os.popen()` 在新版本的Python中已经不推荐使用，推荐使用 `subprocess` 模块来替代。

查询终端的尺寸

1、os.get_terminal_size(fd=STDOUT_FILENO)

作用：获取指定文件描述符fd所引用的命令行终端窗口的大小，并返回一个包含宽度和高度的命名元组。

详解：`os.get_terminal_size(fd=STDOUT_FILENO)` 函数用于获取终端的大小。它返回一个命名元组，包含两个元素：`columns` 和 `lines`，分别表示终端的宽度和高度。

- `fd` 是一个文件描述符，它引用了一个已打开的终端。默认值为 `STDOUT_FILENO`，表示标准输出。

以下是一个使用 `os.get_terminal_size()` 的例子：


import os
 
# 获取终端的大小
size = os.get_terminal_size()
 
# 输出终端的宽度和高度
print("Terminal size:", size.columns, "x", size.lines)

注意：这里的终端指的是运行窗口，如果在pycharm上运行会报错，在cmd或powershell上运行，则是关联了命令行窗口，则可以正常获取输出

文件描述符的继承

1、os.get_inheritable(fd)

作用：获取文件描述符fd的可继承标志，并返回一个布尔值。

详解：`os.get_inheritable(fd)` 函数用于获取文件描述符的可继承标志。如果文件描述符是可继承的，那么它将被子进程继承；如果文件描述符是不可继承的，那么它将不被子进程继承。

- `fd` 是一个文件描述符，它引用了一个已打开的文件或者管道。

`os.get_inheritable()` 函数返回的是一个布尔值，如果文件描述符是可继承的，那么返回 `True`；如果文件描述符是不可继承的，那么返回 `False`。

示例代码：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("test.txt", os.O_RDWR)
 
# 获取文件描述符的可继承标志
inheritable = os.get_inheritable(fd)
 
# 输出可继承标志
print("Inheritable:", inheritable)
 
# 关闭文件
os.close(fd)

2、os.set_inheritable(fd, inheritable)

作用：设置文件描述符fd的继承标志。

详解：`os.set_inheritable(fd, inheritable)` 函数用于设置文件描述符的继承标志。如果设置为True，那么在创建新的子进程时，这个文件描述符将会被子进程继承。如果设置为False，那么这个文件描述符将不会被子进程继承。

- `fd` 是一个文件描述符，它引用一个已打开的文件或者管道。
- `inheritable` 是一个布尔值，表示要设置的继承标志。

示例代码：


import os
 
# 打开一个文件并获取其文件描述符
fd = os.open("test.txt", os.O_RDWR)
 
# 设置文件描述符的可继承标志
os.set_inheritable(fd, True)
 
# 关闭文件
os.close(fd)

3、os.get_handle_inheritable(handle, /)

作用：获取Windows平台上的文件句柄的继承标志。

详解：`os.get_handle_inheritable(handle)` 函数用于获取Windows平台上的文件句柄的继承标志。如果文件句柄是可继承的，那么它将被子进程继承；如果文件句柄是不可继承的，那么它将不被子进程继承。

- `handle` 是一个Windows平台上的文件句柄。

`os.get_handle_inheritable()` 函数返回的是一个布尔值，如果文件句柄是可继承的，那么返回 `True`；如果文件句柄是不可继承的，那么返回 `False`。

示例代码：


import os
 
# 打开一个文件并获取其文件句柄
handle = os.open("test.txt", os.O_RDWR | os.O_BINARY)
 
# 获取文件句柄的可继承标志
inheritable = os.get_handle_inheritable(handle)
 
# 输出可继承标志
print("Inheritable:", inheritable)
 
# 关闭文件句柄
os.close(handle)

4、os.set_handle_inheritable(handle, inheritable, /)

作用：设置Windows平台上的文件句柄的继承标志。

详解：`os.set_handle_inheritable(handle, inheritable)` 函数用于设置Windows平台上的文件句柄的继承标志。如果设置为True，那么在创建新的子进程时，这个文件句柄将会被子进程继承。如果设置为False，那么这个文件句柄将不会被子进程继承。

- `handle` 是一个Windows平台上的文件句柄。
- `inheritable` 是一个布尔值，表示要设置的继承标志。

示例代码：


import os
 
# 打开一个文件并获取其文件句柄
handle = os.open("test.txt", os.O_RDWR | os.O_BINARY)
 
# 设置文件句柄的可继承标志
os.set_handle_inheritable(handle, True)
 
# 关闭文件句柄
os.close(handle)

进程管理

1、os.abort()

作用：在程序中引发一个硬退出。

详解：`os.abort()` 函数用于在程序中引发一个硬退出，也就是说，程序立即终止，不执行任何清理操作（如关闭打开的文件等）。这个函数会引发一个 `SIGABRT` 信号，这个信号的默认行为就是终止程序。

示例代码：


import os
 
print('This is a message.')
 
# 引发一个硬退出
os.abort()
 
print('This message will not be printed.')

这段代码将打印出一条消息，然后立即终止。最后一条打印语句不会被执行。

注意：`os.abort()` 函数是一种非常“粗暴”的终止程序的方式，它不会执行任何清理操作，直接结束进程。因此，除非有特殊的需要，否则一般不建议在程序中使用这个函数。在大多数情况下，更推荐使用 `sys.exit()` 函数来终止程序，因为这个函数会执行清理操作。

2、os.add_dll_directory(path)

作用：添加一个目录到DLL搜索路径。

详解：`os.add_dll_directory(path)` 函数用于将一个目录添加到DLL（动态链接库）搜索路径。这个函数返回一个对象，当这个对象被销毁或者退出 `with` 语句块时，添加的目录将被从DLL搜索路径中删除。

- `path` 是要添加的目录的路径。

这个函数在Python 3.8版本后引入，主要用于Windows平台，因为在Windows平台上，Python会搜索指定的目录来寻找DLL。

示例代码：


import os
 
# 添加一个目录到DLL搜索路径
with os.add_dll_directory('C:\\path\\to\\dlls'):
    # 在这个语句块中，'C:\\path\\to\\dlls' 目录被添加到DLL搜索路径
    pass
# 出了这个语句块，'C:\\path\\to\\dlls' 目录被从DLL搜索路径中删除

3、os.execl等

os.execl(path, arg0, arg1, ...)

os.execle(path, arg0, arg1, ..., env)

os.execlp(file, arg0, arg1, ...)

os.execlpe(file, arg0, arg1, ..., env)

os.execv(path, args)

os.execve(path, args, env)

os.execvp(file, args)¶

os.execvpe(file, args, env)

这些函数都是Python的os模块中用于执行新程序的函数。他们都会替换当前进程，这意味着这些函数执行后，原来的程序就不会继续执行了。

- `os.execl(path, arg0, arg1, ...)`：执行可执行文件，可以传入多个参数，每个参数都是一个字符串。
- `os.execle(path, arg0, arg1, ..., env)`：和`os.execl`类似，但是最后一个参数是一个字典，表示新程序的环境变量。
- `os.execlp(file, arg0, arg1, ...)`：和`os.execl`类似，但是会使用PATH环境变量来查找可执行文件。
- `os.execlpe(file, arg0, arg1, ..., env)`：是`os.execlp`和`os.execle`的结合。
- `os.execv(path, args)`：和`os.execl`类似，但是参数是一个列表或者元组，而不是多个参数。
- `os.execve(path, args, env)`：和`os.execv`类似，但是有一个额外的环境变量参数。
- `os.execvp(file, args)`：和`os.execv`类似，但是会使用PATH环境变量来查找可执行文件。
- `os.execvpe(file, args, env)`：是`os.execvp`和`os.execve`的结合。

示例代码：


import os
 
# 执行一个新程序，替换当前进程
os.execl('/path/to/program', 'program', 'arg1', 'arg2')

这段代码将执行一个新程序，这个程序的路径是`/path/to/program`，程序的名字是`program`，还有两个参数`arg1`和`arg2`。执行这个函数后，原来的程序就不会继续执行了。

注意：这些函数执行后，原来的程序就不会继续执行了。如果你需要在执行新程序后，原来的程序还需要继续执行，那么你应该使用`os.system()`或者`subprocess`模块。

3.1、windows上的使用

Windows上通常需要指定可执行文件的完整名称，例如 program.exe 而不仅仅是 program。此外，对于Windows系统上的可执行文件路径，通常使用反斜杠（\）作为路径分隔符。

在Windows上执行新程序的示例：


import os
 
# 执行一个新程序，替换当前进程
os.execl('C:\\path\\to\\program.exe', 'program', 'arg1', 'arg2')

在这个例子中，新程序的路径是 C:\path\to\program.exe，程序的名字是 program，还有两个参数 arg1 和 arg2。执行这个函数后，原来的程序就不会继续执行了。

要注意的是，尽管这些函数在Windows上也可以使用，但在不同操作系统之间编写可移植的代码可能会遇到一些挑战。例如，路径分隔符、文件扩展名等可能因操作系统而异。为了应对这种情况，可以使用Python的 os.path 模块和 sys.platform 属性来处理操作系统相关的差异。

4、os._exit(n)

作用：退出当前进程。

详解：`os._exit(n)` 函数用于结束当前进程。这个函数不会执行任何清理操作（如调用 `finally` 块或者 `atexit` 钩子函数），而是直接结束进程。

- `n` 是一个整数，表示退出状态。这个值将被返回给父进程，通常 `0` 表示正常退出，非零值表示出现错误。

示例代码：


import os
 
print('This is a message.')
 
# 退出当前进程
os._exit(0)
 
print('This message will not be printed.')

这段代码将打印出一条消息，然后立即结束进程。最后一条打印语句不会被执行。

注意：`os._exit(n)` 函数是一种非常“粗暴”的终止进程的方式，它不会执行任何清理操作，直接结束进程。因此，除非有特殊的需要，否则一般不建议在程序中使用这个函数。在大多数情况下，更推荐使用 `sys.exit()` 函数来终止程序，因为这个函数会执行清理操作。

5、os.startfile(path[, operation][, arguments][, cwd][, show_cmd])

作用：在Windows上运行一个可执行文件或者打开一个文档。

详解：`os.startfile(path[, operation][, arguments][, cwd][, show_cmd])` 函数用于在Windows上运行一个可执行文件或者打开一个文档。

- `path` 是要打开的文件的路径。
- `operation` 是一个可选参数，表示要执行的操作。如果省略这个参数，那么默认的操作是打开文件。其他可能的值包括 `'print'`（打印文件）等。
- `arguments` 是一个可选参数，表示传递给可执行文件的参数。
- `cwd` 是一个可选参数，表示运行程序的当前工作目录。
- `show_cmd` 是一个可选参数，表示窗口的显示方式。例如，`SW_HIDE`表示隐藏窗口，`SW_SHOW`表示显示窗口。

示例代码：


import os
 
# 打开一个文件
os.startfile('C:\\path\\to\\file.txt')
 
# 运行一个程序
os.startfile('C:\\path\\to\\program.exe')

这段代码将打开一个文本文件和运行一个程序。

注意：这个函数只在Windows上可用。在其他平台上，可以使用 `os.system()` 函数或者 `subprocess` 模块来运行一个程序。

6、os.system(command)

作用：运行一个系统命令。

详解：`os.system(command)`函数用于在系统shell中执行一个命令。这个函数将返回命令的退出状态，或者在出现错误时返回一个错误码。

- `command` 是要执行的命令，它是一个字符串。

示例代码：


import os
 
# 运行一个命令
exit_status = os.system('ls -l')

这段代码将在系统shell中执行 `ls -l` 命令，并将命令的退出状态存储在 `exit_status` 变量中。`ls -l` 命令用于列出当前目录中的所有文件和目录。

注意：`os.system()` 函数只是简单地在系统shell中执行命令，它不会处理命令的输出。如果你需要获取命令的输出，可以使用 `subprocess` 模块的 `subprocess.check_output()` 函数。此外，为了安全性和可移植性，通常推荐使用 `subprocess` 模块来替代 `os.system()` 函数。

7、os.times()

作用：返回当前进程和其子进程的系统资源使用统计。

详解：`os.times()` 函数用于返回当前进程和其子进程的系统资源使用统计，包括用户时间、系统时间等。

这个函数返回一个包含五个元素的元组：

- 用户模式下的CPU时间（以秒为单位）
- 内核模式下的CPU时间（以秒为单位）
- 所有子进程在用户模式下的CPU时间（以秒为单位）
- 所有子进程在内核模式下的CPU时间（以秒为单位）
- 实际经过的时间，从进程开始到现在（以秒为单位）

示例代码：


import os
 
# 获取当前进程和其子进程的系统资源使用统计
times = os.times()
 
print('User time:', times[0])
print('System time:', times[1])
print('Children user time:', times[2])
print('Children system time:', times[3])
print('Elapsed real time:', times[4])

这段代码将打印出当前进程和其子进程的用户模式下的CPU时间、内核模式下的CPU时间，以及实际经过的时间。

路径高级操作

1、os.curdir

作用：表示当前目录的字符串。

详解：`os.curdir` 是Python的os模块中的一个常量，它的值是表示当前目录的字符串。在大多数平台上，它的值是 `'.'`。

示例代码：


import os
 
# 打印当前目录
print(os.curdir)

这段代码将打印出 `'.'`，表示当前目录。

`os.curdir` 常常用于与其他目录或文件路径进行拼接，例如：


import os
 
# 拼接路径
path = os.path.join(os.curdir, 'file.txt')
 
print(path)  # 输出：./file.txt

这段代码将 `os.curdir`（当前目录）与 `'file.txt'` 进行拼接，得到相对于当前目录的文件路径 `./file.txt`。

2、os.pardi

作用：表示父目录的字符串。

详解：`os.pardir` 是Python的os模块中的一个常量，它的值是表示父目录的字符串。在大多数平台上，它的值是 `'..'`。

示例代码：


import os
 
# 打印父目录
print(os.pardir)

这段代码将打印出 `'..'`，表示父目录。

`os.pardir` 常常用于与其他目录或文件路径进行拼接，例如：


import os
 
# 拼接路径
path = os.path.join(os.pardir, 'file.txt')
 
print(path)  # 输出：../file.txt

这段代码将 `os.pardir`（父目录）与 `'file.txt'` 进行拼接，得到相对于父目录的文件路径 `../file.txt`。

3、os.sep

作用：表示当前操作系统的路径分隔符。

详解：`os.sep` 是Python的os模块中的一个常量，它的值是当前操作系统的路径分隔符。在Unix和Linux系统上，它的值是 `'/'`。在Windows系统上，它的值是 `'\\'`。

示例代码：


import os
 
# 打印路径分隔符
print(os.sep)

这段代码将打印出当前操作系统的路径分隔符。

`os.sep` 常常用于与其他目录或文件路径进行拼接，例如：


import os
 
# 拼接路径
path = 'home' + os.sep + 'user' + os.sep + 'file.txt'
 
print(path)  # 输出：home/user/file.txt（在Unix和Linux系统上）

这段代码将 `'home'`、`'user'` 和 `'file.txt'` 通过路径分隔符进行拼接，得到一个完整的文件路径。这样做的好处是，无论在什么操作系统上运行，都能得到正确的路径。

4、os.altsep

作用：表示当前操作系统的备选路径分隔符。

详解：`os.altsep` 是Python的os模块中的一个常量，它的值是当前操作系统的备选路径分隔符。

在Unix和Linux系统上，这个值是 `None`，因为这些系统只有一种路径分隔符 `'/'`。在Windows系统上，这个值是 `'/'`，因为Windows系统除了主要的路径分隔符 `'\\'` 之外，还可以接受 `'/'` 作为路径分隔符。

示例代码：


import os
 
# 打印备选路径分隔符
print(os.altsep)

这段代码将打印出当前操作系统的备选路径分隔符。

在处理文件路径时，通常只需要使用 `os.sep`。`os.altsep` 主要用于处理一些特殊情况，例如在Windows系统上处理使用 `'/'` 分隔的路径。

5、os.extsep

作用：表示当前操作系统的扩展名分隔符。

详解：`os.extsep` 是Python的os模块中的一个常量，它的值是当前操作系统的扩展名分隔符。在大多数操作系统上，包括Windows、Linux和Unix，它的值都是 `'.'`。

示例代码：


import os
 
# 打印扩展名分隔符
print(os.extsep)

这段代码将打印出 `'.'`，表示扩展名分隔符。

`os.extsep` 常常用于处理文件扩展名，例如：


import os
 
# 获取文件名和扩展名
filename = 'example.txt'
basename, ext = filename.rsplit(os.extsep, 1)
 
print('Base name:', basename)  # 输出：example
print('Extension:', ext)  # 输出：txt

这段代码将使用 `os.extsep` 来分割文件名和扩展名。

6、os.pathsep

作用：表示当前操作系统的路径列表分隔符。

详解：`os.pathsep` 是Python的os模块中的一个常量，它的值是当前操作系统的路径列表分隔符。在Unix和Linux系统上，它的值是 `':'`。在Windows系统上，它的值是 `';'`。

示例代码：


import os
 
# 打印路径列表分隔符
print(os.pathsep)

这段代码将打印出当前操作系统的路径列表分隔符。

`os.pathsep` 常用于处理包含多个路径的环境变量，例如 `PATH`。例如，可以使用 `os.pathsep` 来分割 `PATH` 环境变量中的所有路径：


import os
 
# 获取PATH环境变量
path = os.environ['PATH']
 
# 分割所有路径
paths = path.split(os.pathsep)
 
for path in paths:
    print(path)

这段代码将打印出 `PATH` 环境变量中的所有路径。

7、os.defpath

作用：表示Python解释器默认的搜索路径。

详解：`os.defpath` 是Python的os模块中的一个常量，它的值是Python解释器默认的搜索路径。这是一个包含一个或多个路径的字符串，这些路径由 `os.pathsep` 分隔。在大多数环境中，它的值是 `'.:/bin:/usr/bin'`。

示例代码：


import os
 
# 打印Python解释器默认的搜索路径
print(os.defpath)

这段代码将打印出Python解释器默认的搜索路径。

`os.defpath` 主要用于在 `os.execvp()` 等函数中作为默认的 `PATH` 环境变量。如果在调用这些函数时没有提供 `PATH` 环境变量，那么Python解释器将使用 `os.defpath` 来搜索可执行文件。

8、os.linesep

作用：表示当前操作系统的行分隔符。

详解：`os.linesep` 是Python的os模块中的一个常量，它的值是当前操作系统的行分隔符。在Unix和Linux系统上，它的值是 `'\n'`（换行符）。在Windows系统上，它的值是 `'\r\n'`（回车符+换行符）。

示例代码：


import os
 
# 打印行分隔符
print(os.linesep)

这段代码将打印出当前操作系统的行分隔符。

`os.linesep` 常用于处理跨平台的文本文件。例如，如果你需要在不同操作系统中创建文本文件并且希望它们具有相同的行分隔符，可以使用 `os.linesep`：


import os
 
# 使用操作系统的行分隔符创建文本文件
with open('example.txt', 'w') as f:
    f.write('Line 1' + os.linesep)
    f.write('Line 2' + os.linesep)
    f.write('Line 3' + os.linesep)

这段代码将创建一个文本文件，其中每行都以当前操作系统的行分隔符结尾。

9、os.devnull

作用：表示一个特殊的文件路径，写入到这个文件的数据会被操作系统丢弃。

详解：`os.devnull` 是Python的os模块中的一个常量，它的值是一个特殊的文件路径。在Unix和Linux系统上，它的值是 `'/dev/null'`。在Windows系统上，它的值是 `'NUL'`。

示例代码：


import os
 
# 打印丢弃文件的路径
print(os.devnull)

这段代码将打印出操作系统的丢弃文件路径。

`os.devnull` 常用于需要丢弃输出的情况。例如，如果你需要执行一个命令，但是不关心它的输出，可以将输出重定向到 `os.devnull`：


import os
import subprocess
 
# 执行一个命令，丢弃输出
with open(os.devnull, 'w') as devnull:
    subprocess.run(['echo', 'Hello, World!'], stdout=devnull)

这段代码将执行 `echo` 命令，但是它的输出会被重定向到 `os.devnull`，因此不会在控制台上显示任何内容。

10、os.urandom(n)

`os.urandom(n)` 是Python的os模块中的一个函数，用于生成指定长度的加密安全的随机字节串。它使用操作系统提供的随机生成器，生成的随机数具有较高的安全性，通常用于加密和安全相关的场景。

参数：

- `n`: 生成的随机字节串的长度。

返回值：返回一个长度为n的字节串。

示例代码：


import os
 
# 生成一个16字节的随机字节串
random_bytes = os.urandom(16)
print(random_bytes)

这段代码生成一个16字节的随机字节串，并打印其值。输出可能类似于以下内容：

b'\x8b\x9d\x1e\xdco\x1e\x9e\x8c\x9c;\xaf&\x8a\x0c\x9f'

`os.urandom()` 生成的随机字节串可以用于加密密钥、初始化向量、盐值等安全相关的用途。如果你需要生成随机整数或浮点数，可以使用Python的 `random` 模块。需要注意的是，`random` 模块生成的随机数并不适用于加密和安全相关的场景，因为它们可能较容易被预测。

四、总结

通过一些官方的文档及资料查询，总结了os库在windows下的各种使用方法，有很多方法还是没有见过的，对以后的一些代码思路又有了更多的拓展；顺便也希望大家多点赞评论一下，加加热度。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/729685