Como executar scripts bash usando Python?

Se você estiver usando o Linux, com certeza adoraria os comandos do shell.

E se você estiver trabalhando com Python, pode ter tentado automatizar as coisas. Essa é uma forma de economizar tempo. Você também pode ter alguns scripts bash para automatizar as coisas.

Python é útil para escrever scripts do que o bash. E o gerenciamento de scripts Python é fácil em comparação com scripts bash. Você achará difícil manter os scripts bash quando estiver crescendo.

Mas e se você já tiver scripts bash que deseja executar usando Python?

Existe alguma maneira de executar os comandos e scripts bash em Python?

Sim, Python tem um módulo embutido chamado subprocesso que é usado para executar os comandos e scripts dentro de scripts Python. Vamos ver como executar comandos e scripts bash em scripts Python em detalhes.

Executando Comandos Bash

Como você já deve ter visto, o subprocesso do módulo é usado para executar os comandos e scripts do bash. Ele fornece métodos e classes diferentes para o mesmo.

Há principalmente um método e uma classe para conhecer do módulo de subprocesso. Eles são executados e Popen. Esses dois nos ajudam a executar os comandos bash em scripts Python. Vamos vê-los um por um.

subprocess.run()

O método subprocess.run() receberá uma lista de strings como argumento posicional. Isso é obrigatório, pois possui o comando bash e argumentos para ele. O primeiro item da lista é o nome do comando e os itens restantes são os argumentos do comando.

  11 Melhores Recursos e Tutoriais de Aprendizagem de Redação

Vamos ver um exemplo rápido.

import subprocess
subprocess.run(["ls"])

O script acima lista todos os itens no diretório de trabalho atual conforme o script está. Não há argumentos para o comando no script acima. Nós demos apenas o comando bash. Podemos fornecer argumentos adicionais ao comando ls como -l, -a, -la, etc.

Vamos ver um exemplo rápido com argumentos de comando.

import subprocess
subprocess.run(["ls", "-la"])

O comando acima exibe todos os arquivos, incluindo arquivos ocultos, juntamente com as permissões. Fornecemos o argumento la que exibe arquivos e diretórios com informações extras e arquivos ocultos.

Podemos acabar cometendo alguns erros ao escrever os comandos. Erros irão aumentar de acordo com os erros. E se você quiser capturá-los e usá-los mais tarde? Sim, podemos fazer isso usando o argumento de palavra-chave stderr.

Vamos ver um exemplo.

import subprocess
result = subprocess.run(["cat", "sample.txt"], stderr=subprocess.PIPE, text=True)
print(result.stderr)

Certifique-se de não ter o arquivo com o nome sample.txt no diretório de trabalho. O valor para o argumento de palavra-chave stderr é PIPE, que ajuda a retornar o erro em um objeto. Podemos acessá-lo mais tarde com o mesmo nome. E o texto do argumento da palavra-chave ajuda a dizer que a saída deve ser uma string.

Da mesma forma, podemos capturar a saída do comando usando o argumento de palavra-chave stdout.

import subprocess
result = subprocess.run(["echo", "Hello, World!"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
print(result.stdout)

subprocess.run() – entrada

Você pode dar entrada aos comandos usando o argumento da palavra-chave input. Daremos entradas em um formato de string. Portanto, precisamos definir o texto do argumento da palavra-chave como True. Por padrão, ele recebe em bytes.

Vejamos um exemplo.

import subprocess
subprocess.run(["python3", "add.py"], text=True, input="2 3")

No programa acima, o script Python add.py receberá dois números como entrada. Nós demos a entrada para o script Python usando o argumento da palavra-chave input.

  Como fazer um bom papel de parede ao vivo para o seu iPhone

subprocesso.Popen()

A classe subprocess.Popen() é avançada que o método subprocess.run(). Ele nos dá mais opções para executar os comandos. Vamos criar uma instância do subprocess.Popen() e usá-la para várias coisas como saber o status da execução do comando, obter saída, dar entrada, etc.,

Existem vários métodos da classe subprocess.Popen() que precisamos conhecer. Vamos vê-los um por um junto com os exemplos de código.

esperar

É usado para esperar até a conclusão da execução do comando. As próximas linhas do script Python não serão executadas até a conclusão do comando anterior escrito após o método wait. Vamos ver o exemplo.

import subprocess
process = subprocess.Popen(["ls", "-la"])
print("Completed!")

Execute o código acima e observe a saída. Você verá que a mensagem Concluído! é impresso antes da execução do comando. Podemos evitá-lo usando o método wait. Vamos esperar até a conclusão do comando.

import subprocess
process = subprocess.Popen(["ls", "-la"])
process.wait()

print("Completed!")

Se você vir a saída para o código acima, perceberá que a espera está realmente funcionando. A instrução print é executada após a conclusão da execução do comando.

comunicar

O método comunicar é usado para obter a saída, erro e dar entrada ao comando. Ele retorna uma tupla contendo saída e erro, respectivamente. Vamos ver um exemplo.

import subprocess
process = subprocess.Popen(["echo", "Hello, World!"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
result = process.communicate()
print(result)

subprocess.Popen() – entrada

Não podemos passar a entrada para a classe Popen diretamente. Precisamos usar o argumento de palavra-chave chamado stdin para fornecer a entrada para o comando. A instância da classe Popen nos fornecerá o objeto stdin. Ele tem um método chamado write que é usado para fornecer a entrada para o comando.

  12 Melhor plataforma SaaS de helpdesk para sua empresa

Como discutimos anteriormente, ele receberá entradas como objetos semelhantes a bytes por padrão. Portanto, não se esqueça de definir o texto do argumento da palavra-chave como True ao criar a instância de Popen.

Vamos ver um exemplo.

import subprocess
process = subprocess.Popen(["python3", "add.py"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
process.stdin.write("2 3")
process.stdin.close()
print(process.stdout.read())

votação

O método poll é usado para verificar se a execução do comando foi concluída ou não. Este método retornará Nenhum se o comando ainda estiver em execução. Vamos ver um exemplo.

import subprocess
process = subprocess.Popen(['ping', '-c 5', 'geekflare.com'], stdout=subprocess.PIPE, text=True)
while True:
    output = process.stdout.readline()
    if output:
    	print(output.strip())
    result = process.poll()
    if result is not None:
        break

No código acima, usamos o comando ping com 5 solicitações. Há um loop infinito que itera até a conclusão da execução do comando. Usamos o método poll para verificar o status da execução do comando. Se a pesquisa de método retornar um código diferente de Nenhum, a execução será concluída. E o loop infinito quebra.

Executando scripts Bash

Vimos duas maneiras de executar os comandos. Agora, vamos ver como executar os scripts bash em scripts Python.

O subprocesso tem um método chamado call. Este método é usado para executar os scripts bash. O método retorna o código de saída do script bash. O código de saída padrão para os scripts bash é 0. Vejamos um exemplo.

Crie um script bash com o nome practice.sh da seguinte forma.

#!/bin/bash

echo "Hello, World!"
exit 1

Agora, escreva um script Python e execute o script bash acima.

import subprocess
exit_code = subprocess.call('./practice.sh')
print(exit_code)

Você obterá a seguinte saída depois de executar o script Python acima.

Hello, World!
1

Conclusão

Vimos como executar comandos e scripts bash em Python. Você pode usá-los para automatizar as coisas com mais eficiência.

Boa codificação 👨‍💻