Resumão de Python — Aulas 03 a 08

Este documento é uma referência rápida de tudo que você aprendeu até aqui. Não substitui as aulas — use-o para revisar antes de provas, consultar sintaxe durante exercícios ou identificar lacunas no seu aprendizado.

O que este resumão cobre

Aula	Tema	Seção aqui
03	Tipos, variáveis e operadores	§1 e §2
04	Estruturas de decisão	§3
05	Funções e modularização	§4
06	Bibliotecas e depuração	§5
07	Estruturas de repetição	§6
08	Strings	§7

1. Tipos de Dados e Variáveis

1.1 Os quatro tipos primitivos

Python identifica automaticamente o tipo pelo valor atribuído (tipagem dinâmica):

Tipo	O que armazena	Exemplo de literal
`int`	Números inteiros (sem casas decimais)	`42`, `-7`, `0`
`float`	Números reais (com casas decimais)	`3.14`, `-0.5`, `1.0`
`str`	Texto (sequência de caracteres)	`"olá"`, `'Python'`
`bool`	Valor lógico	`True`, `False`

idade   = 21          # int
altura  = 1.73        # float
nome    = "Diego"     # str
ativo   = True        # bool

print(type(idade))    # <class 'int'>
print(type(altura))   # <class 'float'>
print(type(nome))     # <class 'str'>
print(type(ativo))    # <class 'bool'>

1.2 Conversão entre tipos

Use as funções de conversão quando precisar transformar um tipo em outro — especialmente ao ler entradas do usuário com input(), que sempre retorna str:

Função	Converte para	Exemplo
`int(x)`	`int`	`int("42")` → `42`
`float(x)`	`float`	`float("3.14")` → `3.14`
`str(x)`	`str`	`str(100)` → `"100"`
`bool(x)`	`bool`	`bool(0)` → `False`

entrada = input("Digite sua idade: ")   # entrada é str
idade   = int(entrada)                  # converte para int
print(idade + 1)                        # agora funciona

:::danger Armadilha frequente input() sempre retorna str. Somar "5" + 3 causa TypeError. Sempre converta antes de operar. :::

1.3 Boas práticas para nomes de variáveis

Use snake_case: nota_final, nome_aluno, total_itens
Nomes descritivos: media_turma em vez de m
Evite palavras reservadas do Python: for, if, print, type, list…

2. Operadores

2.1 Operadores aritméticos

Operador	Operação	Exemplo	Resultado
`+`	Soma	`10 + 3`	`13`
`-`	Subtração	`10 - 3`	`7`
`*`	Multiplicação	`10 * 3`	`30`
`/`	Divisão real	`10 / 3`	`3.333…`
`//`	Divisão inteira	`10 // 3`	`3`
`%`	Resto (módulo)	`10 % 3`	`1`
`**`	Potência	`2 ** 10`	`1024`

a, b = 10, 3
print(a / b)    # 3.3333333333333335  ← sempre float
print(a // b)   # 3                   ← descarta o decimal
print(a % b)    # 1                   ← resto da divisão inteira
print(a ** b)   # 1000

:::tip Usos comuns de %

Verificar paridade: n % 2 == 0 → par
Verificar divisibilidade: n % 5 == 0 → múltiplo de 5
Rotação de índices em ciclos :::

2.2 Operadores relacionais

Sempre retornam True ou False:

Operador	Significado	Exemplo (`a=10, b=3`)	Resultado
`==`	Igual	`a == 10`	`True`
`!=`	Diferente	`a != b`	`True`
`>`	Maior que	`a > b`	`True`
`<`	Menor que	`a < b`	`False`
`>=`	Maior ou igual	`b >= 3`	`True`
`<=`	Menor ou igual	`a <= 5`	`False`

:::danger Armadilha frequente = é atribuição. == é comparação. Escrever if x = 5: é erro de sintaxe. :::

2.3 Operadores lógicos

Combinam expressões booleanas:

Operador	Regra	Exemplo	Resultado
`and`	Verdadeiro somente se ambos forem `True`	`True and False`	`False`
`or`	Verdadeiro se pelo menos um for `True`	`True or False`	`True`
`not`	Inverte o valor lógico	`not True`	`False`

idade          = 20
tem_documento  = True

pode_entrar    = idade >= 18 and tem_documento   # True
dia_de_folga   = False or True                   # True
bloqueado      = not pode_entrar                 # False

2.4 Ordem de precedência

Do maior para o menor (operadores na mesma linha têm precedência igual):

Maior prioridade
  **                        (potência)
  *, /, //, %               (multiplicação / divisão)
  +, -                      (adição / subtração)
  ==, !=, >, <, >=, <=      (relacional)
  not                       (negação lógica)
  and                       (conjunção)
  or                        (disjunção)
Menor prioridade

Use parênteses para tornar a intenção explícita quando houver dúvida:

# Sem parênteses — pode ser confuso
resultado = 2 + 3 * 4         # 14  (multiplicação primeiro)

# Com parênteses — intenção clara
resultado = (2 + 3) * 4       # 20

3. Estruturas de Decisão

3.1 Mapa de uso

Situação	Estrutura
Executar algo apenas se uma condição for `True`	`if` simples
Dois caminhos mutuamente exclusivos	`if / else`
Três ou mais faixas/categorias	`if / elif / else`
Comparar uma variável com valores fixos e conhecidos	`match / case`

3.2 Formas do `if`

# Decisão simples
if idade >= 18:
    print("Maior de idade")

# Decisão binária
if nota >= 6.0:
    print("Aprovado")
else:
    print("Reprovado")

# Múltiplos caminhos — elif é avaliado em ordem; para assim que uma condição for True
if media >= 9:
    conceito = "A"
elif media >= 8:
    conceito = "B"
elif media >= 7:
    conceito = "C"
elif media >= 6:
    conceito = "D"
else:
    conceito = "F"

:::tip Regra de ouro do elif Os ramos são avaliados de cima para baixo e o primeiro True encerra a busca. Por isso, coloque as faixas mais restritivas (maiores valores) primeiro. :::

3.3 Condições compostas

# AND: as duas devem ser True
if idade >= 18 and tem_documento:
    print("Entrada permitida")

# OR: pelo menos uma True
if dia == "sábado" or dia == "domingo":
    print("Fim de semana")

# NOT: inverte
if not esta_bloqueado:
    print("Acesso liberado")

3.4 `match / case` (Python 3.10+)

Use quando você compara uma variável com valores fixos e enumeráveis. O case _: é o caso padrão (equivalente ao else):

opcao = 2

match opcao:
    case 1:
        print("Cadastrar")
    case 2:
        print("Listar")
    case 3:
        print("Sair")
    case _:
        print("Opção inválida")

Múltiplos valores no mesmo case com |:

match dia:
    case "sábado" | "domingo":
        print("Fim de semana")
    case _:
        print("Dia útil")

:::note match/case vs if/elif Use match/case para valores discretos e fixos (menu, código de status, nome de comando). Use if/elif para intervalos e condições complexas (faixas de notas, comparações com and/or). :::

4. Funções

4.1 Anatomia de uma função

#        ① nome      ② parâmetros
def calcular_media(n1, n2, n3):
    """③ Docstring: descreve o que a função faz."""
    resultado = (n1 + n2 + n3) / 3   # ④ corpo
    return resultado                  # ⑤ retorno

① def — palavra-chave que inicia a definição
② Parâmetros — variáveis locais que recebem os argumentos na chamada
③ Docstring — string de documentação (opcional, mas recomendada)
④ Corpo — bloco indentado com a lógica da função
⑤ return — entrega um valor ao chamador (sem return, a função devolve None)

4.2 Chamada e argumentos

# Definição
def soma(a, b):
    return a + b

# Chamadas
resultado = soma(10, 7)       # argumentos posicionais
print(resultado)              # 17

print(soma(3, soma(4, 5)))    # composição: soma(3, 9) → 12

4.3 Parâmetros com valor padrão

Tornam o argumento opcional. Sempre vêm depois dos parâmetros obrigatórios:

def saudacao(nome, periodo="dia"):
    print(f"Bom {periodo}, {nome}!")

saudacao("Ana")              # Bom dia, Ana!
saudacao("Carlos", "tarde")  # Boa tarde, Carlos!

4.4 `return` vs `print` — a distinção mais importante

	`print`	`return`
O que faz	Exibe na tela	Entrega valor ao chamador
Quem usa	O humano	O programa
Valor resultante da chamada	`None`	O valor especificado
Permite composição?	❌	✅

def dobro_errado(n):
    print(n * 2)          # exibe, mas não entrega

def dobro(n):
    return n * 2          # entrega

x = dobro_errado(5)       # x é None  ← bug silencioso
y = dobro(5)              # y é 10    ← correto
print(y + 1)              # 11

:::danger Armadilha frequente Usar print dentro de uma função quando se precisa do valor para cálculos posteriores é um dos bugs mais comuns em iniciantes. Dentro de funções, prefira return. :::

4.5 Escopo de variáveis

Variáveis criadas dentro de uma função são locais — não existem fora dela:

def quadrado(x):
    resultado = x ** 2    # resultado é local
    return resultado

print(quadrado(5))        # 25
# print(resultado)        # NameError: não existe aqui

Variáveis definidas fora de qualquer função são globais e podem ser lidas dentro de funções, mas não modificadas sem global (evite global — use parâmetros e return):

# ❌ Ruim — usa global
contador = 0
def incrementar():
    global contador
    contador += 1

# ✅ Bom — parâmetro + return
def incrementar(contador):
    return contador + 1

contador = incrementar(contador)

4.6 Composição de funções

A saída de uma função pode ser a entrada de outra — isso é composição:

def calcular_media(n1, n2, n3):
    return (n1 + n2 + n3) / 3

def aprovado(media, minima=6.0):
    return media >= minima

def formatar(nome, media, situacao):
    return f"{nome} | {media:.2f} | {situacao}"

# Programa principal
media    = calcular_media(8.0, 7.5, 9.0)          # 8.17
status   = "Aprovado" if aprovado(media) else "Reprovado"
relatorio = formatar("Ana", media, status)
print(relatorio)   # Ana | 8.17 | Aprovado

5. Bibliotecas Padrão e Depuração

5.1 Como importar

import math                    # importa o módulo inteiro
from math import sqrt, pi      # importa nomes específicos
import random                  # outro módulo

5.2 Módulo `math`

Função / Constante	O que faz	Exemplo	Resultado
`math.pi`	Constante π	`math.pi`	`3.14159…`
`math.sqrt(x)`	Raiz quadrada	`math.sqrt(25)`	`5.0`
`math.ceil(x)`	Arredonda para cima	`math.ceil(2.1)`	`3`
`math.floor(x)`	Arredonda para baixo	`math.floor(2.9)`	`2`
`math.pow(x, y)`	Potência (retorna `float`)	`math.pow(2, 8)`	`256.0`
`math.log(x)`	Logaritmo natural	`math.log(math.e)`	`1.0`

import math

def area_circulo(raio):
    return math.pi * math.pow(raio, 2)

def hipotenusa(a, b):
    return math.sqrt(a**2 + b**2)

print(f"Área (r=5): {area_circulo(5):.2f}")   # 78.54
print(f"Hipotenusa (3,4): {hipotenusa(3,4)}") # 5.0

5.3 Módulo `random`

Função	O que faz	Exemplo
`random.randint(a, b)`	Inteiro aleatório entre a e b (inclusive)	`random.randint(1, 6)`
`random.random()`	Float aleatório entre 0.0 e 1.0	`random.random()`
`random.choice(seq)`	Escolhe um elemento aleatório	`random.choice(["A","B","C"])`
`random.shuffle(seq)`	Embaralha a lista no lugar	`random.shuffle(cartas)`

import random

def rolar_dado(lados=6):
    return random.randint(1, lados)

print(rolar_dado())     # número entre 1 e 6
print(rolar_dado(20))   # número entre 1 e 20

5.4 Outros módulos úteis da biblioteca padrão

Módulo	Principais recursos
`statistics`	`mean()`, `median()`, `mode()`, `stdev()`
`datetime`	`datetime.now()`, `date.today()`, `timedelta`
`os`	`getcwd()`, `listdir()`, `path.exists()`
`json`	`dumps()`, `loads()`, `dump()`, `load()`
`string`	`ascii_letters`, `digits`, `punctuation`

5.5 Depuração com `print`

Adicione print temporários com prefixo [DEBUG] para inspecionar valores durante o desenvolvimento:

def calcular_desconto(preco, percentual):
    print(f"[DEBUG] preco={preco}, percentual={percentual}")
    desconto = preco * (percentual / 100)
    print(f"[DEBUG] desconto={desconto}")
    return preco - desconto

print(calcular_desconto(200, 15))   # Preço final: 170.0

Remova os [DEBUG] antes de entregar o código. No VS Code, use o atalho Ctrl+H para buscar e substituir todos de uma vez.

5.6 Depuração com o debugger do VS Code

Ação	Atalho	O que faz
Definir breakpoint	Clique na margem esquerda	Pausa a execução naquela linha
Iniciar depuração	`F5`	Executa até o próximo breakpoint
Step Over	`F10`	Executa a linha atual, sem entrar em funções
Step Into	`F11`	Entra dentro da função chamada
Continue	`F5`	Retoma até o próximo breakpoint

6. Estruturas de Repetição

6.1 Mapa de decisão: `for` ou `while`?

Situação	Use
Quantidade de iterações conhecida antes de começar	`for`
Percorrer todos os elementos de uma coleção ou string	`for`
Repetir enquanto uma condição for verdadeira	`while`
Quantidade de iterações desconhecida (depende de entrada)	`while`
Parada antecipada por condição interna	`for` + `break`
Pular itens específicos mantendo o laço	`for` + `continue`

6.2 Laço `for`

# Percorrer uma lista
frutas = ["maçã", "banana", "laranja"]
for fruta in frutas:
    print(fruta)

# Percorrer uma string
for letra in "Python":
    print(letra)   # P y t h o n (um por linha)

6.3 `range()` — formas de uso

range(fim)              # 0, 1, …, fim-1
range(inicio, fim)      # inicio, …, fim-1
range(inicio, fim, passo)

Chamada	Sequência gerada
`range(5)`	`0 1 2 3 4`
`range(2, 7)`	`2 3 4 5 6`
`range(0, 10, 3)`	`0 3 6 9`
`range(10, 0, -2)`	`10 8 6 4 2`

:::danger Armadilha frequente O limite superior do range é exclusivo. range(1, 11) vai de 1 a 10, não de 1 a 11. :::

6.4 Laço `while`

# Forma básica
contador = 0
while contador < 5:
    print(contador)
    contador += 1    # ← sem isso, loop infinito!

# Padrão sentinela — leitura antes do while, releitura no fim do corpo
n = int(input())
soma = 0
quantidade = 0

while n != -1:
    soma      += n
    quantidade += 1
    n = int(input())   # ← releitura SEMPRE no fim do corpo

if quantidade > 0:
    print(f"Média: {soma / quantidade:.2f}")

:::danger Os três erros clássicos do while

Sem atualização da condição no corpo → loop infinito
Releitura no início do corpo → sentinela é processado
Variável não inicializada antes do while → NameError :::

6.5 `break` e `continue`

# break — encerra o laço imediatamente
for numero in range(1, 100):
    if numero % 7 == 0:
        print(f"Primeiro múltiplo de 7: {numero}")   # 7
        break

# continue — pula para a próxima iteração
for numero in range(1, 11):
    if numero % 2 == 0:
        continue           # pula os pares
    print(numero)          # imprime 1 3 5 7 9

:::tip break não transforma for em while O for ainda tem um teto máximo definido pelo range ou pelo tamanho da coleção. Use while quando realmente não há limite superior conhecido. :::

6.6 Ciclo de vida das variáveis em laços

Esta é a decisão mais importante ao escrever laços. Responda sobre cada variável:

"Esta variável pertence a um item ou ao conjunto?"

Tipo	Onde inicializar	Exemplo
Persistente — acumula ao longo de todas as iterações	Fora do laço	`total_aprovados` na turma inteira
Com reset — começa do zero a cada iteração	Dentro do laço	`soma` das notas de um aluno
Flag booleana — registra evento em um item	Dentro do laço	`tem_nota_zero` desse aluno

num_alunos = int(input())
aprovados  = 0                         # persistente — pertence à TURMA

for a in range(num_alunos):
    soma       = 0                     # reset      — pertence ao ALUNO
    tem_zero   = False                 # flag       — pertence ao ALUNO

    for j in range(3):
        nota = float(input())
        soma += nota
        if nota == 0:
            tem_zero = True

    media = soma / 3
    if media >= 6 and not tem_zero:
        aprovados += 1                 # atualiza o persistente

print(f"Aprovados: {aprovados} de {num_alunos}")

7. Strings

7.1 Indexação

Strings são sequências indexadas a partir do zero. Índices negativos contam do final:

 P   y   t   h   o   n
 0   1   2   3   4   5
-6  -5  -4  -3  -2  -1

s = "Python"
print(s[0])    # P
print(s[-1])   # n  (último)
print(s[-2])   # o  (penúltimo)

7.2 Fatiamento (slicing)

Notação: s[inicio:fim:passo] — o fim é exclusivo:

Expressão	Resultado	Descrição
`s[1:4]`	`"yth"`	Índices 1, 2, 3
`s[:3]`	`"Pyt"`	Do início até o índice 2
`s[3:]`	`"hon"`	Do índice 3 até o fim
`s[::2]`	`"Pto"`	Um a cada dois
`s[::-1]`	`"nohtyP"`	String invertida

texto = "algoritmo"
print(texto[:4])    # algo
print(texto[4:])    # ritmo
print(texto[::-1])  # omtirогla

7.3 Métodos de transformação de case

s = "olá, Mundo!"
print(s.upper())       # OLÁ, MUNDO!
print(s.lower())       # olá, mundo!
print(s.capitalize())  # Olá, mundo!  (só a 1ª letra maiúscula)
print(s.title())       # Olá, Mundo!  (1ª letra de cada palavra)

7.4 Métodos de limpeza

entrada = "   dado com espaços   "
print(entrada.strip())    # "dado com espaços"   (remove das duas bordas)
print(entrada.lstrip())   # "dado com espaços   " (só da esquerda)
print(entrada.rstrip())   # "   dado com espaços" (só da direita)

7.5 Métodos de busca e substituição

frase = "café com leite e café"
print(frase.count("café"))        # 2
print(frase.find("leite"))        # 9  (índice da 1ª ocorrência; -1 se não achar)
print("café" in frase)            # True
print(frase.replace("café","chá"))# chá com leite e chá

7.6 Métodos de divisão e junção

csv   = "Alice,Bob,Carol"
nomes = csv.split(",")              # ['Alice', 'Bob', 'Carol']
texto = " | ".join(nomes)           # "Alice | Bob | Carol"

frase = "uma frase qualquer"
palavras = frase.split()            # divide por espaço (padrão)
print(len(palavras))                # 3

7.7 Métodos de verificação (retornam `bool`)

Método	Retorna `True` se…
`s.isalpha()`	Todos os caracteres são letras
`s.isdigit()`	Todos os caracteres são dígitos
`s.isalnum()`	Todos são letras ou dígitos
`s.isspace()`	Todos são espaços em branco
`s.startswith(prefixo)`	String começa com `prefixo`
`s.endswith(sufixo)`	String termina com `sufixo`
`s.isupper()`	Todas as letras são maiúsculas
`s.islower()`	Todas as letras são minúsculas

print("abc".isalpha())           # True
print("123".isdigit())           # True
print("abc123".isalnum())        # True
print("hello".startswith("he"))  # True
print("world".endswith("ld"))    # True

7.8 Formatação com f-strings

Coloque a variável entre {} após o f. Use especificadores de formato após ::

Especificador	Efeito	Exemplo	Saída
`.2f`	Float com 2 casas decimais	`f"{3.14159:.2f}"`	`"3.14"`
`.0f`	Float sem casas decimais	`f"{8.7:.0f}"`	`"9"`
`d`	Inteiro	`f"{42:d}"`	`"42"`
`>10`	Alinhado à direita em 10 posições	`f"{'Ana':>10}"`	`" Ana"`
`<10`	Alinhado à esquerda em 10 posições	`f"{'Ana':<10}"`	`"Ana "`
`^10`	Centralizado em 10 posições	`f"{'Ana':^10}"`	`" Ana "`

nome = "Ana"
nota = 8.756

print(f"Nome: {nome}")              # Nome: Ana
print(f"Nota: {nota:.2f}")          # Nota: 8.76
print(f"Arredondado: {nota:.0f}")   # Arredondado: 9
print(f"{'Item':<12}{'Preço':>8}")  # Item            Preço
print(f"{'Caneta':<12}{1.50:>8.2f}")# Caneta             1.50

7.9 Iteração e comprimento

nome = "Carolina"
print(len(nome))      # 8

for letra in nome:
    print(letra)      # C a r o l i n a  (um por linha)

# Contar vogais
vogais = sum(1 for c in nome.lower() if c in "aeiou")
print(vogais)         # 5

Quadro-resumo: erros mais comuns

Erro	Causa típica	Como corrigir
`TypeError: can only concatenate str (not "int")`	Tentou somar `str` com `int` sem converter	Use `int()` ou `float()` na entrada
`NameError: name 'x' is not defined`	Variável usada antes de ser criada	Inicialize a variável antes de usá-la
`IndentationError`	Indentação inconsistente	Use sempre 4 espaços; nunca misture espaço e tab
`SyntaxError` próximo a `=` numa condição	Usou `=` em vez de `==`	Troque `if x = 5:` por `if x == 5:`
Loop infinito (`while` trava)	Condição nunca se torna `False`	Garanta que a variável da condição é atualizada no corpo
Sentinela processado no `while`	Releitura no início do corpo	Mova a releitura para o fim do corpo
Função retorna `None`	Esqueceu o `return`	Adicione `return valor` ao final da função
Reset no lugar errado	Acumulador iniciado fora do laço externo	Mova a inicialização para dentro do laço onde ela deve zerar

Referências

Documentação Oficial

Python Docs — Tutorial completo: https://docs.python.org/3/tutorial/
Python Docs — Built-in Types: https://docs.python.org/3/library/stdtypes.html
Python Docs — Control Flow: https://docs.python.org/3/tutorial/controlflow.html
Python Docs — Defining Functions: https://docs.python.org/3/tutorial/controlflow.html#defining-functions
Python Docs — math module: https://docs.python.org/3/library/math.html
Python Docs — random module: https://docs.python.org/3/library/random.html
Python Docs — String Methods: https://docs.python.org/3/library/stdtypes.html#string-methods

Aprofundamento

Real Python — Python Variables: https://realpython.com/python-variables/
Real Python — Conditional Statements: https://realpython.com/python-conditional-statements/
Real Python — Defining Your Own Python Function: https://realpython.com/defining-your-own-python-function/
Real Python — Python Scope (LEGB Rule): https://realpython.com/python-scope-legb-rule/
Real Python — Python for Loops: https://realpython.com/python-for-loop/
Real Python — Python while Loops: https://realpython.com/python-while-loop/
Real Python — Python String Formatting: https://realpython.com/python-string-formatting/

O que este resumão cobre​

1. Tipos de Dados e Variáveis​

1.1 Os quatro tipos primitivos​

1.2 Conversão entre tipos​

1.3 Boas práticas para nomes de variáveis​

2. Operadores​

2.1 Operadores aritméticos​

2.2 Operadores relacionais​

2.3 Operadores lógicos​

2.4 Ordem de precedência​

3. Estruturas de Decisão​

3.1 Mapa de uso​

3.2 Formas do if​

3.3 Condições compostas​

3.4 match / case (Python 3.10+)​

4. Funções​

4.1 Anatomia de uma função​

4.2 Chamada e argumentos​

4.3 Parâmetros com valor padrão​

4.4 return vs print — a distinção mais importante​

4.5 Escopo de variáveis​

4.6 Composição de funções​

5. Bibliotecas Padrão e Depuração​

5.1 Como importar​

5.2 Módulo math​

5.3 Módulo random​

5.4 Outros módulos úteis da biblioteca padrão​

5.5 Depuração com print​

5.6 Depuração com o debugger do VS Code​

6. Estruturas de Repetição​

6.1 Mapa de decisão: for ou while?​

6.2 Laço for​

6.3 range() — formas de uso​

6.4 Laço while​

6.5 break e continue​

6.6 Ciclo de vida das variáveis em laços​

7. Strings​

7.1 Indexação​

7.2 Fatiamento (slicing)​

7.3 Métodos de transformação de case​

7.4 Métodos de limpeza​

7.5 Métodos de busca e substituição​

7.6 Métodos de divisão e junção​

7.7 Métodos de verificação (retornam bool)​

7.8 Formatação com f-strings​

7.9 Iteração e comprimento​

Quadro-resumo: erros mais comuns​

Referências​

Documentação Oficial​

Aprofundamento​