os模块篇（三）

专栏目录

os.putenv(key, value, /)

os.putenv(key, value) 是 Python 中的一个方法，用于设置环境变量。这个方法属于 os 模块，该模块提供了许多与操作系统交互的功能。

os.putenv(key, value) 的参数如下：

• key: 环境变量的名称（字符串）。
• value: 环境变量的值（字符串）。

使用 os.putenv 设置的环境变量只影响当前进程及其子进程。当当前进程结束时，这些环境变量不会影响到其他进程或系统环境。

下面是一个简单的示例：

import os

# 设置环境变量
os.putenv('MY_ENV_VAR', 'Hello, World!')

# 获取并打印环境变量的值
print(os.getenv('MY_ENV_VAR'))  # 输出: Hello, World!
1
2
3
4
5
6
7

然而，在 Python 中更常用的方法是使用 os.environ 字典来设置和获取环境变量，因为它提供了更直观和方便的方式来操作环境变量。例如：

import os

# 设置环境变量
os.environ['MY_ENV_VAR'] = 'Hello, World!'

# 获取并打印环境变量的值
print(os.environ['MY_ENV_VAR'])  # 输出: Hello, World!
1
2
3
4
5
6
7

这两种方法（os.putenv 和 os.environ）都可以用来设置环境变量，但使用 os.environ 通常更为简洁和方便。

os.setegid(egid, /)

os.setegid(egid) 是 Python 的 os 模块中的一个函数，用于设置当前进程的有效组 ID（effective group ID）。在 Unix 和类 Unix 系统中，每个进程都有一个组 ID（group ID）和一个有效组 ID，它们通常用于确定进程对文件和其他资源的访问权限。

os.setegid(egid) 的参数是：

• egid: 一个整数，表示要设置的有效组 ID。

请注意，只有超级用户（root）才能成功更改有效组 ID。对于非 root 用户，尝试更改有效组 ID 通常会引发 PermissionError。

使用 os.setegid() 时要小心，因为更改进程的有效组 ID 可能会影响该进程对文件系统和其他资源的访问权限。

下面是一个简单的示例，展示了如何使用 os.setegid()：

import os

# 获取当前进程的有效组 ID
current_egid = os.getegid()
print(f"Current effective group ID: {current_egid}")

# 尝试设置新的有效组 ID
# 注意：这里假设您有足够的权限来更改有效组 ID
try:
    os.setegid(1000)  # 假设 1000 是您想设置的新组 ID
    print("Effective group ID changed successfully.")
except PermissionError:
    print("Permission denied. Unable to change effective group ID.")

# 再次获取并打印有效组 ID，以确认是否更改成功
new_egid = os.getegid()
print(f"New effective group ID: {new_egid}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在上面的代码中，我们首先使用 os.getegid() 获取当前进程的有效组 ID，然后尝试使用 os.setegid() 设置一个新的有效组 ID。请注意，由于权限限制，这个操作可能会失败。最后，我们再次使用 os.getegid() 来验证有效组 ID 是否已更改。

在实际应用中，更改进程的有效组 ID 通常不是必需的，除非你正在编写需要特定权限级别的系统级程序或服务。在大多数情况下，使用标准文件 I/O 函数和文件权限管理就可以满足需求。

os.seteuid(euid, /)

os.seteuid(euid) 是 Python 的 os 模块中的一个函数，用于设置当前进程的有效用户 ID（effective user ID）。有效用户 ID 是 Unix 和类 Unix 系统中进程的一个属性，它决定了进程对文件的访问权限和其他一些系统操作的权限。

os.seteuid(euid) 的参数是：

• euid: 一个整数，表示要设置的有效用户 ID。

和 os.setegid() 一样，只有超级用户（root）才能成功更改有效用户 ID。对于非 root 用户，尝试更改有效用户 ID 通常会引发 PermissionError。

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

import os

# 获取当前进程的有效用户 ID
current_euid = os.geteuid()
print(f"Current effective user ID: {current_euid}")

# 尝试设置新的有效用户 ID
# 注意：这里假设您有足够的权限来更改有效用户 ID
try:
    os.seteuid(1000)  # 假设 1000 是您想设置的新用户 ID
    print("Effective user ID changed successfully.")
except PermissionError:
    print("Permission denied. Unable to change effective user ID.")

# 再次获取并打印有效用户 ID，以确认是否更改成功
new_euid = os.geteuid()
print(f"New effective user ID: {new_euid}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在上面的代码中，我们首先使用 os.geteuid() 获取当前进程的有效用户 ID，然后尝试使用 os.seteuid() 设置一个新的有效用户 ID。和 os.setegid() 一样，由于权限限制，这个操作可能会失败。最后，我们再次使用 os.geteuid() 来验证有效用户 ID 是否已更改。

请注意，更改进程的有效用户 ID 是一个高级操作，通常只有当你需要编写需要特定权限级别的系统级程序或服务时才会这么做。在大多数情况下，应用程序不应该需要更改其有效用户 ID。

os.setgid(gid, /)

os.setgid(gid) 是 Python 的 os 模块中的一个函数，用于设置当前进程的组 ID（group ID）。在 Unix 和类 Unix 系统中，每个进程都有一个组 ID，它决定了进程对文件和其他资源的访问权限。

os.setgid(gid) 的参数是：

• gid: 一个整数，表示要设置的组 ID。

与 os.setegid() 不同，os.setgid() 设置的是实际组 ID（real group ID），而不是有效组 ID。实际组 ID 是进程创建时继承的组 ID，而有效组 ID 用于决定进程的文件访问权限。

请注意，只有超级用户（root）才能成功更改实际组 ID。对于非 root 用户，尝试更改实际组 ID 通常会引发 PermissionError。

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

import os

# 获取当前进程的实际组 ID
current_gid = os.getgid()
print(f"Current real group ID: {current_gid}")

# 尝试设置新的实际组 ID
# 注意：这里假设您有足够的权限来更改实际组 ID
try:
    os.setgid(1000)  # 假设 1000 是您想设置的新组 ID
    print("Real group ID changed successfully.")
except PermissionError:
    print("Permission denied. Unable to change real group ID.")

# 再次获取并打印实际组 ID，以确认是否更改成功
new_gid = os.getgid()
print(f"New real group ID: {new_gid}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在上面的代码中，我们首先使用 os.getgid() 获取当前进程的实际组 ID，然后尝试使用 os.setgid() 设置一个新的实际组 ID。和 os.setegid() 一样，由于权限限制，这个操作可能会失败。最后，我们再次使用 os.getgid() 来验证实际组 ID 是否已更改。

在大多数应用程序中，更改进程的实际组 ID 不是必需的。通常，更改有效组 ID（使用 os.setegid()）就足够了，因为它决定了进程的文件访问权限。实际组 ID 更多的是在系统编程和创建新进程时用到。

os.setgroups(groups, /)

os.setgroups(groups) 是 Python 的 os 模块中的一个函数，用于设置当前进程的所有组 ID（group IDs）。这个函数允许你更改进程所属的所有组的列表。

os.setgroups(groups) 的参数是：

• groups: 一个整数列表，表示要设置的所有组 ID。

需要注意的是，只有超级用户（root）才能更改进程的所有组 ID 列表。对于非 root 用户，尝试调用 os.setgroups() 通常会引发 PermissionError。

这个函数将替换当前进程的所有组 ID，而不是添加新的组 ID 到现有的列表中。如果 groups 参数为空列表，则进程将没有任何附加组。

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

import os

# 获取当前进程的所有组 ID
current_groups = os.getgroups()
print(f"Current group IDs: {current_groups}")

# 尝试设置新的所有组 ID
# 注意：这里假设您有足够的权限来更改所有组 ID
try:
    new_groups = [1000, 2000]  # 假设 1000 和 2000 是您想设置的组 ID
    os.setgroups(new_groups)
    print("Group IDs changed successfully.")
except PermissionError:
    print("Permission denied. Unable to change group IDs.")

# 再次获取并打印所有组 ID，以确认是否更改成功
new_groups = os.getgroups()
print(f"New group IDs: {new_groups}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在上面的代码中，我们首先使用 os.getgroups() 获取当前进程的所有组 ID，然后尝试使用 os.setgroups() 设置一个新的组 ID 列表。和前面的函数一样，由于权限限制，这个操作可能会失败。最后，我们再次使用 os.getgroups() 来验证所有组 ID 是否已更改。

在实际应用中，更改进程的所有组 ID 列表通常不是必需的，除非你需要精细控制进程对文件和其他资源的访问权限。在大多数情况下，使用标准文件 I/O 函数和文件权限管理就可以满足需求。

os.setns(fd, nstype=0)

os.setns(fd, nstype=0) 是 Python 3.8 版本中新增的 os 模块函数，用于将当前进程设置到一个新的命名空间（namespace）中。Linux 命名空间是 Linux 内核提供的一种隔离机制，允许系统的一部分视图（如进程、网络、挂载点等）对不同的进程看起来是不同的。这有助于实现容器化技术，如 Docker 和 LXC。

os.setns() 函数的参数是：

• fd: 一个文件描述符，通常是通过打开 /proc/[pid]/ns/[type] 文件获得的，其中 [pid] 是目标命名空间的进程 ID，[type] 是命名空间类型（如 pid、net、mnt、uts、ipc 或 user）。
• nstype: 一个可选参数，用于指定命名空间的类型。如果不指定，则从 fd 中推断。

命名空间类型包括：

• pid: 进程命名空间，隔离进程 ID。
• net: 网络命名空间，隔离网络设备和地址。
• mnt: 挂载命名空间，隔离文件系统挂载点。
• uts: UTS 命名空间，隔离主机名和域名。
• ipc: IPC 命名空间，隔离进程间通信资源。
• user: 用户命名空间，隔离用户 ID 和组 ID。

os.setns() 函数将当前进程加入到由 fd 指定的命名空间中，并返回 0 表示成功，否则返回 -1 并设置 errno 以指示错误。

下面是一个使用 os.setns() 的简单示例，该示例将当前进程加入到目标进程的 PID 命名空间中：

import os

# 获取目标进程的 PID
target_pid = 1234

# 打开目标进程的 PID 命名空间
ns_path = f"/proc/{target_pid}/ns/pid"
with open(ns_path, "r") as ns_file:
    ns_fd = ns_file.fileno()

    try:
        # 将当前进程加入到目标进程的 PID 命名空间中
        os.setns(ns_fd)
        print("Successfully set namespace.")
    except OSError as e:
        print(f"Failed to set namespace: {e}")

    # 关闭文件描述符
    os.close(ns_fd)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

请注意，由于 os.setns() 需要超级用户权限来更改命名空间，因此在非特权进程中使用它通常会失败。此外，错误处理在上述示例中是基本的，实际使用中可能需要更详细的错误处理逻辑。

这个函数在编写需要深入操作系统级别的应用程序（如容器管理工具或系统级服务）时非常有用。在普通应用程序开发中，通常不需要使用 os.setns()。

os.setpgrp()

os.setpgrp() 是 Python 的 os.os.setpgid() 的别名，用于设置当前进程的进程组 ID（process group ID）。进程组是一个或多个进程的集合，通常用于信号传递和作业控制。

os.setpgrp() 没有参数，它会将当前进程加入到当前会话（session）的新进程组中，并将当前进程设置为该进程组的领头进程（leader）。如果调用成功，该函数返回 0；如果失败，则引发 OSError。

在 Unix 和类 Unix 系统中，每个进程都有一个进程组 ID，它可以通过 os.getpgrp() 函数获取。进程组通常用于将一组相关的进程组合在一起，以便通过终端（terminal）或其他控制机制进行统一管理。

请注意，只有进程组的领头进程才能调用 os.setpgrp()。非领头进程尝试调用此函数将会失败。

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

import os

# 获取当前进程的进程组 ID
current_pgrp = os.getpgrp()
print(f"Current process group ID: {current_pgrp}")

# 尝试设置新的进程组 ID
try:
    os.setpgrp()
    print("Process group ID changed successfully.")
except OSError as e:
    print(f"Failed to change process group ID: {e}")

# 再次获取并打印进程组 ID，以确认是否更改成功
new_pgrp = os.getpgrp()
print(f"New process group ID: {new_pgrp}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在上面的代码中，我们首先使用 os.getpgrp() 获取当前进程的进程组 ID，然后尝试使用 os.setpgrp() 设置新的进程组 ID。如果调用成功，进程组 ID 应该会发生变化。由于只有领头进程才能更改进程组 ID，因此非领头进程执行此代码可能会失败。

请注意，os.setpgrp() 在 Python 3.4 之后被标记为已弃用，并且在 Python 3.8 中被移除。如果您正在使用较新版本的 Python，您可能需要使用其他方法来设置进程组 ID，例如通过 os.setpgid(os.getpid(), os.getpid())。

os.setpgid(pid, pgrp, /)

os.setpgid(pid, pgrp) 是 Python 的 os 模块中的一个函数，用于将指定的进程 pid 移动到新的进程组 pgrp 中。这个函数主要用于改变现有进程的进程组归属。

参数说明：

• pid: 要移动的进程的进程 ID。
• pgrp: 目标进程组的 ID。

调用 os.setpgid() 时，进程 pid 会被移动到进程组 pgrp 中。如果 pid 等于 0，则调用进程本身会移动到进程组 pgrp 中。

需要注意的是，只有具有足够权限的进程（通常是进程组的领头进程或者超级用户）才能成功调用 os.setpgid()。

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

import os

# 获取当前进程的进程 ID
current_pid = os.getpid()

# 获取当前进程的进程组 ID
current_pgrp = os.getpgrp()

print(f"Current PID: {current_pid}")
print(f"Current PGRP: {current_pgrp}")

# 假设我们有一个目标进程 ID 和目标进程组 ID
target_pid = 1234  # 替换为你想移动的进程的 PID
target_pgrp = 5678  # 替换为你想将进程移动到的进程组 PGRP

try:
    # 尝试将目标进程移动到新的进程组
    os.setpgid(target_pid, target_pgrp)
    print(f"Process {target_pid} moved to process group {target_pgrp} successfully.")
except PermissionError:
    print("Permission denied. Unable to move process to the new process group.")

# 再次获取并打印当前进程的进程组 ID，以确认是否更改成功
new_pgrp = os.getpgrp()
print(f"New PGRP after operation: {new_pgrp}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在上面的代码中，我们首先获取了当前进程的 PID 和 PGRP，然后尝试将目标进程 target_pid 移动到新的进程组 target_pgrp 中。如果操作成功，将打印相应的成功消息；否则，将捕获 PermissionError 并打印错误消息。

需要注意的是，os.setpgid() 在 Python 3.4 之后被标记为已弃用，并且在 Python 3.8 中被移除。如果你正在使用较新版本的 Python，并且需要设置进程组，你可能需要使用 os.setpgrp()（对于当前进程）或 os.killpg(pgrp, signal)（向进程组发送信号）等替代方法。

os.setpriority(which, who, priority)

os.setpriority(which, who, priority) 是 Python 的 os 模块中的一个函数，用于设置进程或线程的调度优先级。这个函数在 Unix-like 系统上有效，但在 Windows 上并不可用。

函数的参数如下：

• which: 指定要设置优先级的对象类型。这可以是以下常量之一：

  • os.PRIO_PROCESS: 设置进程的优先级。
  • os.PRIO_PGRP: 设置进程组的优先级。
  • os.PRIO_THREAD: 设置线程的优先级（在支持线程优先级的系统上）。

• who: 指定要设置优先级的进程、进程组或线程的标识符。对于 os.PRIO_PROCESS，who 是进程的 PID；对于 os.PRIO_PGRP，who 是进程组的 PGID；对于 os.PRIO_THREAD，who 是线程的 TID。

• priority: 指定新的优先级值。具体的取值范围和含义取决于 which 参数和操作系统。

调用 os.setpriority(which, who, priority) 后，操作系统会尝试调整指定对象（进程、进程组或线程）的调度优先级。这通常涉及到内核调度算法中的优先级设置，但实际效果取决于操作系统的实现和当前系统的负载情况。

需要注意的是，只有具有足够权限的进程（通常是超级用户或进程的所有者）才能成功调用 os.setpriority() 来改变其他进程的优先级。此外，不是所有的 Unix-like 系统都支持所有的优先级设置选项。

以下是一个使用 os.setpriority() 的示例，尝试提高当前进程的优先级：

import os

# 获取当前进程的 PID
current_pid = os.getpid()

# 设置当前进程的优先级
try:
    # 尝试提高当前进程的优先级
    # 注意：具体的优先级值取决于操作系统和可用选项
    os.setpriority(os.PRIO_PROCESS, current_pid, 10)
    print("Process priority changed successfully.")
except PermissionError:
    print("Permission denied. Unable to change process priority.")
except ValueError:
    print("Invalid priority value.")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在上面的代码中，我们尝试提高当前进程的优先级。但是，如果当前进程没有足够的权限，或者提供的优先级值无效，调用将失败并抛出异常。