Tutorial de como executar scripts Python

Normalmente, todo iniciante aprende primeiro a escrever um script Python na linha de comando e, em seguida, passa a executar o script a partir da linha de comando, sendo que o script geralmente é escrito em um editor de texto e executado a partir da linha de comando. Nesta postagem, exploramos em mais detalhes como executar scripts Python. 

Scripts e interpretadores Python

Os computadores não conseguem entender o código da mesma forma que os humanos o escrevem e, portanto, você precisa de um intérprete entre o computador e o código escrito por humanos. O trabalho do intérprete é converter o código em um formato que os computadores possam entender e processar.

O interpretador processa o código das seguintes maneiras:

• Processa o script Python em uma sequência

• Compila o código em um formato de código de bytes, que é uma linguagem de nível inferior compreendida pelos computadores.

• Por fim, uma máquina virtual Python (PVM) entra em cena. O PVM é a força motriz do tempo de execução do Python. É um processo que itera sobre as instruções de seu código bytecode de baixo nível para executá-las uma a uma.

Assim como os scripts, você tem algo chamado Module, que é um script Python importado e usado em outro script Python.

O script Python é salvo com uma extensão .py, que informa ao computador que se trata de um script de programa Python. Ao contrário do Windows, os sistemas operacionais baseados em Unix, como o Linux e o Mac, vêm com o Python pré-instalado. Além disso, a maneira como os scripts Python são executados nos sistemas operacionais Windows e Unix é diferente.

Executando scripts Python: Preparação

Para todos os usuários, especialmente os usuários do sistema operacional Windows, é altamente recomendável instalar o Anaconda, que pode ser baixado do site da Anaconda. Você pode seguir as instruções fornecidas neste tutorial de instalação do anaconda para Windows.

Para instalar o Python3 em um sistema operacional Windows, consulte este tutorial de configuração do Python.

O interpretador de linha de comando para Python pode ser acessado em vários sistemas operacionais das seguintes maneiras:

• Em Windows, a linha de comando é conhecida como prompt de comando, que pode ser acessado clicando no menu start e procurando por command prompt. Outra maneira é acessar a caixa de diálogo Run e digitar cmd e pressionar Enter(menu Iniciar $->$ Executar e digitar cmd). Depois disso, se o Python estiver instalado em seu drive C, tudo o que você precisa fazer é digitar C:\python36\python.exe, em que python36 é a versão do Python (Observação: Esse caminho pode variar de acordo com o diretório no qual o Python está configurado).

• Em um sistema Mac, isso é muito simples. Tudo o que você precisa fazer é abrir o site Launchpad e procurar por Terminal e, no terminal, digitar Python, e ele fornecerá uma saída com a versão do Python.

• Assim como no sistema Mac, acessar o terminal em um sistema Linux também é muito fácil. Clique com o botão direito do mouse na área de trabalho e clique em Terminal no terminal, digite Python.

Observação: Neste tutorial, você aprenderá a usar o Terminal do Mac OS.

Então, sem mais delongas, vamos começar!

Escrevendo scripts Python no terminal

Vamos ver como podemos codificar e gerar a saída no próprio terminal. Para fazer isso, primeiro digite python3, o que significa que você estará usando a versão Python3.

Depois disso, você pode codificar normalmente como faria em um editor de texto ou em um IDE (ambiente de desenvolvimento integrado), embora não obtenha as funcionalidades no terminal como obteria com um IDE.

Você começará com o exemplo do evergreen Hello, World! e vamos ver como é a saída no terminal.

Não é legal como, apenas abrindo o terminal e digitando Python3, você pode codificar em Python? Vamos tentar mais alguns exemplos.

Um aspecto a ser observado no exemplo acima é que, mesmo sem digitar a instrução print, você conseguiu obter o resultado.

Vamos complicar um pouco o código e permitir que você use a biblioteca NumPy (Numerical Python) para criar duas matrizes e aplicar algumas operações matemáticas a elas. Para se ter uma ideia do que é o numpy, trata-se de uma biblioteca de programação Python que tem a capacidade de lidar com matrizes e arrays multidimensionais grandes, além de uma ampla coleção de funções matemáticas de alto nível para operar nesses arrays.

Você pode observar na figura acima que, usando o numpy, foi possível criar, adicionar e multiplicar duas matrizes numpy no terminal. Um aspecto a ser observado aqui é que a função multiply no numpy faz uma multiplicação por elementos, enquanto a função dot usa o produto escalar de duas matrizes. Para executar o comando np.dot, você precisa se certificar de que o columns da primeira matriz seja igual ao rows da segunda matriz e, portanto, ao value error.

Como executar scripts Python no terminal

Em vez de escrever o script Python no terminal, tudo o que você precisa fazer é usar um editor de texto como vim, emacs ou notepad++ e salvá-lo com uma extensão .py. Em seguida, abra o terminal e vá para o diretório onde o código reside e execute o script com a palavra-chave python seguida do nome do script.

Para criar o arquivo terminal.py, use vim no terminal com o nome do programa como vim terminal.py e cole o código abaixo nele. Para salvar o código, pressione a tecla esc seguida de wq!. E, finalmente, para executar esse script, tudo o que você precisa fazer é digitar python3 terminal.py e, em menos de um segundo, você verá o resultado como mostrado acima.

A seguir, o código usado no exemplo acima.

import numpy as np

x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)

# Elementwise sum; both produce the array
# [[ 6.0  8.0]
#  [10.0 12.0]]
print("Output of adding x and y with a '+' operator:",x + y)
print("Output of adding x and y using 'numpy.add':",np.add(x, y))

# Elementwise difference; both produce the array
# [[-4.0 -4.0]
#  [-4.0 -4.0]]
print("Output of subtracting x and y with a '-' operator:",x - y)
print("Output of subtracting x and y using 'numpy.subtract':",np.subtract(x, y))

# Elementwise product; both produce the array
# [[ 5.0 12.0]
#  [21.0 32.0]]
print("Output of elementwise product of x and y with a '*' operator:",x * y)
print("Output of element wise product of x and y using 'numpy.multiply':",np.multiply(x, y))

# Elementwise division; both produce the array
# [[ 0.2         0.33333333]
#  [ 0.42857143  0.5       ]]
print("Output of elementwise division x and y with a '/' operator:",x / y)
print("Output of elementwise division x and y using 'numpy.divide':",np.divide(x, y))

# Elementwise square root; produces the array
# [[ 1.          1.41421356]
#  [ 1.73205081  2.        ]]
print("Output of elementwise square root x using 'numpy.sqrt':",np.sqrt(x))

Output of adding x and y with a '+' operator: [[ 6.  8.]
 [10. 12.]]
Output of adding x and y using 'numpy.add': [[ 6.  8.]
 [10. 12.]]
Output of subtracting x and y with a '-' operator: [[-4. -4.]
 [-4. -4.]]
Output of subtracting x and y using 'numpy.subtract': [[-4. -4.]
 [-4. -4.]]
Output of elementwise product of x and y with a '*' operator: [[ 5. 12.]
 [21. 32.]]
Output of element wise product of x and y using 'numpy.multiply': [[ 5. 12.]
 [21. 32.]]
Output of elementwise division x and y with a '/' operator: [[0.2        0.33333333]
 [0.42857143 0.5       ]]
Output of elementwise division x and y using 'numpy.divide': [[0.2        0.33333333]
 [0.42857143 0.5       ]]
Output of elementwise square root x using 'numpy.sqrt': [[1.         1.41421356]
 [1.73205081 2.        ]]

Passagem de argumentos da linha de comando para o script Python

Os argumentos de linha de comando facilitam muito a vida. Muitas vezes, em códigos prontos para produção, são usados argumentos de linha de comando. Isso torna eficiente a reprodutibilidade da saída do código. Por exemplo, digamos que o seu código tenha muitas entradas de usuário ou arquivos que estão sendo lidos, então, ao usar argumentos de linha de comando, você não precisará entrar no código para fazer todas essas alterações, caso precise alterar o nome do arquivo ou uma entrada de variável.

Para fazer isso, você usará o módulo sys, que é um módulo Python incorporado. Dentro de sys, você tem argv, que fornece a lista de argumentos da linha de comando passados para o programa Python. sys.argv lê os argumentos da linha de comando como uma lista de itens em que o primeiro item/elemento dessa lista pode ser acessado como sys.argv[1], enquanto o primeiro argumento, ou seja, sys.argv[0], é sempre o nome do programa como foi chamado.

Vamos dar um exemplo simples e ver como isso funciona.

Observação: O argumento da linha de comando é lido como um string pelo Python, portanto, certifique-se de convertê-lo como um integer caso esteja lidando com números.

Assim como no exemplo anterior, salve as linhas de código abaixo em um editor como command_line.py e, para executar o código, digite python3 command_line.py 10, em que 10 é o argumento da linha de comando.

import sys
num = sys.argv[1]
for i in range(int(num)):
    print (i)

E se você não fornecer nenhum argumento de linha de comando?

Você receberá um erro list index out of range, o que também reforça que sys.argv é lido como uma lista de itens. Para evitar esses erros, você precisa do site exceptional handling, que está fora do escopo deste tutorial.

Gravação da saída de um script Python em um arquivo

Por fim, como bônus, vamos ver como é possível salvar a saída do script Python em um arquivo txt usando a chave >. 

Primeiro, você criará uma pasta cli e moverá o código command_line.py para a pasta cli. Em seguida, você verificará o que há nessa pasta para garantir que não haja nenhum arquivo txt já existente.

Em seguida, você digitará python3 command_line.py 10 > output.txt e, por fim, verificará o conteúdo da pasta cli. Agora, você deve conseguir ver o arquivo output.txt.

Vamos abrir e ver o conteúdo do arquivo output.txt.

Na saída acima, você pode ver que os dígitos do 0-9 foram gravados em um arquivo de texto usando apenas o sinal >.

Conclusão

Parabéns por terminar o tutorial.

Ainda há muito a ser explorado, como a execução baseada em GUI em Python, a execução de scripts Python de forma interativa e a execução de scripts Python a partir de um gerenciador de arquivos ou de um IDE. Especificamente em relação à execução da linha de comando, talvez você queira experimentar o Windows command prompt e ver como ele é diferente de um sistema operacional baseado em Unix.

Se você estiver começando a usar Python e quiser saber mais, faça o curso Introdução à ciência de dados em Python do DataCamp.