antonino, Autor em Área de Trampo

Categorias

Um framework é uma estrutura pronta para construir aplicações. Ele fornece componentes reutilizáveis e convenções predefinidas. Assim, você foca na lógica do negócio, não nos detalhes técnicos. Primeiramente, Python possui frameworks para web, dados e testes. Por exemplo, Django, Flask, FastAPI, Pandas e Pytest. Cada um resolve problemas diferentes com abordagens distintas. A escolha certa economiza meses de trabalho e evita retrabalho. Além disso, frameworks impõem boas práticas e segurança. A voz passiva é usada aqui: “as rotas são definidas com decoradores”. Portanto, conhecer os principais é essencial para qualquer dev. Neste guia, exploraremos três categorias essenciais. Vamos começar pelos gigantes do desenvolvimento web. Depois veremos APIs e, por fim, automação de testes. Cada exemplo mostrará um trecho funcional em Python.

Django e Flask: web apps completos vs. microsserviços

Django é um framework full-stack “baterias incluídas”. Ele traz ORM, autenticação, admin e formulários prontos. Quando usar Django? Em projetos grandes e monolíticos. Por exemplo, e-commerces, portais ou sistemas internos. Sua curva de aprendizado é íngreme, mas recompensa com velocidade. Por outro lado, Flask é minimalista e flexível. Ele fornece apenas o essencial para rotas e requisições. Use Flask em microsserviços, APIs simples ou protótipos. A extensão é feita via bibliotecas externas escolhidas por você. Isso dá controle total, mas exige mais decisões. Foi observado que iniciantes preferem Flask pela simplicidade. Já empresas consolidadas adotam Django pela produtividade. Ambos suportam templates, mas Django tem o próprio sistema. Veja um exemplo mínimo com Flask:

# Flask - framework minimalista
from flask import Flask
app = Flask(__name__)
@app.route('/')
def ola():
    return 'Olá, mundo!'
@app.route('/user/')
def saudacao(nome):
    return f'Bem-vindo, {nome}!'
if __name__ == '__main__':
    app.run(debug=True)

# Flask - framework minimalista

from flask import Flask

app = Flask(__name__)

@app.route('/')

def ola():

return 'Olá, mundo!'

@app.route('/user/')

def saudacao(nome):

return f'Bem-vindo, {nome}!'

if __name__ == '__main__':

app.run(debug=True)

Esse servidor já responde em http://localhost:5000. Já o Django exigiria projetos, apps e configurações. Portanto, escolha Flask para rapidez e Django para estrutura.

FastAPI: performance e documentação automática

FastAPI é o framework moderno para APIs REST. Ele é assíncrono e extremamente rápido (como Node.js ou Go). A principal vantagem é a documentação interativa automática. O Swagger UI é gerado diretamente das anotações de tipo. Quando utilizar FastAPI? Em projetos que exigem alta performance. Por exemplo, microsserviços de dados em tempo real. Também é ótimo para integrações com machine learning. A validação de dados é feita com modelos Pydantic. Isso reduz bugs de tipo e facilita a manutenção. A voz passiva é aplicada: “os parâmetros são validados automaticamente”. Além disso, suporta WebSockets e background tasks nativamente. Comparado ao Flask, FastAPI é mais moderno e rápido. Porém, a curva de aprendizado inclui conceitos assíncronos. Veja um exemplo simples de API com FastAPI:

# FastAPI - assíncrono com documentação automática
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
    nome: str
    preco: float
@app.get('/')
def raiz():
    return {'mensagem': 'API funcionando'}
@app.post('/itens/')
def criar_item(item: Item):
    return {'item_recebido': item.nome, 'preco': item.preco}

# FastAPI - assíncrono com documentação automática

from fastapi import FastAPI

from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):

nome: str

preco: float

@app.get('/')

def raiz():

return {'mensagem': 'API funcionando'}

@app.post('/itens/')

def criar_item(item: Item):

return {'item_recebido': item.nome, 'preco': item.preco}

Execute com uvicorn main:app --reload e acesse /docs. Você verá uma interface pronta para testar sua API. Isso é perfeito para equipes que precisam de documentação viva.

Pytest e unittest: testes automatizados

Testes são parte fundamental de qualquer software profissional. Frameworks como Pytest e unittest organizam e executam testes. O unittest é built-in e inspirado no JUnit (Java). Já o Pytest é mais simples, poderoso e amplamente adotado. Quando usar unittest? Em projetos que exigem zero dependências externas. Porém, a maioria prefere Pytest pela sintaxe limpa e fixtures. Com Pytest, você escreve funções com assert direto. Não precisa de classes ou métodos especiais. A voz passiva é vista: “os testes são descobertos automaticamente”. Isso economiza tempo e reduz boilerplate. Use frameworks de teste sempre que o código for além de scripts pessoais. Eles previnem regressões e documentam o comportamento esperado. Veja um exemplo comparativo:

# Pytest - mais simples e legível
def soma(a, b):
    return a + b
def test_soma_positivos():
    assert soma(2, 3) == 5
def test_soma_negativos():
    assert soma(-1, -4) == -5
# Para rodar: pytest nome_do_arquivo.py
# unittest - estilo mais verboso (built-in)
import unittest
class TestSoma(unittest.TestCase):
    def test_positivos(self):
        self.assertEqual(soma(2, 3), 5)
if __name__ == '__main__':
    unittest.main()

# Pytest - mais simples e legível

def soma(a, b):

return a + b

def test_soma_positivos():

assert soma(2, 3) == 5

def test_soma_negativos():

assert soma(-1, -4) == -5

# Para rodar: pytest nome_do_arquivo.py

# unittest - estilo mais verboso (built-in)

import unittest

class TestSoma(unittest.TestCase):

def test_positivos(self):

self.assertEqual(soma(2, 3), 5)

if __name__ == '__main__':

unittest.main()

Pytest exige menos código e é mais expressivo. Além disso, ele mostra detalhes ricos quando um teste falha. Por fim, lembre-se: nenhum framework é bala de prata. Avalie seu projeto, equipe e requisitos antes de decidir. Mas dominar esses três já cobre 80% dos cenários profissionais.

Paradigma imperativo e procedural

O paradigma imperativo descreve o programa como sequência de comandos. Ele foca em "como fazer" passo a passo. Variáveis, loops e condicionais são seus blocos básicos. Quando usar? Em scripts simples e algoritmos diretos. Por exemplo, calcular a média de uma lista de números. A programação procedural é uma evolução do imperativo. Ela organiza o código em funções reutilizáveis. Isso evita repetição e melhora a legibilidade. Foi observado que C e Python inicial seguem esse estilo. A principal vantagem é a clareza para iniciantes. Contudo, projetos grandes ficam confusos sem objetos. Portanto, use o imperativo para roteiros curtos. E prefira o procedural quando há lógica repetitiva. Veja um exemplo de estilo procedural em Python:

# Paradigma procedural (imperativo estruturado) def calcular_media(numeros): soma = 0 for n in numeros: soma += n return soma / len(numeros) def main(): dados = [10, 20, 30, 40] media = calcular_media(dados) print(f"Média: {media}") main()

No código, as funções organizam a lógica em etapas. Não há objetos nem herança, apenas dados e funções. Esse estilo é ótimo para processamento de dados linear. Além disso, é fácil de testar cada função isoladamente.

Paradigma orientado a objetos

A orientação a objetos organiza o código em entidades. Cada objeto contém dados (atributos) e comportamentos (métodos). Esse paradigma favorece a reutilização e o encapsulamento. Quando utilizar? Em sistemas complexos com muitas entidades. Por exemplo, jogos, interfaces gráficas ou simuladores. Herança permite criar hierarquias de classes especializadas. Polimorfismo trata objetos diferentes de forma uniforme. A voz passiva é aplicada: "o estado interno é protegido por encapsulamento". Assim, mudanças locais não afetam o resto do sistema. Isso é crucial em equipes grandes e projetos longos. Porém, a sobrecarga de planejar classes pode ser excessiva. Então, evite OO para scripts pequenos ou cálculos puros. Veja um exemplo de classe em Python:

class Retangulo: def __init__(self, largura, altura): self.largura = largura self.altura = altura def area(self): return self.largura * self.altura def perimetro(self): return 2 * (self.largura + self.altura) r = Retangulo(5, 3) print(f"Área: {r.area()}, Perímetro: {r.perimetro()}")

Aqui, o retângulo é um objeto com dados e operações. Podemos criar vários retângulos independentes facilmente. Isso mostra como a OO modela o mundo real.

Paradigma funcional

O paradigma funcional evita estado mutável e efeitos colaterais. Ele trata a computação como avaliação de funções matemáticas. Funções são de primeira classe e podem ser passadas como argumentos. Quando usar? Em processamento de dados em pipelines. Por exemplo, transformações de listas com map e filter. Também é excelente para sistemas concorrentes. Isso ocorre porque não há variáveis compartilhadas. A fórmula da composição de funções é: \((f \circ g)(x) = f(g(x))\). Portanto, cada função produz a mesma saída para a mesma entrada. Isso facilita testes e raciocínio sobre o código. Python suporta funcional com lambda, map, filter e reduce. No entanto, não é puramente funcional como Haskell. Use o funcional quando a imutabilidade traz benefícios claros. Por exemplo, análise de dados ou expressões regulares. Evite-o quando houver muitas interações com I/O ou estado global. Veja um exemplo funcional em Python:

# Paradigma funcional com funções puras from functools import reduce numeros = [1, 2, 3, 4, 5] # Mapear: dobro de cada número dobros = list(map(lambda x: x * 2, numeros)) # Filtrar: apenas pares pares = list(filter(lambda x: x % 2 == 0, numeros)) # Reduzir: soma total soma = reduce(lambda a, b: a + b, numeros) print(f"Dobros: {dobros}") # [2,4,6,8,10] print(f"Pares: {pares}") # [2,4] print(f"Soma: {soma}") # 15

Nesse código, nenhuma variável é alterada após criada. Cada função transforma uma lista em outra lista nova. Isso é declarativo: dizemos "o que" fazer, não "como". Por fim, lembre-se: paradigmas são ferramentas complementares. Misturá-los bem é a chave para software de qualidade. Python permite essa mistura de forma natural e poderosa.

Frameworks Populares em Python