os模块篇（十九）

os.register_at_fork(*, before=None, after_in_parent=None, after_in_child=None)

os.register_at_fork() 是 Python 的一个函数，它允许你在进程分叉（通过 os.fork()）之前和之后注册回调函数。这些回调函数分别在父进程和子进程中执行，以便进行资源管理和状态设置。

在 Unix-like 系统中，os.fork() 会创建一个与父进程几乎完全相同的子进程。由于子进程是父进程的副本，因此父进程打开的文件描述符、锁和其他资源也会被子进程继承。os.register_at_fork() 允许你在进程分叉的关键时刻执行特定的操作，以确保这些资源得到正确的处理。

下面是 os.register_at_fork() 函数的参数解释：

• before: 一个可选的回调函数，它将在 os.fork() 调用之前被调用。这可以用于执行一些需要在分叉之前完成的准备工作，比如关闭不需要的文件描述符或释放锁。

• after_in_parent: 一个可选的回调函数，它将在父进程中 os.fork() 调用之后被调用。这可以用于执行一些需要在父进程中完成的清理工作或其他初始化任务。

• after_in_child: 一个可选的回调函数，它将在子进程中 os.fork() 调用之后被调用。这可以用于执行一些需要在子进程中完成的初始化工作，比如打开新的文件描述符或设置特定的环境变量。

这些回调函数应该接受一个参数，即 os.register_at_fork() 函数本身。这允许你在回调函数中注册更多的函数，或者执行其他需要的操作。

需要注意的是，os.register_at_fork() 在 Windows 平台上不可用，因为它依赖于 Unix-like 系统中的进程分叉机制。

以下是一个使用 os.register_at_fork() 的示例：

import os

# 在父进程和子进程中分别执行的回调函数
def before_fork():
    print("Before fork")

def after_fork_parent():
    print("After fork in parent")

def after_fork_child():
    print("After fork in child")

# 注册回调函数
os.register_at_fork(before=before_fork, after_in_parent=after_fork_parent, after_in_child=after_fork_child)

# 执行进程分叉
pid = os.fork()

if pid == 0:
    # 子进程代码
    print("This is the child process")
else:
    # 父进程代码
    print("This is the parent process")

在这个示例中，before_fork 会在 os.fork() 调用之前执行，after_fork_parent 会在父进程中执行，而 after_fork_child 会在子进程中执行。通过这种方式，你可以在进程分叉的不同阶段执行特定的操作。

os.spawnl(mode, path, …)

os.spawnl() 是 Python 的一个较低级别的函数，用于创建新的进程来执行另一个程序。这个函数在 Unix-like 系统上可用，并且提供了一种启动新进程的方式，同时允许你传递参数和环境变量。

函数的参数解释如下：

• mode: 这个参数决定了父进程如何与新创建的子进程交互。它可以是以下几种模式之一：

  • os.P_WAIT: 父进程会等待子进程执行完毕。这是阻塞式的调用，父进程会暂停执行，直到子进程结束。
  • os.P_NOWAIT: 父进程不会等待子进程执行完毕。这是非阻塞式的调用，父进程会继续执行，而子进程在后台运行。
  • os.P_DETACH: 父进程启动子进程后立即分离，子进程成为一个独立的进程组，父进程不会等待它。这在某些系统上可能不可用。

• path: 这是要执行的程序的路径。通常，这是一个可执行文件的路径。

• …: 后续的参数是传递给新进程的命令行参数。这些参数应该按照程序期望的顺序传递，并且通常是以空格分隔的字符串形式。第一个参数通常是程序的名称，后面的参数是程序需要的任何命令行参数。

os.spawnl() 函数也会设置新进程的环境变量，但这些环境变量不是通过参数传递的，而是继承自父进程当前的环境。如果你需要为新进程设置特定的环境变量，你需要使用其他函数（如 os.environ）来修改父进程的环境，这会影响到通过 os.spawnl() 创建的子进程。

需要注意的是，os.spawnl() 在 Windows 平台上不可用，因为它是基于 Unix-like 系统的进程创建机制。在 Windows 上，你通常会使用 subprocess 模块来创建新进程。

这里是一个简单的 os.spawnl() 使用示例：

import os

# 假设我们有一个名为 'my_program' 的可执行文件，它接受命令行参数
# 我们想要传递 'arg1' 和 'arg2' 作为参数

# 使用 os.spawnl() 创建新进程来执行 my_program
os.spawnl(os.P_WAIT, '/path/to/my_program', 'my_program', 'arg1', 'arg2')

# 如果使用了 os.P_WAIT 模式，父进程会在这里等待，直到 my_program 执行完毕

# 如果使用了 os.P_NOWAIT，父进程会继续执行，而不会等待 my_program

在实际应用中，由于 os.spawnl() 提供了较低级别的控制，并且不如 subprocess 模块灵活和强大，因此通常建议使用 subprocess 模块来创建新进程。

os.spawnle(mode, path, …, env)

os.spawnle() 是 Python 的一个较低级别的函数，用于创建新的进程来执行另一个程序，并允许你指定环境变量。这个函数在 Unix-like 系统上可用，并且提供了一种启动新进程的方式，同时允许你传递参数和环境变量。

函数的参数解释如下：

• mode: 这个参数决定了父进程如何与新创建的子进程交互。它可以是以下几种模式之一：

  • os.P_WAIT: 父进程会等待子进程执行完毕。
  • os.P_NOWAIT: 父进程不会等待子进程执行完毕。
  • os.P_DETACH: 父进程启动子进程后立即分离，子进程成为一个独立的进程组，父进程不会等待它。

• path: 这是要执行的程序的路径。

• …: 后续的参数是传递给新进程的命令行参数，以列表的形式给出。

• env: 这是一个字典，其中包含要传递给新进程的环境变量。这些环境变量会覆盖父进程的环境变量。

os.spawnle() 函数允许你为新进程设置特定的环境变量，而不是继承父进程的环境变量。这对于需要隔离环境变量或设置特定环境以运行程序的场景非常有用。

需要注意的是，os.spawnle() 在 Windows 平台上不可用，因为它是基于 Unix-like 系统的进程创建机制。在 Windows 上，你通常会使用 subprocess 模块来创建新进程。

下面是一个使用 os.spawnle() 的示例：

import os

# 创建一个环境变量字典
env = {
    'MY_ENV_VAR': 'my_value',
    # 其他环境变量...
}

# 使用 os.spawnle() 创建新进程，并传递环境变量
os.spawnle(os.P_WAIT, '/path/to/my_program', 'my_program', 'arg1', 'arg2', env=env)

# 如果使用了 os.P_WAIT 模式，父进程会在这里等待，直到 my_program 执行完毕

在这个示例中，我们创建了一个包含环境变量的字典 env，并将其作为 os.spawnle() 的一个参数传递。这样，新创建的进程 my_program 将使用我们指定的环境变量，而不是继承父进程的环境变量。

然而，由于 os.spawnle() 提供了较低级别的控制，并且不如 subprocess 模块灵活和强大，因此通常建议使用 subprocess 模块来创建新进程。

os.spawnlp(mode, file, …)

os.spawnlp() 是 Python 的一个函数，用于在 Unix-like 系统上创建新的进程来执行另一个程序。这个函数与 os.spawnle() 类似，但 os.spawnlp() 使用环境变量路径来查找要执行的程序，而 os.spawnle() 需要提供程序的完整路径。

函数的参数解释如下：

• mode: 与 os.spawnle() 中的 mode 参数相同，它决定了父进程如何与新创建的子进程交互。可以是 os.P_WAIT、os.P_NOWAIT 或 os.P_DETACH。

• file: 这是要执行的程序的名称。与 os.spawnle() 不同，os.spawnlp() 会在环境变量 PATH 中查找这个名称对应的可执行文件。因此，你不需要提供完整的路径，只需要提供程序的名称。

• …: 后续的参数是传递给新进程的命令行参数。这些参数应该按照程序期望的顺序传递，并且通常是以空格分隔的字符串形式。第一个参数通常是程序的名称（尽管在 os.spawnlp() 中它是可选的，因为 file 参数已经指定了程序名称），后面的参数是程序需要的任何命令行参数。

需要注意的是，os.spawnlp() 也会设置新进程的环境变量，这些环境变量是继承自父进程的。如果你需要为新进程设置特定的环境变量，你需要在调用 os.spawnlp() 之前修改父进程的环境变量。

此外，与 os.spawnle() 一样，os.spawnlp() 在 Windows 平台上也是不可用的。在 Windows 上，你通常会使用 subprocess 模块来创建新进程。

下面是一个 os.spawnlp() 的使用示例：

import os

# 假设环境变量 PATH 中包含了 '/path/to/' 目录
# 我们想要执行名为 'my_program' 的程序，并传递参数 'arg1' 和 'arg2'

# 使用 os.spawnlp() 创建新进程来执行 my_program
os.spawnlp(os.P_WAIT, 'my_program', 'arg1', 'arg2')

# 如果使用了 os.P_WAIT 模式，父进程会在这里等待，直到 my_program 执行完毕

# 如果使用了 os.P_NOWAIT，父进程会继续执行，而不会等待 my_program

在这个示例中，os.spawnlp() 会在环境变量 PATH 中查找 my_program 可执行文件，并使用提供的参数执行它。如果 my_program 不在 PATH 中，函数将引发一个 FileNotFoundError。

os.spawnlpe(mode, file, …, env)

os.spawnlpe() 是 Python 中的一个较旧的函数，用于在 Unix-like 系统上创建新的进程来执行另一个程序。这个函数结合了 os.spawnl() 和 os.putenv() 的功能，允许你指定要执行的程序、命令行参数以及环境变量。

函数的参数解释如下：

• mode: 这是一个整数，决定了父进程如何与子进程交互。它的值与 os.spawnl() 中的 mode 参数相同，可以是 os.P_WAIT、os.P_NOWAIT 或 os.P_DETACH。

• file: 这是要执行的程序的名称。与 os.spawnl() 不同的是，os.spawnlpe() 会在环境变量 PATH 中查找这个名称对应的可执行文件。因此，你不需要提供完整的路径，只需要提供程序的名称。

• …: 后续的参数是传递给新进程的命令行参数。这些参数应该按照程序期望的顺序传递，并且通常是以空格分隔的字符串形式。第一个参数通常是程序的名称（尽管在 os.spawnlpe() 中它是可选的，因为 file 参数已经指定了程序名称），后面的参数是程序需要的任何命令行参数。

• env: 这是一个环境变量的字典。os.spawnlpe() 会使用这个字典来设置新进程的环境变量。这意味着新进程将不会继承父进程的环境变量，而是使用这里指定的环境变量。

需要注意的是，os.spawnlpe() 函数在 Python 3.4 之后被标记为已弃用（deprecated），并在 Python 3.8 中被移除。这是因为这个函数与 os.spawnle() 和 os.putenv() 的组合功能重复，而且使用 subprocess 模块是更现代、更推荐的方式来创建新的进程。

如果你正在编写新的代码，建议使用 subprocess 模块来创建新进程，因为它提供了更多的功能和更好的可移植性。如果你正在维护使用 os.spawnlpe() 的旧代码，建议将其迁移到 subprocess 模块以提高代码的稳定性和可维护性。

os.spawnv(mode, path, args)

os.spawnv() 是 Python 的一个较旧且较低级别的函数，用于在 Unix-like 系统上创建新的进程来执行另一个程序。与 os.spawnle() 类似，os.spawnv() 也允许你指定程序的完整路径和命令行参数，但它不会让你直接设置环境变量；相反，新进程将继承父进程的环境变量。

函数的参数解释如下：

• mode: 这是一个整数，决定了父进程如何与新创建的子进程交互。它的值与 os.spawnle() 中的 mode 参数相同，可以是 os.P_WAIT、os.P_NOWAIT 或 os.P_DETACH。

• path: 这是要执行的程序的完整路径。

• args: 这是一个参数列表，用于传递给新进程。列表的第一个元素通常是程序的名称（尽管在 os.spawnv() 中它是可选的，因为 path 参数已经指定了程序名称），后面的元素是程序需要的任何命令行参数。

需要注意的是，os.spawnv() 不会修改或设置新进程的环境变量；新进程将继承父进程的环境变量。如果你需要为新进程设置特定的环境变量，你需要在调用 os.spawnv() 之前修改父进程的环境变量。

此外，与 os.spawnle() 一样，os.spawnv() 在 Windows 平台上也是不可用的。在 Windows 上，你通常会使用 subprocess 模块来创建新进程。

下面是一个使用 os.spawnv() 的示例：

import os

# 命令行参数列表
args = ['my_program', 'arg1', 'arg2']

# 使用 os.spawnv() 创建新进程来执行 my_program
os.spawnv(os.P_WAIT, '/path/to/my_program', args)

# 如果使用了 os.P_WAIT 模式，父进程会在这里等待，直到 my_program 执行完毕

# 如果使用了 os.P_NOWAIT，父进程会继续执行，而不会等待 my_program

在这个示例中，os.spawnv() 会使用提供的完整路径 /path/to/my_program 和参数列表 args 来启动新进程执行 my_program 程序。如果 my_program 程序需要环境变量，那么这些变量必须在调用 os.spawnv() 之前通过其他方式（如 os.environ）进行设置。

os.spawnve(mode, path, args, env)

os.spawnve() 是 Python 中的一个较旧且较低级别的函数，用于在 Unix-like 系统上创建新的进程来执行另一个程序。与 os.spawnv() 类似，os.spawnve() 允许你指定程序的完整路径、命令行参数以及环境变量列表。

函数的参数解释如下：

• mode: 这是一个整数，决定了父进程如何与新创建的子进程交互。它的值与 os.spawnv() 和 os.spawnle() 中的 mode 参数相同，可以是 os.P_WAIT、os.P_NOWAIT 或 os.P_DETACH。

• path: 这是要执行的程序的完整路径。

• args: 这是一个参数列表，用于传递给新进程。列表的第一个元素通常是程序的名称，后面的元素是程序需要的任何命令行参数。

• env: 这是一个环境变量的列表，每个环境变量都是一个字符串，格式为 “key=value”。这个列表用于设置新进程的环境变量。新进程将使用这个列表中的环境变量，而不是继承父进程的环境变量。

需要注意的是，env 参数是一个字符串列表，而不是一个字典。每个字符串的格式必须是 “key=value”，其中 “key” 是环境变量的名称，“value” 是环境变量的值。这个列表中的环境变量将完全替换父进程的环境变量，而不是仅仅添加或修改几个环境变量。

此外，与 os.spawnv() 和 os.spawnle() 一样，os.spawnve() 在 Windows 平台上也是不可用的。在 Windows 上，你通常会使用 subprocess 模块来创建新进程。

下面是一个使用 os.spawnve() 的示例：

import os

# 命令行参数列表
args = ['my_program', 'arg1', 'arg2']

# 环境变量列表
env = ['PATH=/usr/bin:/bin', 'MY_VAR=my_value']

# 使用 os.spawnve() 创建新进程来执行 my_program
# 注意，env 参数是一个字符串列表，每个元素都是 "key=value" 格式
os.spawnve(os.P_WAIT, '/path/to/my_program', args, env)

# 如果使用了 os.P_WAIT 模式，父进程会在这里等待，直到 my_program 执行完毕

# 如果使用了 os.P_NOWAIT，父进程会继续执行，而不会等待 my_program

在这个示例中，os.spawnve() 会使用提供的完整路径 /path/to/my_program、参数列表 args 和环境变量列表 env 来启动新进程执行 my_program 程序。新进程将使用 env 列表中指定的环境变量，而不是继承父进程的环境变量。

os.spawnvp(mode, file, args)

os.spawnvp() 是 Python 的一个较低级别的函数，用于在 Unix-like 系统上创建新的进程来执行另一个程序。这个函数结合了 os.spawnv() 和 os.execvp() 的功能，允许你指定要执行的程序的名称、命令行参数以及使用 PATH 环境变量来查找程序。

函数的参数解释如下：

• mode: 这是一个整数，决定了父进程如何与新创建的子进程交互。它的值与 os.spawnv() 和其他 os.spawn*() 函数中的 mode 参数相同，可以是 os.P_WAIT、os.P_NOWAIT 或 os.P_DETACH。

• file: 这是要执行的程序的名称。与 os.spawnv() 不同的是，os.spawnvp() 会在环境变量 PATH 中查找这个名称对应的可执行文件。这意味着你不需要提供完整的路径，只需要提供程序的名称。

• args: 这是一个参数列表，用于传递给新进程。列表的第一个元素应该是程序的名称（尽管在 os.spawnvp() 中它是可选的，因为 file 参数已经指定了程序名称），后面的元素是程序需要的任何命令行参数。

需要注意的是，os.spawnvp() 不会自动设置环境变量。新进程将继承父进程的环境变量。如果你需要为新进程设置特定的环境变量，你需要在调用 os.spawnvp() 之前通过其他方式（如修改 os.environ 字典）来设置它们。

此外，与 os.spawnv() 和其他 os.spawn*() 函数一样，os.spawnvp() 在 Windows 平台上也是不可用的。在 Windows 上，你通常会使用 subprocess 模块来创建新进程。

下面是一个使用 os.spawnvp() 的示例：

import os

# 命令行参数列表
args = ['my_program', 'arg1', 'arg2']

# 使用 os.spawnvp() 创建新进程来执行 my_program
# my_program 应该在环境变量 PATH 指定的目录中可找到
os.spawnvp(os.P_WAIT, 'my_program', args)

# 如果使用了 os.P_WAIT 模式，父进程会在这里等待，直到 my_program 执行完毕

# 如果使用了 os.P_NOWAIT，父进程会继续执行，而不会等待 my_program

在这个示例中，os.spawnvp() 会使用 PATH 环境变量来查找 my_program 可执行文件，并使用提供的参数列表 args 来启动新进程执行它。如果 my_program 需要特定的环境变量，你需要在调用 os.spawnvp() 之前通过修改 os.environ 来设置它们。

os.spawnvpe(mode, file, args, env)

os.spawnvpe() 是 Python 中的一个较低级别的函数，用于在 Unix-like 系统上创建新的进程来执行另一个程序。这个函数结合了 os.spawnv() 和 os.execvpe() 的功能，允许你指定要执行的程序的名称、命令行参数以及一个环境变量列表。

函数的参数解释如下：

• mode: 这是一个整数，决定了父进程如何与新创建的子进程交互。它的值与 os.spawnv()、os.spawnle() 和其他 os.spawn*() 函数中的 mode 参数相同，可以是 os.P_WAIT、os.P_NOWAIT 或 os.P_DETACH。

• file: 这是要执行的程序的名称。与 os.spawnv() 不同的是，os.spawnvpe() 不会在环境变量 PATH 中查找这个名称对应的可执行文件，所以你需要提供程序的完整路径。

• args: 这是一个参数列表，用于传递给新进程。列表的第一个元素应该是程序的名称（尽管在 os.spawnvpe() 中它是可选的，因为 file 参数已经指定了程序名称），后面的元素是程序需要的任何命令行参数。

• env: 这是一个环境变量列表，用于设置新进程的环境变量。列表中的每个元素都是一个字符串，格式为 “key=value”。这个列表会完全替换父进程的环境变量，新进程将使用这个列表中的环境变量。

与 os.spawnve() 类似，os.spawnvpe() 允许你为新进程设置特定的环境变量列表。但是，os.spawnvpe() 会在环境变量 PATH 中查找 file 指定的程序名称，而 os.spawnve() 则要求你提供程序的完整路径。

请注意，os.spawnvpe() 在 Windows 平台上也是不可用的。在 Windows 上创建新进程时，你通常会使用 subprocess 模块。

下面是一个使用 os.spawnvpe() 的示例：

import os

# 命令行参数列表
args = ['my_program', 'arg1', 'arg2']

# 环境变量列表
env = ['PATH=/usr/bin:/bin', 'MY_VAR=my_value']

# 使用 os.spawnvpe() 创建新进程来执行 my_program
# 注意，你需要提供 my_program 的完整路径
os.spawnvpe(os.P_WAIT, '/path/to/my_program', args, env)

# 如果使用了 os.P_WAIT 模式，父进程会在这里等待，直到 my_program 执行完毕

# 如果使用了 os.P_NOWAIT，父进程会继续执行，而不会等待 my_program

在这个示例中，os.spawnvpe() 使用提供的完整路径 /path/to/my_program、参数列表 args 和环境变量列表 env 来启动新进程执行 my_program 程序。新进程将使用 env 列表中指定的环境变量，而不是继承父进程的环境变量。

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

os.startfile() 是 Windows 平台特有的函数，用于启动与指定文件关联的应用程序来打开或操作该文件。这个函数非常有用，因为它允许你以与操作系统中双击文件相同的方式打开文件，而无需知道应该使用哪个应用程序来打开它。

函数的参数解释如下：

• path: 这是要打开的文件的路径。

• operation: 这是一个可选参数，用于指定操作类型。例如，你可以使用 “open” 来打开文件，使用 “print” 来打印文件等。如果不指定操作类型，os.startfile() 会使用文件的默认操作。

• arguments: 这是一个可选参数，用于传递给打开文件的程序的额外参数。

• cwd: 这是一个可选参数，用于指定新进程的当前工作目录。

• show_cmd: 这是一个可选参数，用于控制是否显示命令窗口。通常，你不需要指定这个参数，除非你有特定的需求。

下面是一个使用 os.startfile() 的简单示例：

import os

# 打开一个文本文件
os.startfile("C:\\path\\to\\your\\file.txt")

# 用指定的应用程序打开文件
os.startfile("C:\\path\\to\\your\\file.txt", "open", "notepad")

# 打印一个图片文件
os.startfile("C:\\path\\to\\your\\image.jpg", "print")

在第一个示例中，文本文件会用默认的文本编辑器打开。在第二个示例中，文本文件会用记事本（Notepad）打开，即使这不是默认的文本编辑器。在第三个示例中，图片文件会被打印出来。

请注意，os.startfile() 是 Windows 平台特有的，因此在非 Windows 平台上不可用。在 Unix-like 系统上，你可以使用 subprocess 模块来启动外部程序，但这通常需要你知道应该使用哪个程序来打开或操作文件。

os.system(command)

os.system(command) 是 Python 中 os 模块提供的一个函数，用于执行 shell 命令。这个函数接受一个字符串参数 command，该字符串是要在子 shell 中执行的命令。os.system() 会调用系统 shell 来执行这个命令，并返回命令的退出状态。

退出状态是一个整数，通常用来表示命令执行的成功与否。如果命令成功执行，则通常返回 0；如果命令执行失败，则返回一个非零值。具体的返回值依赖于被执行的命令和操作系统。

下面是一个简单的示例，演示如何使用 os.system() 来执行一个 shell 命令：

import os

# 执行 "ls -l" 命令
result = os.system("ls -l")

# 打印命令的退出状态
print("Exit status:", result)

在这个示例中，os.system(“ls -l”) 会调用系统的 shell 来执行 ls -l 命令，该命令用于列出当前目录下的文件和目录。result 变量将存储命令的退出状态。

需要注意的是，os.system() 有一些缺点和限制：

• 它依赖于系统的 shell，这意味着它可能受到 shell 注入攻击的影响，如果命令字符串是由不可信的输入构建的。
• 它不能提供命令执行的任何输出，除非是通过退出状态或写入到文件。如果你需要捕获命令的输出，应该使用 subprocess 模块。
• 它不能用于需要复杂进程管理的场景，比如需要设置环境变量、更改工作目录或进行错误处理的情况。

对于更复杂的需求，推荐使用 subprocess 模块，它提供了更强大和灵活的功能来执行子进程和与其交互。

os.times()

os.times() 是 Python 的 os 模块中的一个函数，它用于获取系统 CPU 时间。这个函数在 Unix-like 系统上可用，但在 Windows 上不可用。它返回一个包含五个浮点数的元组，这些数字代表了用户 CPU 时间、系统 CPU 时间、子用户 CPU 时间、子系统 CPU 时间以及总的 CPU 时间（以秒为单位）。

• user: 用户 CPU 时间，表示进程在用户模式下花费的 CPU 时间。
• system: 系统 CPU 时间，表示进程在内核模式下花费的 CPU 时间。
• children_user: 子进程的用户 CPU 时间。
• children_system: 子进程的系统 CPU 时间。
• elapsed: 过去的实际墙钟时间（elapsed real time），即从系统启动到 os.times() 被调用的时间。

下面是一个使用 os.times() 的简单示例：

import os
import time

# 记录开始时间
start_time = time.time()

# 执行一些计算或操作
# ...

# 记录结束时间
end_time = time.time()

# 获取 CPU 时间
cpu_times = os.times()

# 打印结果
print("User CPU time:", cpu_times.user)
print("System CPU time:", cpu_times.system)
print("Elapsed real time:", cpu_times.elapsed)
print("Total CPU time:", cpu_times.user + cpu_times.system)
print("Wall clock time:", end_time - start_time)

请注意，os.times() 给出的是进程及其子进程的 CPU 时间，而不是从系统启动到现在为止的总 CPU 时间。此外，由于 os.times() 只在 Unix-like 系统上可用，如果你在 Windows 上运行上述代码，将会得到一个 AttributeError。

在 Windows 上，如果你需要获取类似的 CPU 时间信息，可以考虑使用 psutil 库，这是一个跨平台的库，可以提供各种系统使用信息，包括 CPU 时间。例如：

python
import psutil

获取 CPU 时间

cpu_times = psutil.cpu_times()

打印结果

print(“User CPU time:”, cpu_times.user)
print(“System CPU time:”, cpu_times.system)
print(“Total CPU time:”, cpu_times.user + cpu_times.system)

psutil.cpu_times() 在 Windows 和 Unix-like 系统上都可以使用，并且提供了类似的信息。

os.wait()

os.wait() 是 Python 的 os 模块中的一个函数，它用于等待子进程的结束。当你使用 os.fork() 创建一个子进程后，父进程和子进程会并发执行。如果你希望在父进程中等待子进程完成其任务后再继续执行，你可以使用 os.wait()。

os.wait() 函数会阻塞父进程，直到一个子进程结束。当子进程结束时，os.wait() 会收集子进程的终止状态，并返回一个包含两个元素的元组 (pid, status)。其中 pid 是已结束子进程的进程ID，status 是子进程的退出状态。

退出状态是一个整数，可以通过 os.WIFEXITED(status)、os.WIFSIGNALED(status) 和 os.WEXITSTATUS(status) 等宏来检查子进程是正常退出还是由于接收到信号而终止，以及获取子进程的退出码。

下面是一个使用 os.fork() 和 os.wait() 的简单示例：

import os
import sys

def child_process():
    # 子进程执行的代码
    print("Child process is running with PID:", os.getpid())
    sys.exit(42)  # 子进程退出并返回状态码 42

if __name__ == "__main__":
    # 创建子进程
    pid = os.fork()

    if pid == 0:
        # 子进程代码
        child_process()
    else:
        # 父进程代码
        print("Parent process is running with PID:", os.getpid())
        print("Waiting for child process to finish...")

        # 等待子进程结束
        try:
            pid, status = os.wait()
            print("Child process finished with PID:", pid)
            print("Exit status:", status)
            if os.WIFEXITED(status):
                print("Child exited normally with code", os.WEXITSTATUS(status))
            elif os.WIFSIGNALED(status):
                print("Child terminated by signal", os.WTERMSIG(status))
        except OSError as e:
            print("OS error:", e.errno, e.strerror)

在这个示例中，父进程创建了一个子进程，并通过 os.wait() 等待子进程结束。子进程打印其进程ID并退出，返回一个状态码 42。父进程在子进程结束后打印子进程的进程ID和退出状态。

需要注意的是，os.wait() 只等待一个子进程。如果你有多个子进程需要等待，你可能需要使用 os.waitpid() 函数，它可以等待指定的子进程。此外，在 Unix-like 系统上，你还可以使用 subprocess 模块来管理子进程，它提供了更高级别的接口来启动和管理子进程。

os.waitid(idtype, id, options, /)

os.waitid() 是 Python 的 os 模块中的一个函数，它用于等待一个或多个子进程的终止，并获取关于这些子进程的信息。这个函数在 Unix-like 系统上提供了更高级的进程等待功能，相较于传统的 os.wait() 或 os.waitpid()。

函数的参数解释如下：

• idtype: 指定要等待的子进程的类型。这可以是以下几个常量之一：

  • os.P_PID: 按进程 ID 等待。
  • os.P_PGID: 按进程组 ID 等待。
  • os.P_ALL: 等待任何子进程。

• id: 根据 idtype 的值，这个参数可以是进程 ID、进程组 ID 或其他标识符。

• options: 这是一个位掩码，用于指定函数的行为。可以是以下常量之一或它们的组合：

  • os.WNOHANG: 如果没有子进程满足条件，则立即返回而不是等待。
  • os.WUNTRACED: 也报告那些被停止（而不是终止）的子进程。

os.waitid() 返回一个元组，其中包含两个元素：(status, info)。status 是一个整数，表示函数调用的结果状态。info 是一个包含子进程信息的字典，其结构取决于 idtype 的值。

下面是一个使用 os.waitid() 的示例：

import os

# 创建一个子进程
pid = os.fork()

if pid == 0:
    # 子进程执行的代码
    print("Child process is running with PID:", os.getpid())
    os._exit(42)  # 子进程退出并返回状态码 42
else:
    # 父进程执行的代码
    print("Parent process is running with PID:", os.getpid())
    
    # 等待子进程结束
    try:
        status, info = os.waitid(os.P_PID, pid, 0)
        print("Child process ended with status:", status)
        print("Info about the child process:", info)
    except OSError as e:
        print("Error waiting for child process:", e)

在这个示例中，父进程使用 os.waitid() 等待特定 PID 的子进程结束，并打印子进程的退出状态和相关信息。

需要注意的是，os.waitid() 是 Unix-like 系统特有的，因此在 Windows 平台上不可用。在 Windows 上，你通常会使用 os.wait() 或 subprocess 模块来处理子进程。