Como executar comandos externos em Python

Executando comandos do sistema em Python

Python fornece recursos poderosos para executar programas externos e comandos do sistema diretamente de seus scripts. Este recurso permite que você aproveite a simplicidade do Python enquanto aproveita a vasta gama de ferramentas disponíveis em seu sistema operacional.

Esteja você automatizando tarefas repetitivas ou integrando fluxos de trabalho complexos, entender como chamar comandos do sistema em Python pode aumentar significativamente sua produtividade. Neste guia, exploraremos diferentes métodos para conseguir isso de forma eficaz.

Compreendendo a execução de scripts em Python

Os scripts fornecidos demonstram várias maneiras de executar comandos externos usando Python. O subprocess.run O comando é versátil, permitindo que você execute comandos shell diretamente de seu script Python. Por exemplo, subprocess.run(['echo', 'Hello, World!']) imprime uma mensagem no console, enquanto subprocess.run(['ls', '-l'], capture_output=True, text=True) captura a saída do ls -l comando, exibindo uma listagem detalhada do diretório. Usando shell=True com subprocess.run permite o uso de recursos de shell, como expansão de curinga, tornando-o útil para comandos mais complexos.

O subprocess.Popen O comando fornece mais controle sobre a execução do comando, permitindo a execução assíncrona do comando e a interação com os fluxos de entrada e saída do processo. Por exemplo, o exemplo de script com subprocess.Popen(['ping', 'localhost'], stdout=subprocess.PIPE) executa ping continuamente na máquina local e lê cada linha de saída. Adicionalmente, os.system é usado para execução simples de comandos, mas não possui a flexibilidade de subprocess. Variáveis ​​de ambiente podem ser modificadas e passadas para o subprocesso usando os.environ.copy() e a env parâmetro em subprocess.run, permitindo a execução dinâmica de comandos com base no ambiente.

import subprocess
# Example 1: Running a simple shell command
subprocess.run(['echo', 'Hello, World!'])
# Example 2: Capturing the output of a command
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(result.stdout)
# Example 3: Running a command with shell=True
subprocess.run('echo Hello from the shell', shell=True)
# Example 4: Checking the return code
result = subprocess.run(['ls', 'nonexistentfile'], capture_output=True)
if result.returncode != 0:
    print('Command failed')
# Example 5: Using subprocess.Popen for more control
process = subprocess.Popen(['ping', 'localhost'], stdout=subprocess.PIPE)
while True:
    output = process.stdout.readline()
    if output == b'' and process.poll() is not None:
        break
    if output:
        print(output.strip().decode())

import os
import subprocess
# Example 1: Using os.system to run a command
os.system('echo This is a test')
# Example 2: Running a command and capturing output with subprocess
result = subprocess.run(['date'], capture_output=True, text=True)
print('Current date and time:', result.stdout)
# Example 3: Executing multiple commands
commands = ['echo First command', 'echo Second command']
for cmd in commands:
    os.system(cmd)
# Example 4: Running a command with environment variables
env = os.environ.copy()
env['MY_VAR'] = 'Hello'
subprocess.run('echo $MY_VAR', shell=True, env=env)
# Example 5: Handling command errors
try:
    subprocess.check_output(['false_command'], stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
    print('An error occurred:', e.output.decode())

Técnicas Avançadas para Execução de Comandos do Sistema

Outro aspecto da execução de comandos do sistema em Python envolve o uso do shlex módulo para lidar com a análise de comandos shell. Este módulo fornece uma maneira de dividir comandos shell em um formato de lista, que pode então ser passado para subprocess funções. Isso garante que os argumentos com espaços sejam tratados corretamente. Além disso, você pode usar o subprocess.PIPE para direcionar os fluxos padrão de entrada, saída e erro para o processo pai, permitindo uma comunicação mais complexa entre processos.

Por exemplo, encadear comandos e processar sua saída sequencialmente pode ser conseguido canalizando a saída de um comando para outro usando subprocess.Popen. Isso permite criar sequências de comandos poderosas, semelhantes às que você faria em um script de shell. Você também pode usar threading para executar vários comandos de subprocesso simultaneamente, aumentando a eficiência do seu script, especialmente ao lidar com tarefas vinculadas a E/S.

Técnicas Avançadas para Execução de Comandos do Sistema

Outro aspecto da execução de comandos do sistema em Python envolve o uso do shlex módulo para lidar com a análise de comandos shell. Este módulo fornece uma maneira de dividir comandos shell em um formato de lista, que pode então ser passado para subprocess funções. Isso garante que os argumentos com espaços sejam tratados corretamente. Além disso, você pode usar o subprocess.PIPE para direcionar os fluxos padrão de entrada, saída e erro para o processo pai, permitindo uma comunicação mais complexa entre processos.

Por exemplo, encadear comandos e processar sua saída sequencialmente pode ser conseguido canalizando a saída de um comando para outro usando subprocess.Popen. Isso permite criar sequências de comandos poderosas, semelhantes às que você faria em um script de shell. Você também pode usar threading para executar vários comandos de subprocesso simultaneamente, aumentando a eficiência do seu script, especialmente ao lidar com tarefas vinculadas a E/S.