原文地址：https://pymotw.com/3/os/index.html

目的：可移植的访问操作系统的特定功能。

os模块为平台特定模块（比如posix，nt和mac）提供了一个包装器。所有平台的函数API应该相同，所以使用os模块提供了一些可移植的措施。但是，不是所有函数在每个平台都有效。本文描述的很多进程管理函数在Windows上无效。

os模块的Python文档中，它的子标题是“各种操作系统接口”。该模块主要包括创建和管理运行的进程或文件系统的内容（文件和目录）的函数，以及一些其它功能。

1、检查文件系统的内容

使用listdir()返回文件系统中一个目录的内容列表。

# os_listdir.py

import os
import sys

print(os.listdir(sys.argv[1]))

返回值是给定目录中所有命名成员的列表。文件，子目录和符号链接之间没有区别。

$ python3 os_listdir.py .

['index.rst', 'os_access.py', 'os_cwd_example.py',
'os_directories.py', 'os_environ_example.py',
'os_exec_example.py', 'os_fork_example.py',
'os_kill_example.py', 'os_listdir.py', 'os_listdir.py~',
'os_process_id_example.py', 'os_process_user_example.py',
'os_rename_replace.py', 'os_rename_replace.py~',
'os_scandir.py', 'os_scandir.py~', 'os_spawn_example.py',
'os_stat.py', 'os_stat_chmod.py', 'os_stat_chmod_example.txt',
'os_strerror.py', 'os_strerror.py~', 'os_symlinks.py',
'os_system_background.py', 'os_system_example.py',
'os_system_shell.py', 'os_wait_example.py',
'os_waitpid_example.py', 'os_walk.py']

walk()函数递归遍历一个目录，并为每个子目录生成一个元组，其中包括目录路径，该路径的所有直接子目录，以及一个该目录下所有文件名的列表。

# os_walk.py

import os
import sys

# If we are not given a path to list, use /tmp
if len(sys) == 1:
    root = '/tmp'
else:
    root = sys.argv[1]
    
for dir_name, sub_dirs, files in os.walk(root):
    print(dir_name)
    # Make the subdirectory names stand out with /
    sub_dirs = [n + '/' for n in sub_dirs]
    # Mix the directory contents together
    contents = sub_dirs + files
    contents.sort()
    # Show the contents
    for c in contents:
        print('  {}'.format(c))
    print()

这个例子显示一个递归的目录列表。

$ python3 os_walk.py ../zipimport

../zipimport
  __init__.py
  example_package/
  index.rst
  zipimport_example.zip
  zipimport_find_module.py
  zipimport_get_code.py
  zipimport_get_data.py
  zipimport_get_data_nozip.py
  zipimport_get_data_zip.py
  zipimport_get_source.py
  zipimport_is_package.py
  zipimport_load_module.py
  zipimport_make_example.py

../zipimport/example_package
  README.txt
  __init__.py

如果需要文件名之外的更多信息，scandir()比listdir()更高效，因为扫描目录时只需要执行一次系统调用就能收集更多信息。

# os_scandir.py

import os
import sys

for entry in os.scandir(sys.argv[1]):
    if entry.is_dir():
        typ = 'dir'
    elif entry.is_file():
        typ = 'file'
    elif entry.is_symlink():
        typ = 'link'
    else:
        typ = 'unknow'
    print('{name} {typ}'.format(
        name=entry.name,
        typ=typ,
    ))

scandir()返回为目录中的项目返回一个DirEntry实例的序列。该对象有一些访问文件元数据的属性和方法。

$ python3 os_scandir.py .

index.rst file
os_access.py file
os_cwd_example.py file
os_directories.py file
os_environ_example.py file
os_exec_example.py file
os_fork_example.py file
os_kill_example.py file
os_listdir.py file
os_listdir.py~ file
os_process_id_example.py file
os_process_user_example.py file
os_rename_replace.py file
os_rename_replace.py~ file
os_scandir.py file
os_scandir.py~ file
os_spawn_example.py file
os_stat.py file
os_stat_chmod.py file
os_stat_chmod_example.txt file
os_strerror.py file
os_strerror.py~ file
os_symlinks.py file
os_system_background.py file
os_system_example.py file
os_system_shell.py file
os_wait_example.py file
os_waitpid_example.py file
os_walk.py file

2、管理文件系统的权限

使用stat()和lstat()（用于检查可能是符号链接的状态）可以访问一个文件的详细信息。

# os_stat.py

import os
import sys
import time

if len(sys.argv) == 1:
    filename = __file__
else:
    filename = sys.argv[1]
    
stat_info = os.stat(filename)

print('os.stat({}):'.format(filename))
print('  Size:', stat_info.st_size)
print('  Permissions:', oct(stat_info.st_mode))
print('  Owner:', stat_info.st_uid)
print('  Device:', stat_info.st_dev)
print('  Created      :', time.ctime(stat_info.st_ctime))
print('  Last modified:', time.ctime(stat_info.st_mtime))
print('  Last accessed:', time.ctime(stat_info.st_atime))

输出结果取决于示例代码是如何运行的。尝试在命令行中传递不同的文件名到os_stat.py中。

$ python3 os_stat.py

os.stat(os_stat.py):
  Size: 593
  Permissions: 0o100644
  Owner: 527
  Device: 16777218
  Created      : Sat Dec 17 12:09:51 2016
  Last modified: Sat Dec 17 12:09:51 2016
  Last accessed: Sat Dec 31 12:33:19 2016

$ python3 os_stat.py index.rst

os.stat(index.rst):
  Size: 26878
  Permissions: 0o100644
  Owner: 527
  Device: 16777218
  Created      : Sat Dec 31 12:33:10 2016
  Last modified: Sat Dec 31 12:33:10 2016
  Last accessed: Sat Dec 31 12:33:19 2016

在类Unix系统上，可以传递一个整数作为模式给chmod()，来修改文件权限。模式值可以使用在stat模块中定义的常量构建。下面这个例子切换用户的执行权限位：

# os_stat_chmod.py

import os
import stat

filename = 'os_stat_chmod_example.txt'
if os.path.exists(filename):
    os.unlink(filename)
with open(filename, 'wt') as f:
    f.write('content')
    
# Determine what permissions are already set using stat
existing_permissions = stat.S_IMODE(os.stat(filename).st_mode)

if not os.access(filename, os.X_OK):
    print('Adding excute permission')
    new_permissions = existing_permissions | stat.S_IXUSR
else:
    print('Removing execute permission')
    new_permissions = existing_permissions ^ stat.S_IXUSR
    
os.chmod(filename, new_permissions)

这个脚本假设它具有在运行时修改文件模式所需的权限。

$ python3 os_stat_chmod.py

Adding execute permission

access()函数用于测试进程对文件的访问权限。

# os_access.py

print('Testing:', __file__)
print('Exists:', os.access(__file__, os.F_OK))
print('Readable:', os.access(__file__, os.R_OK))
print('Writable:', os.access(__file__, os.W_OK))
print('Executable:', os.access(__file__, os.X_OK))

结果取决于如何运行实例代码，但输出类似这样：

$ python3 os_access.py

Testing: os_access.py
Exists: True
Readable: True
Writable: True
Executable: False

access()的库文档包括两个特殊警告。第一个，在一个文件上调用open()之前，调用access()测试文件是否可以被打开没有意义。在这两次调用之间有很短的，但确实存在的时间间隔，期间文件的权限有可能被改变。另一个警告主要适用于扩展自POSIX权限语义的联网文件系统。某些文件系统类型可能会响应进程有权限访问文件的POSIX调用，然后由于某些原因没有通过POSIX调用测试，尝试使用open()时会出错。总而言之，最好使用需要的模式调用open()，并捕获出错时抛出的IOError。

3、创建和删除目录

有几个函数用于操作文件系统中的目录，包括创建，列出内容和删除它们。

# os_directories.py

dir_name = 'os_directories_example'

print('Creating', dir_name)
os.makedirs(dir_name)

file_name = os.path.join(dir_name, 'example.txt')
print('Creating', file_name)
with open(file_name, 'wt') as f:
    f.write('example file')

print('Cleaning up')
os.unlink(file_name)
os.rmdir(dir_name)

有两个函数集用于创建和删除目录。使用mkdir()创建一个新目录时，所有父目录必须已经存在。使用rmdir()删除一个目录时，只有叶子目录（路径的最后一部分）会真正的被删除。相反，makedirs()和removedirs()会操作路径中的所有节点。makedirs()会创建路径中所有不存在的部分，removedirs()会删除所有父目录，知道它们为空。

$ python3 os_directories.py

Creating os_directories_example
Creating os_directories_example/example.txt
Cleaning up

4、使用符号链接

对于支持符号链接的平台和文件系统，有些函数用于符号链接。

# os_symlinks.py

import os

link_name = '/tmp/' + os.path.basename(__file__)

print('Creating link {} -> {}'.format(link_name, __file__))
os.symlink(__file__, link_name)

stat_info = os.lstat(link_name)
print('Permissions:', oct(stat_info.st_mode))

print('Points to:', os.readlink(link_name))

# Cleanup
os.unlink(link_name)

使用symlink()创建一个符号链接，readlink()读取链接，确定它指向的原始文件。lstat()函数类似stat()，但是它在符号链接上运行。

$ python3 os_symlinks.py

Creating link /tmp/os_symlinks.py -> os_symlinks.py
Permissions: 0o120755
Points to: os_symlinks.py

5、安全地替换已存在的文件

替换或重命名已存在文件不是幂等的，并且可能把应用程序暴露于竞争条件。对于这些操作，rename()和replace()函数可以在兼容POSIX系统上使用原子操作来实现安全的算法。

# os_rename_replace.py

import glob
import os

with open('rename_start.txt', 'w') as f:
    f.write('starting as rename_start.txt')
    
print('Starting:', glob.glob('rename*.txt'))

os.rename('rename_start.txt', 'rename_finish.txt')

print('After rename:', glob.glob('rename*.txt'))

with open('rename_finish.txt', 'r') as f:
    print('Contents:', repr(f.read()))
    
with open('rename_new_contents.txt', 'w') as f:
    f.write(ending with contents of rename_new_contents.txt')
    
os.replace('rename_new_contents.txt', 'rename_finish.txt')

with open('rename_new_contents.txt', 'r') as f:
    print('After replace:', repr(f.read()))
    
for name in glob.glob('rename*.txt'):
    os.unlink(name)

大多数时候，rename()和replace()函数可以跨文件系统工作。如果将文件移动到新文件系统，或者目标已经存在，则重命名文件可能会失败。

$ python3 os_rename_replace.py

Starting: ['rename_start.txt']
After rename: ['rename_finish.txt']
Contents: 'starting as rename_start.txt'
After replace: 'ending with contents of rename_new_contents.txt'

6、检测和修改进程所有者

os提供的下一组函数用于确定和修改进程所有者的ID。这最常被守护程序或特殊系统程序的作者用于修改权限级别，而不是以root身份运行。本节不会解释Unix安全性，进程所有者等的所有错综复杂的细节。有关详细信息请参考本节末尾的参考列表。

下面这个示例显示了一个进程的real和effective用户和组的信息，然后修改effective值。这类似于系统引导期间，守护程序以root身份启动时需要完成一些工作，用于降低权限级别，并以另一个用户运行。

注意：运行示例之前，修改TEST_GID和TEST_UID值为系统中定义的real用户。

# os_process_user_example.py

import os

TEST_GID = 502
TEST_UID = 502

def show_user_info():
    print('User (actual/effective)  :  {} / {}'.format(
        os.getuid(), os.geteuid()))
    print('Group (actual/effective)  :  {} / {}'.format(
        os.getgid(), os.getegid()))
    print('Actual Groups  :', os.getgroups())
    
print('BEFORE CHANGE:')
show_user_info()
print()

try:
    os.setgid(TEST_ID)
except OSError:
    print('ERROR: Could not change effective group. '
          'Rerun as root.')
else:
    print('CHANGE GROUP:')
    show_user_info()
    print()

try:
    os.seteuid(TEST_ID)
except OSError:
    print('ERROR: Could not change effective user. '
          'Rerun as root.')
else:
    print('CHANGE USER:')
    show_user_info()
    print()

当在OS X上运行的用户ID为502，组为502时，产生以下输出：

$ python3 os_process_user_example.py

BEFORE CHANGE:
User (actual/effective)  : 527 / 527
Group (actual/effective) : 501 / 501
Actual Groups   : [501, 701, 402, 702, 500, 12, 61, 80, 98, 398,
399, 33, 100, 204, 395]

ERROR: Could not change effective group. Rerun as root.
ERROR: Could not change effective user. Rerun as root.

值不会修改，因为它没有作为root运行，一个进程不能修改它的effective所有者的值。任何设置effective user id或group id为当前用户之外的其它值都会导致OSError。使用sudo运行同一个脚本，用root权限开始一个不同的场景。

$ sudo python3 os_process_user_example.py

BEFORE CHANGE:

User (actual/effective)  : 0 / 0
Group (actual/effective) : 0 / 0
Actual Groups : [0, 1, 2, 3, 4, 5, 8, 9, 12, 20, 29, 61, 80,
702, 33, 98, 100, 204, 395, 398, 399, 701]

CHANGE GROUP:
User (actual/effective)  : 0 / 0
Group (actual/effective) : 0 / 502
Actual Groups   : [0, 1, 2, 3, 4, 5, 8, 9, 12, 20, 29, 61, 80,
702, 33, 98, 100, 204, 395, 398, 399, 701]

CHANGE USER:
User (actual/effective)  : 0 / 502
Group (actual/effective) : 0 / 502
Actual Groups   : [0, 1, 2, 3, 4, 5, 8, 9, 12, 20, 29, 61, 80,
702, 33, 98, 100, 204, 395, 398, 399, 701]

这种情况下，因为用root启动，所以脚本会修改进程的effective user和group。一旦修改了effective UID，进程会被限制在该用户的权限下。因为非root用户不能修改它们的effective group，所以程序需要在修改用户之前修改组。

7、管理进程环境

操作系统通过os模块暴露给程序的另一个特征是环境。在环境中设置的变量作为字符串可见，可以通过os.environ或getenv()读取。环境变量通常用于配置搜索路径，文件位置和调试标识等值。这个示例显示了如何检索一个环境变量，以及传递一个值给子进程。

# os_environ_example.py

import os

print('Initial value:', os.environ.get('TESTVAR', None))
print('Child process:')
os.system('echo $TESTVAR')

os.environ['TESTVAR'] = 'THIS VALUE WAS CHANGED'

print()
print('Changed value:', os.environ['TESTVAR'])
print('Child process:')
os.system('echo $TESTVAR')

del os.environ['TESTVAR']

print()
print('Remove value:', os.environ.get('TESTVAR', None))
print('Child process:')
os.system('echo $TESTVAR')

os.environ对象遵循标准的Python映射API，用于检索和设置值。对os.environ的修改会为子进程导出。

$ python3 -u os_environ_example.py

Initial value: None
Child process:


Changed value: THIS VALUE WAS CHANGED
Child process:
THIS VALUE WAS CHANGED

Removed value: None
Child process:

8、管理进程工作目录

带层级文件系统的操作系统有当前工作目录的概念——当用相对路径访问文件时，进程用作起始位置的目录。可以使用getcwd()查询当前工作目录，使用chdir()修改。

# os_cwd_example.py

import os

print('Starting:', os.getcwd())

print('Moving up one:', os.pardir)
os.chdir(os.pardir)

print('After move:', os.getcwd())

os.curdir和os.pardir用于指向当前目录和父目录。

$ python3 os_cwd_example.py

Starting: .../pymotw-3/source/os
Moving up one: ..
After move: .../pymotw-3/source

9、运行外部命令

警告：
用于处理进程的很多函数的移植性是有限制的。要以平台独立的方式，以更一致的方法使用进程，请参考subprocess模块。

运行独立命令的最基本的，并且不与它交互的方式是使用system()。它接收单个字符串参数，它是被子进程在shell中执行的命令行。

# os_system_example.py

import os

# Simple command
os.system('pwd')

system()的返回值是shell执行程序的退出值，它被打包成一个16 bit的数字，其中高字节是退出状态，低字节是导致进程死亡的信号数或者0。

$ python3 -u os_system_example.py

.../pymotw-3/source/os

因为命令直接传递给shell处理，所以可以包括shell语法，比如通配符或者环境变量。

# os_system_shell.py

import os

# Command with shell expansion
os.system('echo $TMPDIR')

当shell执行命令行时，字符串中的环境变量TMPDIR会被展开。

$ python3 -u os_system_shell.py

/var/folders/5q/8gk0wq888xlggz008k8dr7180000hg/T/

除非命令明确地在后台执行，否则调用system()会阻塞，直到完成执行。默认情况下，子进程的标准输入，输出和错误与调用者拥有的适当流关联，但是可以使用shell语法重定向。

# os_system_background.py

import os
import time

print('Calling...')
os.system('date; (sleep 3; date) &')

print('Sleeping...')
time.sleep(5)

尽管这正好掉进了shell的诡计中，但是有更好的方式完成同样的任务。

$ python3 -u os_system_background.py

Calling...
Sat Dec 31 12:33:20 EST 2016
Sleeping...
Sat Dec 31 12:33:23 EST 2016

10、使用os.fork()创建进程

POSIX函数fork()和exec()（在Mac OS X，Linux和其它Unix版本下可用）通过os模块暴露。已经有很多书籍介绍了可靠的使用这些函数，所以在图书馆或书店查阅更多细节，这里只是一个简介。

使用fork()创建一个新进程，作为当前进程的克隆：

# os_fork_example.py

import os

pid = os.fork()

if pid:
    print('Child process id:', pid)
else:
    print('I am the child')

每次运行示例时，输入取决于系统的状态，但它看起来是这样的：

$ python3 -u os_fork_example.py

Child process id: 29190
I am the child

fork之后会有两个进程执行同样的代码。通过检查fork()的返回值，告诉程序在哪个进程中。如果值为0，则当前是子进程。如果不为0，则程序在父进程中执行，返回值是子进程的进程ID。

# os_kill_example.py

import os
import signal
import time


def signal_usr1(signum, frame):
    "Callback invoked when a signal is received"
    pid = os.getpid()
    print('Received USR1 in process {}'.format(pid))


print('Forking...')
child_pid = os.fork()
if child_pid:
    print('PARENT: Pausing before sending signal...')
    time.sleep(1)
    print('PARENT: Signaling {}'.format(child_pid))
    os.kill(child_pid, signal.SIGUSR1)
else:
    print('CHILD: Setting up signal handler')
    signal.signal(signal.SIGUSR1, signal_usr1)
    print('CHILD: Pausing to wait for signal')
    time.sleep(5)

父进程可以使用kill()和signal模块发送信号到子进程。首先定义一个接收到信号时触发的信号处理器。然后fork()，并在用kill()发送USR1信号之前，在父进程中暂停一小段时间。这个示例用暂停让子进程有时间设置信号处理器。实际程序中，不需要（或者不希望）调用sleep()。在子进程中设置信号处理器，并休眠一段时间，让父进程发送信号。

$ python3 -u os_kill_example.py

Forking...
PARENT: Pausing before sending signal...
CHILD: Setting up signal handler
CHILD: Pausing to wait for signal
PARENT: Signaling 29193
Received USR1 in process 29193

在子进程中处理独立行为的一种简单方法是检查fork()的返回值，然后分支。更复杂的行为可能需要比简单分支更多的独立代码。其它情况下，可能需要包装已经存在的程序。对于这两种情况，exec*()函数系列可以用于运行其它程序。

# os_exec_example.py

import os

child_pid = os.fork()
if child_pid:
    os.waitpid(child_pid, 0)
else:
    os.execlp('pwd', 'pwd', '-P')

当程序通过exec()运行时，该程序的代码会替换已存在进程中的代码。

$ python3 os_exec_example.py

.../pymotw-3/source/os

根据参数的可用形式，父进程的路径和环境是否应该拷贝到子进程中等，exec()有很多变体。对于所有变种，第一个参数是路径或文件名，剩余的参数控制程序如何执行。它们作为命令行参数传递，或者覆盖进程环境（参考os.environ和os.getenv）。完整细节请参考库文档。

11、等待子进程

很多计算密集型程序使用多进程来解决Python和全局解释器锁的线程限制。当启动多个进程执行独立的任务时，主机需要等待其中一个或多个进程完成，然后再启动新进程，以避免服务器超负荷。使用wait()和相关函数有几种不同的方式。

不管哪个子进程先退出不重要时，使用wait()。一旦任何子进程退出就会返回。

# os_wait_example.py

import os
import sys
import time

for i in range(2):
    print('PARENT {}: FORKING {}'.format(os.getpid(), i))
    worker_pid = os.fork()
    if not worker_pid:
        print('WORKER {}: Starting'.format(i))
        time.sleep(2 + i)
        print('WORKER {}: Finishing'.format(i))
        sys.exit(i)

for i in range(2):
    print('PARENT: Waiting for {}'.format(i))
    done = os.wait()
    print('PARENT: Child done:', done)

wait()的返回值是一个元组，其中包括进程ID和组合为16 bit值的退出状态。低字节是杀死进程的信号数字，高字节是进程退出时返回的状态码。

$ python3 -u os_wait_example.py

PARENT 29202: Forking 0
PARENT 29202: Forking 1
PARENT: Waiting for 0
WORKER 0: Starting
WORKER 1: Starting
WORKER 0: Finishing
PARENT: Child done: (29203, 0)
PARENT: Waiting for 1
WORKER 1: Finishing
PARENT: Child done: (29204, 256)

使用waitpid()等待指定进程。

# os_waitpid_example.py

import os
import sys
import time

workers = []
for i in range(2):
    print('PARENT {}: Forking {}'.format(os.getpid(), i))
    worker_pid = os.fork()
    if not worker_pid:
        print('WORKER {}: Starting'.format(i))
        time.sleep(2 + i)
        print('WORKER {}: Finishing'.format(i))
        sys.exit(i)
    workers.append(worker_pid)

for pid in workers:
    print('PARENT: Waiting for {}'.format(pid))
    done = os.waitpid(pid, 0)
    print('PARENT: Child done:', done)

传递目标进程的进程ID，waitpid()会阻塞直到该进程退出。

$ python3 -u os_waitpid_example.py

PARENT 29211: Forking 0
PARENT 29211: Forking 1
PARENT: Waiting for 29212
WORKER 0: Starting
WORKER 1: Starting
WORKER 0: Finishing
PARENT: Child done: (29212, 0)
PARENT: Waiting for 29213
WORKER 1: Finishing
PARENT: Child done: (29213, 256)

wait3()和wait4()以类似的方式工作，但是会返回子进程更详细的信息，包括pid，退出状态和资源使用情况。

12、生成新进程

为了方便，spawn()函数族在一条语句中处理fork()和exec()：

# os_spawn_example.py

import os

os.spawnlp(os.P_WAIT, 'pwd', 'pwd', '-P')

第一个参数是模式，指定返回之前是否等待进程完成。这个示例中等待进程完成。使用P_NOWAIT让其它进程启动，然后在当前进程中继续。

$ python3 os_spawn_example.py

.../pymotw-3/source/os

13、操作系统错误码

由操作系统定义，并在errno模块中管理的错误码可以使用strerror()翻译为消息字符串。

# os_strerror.py

import errno
import os

for num in [errno.ENOENT, errno.EINTR, errno.EBUSY]:
    name = errno.errorcode[num]
    print('[{num:>2}] {name:<6}: {msg}'.format(
        name=name, num=num, msg=os.strerror(num)))

这个示例显示了与某些频繁出现的错误代码相关联的消息。

$ python3 os_strerror.py

[ 2] ENOENT: No such file or directory
[ 4] EINTR : Interrupted system call
[16] EBUSY : Resource busy

参考

• os的标准库文档
• Python2到3的移植笔记
• signal —— signal模块部分更详细地介绍了信号处理技术。
• subprocess —— subprocess模块代替os.popen()。
• multiprocessing —— multiprocessing模块可以更容易地使用额外进程。
• tempfile —— tempfile模块用于使用临时文件。
• 使用目录树 —— shutil模块还包括使用目录树的函数。
• Speaking UNIX, Part 8. —— 学习UNIX的多任务。
• Standard streams —— 近一步讨论stdin，stdout和stderr。
• Delve into Unix Process Creation —— 解释Unix进程的生命周期。
• Advanced Programming in the UNIX(R) Environment By W. Richard Stevens and Stephen A. Rago. Published by Addison-Wesley Professional, 2005. ISBN-10: 0201433079 —— 这本书覆盖了多进程，比如处理信号，关闭重复的文件描述符等。