Frameworks Populares em Python

– Python
– Conhecimento Base
0 – Configuracoes
1 – Tipos de Dados
2 – Declaração de Variáveis
3 – Declaração de Constantes
4 – Funções e Módulos
5 – Orientação a Objetos
6 – Módulos e Pacotes
7 – Entrada e Saída
8 – Bibliotecas Integradas – Pypi
9 – Paradgmas de Programação
10 – Frameworks Populares (ecosistema)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

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/<nome>')
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/<nome>')

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.

Indice

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

FastAPI: performance e documentação automática

Pytest e unittest: testes automatizados

Deixe um comentário Cancelar resposta