• Leia rápido. Se você reconhece o tópico e sabe o snippet de cor, siga. Se travou, é sinal de estudar.
• Os → aprofunde em… apontam para as apostilas completas: Python (do básico ao avançado), Análise de Dados com Python, Algoritmos com Python, FastAPI, Aceleração de Código com IA.
• As caixas ⚠️ armadilha são o que mais cai em entrevista e o que mais gera bug — não pule.
• A auto-checagem no fim de cada seção: se você não responde de cabeça, volte.
• O checklist final é a lista literal para marcar antes de dizer "sei o básico de Python".

type(x)                 # o tipo
isinstance(x, (int, float))   # checagem (aceita tupla de tipos)
x == y                  # igualdade de VALOR
x is y                  # mesma IDENTIDADE (mesmo objeto na memória)
x is None               # SEMPRE assim para None (nunca == None)

Truthiness

Falsy: False, None, 0, 0.0, "", [], {}, (), set(), e objetos com __len__() == 0. Todo o resto é truthy.

a = [1, 2, 3]
b = a           # b e a apontam para a MESMA lista
b.append(4)     # a agora é [1, 2, 3, 4]  ← aliasing
c = a[:]        # cópia RASA (ou list(a), a.copy())
import copy; d = copy.deepcopy(a)   # cópia PROFUNDA

Escopo: LEGB

Ao ler um nome, Python procura em: Local → Enclosing (função externa) → Global (módulo) → Built-in.

x = 10
def f():
    global x        # para ATRIBUIR a x global de dentro da função
    x = 20
def outer():
    y = 1
    def inner():
        nonlocal y   # para atribuir ao y do enclosing
        y += 1

# comprehensions
[x*x for x in nums if x % 2 == 0]        # list
{k: v for k, v in pares}                  # dict
{x % 3 for x in nums}                       # set
(x for x in nums)                          # generator (lazy, não é tuple comprehension)

# slicing (funciona em list, str, tuple)
a[1:4]     a[::2]     a[::-1]     a[:-1]        # start:stop:step

# unpacking
primeiro, *meio, ultimo = [1, 2, 3, 4, 5]      # meio = [2, 3, 4]
d = {**d1, **d2}                               # merge de dicts (d2 vence)
f(*args, **kwargs)                             # espalhar em chamada

# idiomas úteis
from collections import Counter, defaultdict, deque
Counter(lista).most_common(3)
d = defaultdict(list); d[k].append(v)          # sem checar se a chave existe

if cond:
    ...
elif outra:
    ...
else:
    ...

for i, item in enumerate(lista, start=1):   # índice + valor
    ...
for a, b in zip(xs, ys):                    # iterar em paralelo (para no menor)
    ...
for x in lista:
    if achou: break
else:                                       # roda se o for NÃO deu break
    print("não achou")

while cond:
    ...
    if pular: continue

# match (3.10+) — pattern matching, não é só switch
match ponto:
    case (0, 0):            print("origem")
    case (x, 0) | (0, x):   print("eixo")
    case (x, y) if x == y: print("diagonal")
    case _:                print("outro")

# walrus := — atribui e usa na mesma expressão
while (linha := f.readline()):
    processar(linha)

def f(a, b, /, c, *args, d=10, **kwargs) -> int:
    """docstring."""
    return a + b
# a, b  → positional-only (antes do /)
# c     → posicional ou nomeado
# *args → tupla dos posicionais extras
# d     → keyword-only (depois de *), com default
# **kwargs → dict dos nomeados extras

quadrado = lambda x: x*x            # expressão anônima, uma linha só

# type hints (não são checados em runtime; use mypy/pyright)
def saudar(nome: str, vezes: int = 1) -> str: ...
from typing import Optional        # ou str | None no 3.10+

Decorators (noção)

@cache                              # functools.cache — memoiza
def fib(n): ...

# um decorator é uma função que recebe uma função e retorna outra
def logar(fn):
    def wrapper(*a, **kw):
        print("chamando", fn.__name__)
        return fn(*a, **kw)
    return wrapper

class Conta:
    taxa = 0.02                     # atributo de CLASSE (compartilhado)

    def __init__(self, saldo=0):
        self.saldo = saldo          # atributo de INSTÂNCIA
        self._historico = []        # _ = "não mexa" (convenção)

    def depositar(self, v):
        self.saldo += v

    @property
    def disponivel(self):           # acessa como atributo: c.disponivel
        return self.saldo * (1 - Conta.taxa)

    @staticmethod
    def valida(v): return v > 0     # sem self nem cls

    @classmethod
    def nova(cls): return cls(100)   // factory; cls = a classe

    def __repr__(self):             # o que aparece no debugger/repl
        return f"Conta(saldo={self.saldo})"

class Poupanca(Conta):
    def __init__(self, saldo=0, rendimento=0.01):
        super().__init__(saldo)
        self.rendimento = rendimento

Dataclass (para "sacos de dados")

from dataclasses import dataclass
@dataclass
class Ponto:
    x: int
    y: int = 0            # gera __init__, __repr__, __eq__ de graça

try:
    v = d[chave]
except KeyError:
    v = padrao
except (ValueError, TypeError) as e:
    log.error("falha: %s", e)
    raise                       # re-lança o mesmo
else:
    # roda se o try NÃO lançou
finally:
    # SEMPRE roda (cleanup)

raise ValueError("mensagem")
raise RuntimeError("contexto") from e     # encadeia a causa

class ValidacaoError(Exception):            # exceção custom: herde de Exception
    pass

Hierarquia (o que você trata)

BaseException → Exception → (ValueError, TypeError, KeyError, IndexError, FileNotFoundError, AttributeError, StopIteration, RuntimeError, …). Capture Exception no máximo — nunca except: pelado (pega KeyboardInterrupt, SystemExit).

with — context managers

with open("dados.txt") as f:      # fecha o arquivo mesmo se der erro
    conteudo = f.read()
with lock, open(a) as fa, open(b) as fb:   # vários
    ...

import json
import numpy as np
from pathlib import Path
from mypkg.util import helper
from . import irmao          # import relativo (dentro de um pacote)

if __name__ == "__main__":      # só roda quando o arquivo é executado direto,
    main()                       # não quando é importado

Ambiente e dependências

Nunca instale pacotes no Python do sistema. Sempre um venv por projeto. uv é o gerenciador moderno (rápido; substitui pip/venv/pip-tools).

Iterável vs iterador vs generator

• Iterável: algo sobre o qual dá para fazer for (list, str, dict, arquivo…). Tem __iter__.
• Iterador: tem __next__; produz o próximo item; esgota.
• Generator: função com yield — produz valores sob demanda (lazy), sem materializar tudo na memória.

def pares_ate(n):
    for i in range(0, n, 2):
        yield i               # pausa aqui, devolve i, retoma na próxima

for x in pares_ate(1_000_000):   # não cria 1M de itens na memória
    ...

# generator expression: some sem construir a lista
total = sum(x*x for x in nums)

Idiomas que sinalizam fluência

Bibliotecas para conhecer: itertools (chain, groupby, product, islice), functools (cache, reduce, partial), collections (Counter, defaultdict, deque, namedtuple).

Aprofundamento por tema: Python (do básico ao avançado, a apostila completa) · Análise de Dados com Python (pandas, numpy) · Algoritmos com Python (estruturas e complexidade) · FastAPI (async, APIs) · Aceleração de Código com IA (fluxo assistido).