Como desenvolvedor Python, você está provavelmente familiarizado com o poder de linguagens de script como Bash ou PowerShell. Mas, caso esse não seja o caso, vamos a uma breve explicação.
Comandos de Shell
Um shell é um programa de computador que fornece uma interface entre o usuário e o sistema operacional. O shell atua como a camada mais externa do sistema operacional, gerenciando a interação entre o usuário e o núcleo do sistema (o kernel). Ele pode ser usado de forma interativa (digitando comandos um de cada vez) ou por meio de scripts (automatizando tarefas com uma sequência de comandos). Ele permite que os usuários interajam com o sistema inserindo comandos ou usando elementos gráficos. O shell interpreta a entrada do usuário – sejam elas comandos digitados em uma interface de linha de comando (CLI) ou ações em uma interface gráfica do usuário (GUI) – e as traduz em instruções que o sistema operacional pode executar.
Existem dois tipos principais de shells: shells gráficos e shells de linha de comando. Shells gráficos oferecem uma interface visual com janelas, ícones e menus, como o ambiente de desktop do Windows. Shells de linha de comando fornecem uma interface baseada em textos em que os usuários digitam comandos. Bash e PowerShell são dois exemplos desse tipo de shell.
Bash e PowerShell
Bash e PowerShell são interfaces de linha de comando e linguagens de script (código).
Bash (Bourne Again Shell) é um interpretador de linha de comando e linguagem de script que se originou em ambientes Unix e Linux. O Bash é o shell padrão para a maioria das distribuições Linux. Ele também está disponível no macOS e, mais recentemente, no Windows (via Windows Subsystem for Linux). Ele é amplamente utilizado para automatizar tarefas, gerenciar arquivos e executar comandos do sistema. Scripts Bash são sequências de comandos salvos em um arquivo, executados linha por linha. Veja um exemplo de comando Bash:
ls -l
Este comando lista o conteúdo do diretório.
PowerShell é um shell de linha de comando e linguagem de script desenvolvido pela Microsoft, originalmente para Windows, mas agora disponível em várias plataformas (Windows, Linux, macOS). Ele foi projetado para automação de tarefas e gerenciamento de configuração, especialmente em ambiente Windows. O PowerShell é orientado a objetos: ele trata a entrada e a saída como objetos em vez de texto simples, permitindo uma manipulação de dados mais complexa. Ele é especialmente poderoso para gerenciar tarefas centradas no Windows. Veja um exemplo de comando:
Get-Process
Este comando lista os processos sendo executados.
Dominar o Bash ou o PowerShell é uma habilidade valiosa na automação e gerenciamento de inúmeras tarefas. No entanto, você sabe que pode executar esses comandos de shell diretamente do seu código em Python? Neste post, exploraremos como usar o módulo subprocess para executar comandos Unix e Windows com Python.
O que é subprocess?
O módulo subprocess do Python é uma biblioteca integrada que permite executar programas e comandos externos de dentro do um código Python. Ele cria e gerencia processos filhos, permitindo que um script Python interaja com o sistema operacional da mesma forma que um usuário faria na linha de comando. Com o subprocess, você pode iniciar novos processos, conectar-se a seus canais de entrada/saída/erro e obter códigos de retorno. Portanto, esse módulo é uma ferramenta importante para automatizar tarefas, executar comandos do sistema e interagir com outros processos.
Entenda o Shell de seu sistema operacional
Ao usar o subprocess para executar um comando, você pode especificar se deseja executá-lo por meio de um shell (como Bash ou PowerShell) ou diretamente como um programa. O parâmetro shell=True informa ao subprocess para executar o comando por meio do shell padrão do sistema. O uso de um shell permite que você use recursos de shell, como pipes (|) e asteriscos (*), assim como faria em uma sessão de shell interativa. No entanto, antes de sair tentando executar comandos Bash ou PowerShell, é preciso saber qual é o mais adequado para o seu sistema operacional.
Em sistemas do tipo Unix, o shell geralmente é /bin/sh (ou Bash, se especificado). Por padrão, o subprocess usa /bin/sh, mas você pode defini-lo explicitamente como Bash usando o argumento executable:
subprocess.run("echo Oi do Bash!", shell=True, executable="/bin/bash")
Máquinas Windows não têm um shell Bash nativo. Consequentemente, se você tentar executar um comando Bash como ls diretamente com subprocess.run([‘ls’, ‘-l’]), obterá um erro. O Windows usa seu próprio shell com comandos específicos. No Windows, o shell normalmente é cmd.exe, mas ele também pode ser definido como PowerShell.
Veja um exemplo de como rodar comandos PowerShell (funciona apenas no Windows ou no Linux/macOS com o PowerShell instalado) com uma pequena função do Python:
import subprocess
def run(cmd):
res = subprocess.run(["powershell", "-Command", cmd], capture_output=True)
return res
Esta função recebe um comando PowerShell como argumento e retorna o resultado de sua execução.
Se você precisa usar comandos Bash no Windows, existem duas opções principais. Se você tiver o Git para Windows instalado, ele vem com o Git Bash. Você pode invocar comandos Bash chamando o executável bash.exe diretamente do Python:
import subprocess
subprocess.run(['C:\\Program Files\\Git\\bin\\bash.exe', '-c', 'ls'])
Outra forma de usar comandos Bash no Windows envolve usar o WSL (Subsistema do Windows para Linux). Se você tiver o WSL instalado, poderá executar comandos bash por meio do WSL invocando wsl.exe:
import subprocess
subprocess.run(['wsl', 'ls', '-l'])
Executando Comandos de Shell com Python
Para executar um comando de shell com Python, você pode usar a função run() do módulo subprocess.Veja um exemplo:
import subprocess
subprocess.run(["ls", "-l"])
Neste exemplo, o primeiro passo foi importar o módulo subprocess para poder usá-lo. Depois, usamos a função run() para executar um comando de shell que mostra o conteúdo do diretório. Ao executarmos um código Python com esse trecho, ele ira imprimir o conteúdo do diretório no terminal. Se você deseja salvar o conteúdo ou usar de alguma maneira essa informação no seu código, basta atribuí-la a uma variável:
import subprocess
resultado = subprocess.run(["ls", "-l"], capture_output=True, text=True)
Note que, no exemplo acima, usamos alguns argumentos novos. O método subprocess.run() pode receber vários argumentos. Alguns deles são:
capture_output: quando definido como True, capturará a saída padrão e o erro padrão.
text: quando definido como True, retornará stdout e stderr como string.
check: um valor booleano que indica se o código de retorno do subprocesso deve ser verificado, se check for True e o código de retorno for diferente de zero, o subprocesso CalledProcessError será gerado.
shell: argumento booleano que indica se o comando deve ser executado em um shell. Isso significa que o comando é passado como uma string e recursos específicos do shell, como “*” e “|”, podem ser usados.
Exemplos de Comandos de Shell executados com Python
Comandos shell podem ser executados em Python para as mais variadas finalidades. Vamos explorar alguns exemplos a seguir.
cwd
O módulo de subprocesso possui um parâmetro chamado cwd que permite especificar o diretório de trabalho para um subprocesso. Este parâmetro pode ser passado como um argumento para a função run(). Através dele, especificamos o diretório de trabalho que desejamos e executamos comandos diretamente nele:
subprocess.run(["ls", "-l"], cwd="/caminho/para/diretorio")
Clonando repos git
Já pensou em clonar repositórios do GitHub diretamente de códigos Python? O módulo subprocess permite realizar isso facilmente:
import subprocess
# Define o diretório de diretorio_de_trabalho
diretorio_de_trabalho = "/caminho/para/diretorio"
# clona repositório para o diretório selecionado
subprocess.run(["git", "clone", "https://github.com/examplo/repo.git"], cwd=diretorio_de_trabalho)
echo
O comando echo permite imprimir mensagens diretamente no terminal.
import subprocess
subprocess.run(['echo', 'Oi, subprocess!'])
executando backups
Neste exemplo, estamos usando o subprocesso para automatizar uma tarefa de backup de dados. O comando tar é usado para criar um arquivo compactado de um diretório.
import subprocess
subprocess.run(['tar', '-czf', 'backup.tar.gz', '/caminho/do/diretorio'])
executando códigos Python
Outra habilidade fantástica do módulo subprocess é a execução de códigos Python (ou de outras linguagens). Ou seja, podemos usá-lo em um código Python para controlar a execução de outros códigos Python. Veja um exemplo. Primeiro, criaremos um código Python para ser executado (exemplo.py):
print('Oi do Python')
minha_lista = [1, 2, 3, 4, 5]
for item in minha_lista:
print(item + 1)
Depois, para executá-lo com subprocess, usamos a função run() e especificamos a linguagem (python) e o código que deve ser executado.
import subprocess
resultado = subprocess.run(["python", "exemplo.py"])
Lidando com Erros e Exceções
Ao executar comandos externos com Python, é essencial lidar com erros e exceções corretamente. E essa é uma das grandes vantagens de poder executar comandos de shell com Python. Podemos nos beneficiar, por exemplo, do tratamento de erros com o bloco try/except:
import subprocess
try:
res = subprocess.check_output(["python", "--version"], text=True)
print(res)
except subprocess.CalledProcessError as e:
print(f"Comando fallhou com o seguinte retorno {e.returncode}")
Neste exemplo, tentamos verificar a versão do Python com subprocess em um bloco try/except. A vantagem desse procedimento é que, caso alguma coisa gere uma exceção, o código consegue lidar com ela sem grandes problemas.
Conclusão
Executar comandos de shell do Python pode ser uma forma poderosa de automatizar tarefas e interagir com outros processos. Independentemente de sua máquina ter sistema operacional Unix ou Windows, você pode começar a executar comandos de shell a partir do seu código em Python.
Fique de olho em mais tutoriais e artigos sobre Python e IA!
