💪 Exercícios Práticos PyBR

23 exercícios progressivos para você dominar programação do básico ao avançado!

📚 Sobre os Exercícios

Os exercícios foram cuidadosamente desenvolvidos para ensinar programação de forma progressiva. Cada exercício introduz novos conceitos enquanto reforça os anteriores.

Tempo estimado: 10-20 minutos por exercício
Pré-requisitos: Python 3.6+ instalado
Localização: Pasta exercicios/

🎯 Trilhas de Aprendizado

🟢 Nível 1: Fundamentos (Exercícios 1-6)

Objetivo: Aprender conceitos básicos de programação
Tempo: 2-3 horas
Você vai aprender: Variáveis, tipos de dados, entrada/saída, operadores

🟡 Nível 2: Controle e Estruturas (Exercícios 7-14)

Objetivo: Dominar estruturas de controle e funções
Tempo: 4-5 horas
Você vai aprender: Condicionais, laços, listas, funções

🔴 Nível 3: Programação Avançada (Exercícios 15-23)

Objetivo: Criar projetos completos com OOP e programação funcional
Tempo: 6-7 horas
Você vai aprender: Classes, projetos reais, lambda, filtrar, mapear, boas práticas

🟢 Exercícios Básicos (1-6)

01. Olá Mundo 👋

Conceitos: imprimir(), strings
Dificuldade: ⭐☆☆☆☆
Tempo: 5 minutos

Seu primeiro programa! Aprenda a exibir mensagens na tela.

imprimir("Olá, Mundo!")
imprimir("Bem-vindo ao PyBR!")

O que você aprende:

Como usar a função imprimir()
Sintaxe básica do PyBR
Executar um programa

Desafio extra:

Exiba seu nome e idade
Crie uma mensagem de boas-vindas personalizada

02. Variáveis 📦

Conceitos: Variáveis, tipos de dados
Dificuldade: ⭐☆☆☆☆
Tempo: 10 minutos

Aprenda a armazenar informações em variáveis.

# Textos (strings)
nome = "Ana"
sobrenome = "Silva"

# Números inteiros
idade = 15
ano = 2024

# Números decimais
altura = 1.65
peso = 52.5

# Booleanos
estudante = Verdadeiro

imprimir(f"{nome} {sobrenome} tem {idade} anos")

O que você aprende:

Criar e usar variáveis
Tipos de dados (string, int, float, bool)
Concatenação e formatação de strings

Desafio extra:

Crie variáveis para um personagem de jogo
Use diferentes tipos de dados

03. Cálculos ➕➖✖️➗

Conceitos: Operadores aritméticos
Dificuldade: ⭐☆☆☆☆
Tempo: 10 minutos

Faça operações matemáticas com Python.

a = 10
b = 3

soma = a + b
subtracao = a - b
multiplicacao = a * b
divisao = a / b
resto = a % b
potencia = a ** b

imprimir(f"Soma: {soma}")
imprimir(f"Divisão: {divisao:.2f}")

O que você aprende:

Operadores: +, -, *, /, %, **
Ordem de precedência
Formatação de números

Desafio extra:

Calcule a área de um círculo (π × r²)
Converta temperatura Celsius para Fahrenheit

04. Entrada e Saída 🔄

Conceitos: entrada(), conversão de tipos
Dificuldade: ⭐⭐☆☆☆
Tempo: 15 minutos

Interaja com o usuário recebendo dados.

nome = entrada("Qual é o seu nome? ")
idade = inteiro(entrada("Qual é a sua idade? "))

imprimir(f"Olá, {nome}!")
imprimir(f"Você tem {idade} anos")

se idade >= 18:
    imprimir("Você é maior de idade")
senao:
    imprimir("Você é menor de idade")

O que você aprende:

Usar entrada() para receber dados
Converter tipos com inteiro() e flutuante()
Validar entrada do usuário

Desafio extra:

Peça nome, idade e cidade do usuário
Crie uma calculadora de soma de dois números

05. Calculadora de IMC 📊

Conceitos: Fórmulas, conversão, condicionais
Dificuldade: ⭐⭐☆☆☆
Tempo: 15 minutos

Crie uma calculadora de Índice de Massa Corporal.

peso = flutuante(entrada("Digite seu peso (kg): "))
altura = flutuante(entrada("Digite sua altura (m): "))

imc = peso / (altura ** 2)

imprimir(f"Seu IMC é: {imc:.2f}")

se imc < 18.5:
    imprimir("Abaixo do peso")
senaose imc < 25:
    imprimir("Peso normal")
senaose imc < 30:
    imprimir("Sobrepeso")
senao:
    imprimir("Obesidade")

O que você aprende:

Aplicar fórmulas matemáticas
Estruturas condicionais
Classificação por faixas

Desafio extra:

Adicione mais faixas de IMC
Mostre dicas de saúde baseadas no resultado

06. Estruturas Condicionais 🔀

Conceitos: se, senao, senaose
Dificuldade: ⭐⭐☆☆☆
Tempo: 15 minutos

Tome decisões no código com condicionais.

nota = flutuante(entrada("Digite sua nota (0-10): "))

se nota >= 9:
    conceito = "A - Excelente!"
senaose nota >= 7:
    conceito = "B - Bom"
senaose nota >= 5:
    conceito = "C - Regular"
senao:
    conceito = "D - Insuficiente"

imprimir(f"Seu conceito é: {conceito}")

O que você aprende:

Condicionais simples e compostas
Operadores de comparação
Lógica de decisão

Desafio extra:

Crie um sistema de desconto baseado no valor da compra
Verifique se um ano é bissexto

🟡 Exercícios Intermediários (7-14)

Conceitos: Dicionários, validação
Dificuldade: ⭐⭐☆☆☆
Tempo: 20 minutos

Crie um sistema simples de autenticação.

usuarios = {
    "admin": "123456",
    "maria": "senha123",
    "joao": "abc456"
}

usuario = entrada("Usuário: ")
senha = entrada("Senha: ")

se usuario em usuarios e usuarios[usuario] == senha:
    imprimir(f"✓ Bem-vindo, {usuario}!")
senao:
    imprimir("✗ Usuário ou senha incorretos!")

O que você aprende:

Dicionários (chave-valor)
Operador em (in)
Validação de dados

Desafio extra:

Limite o número de tentativas
Adicione opção de cadastro de novos usuários

08. Laços com Para 🔁

Conceitos: para, intervalo()
Dificuldade: ⭐⭐☆☆☆
Tempo: 20 minutos

Repita ações com laços de repetição.

# Contagem de 1 a 10
para i em intervalo(1, 11):
    imprimir(f"Número: {i}")

# Números pares de 0 a 20
para num em intervalo(0, 21, 2):
    imprimir(num, fim=" ")

# Iterando sobre listas
frutas = ["maçã", "banana", "laranja"]
para fruta em frutas:
    imprimir(f"Eu gosto de {fruta}")

O que você aprende:

Laço para (for)
Função intervalo() (range)
Iterar sobre sequências

Desafio extra:

Imprima todos os múltiplos de 5 até 100
Calcule a soma de números de 1 a 100

09. Tabuada ✖️

Conceitos: Laços aninhados, formatação
Dificuldade: ⭐⭐⭐☆☆
Tempo: 20 minutos

Gere tabuadas completas.

numero = inteiro(entrada("Digite um número: "))

imprimir(f"\n=== TABUADA DO {numero} ===")
para i em intervalo(1, 11):
    resultado = numero * i
    imprimir(f"{numero} x {i:2d} = {resultado:3d}")

# Tabuada completa (1 a 10)
para n em intervalo(1, 11):
    imprimir(f"\n=== Tabuada do {n} ===")
    para i em intervalo(1, 11):
        imprimir(f"{n} x {i} = {n*i}")

O que você aprende:

Laços aninhados
Formatação de saída
Organização de código

Desafio extra:

Crie uma tabuada completa de 1 a 10 em formato de tabela
Adicione cores ou emojis na saída

10. Laço Enquanto 🔄

Conceitos: enquanto, quebre, continue
Dificuldade: ⭐⭐⭐☆☆
Tempo: 25 minutos

Use laços com condição.

# Contagem regressiva
contador = 10
enquanto contador >= 0:
    imprimir(f"{contador}...")
    contador -= 1
imprimir("🚀 Lançamento!")

# Menu com loop
enquanto Verdadeiro:
    imprimir("\n1. Opção 1")
    imprimir("2. Opção 2")
    imprimir("3. Sair")
    
    escolha = entrada("Escolha: ")
    
    se escolha == "3":
        quebre
    senaose escolha == "1":
        imprimir("Você escolheu 1")
    senao:
        imprimir("Opção inválida!")

O que você aprende:

Laço enquanto (while)
Palavras-chave quebre e continue
Loops infinitos controlados

Desafio extra:

Crie um sistema de senha com tentativas limitadas
Faça um programa que some números até o usuário digitar 0

11. Jogo de Adivinhação 🎮

Conceitos: Números aleatórios, loops, lógica
Dificuldade: ⭐⭐⭐☆☆
Tempo: 30 minutos

Crie um jogo interativo!

importar random

numero_secreto = random.randint(1, 100)
tentativas = 0

imprimir("=== JOGO DE ADIVINHAÇÃO ===")
imprimir("Adivinhe o número entre 1 e 100")

enquanto Verdadeiro:
    palpite = inteiro(entrada("\nSeu palpite: "))
    tentativas += 1
    
    se palpite == numero_secreto:
        imprimir(f"🎉 Parabéns! Acertou em {tentativas} tentativas!")
        quebre
    senaose palpite < numero_secreto:
        imprimir("📈 Tente um número maior!")
    senao:
        imprimir("📉 Tente um número menor!")

O que você aprende:

Importar módulos
Números aleatórios
Lógica de jogo

Desafio extra:

Limite o número de tentativas
Mostre a distância do número secreto
Adicione níveis de dificuldade

12. Trabalhando com Listas 📝

Conceitos: Listas, métodos, manipulação
Dificuldade: ⭐⭐⭐☆☆
Tempo: 25 minutos

Aprenda a trabalhar com coleções de dados.

# Criando listas
numeros = [1, 2, 3, 4, 5]
frutas = ["maçã", "banana", "laranja"]
mista = [1, "texto", 3.14, Verdadeiro]

# Adicionando elementos
frutas.append("uva")
frutas.insert(0, "morango")

# Removendo elementos
frutas.remove("banana")
ultima = frutas.pop()

# Acessando elementos
imprimir(frutas[0])  # Primeiro
imprimir(frutas[-1])  # Último

# Fatiamento
imprimir(frutas[1:3])

# Percorrendo
para i, fruta em enumerar(frutas):
    imprimir(f"{i+1}. {fruta}")

O que você aprende:

Criar e manipular listas
Métodos: append, insert, remove, pop
Indexação e fatiamento
Enumerar elementos

Desafio extra:

Crie uma lista de compras interativa
Ordene uma lista de números

13. Funções Simples 🔧

Conceitos: definir, parâmetros
Dificuldade: ⭐⭐⭐☆☆
Tempo: 25 minutos

Organize código em funções reutilizáveis.

definir saudar(nome):
    imprimir(f"Olá, {nome}!")

definir somar(a, b):
    resultado = a + b
    imprimir(f"{a} + {b} = {resultado}")

definir exibir_menu():
    imprimir("=== MENU ===")
    imprimir("1. Opção 1")
    imprimir("2. Opção 2")
    imprimir("3. Sair")

# Usando as funções
saudar("Maria")
somar(5, 3)
exibir_menu()

O que você aprende:

Criar funções com definir
Passar parâmetros
Organizar código

Desafio extra:

Crie funções para calcular área e perímetro de formas
Faça uma função que valida CPF

14. Funções com Retorno ↩️

Conceitos: retornar, funções que retornam valores
Dificuldade: ⭐⭐⭐☆☆
Tempo: 30 minutos

Crie funções que retornam resultados.

definir somar(a, b):
    retornar a + b

definir calcular_media(notas):
    soma = sum(notas)
    retornar soma / tamanho(notas)

definir eh_par(numero):
    retornar numero % 2 == 0

# Usando funções
resultado = somar(10, 5)
imprimir(f"Soma: {resultado}")

notas = [8.5, 9.0, 7.5]
media = calcular_media(notas)
imprimir(f"Média: {media:.2f}")

se eh_par(10):
    imprimir("10 é par")

O que você aprende:

Retornar valores com retornar
Usar retorno em expressões
Funções booleanas

Desafio extra:

Crie funções matemáticas (fatorial, fibonacci)
Faça uma função que valida email

🔴 Exercícios Avançados (15-22)

15. Calculadora com Funções 🧮

Conceitos: Múltiplas funções, menu, organização
Dificuldade: ⭐⭐⭐⭐☆
Tempo: 40 minutos

Crie uma calculadora completa e organizada.

definir somar(a, b):
    retornar a + b

definir subtrair(a, b):
    retornar a - b

definir multiplicar(a, b):
    retornar a * b

definir dividir(a, b):
    se b == 0:
        retornar "Erro: divisão por zero"
    retornar a / b

enquanto Verdadeiro:
    imprimir("\n=== CALCULADORA ===")
    imprimir("1. Somar")
    imprimir("2. Subtrair")
    imprimir("3. Multiplicar")
    imprimir("4. Dividir")
    imprimir("5. Sair")
    
    opcao = entrada("Escolha: ")
    
    se opcao == "5":
        quebre
    
    # Resto do código...

O que você aprende:

Múltiplas funções relacionadas
Validação de entrada
Tratamento de erros

Desafio extra:

Adicione mais operações (potência, raiz)
Implemente histórico de cálculos

16. Classe Cachorro 🐕

Conceitos: Classes, __init__, métodos
Dificuldade: ⭐⭐⭐⭐☆
Tempo: 35 minutos

Introdução à Programação Orientada a Objetos!

classe Cachorro:
    definir __init__(self, nome, idade, raca):
        self.nome = nome
        self.idade = idade
        self.raca = raca
    
    definir latir(self):
        imprimir(f"{self.nome} diz: Au au!")
    
    definir aniversario(self):
        self.idade += 1
        imprimir(f"{self.nome} fez {self.idade} anos!")
    
    definir apresentar(self):
        imprimir(f"Nome: {self.nome}")
        imprimir(f"Idade: {self.idade} anos")
        imprimir(f"Raça: {self.raca}")

# Criando objetos
rex = Cachorro("Rex", 3, "Labrador")
bobby = Cachorro("Bobby", 5, "Poodle")

rex.apresentar()
rex.latir()
rex.aniversario()

O que você aprende:

Criar classes com classe
Método __init__ (construtor)
Atributos e métodos
Criar objetos (instâncias)

Desafio extra:

Adicione método para comer e dormir
Crie uma classe Gato similar

17. Classe Conta Bancária 💰

Conceitos: Métodos, encapsulamento
Dificuldade: ⭐⭐⭐⭐☆
Tempo: 40 minutos

Simule operações bancárias.

classe ContaBancaria:
    definir __init__(self, titular, saldo=0):
        self.titular = titular
        self.saldo = saldo
    
    definir depositar(self, valor):
        se valor > 0:
            self.saldo += valor
            imprimir(f"✓ Depósito de R$ {valor:.2f}")
        senao:
            imprimir("✗ Valor inválido")
    
    definir sacar(self, valor):
        se valor > self.saldo:
            imprimir("✗ Saldo insuficiente")
        senaose valor > 0:
            self.saldo -= valor
            imprimir(f"✓ Saque de R$ {valor:.2f}")
        senao:
            imprimir("✗ Valor inválido")
    
    definir extrato(self):
        imprimir(f"Titular: {self.titular}")
        imprimir(f"Saldo: R$ {self.saldo:.2f}")

conta = ContaBancaria("João", 1000)
conta.extrato()
conta.depositar(500)
conta.sacar(200)
conta.extrato()

O que você aprende:

Lógica de negócio em classes
Validações em métodos
Estado do objeto

Desafio extra:

Adicione histórico de transações
Implemente transferência entre contas
Adicione taxa de saque

18. Classe Retângulo 📐

Conceitos: Propriedades calculadas, geometria
Dificuldade: ⭐⭐⭐⭐☆
Tempo: 35 minutos

Calcule área e perímetro geometricamente.

classe Retangulo:
    definir __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura
    
    definir calcular_area(self):
        retornar self.largura * self.altura
    
    definir calcular_perimetro(self):
        retornar 2 * (self.largura + self.altura)
    
    definir eh_quadrado(self):
        retornar self.largura == self.altura
    
    definir exibir_info(self):
        imprimir(f"Largura: {self.largura}")
        imprimir(f"Altura: {self.altura}")
        imprimir(f"Área: {self.calcular_area()}")
        imprimir(f"Perímetro: {self.calcular_perimetro()}")
        
        se self.eh_quadrado():
            imprimir("É um quadrado!")

ret = Retangulo(10, 5)
ret.exibir_info()

O que você aprende:

Métodos com cálculos
Propriedades derivadas
Lógica matemática em OOP

Desafio extra:

Crie classes para Círculo e Triângulo
Adicione método para comparar áreas

19. Classe Aluno com Notas 🎓

Conceitos: Listas em classes, cálculos
Dificuldade: ⭐⭐⭐⭐☆
Tempo: 40 minutos

Gerencie notas e aprovação de alunos.

classe Aluno:
    definir __init__(self, nome, matricula):
        self.nome = nome
        self.matricula = matricula
        self.notas = []
    
    definir adicionar_nota(self, nota):
        se 0 <= nota <= 10:
            self.notas.append(nota)
            imprimir(f"✓ Nota {nota} adicionada")
        senao:
            imprimir("✗ Nota inválida (0-10)")
    
    definir calcular_media(self):
        se tamanho(self.notas) == 0:
            retornar 0
        retornar sum(self.notas) / tamanho(self.notas)
    
    definir situacao(self):
        media = self.calcular_media()
        
        se media >= 7:
            retornar "Aprovado"
        senaose media >= 5:
            retornar "Recuperação"
        senao:
            retornar "Reprovado"
    
    definir boletim(self):
        imprimir(f"\n=== BOLETIM ===")
        imprimir(f"Aluno: {self.nome}")
        imprimir(f"Matrícula: {self.matricula}")
        imprimir(f"Notas: {self.notas}")
        imprimir(f"Média: {self.calcular_media():.2f}")
        imprimir(f"Situação: {self.situacao()}")

aluno = Aluno("Maria Silva", "2024001")
aluno.adicionar_nota(8.5)
aluno.adicionar_nota(9.0)
aluno.adicionar_nota(7.5)
aluno.boletim()

O que você aprende:

Listas como atributos
Cálculos com dados da classe
Sistema completo de gerenciamento

Desafio extra:

Adicione diferentes disciplinas
Implemente sistema de faltas

20. Projeto: Lista de Tarefas ✅

Conceitos: Projeto completo, CRUD
Dificuldade: ⭐⭐⭐⭐⭐
Tempo: 60 minutos

Sistema completo de gerenciamento de tarefas!

Funcionalidades:

✅ Adicionar tarefas
✅ Listar tarefas
✅ Marcar como concluída
✅ Remover tarefas
✅ Prioridades
✅ Interface em menu

O que você aprende:

CRUD completo (Create, Read, Update, Delete)
Estruturas de dados complexas
Interface de usuário
Validações

Desafio extra:

Salvar tarefas em arquivo
Adicionar datas de vencimento
Filtrar por prioridade

21. Projeto: Quiz Interativo 🎯

Conceitos: Dicionários, lógica de jogo
Dificuldade: ⭐⭐⭐⭐⭐
Tempo: 60 minutos

Crie um jogo de perguntas e respostas!

Funcionalidades:

📚 Banco de perguntas
⏱️ Sistema de pontuação
📊 Estatísticas
🎮 Feedback imediato

O que você aprende:

Trabalhar com dicionários
Lógica de pontuação
Interface interativa

Desafio extra:

Adicione categorias
Implemente ranking
Adicione dificuldades

22. Projeto: Conversor de Temperatura 🌡️

Conceitos: Menu completo, funções, validação
Dificuldade: ⭐⭐⭐⭐⭐
Tempo: 50 minutos

Conversor completo de temperaturas!

Conversões:

🌡️ Celsius ↔ Fahrenheit
🌡️ Celsius ↔ Kelvin
🌡️ Fahrenheit ↔ Kelvin

Funcionalidades:

Menu interativo
Validação de entrada
Múltiplas conversões
Interface amigável

O que você aprende:

Projeto completo
Múltiplas funções
Validação robusta
Interface profissional

Desafio extra:

Adicione histórico de conversões
Implemente conversão em lote
Crie gráficos de temperatura

23. Funções Avançadas: Lambda, Filtrar e Mapear 🚀

Conceitos: Lambda, filtrar, mapear, qualquer, todos
Dificuldade: ⭐⭐⭐⭐⭐
Tempo: 40 minutos

Domine ferramentas poderosas de processamento de dados!

Você vai aprender:

✨ Lambda - Criar funções rápidas e anônimas
🔍 Filtrar - Selecionar elementos de listas
🔄 Mapear - Aplicar funções a todos elementos
✅ Qualquer/Todos - Verificações lógicas

Exemplos práticos:

# Lambda
dobro = lambda x: x * 2

# Mapear - dobrar todos os números
numeros = [1, 2, 3, 4, 5]
dobrados = lista(mapear(lambda x: x * 2, numeros))

# Filtrar - apenas números pares
pares = lista(filtrar(lambda x: x % 2 == 0, numeros))

# Combinar
resultado = lista(mapear(
    lambda x: x * 2,
    filtrar(lambda x: x % 2 == 0, numeros)
))

Casos de uso real:

📊 Análise de notas de alunos
💰 Processamento de preços e descontos
📝 Filtragem de dados
🔢 Transformação de listas

Funções utilizadas:

lambda - Funções anônimas
mapear() - Transforma elementos
filtrar() - Seleciona elementos
qualquer() - Verifica se algum é True
todos() - Verifica se todos são True
maximo(), minimo(), sum() - Análise (sum é nativo)
arredondar() - Formatação

O que você aprende:

Programação funcional
Processamento eficiente de dados
Código mais limpo e expressivo
Técnicas avançadas de Python

Desafio extra:

Crie um sistema de análise de vendas
Filtre e transforme dados de estudantes
Implemente um processador de textos
Desenvolva calculadora estatística

🚀 Como Fazer os Exercícios

Passo a Passo

Clone o repositório

git clone https://github.com/maxwellamaral/pybr.git
cd pybr

Execute um exercício

python pybr.py exercicios/01-ola-mundo.pybr

Estude o código
- Leia os comentários
- Entenda cada linha
- Teste modificações
Faça os desafios
- Tente resolver sozinho primeiro
- Pesquise quando travar
- Compare com a solução

Dicas de Estudo

✅ Faça na ordem - Os exercícios são progressivos
✅ Pratique todo dia - Mesmo que seja 30 minutos
✅ Não copie - Digite o código para aprender
✅ Experimente - Modifique o código e veja o que acontece
✅ Anote dúvidas - Pesquise depois ou pergunte
✅ Refaça - Revise exercícios anteriores

Recursos de Apoio

📖 Tutorial Completo - Conceitos detalhados
📚 Referência - Documentação da linguagem
💬 Issues no GitHub - Tire dúvidas
🎓 Tutorial Original - Versão estendida

📊 Acompanhe seu Progresso

Checklist de Exercícios

🟢 Básico

🟡 Intermediário

🔴 Avançado

Conquistas 🏆

🥉 Bronze - Complete os 6 exercícios básicos
🥈 Prata - Complete até exercício 14
🥇 Ouro - Complete todos os 23 exercícios
💎 Diamante - Complete todos com desafios extras

❓ Dúvidas Frequentes

P: Preciso fazer na ordem?
R: Sim! Os exercícios são progressivos e cada um usa conceitos dos anteriores.

P: Quanto tempo leva para completar todos?
R: Aproximadamente 13-16 horas, fazendo com calma e entendendo.

P: E se eu travar em um exercício?
R: Revise o tutorial, consulte a referência, ou abra uma issue.

P: Posso pular exercícios?
R: Não é recomendado, mas você pode fazer exercícios intermediários se já souber o básico.

P: Os desafios extras são obrigatórios?
R: Não, mas são ótimos para praticar e fixar o conteúdo!

Bons estudos e divirta-se programando! 🚀

← Voltar ao Tutorial

Ver Referência →

Início

💪 Exercícios Práticos PyBR

📚 Sobre os Exercícios

🎯 Trilhas de Aprendizado

🟢 Nível 1: Fundamentos (Exercícios 1-6)

🟡 Nível 2: Controle e Estruturas (Exercícios 7-14)

🔴 Nível 3: Programação Avançada (Exercícios 15-23)

🟢 Exercícios Básicos (1-6)

01. Olá Mundo 👋

02. Variáveis 📦

03. Cálculos ➕➖✖️➗

04. Entrada e Saída 🔄

05. Calculadora de IMC 📊

06. Estruturas Condicionais 🔀

🟡 Exercícios Intermediários (7-14)

07. Sistema de Login 🔐

08. Laços com Para 🔁

09. Tabuada ✖️

10. Laço Enquanto 🔄

11. Jogo de Adivinhação 🎮

12. Trabalhando com Listas 📝

13. Funções Simples 🔧

14. Funções com Retorno ↩️

🔴 Exercícios Avançados (15-22)

15. Calculadora com Funções 🧮

16. Classe Cachorro 🐕

17. Classe Conta Bancária 💰

18. Classe Retângulo 📐

19. Classe Aluno com Notas 🎓

20. Projeto: Lista de Tarefas ✅

21. Projeto: Quiz Interativo 🎯

22. Projeto: Conversor de Temperatura 🌡️

23. Funções Avançadas: Lambda, Filtrar e Mapear 🚀

🚀 Como Fazer os Exercícios

Passo a Passo

Dicas de Estudo

Recursos de Apoio

📊 Acompanhe seu Progresso

Checklist de Exercícios

🟢 Básico

🟡 Intermediário

🔴 Avançado

Conquistas 🏆

❓ Dúvidas Frequentes