Tudo o que
já sabemos

Sete blocos, uma lógica só

Tudo que estudamos se encaixa em sete peças. Elas não vivem separadas: um programa de verdade usa todas ao mesmo tempo.

Variáveis e tipos

Uma variável é um nome que aponta para um valor guardado na memória. Em Python o tipo é definido pelo valor — você não declara, só atribui.

idade = 17            # int   → número inteiro
altura = 1.75         # float → número com vírgula
nome = "Ana"          # str   → texto
aprovado = True       # bool  → True ou False

print(type(idade))    # <class 'int'>

# input() SEMPRE devolve texto (str)
idade = input("Idade: ")     # "17" ← texto!
print(idade + 1)             # ERRO

# Converta na hora de ler:
idade = int(input("Idade: "))
nota  = float(input("Nota: "))

Operadores aritméticos

Operadores relacionais

Comparam dois valores e devolvem sempre True ou False. São eles que alimentam o if e a condição do while.

Operadores lógicos

Combinam duas ou mais comparações em uma única condição.

Quanto vale 17 % 5?

Lembrando: % devolve o resto da divisão inteira.

if · elif · else

A estrutura de decisão testa condições de cima para baixo e executa apenas o primeiro bloco cuja condição for verdadeira. O else é a rede de segurança: roda quando nenhuma das anteriores der certo.

nota = float(input("Nota: "))

if nota >= 6.0:
    print("Aprovado")
elif nota >= 4.0:            # só testa se a de cima foi False
    print("Recuperação")
else:                         # só roda se todas foram False
    print("Reprovado")

Condições compostas

Quando a decisão depende de mais de um fator, combinamos comparações com and / or.

# Aprovação por nota E frequência
nota = 7.5
faltas = 8

if nota >= 6.0 and faltas <= 10:
    print("Aprovado")
elif nota >= 6.0 and faltas > 10:
    print("Reprovado por falta")
else:
    print("Reprovado por nota")

# Faixa de valores — o intervalo
idade = 16

if idade >= 12 and idade <= 17:
    print("Adolescente")

# Python aceita o encadeamento:
if 12 <= idade <= 17:
    print("Adolescente")

Os três tropeços do if

if nota >= 6
print("Aprovado")
# SyntaxError + IndentationError

if nota >= 6.0:
    print("Aprovado")
if nota >= 4.0:              # testa de novo!
    print("Recuperação")     # nota 8 imprime os dois

range() dissecado

O range não é um laço — é um gerador de sequência de números. Ele só produz a lista de valores; quem percorre é o for.

O fim nunca entra

Visualizando range(5) — cinco números, começando no zero, parando antes do 5:

# Contar de 1 a 10 (o jeito certo)
for i in range(1, 11):
    print(i)     # 1, 2, 3 ... 10

# Tabuada do 7 — pulando de 7 em 7
for n in range(7, 71, 7):
    print(n)     # 7, 14, 21 ... 70

O laço for

O for repete um bloco uma vez para cada item de uma sequência. Use quando você já sabe quantas vezes vai repetir.

# Percorrendo os VALORES da lista
frutas = ["maçã", "uva", "pera"]

for fruta in frutas:
    print(fruta)
# maçã / uva / pera

# Percorrendo os ÍNDICES da lista
frutas = ["maçã", "uva", "pera"]

for i in range(len(frutas)):
    print(i, "->", frutas[i])
# 0 -> maçã / 1 -> uva / 2 -> pera

O laço while

O while repete enquanto uma condição for verdadeira. Use quando não se sabe de antemão quantas repetições serão necessárias.

# Contador — você controla o índice
i = 1
while i <= 5:
    print(i)
    i = i + 1        # sem isso: laço infinito

# Sentinela — repete até o usuário parar
senha = ""
while senha != "1234":
    senha = input("Senha: ")
print("Acesso liberado")

for ou while?

break e continue

Duas palavras que alteram o fluxo dentro de qualquer laço.

# break — ABANDONA o laço na hora
for n in [4, 9, 7, 2, 8]:
    if n == 7:
        print("Achei o 7!")
        break            # sai do for
    print(n)
# 4 / 9 / Achei o 7!  → 2 e 8 nem são vistos

# continue — PULA para a próxima volta
for n in [4, 9, 7, 2, 8]:
    if n % 2 != 0:
        continue         # ignora os ímpares
    print(n)
# 4 / 2 / 8

Laços aninhados

Um laço dentro do outro. O de fora dá uma volta; o de dentro dá todas as suas voltas antes de o de fora avançar.

for tabuada in range(1, 4):          # externo: 1, 2, 3
    print(f"\nTabuada do {tabuada}")
    for n in range(1, 11):           # interno: 1 a 10, TODA vez
        print(tabuada, "x", n, "=", tabuada * n)

Quantas vezes esse laço repete?

for i in range(2, 10, 3):
    print(i)

Listas (vetores)

Uma variável que guarda vários valores. Cada um ocupa uma posição — e a contagem começa no zero.

Percurso com acumulador

Soma, média, contagem, maior, menor, busca — todos são o mesmo laço. Muda só o que acontece dentro dele.

notas = [7.5, 8.0, 6.5, 9.0]

soma = 0                       # 1 · antes
maior = notas[0]

for i in range(len(notas)):    # 2 · dentro
    soma = soma + notas[i]
    if notas[i] > maior:
        maior = notas[i]

media = soma / len(notas)      # 3 · depois
print("Média:", media, "| Maior:", maior)

O que esse código imprime?

numeros = [3, 8, 5, 12, 7]
total = 0

for n in numeros:
    if n % 2 == 0:
        total = total + n

print(total)

Função é uma receita

Uma função é um bloco de código com nome, que executa uma tarefa e pode ser reaproveitado quantas vezes você quiser. Em vez de repetir o mesmo trecho em três lugares, você o empacota e chama pelo nome.

def saudacao():          # DEFINIR = escrever a receita
    print("Olá, seja bem-vindo!")

saudacao()               # CHAMAR = executar a receita
print("Linha do principal.")
saudacao()

Olá, seja bem-vindo!
Linha do principal.
Olá, seja bem-vindo!
→ três saídas, uma única definição

Parâmetros e argumentos

Parâmetros são as "portas de entrada" da função: variáveis declaradas na definição que recebem valores diferentes a cada chamada.

def media(a, b, c):          # a, b, c → PARÂMETROS
    return (a + b + c) / 3

print(media(7, 8, 6))        # 7, 8, 6 → ARGUMENTOS  → 7.0

return não é print

O print mostra na tela e o valor acaba ali. O return devolve o valor para quem chamou — e encerra a função na hora.

# Só imprime — o valor se perde
def dobro(n):
    print(n * 2)

x = dobro(5)      # imprime 10
print(x)          # None ← nada voltou

# Retorna — dá para reaproveitar
def dobro(n):
    return n * 2

x = dobro(5)      # x recebe 10
print(x + 3)      # 13

O que esse código imprime?

def soma(a, b):
    total = a + b

resultado = soma(3, 4)
print(resultado)

Checklist de depuração

Antes de chamar o professor, passe por estas seis linhas. Elas resolvem a maioria dos erros do bimestre:

Um programa, sete blocos

Escrevam um programa que use todos os conceitos revisados. Se ele funcionar, você está pronto para a avaliação.

Os sete blocos num só programa

Uma solução completa: à esquerda as funções (cada uma faz uma coisa e devolve o resultado), à direita o programa principal que as usa.

def ler_numeros(qtd):        # 1 · entrada + lista
    lista = []
    for i in range(qtd):
        lista.append(int(input(f"Nº {i + 1}: ")))
    return lista

def media(lista):            # 2 · acumulador
    soma = 0
    for n in lista:
        soma += n
    return soma / len(lista)

def contar_pares(lista):     # 3 · % + if
    pares = 0
    for n in lista:
        if n % 2 == 0:
            pares += 1
    return pares

def buscar(lista, alvo):     # 4 · busca linear
    for i in range(len(lista)):
        if lista[i] == alvo:
            return i         # return já encerra o laço
    return -1

while True:                  # 5 · condição de parada
    if input("\nEnter ou 'sair': ") == "sair":
        break

    qtd = int(input("Quantos números? "))
    numeros = ler_numeros(qtd)

    maior = menor = numeros[0]
    for n in numeros:
        if n > maior: maior = n
        if n < menor: menor = n

    pares = contar_pares(numeros)
    print("Média:", media(numeros))
    print("Maior:", maior, "| Menor:", menor)
    print("Pares:", pares,
          "| Ímpares:", len(numeros) - pares)

    alvo = int(input("Buscar qual número? "))
    print("Posição:", buscar(numeros, alvo))