Continuação da introdução à programação usando a linguagem Python.
if, elif, else), a repetir tarefas de forma inteligente com laços while e for, a dominar os comandos break, continue e pass, e a depurar seus programas no Google Colab. Com esses recursos, seus programas deixarão de ser sequências lineares e passarão a resolver problemas reais de forma dinâmica e eficiente.
Nos programas que escrevemos na Parte I, as instruções eram executadas uma após a outra, da primeira à última, em ordem estritamente sequencial. Esse modelo, embora funcional para tarefas simples, é insuficiente para resolver a maioria dos problemas do mundo real. Para que um programa possa tomar decisões e repetir ações, precisamos de mecanismos chamados estruturas de controle de fluxo.
Conforme (MATTHES, 2019), o controle de fluxo é o que permite a um programa responder de forma diferente a situações diferentes, tornando-o dinâmico e adaptável. Existem três estruturas fundamentais de controle de fluxo, presentes em praticamente todas as linguagens de programação:
| Estrutura | Função | Exemplo em Python |
|---|---|---|
| Sequência | Instruções executadas na ordem em que aparecem | Código linear (Parte I) |
| Seleção (Decisão) | Executa blocos diferentes conforme uma condição | if, elif, else |
| Repetição (Iteração) | Repete um bloco de instruções enquanto uma condição for verdadeira | while, for |
Antes de estudar as estruturas condicionais, é essencial compreender as expressões booleanas, pois são elas que determinam qual caminho o programa deve seguir. Uma expressão booleana é qualquer expressão que, ao ser avaliada, resulta em um valor True (verdadeiro) ou False (falso) (SWEIGART, 2020).
Na Parte I, conhecemos os operadores relacionais (==, !=, >, <, >=, <=) e os operadores lógicos (and, or, not). Esses operadores são os blocos fundamentais para construir expressões booleanas. Vamos aprofundar seu uso com exemplos mais elaborados:
# Expressões Booleanas: a base das decisões
idade = 20
tem_carteira = True
saldo = 150.00
# Expressões simples
print(idade >= 18) # True
print(saldo > 200) # False
# Expressões compostas com operadores lógicos
pode_dirigir = idade >= 18 and tem_carteira
print("Pode dirigir?", pode_dirigir) # True
pode_comprar = saldo >= 100 or tem_carteira
print("Pode comprar?", pode_comprar) # True
# Operador 'in': verifica pertencimento
frutas = ["maçã", "banana", "laranja"]
print("banana" in frutas) # True
print("uva" not in frutas) # True
# Valores "truthy" e "falsy" em Python
print(bool(0)) # False (zero é falsy)
print(bool(42)) # True (qualquer número diferente de zero)
print(bool("")) # False (string vazia é falsy)
print(bool("Python")) # True (string não vazia)
print(bool([])) # False (lista vazia é falsy)
print(bool(None)) # False (None é falsy)False) são: 0, 0.0, "" (string vazia), [] (lista vazia), () (tupla vazia), {} (dicionário vazio) e None. Todos os demais valores são truthy (equivalentes a True). Esse comportamento é muito utilizado em condicionais para verificar se uma variável contém algum valor significativo (MATTHES, 2019).
A estrutura condicional é o mecanismo que permite ao programa tomar decisões. Com ela, diferentes blocos de código são executados conforme o resultado de uma expressão booleana. Em Python, a estrutura condicional é construída com as palavras reservadas if (se), elif (senão se) e else (senão) (MENEZES, 2019).
if, elif ou else só será executado se a condição correspondente for verdadeira. Esquecer a indentação (ou usar indentação inconsistente) gera um IndentationError (PAIVA, 2021).
A forma mais básica de decisão. O bloco de código indentado é executado apenas se a condição for verdadeira.
# Condicional simples: if
idade = int(input("Digite sua idade: "))
if idade >= 18:
print("Você é maior de idade.")
print("Pode acessar o sistema.")
print("Fim do programa.") # Sempre executadoQuando precisamos executar um bloco caso a condição seja verdadeira e outro bloco caso seja falsa, usamos if-else.
# Condicional composta: if-else
nota = float(input("Digite sua nota (0 a 10): "))
if nota >= 7.0:
print("Parabéns! Você foi APROVADO(A).")
else:
print("Infelizmente, você foi REPROVADO(A).")
print(f"Sua nota foi: {nota:.1f}")Quando há múltiplas condições mutuamente exclusivas, usamos elif (contração de else if) para testar cada uma delas em sequência. O bloco else ao final é opcional e funciona como um "caso contrário" para todas as condições anteriores (SWEIGART, 2020).
# Condicional encadeada: classificação de notas
nota = float(input("Digite sua nota (0 a 10): "))
if nota >= 9.0:
conceito = "A (Excelente)"
elif nota >= 7.0:
conceito = "B (Bom)"
elif nota >= 5.0:
conceito = "C (Regular)"
elif nota >= 3.0:
conceito = "D (Insuficiente)"
else:
conceito = "E (Reprovado)"
print(f"Nota: {nota:.1f} → Conceito: {conceito}")nota >= 7.0 and nota < 9.0 — se o programa chegou ao elif nota >= 7.0, é porque a nota já é menor que 9.0.
É possível colocar uma estrutura condicional dentro de outra. Isso é chamado de aninhamento (ou nesting). Embora seja uma técnica válida, o excesso de aninhamento torna o código difícil de ler e manter. De modo geral, recomenda-se não ultrapassar dois ou três níveis de profundidade (MENEZES, 2019).
# Condicionais aninhadas: sistema de login simplificado
usuario = input("Usuário: ")
senha = input("Senha: ")
if usuario == "admin":
if senha == "1234":
print("Acesso concedido! Bem-vindo, administrador.")
else:
print("Senha incorreta.")
else:
print("Usuário não encontrado.")Uma alternativa mais elegante ao aninhamento é combinar condições usando operadores lógicos (and, or, not). O exemplo anterior poderia ser reescrito de forma mais concisa:
# Versão com operador lógico (mais concisa)
usuario = input("Usuário: ")
senha = input("Senha: ")
if usuario == "admin" and senha == "1234":
print("Acesso concedido! Bem-vindo, administrador.")
elif usuario == "admin":
print("Senha incorreta.")
else:
print("Usuário não encontrado.")Python oferece uma sintaxe compacta para atribuições condicionais simples, conhecida como expressão ternária. Ela é útil quando o objetivo é atribuir um valor com base em uma única condição (PYTHON SOFTWARE FOUNDATION, 2024).
# Expressão condicional ternária
# Sintaxe: valor_se_verdadeiro if condição else valor_se_falso
idade = int(input("Idade: "))
status = "Maior de idade" if idade >= 18 else "Menor de idade"
print(status)
# Outro exemplo: par ou ímpar
numero = int(input("Número: "))
paridade = "par" if numero % 2 == 0 else "ímpar"
print(f"O número {numero} é {paridade}.")# Calculadora simples com condicionais
n1 = float(input("Primeiro número: "))
op = input("Operação (+, -, *, /): ")
n2 = float(input("Segundo número: "))
if op == "+":
resultado = n1 + n2
elif op == "-":
resultado = n1 - n2
elif op == "*":
resultado = n1 * n2
elif op == "/":
if n2 != 0:
resultado = n1 / n2
else:
resultado = "ERRO: divisão por zero!"
else:
resultado = "Operação inválida!"
print(f"Resultado: {resultado}")O laço while (enquanto) é uma estrutura de repetição que executa um bloco de código enquanto uma condição for verdadeira. Ele é chamado de laço indeterminado porque, ao contrário do for, não sabemos necessariamente de antemão quantas vezes o bloco será repetido — a repetição depende de uma condição que é avaliada a cada iteração (MATTHES, 2019).
# Laço while: contagem regressiva
contador = 5
while contador > 0:
print(f"Contagem: {contador}")
contador -= 1 # ESSENCIAL: atualizar a variável de controle
print("Lançar! 🚀")Contagem: 5
Contagem: 4
Contagem: 3
Contagem: 2
Contagem: 1
Lançar! 🚀
while nunca se tornar falsa, o programa entra em um laço infinito e nunca para de executar. Isso geralmente acontece quando o programador esquece de atualizar a variável de controle dentro do laço. No Google Colab, você pode interromper a execução clicando no botão ⬜ Parar (ou pressionando Ctrl + M + I) (SWEIGART, 2020).
# Padrão 1: Acumulador — somar números até o usuário digitar 0
soma = 0
numero = int(input("Digite um número (0 para sair): "))
while numero != 0:
soma += numero
numero = int(input("Digite um número (0 para sair): "))
print(f"Soma total: {soma}")
# ------------------------------------------------
# Padrão 2: Validação de entrada — garantir dado correto
idade = int(input("Digite sua idade (0 a 150): "))
while idade < 0 or idade > 150:
print("Valor inválido! Tente novamente.")
idade = int(input("Digite sua idade (0 a 150): "))
print(f"Idade registrada: {idade} anos.")
# ------------------------------------------------
# Padrão 3: Sentinela — repetir até uma condição de parada
print("=== Menu ===")
opcao = ""
while opcao != "3":
print("1 - Jogar")
print("2 - Configurações")
print("3 - Sair")
opcao = input("Escolha: ")
if opcao == "1":
print("Iniciando jogo...\n")
elif opcao == "2":
print("Abrindo configurações...\n")
elif opcao == "3":
print("Até logo!")
else:
print("Opção inválida!\n")Os laços de repetição são uma das fontes mais comuns de erros em programas de iniciantes. Erros como laços infinitos, execução a mais ou a menos (erro off-by-one) e condições de parada incorretas são frequentes. Nesta seção, aprenderemos a identificar e corrigir esses erros por meio de técnicas simples de depuração — um tema que será expandido na seção 10 (SWEIGART, 2020).
A técnica mais simples (e surpreendentemente eficaz) de depuração é inserir chamadas print() dentro do laço para inspecionar o valor das variáveis a cada iteração.
# Programa com BUG: deveria somar de 1 a 5, mas há um erro
soma = 0
i = 1
while i <= 5:
soma += i
print(f"[DEBUG] i={i}, soma={soma}") # linha de depuração
# ERRO: esquecemos de incrementar i!
# i += 1 ← esta linha está faltando!
# Ao executar, o print de depuração mostraria:
# [DEBUG] i=1, soma=1
# [DEBUG] i=1, soma=2
# [DEBUG] i=1, soma=3 ← i nunca muda → laço infinito!
# --- Versão corrigida ---
soma = 0
i = 1
while i <= 5:
soma += i
print(f"[DEBUG] i={i}, soma={soma}")
i += 1 # Agora i é incrementado corretamente
print(f"Soma final: {soma}") # 15Python possui uma sintaxe exclusiva: o bloco else após um while. Esse bloco é executado apenas se o laço terminar normalmente (sem ser interrompido por break). É útil para detectar se uma busca foi bem-sucedida (PYTHON SOFTWARE FOUNDATION, 2024).
# while-else: verificar se um número é primo
numero = int(input("Digite um número inteiro positivo: "))
divisor = 2
while divisor < numero:
if numero % divisor == 0:
print(f"{numero} NÃO é primo (divisível por {divisor}).")
break
divisor += 1
else:
# Executado apenas se o while terminou sem break
print(f"{numero} é primo!")O laço for em Python é uma estrutura de repetição determinada, projetada para iterar (percorrer) sobre os elementos de uma sequência — como uma lista, uma string, um intervalo numérico ou qualquer outro objeto iterável. Diferentemente do while, o for é ideal quando sabemos de antemão quantas vezes a repetição deve ocorrer ou quando queremos processar cada item de uma coleção (MATTHES, 2019).
# Iterando sobre uma lista
frutas = ["maçã", "banana", "laranja", "uva"]
for fruta in frutas:
print(f"Eu gosto de {fruta}!")
# Iterando sobre uma string (caractere por caractere)
palavra = "Python"
for letra in palavra:
print(letra, end=" ") # P y t h o n
print() # Quebra de linhaA função range() gera uma sequência de números inteiros e é a companheira mais frequente do for. Ela aceita até três argumentos: range(início, fim, passo) (PAIVA, 2021).
| Forma | Descrição | Exemplo | Sequência gerada |
|---|---|---|---|
range(n) |
De 0 até n-1, passo 1 | range(5) |
0, 1, 2, 3, 4 |
range(a, b) |
De a até b-1, passo 1 | range(2, 7) |
2, 3, 4, 5, 6 |
range(a, b, p) |
De a até b-1, passo p | range(0, 10, 2) |
0, 2, 4, 6, 8 |
range(a, b, -p) |
De a até b+1, passo -p (decrescente) | range(10, 0, -2) |
10, 8, 6, 4, 2 |
range() não é incluído na sequência. Assim, range(1, 6) gera os números 1, 2, 3, 4, 5 — mas não o 6. Esse é outro erro frequente entre iniciantes e é análogo ao conceito matemático de intervalo semiaberto [a, b).
# Repetir 5 vezes (range com 1 argumento)
for i in range(5):
print(f"Iteração {i}")
# Saída: Iteração 0, Iteração 1, ..., Iteração 4
# Tabuada de um número (range com 2 argumentos)
n = int(input("Tabuada de: "))
for i in range(1, 11):
print(f"{n} x {i} = {n * i}")
# Números pares de 0 a 20 (range com 3 argumentos)
print("Números pares de 0 a 20:")
for par in range(0, 21, 2):
print(par, end=" ") # 0 2 4 6 8 10 12 14 16 18 20
print()
# Contagem regressiva (passo negativo)
print("Contagem regressiva:")
for i in range(10, 0, -1):
print(i, end=" ")
print("Lançar! 🚀")Quando precisamos do índice de cada elemento durante a iteração, usamos enumerate(). Essa função retorna pares (índice, valor) a cada iteração, eliminando a necessidade de manter um contador manualmente (PYTHON SOFTWARE FOUNDATION, 2024).
# enumerate(): iterando com índice e valor
linguagens = ["Python", "Java", "C++", "JavaScript"]
for indice, nome in enumerate(linguagens):
print(f"{indice + 1}. {nome}")
# Saída:
# 1. Python
# 2. Java
# 3. C++
# 4. JavaScript
# Também pode especificar o valor inicial do índice:
for i, nome in enumerate(linguagens, start=1):
print(f"{i}. {nome}")# Padrão: Acumulador — somar N números digitados pelo usuário
n = int(input("Quantos números deseja somar? "))
soma = 0
for i in range(1, n + 1):
valor = float(input(f"Número {i}: "))
soma += valor
print(f"Soma: {soma:.2f}")
print(f"Média: {soma / n:.2f}")
# ------------------------------------------------
# Padrão: Contador — contar pares em uma faixa
pares = 0
impares = 0
for num in range(1, 21):
if num % 2 == 0:
pares += 1
else:
impares += 1
print(f"De 1 a 20: {pares} pares e {impares} ímpares.")
# ------------------------------------------------
# Padrão: Maior e menor valor
n = int(input("Quantos números? "))
maior = None
menor = None
for i in range(n):
valor = float(input(f"Valor {i + 1}: "))
if maior is None or valor > maior:
maior = valor
if menor is None or valor < menor:
menor = valor
print(f"Maior: {maior} | Menor: {menor}")Assim como o while, o for também pode ter um bloco else. Ele é executado quando o laço termina normalmente (sem break).
# for-else: buscar um elemento em uma lista
nomes = ["Ana", "Bruno", "Carla", "Daniel"]
busca = input("Buscar nome: ")
for nome in nomes:
if nome.lower() == busca.lower():
print(f"'{nome}' encontrado na lista!")
break
else:
# Executado somente se o break NÃO foi acionado
print(f"'{busca}' não foi encontrado.")Python oferece três instruções especiais que alteram o comportamento normal de laços de repetição: break, continue e pass. Cada uma tem uma finalidade distinta e deve ser utilizada com critério (SWEIGART, 2020).
| Instrução | Efeito | Funciona em |
|---|---|---|
break |
Interrompe o laço imediatamente e segue para a próxima instrução após o laço | for, while |
continue |
Pula o restante da iteração atual e volta ao início do laço para a próxima iteração | for, while |
pass |
Não faz absolutamente nada; serve como placeholder sintático | Qualquer bloco |
# break: encontrar o primeiro múltiplo de 7 entre 50 e 100
for num in range(50, 101):
if num % 7 == 0:
print(f"Primeiro múltiplo de 7: {num}")
break # Encerra o laço assim que encontra
# Saída: Primeiro múltiplo de 7: 56
# break com while: jogo de adivinhação
import random
secreto = random.randint(1, 20)
tentativas = 0
while True: # Laço "infinito" controlado por break
palpite = int(input("Adivinhe o número (1-20): "))
tentativas += 1
if palpite == secreto:
print(f"Acertou em {tentativas} tentativa(s)!")
break
elif palpite < secreto:
print("Muito baixo!")
else:
print("Muito alto!")# continue: imprimir apenas números ímpares de 1 a 10
for i in range(1, 11):
if i % 2 == 0:
continue # Pula os pares
print(i, end=" ")
# Saída: 1 3 5 7 9
print()
# continue: processar notas válidas e ignorar inválidas
total = 0
validas = 0
for i in range(5):
entrada = input(f"Nota {i + 1}: ")
if not entrada.replace(".", "", 1).isdigit():
print(" → Ignorada (não é número).")
continue
nota = float(entrada)
if nota < 0 or nota > 10:
print(" → Ignorada (fora do intervalo 0-10).")
continue
total += nota
validas += 1
if validas > 0:
print(f"Média das notas válidas: {total / validas:.2f}")
else:
print("Nenhuma nota válida foi digitada.")A instrução pass não executa nenhuma ação. Ela existe para servir como placeholder em blocos que ainda não foram implementados (por exemplo, durante o planejamento do código). Em Python, um bloco vazio gera erro de sintaxe; o pass resolve esse problema (MENEZES, 2019).
# pass: esqueleto de um programa (planejamento)
nota = float(input("Nota: "))
if nota >= 7:
print("Aprovado!")
elif nota >= 5:
pass # TODO: implementar lógica de recuperação
else:
pass # TODO: implementar lógica de reprovação
# pass em um laço: ignorar certos valores silenciosamente
for i in range(10):
if i % 3 == 0:
pass # Nenhuma ação especial para múltiplos de 3 (por enquanto)
else:
print(i, end=" ")
# Saída: 1 2 4 5 7 8break → "Saia do laço agora!"continue → "Pule esta iteração e vá para a próxima!"pass → "Não faça nada aqui (por enquanto)."
Depuração (ou debugging) é o processo de identificar, localizar e corrigir erros em um programa. O nome remonta à década de 1940, quando Grace Hopper encontrou uma mariposa (bug) causando problemas em um computador. Saber depurar é tão importante quanto saber programar — programadores experientes dedicam uma parcela significativa do seu tempo a essa atividade (SWEIGART, 2020).
Antes de depurar, é essencial distinguir os três tipos de erro que podem ocorrer:
| Tipo de Erro | Quando Ocorre | Exemplo |
|---|---|---|
Erro de SintaxeSyntaxError |
O código viola as regras gramaticais do Python; detectado antes da execução | if x == 5 (falta :) |
| Erro de Execução (Exceção) |
O código está sintaticamente correto, mas falha durante a execução | 10 / 0 → ZeroDivisionError |
| Erro de Lógica | O programa executa sem erro, mas produz resultado incorreto | Calcular média com n1 + n2 / 2 em vez de (n1 + n2) / 2 |
Quando ocorre uma exceção, Python exibe uma mensagem chamada traceback, que indica o arquivo, a linha e o tipo de erro. Aprender a ler o traceback é a habilidade mais importante de depuração (PAIVA, 2021).
# Código com erro proposital
nome = "Maria"
idade = "25" # Deveria ser int, mas é str
# A linha abaixo causará erro:
ano_nascimento = 2026 - idade
# Python exibirá algo como:
# ---------------------------------------------------------------------------
# TypeError Traceback (most recent call last)
# <ipython-input-1-...> in <cell line: 4>()
# 2 idade = "25"
# ----> 4 ano_nascimento = 2026 - idade ← LINHA DO ERRO
#
# TypeError: unsupported operand type(s) for -: 'int' and 'str'
# ↑ TIPO DO ERRO ↑ DESCRIÇÃO DO PROBLEMA2. Suba até a seta (---->) — ela indica a linha exata que causou o erro.
3. Analise as variáveis e expressões naquela linha para entender o problema.
| Exceção | Causa Comum | Exemplo |
|---|---|---|
SyntaxError |
Código escrito incorretamente | Falta de :, parênteses não fechados |
IndentationError |
Indentação inconsistente ou ausente | Mistura de tabs e espaços |
NameError |
Variável usada antes de ser definida | print(x) sem declarar x |
TypeError |
Operação entre tipos incompatíveis | "5" + 3 |
ValueError |
Valor inadequado para a operação | int("abc") |
ZeroDivisionError |
Divisão por zero | 10 / 0 |
IndexError |
Índice fora dos limites de uma lista | lista[10] quando a lista tem 3 itens |
O Google Colab, por ser baseado em Jupyter Notebooks, oferece um ambiente interativo que facilita a depuração. A seguir, apresentamos as técnicas mais úteis para iniciantes (PYTHON SOFTWARE FOUNDATION, 2024):
Já vimos esta técnica na seção 6. Consiste em inserir chamadas print() estratégicas para exibir o valor de variáveis em pontos-chave do programa. Apesar de simples, é a técnica mais utilizada mesmo por programadores experientes.
# Dica: use f-strings com rótulos descritivos
# para tornar a saída de depuração mais legível
x = 10
y = 3
resultado = x ** y + 2 * x
# Depuração com f-string "auto-documentada" (Python 3.8+)
print(f"{x = }") # x = 10
print(f"{y = }") # y = 3
print(f"{resultado = }") # resultado = 1020
# Verificando tipos durante a depuração
print(f"{type(x) = }") # type(x) = <class 'int'>O Colab permite dividir o código em células independentes. Isso é uma vantagem enorme para depuração: você pode executar cada parte do programa separadamente, verificando os resultados intermediários antes de prosseguir.
2. Execute uma célula de cada vez com
Shift + Enter.3. Após cada célula, verifique os valores das variáveis digitando o nome da variável em uma nova célula e executando-a (o Colab exibe o valor automaticamente).
4. Quando encontrar a célula problemática, isole a linha do erro.
Quando um erro ocorre em uma célula do Colab, você pode ativar o depurador interativo digitando %debug na célula seguinte. Isso abre uma sessão interativa onde é possível inspecionar variáveis, executar comandos e navegar pela pilha de execução (PYTHON SOFTWARE FOUNDATION, 2024).
# Célula 1: código com erro
numeros = [10, 20, 0, 5]
resultados = []
for n in numeros:
resultados.append(100 / n) # ZeroDivisionError quando n=0
# ------------------------------------------------
# Célula 2: ativar o depurador após o erro
%debug
# No prompt do depurador (ipdb>), digite:
# p n → mostra o valor de n (será 0)
# p numeros → mostra a lista completa
# p resultados → mostra os resultados até o erro
# q → sai do depuradorPara inspecionar o programa em um ponto específico antes que o erro ocorra, use breakpoint() (Python 3.7+) ou import pdb; pdb.set_trace(). Quando a execução chegar nessa linha, o programa pausa e abre o depurador interativo.
# Usando breakpoint() para pausar a execução
def calcular_media(notas):
soma = 0
for nota in notas:
soma += nota
breakpoint() # Pausa aqui a cada iteração
return soma / len(notas)
notas = [8.5, 7.0, 9.2]
media = calcular_media(notas)
# No prompt do depurador (Pdb), comandos úteis:
# n → executa a próxima linha (next)
# c → continua a execução até o próximo breakpoint (continue)
# p x → exibe o valor da variável x (print)
# l → mostra o código ao redor da linha atual (list)
# q → encerra o depurador (quit)Embora o tratamento completo de exceções seja tema para um próximo artigo, a estrutura try-except é uma ferramenta básica de depuração que todo iniciante deve conhecer. Ela permite capturar um erro e executar um bloco alternativo em vez de interromper o programa (MATTHES, 2019).
# try-except: capturando erros de forma elegante
# Sem try-except: o programa para se o usuário digitar texto
# idade = int(input("Idade: ")) # ValueError se digitar "abc"
# Com try-except: o programa trata o erro e continua
try:
idade = int(input("Idade: "))
print(f"Sua idade é {idade}.")
except ValueError:
print("Erro: digite um número inteiro válido!")
# Combinando try-except com while para validação robusta
while True:
try:
nota = float(input("Digite sua nota (0-10): "))
if 0 <= nota <= 10:
break
print("A nota deve estar entre 0 e 10.")
except ValueError:
print("Entrada inválida! Digite um número.")
print(f"Nota registrada: {nota}")| Atalho | Função |
|---|---|
Shift + Enter |
Executar célula atual e avançar para a próxima |
Ctrl + Enter |
Executar célula atual sem avançar |
Ctrl + M + I |
Interromper execução (útil para laços infinitos) |
Ctrl + M + . |
Reiniciar o runtime (limpa todas as variáveis) |
Ctrl + M + A |
Inserir célula de código acima |
Ctrl + M + B |
Inserir célula de código abaixo |
Ctrl + Shift + H |
Abrir histórico de versões do notebook |
Para consolidar todos os conceitos desta Parte II — condicionais, laços while e for, break, continue e tratamento de exceções —, vamos construir um jogo de adivinhação mais robusto:
# ================================================
# Jogo de Adivinhação - Exemplo Integrador
# Conceitos: if/elif/else, while, for, break,
# continue, try-except, f-strings
# ================================================
import random
# Configuração
MINIMO = 1
MAXIMO = 50
MAX_TENTATIVAS = 7
secreto = random.randint(MINIMO, MAXIMO)
tentativas = []
acertou = False
print(f"🎯 Adivinhe o número entre {MINIMO} e {MAXIMO}!")
print(f"Você tem {MAX_TENTATIVAS} tentativas.\n")
# Laço principal do jogo
for rodada in range(1, MAX_TENTATIVAS + 1):
restantes = MAX_TENTATIVAS - rodada + 1
print(f"--- Tentativa {rodada}/{MAX_TENTATIVAS} ---")
# Validação de entrada com try-except e while
while True:
try:
palpite = int(input(f"Seu palpite ({MINIMO}-{MAXIMO}): "))
if palpite < MINIMO or palpite > MAXIMO:
print(f"Fora do intervalo! Digite entre {MINIMO} e {MAXIMO}.")
continue
if palpite in tentativas:
print("Você já tentou esse número! Tente outro.")
continue
break # Entrada válida e não repetida
except ValueError:
print("Digite um número inteiro válido!")
tentativas.append(palpite)
# Verificar o palpite
if palpite == secreto:
acertou = True
print(f"\n🎉 PARABÉNS! O número era {secreto}!")
print(f"Você acertou em {rodada} tentativa(s)!")
break
elif palpite < secreto:
dica = "⬆ Muito baixo!"
else:
dica = "⬇ Muito alto!"
# Dica extra de proximidade
diferenca = abs(palpite - secreto)
if diferenca <= 3:
temperatura = "🔥 Quente!"
elif diferenca <= 10:
temperatura = "😐 Morno."
else:
temperatura = "🧊 Frio!"
print(f"{dica} {temperatura} (restam {restantes - 1})\n")
# Mensagem final (for-else)
if not acertou:
print(f"\n😞 Suas tentativas acabaram! O número era {secreto}.")
# Histórico
print(f"\nHistórico de palpites: {tentativas}")Nesta Parte II, avançamos de forma significativa no aprendizado de Python. Partimos das expressões booleanas — a base lógica de toda decisão computacional — e exploramos as estruturas condicionais (if, elif, else), que permitem ao programa reagir de maneira diferente a cada situação. Em seguida, dominamos os laços de repetição: o while, para repetições indeterminadas controladas por condição, e o for, para iterações determinadas sobre sequências e intervalos numéricos com range().
Aprendemos também os comandos break, continue e pass, que oferecem controle fino sobre o comportamento dos laços. Por fim, mergulhamos nas técnicas de depuração — desde o simples print() estratégico até o uso do depurador interativo (%debug) e do try-except — ferramentas indispensáveis para encontrar e corrigir erros no Google Colab.
Com o domínio das estruturas de controle de fluxo e das técnicas de depuração, seus programas agora podem tomar decisões, repetir tarefas, validar entradas e lidar com erros de forma elegante. O próximo passo natural é explorar as funções, que permitirão organizar o código em blocos reutilizáveis, e as estruturas de dados (listas, tuplas, dicionários), que ampliarão enormemente o repertório de problemas que você poderá resolver.
while e for, ou construa um validador de CPF. Quanto mais você pratica, mais natural a programação se torna. Como reforça (SWEIGART, 2020), a melhor forma de aprender a programar é programando!
Visto no Brasil Acadêmico
Comentários