从新手到大师：Python 系统与文件操作全攻略

"Python大师之路：系统与文件操作的终极指南"

前言

在当今数字化的世界中，系统和文件操作是每个Python开发者必备的关键技能。本指南将带领您深入探索Python中与系统和文件操作相关的核心库，以及如何应用这些库解决实际问题。无论您是初学者还是经验丰富的开发者，都将在这篇文章中找到有关系统和文件操作的宝贵知识。

文章目录

**"Python大师之路：系统与文件操作的终极指南"**
- 前言
- - [1. 简介](#1. 简介)
  - - [1.1 操作系统和文件系统的关系](#1.1 操作系统和文件系统的关系)
    - [1.2 Python在系统和文件操作中的重要性](#1.2 Python在系统和文件操作中的重要性)
  - [2. 操作系统相关库](#2. 操作系统相关库)
  - - [2.1 `os`库](#2.1 os库)
    - - [2.1.1 常见方法及其功能](#2.1.1 常见方法及其功能)
      - [2.1.2 目录和文件的创建与删除](#2.1.2 目录和文件的创建与删除)
      - [2.1.3 环境变量的管理](#2.1.3 环境变量的管理)
    - [2.2 `sys`库](#2.2 sys库)
    - - [2.2.1 获取命令行参数](#2.2.1 获取命令行参数)
      - [2.2.2 Python解释器的相关信息](#2.2.2 Python解释器的相关信息)
      - [2.2.3 系统退出与异常处理](#2.2.3 系统退出与异常处理)
  - [3. 文件和目录操作](#3. 文件和目录操作)
  - - [3.1 `shutil`库](#3.1 shutil库)
    - - [3.1.1 复制文件与目录](#3.1.1 复制文件与目录)
      - [3.1.2 移动文件与目录](#3.1.2 移动文件与目录)
      - [3.1.3 文件和目录的压缩与解压缩](#3.1.3 文件和目录的压缩与解压缩)
  - [4. 进阶文件处理](#4. 进阶文件处理)
  - - [4.1 `glob`库](#4.1 glob库)
    - - [4.1.1 文件通配符的使用](#4.1.1 文件通配符的使用)
      - [4.1.2 搜索文件和目录](#4.1.2 搜索文件和目录)
      - [4.1.3 文件路径的处理](#4.1.3 文件路径的处理)
    - [4.2 `pathlib`库](#4.2 pathlib库)
    - - [4.2.1 面向对象的路径操作](#4.2.1 面向对象的路径操作)
      - [4.2.2 跨平台路径操作](#4.2.2 跨平台路径操作)
      - [4.2.3 文件属性和权限的获取](#4.2.3 文件属性和权限的获取)
  - [5. 文件编码和处理](#5. 文件编码和处理)
  - - [5.1 `codecs`库](#5.1 codecs库)
    - - [5.1.1 文件编码的处理](#5.1.1 文件编码的处理)
      - [5.1.2 文本文件的读写](#5.1.2 文本文件的读写)
    - [5.2 `io`库](#5.2 io库)
    - - [5.2.1 缓冲流和原始字节流的操作](#5.2.1 缓冲流和原始字节流的操作)
      - [5.2.2 内存中文件的处理](#5.2.2 内存中文件的处理)
  - [6. 监控和处理文件变化](#6. 监控和处理文件变化)
  - - [6.1 `watchdog`库](#6.1 watchdog库)
    - - [6.1.1 文件系统事件的监控](#6.1.1 文件系统事件的监控)
      - [6.1.2 文件变化的回调处理](#6.1.2 文件变化的回调处理)
    - [6.2 `pyinotify`库](#6.2 pyinotify库)
    - - [6.2.1 Linux系统下的文件系统事件监控](#6.2.1 Linux系统下的文件系统事件监控)
      - [6.2.2 监控多个目录和递归监控](#6.2.2 监控多个目录和递归监控)
  - [7. 性能优化和并发处理](#7. 性能优化和并发处理)
  - - [7.1 `concurrent.futures`库](#7.1 concurrent.futures库)
    - - [7.1.1 并行文件处理](#7.1.1 并行文件处理)
      - [7.1.2 异步文件操作](#7.1.2 异步文件操作)
      - [7.1.3 线程池和进程池的使用](#7.1.3 线程池和进程池的使用)
    - [7.2 `multiprocessing`库](#7.2 multiprocessing库)
    - - [7.2.1 多进程文件处理](#7.2.1 多进程文件处理)
      - [7.2.2 进程间通信](#7.2.2 进程间通信)
      - [7.2.3 共享资源和锁的管理](#7.2.3 共享资源和锁的管理)
  - [8. 安全性和权限管理](#8. 安全性和权限管理)
  - - [8.1 `getpass`库](#8.1 getpass库)
    - - [8.1.1 安全输入密码](#8.1.1 安全输入密码)
      - [8.1.2 密码管理和存储](#8.1.2 密码管理和存储)
    - [8.2 `os.access`和`os.chmod`方法](#8.2 os.access和os.chmod方法)
    - - [8.2.1 文件权限的获取和修改](#8.2.1 文件权限的获取和修改)
      - [8.2.2 安全的文件操作实践](#8.2.2 安全的文件操作实践)
  - [9. 实际应用场景](#9. 实际应用场景)
  - - [9.1 文件备份和同步](#9.1 文件备份和同步)
    - - [9.1.1 定时备份](#9.1.1 定时备份)
      - [9.1.2 文件同步工具](#9.1.2 文件同步工具)
    - [9.2 日志文件处理](#9.2 日志文件处理)
    - - [9.2.1 实时日志监控](#9.2.1 实时日志监控)
      - [9.2.2 日志文件的切割和归档](#9.2.2 日志文件的切割和归档)
    - [9.3 数据库备份与恢复](#9.3 数据库备份与恢复)
    - - [9.3.1 数据库导出与导入](#9.3.1 数据库导出与导入)
      - [9.3.2 自动化备份方案](#9.3.2 自动化备份方案)
  - [10. 结语](#10. 结语)
- 总结

1. 简介

操作系统和文件系统之间存在紧密的关系，而Python作为一种高级编程语言，提供了丰富的库来进行系统和文件操作。本文将介绍在Python中进行系统和文件操作的关键库，以及它们的具体用法。

1.1 操作系统和文件系统的关系

操作系统是计算机硬件与应用程序之间的桥梁，而文件系统则是操作系统用于组织和存储文件的一种机制。Python通过不同的库提供了对操作系统和文件系统的直接访问，使开发者能够轻松地执行各种系统和文件操作。

1.2 Python在系统和文件操作中的重要性

Python提供了丰富的标准库和第三方库，使得系统和文件操作变得简单而强大。在本文中，我们将深入研究os、sys和shutil等库，通过实例演示它们的用法，帮助读者更好地掌握Python中的系统和文件操作。

2. 操作系统相关库

Python中有几个与操作系统直接交互的关键库，其中包括os和sys。

2.1 `os`库

os库提供了与操作系统交互的多种方法，涵盖了文件和目录的创建、删除、路径操作以及环境变量的管理等功能。

2.1.1 常见方法及其功能

python 复制代码

import os

# 获取当前工作目录
current_directory = os.getcwd()
print("当前工作目录:", current_directory)

# 列出指定目录下的文件和子目录
files_and_directories = os.listdir('.')
print("文件和子目录:", files_and_directories)

2.1.2 目录和文件的创建与删除

python 复制代码

# 创建目录
os.mkdir('new_directory')

# 删除目录
os.rmdir('new_directory')

# 创建文件（空文件）
with open('new_file.txt', 'w') as file:
    pass

# 删除文件
os.remove('new_file.txt')

2.1.3 环境变量的管理

python 复制代码

# 获取环境变量的值
python_path = os.environ.get('PYTHONPATH')
print("PYTHONPATH环境变量值:", python_path)

2.2 `sys`库

sys库提供了与Python解释器和系统直接交互的方法，例如获取命令行参数、处理异常等。

2.2.1 获取命令行参数

python 复制代码

import sys

# 获取命令行参数
arguments = sys.argv
print("命令行参数:", arguments)

2.2.2 Python解释器的相关信息

python 复制代码

# 获取Python解释器的版本信息
python_version = sys.version
print("Python版本信息:", python_version)

2.2.3 系统退出与异常处理

python 复制代码

try:
    # 产生一个异常
    x = 1 / 0
except ZeroDivisionError as e:
    # 捕获异常并输出错误信息
    sys.exit(f"发生错误: {e}")

3. 文件和目录操作

shutil库是Python中文件和目录操作的高级工具，提供了复制、移动、压缩和解压缩等功能。

3.1 `shutil`库

3.1.1 复制文件与目录

python 复制代码

import shutil

# 复制文件
shutil.copy('source_file.txt', 'destination_directory')

# 复制整个目录树
shutil.copytree('source_directory', 'destination_directory')

3.1.2 移动文件与目录

python 复制代码

# 移动文件
shutil.move('old_location/file.txt', 'new_location/')

# 移动目录
shutil.move('old_directory', 'new_location/')

3.1.3 文件和目录的压缩与解压缩

python 复制代码

# 压缩文件
shutil.make_archive('archive', 'zip', 'source_directory')

# 解压缩文件
shutil.unpack_archive('archive.zip', 'destination_directory')

4. 进阶文件处理

在文件处理的过程中，还有一些其他常用的库可以提高效率和灵活性。

4.1 `glob`库

glob库提供了通过通配符匹配文件路径的方法，方便进行文件搜索和处理。

4.1.1 文件通配符的使用

python 复制代码

import glob

# 匹配当前目录下所有.txt文件
txt_files = glob.glob('*.txt')
print("所有txt文件:", txt_files)

4.1.2 搜索文件和目录

python 复制代码

# 搜索所有子目录中的.py文件
python_files = glob.glob('**/*.py', recursive=True)
print("所有Python文件:", python_files)

4.1.3 文件路径的处理

python 复制代码

# 获取文件路径的基本信息
file_path = 'path/to/file.txt'
file_name = os.path.basename(file_path)
file_directory = os.path.dirname(file_path)
print("文件名:", file_name)
print("所在目录:", file_directory)

4.2 `pathlib`库

pathlib库提供了一种面向对象的路径操作方式，使得路径操作更加直观和易读。

4.2.1 面向对象的路径操作

python 复制代码

from pathlib import Path

# 创建Path对象
file_path = Path('path/to/file.txt')

# 获取文件名
file_name = file_path.name
print("文件名:", file_name)

# 获取文件所在目录
file_directory = file_path.parent
print("所在目录:", file_directory)

4.2.2 跨平台路径操作

python 复制代码

# 使用Path对象进行路径拼接
new_path = file_path / 'subdirectory' / 'new_file.txt'
print("新路径:", new_path)

4.2.3 文件属性和权限的获取

python 复制代码

# 获取文件大小
file_size = file_path.stat().st_size
print("文件大小:", file_size)

# 获取文件权限
file_permission = file_path.stat().st_mode
print("文件权限:", file_permission)

5. 文件编码和处理

在处理文件时，经常需要考虑文件的编码以及如何进行文本文件的读写。

5.1 `codecs`库

codecs库提供了文件编码的处理方法，特别适用于处理不同编码的文本文件。

5.1.1 文件编码的处理

python 复制代码

import codecs

# 打开UTF-8编码的文件
with codecs.open('utf8_file.txt', 'r', encoding='utf-8') as file:
    content = file.read()
    print("文件内容:", content)

5.1.2 文本文件的读写

python 复制代码

# 写入内容到UTF-8编码的文件
with codecs.open('utf8_file.txt', 'w', encoding='utf-8') as file:
    file.write("Hello, 你好！")

5.2 `io`库

io库提供了对缓冲流和原始字节流的处理，同时也支持在内存中进行文件操作。

5.2.1 缓冲流和原始字节流的操作

python 复制代码

import io

# 创建一个字节流缓冲区
buffer = io.BytesIO(b'Hello, World!')

# 读取缓冲区内容
data = buffer.read()
print("读取内容:", data)

5.2.2 内存中文件的处理

python 复制代码

# 在内存中创建文件并写入内容
with io.StringIO() as file:
    file.write("This is a file in memory.")
    content = file.getvalue()
    print("内存中文件内容:", content)

6. 监控和处理文件变化

在某些场景下，需要监控文件系统中文件的变化并及时作出响应。

6.1 `watchdog`库

watchdog库提供了对文件系统事件的监控，可以实时捕获文件的创建、修改、删除等事件。

6.1.1 文件系统事件的监控

python 复制代码

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class MyHandler(FileSystemEventHandler):
    def on_modified(self, event):
        if event.is_directory:
            return
        print(f'文件被修改: {event.src_path}')

# 创建观察者
observer = Observer()
observer.schedule(MyHandler(), path='path/to/directory', recursive=True)

# 启动观察者
observer.start()

# 在此处进行其他操作

# 关闭观察者
observer.stop()
observer.join()

6.1.2 文件变化的回调处理

python 复制代码

class MyHandler(FileSystemEventHandler):
    def on_created(self, event):
        if event.is_directory:
            return
        print(f'文件被创建: {event.src_path}')

# 创建观察者并设置回调处理
observer = Observer()
observer.schedule(MyHandler(), path='path/to/directory', recursive=True)

# 启动观察者
observer.start()

# 在此处进行其他操作

# 关闭观察者
observer.stop()
observer.join()

6.2 `pyinotify`库

在Linux系统下，pyinotify库提供了对文件系统事件的监控。

6.2.1 Linux系统下的文件系统事件监控

python 复制代码

import pyinotify

wm = pyinotify.WatchManager()
mask = pyinotify.IN_MODIFY | pyinotify.IN_CREATE | pyinotify.IN_DELETE

class EventHandler(pyinotify.ProcessEvent):
    def process_IN_CREATE(self, event):
        print(f"文件被创建: {event.pathname}")

    def process_IN_MODIFY(self, event):
        print(f"文件被修改: {event.pathname}")

    def process_IN_DELETE(self, event):
        print(f"文件被删除: {event.pathname}")

notifier = pyinotify.Notifier(wm, EventHandler())
wdd = wm.add_watch('path/to/directory', mask, rec=True)

# 在此处进行其他操作

notifier.stop()

6.2.2 监控多个目录和递归监控

python 复制代码

wdd = wm.add_watch(['path/to/directory1', 'path/to/directory2'], mask, rec=True)

7. 性能优化和并发处理

在处理大量文件或需要提高处理效率时，可以利用并发处理和多进程来优化性能。

7.1 `concurrent.futures`库

concurrent.futures库提供了高层次的界面，支持并行处理和异步操作。

7.1.1 并行文件处理

python 复制代码

from concurrent.futures import ThreadPoolExecutor

def process_file(file_path):
    # 处理文件的具体逻辑
    pass

# 获取文件列表
file_list = glob.glob('path/to/files/*.txt')

# 使用线程池并行处理文件
with ThreadPoolExecutor() as executor:
    executor.map(process_file, file_list)

7.1.2 异步文件操作

python 复制代码

import asyncio

async def process_file(file_path):
    # 异步处理文件的具体逻辑
    pass

# 获取文件列表
file_list = glob.glob('path/to/files/*.txt')

# 使用异步事件循环并发处理文件
async def main():
    tasks = [process_file(file_path) for file_path in file_list]
    await asyncio.gather(*tasks)

asyncio.run(main())

7.1.3 线程池和进程池的使用

python 复制代码

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

# 使用线程池处理任务
with ThreadPoolExecutor() as executor:
    executor.submit(some_function, arg1, arg2)

# 使用进程池处理任务
with ProcessPoolExecutor() as executor:
    executor.submit(some_function, arg1, arg2)

7.2 `multiprocessing`库

multiprocessing库提供了多进程处理的功能，适用于一些需要充分利用多核处理器的场景。

7.2.1 多进程文件处理

python 复制代码

import multiprocessing

def process_file(file_path):
    # 多进程处理文件的具体逻辑
    pass

# 获取文件列表
file_list = glob.glob('path/to/files/*.txt')

# 使用进程池并行处理文件
with multiprocessing.Pool() as pool:
    pool.map(process_file, file_list)

7.2.2 进程间通信

python 复制代码

from multiprocessing import Process, Queue

def worker(queue):
    # 在子进程中进行一些任务
    result = 42
    queue.put(result)

if __name__ == '__main__':
    # 创建队列
    result_queue = Queue()

    # 创建子进程并传递队列
    process = Process(target=worker, args=(result_queue,))
    process.start()

    # 在主进程中获取子进程的结果
    result = result_queue.get()

    # 等待子进程结束
    process.join()

    print("子进程的结果:", result)

7.2.3 共享资源和锁的管理

python 复制代码

from multiprocessing import Process, Value, Lock

def increment(counter, lock):
    for _ in range(100000):
        with lock:
            counter.value += 1

if __name__ == '__main__':
    # 创建共享变量和锁
    counter = Value('i', 0)
    lock = Lock()

    # 创建多个子进程并传递共享变量和锁
    processes = [Process(target=increment, args=(counter, lock)) for _ in range(4)]

    # 启动子进程
    for process in processes:
        process.start()

    # 等待所有子进程结束
    for process in processes:
        process.join()

    print("最终计数值:", counter.value)

8. 安全性和权限管理

在文件处理过程中，保护文件的安全性以及正确处理权限是至关重要的。

8.1 `getpass`库

getpass库提供了安全地输入密码的方法，避免在代码中明文显示密码。

8.1.1 安全输入密码

python 复制代码

import getpass

# 安全输入密码
password = getpass.getpass("请输入密码: ")

8.1.2 密码管理和存储

python 复制代码

import hashlib

# 加密密码
def encrypt_password(password):
    return hashlib.sha256(password.encode()).hexdigest()

# 存储加密后的密码
stored_password = encrypt_password(password)

# 验证密码
def verify_password(entered_password, stored_password):
    return encrypt_password(entered_password) == stored_password

8.2 `os.access`和`os.chmod`方法

os.access和os.chmod方法允许您获取和修改文件的权限。

8.2.1 文件权限的获取和修改

python 复制代码

# 获取文件权限
file_permission = os.access('path/to/file.txt', os.R_OK)
print("文件是否可读:", file_permission)

# 修改文件权限
os.chmod('path/to/file.txt', 0o755)

8.2.2 安全的文件操作实践

python 复制代码

# 检查文件是否存在并可写
if os.path.exists('path/to/file.txt') and os.access('path/to/file.txt', os.W_OK):
    # 执行写入操作
    with open('path/to/file.txt', 'w') as file:
        file.write("Hello, World!")
else:
    print("文件不存在或不可写")

9. 实际应用场景

在实际应用中，系统和文件操作常常用于处理文件备份、日志文件、数据库备份等任务。

9.1 文件备份和同步

9.1.1 定时备份

python 复制代码

import shutil
import time

# 源文件路径
source_path = 'path/to/source'

# 备份目录路径
backup_path = 'path/to/backup'

# 定时备份
while True:
    # 获取当前时间戳
    timestamp = time.strftime("%Y%m%d%H%M%S")

    # 备份文件夹
    backup_folder = f'backup_{timestamp}'
    destination_path = os.path.join(backup_path, backup_folder)
    shutil.copytree(source_path, destination_path)

    # 间隔一小时进行下一次备份
    time.sleep(3600)

9.1.2 文件同步工具

python 复制代码

import filecmp

# 源目录和目标目录
source_directory = 'path/to/source'
target_directory = 'path/to/target'

# 创建文件比较器
comparator = filecmp.dircmp(source_directory, target_directory)

# 获取差异文件列表
diff_files = comparator.diff_files
print("差异文件:", diff_files)

# 同步源目录到目标目录
shutil.copytree(source_directory, target_directory, dirs_exist_ok=True)

9.2 日志文件处理

9.2.1 实时日志监控

python 复制代码

import time

# 日志文件路径
log_file_path = 'path/to/log.txt'

# 持续监控日志文件
while True:
    with open(log_file_path, 'r') as file:
        new_entries = file.readlines()

        # 处理新增的日志条目
        for entry in new_entries:
            print(f"新日志条目: {entry}")

    # 等待一秒后继续监控
    time.sleep(1)

9.2.2 日志文件的切割和归档

python 复制代码

import logging
from logging.handlers import RotatingFileHandler

# 配置日志记录器
logger = logging.getLogger('my_logger')
logger.setLevel(logging.INFO)

# 创建RotatingFileHandler，设置文件切割
handler = RotatingFileHandler('path/to/log.txt', maxBytes=100000, backupCount=3)
logger.addHandler(handler)

# 记录日志
logger.info("This is a log entry.")

9.3 数据库备份与恢复

9.3.1 数据库导出与导入

python 复制代码

import subprocess

# 数据库备份
subprocess.run(['mysqldump', '-u', 'username', '-p', 'password', 'database_name', '>', 'backup.sql'])

# 数据库恢复
subprocess.run(['mysql', '-u', 'username', '-p', 'password', 'database_name', '<', 'backup.sql'])

9.3.2 自动化备份方案

python 复制代码

import subprocess
import time

# 自动化数据库备份
while True:
    # 获取当前时间戳
    timestamp = time.strftime("%Y%m%d%H%M%S")

    # 执行数据库备份
    backup_file = f'database_backup_{timestamp}.sql'
    subprocess.run(['mysqldump', '-u', 'username', '-p', 'password', 'database_name', '>', backup_file])

    # 每天备份一次
    time.sleep(86400)

10. 结语

在本文中，我们深入探讨了Python中与系统和文件操作相关的关键库，包括os、sys、shutil等，并通过详细的实例演示了它们的用法。我们还介绍了一些进阶的文件处理库，如glob、pathlib、codecs、io等，以及在实际应用中的场景和最佳实践。通过学习这些知识，读者可以更好地利用Python进行系统和文件操作，提高代码的效率和可维护性。

最后，鼓励读者在实际项目中应用这些知识，根据具体需求进一步拓展和优化代码，不断提升自己在文件处理和系统操作方面的技能。

总结

通过本指南，您学会了如何巧妙地使用Python中的系统和文件操作库，提高了对文件处理的熟练程度。我们讨论了高级技术，如多线程、多进程、异步操作，以及如何确保文件安全性和权限管理。这一深入的学习旅程将使您能够更自信地处理各种文件和系统任务，从而更加高效地构建和维护Python应用程序。

从新手到大师：Python 系统与文件操作全攻略

"Python大师之路：系统与文件操作的终极指南"

前言

文章目录

1. 简介

1.1 操作系统和文件系统的关系

1.2 Python在系统和文件操作中的重要性

2. 操作系统相关库

2.1 os库

2.1.1 常见方法及其功能

2.1.2 目录和文件的创建与删除

2.1.3 环境变量的管理

2.2 sys库

2.2.1 获取命令行参数

2.2.2 Python解释器的相关信息

2.2.3 系统退出与异常处理

3. 文件和目录操作

3.1 shutil库

3.1.1 复制文件与目录

3.1.2 移动文件与目录

3.1.3 文件和目录的压缩与解压缩

4. 进阶文件处理

4.1 glob库

4.1.1 文件通配符的使用

4.1.2 搜索文件和目录

4.1.3 文件路径的处理

4.2 pathlib库

4.2.1 面向对象的路径操作

4.2.2 跨平台路径操作

4.2.3 文件属性和权限的获取

5. 文件编码和处理

5.1 codecs库

5.1.1 文件编码的处理

5.1.2 文本文件的读写

5.2 io库

5.2.1 缓冲流和原始字节流的操作

5.2.2 内存中文件的处理

6. 监控和处理文件变化

6.1 watchdog库

6.1.1 文件系统事件的监控

6.1.2 文件变化的回调处理

6.2 pyinotify库

6.2.1 Linux系统下的文件系统事件监控

6.2.2 监控多个目录和递归监控

7. 性能优化和并发处理

7.1 concurrent.futures库

7.1.1 并行文件处理

7.1.2 异步文件操作

7.1.3 线程池和进程池的使用

7.2 multiprocessing库

7.2.1 多进程文件处理

7.2.2 进程间通信

7.2.3 共享资源和锁的管理

8. 安全性和权限管理

8.1 getpass库

8.1.1 安全输入密码

8.1.2 密码管理和存储

8.2 os.access和os.chmod方法

8.2.1 文件权限的获取和修改

8.2.2 安全的文件操作实践

9. 实际应用场景

9.1 文件备份和同步

9.1.1 定时备份

9.1.2 文件同步工具

9.2 日志文件处理

9.2.1 实时日志监控

9.2.2 日志文件的切割和归档

9.3 数据库备份与恢复

9.3.1 数据库导出与导入

9.3.2 自动化备份方案

10. 结语

总结

2.1 `os`库

2.2 `sys`库

3.1 `shutil`库

4.1 `glob`库

4.2 `pathlib`库

5.1 `codecs`库

5.2 `io`库

6.1 `watchdog`库

6.2 `pyinotify`库

7.1 `concurrent.futures`库

7.2 `multiprocessing`库

8.1 `getpass`库

8.2 `os.access`和`os.chmod`方法