Python执行Linux命令：从入门到精通（新手必读指南）

# 1. Python执行Linux命令的基础

Python是一种功能强大的编程语言，它提供了丰富的库和模块，使开发者能够轻松执行Linux命令。本章将介绍Python执行Linux命令的基础知识，包括：

- **subprocess模块：** subprocess模块提供了用于创建和管理子进程的函数，允许Python程序执行Linux命令。
- **os模块：** os模块提供了一组用于与操作系统交互的函数，包括执行Linux命令的功能。
- **shlex模块：** shlex模块提供了用于解析和引用shell命令的函数，这对于安全地执行Linux命令非常有用。

# 2. Python执行Linux命令的实践技巧

### 2.1 Python的subprocess模块

Python的subprocess模块提供了用于创建和管理子进程的函数。它提供了比os模块更细粒度的控制，并允许我们以更高级的方式与子进程交互。

#### 2.1.1 subprocess.run()函数的用法

subprocess.run()函数用于执行一个命令并等待其完成。它返回一个CompletedProcess对象，其中包含有关子进程执行状态的信息。

import subprocess

# 执行命令并捕获输出
result = subprocess.run(['ls', '-l'], capture_output=True)

# 检查子进程的返回码
if result.returncode == 0:
    # 命令执行成功
    print(result.stdout.decode('utf-8'))
else:
    # 命令执行失败
    print(f'Error: {result.stderr.decode("utf-8")}')

#### 2.1.2 subprocess.Popen()函数的用法

subprocess.Popen()函数用于创建子进程，但不会等待其完成。它返回一个Popen对象，该对象允许我们与子进程进行交互。

import subprocess

# 创建子进程
process = subprocess.Popen(['ping', 'google.com'])

# 等待子进程完成
process.wait()

# 检查子进程的返回码
if process.returncode == 0:
    # 命令执行成功
    print('Ping successful')
else:
    # 命令执行失败
    print('Ping failed')

### 2.2 Python的os模块

os模块提供了与操作系统交互的函数，包括执行命令。

#### 2.2.1 os.system()函数的用法

os.system()函数执行给定的命令并等待其完成。它返回命令的退出状态码。

import os

# 执行命令
os.system('ls -l')

#### 2.2.2 os.popen()函数的用法

os.popen()函数打开一个管道，用于与子进程进行通信。它返回一个文件对象，我们可以使用该对象读取子进程的输出。

import os

# 打开管道
pipe = os.popen('ls -l')

# 读取子进程的输出
output = pipe.read()

# 关闭管道
pipe.close()

### 2.3 Python的shlex模块

shlex模块提供了用于解析shell命令的函数。

#### 2.3.1 shlex.split()函数的用法

shlex.split()函数将给定的字符串解析为一个shell命令列表。

import shlex

# 解析shell命令
command_list = shlex.split('ls -l /home/user')

#### 2.3.2 shlex.quote()函数的用法

shlex.quote()函数将给定的字符串转义为一个shell安全的字符串。

import shlex

# 转义shell命令
escaped_command = shlex.quote('ls -l /home/user')

# 3. Python执行Linux命令的实战应用

### 3.1 文件管理

#### 3.1.1 创建、删除和移动文件

Python提供了多种方法来管理Linux文件系统，包括创建、删除和移动文件。

# 创建文件
with open("new_file.txt", "w") as f:
    f.write("Hello world!")

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

# 移动文件
os.rename("old_file.txt", "new_file.txt")

#### 3.1.2 读写文件内容

Python还允许您轻松地读写文件内容。

# 读文件
with open("file.txt", "r") as f:
    data = f.read()

# 写文件
with open("file.txt", "w") as f:
    f.write("Hello world!")

### 3.2 进程管理

#### 3.2.1 启动和终止进程

Python可以通过subprocess模块启动和终止进程。

# 启动进程
process = subprocess.Popen(["ls", "-l"])

# 终止进程
process.terminate()

#### 3.2.2 获取进程信息

Python也可以获取有关进程的信息，例如其PID和状态。

# 获取进程ID
pid = process.pid

# 获取进程状态
status = process.poll()

### 3.3 系统管理

#### 3.3.1 获取系统信息

Python可以获取有关系统的信息，例如主机名、操作系统和内核版本。

# 获取主机名
hostname = os.uname().nodename

# 获取操作系统
os_name = os.uname().sysname

# 获取内核版本
kernel_version = os.uname().release

#### 3.3.2 设置系统配置

Python还可以设置系统配置，例如更改环境变量或修改文件权限。

# 设置环境变量
os.environ["PATH"] += ":/new/path"

# 更改文件权限
os.chmod("file.txt", 0o755)

# 4. Python执行Linux命令的高级技巧

### 4.1 并发执行命令

#### 4.1.1 使用多线程

多线程允许在单个进程中同时执行多个任务。在Python中，可以使用`threading`模块创建和管理线程。以下代码示例演示了如何使用多线程并发执行Linux命令：

import threading
import subprocess

def run_command(command):
    subprocess.run(command, shell=True)

commands = ["ls -l", "df -h", "free -m"]

threads = []
for command in commands:
    thread = threading.Thread(target=run_command, args=(command,))
    threads.append(thread)

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

在上面的示例中，`run_command()`函数被定义为一个线程目标函数，它使用`subprocess.run()`函数执行给定的Linux命令。主线程创建了一个线程列表，其中每个线程负责执行一个命令。然后，主线程启动所有线程并等待它们完成。

#### 4.1.2 使用多进程

多进程允许在不同的进程中同时执行多个任务。在Python中，可以使用`multiprocessing`模块创建和管理进程。以下代码示例演示了如何使用多进程并发执行Linux命令：

import multiprocessing
import subprocess

def run_command(command):
    subprocess.run(command, shell=True)

commands = ["ls -l", "df -h", "free -m"]

processes = []
for command in commands:
    process = multiprocessing.Process(target=run_command, args=(command,))
    processes.append(process)

for process in processes:
    process.start()

for process in processes:
    process.join()

在上面的示例中，`run_command()`函数被定义为一个进程目标函数，它使用`subprocess.run()`函数执行给定的Linux命令。主进程创建了一个进程列表，其中每个进程负责执行一个命令。然后，主进程启动所有进程并等待它们完成。

### 4.2 错误处理和异常处理

#### 4.2.1 捕获和处理异常

当执行Linux命令时，可能会发生各种错误。在Python中，可以使用`try`和`except`块来捕获和处理异常。以下代码示例演示了如何捕获和处理`subprocess.run()`函数引发的异常：

import subprocess

try:
    subprocess.run("non-existent-command", shell=True)
except subprocess.CalledProcessError as e:
    print("Error:", e.returncode, e.output)

在上面的示例中，`try`块尝试执行一个不存在的命令。如果命令执行失败，`subprocess.CalledProcessError`异常将被引发并被`except`块捕获。异常对象包含有关错误的详细信息，例如返回码和命令输出。

#### 4.2.2 自定义错误类

在某些情况下，可能需要创建自定义错误类来处理特定类型的错误。以下代码示例演示了如何创建自定义错误类：

class MyError(Exception):
    def __init__(self, message):
        self.message = message

def run_command(command):
    try:
        subprocess.run(command, shell=True)
    except subprocess.CalledProcessError as e:
        raise MyError(f"Error: {e.returncode}, {e.output}")

在上面的示例中，`MyError`类是一个自定义错误类，它从`Exception`类继承。它有一个构造函数，它接受一个错误消息作为参数。`run_command()`函数使用自定义错误类来包装`subprocess.CalledProcessError`异常，从而提供更具体的错误信息。

### 4.3 命令输出的解析和处理

#### 4.3.1 使用正则表达式

正则表达式是一种强大的模式匹配语言，可用于解析和处理命令输出。以下代码示例演示了如何使用正则表达式从`ls -l`命令的输出中提取文件大小：

import subprocess
import re

output = subprocess.run("ls -l", shell=True, capture_output=True).stdout.decode()

pattern = r"^-[rwx]{3}\s+\d+\s+\w+\s+\w+\s+\d+\s+\w+\s+\d+\s+(.+)$"

for line in output.splitlines():
    match = re.match(pattern, line)
    if match:
        filename = match.group(1)
        print(filename)

在上面的示例中，`subprocess.run()`函数被用来执行`ls -l`命令并捕获其输出。正则表达式模式`pattern`用于匹配每行的文件大小和文件名。`re.match()`函数用于在每行上应用正则表达式模式，如果匹配成功，则提取文件名并打印它。

#### 4.3.2 使用JSON和XML解析器

如果命令输出是JSON或XML格式，可以使用相应的解析器来解析和处理它。以下代码示例演示了如何使用`json`模块解析JSON输出：

import subprocess
import json

output = subprocess.run("jq -n --stream '{\"name\": \"John\", \"age\": 30}'", shell=True, capture_output=True).stdout.decode()

data = json.loads(output)

print(data["name"])
print(data["age"])

在上面的示例中，`subprocess.run()`函数被用来执行`jq`命令，该命令生成JSON输出。`json.loads()`函数用于解析JSON输出并将其加载到Python数据结构中。然后，可以访问JSON数据并打印其值。

# 5. Python执行Linux命令的最佳实践

### 5.1 安全考虑

**5.1.1 输入验证和转义**

在执行Linux命令时，用户输入可能包含恶意代码或注入攻击。因此，必须对用户输入进行验证和转义，以防止安全漏洞。

import shlex

# 转义用户输入中的特殊字符
escaped_input = shlex.quote(user_input)

# 执行转义后的命令
subprocess.run(f"echo {escaped_input}", shell=True)

**5.1.2 权限管理**

在某些情况下，可能需要以root权限执行命令。但是，这会带来安全风险，因为root用户拥有对系统的所有权限。因此，应谨慎使用root权限，并仅在绝对必要时使用。

# 以root用户执行命令
subprocess.run("ls -l", shell=True, stdout=subprocess.PIPE)

### 5.2 性能优化

**5.2.1 使用缓存**

如果需要多次执行相同的命令，可以将命令输出缓存起来，以避免重复执行。

import functools

# 创建一个缓存装饰器
def cache(func):
    cache = {}

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]

    return wrapper

# 使用缓存装饰器装饰执行命令的函数
@cache
def execute_command(command):
    return subprocess.run(command, shell=True, stdout=subprocess.PIPE).stdout

# 缓存后的命令执行
execute_command("ls -l")

**5.2.2 并行执行命令**

如果需要同时执行多个命令，可以使用多线程或多进程来提高性能。

import threading

# 使用多线程并行执行命令
threads = []
for command in commands:
    thread = threading.Thread(target=subprocess.run, args=(command,))
    threads.append(thread)

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()