Exercícios de Python para iniciantes: guia prático com respostas

A melhor forma de aprender Python é ganhar familiaridade com repetição, experimentação e resolução de problemas. Por isso a filosofia de “aprender fazendo” está no centro de como programadores eficientes são formados. 

Escrever código, errar e corrigir é como você desenvolve habilidades de verdade.

Neste artigo, vamos passar por um conjunto estruturado de exercícios de Python feitos especificamente para iniciantes. Os exercícios começam com variáveis simples e, aos poucos, evoluem para funções, estruturas de dados e pequenos projetos com dados.

Antes de continuar a leitura, aqui vai um desafio: tente resolver os três primeiros exercícios deste artigo agora, sem olhar as explicações. Mesmo que você trave, é na tentativa que acontece a maior parte do aprendizado.

Se você prefere uma experiência mais guiada, os cursos da DataCamp verificam sua sintaxe e lógica passo a passo. Isso impede que pequenos erros travem seu progresso e é especialmente útil para iniciantes. Um bom ponto de partida é o curso Introduction to Python.

começando com exercícios de Python

Antes de partir para os exercícios, você precisa de um ambiente básico para escrever e executar código Python. Felizmente, começar nunca foi tão fácil.

preparação

Para rodar Python localmente, instale um editor de código amigável para iniciantes, como o Visual Studio Code.

Uma configuração típica é assim:

• Instale o Python no site oficial

• Instale o Visual Studio Code

• Adicione a extensão Python dentro do VS Code

• Crie um novo arquivo .py e comece a programar

O VS Code é um ótimo lugar para começar a codar, pois é open source e gratuito. Você pode visitar a página de download para baixar o software. Baixe e instale quando concluir o download.

Se preferir não instalar nada, use o DataLab, um ambiente no navegador que executa código Python (e SQL) na hora. É ideal para acompanhar tutoriais, testar trechos de código e experimentar sem se preocupar com configuração.

como usar estes exercícios

Para maximizar seu aprendizado, cada exercício deste artigo foi feito para ser tentado antes de ler a solução ou explicação.

Veja como aproveitar ao máximo:

• Dedique pelo menos 15 minutos tentando resolver por conta própria
• Escreva o programa completo, mesmo que pareça repetitivo
• Só confira o gabarito depois de tentar

Um gabarito completo para todos os exercícios está disponível em uma planilha DataLab vinculada aqui. Assim, você pode comparar sua abordagem com uma solução funcional e entender outras maneiras de resolver o mesmo problema.

exercícios de Python com variáveis, entrada e saída

Vamos começar com exercícios básicos focados nos blocos fundamentais: armazenar valores, ler entradas do usuário e imprimir resultados na tela.

a saudação personalizada

Para começar, veja um exercício simples de Python que imprime uma mensagem personalizada.

exercício

Escreva um programa que:

• Peça o nome do usuário usando input()

• Peça a idade do usuário usando input()

• Imprima uma saudação usando strings formatadas

• Calcule o ano em que o usuário fará 100 anos

Antes de escrever qualquer código, ajuda pensar em como a informação flui por um programa simples como este. O usuário fornece entradas brutas como texto, o Python armazena essas entradas em variáveis e você transforma esses valores em algo significativo. 

Este exercício reflete muitos programas reais, em que a entrada do usuário raramente é utilizável em sua forma original e precisa ser validada ou convertida primeiro.

código inicial

Aqui está um código inicial para te guiar:

# Task: Ask for the user's name
name = input("Enter your name: ")

# Task: Ask for the user's age (note: input() returns a string)
age_str = input("Enter your age: ")

# Task: Convert age_str to an int
# age = ...

# Task: Calculate the year the user turns 100
# Tip: you'll need the current year
# current_year = ...
# year_turn_100 = ...

# Task: Print a personalized message using an f-string
# print(...)

conceitos-chave praticados

• input() sempre retorna uma string

• Converter strings em inteiros com int()

• Aritmética básica com números

• Formatação de strings com f-strings

Este exercício mostra que entradas do usuário geralmente precisam ser transformadas antes de serem usadas em cálculos.

o conversor de temperatura

Vamos aplicar suas habilidades de Python a algumas conversões de unidades básicas.

exercício

Escreva um programa que:

• Peça ao usuário uma temperatura em Celsius

• Converta para Fahrenheit usando a fórmula: F = (C × 9/5) + 32

• Imprima a temperatura convertida

código inicial

Aqui está um código inicial para te guiar:

# Task: Ask the user for a Celsius temperature
celsius_str = input("Temperature in Celsius: ")

# Task: Convert the input to a float
# celsius = ...

# Task: Apply the conversion formula
# fahrenheit = ...

# Task: Print the result (consider formatting to 1–2 decimal places)
# print(...)

conceitos-chave praticados

• Números de ponto flutuante

• Expressões aritméticas

• Conversão de tipos com float()

Este exercício reforça que nem todas as entradas numéricas são inteiros e que o Python lida naturalmente com decimais.

o enigma da troca

Este exercício parece trivial, mas é comum iniciantes pensarem em variáveis como caixas que precisam ser esvaziadas e preenchidas passo a passo. Vamos ver como fazer uma troca de valores em Python.

exercício

Você recebe duas variáveis: a = 5 e b = 10. Troque seus valores sem reatribuir manualmente um a um.

O Python permite uma forma mais expressiva de pensar em atribuição, em que valores podem ser desempacotados e reatribuídos em uma única operação.

código inicial

Aqui está um código inicial para te guiar:

a = 5
b = 10

# Task: Swap a and b
# Hint: Try a temporary variable first.
# Then try the Pythonic approach (tuple unpacking).

# Task: Print the swapped values to verify
# print("a:", a)
# print("b:", b)

conceitos-chave praticados

• Atribuição de variáveis
• Variáveis temporárias vs desempacotamento de tuplas

Isso introduz o desempacotamento de tuplas, um recurso que torna o Python conciso e expressivo.

Para mais informações sobre o básico, confira nosso Python Cheat Sheet.

exercícios de Python com controle de fluxo e lógica

O controle de fluxo permite que seus programas tomem decisões e repitam ações com base em condições.

verificador de par ou ímpar

Um caso comum do operador módulo é checar se um número é par ou ímpar. Vamos testar abaixo.

exercício

Escreva um programa que:

• Peça um número ao usuário

• Use o operador módulo %

• Imprima se o número é par ou ímpar

código inicial

Aqui está um código inicial para te guiar:

# Task: Ask the user for a number
num_str = input("Enter a whole number: ")

# Task: Convert to int
# num = ...

# Task: Use modulo (%) to decide even vs odd
# if ...:
#     print("Even")
# else:
#     print("Odd")

conceitos-chave praticados

• Operador módulo

• if / else

• Lógica booleana

Este costuma ser o primeiro exemplo em que iniciantes veem como condições controlam o comportamento do programa.

o clássico desafio FizzBuzz

Um desafio de programação muito comum é o FizzBuzz. Vamos ver do que se trata.

exercício

Imprima os números de 1 a 100 com as seguintes regras:

• Múltiplos de 3 imprimem Fizz

• Múltiplos de 5 imprimem Buzz

• Múltiplos de ambos imprimem FizzBuzz

Este exercício treina você a pensar cuidadosamente em árvores de decisão e casos de borda — habilidade crucial ao escrever programas reais.

código inicial

Aqui está um código inicial para te guiar:

# Task: Loop from 1 to 100
for n in range(1, 101):
    # Task: Check multiples of 3 AND 5 first
    # if ...:
    #     print("FizzBuzz")

    # Task: Then multiples of 3
    # elif ...:
    #     print("Fizz")

    # Task: Then multiples of 5
    # elif ...:
    #     print("Buzz")

    # Task: Otherwise, print the number
    # else:
    #     print(n)
    pass

conceitos-chave praticados

• Laços for

• Ordem de condições

• Operadores lógicos

Este exercício é um rito de passagem para programadores e é usado para ensinar pensamento estruturado em controle de fluxo. Leia mais sobre laços no nosso tutorial de loops em Python.

o jogo da adivinhação

Este exercício apresenta programas interativos que respondem dinamicamente à entrada do usuário.

exercício

Escreva um programa que:

• Gere um número aleatório (importando random)

• Use um laço while para pedir palpites

• Imprima o feedback "Too high" ou "Too low" após cada palpite

• Pare quando o número correto for adivinhado

Este costuma ser o primeiro exercício em que iniciantes vivenciam um programa que parece interativo, não linear. Diferente de scripts anteriores que rodam do início ao fim e saem, este programa continua executando até que uma condição seja atendida.

O pulo do gato aqui é entender a condição de término do laço.

código inicial

Aqui está um código inicial para te guiar:

import random

# Task: Pick a random number in a reasonable range
# target = random.randint(1, 100)

# Task: Use a while loop to keep asking until correct
# while ...:
#     guess_str = input("Your guess (1–100): ")
#     # guess = ...
#     # if guess > target:
#     #     print("Too high")
#     # elif guess < target:
#     #     print("Too low")
#     # else:
#     #     print("Correct!")
#     #     break

conceitos-chave praticados

• Importação de módulos (random)

• Laços while

• Condições de término de laço

exercícios de Python com listas, laços e iteração

Listas permitem trabalhar com coleções de valores, enquanto laços possibilitam processá-las com eficiência.

a soma da lista

Esse padrão aparece com frequência em fluxos de processamento e análise de dados.

exercício

Escreva um programa que some todos os números de uma lista sem usar a função nativa sum(). O programa deve realizar a lógica da soma explicitamente em um laço, em vez de depender de ajudantes de agregação.

código inicial

Aqui está um código inicial para te guiar:

numbers = [3, 7, 2, 9, 4]

# Task: Create an accumulator variable
# total = ...

# Task: Loop through numbers and add each value to total
# for ...:
#     ...

# Task: Print the final total
# print(total)

conceitos-chave praticados

• Inicializar uma variável acumuladora

• Iteração com laços for

• Atualizar valores passo a passo

Para mais exemplos com listas, confira nosso guia sobre as perguntas mais comuns sobre listas em Python.

encontrando o maior número

O próximo exercício é parecido com o anterior, mas funciona de forma diferente dentro do laço. Ele reforça o pensamento algorítmico e espelha como funções internas operam por baixo dos panos.

exercício

Desafie o usuário a encontrar o maior número de uma lista sem usar max().

código inicial

Aqui está um código inicial para te guiar:

numbers = [12, 5, 27, 3, 19]

# Task: Initialize current_max using the first element
# current_max = numbers[0]

# Task: Loop through the remaining elements and update current_max
# for ...:
#     if ...:
#         current_max = ...

# Task: Print the largest number
# print(current_max)

conceitos-chave praticados

• Lógica de comparação
• Acompanhar estado durante a iteração

removendo duplicatas

Dados do mundo real são bagunçados, e isso muitas vezes envolve pontos duplicados. O exercício a seguir prepara você para tarefas de limpeza de dados.

exercício

Transforme uma lista com elementos duplicados em uma nova lista com apenas itens únicos.

À primeira vista, este problema pode parecer simples, mas ele introduz a ideia de rastrear o que você já viu. Isso é fundamental em processamento de dados, onde identificar e remover registros duplicados é rotina.

código inicial

Aqui está um código inicial para te guiar:

data = ["apple", "banana", "apple", "orange", "banana", "kiwi"]

# Task: Create a new list for unique items
# unique = []

# Task: Loop through data and append items you haven't seen yet
# for item in data:
#     if ...:
#         ...

# Task: Print or return the unique list
# print(unique)

conceitos-chave praticados

• Checagem de pertencimento com in

• Construção de novas listas

• Entender unicidade de dados

exercícios de Python com dicionários e manipulação de strings

Dicionários e strings são essenciais para organizar e transformar dados textuais. Vamos ver como lidar com eles.

contador de frequência de caracteres

Este exercício ensina a construir tabelas de frequência, uma tarefa comum em análise de dados.

exercício

Receba uma string e retorne um dicionário contando quantas vezes cada caractere aparece.

Este exercício representa um passo conceitual importante: construir uma estrutura de dados dinamicamente enquanto o programa roda. Em vez de trabalhar com uma lista ou dicionário pré-definidos, você cria e atualiza entradas com base nos dados encontrados.

código inicial

Aqui está um código inicial para te guiar:

text = input("Enter some text: ")

# Task: Create an empty dictionary
# counts = {}

# Task: Loop over each character and update counts
# for ch in text:
#     # Option A: counts[ch] = counts.get(ch, 0) + 1
#     # Option B: if ch in counts: ... else: ...
#     pass

# Task: Print the frequency table
# print(counts)

conceitos-chave praticados

• Dicionários

• Método .get()

• Inicialização condicional

agenda telefônica simples

Este exercício aborda a lógica de dicionários, base para entender estruturas de dados tabulares mais adiante.

exercício

Crie um programa que armazene nomes e números em um dicionário e permita que o usuário pesquise pelo nome.

Este exercício introduz a ideia de usar um programa como uma ferramenta de consulta persistente, e não apenas um cálculo pontual. Você está modelando uma versão simplificada de como muitos aplicativos armazenam e recuperam informações.

código inicial

Aqui está um código inicial para te guiar:

phonebook = {
    # "Alice": "9123 4567",
    # "Ben": "9876 5432",
}

# Task: (Optional) add entries via input()
# name = input("Name to add: ")
# number = input("Number to add: ")
# phonebook[name] = number

# Task: Search loop (one lookup is fine for a start)
query = input("Search name: ")

# Task: Print the number if found, otherwise print a friendly message
# if ...:
#     print(...)
# else:
#     print("Not found")

conceitos-chave praticados

• Consultas em dicionários
• Relações chave–valor

Se quiser se aprofundar em dicionários, recomendamos nosso guia completo sobre métodos de dicionário em Python.

verificador de palíndromos

Este exercício combina processamento de texto com comparação lógica ao analisar palíndromos.

exercício

Um palíndromo é qualquer palavra, frase, número ou sequência de caracteres que se lê da mesma forma de trás para frente. Crie um script que verifique se uma string é um palíndromo (ignorando maiúsculas/minúsculas e espaços).

código inicial

Aqui está um código inicial para te guiar:

text = input("Enter a word or phrase: ")

# Task: Normalize (lowercase + remove spaces)
# normalized = ...

# Task: Reverse using slicing
# reversed_text = ...

# Task: Compare and print a result message
# if ...:
#     print("Palindrome")
# else:
#     print("Not a palindrome")

conceitos-chave praticados

• Métodos de string (lower(), replace())

• Fatiamento de strings ([::-1])

exercícios de Python com funções e modularidade

Funções permitem escrever código reutilizável e organizado, sem repetir lógica.

a calculadora de fatorial

A calculadora de fatorial ajuda você a entender valores de retorno, que são essenciais para construir programas maiores.

exercício

Defina uma função que receba um inteiro e retorne seu fatorial usando um laço.

A distinção entre imprimir e retornar um valor é especialmente importante. Retornar resultados permite compor sua função com outros códigos — essencial quando os programas crescem além de um único arquivo.

código inicial

Aqui está um código inicial para te guiar:

def factorial(n: int) -> int:
    """Return n! (factorial of n) using a loop."""
    # Task: Decide how to handle n < 0

    # Task: Initialize result
    # result = ...

    # Task: Multiply result by each integer from 1 to n
    # for ...:
    #     ...

    # Task: Return the computed factorial
    # return result
    pass

# Optional quick test
# print(factorial(5))  # expected: 120

conceitos-chave praticados

• Definição de funções
• Cálculos baseados em laço
• Retornar valores vs imprimir

Leia mais sobre funções no nosso tutorial de funções em Python.

validador de números primos

Agora vamos ver uma função validadora de números primos. Isso vai te ajudar a criar funções reutilizáveis.

exercício

Escreva uma função que retorne True se um número for primo e False caso contrário.

A verificação de primos também mostra como funções encapsulam logicamente o código. Uma vez escrita, a função pode ser reutilizada em qualquer lugar sem precisar entender seus detalhes internos.

código inicial

Aqui está um código inicial para te guiar:

def is_prime(n: int) -> bool:
    """Return True if n is prime, otherwise False."""
    # Task: Handle small cases (n <= 1)

    # Task: Check divisibility from 2 up to an appropriate limit
    # for ...:
    #     if ...:
    #         return False

    # Task: If no divisors found, return True
    # return True
    pass

# Optional quick tests
# print(is_prime(2))   # expected: True
# print(is_prime(15))  # expected: False

conceitos-chave praticados

• Laços
• Retornos antecipados
• Eficiência lógica

impressor de argumentos flexível

Isso introduz assinaturas de função avançadas usadas em muitas bibliotecas Python.

exercício

Crie uma função que aceite qualquer número de argumentos usando *args e os imprima um por um.

Este exercício apresenta um dos recursos mais flexíveis do Python: argumentos de comprimento variável. Ele tira seu pensamento de entradas fixas e leva a funções que se adaptam a diferentes usos.

Entender *args facilita a leitura e o uso de bibliotecas reais de Python, nas quais funções frequentemente aceitam um número flexível de parâmetros por conveniência e extensibilidade.

código inicial

Aqui está um código inicial para te guiar:

def print_args(*args) -> None:
    """Print each positional argument on its own line."""
    # Task: Loop over args and print each one
    # for ...:
    #     print(...)
    pass

# Optional quick test
# print_args("hello", 42, True)

conceitos-chave praticados

• Argumentos de comprimento variável
• Flexibilidade de funções

aplicando habilidades de Python com projetos guiados

Exercícios desenvolvem habilidades, mas projetos transformam essas habilidades em confiança.

investigando filmes da Netflix

O projeto guiado Investigating Netflix Movies faz uma pergunta aparentemente simples: os filmes estão ficando mais curtos com o tempo? Para responder, você vai trabalhar com um conjunto real de dados de títulos da Netflix e, aos poucos, transformar linhas brutas em um insight visual claro.

O poder deste projeto está em fazer a ponte entre os fundamentos de Python para iniciantes e a análise de dados aplicada. Você vê como uma lógica simples ganha escala quando combinada com as ferramentas certas — tudo sem precisar instalar nada localmente.

Dr. Semmelweis e a descoberta da lavagem das mãos

O projeto Dr. Semmelweis and the Importance of Handwashing coloca você no papel de um analista de dados investigando um problema histórico real. Em meados do século XIX, o Dr. Ignaz Semmelweis observou taxas de mortalidade incomumente altas em uma ala do hospital em comparação com outra, mas não tinha as ferramentas computacionais para provar o motivo.

Usando registros históricos, você vai analisar dados de mortalidade antes e depois da introdução da lavagem das mãos. O projeto foca em manipular dados tabulares com pandas, calcular taxas e comparar médias ao longo do tempo. 

explorando o mercado de Airbnb em Nova York

No projeto Exploring Airbnb Market Trends, você entra em um cenário muito próximo do trabalho analítico real: dados bagunçados e inconsistentes que precisam de bastante limpeza antes que qualquer análise faça sentido. 

O conjunto de dados traz anúncios de aluguel com preços armazenados como strings, notas de avaliação ausentes e formatação inconsistente.

Sua principal tarefa é limpar e padronizar os dados. O projeto reforça a ideia de que a preparação de dados não é um “pré-requisito chato”, mas uma competência central de análise. Muitas vezes, a maior parte do tempo de profissionais de dados é gasta limpando dados, e este projeto é um ótimo checkpoint prático para essa habilidade.

conclusão

Você começou com variáveis simples e entrada do usuário, depois avançou por controle de fluxo, estruturas de dados, funções e, por fim, aplicou tudo em projetos guiados. Esses exercícios devem ter dado uma boa visão de como o Python é usado em ambientes reais.

Seu próximo passo natural é um aprendizado estruturado. Prática consistente aliada a uma instrução guiada é o caminho mais rápido para transformar exercícios em expertise. Recomendo se inscrever na nossa trilha Python Programming ou Data Scientist para começar.