Três maneiras de transformar um script Python num arquivo Exe

Como converter um script Python em um arquivo .exe 

Agora que você já sabe o que são arquivos .exe e por que pode querer converter um arquivo Python em um arquivo .exe, vamos ver como fazer isso no Python. Nesta seção, vamos falar sobre três frameworks: pyinstaller, nuitka e auto-py-to-exe.

Uma coisa pra ficar de olho é que auto-py-to-exe tem problemas de compatibilidade conhecidos com o Python 3.11 e versões posteriores, e geralmente só é confiável até o Python 3.10, a menos que você use versões mais recentes específicas e dependências cuidadosamente combinadas.

Dito isso, vamos começar.

Preparando o roteiro

Essa demonstração vai usar o conjunto de dados abertos do Airbnb da cidade de Nova York.  

Antes que os cientistas de dados possam analisar um conjunto de dados, os dados precisam ser formatados para serem compatíveis com as ferramentas que eles estão usando. Então, criar um esquema de validação define de forma eficaz todas as validações que se aplicam a cada campo de forma declarativa. Esse processo pode ser bem repetitivo. Pra evitar que nossos cientistas de dados fiquem fazendo tarefas repetitivas, criamos um script de validação automático pra rodar de vez em quando. 

Observação: Tenha muito cuidado ao usar caminhos relativos se o seu script precisar ler dados. É melhor usar caminhos absolutos pra garantir que seu executável funcione como esperado. 

import pandas as pd
from pandas.api.types import CategoricalDtype

def perform_validation(filename:str):
    """
    A function to validate inputs for NYC Airbnb Open data.
    """
    path_to_data = "../.."
    data = pd.read_csv(f"{path_to_data}{filename}")



    # Convert neighbourhood_group to type category
    neighbourhood_group_to_cat = CategoricalDtype(
        categories=["Manhattan", "Brooklyn", "Queens", "Bronx", "Staten Island"],
        ordered=False
        )
 
    data["neighbourhood_group"] = data["neighbourhood_group"].astype(neighbourhood_group_to_cat)

    # Convert room_type to type category
    room_type_to_cat = CategoricalDtype(
        categories=["Entire home/apt", "Private room", "Shared room"],
        ordered=False
    )

    data["room_type"] = data["room_type"].astype(room_type_to_cat)

    # Convert last_review to datetime
    data["last_review"] = pd.to_datetime(data["last_review"])

    # Minimum nights a person can stay is one night
    assert data["minimum_nights"].min() >= 1

    # Minimum number of reviews is 0
    assert data["number_of_reviews"].min() >= 0
 
    # Minimum number of reviews per month
    assert data["reviews_per_month"].min() >= 0.00

    # Minimum amount of listings per host
    assert data["calculated_host_listings_count"].min() >= 1

    # Number of days when listing is available for books
    # Could be 0 if tennant has long term booking
    assert data["availability_365"].min() >= 0

    # Save validated data
    data.to_csv("validated_ab_nyc_2019.csv", index=False)

if __name__ == "__main__":
    # User inputs filename
    filename = input("Enter filename: ")
 
    # Ensure it's a string
    if not filename.isalpha():
        filename = str(filename)
 
    # Automated validation
    perform_validation(filename)

Observação: copiamos e colamos esse script nos diretórios pyinstaller, nuitka e auto-py-to-exe. 

# Directory structure
|   AB_NYC_2019.csv
|  
+---auto_py_to_exe
|   |   requirements.txt
|   |   validation.py         
+---pyinstaller
    |   requirements.txt
    |   validation.py

Cada diretório tem seu próprio ambiente virtual no qual instalamos os requisitos: veja os requisitos do pyinstaller ou os requisitos do auto-py-to-exe. Se você estiver acompanhando o código, certifique-se de criar um ambiente virtual no diretório pyinstaller e no diretório auto-py-to-exe. 

Em um nível mais alto, o script acima tem uma função – saiba mais sobre como escrever funções em Python – que lê um conjunto de dados e depois define o formato esperado de campos específicos nos dados. O próximo passo é transformar esse script Python num arquivo executável que possa ser rodado de vez em quando para criar um conjunto de dados formatado. 

Método 1: Pyinstaller

O Pyinstaller permite converter rapidamente um arquivo Python em um arquivo executável a partir do seu terminal. Depois de criar seu ambiente virtual e instalar os requisitos para seu script (incluindo o pyinstaller), basta abrir o terminal e ir até o diretório onde está o arquivo Python que você quer converter. 

O próximo passo é executar o seguinte comando: 

pyinstaller --onefile validation.py

No começo, você vai ver vários registros, e o último vai dizer algo tipo “concluído com sucesso” – desde que o arquivo executável tenha sido criado sem problemas. 

Figura 1: Registros mostrando que o arquivo executável está sendo criado e que foi concluído com sucesso.

Quando você terminar de rodar isso, vai aparecer dois novos diretórios, build e dist, no mesmo lugar onde tá o arquivo Python. No diretório dist, você vai encontrar o script validation.exe.

Figura 2: Um GIF mostrando como o validation.exe funciona em um conjunto de dados.

Para rodar o script, é só clicar nele. Isso vai abrir um console que vai pedir pra você colocar o nome do arquivo dos dados que você quer validar. Depois de colocar o nome do arquivo, o console vai fechar e os dados validados vão ser criados no mesmo diretório do arquivo validation.exe – veja a Figura 2. 

Método 2: Nuitka

O Nuitka é outra opção que vale a pena pensar. Diferente do PyInstaller, que junta seu script Python com o interpretador Python, o Nuitka realmente compila seu código Python para código C. Isso resulta em melhor proteção do código-fonte, execução potencialmente mais rápida e, muitas vezes, tamanhos de arquivo menores. A desvantagem é um tempo de compilação mais longo e uma configuração mais complexa.

Instalação e configuração

Depois de criar um ambiente virtual e instalar o Nuitka usando o pip install nuitka, você precisa garantir que um compilador C esteja disponível no seu sistema. O compilador que você precisa depende do seu sistema operacional:

• Windows: Baixe e instale o Microsoft Visual C++ Build Tools (grátis) no site do Visual Studio ou use o MinGW.

• macOS: Instale as Ferramentas de Linha de Comando do Xcode com xcode-select --install

• Linux: O GCC geralmente já vem instalado; se não estiver, instale-o usando o gerenciador de pacotes.

Depois de instalado, o Nuitka vai detectar automaticamente o seu compilador. Se você tiver problemas, veja se o compilador está instalado no seu sistema PATH.

Convertendo o script de validação com o Nuitka

Vamos converter o mesmo script de validação do Airbnb de Nova York usando o Nuitka, assim como fizemos com o PyInstaller e o auto-py-to-exe. Para compilar nosso script em um executável, execute:

python -m nuitka --onefile --follow-imports --include-package=pandas validation.py

Vamos analisar cada sinalizador:

• --onefile: Cria um único arquivo executável (em vez de um diretório com vários arquivos e dependências)

• --follow-imports: Inclui automaticamente todos os módulos que seu script importa.

• --include-package=pandas: Inclui explicitamente o pacote pandas (alguns pacotes não são detectados automaticamente, então isso garante que ele seja incluído).

Diferente do PyInstaller, que leva só uns 30 segundos, o Nuitka demora bem mais — geralmente de 5 a 15 minutos, dependendo da complexidade do seu código e da velocidade do sistema. Você vai ver a saída da compilação no terminal mostrando o progresso durante a etapa de compilação C.

Quando terminar, você vai ver uma mensagem dizendo que o executável foi criado. O executável compilado é criado no mesmo diretório que o arquivo validation.py.

Clique duas vezes em validation.exe ou execute-o a partir da linha de comando. Uma janela do console vai aparecer pedindo pra você colocar um nome de arquivo, igual ao PyInstaller. Depois de digitar AB_NYC_2019.csve apertar Enter, a validação rola, o console fecha e um novo arquivo validated_ab_nyc_2019.csv é criado no mesmo diretório, igualzinho à versão do PyInstaller.

Método 3: auto-py-to-exe

O primeiro passo para criar um arquivo executável usando o auto-py-to-exe é rodá-lo com o seguinte comando: 

auto-py-to-exe 

Isso deve trazer uma interface gráfica do usuário (GUI) que vai nos ajudar a transformar nosso arquivo Python em um arquivo executável. 

Figura 3: A interface gráfica do usuário voltou depois de rodar o comando auto-py-to-exe. 

Observação: se não estiver funcionando, certifique-se de ter criado um ambiente virtual no diretório auto-py-to-exe e instalado o requirements.txt no seu ambiente virtual usando o seguinte comando: pip install -r requirements.txt.

A interface gráfica tem vários campos que a gente precisa preencher. Vamos dar uma olhada em cada um deles e analisar: 

• Localização específica: Neste campo, você precisa colocar o local do script do arquivo Python que quer transformar em um executável.  
• Onefile: É aqui que você escolhe se quer criar um único diretório ou arquivo. Um único diretório vai ter todas as dependências necessárias para rodar seu script e um arquivo executável, enquanto que escolher “Um arquivo” vai criar um único arquivo executável. 
• Janela do console: A escolha entre uma janela de console “baseada em console” ou “baseada em janela” depende do que o seu script retorna. Por exemplo, o script que criamos acima precisa que o usuário digite um nome de arquivo. Então, a gente recomenda a solução “Baseada em Console”, porque ela abre o console depois de rodar o arquivo executável. Se não precisar mostrar as saídas do console depois de rodar o arquivo executável, então “Baseado em janela” é uma boa opção. 

Também temos outras opções para configurar a criação do nosso arquivo executável (por exemplo, adicionar ícones, arquivos adicionais e muito mais). Nesta seção, também podemos mudar o caminho para onde queremos exportar os arquivos gerados pelo nosso arquivo executável: para fazer isso, selecione a opção “Configurações” e procure o diretório de saída que você quiser. O último passo é escolher “Converter .py para .exe” pra converter nosso arquivo Python. 

Dá uma olhada no GIF da Figura 4 pra ver como a gente configurou nosso arquivo executável. 

Figura 4: Um GIF mostrando como configurar o auto-py-to-exe

Quando voltarmos ao diretório auto-py-to-exe, vai ter um diretório chamado output: é onde fica o nosso arquivo validation.exe. Escolha o arquivo que você quer rodar, e vai aparecer um console pedindo pra você digitar o nome do arquivo:

Figura 5: O console voltou depois de rodar o arquivo de validação executável. 

É só digitar o nome do arquivo – nesse exemplo, AB_NYC_2019.csv – e apertar Enter. Isso vai fechar o console e criar um novo arquivo no diretório de saída (onde fica o arquivo executável) chamado validated_ab_nyc_2019.csv.

PyInstaller x Nuitka

Vejacomo o Nuitka e o PyInstaller se comparam no mesmo script de validação, junto com o auto-py-to-exe como uma alternativa GUI:

O PyInstaller e o Nuitka oferecem suporte confiável para todas as versões modernas do Python, enquanto o auto-py-to-exe tem problemas de compatibilidade conhecidos com o Python 3.11 e versões posteriores. O Nuitka faz executáveis menores e mais rápidos com proteção IP melhor, mas o processo de compilação é tipo 16 vezes mais lento que o PyInstaller.

Conclusão

Neste artigo, você aprendeu: 

• O que é um arquivo Python
• O que é um arquivo executável e por que ele pode ser útil 
• Como transformar um script Python em um executável usando o pyinstaller, que é uma ferramenta ótima pra quem curte mais as operações de linha de comando. 
• Como converter um script Python em um executável usando o auto-py-to-exe, que dá aos usuários uma interface gráfica (GUI) pra configurar como o arquivo executável deve ser criado. 

Saiba mais sobre como você pode usar o Python para fazer ciência de dados no programa DataCamps Associate Data Scientist with Python.