Arquivo de Python - Página 22 de 240

– Web
1 – Backend (servidor)
1.1 – Sincrono (Django, Flask, FastAPI)
1.2 – Assincrono (FastAPI, Sanic, Aiohttp)
1.3 – WebSockets (Socket.IO, WebSockets)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

WebSockets mantêm uma conexão aberta entre cliente e servidor. Diferente do HTTP, os dados trafegam nas duas direções livremente. Primeiramente, isso permite atualizações instantâneas sem recarregar a página. Por exemplo, chats, notificações ou jogos online usam essa tecnologia. O servidor pode enviar mensagens ao cliente a qualquer momento. Além disso, a latência é muito menor que requisições HTTP tradicionais. A voz passiva é usada aqui: “uma única conexão TCP é estabelecida e mantida”. Quando utilizar WebSockets? Em aplicações que exigem tempo real. Dashboards de monitoramento, colaboração simultânea ou streaming de dados. Duas abordagens principais existem no ecossistema Python. WebSockets puros (RFC 6455) e Socket.IO (biblioteca com fallbacks). Vamos explorar ambas com exemplos práticos. Escolha a que melhor se adapta ao seu projeto.

Websockets puros: leve e nativo

WebSockets puros seguem o padrão oficial da web. Eles são suportados por todos os navegadores modernos. Em Python, a biblioteca websockets é a mais madura. Quando usar WebSockets puros? Em projetos que exigem baixo overhead. Também quando você controla tanto cliente quanto servidor. A desvantagem é a falta de fallback para conexões antigas. Além disso, não há reconexão automática ou salas prontas. A voz passiva é aplicada: “os eventos são tratados com funções assíncronas”. Um exemplo de servidor WebSocket puro com websockets:

import asyncio
import websockets
from datetime import datetime

async def enviar_horario(websocket, path):
    """Envia a hora atual a cada segundo."""
    try:
        while True:
            mensagem = f"Horário: {datetime.now().strftime('%H:%M:%S')}"
            await websocket.send(mensagem)
            await asyncio.sleep(1)
    except websockets.exceptions.ConnectionClosed:
        print("Cliente desconectado")

async def main():
    async with websockets.serve(enviar_horario, "localhost", 8765):
        print("Servidor WebSocket rodando em ws://localhost:8765")
        await asyncio.Future()  # Roda para sempre

if __name__ == "__main__":
    asyncio.run(main())

import asyncio

import websockets

from datetime import datetime

async def enviar_horario(websocket, path):

"""Envia a hora atual a cada segundo."""

try:

while True:

mensagem = f"Horário: {datetime.now().strftime('%H:%M:%S')}"

await websocket.send(mensagem)

await asyncio.sleep(1)

except websockets.exceptions.ConnectionClosed:

print("Cliente desconectado")

async def main():

async with websockets.serve(enviar_horario, "localhost", 8765):

print("Servidor WebSocket rodando em ws://localhost:8765")

await asyncio.Future() # Roda para sempre

if __name__ == "__main__":

asyncio.run(main())

Para testar, abra o console do navegador e digite: let ws = new WebSocket("ws://localhost:8765"); ws.onmessage = (e) => console.log(e.data); O servidor enviará a hora atualizada a cada segundo. Isso é WebSocket puro: simples, rápido e eficiente.

Socket.IO: alto nível e robusto

Socket.IO é uma biblioteca que emula WebSockets com fallbacks. Se WebSocket não estiver disponível, usa polling HTTP ou outras técnicas. Além disso, oferece reconexão automática e salas de conversa. Quando usar Socket.IO? Em aplicações que precisam de confiabilidade máxima. Também quando você quer funcionalidades prontas como broadcasts. A desvantagem é o overhead extra e a necessidade de cliente específico. O servidor Python python-socketio é fácil de integrar com Flask ou FastAPI. Exemplo de servidor Socket.IO com Flask:

from flask import Flask, render_template
from flask_socketio import SocketIO, emit, send
import time

app = Flask(__name__)
app.config['SECRET_KEY'] = 'segredo!'
socketio = SocketIO(app, cors_allowed_origins="*")

@socketio.on('mensagem_cliente')
def handle_mensagem(data):
    print(f"Recebido: {data}")
    # Envia para todos os clientes conectados
    emit('resposta_servidor', f"Eco: {data}", broadcast=True)

@socketio.on('ping')
def handle_ping():
    emit('pong', {'timestamp': time.time()})

if __name__ == '__main__':
    socketio.run(app, host='0.0.0.0', port=5000, debug=True)

from flask import Flask, render_template

from flask_socketio import SocketIO, emit, send

import time

app = Flask(__name__)

app.config['SECRET_KEY'] = 'segredo!'

socketio = SocketIO(app, cors_allowed_origins="*")

@socketio.on('mensagem_cliente')

def handle_mensagem(data):

print(f"Recebido: {data}")

# Envia para todos os clientes conectados

emit('resposta_servidor', f"Eco: {data}", broadcast=True)

@socketio.on('ping')

def handle_ping():

emit('pong', {'timestamp': time.time()})

if __name__ == '__main__':

socketio.run(app, host='0.0.0.0', port=5000, debug=True)

No lado cliente, você precisa incluir a biblioteca socket.io.js. Depois, conecte com io.connect('http://localhost:5000'). Socket.IO gerencia automaticamente a reconexão se o servidor cair. Isso é excelente para aplicações móveis ou redes instáveis.

Comparação direta e critérios de escolha

WebSockets puros são melhores para desempenho máximo. Eles têm menor latência e menos tráfego de controle. Socket.IO é superior em confiabilidade e facilidade de uso. A fórmula da taxa de sucesso em redes ruins: \(S = \frac{C_{\text{sucesso}}}{C_{\text{total}}} \times 100\%\) Socket.IO atinge valores maiores em conexões instáveis. Portanto, para intranet ou redes controladas, prefira WebSockets puros. Para aplicações públicas na internet, Socket.IO é mais seguro. Ambos são assíncronos e integram bem com FastAPI ou Aiohttp. Um exemplo de cliente WebSocket puro em Python:

import asyncio
import websockets

async def cliente():
    uri = "ws://localhost:8765"
    async with websockets.connect(uri) as websocket:
        await websocket.send("Olá servidor!")
        resposta = await websocket.recv()
        print(f"Resposta: {resposta}")

asyncio.run(cliente())

import asyncio

import websockets

async def cliente():

uri = "ws://localhost:8765"

async with websockets.connect(uri) as websocket:

await websocket.send("Olá servidor!")

resposta = await websocket.recv()

print(f"Resposta: {resposta}")

asyncio.run(cliente())

Já para Socket.IO cliente em Python, use python-socketio[client]. A escolha final depende da sua tolerância a complexidade. Comece com WebSockets puros se você controla o ambiente. Migre para Socket.IO se encontrar problemas de conectividade. Ambos são ferramentas poderosas para o arsenal do desenvolvedor. Implemente seu primeiro chat em tempo real ainda hoje!

FastAPI: o mais popular e completo

FastAPI é assíncrono por padrão, mas aceita funções síncronas. Ele é construído sobre o Starlette e usa Pydantic para validação. Sua maior força é a documentação automática (Swagger e ReDoc). Além disso, é extremamente rápido, comparável ao Node.js e Go. Quando usar FastAPI? Em APIs REST, microsserviços e projetos novos. Ele tem suporte nativo a WebSockets e background tasks. A curva de aprendizado é suave para quem conhece Flask. A voz passiva é aplicada: “as dependências são resolvidas de forma assíncrona”. Um exemplo simples de endpoint assíncrono:

from fastapi import FastAPI
import httpx
import asyncio

app = FastAPI()

@app.get('/dados-assincronos')
async def buscar_dados():
    async with httpx.AsyncClient() as cliente:
        # Chamada assíncrona: não bloqueia
        resposta1 = await cliente.get('https://api1.example.com/dados')
        resposta2 = await cliente.get('https://api2.example.com/status')
    
    return {
        'api1': resposta1.json(),
        'api2': resposta2.json()
    }

# Rode com: uvicorn main:app --reload

from fastapi import FastAPI

import httpx

import asyncio

app = FastAPI()

@app.get('/dados-assincronos')

async def buscar_dados():

async with httpx.AsyncClient() as cliente:

# Chamada assíncrona: não bloqueia

resposta1 = await cliente.get('https://api1.example.com/dados')

resposta2 = await cliente.get('https://api2.example.com/status')

return {

'api1': resposta1.json(),

'api2': resposta2.json()

}

# Rode com: uvicorn main:app --reload

As duas chamadas rodam de forma concorrente? Não exatamente. Elas ainda são sequenciais (uma após a outra). Para paralelismo real, use asyncio.gather(). FastAPI lida com milhares de conexões simultâneas facilmente.

Sanic: o veterano da velocidade

Sanic foi criado especificamente para ser rápido e assíncrono. Ele lembra o Flask na sintaxe, mas roda sobre asyncio. Quando usar Sanic? Em projetos que exigem máxima performance bruta. Por exemplo, servidores de jogos ou streaming de dados. Sanic suporta workers múltiplos e é estável há anos. Porém, sua comunidade é menor que a do FastAPI. A documentação é boa, mas menos abrangente. Uma vantagem é o servidor embutido pronto para produção. Não precisa de Gunicorn ou Uvicorn separados. Veja um exemplo de Sanic assíncrono:

from sanic import Sanic
from sanic.response import json
import asyncio

app = Sanic("MeuAppAssincrono")

@app.route("/slow")
async def endpoint_lento(request):
    await asyncio.sleep(2)  # Simula I/O
    return json({"mensagem": "Processado após 2 segundos"})

@app.route("/fast")
async def endpoint_rapido(request):
    return json({"mensagem": "Resposta imediata"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, workers=4)

from sanic import Sanic

from sanic.response import json

import asyncio

app = Sanic("MeuAppAssincrono")

@app.route("/slow")

async def endpoint_lento(request):

await asyncio.sleep(2) # Simula I/O

return json({"mensagem": "Processado após 2 segundos"})

@app.route("/fast")

async def endpoint_rapido(request):

return json({"mensagem": "Resposta imediata"})

if __name__ == "__main__":

app.run(host="0.0.0.0", port=8000, workers=4)

Enquanto /slow dorme, outras requisições são atendidas. O event loop do Sanic gerencia isso automaticamente. Isso é o poder do assíncrono: nenhum bloqueio desnecessário.

Aiohttp: o framework minimalista e direto

Aiohttp é cliente e servidor HTTP assíncrono em um só pacote. Ele não tem validação de dados ou documentação automática. Por outro lado, oferece controle total e baixo overhead. Quando usar Aiohttp? Em projetos onde você quer mínimas abstrações. Também é excelente para proxies, crawlers ou servidores customizados. A curva de aprendizado é mais íngreme que a do FastAPI. Você precisa entender asyncio profundamente. A voz passiva é vista: “as rotas são registradas manualmente nas tabelas”. Exemplo de um servidor simples com Aiohttp:

from aiohttp import web
import asyncio

async def handle_requisicao(request):
    nome = request.match_info.get('nome', 'Anônimo')
    await asyncio.sleep(0.5)  # Simula I/O
    return web.Response(text=f"Olá, {nome}!")

async def iniciar_servidor():
    app = web.Application()
    app.router.add_get('/saudacao/{nome}', handle_requisicao)
    return app

if __name__ == '__main__':
    web.run_app(iniciar_servidor(), port=8080)

from aiohttp import web

import asyncio

async def handle_requisicao(request):

nome = request.match_info.get('nome', 'Anônimo')

await asyncio.sleep(0.5) # Simula I/O

return web.Response(text=f"Olá, {nome}!")

async def iniciar_servidor():

app = web.Application()

app.router.add_get('/saudacao/{nome}', handle_requisicao)

return app

if __name__ == '__main__':

web.run_app(iniciar_servidor(), port=8080)

Esse código é leve e eficiente. Não há validação automática de parâmetros. Você mesmo precisa extrair e verificar os dados. Aiohttp é ideal para quem quer entender profundamente o asyncio.

Comparação final e quando escolher cada um

FastAPI é a escolha para a maioria dos projetos novos. Ele oferece documentação, validação e performance excelentes. Sanic é uma alternativa quando você precisa de velocidade pura. Aiohttp é para cenários onde o controle absoluto é necessário. A fórmula de throughput pode ajudar na decisão: \(Throughput = \frac{N_{\text{conexões}}}{T_{\text{médio resposta}}}\) Em sistemas assíncronos, o throughput é muito maior para I/O. Porém, para CPU intensivo, o assíncrono não traz vantagem. Portanto, avalie seu tipo de operação dominante. Comece com FastAPI se tiver dúvidas. Ele é o mais equilibrado entre poder e simplicidade. Lembre-se: programação assíncrona exige cuidado com race conditions. Use locks e semáforos quando necessário. Com essas ferramentas, você construirá backends escaláveis e modernos.

WebSockets em Python

Websockets puros: leve e nativo

Socket.IO: alto nível e robusto

Comparação direta e critérios de escolha

Servidor Assíncrono em Python

FastAPI: o mais popular e completo

Sanic: o veterano da velocidade

Aiohttp: o framework minimalista e direto

Comparação final e quando escolher cada um