Arquivo de Python - Página 21 de 236

PyInstaller: a ferramenta mais completa

PyInstaller analisa seu script e coleta todas as dependências. Ele empacota tudo em uma única pasta ou um único arquivo. Primeiro, instale com pip install pyinstaller. Depois, execute: pyinstaller meu_script.py. Isso gera uma pasta dist/meu_script/ com o executável. Para criar um único arquivo, use a flag --onefile. Por exemplo: pyinstaller --onefile meu_script.py. O resultado será um .exe (Windows) ou binário (Linux). Esse arquivo pode ser copiado e executado em qualquer máquina similar. Foi observado que o modo --onefile é mais lento para iniciar. Isso ocorre porque ele extrai os arquivos para uma pasta temporária. Portanto, prefira o modo pasta para aplicações grandes. Além disso, ícones personalizados são adicionados com --icon=meu_icone.ico. Veja um exemplo completo:

# meu_script.py - um programa simples
import sys
from datetime import datetime

def main():
    print("=== Gerador de Saudação ===")
    nome = input("Digite seu nome: ")
    hora = datetime.now().hour
    
    if hora < 12:
        saudacao = "Bom dia"
    elif hora < 18:
        saudacao = "Boa tarde"
    else:
        saudacao = "Boa noite"
    
    print(f"{saudacao}, {nome}!")
    input("Pressione Enter para sair...")

if __name__ == "__main__":
    main()

# meu_script.py - um programa simples

import sys

from datetime import datetime

def main():

print("=== Gerador de Saudação ===")

nome = input("Digite seu nome: ")

hora = datetime.now().hour

if hora < 12:

saudacao = "Bom dia"

elif hora < 18:

saudacao = "Boa tarde"

else:

saudacao = "Boa noite"

print(f"{saudacao}, {nome}!")

input("Pressione Enter para sair...")

if __name__ == "__main__":

main()

Para transformar esse script em executável: pyinstaller --onefile --name Saudador meu_script.py O arquivo Saudador.exe aparecerá na pasta dist/. Esse executável roda em qualquer Windows sem Python instalado. A voz passiva é aplicada: “as dependências são detectadas automaticamente”. Isso inclui bibliotecas como datetime (built-in).

Quando usar cada modo e ferramenta

O modo --onefile é ideal para distribuição simples. Por exemplo, enviar por e-mail ou disponibilizar em um site. O modo pasta é melhor para aplicações grandes com muitos assets. Assim, cada arquivo pode ser atualizado separadamente. Outra ferramenta é o cx_Freeze, mais leve que o PyInstaller. Ele é ótimo para scripts de linha de comando simples. Já o Nuitka compila Python para C, gerando executáveis muito rápidos. Contudo, o tempo de compilação é bem maior. Quando evitar executáveis? Em projetos com muitas dependências dinâmicas. Por exemplo, pacotes que carregam plugins via importlib. O PyInstaller pode não detectar essas importações ocultas. Nesse caso, use o hook manual ou o modo --hidden-import. Foi observado que antivírus falsamente detectam executáveis PyInstaller. Isso acontece devido à técnica de empacotamento (bytecode). Portanto, assine digitalmente seu executável para maior confiança.

Dicas práticas e resolução de problemas

Teste seu executável em uma máquina limpa (sem Python). Use --debug para ver logs detalhados de erro. Muitos problemas surgem por caminhos de arquivos incorretos. No código, use sys._MEIPASS para acessar arquivos extras. Isso funciona apenas no PyInstaller. Exemplo de acesso a um arquivo de configuração:

import sys
import os

def resource_path(relative_path):
    """Retorna o caminho correto para arquivos extras."""
    try:
        base_path = sys._MEIPASS
    except AttributeError:
        base_path = os.path.abspath(".")
    return os.path.join(base_path, relative_path)

# Uso
caminho_config = resource_path("config.json")

import sys

import os

def resource_path(relative_path):

"""Retorna o caminho correto para arquivos extras."""

try:

base_path = sys._MEIPASS

except AttributeError:

base_path = os.path.abspath(".")

return os.path.join(base_path, relative_path)

# Uso

caminho_config = resource_path("config.json")

Inclua arquivos adicionais com --add-data "config.json;." (Windows). No Linux ou macOS, use dois pontos: --add-data "config.json:.". Outra dica: reduza o tamanho do executável com --exclude-module. Exclua bibliotecas grandes e não utilizadas (ex: matplotlib, pandas). A fórmula para estimar o tempo de inicialização é complexa: \(T_{\text{inicial}} \approx T_{\text{extração}} + T_{\text{importação}}\). Por fim, lembre-se: executáveis não são código-fonte seguro. Um engenheiro reverso pode extrair seu .pyc com ferramentas. Portanto, use ofuscação adicional para proteção comercial. Mas para a maioria dos casos, o PyInstaller é mais que suficiente. Comece hoje mesmo transformando seus scripts em aplicações standalone!

– Python
– Distribuicao e Empacotamento
1 – Criar Executaveis
3 – Multiplataforma
2 – Criar Instaladores

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Empacotamento é o processo de organizar código em pacotes reutilizáveis. Distribuição significa publicar esses pacotes para outras pessoas. Primeiramente, um pacote Python é uma pasta com um arquivo __init__.py. Esse arquivo pode estar vazio ou conter código de inicialização. Além disso, usamos o setuptools para criar pacotes distribuíveis. O arquivo setup.py descreve metadados como nome e versão. Quando utilizar empacotamento? Sempre que seu código for reutilizado em múltiplos projetos. Por exemplo, uma biblioteca de validação ou utilitários matemáticos. A voz passiva é usada aqui: “as dependências são listadas no install_requires“. Portanto, o empacotamento evita copiar e colar arquivos manualmente. Também facilita o controle de versões e a instalação via pip. Outra ferramenta moderna é o pyproject.toml (PEP 621). Ela substitui setup.py com uma sintaxe mais simples e declarativa. Vamos explorar os principais conceitos passo a passo.

Estrutura básica de um pacote

Um pacote bem estruturado segue uma convenção clara. Crie uma pasta principal com o nome do seu projeto. Dentro dela, coloque um arquivo __init__.py (pode ser vazio). Adicione seus módulos .py ao lado desse arquivo. Por exemplo, meu_pacote/calculadora.py contendo funções matemáticas. Fora da pasta, crie setup.py ou pyproject.toml. Também é comum incluir README.md, LICENSE e tests/. A estrutura mínima se parece com isto:

meu_projeto/
├── meu_pacote/
│   ├── __init__.py
│   └── core.py
├── tests/
│   └── test_core.py
├── setup.py
└── README.md

meu_projeto/

├── meu_pacote/

│ ├── __init__.py

│ └── core.py

├── tests/

│ └── test_core.py

├── setup.py

└── README.md

Essa organização é reconhecida pelo setuptools e pelo pip. Quando usar essa estrutura? Em qualquer biblioteca que você planeja publicar. Mesmo pacotes internos de empresas se beneficiam dela. Foi observado que projetos sem empacotamento viram “spaguetti code”. Portanto, invista meia hora para estruturar corretamente desde o início.

Criando e instalando com setup.py

O arquivo setup.py é o coração do empacotamento tradicional. Ele usa a função setup() do módulo setuptools. Você define nome, versão, autor e dependências. Um exemplo típico contém os seguintes parâmetros:

# setup.py
from setuptools import setup, find_packages

setup(
    name="meu_pacote",
    version="0.1.0",
    author="Seu Nome",
    description="Um pacote exemplo",
    packages=find_packages(),
    install_requires=[
        "requests>=2.25.0",
        "numpy",
    ],
    python_requires=">=3.8",
)

# setup.py

from setuptools import setup, find_packages

setup(

name="meu_pacote",

version="0.1.0",

author="Seu Nome",

description="Um pacote exemplo",

packages=find_packages(),

install_requires=[

"requests>=2.25.0",

"numpy",

python_requires=">=3.8",

)

Após criar esse arquivo, instale o pacote em modo desenvolvimento: pip install -e . O flag -e significa editável – mudanças no código refletem imediatamente. Para gerar um arquivo distribuível (wheel), execute: python setup.py bdist_wheel O arquivo .whl será criado na pasta dist/. Esse wheel pode ser instalado com pip install meu_pacote-0.1.0-py3-none-any.whl. A voz passiva é aplicada: “o wheel é gerado com o comando acima”. Assim, você pode compartilhar o binário sem enviar o código-fonte. Contudo, para pacotes abertos, prefira publicar no PyPI (Python Package Index).

Publicando no PyPI e usando pyproject.toml

O PyPI é o repositório oficial de pacotes Python. Publicar nele permite instalação com pip install seu_pacote. Primeiro, crie uma conta em pypi.org e obtenha um token de API. Depois, instale twine com pip install twine. Envie seu pacote com twine upload dist/*. Mas atenção: a ferramenta moderna recomenda pyproject.toml. Esse arquivo unifica configurações de build, lint e testes. Um exemplo mínimo de pyproject.toml:

[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"

[project]
name = "meu_pacote"
version = "0.1.0"
description = "Exemplo com pyproject.toml"
authors = [{name = "Seu Nome", email = "email@exemplo.com"}]
dependencies = ["requests>=2.25.0"]
requires-python = ">=3.8"

[build-system]

requires = ["setuptools>=61.0"]

build-backend = "setuptools.build_meta"

[project]

name = "meu_pacote"

version = "0.1.0"

description = "Exemplo com pyproject.toml"

authors = [{name = "Seu Nome", email = "email@exemplo.com"}]

dependencies = ["requests>=2.25.0"]

requires-python = ">=3.8"

Com esse arquivo, não precisa mais de setup.py. Execute python -m build para gerar os distributíveis. O comando cria pastas dist/ e build/ automaticamente. Quando usar pyproject.toml? Em todos os projetos novos. Ele é o padrão da comunidade e será o futuro do empacotamento. Por fim, lembre-se de versionar seu pacote semanticamente. Use \(\text{versão} = \text{major.minor.patch}\) conforme a especificação. Isso ajuda usuários a saber se há mudanças que quebram compatibilidade. Distribuir bem seu código é um ato de generosidade com a comunidade. Comece hoje mesmo a empacotar suas próprias bibliotecas!

Criar Executáveis em Python