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.
últimas postagens
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.
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.
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.
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 👨💻