Arquivo de Orientada a Eventos

Servidores Assíncronos

25/04/202623/04/2026 Por antonino

– Python
– Orientada a Eventos
1 – GUI (Tkinter, PyQt, Kivy)
2 – Jogos (Pygame, Pyglet)
3 – Servidores (event-driven com asyncio)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Servidores tradicionais usam um thread por conexão. Isso não escala bem para milhares de clientes simultâneos. Uma abordagem mais eficiente é o modelo event-driven. Python oferece o módulo asyncio para isso. Ele permite que um único thread gerencie muitas conexões. Primeiramente, entenda que asyncio é baseado em corrotinas. Essas funções podem pausar e retomar voluntariamente. Enquanto uma espera dados, outra corrotina executa. Isso é chamado de concorrência cooperativa. Por essa razão, o código é muito mais leve que threads. Além disso, evita problemas clássicos de concorrência. Portanto, asyncio é ideal para servidores de rede.

Como funciona o modelo event-driven com asyncio

No centro do asyncio existe um event loop. Ele gerencia todas as tarefas e operações de I/O. Quando uma corrotina aguarda I/O, ela cede o controle. O event loop então executa outra corrotina pronta. Assim que o I/O completa, a primeira é retomada. Isso é semelhante a sistemas como Node.js. No entanto, Python tem sintaxe mais clara com async/await. Uma fórmula simples representa esse comportamento:

\(\text{Throughput} = \frac{\text{Tarefas}}{\text{Thread}} \times \text{Eficiência}\)

Isso significa que um thread faz o trabalho de muitos. Primeiramente, evite operações bloqueantes no event loop. Isso inclui time.sleep() ou código CPU intensivo. Para essas tarefas, use run_in_executor() como alternativa. Assim, o loop principal continua responsivo.

Outra característica importante é o suporte a protocolos. asyncio fornece classes como Protocol e Transport. Elas abstraem detalhes de sockets e buffers de dados. Isso foi projetado para facilitar a criação de servidores. Você implementa métodos como data_received(). O event loop chama esses métodos automaticamente. Portanto, você foca na lógica de negócio, não no gerenciamento.

Quando utilizar servidores assíncronos

Use servidores asyncio para aplicações com muitas conexões. Chats em tempo real são exemplos perfeitos. Servidores de jogos multiplayer também se beneficiam. APIs REST com alto tráfego podem usar asyncio. WebSockets e sistemas de notificação são casos clássicos. Por outro lado, evite asyncio para tarefas CPU-bound. Processamento de imagens ou cálculos pesados não funcionam bem. Para esses casos, prefira multiprocessamento. Além disso, asyncio não acelera operações sequenciais simples. Se você tem poucos clientes, um servidor síncrono basta. Primeiramente, avalie o perfil de I/O da sua aplicação. Se há muita espera por rede ou disco, asyncio é ideal.

Outro bom uso é para proxies e gateways de API. Eles precisam encaminhar requisições rapidamente. Servidores de arquivos com muitos downloads simultâneos também. Frameworks populares como FastAPI usam asyncio por baixo. Isso foi adotado por empresas como Uber e Netflix. Portanto, dominar asyncio é um diferencial profissional. Então, comece com projetos pequenos e evolua gradualmente.

Exemplo prático: servidor echo assíncrono

O código abaixo implementa um servidor echo simples. Ele recebe mensagens de clientes e as devolve de volta. Este é o “Hello World” dos servidores de rede. Usamos o módulo asyncio.streams para facilitar. As funções asyncio.start_server cria o servidor. Cada conexão é tratada por uma corrotina separada. Observe que não há threads explícitas em lugar algum. A concorrência é gerenciada pelo event loop. Isso permite milhares de conexões simultâneas. Vamos ao código comentado para entendimento.

import asyncio
import time
from datetime import datetime

# ============================================
# SERVIDOR ECHO ASSÍNCRONO
# ============================================

async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
    """
    Corrotina que atende um cliente individual.
    É chamada automaticamente para cada nova conexão.
    """
    client_address = writer.get_extra_info('peername')
    print(f"[{datetime.now().time()}] Cliente conectado: {client_address}")
    
    try:
        while True:
            # Lê dados do cliente (até 1024 bytes)
            data = await reader.read(1024)
            
            if not data:
                # Cliente fechou a conexão
                break
            
            message = data.decode()
            print(f"Recebido de {client_address}: {message.strip()}")
            
            # Ecoa a mensagem de volta
            writer.write(f"Echo: {message}".encode())
            await writer.drain()  # Garante que os dados foram enviados
            
            # Simula processamento (operação não-bloqueante)
            await asyncio.sleep(0.01)  # Pequena pausa controlada
    
    except ConnectionResetError:
        print(f"Conexão resetada por {client_address}")
    except Exception as e:
        print(f"Erro com {client_address}: {e}")
    finally:
        print(f"Cliente desconectado: {client_address}")
        writer.close()
        await writer.wait_closed()


async def run_server(host='127.0.0.1', port=8888):
    """
    Inicia o servidor assíncrono.
    """
    server = await asyncio.start_server(
        handle_client,
        host,
        port,
        start_serving=True
    )
    
    print(f"Servidor rodando em {host}:{port}")
    print(f"Conecte com 'telnet {host} {port}' ou um cliente TCP")
    
    async with server:
        await server.serve_forever()


# ============================================
# CLIENTE DE TESTE (opcional)
# ============================================
async def test_client(messages: list, host='127.0.0.1', port=8888):
    """
    Cliente simples para testar o servidor.
    """
    reader, writer = await asyncio.open_connection(host, port)
    print(f"Conectado ao servidor {host}:{port}")
    
    for msg in messages:
        writer.write(msg.encode())
        await writer.drain()
        print(f"Enviado: {msg.strip()}")
        
        data = await reader.read(1024)
        print(f"Resposta: {data.decode().strip()}")
        await asyncio.sleep(1)
    
    writer.close()
    await writer.wait_closed()
    print("Cliente finalizado")


# ============================================
# PONTO DE ENTRADA
# ============================================
async def main():
    # Opção 1: rodar apenas o servidor
    await run_server()
    
    # Opção 2: rodar servidor e cliente em paralelo (descomente abaixo)
    # server_task = asyncio.create_task(run_server())
    # await asyncio.sleep(1)  # Aguarda servidor iniciar
    # await test_client(["Olá servidor!\n", "Como você está?\n", "Saindo...\n"])
    # server_task.cancel()

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\nServidor encerrado manualmente.")

100

101

102

103

104

105

import asyncio

import time

from datetime import datetime

# ============================================

# SERVIDOR ECHO ASSÍNCRONO

# ============================================

async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):

"""

Corrotina que atende um cliente individual.

É chamada automaticamente para cada nova conexão.

"""

client_address = writer.get_extra_info('peername')

print(f"[{datetime.now().time()}] Cliente conectado: {client_address}")

try:

while True:

# Lê dados do cliente (até 1024 bytes)

data = await reader.read(1024)

if not data:

# Cliente fechou a conexão

break

message = data.decode()

print(f"Recebido de {client_address}: {message.strip()}")

# Ecoa a mensagem de volta

writer.write(f"Echo: {message}".encode())

await writer.drain() # Garante que os dados foram enviados

# Simula processamento (operação não-bloqueante)

await asyncio.sleep(0.01) # Pequena pausa controlada

except ConnectionResetError:

print(f"Conexão resetada por {client_address}")

except Exception as e:

print(f"Erro com {client_address}: {e}")

finally:

print(f"Cliente desconectado: {client_address}")

writer.close()

await writer.wait_closed()

async def run_server(host='127.0.0.1', port=8888):

"""

Inicia o servidor assíncrono.

"""

server = await asyncio.start_server(

handle_client,

host,

port,

start_serving=True

)

print(f"Servidor rodando em {host}:{port}")

print(f"Conecte com 'telnet {host} {port}' ou um cliente TCP")

async with server:

await server.serve_forever()

# ============================================

# CLIENTE DE TESTE (opcional)

# ============================================

async def test_client(messages: list, host='127.0.0.1', port=8888):

"""

Cliente simples para testar o servidor.

"""

reader, writer = await asyncio.open_connection(host, port)

print(f"Conectado ao servidor {host}:{port}")

for msg in messages:

writer.write(msg.encode())

await writer.drain()

print(f"Enviado: {msg.strip()}")

data = await reader.read(1024)

print(f"Resposta: {data.decode().strip()}")

await asyncio.sleep(1)

writer.close()

await writer.wait_closed()

print("Cliente finalizado")

# ============================================

# PONTO DE ENTRADA

# ============================================

async def main():

# Opção 1: rodar apenas o servidor

await run_server()

# Opção 2: rodar servidor e cliente em paralelo (descomente abaixo)

# server_task = asyncio.create_task(run_server())

# await asyncio.sleep(1) # Aguarda servidor iniciar

# await test_client(["Olá servidor!\n", "Como você está?\n", "Saindo...\n"])

# server_task.cancel()

if __name__ == "__main__":

try:

asyncio.run(main())

except KeyboardInterrupt:

print("\nServidor encerrado manualmente.")

No código, o servidor escuta na porta 8888 local. Cada cliente rodará na mesma thread sem bloqueios. A função handle_client é uma corrotina independente. Quando await reader.read() é chamado, o controle é cedido. Outros clientes são atendidos enquanto aguardamos dados. Isso é o coração do modelo event-driven. Para testar, use telnet localhost 8888 no terminal. Digite qualquer mensagem e veja o eco retornar. Você pode abrir múltiplos terminais simultaneamente. Observe como todos são atendidos concorrentemente. Além disso, o servidor lida bem com desconexões inesperadas. Portanto, é um exemplo robusto para começar.

Outro ponto importante é o tratamento de erros. Cada cliente é isolado; uma falha não afeta os outros. Isso foi demonstrado com try/except no handle_client. O servidor continua funcionando mesmo com erros pontuais. Use essa estrutura para criar servidores reais. Primeiramente, substitua a lógica de echo pelo seu negócio. Adicione timeouts para evitar clientes lentos. Use asyncio.wait_for() para isso. Além disso, monitore o loop principal periodicamente. Assim, você garante alta disponibilidade do serviço.

✅ Vantagens do asyncio
Escala para milhares de conexões
Baixo overhead de memória
Código mais simples que threads
Ideal para I/O-bound

⚠️ Desvantagens
Não acelera CPU-bound
Curva de aprendizado inicial
Biblioteca padrão menor que frameworks
Debugging pode ser desafiador

Para produção, use bibliotecas como asyncio com cuidado. Frameworks como aiohttp ou FastAPI abstraem complexidades. Eles oferecem routers, middlewares e validação nativa. No entanto, entender as bases é fundamental. Primeiramente, domine o exemplo acima. Depois, evolua para soluções mais completas. Finalmente, lembre-se de testar sob carga real. Ferramentas como locust ajudam na simulação. Assim, você garante que seu servidor aguenta o tráfego. Portanto, asyncio é uma ferramenta poderosa. Use-a com sabedoria nos projetos certos.

Jogos em Python

25/04/202623/04/2026 Por antonino

– Python
– Orientada a Eventos
1 – GUI (Tkinter, PyQt, Kivy)
2 – Jogos (Pygame, Pyglet)
3 – Servidores (event-driven com asyncio)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Python é uma excelente escolha para criar jogos 2D. Duas bibliotecas se destacam nesse cenário: Pygame e Pyglet. Ambas são gratuitas e possuem comunidades ativas. Primeiramente, entenda que cada uma tem filosofia própria. Pygame é mais antiga e amplamente adotada. Pyglet é mais moderna e aproveita melhor o hardware. Uma boa escolha impacta diretamente seu projeto. Portanto, conhecer as diferenças é fundamental. Além disso, ambas funcionam em Windows, Mac e Linux. Assim, você pode distribuir seus jogos livremente.

Pygame: a veterana confiável e cheia de tutoriais

Pygame é construída sobre a biblioteca SDL. Ela existe desde 2000 e tem enorme base de usuários. Por essa razão, você encontra muitos exemplos prontos. Sua curva de aprendizado é considerada baixa. Isso permite que iniciantes criem jogos rapidamente. Pygame lida com sprites, sons e colisões de forma simples. No entanto, sua performance é limitada para muitos objetos. O suporte a OpenGL é mínimo ou inexistente. Use Pygame para jogos 2D clássicos e protótipos. Ela é perfeita para game jams e aprendizado. Muitos jogos comerciais pequenos foram feitos com ela. Portanto, Pygame é ótima para começar no mundo dos jogos.

Uma fórmula que representa sua proposta é:

\(\text{Pygame} = \text{Simplicidade} \times \text{Tutoriais} – \text{Performance}\)

Isso significa que você ganha facilidade, mas perde em velocidade. Primeiramente, avalie se seu jogo precisa de muitos elementos. Se a resposta for não, Pygame é uma escolha sólida. Dessa forma, você entrega resultados mais rápidos. Jogos de plataforma, puzzles e RPGs simples são viáveis.

Pyglet: performance e recursos modernos nativos

Pyglet foi lançada como alternativa mais moderna. Ela usa OpenGL diretamente, sem camadas intermediárias. Isso proporciona performance superior para gráficos 2D. Além disso, suporta janelas múltiplas e eventos de joystick. Pyglet também reproduz áudio com baixa latência. Diferente do Pygame, ela não depende de bibliotecas externas. Tudo isso é feito em Python puro com bindings nativos. A curva de aprendizado é um pouco mais íngreme. No entanto, o resultado final é mais profissional. Use Pyglet quando performance for prioridade. Ela é ideal para jogos com muitos objetos na tela. Portanto, Pyglet é para quem quer ir além do básico.

Outra vantagem importante é o suporte a shaders. Você pode criar efeitos visuais impressionantes. Isso foi pensado para jogos que exigem estilo único. Pyglet também integra bem com bibliotecas OpenGL avançadas. Assim, você tem controle fino sobre o pipeline gráfico. Para jogos de nave espacial ou bullet hell, é perfeita. Portanto, não a subestime pela menor popularidade.

Quando usar cada biblioteca: guia prático

🎮 Pygame
✅ Muitos tutoriais
✅ Fácil aprendizado
❌ Performance limitada
❌ Sem OpenGL moderno

⚡ Pyglet
✅ Performance alta
✅ OpenGL nativo
⚠️ Menos tutoriais
❌ Curva mais íngreme

Para iniciantes absolutos, Pygame é a recomendação clara. Você encontrará resposta para qualquer dúvida online. Por outro lado, se você já tem experiência, teste Pyglet. Jogos que exigem muitos sprites animados pedem Pyglet. Além disso, se você quer usar efeitos 3D básicos, Pyglet vence. Use Pygame para jogos educacionais e protótipos rápidos. Use Pyglet para projetos que podem crescer em escala. Primeiramente, defina a complexidade do seu jogo. Depois, escolha a ferramenta que melhor se adapta. Lembre-se que você pode migrar entre elas depois. No entanto, isso dá trabalho e deve ser evitado. Portanto, a decisão inicial é muito importante.

Exemplo prático: uma nave espacial simples

O código abaixo mostra uma nave que se move. Implementamos o mesmo jogo nas duas bibliotecas. Assim, você compara a sintaxe e a estrutura. Pygame tem mais código boilerplate explícito. Pyglet usa uma abordagem mais orientada a eventos. Observe como o loop principal difere entre elas. Isso ajuda na sua decisão de qual aprender primeiro. Vamos aos códigos comentados para facilitar.

# ============================================
# EXEMPLO 1: PYGAME (pip install pygame)
# ============================================
import pygame
import sys

# Inicialização
pygame.init()
LARGURA, ALTURA = 800, 600
tela = pygame.display.set_mode((LARGURA, ALTURA))
pygame.display.set_caption("Pygame - Nave")
relogio = pygame.time.Clock()

# Carregar imagens (retângulos coloridos como fallback)
nave = pygame.Surface((50, 50))
nave.fill((0, 255, 0))
nave_rect = nave.get_rect()
nave_rect.center = (LARGURA // 2, ALTURA // 2)

velocidade = 5

# Loop principal
while True:
    for evento in pygame.event.get():
        if evento.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
    
    # Teclas pressionadas
    teclas = pygame.key.get_pressed()
    if teclas[pygame.K_LEFT]:
        nave_rect.x -= velocidade
    if teclas[pygame.K_RIGHT]:
        nave_rect.x += velocidade
    if teclas[pygame.K_UP]:
        nave_rect.y -= velocidade
    if teclas[pygame.K_DOWN]:
        nave_rect.y += velocidade
    
    # Manter dentro da tela
    nave_rect.clamp_ip(tela.get_rect())
    
    # Desenhar
    tela.fill((0, 0, 0))
    tela.blit(nave, nave_rect)
    pygame.display.flip()
    relogio.tick(60)


# ============================================
# EXEMPLO 2: PYGLET (pip install pyglet)
# ============================================
import pyglet
from pyglet.window import key

LARGURA, ALTURA = 800, 600

# Criar janela
janela = pyglet.window.Window(LARGURA, ALTURA, "Pyglet - Nave")
janela.set_location(100, 100)

# Criar nave (quadrado colorido)
nave = pyglet.shapes.Rectangle(LARGURA//2 - 25, ALTURA//2 - 25, 50, 50, color=(0, 255, 0))
velocidade = 300  # pixels por segundo

# Controles
teclas_pressionadas = set()

@janela.event
def on_key_press(symbol, modifiers):
    teclas_pressionadas.add(symbol)

@janela.event
def on_key_release(symbol, modifiers):
    teclas_pressionadas.discard(symbol)

def update(dt):
    """Atualiza posição da nave a cada frame."""
    if key.LEFT in teclas_pressionadas:
        nave.x -= velocidade * dt
    if key.RIGHT in teclas_pressionadas:
        nave.x += velocidade * dt
    if key.UP in teclas_pressionadas:
        nave.y += velocidade * dt
    if key.DOWN in teclas_pressionadas:
        nave.y -= velocidade * dt
    
    # Manter dentro dos limites
    nave.x = max(0, min(nave.x, LARGURA - nave.width))
    nave.y = max(0, min(nave.y, ALTURA - nave.height))

@janela.event
def on_draw():
    janela.clear()
    nave.draw()

# Agendar atualização a cada frame
pyglet.clock.schedule_interval(update, 1/60.0)

pyglet.app.run()

100

# ============================================

# EXEMPLO 1: PYGAME (pip install pygame)

# ============================================

import pygame

import sys

# Inicialização

pygame.init()

LARGURA, ALTURA = 800, 600

tela = pygame.display.set_mode((LARGURA, ALTURA))

pygame.display.set_caption("Pygame - Nave")

relogio = pygame.time.Clock()

# Carregar imagens (retângulos coloridos como fallback)

nave = pygame.Surface((50, 50))

nave.fill((0, 255, 0))

nave_rect = nave.get_rect()

nave_rect.center = (LARGURA // 2, ALTURA // 2)

velocidade = 5

# Loop principal

while True:

for evento in pygame.event.get():

if evento.type == pygame.QUIT:

pygame.quit()

sys.exit()

# Teclas pressionadas

teclas = pygame.key.get_pressed()

if teclas[pygame.K_LEFT]:

nave_rect.x -= velocidade

if teclas[pygame.K_RIGHT]:

nave_rect.x += velocidade

if teclas[pygame.K_UP]:

nave_rect.y -= velocidade

if teclas[pygame.K_DOWN]:

nave_rect.y += velocidade

# Manter dentro da tela

nave_rect.clamp_ip(tela.get_rect())

# Desenhar

tela.fill((0, 0, 0))

tela.blit(nave, nave_rect)

pygame.display.flip()

relogio.tick(60)

# ============================================

# EXEMPLO 2: PYGLET (pip install pyglet)

# ============================================

import pyglet

from pyglet.window import key

LARGURA, ALTURA = 800, 600

# Criar janela

janela = pyglet.window.Window(LARGURA, ALTURA, "Pyglet - Nave")

janela.set_location(100, 100)

# Criar nave (quadrado colorido)

nave = pyglet.shapes.Rectangle(LARGURA//2 - 25, ALTURA//2 - 25, 50, 50, color=(0, 255, 0))

velocidade = 300 # pixels por segundo

# Controles

teclas_pressionadas = set()

@janela.event

def on_key_press(symbol, modifiers):

teclas_pressionadas.add(symbol)

@janela.event

def on_key_release(symbol, modifiers):

teclas_pressionadas.discard(symbol)

def update(dt):

"""Atualiza posição da nave a cada frame."""

if key.LEFT in teclas_pressionadas:

nave.x -= velocidade * dt

if key.RIGHT in teclas_pressionadas:

nave.x += velocidade * dt

if key.UP in teclas_pressionadas:

nave.y += velocidade * dt

if key.DOWN in teclas_pressionadas:

nave.y -= velocidade * dt

# Manter dentro dos limites

nave.x = max(0, min(nave.x, LARGURA - nave.width))

nave.y = max(0, min(nave.y, ALTURA - nave.height))

@janela.event

def on_draw():

janela.clear()

nave.draw()

# Agendar atualização a cada frame

pyglet.clock.schedule_interval(update, 1/60.0)

pyglet.app.run()

Compare os dois códigos com atenção. Pygame usa um loop while explícito e polling de eventos. Pyglet usa callbacks decorados e tempo delta (dt). Essa diferença impacta como você estrutura o jogo. Pygame é mais imperativo: você dita cada passo. Pyglet é mais declarativo: você define reações. Nenhuma abordagem é inerentemente superior. Primeiramente, escolha baseado na sua preferência. Se você gosta de controle explícito, vá de Pygame. Se você prefere eventos e callbacks, Pyglet é melhor. Ambos os códigos rodam a 60 quadros por segundo. Portanto, experimente os dois e sinta a diferença.

Outro ponto importante é a manipulação de áudio. Pygame usa o mixer de forma simples e direta. Pyglet carrega áudio com suporte a formatos variados. Ambas permitem sons de fundo e efeitos sonoros. Para jogos maiores, considere o gerenciamento de recursos. Pygame tem a classe sprite.Sprite otimizada. Pyglet tem grupos de Batch para desenho eficiente. Esses recursos avançados merecem estudo separado. Finalmente, lembre-se que documentação é sua aliada. Pygame tem ótimos tutoriais em português. Pyglet tem menos, mas a oficial é muito clara. Assim, você pode superar os desafios iniciais.