.jpg)
Seja muito bem-vindo à Academy Code Christ!
🌍 Academy Code Christ está disponível em vários idiomas.Fique à vontade para usar o tradutor na Barra lateral (Sidebar) e aprender no seu idioma.
Python 🐍 Etapa 14
Boas Práticas no Desenvolvimento Python
%20-%20Copia.png)
.png)
💻 Pratique o que você aprende
.png)
🎯 Por que publicar e testar seu código?
Um código que funciona não é necessariamente um código pronto
para o mundo real.
Aplicações maduras exigem que o desenvolvedor garanta três elementos principais:
1. Confiabilidade → o sistema deve funcionar mesmo após mudanças.
2. Manutenibilidade → o código precisa ser fácil de entender e evoluir.
3. Distribuição → deve poder ser instalado e executado por qualquer pessoa.
Testes, documentação e empacotamento são os três pilares que garantem esses objetivos.
Organizando a estrutura final de um projeto
Uma estrutura padronizada facilita o trabalho em equipe e uso de ferramentas:
meuprojeto/
│
├── meuprojeto/
│ ├── __init__.py
│ ├── modulo1.py
│ ├── modulo2.py
│
├── tests/
│ ├── test_modulo1.py
│
├── data/
│ ├── exemplos.json
│
├── requirements.txt
├── README.md
├── setup.py
└── main.py
Explicação:
● meuprojeto/ → pacote principal (contém o código fonte).
● tests/ → scripts de teste automatizado.
● data/ → arquivos de entrada e saída opcionais.
● requirements.txt → lista das dependências do projeto.
● setup.py → arquivo para empacotamento e instalação via pip.
● main.py → ponto de entrada (inicializador da aplicação).
Documentando o projeto
A documentação é a base de um código compreensível.
O arquivo principal da documentação é o README.md, comum em repositórios GitHub.
Exemplo de estrutura de README:
# Sistema de Cadastro de Clientes
**Descrição:**
Aplicação Python que gerencia o cadastro de clientes, permitindo inserção, listagem e atualização de registros com integração SQLite.
## Instalação
1. Clone o repositório:
git clone https://github.com/usuario/cadastro-clientes.git
2. Instale as dependências:
pip install -r requirements.txt
## Uso
python main.py
## Tecnologias
- Python 3.12+
- SQLite
- Pandas
Um bom README deve conter:
● Descrição do propósito.
● Instruções de instalação.
● Exemplos de uso.
● Créditos ou licenças.
Documentando funções e classes com docstrings
Dentro do código, use docstrings para explicar o funcionamento de funções e classes.
def calcular_media(lista):
"""
Calcula a média aritmética de uma lista de números.
Parâmetros:
lista (list): Conjunto de números reais.
Retorna:
float: A média dos valores.
"""
return sum(lista) / len(lista)
Você pode exibir essas descrições no console:
help(calcular_media)
Boas práticas de código (PEP 8)
PEP 8 é o Guia de Estilo Oficial do Python.
Algumas regras essenciais:
|
Convenção |
Exemplo |
|
Nomes de variáveis em minúsculas |
idade_usuario |
|
Classes usam CamelCase |
class PessoaFisica: |
|
4 espaços por indentação (sem tabulação) |
Consistência visual |
|
Limite máximo de 79 caracteres por linha |
Facilita leitura em telas pequenas |
|
Use linhas em branco entre funções e classes |
Melhora legibilidade |
Ferramentas que ajudam na checagem:
● flake8
● pylint
● black (formata automaticamente)
Instalando:
pip install flake8 black
Executando:
flake8 meuprojeto/
black meuprojeto/
Gerenciando dependências (requirements)
Registre todas as bibliotecas usadas num arquivo requirements.txt:
pandas==2.2.0
matplotlib==3.8.2
seaborn==0.13.0
sqlite3
Assim, qualquer pessoa pode instalar todas as dependências com um único comando:
pip install -r requirements.txt
O que são testes automatizados?
Testes automatizados verificam se o código faz o que deveria sem precisar de intervenção manual.
Eles evitam regressões e garantem a
consistência após alterações.
Tipos principais:
|
Tipo |
Propósito |
|
Unidade (unit tests) |
Testam funções ou métodos individuais. |
|
Integração |
Checam a interação entre componentes. |
|
Funcional |
Validam o comportamento completo do software. |
Criando testes com unittest
O Python já vem com o módulo unittest, simples e poderoso.
Exemplo:
arquivo → calculadora.py
def somar(a, b):
return a + b
def dividir(a, b):
if b == 0:
raise ValueError("Divisão por zero!")
return a / b
arquivo → tests/test_calculadora.py
import unittest
from calculadora import somar, dividir
class TestCalculadora(unittest.TestCase):
def test_soma(self):
self.assertEqual(somar(2, 3), 5)
def test_divisao(self):
self.assertAlmostEqual(dividir(9, 3), 3)
def test_divisao_por_zero(self):
with self.assertRaises(ValueError):
dividir(10, 0)
if __name__ == "__main__":
unittest.main()
Para executar:
python -m unittest discover
Saída esperada:
...
----------------------------------------------------------------------
Ran 3 tests in 0.002s
OK
Testes com Pytest (framework mais moderno)
Instale:
pip install pytest
Exemplo simplificado:
from calculadora import somar
def test_soma():
assert somar(5, 5) == 10
E execute:
pytest
Pytest descobre e executa automaticamente os arquivos de teste.
Gerando relatórios de cobertura de testes
A cobertura de testes mostra quantas linhas do seu código foram testadas.
Instalando:
pip install coverage
Executando:
coverage run -m pytest
coverage report -m
Exemplo de saída:
Name Stmts Miss Cover
-----------------------------------------
calculadora.py 6 0 100%
Logs e depuração
Manter registros de log ajuda a depurar erros e entender o comportamento em produção.
import logging
logging.basicConfig(
filename="app.log",
level=logging.INFO,
format="%(asctime)s - %(levelname)s - %(message)s"
)
logging.info("Aplicação iniciada.")
logging.warning("Arquivo não encontrado.")
logging.error("Falha ao salvar dados.")
O arquivo app.log será atualizado automaticamente.
Controle de versão com Git
O Git é indispensável em qualquer fluxo de desenvolvimento moderno.
Comandos essenciais:
git init
git add .
git commit -m "primeira versão"
git branch nova-funcionalidade
git checkout nova-funcionalidade
git merge main
E publicar no GitHub:
git remote add origin https://github.com/usuario/repositorio.git
git push -u origin main
Recomendação: faça commits frequentes e descritivos.
Virtual Environments (ambientes isolados)
Ambientes virtuais isolam pacotes de diferentes projetos.
Crie e ative:
Windows
python -m venv venv
venv\Scripts\activate
Linux / Mac
python3 -m venv venv
source venv/bin/activate
Tudo que for instalado via pip ficará restrito àquele ambiente.
Empacotando projetos com setuptools
Com setup.py, seu programa pode ser instalado como pacote local.
from setuptools import setup, find_packages
setup(
name="meuprojeto",
version="1.0.0",
author="Seu Nome",
description="Sistema de gestão simples em Python.",
packages=find_packages(),
install_requires=["pandas", "matplotlib"],
)
Instale o próprio projeto:
pip install .
Seu pacote poderá ser importado de qualquer parte do sistema!
Publicando no PyPI (Python Package Index)
Deseja tornar seu projeto público para o mundo?
Siga esse fluxo:
Instale as ferramentas:
pip install twine build
Gere os arquivos:
python -m build
Envie para o PyPI (necessário conta):
twine upload dist/*
Agora qualquer pessoa poderá instalar:
pip install meuprojeto
Automatizando testes e deploy (CI/CD)
Para projetos maiores, é comum usar Integração Contínua
(CI) —
um automatizador (como GitHub Actions)
que roda testes automaticamente a cada atualização.
Exemplo básico de workflow (.github/workflows/tests.yml):
name: Testes Automáticos
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Instalar Python
uses: actions/setup-python@v5
with:
python-version: "3.12"
- name: Instalar dependências
run: pip install -r requirements.txt
- name: Rodar testes
run: pytest
Licenciamento e compartilhamento
Antes de compartilhar seu código, defina uma licença.
Arquivos como LICENSE deixam claro o que é permitido.
Exemplo – Licença MIT (simples e permissiva)
MIT License
Copyright (c) 2024 Seu Nome
Permission is hereby granted, free of charge, to any person obtaining a copy...
Você também pode disponibilizar o projeto em plataformas como:
● GitHub
● GitLab
Mini‑projeto prático: empacotando e testando uma
biblioteca simples
Estrutura:
conversor/
│
├── conversor/
│ ├── __init__.py
│ └── moeda.py
│
├── tests/
│ └── test_moeda.py
│
├── setup.py
└── README.md
moeda.py
def real_para_dolar(valor, taxa=5.0):
"""Converte reais em dólares."""
return round(valor / taxa, 2)
test_moeda.py
from conversor.moeda import real_para_dolar
def test_conversao():
assert real_para_dolar(10, 5) == 2.0
setup.py
from setuptools import setup, find_packages
setup(
name="conversor",
version="0.1",
packages=find_packages(),
)
Use pytest e depois instale localmente:
pip install .
Agora você pode usar em qualquer script:
from conversor.moeda import real_para_dolar
print(real_para_dolar(50, 4.9))
Boas práticas
✅
Escreva código limpo e autoexplicativo.
✅ Faça commits pequenos e frequentes.
✅ Documente cada função e módulo.
✅ Automatize testes e mantenha cobertura
alta.
✅ Use ambientes virtuais e requirements.txt.
✅ Divulgue e compartilhe suas criações —
colaboração é crescimento.
✅ Nunca pare de refatorar e aprender.
Resumo
Nesta etapa, você consolidou conhecimentos voltados ao ciclo completo de software profissional:
● Organização e documentação de projetos.
● Criação e automação de testes.
● Controle de qualidade e estilo (PEP 8).
● Uso de Git e ambientes virtuais.
● Empacotamento e publicação no PyPI.
● Entendimento dos mecanismos de integração contínua (CI/CD).
Agora você possui o arsenal técnico completo para desenvolver, testar e distribuir qualquer aplicação Python, seja para uso pessoal, acadêmico ou empresarial.
Você caminhou desde os fundamentos até a produção real.
1. Lógica e sintaxe do Python
2. Estruturas e funções
3. POO e modularização
4. Manipulação de dados e arquivos
5. Bancos de dados e SQL
6. Testes, empacotamento e publicação
A partir daqui, as possibilidades são infinitas: automações, web apps com Flask ou Django, data science, inteligência artificial, APIs e muito mais!
Continue praticando, versionando e criando — e nunca pare de aprender.
.png)
.png)
Postar um comentário