Como executar um comando Bash em Python

O Python pode iniciar programas de linha de comando e comandos shell para tarefas como criar diretórios ou usar o Git. Para comandos que terminam, subprocess.run() é geralmente o melhor ponto de partida: ele pode capturar a saída e os erros e fornece um código de retorno. Use os.system() para casos simples que não precisam de saída capturada, e escolha subprocess.Popen() quando precisar interagir com um processo enquanto ele é executado.

Executar um comando com subprocess.run()

Passe uma sequência de argumentos para invocar um executável diretamente. Isso evita pedir a um shell que analise o comando. O exemplo usa o interpretador Python em execução, portanto não depende de o Git estar instalado nem de um shell específico.

import subprocess
import sys

result = subprocess.run(
    [sys.executable, "-c", "print('Hello from Python')"],
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
)

print("stdout:", result.stdout)
print("stderr:", result.stderr)
print("return code:", result.returncode)

stdout: b'Hello from Python\n'
stderr: b''
return code: 0

stdout e stderr são bytes aqui, e returncode é um inteiro. Um código de retorno de 0 indica convencionalmente sucesso; um valor diferente de zero sinaliza que o programa relatou um problema. Você pode verificá-lo por conta própria ou passar check=True para que run() levante CalledProcessError diante de um código de retorno diferente de zero. Para executar o Git, por exemplo, passe uma lista de argumentos como ['git', 'status']; sua saída depende do repositório e deve ser tratada como dados, sem presumir que tenha um conteúdo fixo.

A invocação de um programa não é automaticamente um comando Bash. A sintaxe de shell, como pipes, redirecionamentos ou &&, requer um shell. Definir shell=True pede ao Python que use o shell da plataforma; não garante o Bash. Evite interpolar entradas não confiáveis em um comando shell, pois isso pode permitir a injeção de comandos.

Executar um comando shell com os.system()

os.system() é uma opção limitada para um comando simples quando você não precisa capturar sua saída nem lidar com erros em detalhes. Por exemplo, os.system("mkdir reports") pede ao shell da plataforma que execute o comando de criação do diretório. O comando escreve nos fluxos de console herdados. A função retorna um valor de status, não a saída comum do comando; a interpretação desse status pode variar conforme a plataforma. Prefira subprocess.run() quando precisar inspecionar de forma consistente a saída capturada, os erros ou um código de retorno.

Usar subprocess.Popen() para processos em andamento

Use subprocess.Popen() quando o programa precisar de entrada ou de outra interação antes de terminar. Ele inicia o processo e fornece ao seu código um objeto de processo com o qual trabalhar. Para um processo com saída limitada, defina stdout=subprocess.PIPE e stderr=subprocess.PIPE e, em seguida, chame communicate() para ler esses fluxos e aguardar a conclusão. Os valores de fluxo retornados são bytes, a menos que você providencie a decodificação separadamente.

communicate() é útil quando o processo vai terminar e sua saída capturada pode caber na memória. Não é uma abordagem de streaming para saída ilimitada. Depois que communicate() é concluído, o processo terminou; não há necessidade de chamar kill() ou terminate() nele. Para comandos comuns que simplesmente terminam, run() oferece a interface mais simples.

Escolher o método certo

Use subprocess.run() para a maioria dos comandos: passe uma lista de argumentos, capture os fluxos quando necessário e inspecione returncode. Use os.system() apenas quando um comando shell curto for suficiente e sua saída e seu status detalhado não forem importantes. Use Popen() quando seu programa precisar gerenciar um processo em execução ou trocar dados com ele. Escolha um shell apenas quando o comando precisar de sintaxe de shell, e mantenha valores não confiáveis fora das cadeias de shell interpoladas.