Jogo Snake em Python: Crie Passo a Passo com PyGame

Aprenda a criar um Jogo Snake em Python com PyGame do zero. Monte a lógica, desenhe na tela e desenvolva seu primeiro jogo funcional passo a passo.

Crie o Jogo da Cobrinha com PyGame – Passo a Passo

Você já jogou o clássico Jogo da Cobrinha no celular? E se eu te dissesse que dá para criar esse jogo do zero em Python?

Criar o Jogo Snake em Python é uma das formas mais divertidas e didáticas de aprender lógica de programação e manipulação gráfica.

Com poucas linhas de código e a biblioteca PyGame, você pode desenvolver um jogo totalmente funcional — controlando o movimento da cobrinha, criando a lógica de colisão e pontuação, e ainda entendendo como funciona um loop de jogo.

Neste tutorial completo, você vai aprender como criar um jogo da cobrinha em Python do zero.
Vamos configurar o ambiente, entender cada parte do código e, no final, você terá um jogo totalmente jogável na sua máquina.

E aí, quer começar na criação de jogos em Python com esse jogo nostálgico? Então faça o download do projeto e vamos começar!

Para fazer o download do(s) arquivo(s) utilizados na aula, preencha com o seu e-mail:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

Para criar o jogo Snake em Python, use a biblioteca PyGame: instale com pip install pygame, crie a janela e o loop principal, desenhe a cobra como uma lista de blocos e a comida em posições aleatórias, capture as setas do teclado para mover a cobra e aumente o corpo a cada comida — encerrando quando ela bate na parede ou em si mesma.

Entendendo a Lógica por Trás de um Jogo

Todo jogo segue uma estrutura fundamental composta por três partes principais:

1. Configurações iniciais (como tela, cores e variáveis);
2. Loop infinito (que mantém o jogo rodando e atualizando);
3. Interações do jogador (como apertar teclas ou fechar o jogo).

Dentro desse loop, o programa:

• Desenha os objetos na tela (cobra, comida e pontuação);
• Detecta eventos do usuário;
• Verifica se o jogo deve continuar ou terminar.

Por que usar o PyGame para criar o Snake

A biblioteca PyGame é uma das formas mais acessíveis e divertidas de começar a criar jogos em Python.
Ela permite desenhar elementos gráficos, capturar eventos do teclado e controlar o fluxo do jogo de forma simples.

Além disso, ao construir o Snake, você vai aprender conceitos essenciais de lógica de programação, como:

• Loops infinitos;
• Eventos de usuário;
• Atualização de tela;
• Controle de colisões;
• Funções e variáveis dinâmicas.

Criar um jogo é uma das formas mais práticas e empolgantes de aprender Python!

Vale lembrar que você pode fazer qualquer modificação que quiser dentro do jogo. O que eu vou mostrar é o “básico” do jogo, mas pode personalizar do jeito que quiser!

Configurações Iniciais e Instalação do PyGame

Antes de começar, é importante garantir que o PyGame esteja instalado. Ele é a biblioteca responsável por exibir gráficos e capturar eventos do teclado.

Instalando o PyGame

Abra o terminal e digite:

pip install pygame

Esse comando instala a biblioteca necessária para criar o jogo.

Após isso, você pode abrir o VS Code (ou outro editor de sua preferência) e criar um novo arquivo chamado main.py.

Dica: o PyGame é amplamente usado em projetos didáticos e protótipos. A documentação oficial está disponível em pygame.org/docs.

Criando a Estrutura do Jogo Snake

Agora, vamos entender o esqueleto de qualquer jogo feito com Python e PyGame.
Um jogo 2D segue um padrão simples:

1. Configuração inicial (tela, cores, variáveis).
2. Loop principal (onde o jogo acontece).
3. Eventos (movimento, colisões e atualizações).

Importações e Configurações de Tela

import pygame
import random

pygame.init()
pygame.display.set_caption("Jogo Snake Python")

largura, altura = 1200, 800
tela = pygame.display.set_mode((largura, altura))
relogio = pygame.time.Clock()

Aqui, criamos a janela do jogo e configuramos seu título. A variável relogio controla a velocidade do jogo — ou seja, quantas vezes por segundo o loop é executado.

Definindo Cores RGB

As cores são definidas no padrão RGB (vermelho, verde e azul). Cada valor vai de 0 a 255.

preta = (0, 0, 0)
branca = (255, 255, 255)
vermelha = (255, 0, 0)
verde = (0, 255, 0)

Essas cores serão usadas para o fundo, a cobrinha e a comida.

Criando as Funções do Jogo

Para manter o código limpo e organizado, vamos criar funções específicas para cada parte.

Gerar a Comida Aleatoriamente

A comida precisa aparecer em posições aleatórias na tela, sempre dentro dos limites.

def gerar_comida():
    comida_x = round(random.randrange(0, largura - tamanho_quadrado) / float(tamanho_quadrado)) * float(tamanho_quadrado)
    comida_y = round(random.randrange(0, altura - tamanho_quadrado) / float(tamanho_quadrado)) * float(tamanho_quadrado)
    return comida_x, comida_y

O uso de round e float garante que a comida fique alinhada ao grid do jogo — evitando que apareça “entre” pixels.

Desenhar Comida, Cobra e Pontuação

O PyGame usa retângulos para desenhar objetos na tela. A cobrinha e a comida são quadrados de tamanho fixo.

def desenhar_comida(tamanho, comida_x, comida_y):
    pygame.draw.rect(tela, verde, [comida_x, comida_y, tamanho, tamanho])

def desenhar_cobra(tamanho, pixels):
    for pixel in pixels:
        pygame.draw.rect(tela, branca, [pixel[0], pixel[1], tamanho, tamanho])

A pontuação é desenhada com uma fonte simples:

def desenhar_pontuacao(pontuacao):
    fonte = pygame.font.SysFont("Helvetica", 35)
    texto = fonte.render(f"Pontos: {pontuacao}", True, vermelha)
    tela.blit(texto, [1, 1])

Controlando o Movimento da Cobrinha

Para movimentar a cobrinha, precisamos capturar as teclas pressionadas. O PyGame permite detectar eventos do teclado facilmente.

Detectando as Setas do Teclado

def selecionar_velocidade(tecla):
    if tecla == pygame.K_DOWN:
        velocidade_x = 0
        velocidade_y = tamanho_quadrado
    elif tecla == pygame.K_UP:
        velocidade_x = 0
        velocidade_y = -tamanho_quadrado
    elif tecla == pygame.K_RIGHT:
        velocidade_x = tamanho_quadrado
        velocidade_y = 0
    elif tecla == pygame.K_LEFT:
        velocidade_x = -tamanho_quadrado
        velocidade_y = 0
    return velocidade_x, velocidade_y

• Seta para cima: cobra anda para o topo (eixo Y negativo).
• Seta para baixo: cobra desce (eixo Y positivo).
• Setas laterais: controlam o eixo X.

Lembre-se: o eixo X aumenta para a direita e o eixo Y aumenta para baixo.

Python Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agora

Inicializando o estado do jogo

Agora que você já sabe como controlar a direção, vamos criar as variáveis que representam o estado inicial do jogo.

O que cada variável faz (linha a linha):

def rodar_jogo():
    fim_jogo = False
    x = largura / 2
    y = altura / 2
    velocidade_x = 0
    velocidade_y = 0
    tamanho_cobra = 1
    pixels = []
    comida_x, comida_y = gerar_comida()

• fim_jogo = False
  Flag de controle. Enquanto for False, o loop do jogo continua. Quando vira True, o jogo termina.
• x = largura / 2 e y = altura / 2
  Posição inicial da cabeça da cobra no centro da tela. Por que no centro? Começar no meio facilita testes (você tem espaço para qualquer direção) e evita “mortes instantâneas” por nascer encostado na borda.
• velocidade_x = 0 e velocidade_y = 0
  A cobra começa parada. Esses valores são atualizados quando o jogador pressiona as setas. Pense neles como “deslocamento por tick”: a cada atualização, x soma velocidade_x e y soma velocidade_y.
• tamanho_cobra = 1
  A cobra inicia com 1 segmento (apenas a cabeça). Cada comida aumenta esse valor em 1, o que estende o corpo.
• pixels = []
  Lista que guarda as posições (x, y) de todos os segmentos do corpo, na ordem.
  • a cada movimento, você adiciona a nova cabeça no fim,
  • e remove o segmento mais antigo (o “rabo”) — a não ser quando cresce por comer; nesse caso, não remove, aumentando o comprimento.
• comida_x, comida_y = gerar_comida()
  Gera a primeira comida em uma posição aleatória alinhada ao grid (múltiplos de tamanho_quadrado), dentro dos limites da tela.

Observação importante: inteiros, grid e alinhamento

• Com largura = 1200, altura = 800 e tamanho_quadrado = 20, tudo é múltiplo de 20.
  • largura / 2 → 600.0 e altura / 2 → 400.0 (float com .0).
  • Como os deslocamentos também são múltiplos de 20, e a comida nasce alinhada ao grid, as comparações x == comida_x e y == comida_y funcionam.
• Para robustez extra (por exemplo, se a tela não for múltipla do tamanho do quadrado), você pode forçar inteiros alinhados ao grid desde o início:

# centraliza e garante alinhamento ao grid
x = (largura // 2) - ((largura // 2) % tamanho_quadrado)
y = (altura // 2) - ((altura // 2) % tamanho_quadrado)

Resultado: x e y começam como inteiros e “encaixados” na malha, evitando qualquer surpresa se você mudar a resolução/tamanho do quadrado no futuro.

Criando o Loop Principal do Jogo

Agora, é hora de unir tudo dentro da função principal rodar_jogo().

def rodar_jogo():
    fim_jogo = False
    x = largura / 2
    y = altura / 2
    velocidade_x = 0
    velocidade_y = 0
    tamanho_cobra = 1
    pixels = []
    comida_x, comida_y = gerar_comida()

    while not fim_jogo:
        tela.fill(preta)

        for evento in pygame.event.get():
            if evento.type == pygame.QUIT:
                fim_jogo = True
            elif evento.type == pygame.KEYDOWN:
                velocidade_x, velocidade_y = selecionar_velocidade(evento.key)

Nesse trecho, o loop é executado continuamente até o jogador fechar a janela (QUIT).
A cada iteração, a tela é atualizada e a posição da cobra é recalculada.

Atualizando a Posição e Detectando Colisões

        # Colisão com as bordas da tela
        if x < 0 or x >= largura or y < 0 or y >= altura:
            fim_jogo = True

        # Atualiza posição
        x += velocidade_x
        y += velocidade_y

Se a cabeça da cobra sair da tela, o jogo termina.

Agora, desenhe os elementos:

        desenhar_comida(tamanho_quadrado, comida_x, comida_y)
        pixels.append([x, y])
        if len(pixels) > tamanho_cobra:
            del pixels[0]

A lista pixels guarda as posições do corpo da cobra. Ao mover, um novo quadrado é adicionado à frente e o último é removido, simulando o movimento contínuo.

Colisão com o Próprio Corpo

        for pixel in pixels[:-1]:
            if pixel == [x, y]:
                fim_jogo = True

Aqui, o código verifica se a cabeça da cobra (última posição da lista) tocou alguma parte do corpo.
Se sim, o jogo acaba.

Crescimento e Pontuação

Quando a cobra alcança a comida, o tamanho aumenta e uma nova comida é gerada:

        if x == comida_x and y == comida_y:
            tamanho_cobra += 1
            comida_x, comida_y = gerar_comida()

A pontuação é atualizada dinamicamente:

        desenhar_pontuacao(tamanho_cobra - 1)

E ao final de cada ciclo, a tela é atualizada:

        pygame.display.update()
        relogio.tick(velocidade_jogo)

Código Completo do Jogo Snake em Python

Agora que você entendeu cada parte do jogo e como elas se conectam, veja abaixo o código completo do Jogo Snake em Python.

Esse é o momento de colocar tudo em prática: copie o código no seu editor, salve como main.py e execute.

Você verá o jogo rodando na tela, com a cobrinha se movendo, crescendo ao comer e o placar sendo atualizado em tempo real.

# configurações iniciais
import pygame
import random

pygame.init()
pygame.display.set_caption("Jogo Snake Python")
largura, altura = 1200, 800
tela = pygame.display.set_mode((largura, altura))
relogio = pygame.time.Clock()

# cores RGB
preta = (0, 0, 0)
branca = (255, 255, 255)
vermelha = (255, 0, 0)
verde = (0, 255, 0)

# parametros da cobrinha
tamanho_quadrado = 20
velocidade_jogo = 15

def gerar_comida():
    comida_x = round(random.randrange(0, largura - tamanho_quadrado) / float(tamanho_quadrado)) * float(tamanho_quadrado)
    comida_y = round(random.randrange(0, altura - tamanho_quadrado) / float(tamanho_quadrado)) * float(tamanho_quadrado)
    return comida_x, comida_y

def desenhar_comida(tamanho, comida_x, comida_y):
    pygame.draw.rect(tela, verde, [comida_x, comida_y, tamanho, tamanho])

def desenhar_cobra(tamanho, pixels):
    for pixel in pixels:
        pygame.draw.rect(tela, branca, [pixel[0], pixel[1], tamanho, tamanho])

def desenhar_pontuacao(pontuacao):
    fonte = pygame.font.SysFont("Helvetica", 35)
    texto = fonte.render(f"Pontos: {pontuacao}", True, vermelha)
    tela.blit(texto, [1, 1])

def selecionar_velocidade(tecla):
    if tecla == pygame.K_DOWN:
        velocidade_x = 0
        velocidade_y = tamanho_quadrado
    elif tecla == pygame.K_UP:
        velocidade_x = 0
        velocidade_y = -tamanho_quadrado
    elif tecla == pygame.K_RIGHT:
        velocidade_x = tamanho_quadrado
        velocidade_y = 0
    elif tecla == pygame.K_LEFT:
        velocidade_x = -tamanho_quadrado
        velocidade_y = 0
    return velocidade_x, velocidade_y

def rodar_jogo():
    fim_jogo = False

    x = largura / 2
    y = altura / 2

    velocidade_x = 0
    velocidade_y = 0

    tamanho_cobra = 1
    pixels = []

    comida_x, comida_y = gerar_comida()

    while not fim_jogo:
        tela.fill(preta)

        for evento in pygame.event.get():
            if evento.type == pygame.QUIT:
                fim_jogo = True
            elif evento.type == pygame.KEYDOWN:
                velocidade_x, velocidade_y = selecionar_velocidade(evento.key)

        # desenhar_comida
        desenhar_comida(tamanho_quadrado, comida_x, comida_y)

        # atualizar a posicao da cobra
        if x < 0 or x >= largura or y < 0 or y >= altura:
            fim_jogo = True

        x += velocidade_x
        y += velocidade_y

        # desenhar_cobra
        pixels.append([x, y])
        if len(pixels) > tamanho_cobra:
            del pixels[0]

        # se a cobrinha bateu no proprio corpo
        for pixel in pixels[:-1]:
            if pixel == [x, y]:
                fim_jogo = True

        desenhar_cobra(tamanho_quadrado, pixels)

        # desenhar_pontos
        desenhar_pontuacao(tamanho_cobra - 1)

        # atualizacao da tela
        pygame.display.update()

        # criar uma nova comida
        if x == comida_x and y == comida_y:
            tamanho_cobra += 1
            comida_x, comida_y = gerar_comida()

        relogio.tick(velocidade_jogo)


rodar_jogo()

Testando e Personalizando o Jogo

Agora que o jogo funciona, você pode personalizá-lo. Algumas ideias para deixar mais interessante:

Aumentar a Velocidade Gradualmente

Você pode acelerar o jogo conforme o tamanho da cobra aumenta:

relogio.tick(velocidade_jogo + tamanho_cobra // 2)

Isso torna o jogo mais desafiador à medida que você ganha pontos.

Alterar Cores e Layout

Brinque com cores diferentes para a cobra e o fundo. Exemplo:

branca = (255, 255, 255)
azul = (0, 0, 255)

Adicionar Tela de Game Over

Você pode exibir uma mensagem antes de encerrar o jogo:

fonte = pygame.font.SysFont("Helvetica", 60)
texto = fonte.render("Game Over!", True, vermelha)
tela.blit(texto, [largura/3, altura/2])
pygame.display.update()
pygame.time.delay(2000)

Conceitos de Lógica Envolvidos

Criar o Jogo Snake em Python é um ótimo exercício para praticar conceitos de:

• Loops infinitos (while True ou while not fim_jogo).
• Listas dinâmicas (armazenar posições da cobra).
• Condições lógicas (colisões e pontuação).
• Eventos de teclado (movimentação do jogador).

Esses conceitos são base para qualquer tipo de jogo ou simulação.

Se quiser se aprofundar mais em lógica de programação, veja também o artigo da Hashtag Treinamentos: Como aprender Lógica de Programação em Python

Conclusão

E pronto! Você acabou de criar um Jogo Snake em Python totalmente funcional — aprendendo na prática sobre lógica, loops, funções e manipulação de eventos.

Com pequenas adaptações, dá para transformar essa base em outros jogos: Pong, Tetris, Flappy Bird e muito mais.

O mais importante é que agora você entende como um jogo se estrutura internamente e como Python pode ser usado de forma criativa e visual.

Quer dominar Python e criar projetos incríveis como esse? Acesse o curso completo Python Impressionador da Hashtag e aprenda Python do zero até automações, análise de dados e desenvolvimento profissional.

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

O que você aprende neste vídeo

Resposta rápida: Nesta aula completa, o instrutor ensina a criar o jogo da cobrinha (Snake) em Python do zero com a biblioteca PyGame. Você aprende a estrutura de qualquer jogo (configurações iniciais + um loop infinito que desenha os objetos, cria a lógica de fim e pega as interações), a desenhar a tela/cobra/comida com coordenadas X,Y e cores RGB, a mover a cobrinha pelas setas do teclado, gerar comida aleatória, fazer a cobra crescer ao comer e encerrar o jogo na colisão.

Neste vídeo (61 min):

• 2:00 - Configurações iniciais: importar PyGame e random, criar a tela e definir as cores (padrão RGB).
• 11:00 - Parâmetros da cobra (tamanho do quadrado, velocidade) e o relógio que controla o ritmo do jogo.
• 15:00 - O loop infinito do jogo: desenhar os objetos, criar a lógica de fim e pegar as interações do usuário.
• 20:00 - As variáveis iniciais: a posição da cobra (X,Y), a velocidade e a lista de pixels do corpo.
• 24:00 - A função gerar comida: posição aleatória (random) alinhada ao grid da tela.
• 47:00 - Comer a comida: fazer a cobra crescer e gerar uma nova comida.
• 49:00 - Mover a cobrinha pelas setas do teclado (atualizar a velocidade X e Y).
• 56:00 - Encerrar o jogo na colisão (com a parede ou o próprio corpo) e ideias para melhorar.

FAQ - Perguntas Frequentes

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Posts mais recentes de Python

• 
  Curso Básico de Python: Saia do Zero em 10 Aulas Grátis18 de setembro de 2026
  Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.
• 
  Agentes RAG com Python: como criar um assistente de IA17 de setembro de 2026
  Aprenda a criar Agentes RAG com Python do zero: LangChain, FAISS e OpenAI para montar um assistente de IA que responde com base nos seus documentos.
• 
  25 Tipos de Gráficos em Python: Guia Completo com Código26 de agosto de 2026
  Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Posts mais recentes da Hashtag Treinamentos

• 
  Planilha de Controle de Notas Fiscais no Excel [Grátis]2 de outubro de 2026
  Baixe a planilha de controle de notas fiscais no Excel grátis: calcule ISS e retenções, veja o que está em aberto e gere a cobrança de cada nota de serviço.
• 
  Qual IA usar na empresa: ChatGPT, Claude ou Perplexity?2 de outubro de 2026
  Qual IA usar na empresa: veja as diferenças entre ChatGPT, Claude e Perplexity e quando cada um rende mais em cada área da sua equipe.
• 
  Apostilas Gratuitas em PDF: Excel, Power BI, Python e IA30 de setembro de 2026
  Baixe apostilas gratuitas em PDF de Excel, Power BI, Python, Claude e agentes de IA, com exercícios e gabarito. Escolha a sua e comece hoje.