Uma introdução ao subprocesso Python: Noções básicas e exemplos

Quando usar o Python Subprocess

Automatização de tarefas do sistema

O módulo de subprocessos pode ser usado para automatizar várias tarefas do sistema, como a execução de backups, a inicialização e a interrupção de serviços e o agendamento de tarefas cron. Por exemplo, você pode usar o módulo de subprocesso para executar o comando "cp" para criar um backup de um arquivo ou o comando "service" para iniciar e parar serviços em sistemas Linux.

Você também pode usar o módulo de subprocessos para agendar tarefas a serem executadas em intervalos específicos usando o cron ou outras ferramentas de agendamento.

Execução de ferramentas de linha de comando

O módulo subprocess pode ser usado para executar ferramentas de linha de comando, como grep, sed e awk, e processar a saída delas em seu código Python. Por exemplo, você pode usar o módulo subprocess para executar o comando "grep" para procurar um padrão específico em um arquivo e, em seguida, processar a saída no seu código Python. Isso pode ser útil para tarefas como análise de registros, processamento de dados e manipulação de texto.

Execução de executáveis externos

O módulo de subprocesso pode executar outros executáveis, como arquivos .exe no Windows, e controlar seu comportamento. Por exemplo, você pode usar o módulo de subprocesso para executar um executável que realiza uma tarefa específica e, em seguida, usar a saída desse executável em seu próprio código. Isso pode ser útil para processamento de imagens, análise de dados e tarefas de aprendizado de máquina.

Execução de scripts como processos em segundo plano

Você pode usar o módulo de subprocessos para executar scripts como processos em segundo plano, de modo que eles continuem sendo executados após o encerramento do programa principal. Por exemplo, você pode usar o módulo de subprocesso para executar um script que realiza uma tarefa específica e sair do programa principal sem esperar que o script seja concluído. Isso pode ser útil para monitoramento, registro e coleta de dados.

Execução de scripts com um interpretador que não seja Python

O módulo de subprocessos pode ajudar você a executar scripts escritos em outras linguagens, como Perl, Ruby e Bash. Por exemplo, você pode usar o módulo de subprocesso para executar um script Perl que realiza uma tarefa específica e, em seguida, usar a saída desse script em seu próprio código. Isso pode ser útil para processamento de dados, manipulação de texto e administração do sistema.

Processamento paralelo

O módulo de subprocessos pode ser usado para executar vários processos em paralelo, o que pode ser útil para tarefas como processamento de imagens, análise de dados e aprendizado de máquina. Por exemplo, você pode usar o módulo de subprocessos para executar várias instâncias do mesmo script, cada uma processando uma parte diferente dos dados e, em seguida, combinar os resultados.

Exemplos de subprocessos Python 

execução do subprocesso python

O método subprocess.run() é uma maneira conveniente de executar um subprocesso e esperar que ele seja concluído. Ele permite que você escolha o comando a ser executado e adicione opções como argumentos, variáveis de ambiente e redirecionamentos de entrada/saída. Depois que o subprocesso é iniciado, o método run() bloqueia até que o subprocesso seja concluído e retorna um objeto CompletedProcess, que contém o código de retorno e a saída do subprocesso.

O método subprocess.run() recebe vários argumentos, alguns dos quais são:

• args: O comando a ser executado e seus argumentos, passados como uma lista de cadeias de caracteres.
• capture_output: Quando definido como True, você capturará a saída padrão e o erro padrão.
• text: Quando definido como True, você retornará o stdout e o stderr como string, caso contrário, como bytes.
• check Se a verificação for verdadeira e o código de retorno for diferente de zero, o subprocesso `CalledProcessError` será acionado.
• timeout: Um valor em segundos que especifica quanto tempo você deve esperar para que o subprocesso seja concluído antes de atingir o tempo limite.
• shell: Um valor booleano que indica se você deve executar o comando em um shell. Isso significa que o comando é passado como uma cadeia de caracteres e que os recursos específicos do shell, como expansão de curinga e substituição de variáveis, podem ser usados.

O método subprocess.run() também retorna um objeto CompletedProcess, que contém os seguintes atributos:

• args: O comando e os argumentos que foram executados.
• returncode: O código de retorno do subprocesso.
• stdout: A saída padrão do subprocesso, como um objeto de bytes.
• stderr: O erro padrão do subprocesso, como um objeto de bytes.

Exemplo 1: Executar comandos do shell:

import subprocess

result = subprocess.run(["dir"], shell=True, capture_output=True, text=True)

print(result.stdout)

Saída: 

Volume in drive C has no label.

Volume Serial Number is E414-A41C

 Directory of C:\Users\owner

01/25/2023  10:56 AM    <DIR>          .

01/25/2023  10:56 AM    <DIR>          ..

07/19/2021  01:19 PM    <DIR>          .anaconda

07/19/2021  01:19 PM    <DIR>          .astropy

07/19/2021  01:19 PM    <DIR>          .aws

09/12/2022  08:48 AM               496 .bash_history

03/27/2022  03:08 PM    <DIR>          .cache

09/26/2021  06:58 AM    <DIR>          .conda

09/26/2021  06:59 AM                25 .condarc

…

Os usuários de Linux ou Mac substituem "dir" por "ls" e eliminam o argumento `shell`.

Exemplo 2: Execução de scripts Python:

Você também pode executar um script python usando o método subprocess.run(). Vamos começar criando um script Python simples em um arquivo .py

print(“This is the output from subprocess module”)

Salve esse arquivo como `my_python_file.py`

Agora você pode usar o módulo de subprocesso para executar esse arquivo:

import subprocess

result = subprocess.run(["python", "my_python_file.py"], capture_output=True, text=True)

print(result.stdout)

Saída:

This is the output from subprocess module

Exemplo 3: Executar o código Python diretamente de uma função:

Para casos de uso simples, você pode passar diretamente um comando python na função subprocess.run(). Veja como:

result = subprocess.run(["C:/Users/owner/anaconda3/python", "-c", "print('This is directly from a subprocess.run() function')"], capture_output = True, text = True)

print(result.stdout)

Saída:

This is directly from a subprocess.run() function

Na lista args, o primeiro elemento `C:/Users/owner/anaconda3/python` é um caminho para o Python executável (seu caminho pode ser diferente). O segundo elemento, `-c`, é uma tag Python que permite ao usuário escrever código Python como texto na linha de comando. O terceiro elemento, `print(...)` é o próprio comando Python.

Exemplo 4: Usando o argumento de verificação

O argumento check é um argumento opcional da função subprocess.run() no módulo de subprocessos do Python. É um valor booleano que controla se a função deve verificar o código de retorno do comando que está sendo executado.

Quando check for definido como True, a função verificará o código de retorno do comando e gerará uma exceção CalledProcessError se o código de retorno for diferente de zero. A exceção terá o código de retorno, stdout, stderr e comando como atributos.

Quando a verificação é definida como False (padrão), a função não verifica o código de retorno e não gera uma exceção, mesmo que o comando falhe.

import subprocess

result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

print(result.stdout)

print(result.stderr)

Saída:

---------------------------------------------------------------------------

CalledProcessError                        Traceback (most recent call last)

<ipython-input-81-503b60184db8> in <module>

      1 import subprocess

----> 2 result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

      3 print(result.stdout)

      4 print(result.stderr)

~\anaconda3\lib\subprocess.py in run(input, capture_output, timeout, check, *popenargs, **kwargs)

    514         retcode = process.poll()

    515         if check and retcode:

--> 516             raise CalledProcessError(retcode, process.args,

    517                                      output=stdout, stderr=stderr)

    518     return CompletedProcess(process.args, retcode, stdout, stderr)

CalledProcessError: Command '['python', 'file_donot_exist.py']' returned non-zero exit status 2.

Observe que o comando falhou porque o arquivo `file_donot_exist.py` não existe. Ao contrário de quando você define `check=True`, seu processo não falhará; em vez disso, você receberá a mensagem de erro em `stdout`. 

import subprocess

result = subprocess.run(["python", "my_python_file2.py"], capture_output=True, text=True, check=False)

print(result.stdout)

print(result.stderr)

Saída:

python: can't open file 'my_python_file2.py': [Errno 2] No such file or directory

subprocesso python Popen

O `subprocess.Popen` é uma interface de nível inferior para a execução de subprocessos, enquanto o subprocess.run é um invólucro de nível superior em torno do Popen, que se destina a ser mais conveniente de usar.

O Popen permite que você inicie um novo processo e interaja com seus fluxos padrão de entrada, saída e erro. Ele retorna um identificador para o processo em execução que pode ser usado para aguardar a conclusão do processo, verificar seu código de retorno ou encerrá-lo.

run é uma função mais conveniente que permite que você execute um comando e capture sua saída em uma única chamada, sem precisar criar um objeto Popen e gerenciar os fluxos por conta própria. Ele também permite que você especifique várias opções para a execução do comando, como a possibilidade de gerar uma exceção se o comando falhar.

Em geral, você deve usar run se precisar apenas executar um comando e capturar sua saída e Popen se precisar de mais controle sobre o processo, como interagir com seus fluxos de entrada e saída.

A classe Popen recebe os mesmos argumentos que run(), incluindo os argumentos que especificam o comando a ser executado e outros argumentos opcionais, como stdin, stdout, stderr, shell, cwd e env.

A classe Popen tem vários métodos que permitem que você interaja com o processo, como communicate(), poll(), wait(), terminate() e kill().

import subprocess

p = subprocess.Popen(["python", "--help"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

output, errors = p.communicate()

print(output)

Saída:

usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...

Options and arguments (and corresponding environment variables):

-b     : issue warnings about str(bytes_instance), str(bytearray_instance)

         and comparing bytes/bytearray with str. (-bb: issue errors)

-B     : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x

-c cmd : program passed in as string (terminates option list)

-d     : debug output from parser; also PYTHONDEBUG=x

-E     : ignore PYTHON* environment variables (such as PYTHONPATH)

…

Isso executará o comando `python -help` e criará um novo objeto Popen, que é armazenado na variável p. A saída padrão e o erro do comando são capturados usando o método communicate() e armazenados nas variáveis output e errors, respectivamente.

O `subprocess.Popen` é útil quando você deseja ter mais controle sobre o processo, como enviar entrada para ele, receber saída dele ou esperar que ele seja concluído.

Chamada de subprocesso python

`subprocess.call()` é uma função do módulo de subprocessos do Python que é usada para executar um comando em um processo separado e aguardar a conclusão. Ele retorna o código de retorno do comando, que é zero se o comando for bem-sucedido e diferente de zero se ele falhar.

A função call() recebe os mesmos argumentos que run(), incluindo os argumentos que especificam o comando a ser executado e outros argumentos opcionais, como stdin, stdout, stderr, shell, cwd e env.

A saída padrão e o erro do comando são enviados para o mesmo stdout e stderr que o processo pai, a menos que você os redirecione usando os argumentos stdout e stderr.

import subprocess

return_code = subprocess.call(["python", "--version"])

if return_code == 0:

    print("Command executed successfully.")

else:

    print("Command failed with return code", return_code)

Saída:

Command executed successfully.

Isso executará o comando `python -version` em um processo separado e aguardará que ele seja concluído. O código de retorno do comando será armazenado na variável return_code, que será zero se o comando for bem-sucedido e diferente de zero se ele falhar.

subprocess.call() é útil quando você deseja executar um comando e verificar o código de retorno, mas não precisa capturar a saída.

subprocesso python check_output

check_output é uma função no módulo subprocess que é semelhante a run(), mas retorna apenas a saída padrão do comando e gera uma exceção CalledProcessError se o código de retorno for diferente de zero.

A função check_output usa os mesmos argumentos que run(), incluindo os argumentos que especificam o comando a ser executado e outros argumentos opcionais, como stdin, stderr, shell, cwd e env.

A função check_output retorna a saída padrão do comando como um objeto de bytes ou uma cadeia de caracteres, se text=True for passado.

import subprocess

try:

    output = subprocess.check_output(["python", "--version"], text=True)

    print(output)

except subprocess.CalledProcessError as e:

    print(f"Command failed with return code {e.returncode}")

Saída:

Python 3.8.8

Tubo de subprocessos Python

O módulo de subprocessos do Python oferece uma maneira de criar e interagir com processos filhos, que podem ser usados para executar outros programas ou comandos. Um dos recursos do módulo de subprocesso é a capacidade de criar pipes, que permitem a comunicação entre os processos pai e filho.

Um pipe é um canal de comunicação unidirecional que conecta a saída padrão de um processo à entrada padrão de outro. Um pipe pode conectar a saída de um comando à entrada de outro, permitindo que a saída do primeiro comando seja usada como entrada para o segundo comando.

Os pipes podem ser criados usando o módulo de subprocesso com a classe Popen, especificando o argumento stdout ou stdin como subprocess.PIPE.

Por exemplo, o código a seguir cria um pipe que conecta a saída do comando ls à entrada do comando grep, que filtra a saída para mostrar somente as linhas que contêm a palavra "file" (arquivo):

import subprocess

ls_process = subprocess.Popen(["ls"], stdout=subprocess.PIPE, text=True)

grep_process = subprocess.Popen(["grep", "sample"], stdin=ls_process.stdout, stdout=subprocess.PIPE, text=True)

output, error = grep_process.communicate()

print(output)

print(error)

Saída:

sample_data

Neste exemplo, a classe Popen é usada para criar dois processos filhos, um para o comando ls e outro para o comando grep. O stdout do comando ls é conectado ao stdin do comando grep usando subprocess.PIPE, que cria um pipe entre os dois processos. O método communicate() é usado para enviar a saída do comando ls para o comando grep e recuperar a saída filtrada.

Conclusão

O módulo Python `subprocess` oferece uma maneira eficiente e flexível de criar e interagir com processos filhos, permitindo que você execute outros programas ou emita comandos a partir do seu script Python. De comandos simples, como subprocess.call(), a recursos mais avançados, como pipes, redirecionamento de entrada e saída e passagem de variáveis de ambiente, o módulo de subprocessos tem algo a oferecer para quase todos os casos de uso. É uma ótima maneira de automatizar tarefas repetitivas, executar comandos do sistema e até mesmo interagir com outras linguagens de programação e plataformas.

Ao trabalhar com o módulo de subprocesso, é importante lembrar que a execução de comandos externos representa um risco de segurança, especialmente quando você usa o parâmetro shell=True ou passa uma entrada não higienizada. É sempre uma boa prática usar a função subprocess.run(), que permite que você especifique várias opções de como o comando deve ser executado, como, por exemplo, se deve gerar uma exceção se o comando falhar. 

Se você estiver interessado em mergulhar fundo nas infinitas possibilidades de automação da linha de comando por meio do Python, confira nosso curso Command Line Automation in Python. Neste curso, você aprenderá a escrever um código de automação que navegará em um sistema de arquivos, procurará arquivos que sigam um padrão e determinará se os arquivos são duplicados em um dos vários casos. Após concluir o curso, você será capaz de gerenciar e interagir com os processos Unix, bem como automatizar uma variedade de atividades rotineiras do sistema de arquivos. 

Aumente as habilidades em Python da sua equipe com o DataCamp for Business

Se você ou sua equipe deseja aprimorar suas habilidades em Python e automação de linha de comando, considere explorar o DataCamp for Business. O DataCamp oferece soluções de aprendizagem personalizadas para equipes de todos os tamanhos, ajudando as empresas a se manterem à frente no cenário tecnológico em rápida evolução. Com o DataCamp for Business, você pode aprimorar as habilidades da sua equipe com cursos e trilhas de aprendizagem personalizadas projetadas para desenvolver conhecimentos em Python, automação e outras ferramentas essenciais de ciência de dados. Quer você seja uma startup ou uma empresa, o DataCamp for Business oferece os recursos e a flexibilidade necessários para atingir as metas de aprendizado da sua equipe. Solicite uma demonstração hoje mesmo para saber mais.