# Criar o ambiente (dentro da pasta do projeto)
python -m venv .venv

# Ativar — Linux/macOS
source .venv/bin/activate

# Ativar — Windows (PowerShell)
.venv\Scripts\Activate.ps1

# Instalar dependências
pip install requests

# Congelar as versões usadas
pip freeze > requirements.txt

# Em outra máquina, recriar o ambiente
pip install -r requirements.txt

# Desativar
deactivate

# Instalar o uv (uma vez só)
pip install uv

# Criar projeto novo com pyproject.toml
uv init meu-projeto
cd meu-projeto

# Adicionar dependências (cria .venv automaticamente)
uv add requests pandas

# Rodar um script dentro do ambiente
uv run python main.py

meu-projeto/
├── .venv/                  # ambiente virtual (não vai pro git)
├── .gitignore
├── pyproject.toml          # metadados e dependências
├── README.md
├── src/
│   └── meu_projeto/
│       ├── __init__.py
│       ├── main.py
│       └── utils.py
└── tests/
    ├── __init__.py
    └── test_utils.py

.venv/
__pycache__/
*.pyc
.pytest_cache/
.env
dist/
*.egg-info/

import os

# Lê a variável; se não existir, retorna None
api_key = os.getenv("API_KEY")

# Com valor padrão
db_url = os.getenv("DATABASE_URL", "sqlite:///dev.db")

pip install python-dotenv

# arquivo .env
API_KEY=sk-abc123
DATABASE_URL=postgresql://user:senha@localhost/app

from dotenv import load_dotenv
import os

load_dotenv()  # carrega o .env para as variáveis de ambiente
api_key = os.getenv("API_KEY")

a = [1, 2, 3]
b = a          # b aponta para A MESMA lista
b.append(4)
print(a)       # [1, 2, 3, 4] — surpresa!

# Com imutáveis isso não acontece:
x = "olá"
y = x
y = y + "!"    # cria uma NOVA string
print(x)       # "olá" — intacta

import copy

original = [[1, 2], [3, 4]]

rasa = original.copy()          # ou list(original), ou original[:]
rasa[0].append(99)
print(original)                 # [[1, 2, 99], [3, 4]] — a lista interna é compartilhada!

profunda = copy.deepcopy(original)
profunda[0].append(777)
print(original)                 # [[1, 2, 99], [3, 4]] — agora sim, intacta

# ERRADO — o default é criado UMA vez, na definição da função
def adicionar(item, lista=[]):
    lista.append(item)
    return lista

print(adicionar(1))  # [1]
print(adicionar(2))  # [1, 2]  ← a lista foi reaproveitada!

# CERTO — use None como sentinela
def adicionar(item, lista=None):
    if lista is None:
        lista = []
    lista.append(item)
    return lista

print(adicionar(1))  # [1]
print(adicionar(2))  # [2]  ✓

a = [1, 2]
b = [1, 2]

print(a == b)   # True  — mesmo VALOR
print(a is b)   # False — objetos DIFERENTES na memória

# Regra prática: use `is` apenas com None, True e False
if resultado is None:
    ...

itens = []
if not itens:                 # forma pythônica de checar lista vazia
    print("sem itens")

nome = ""
nome_exibicao = nome or "Anônimo"   # "Anônimo" — `or` retorna o 1º truthy

x = "global"

def externa():
    x = "enclosing"
    def interna():
        x = "local"
        print(x)      # local
    interna()
    print(x)          # enclosing

externa()
print(x)              # global

contador = 0

def incrementa():
    global contador      # evite quando possível — dificulta testes
    contador += 1

def fabrica_contador():
    total = 0
    def incrementa():
        nonlocal total   # modifica a variável da função de fora
        total += 1
        return total
    return incrementa

c = fabrica_contador()
print(c(), c(), c())     # 1 2 3

# Desempacotamento básico
x, y = 10, 20
x, y = y, x                  # troca de valores sem variável temporária

# Com * para "pegar o resto"
primeiro, *meio, ultimo = [1, 2, 3, 4, 5]
print(primeiro, meio, ultimo)   # 1 [2, 3, 4] 5

# Em chamadas de função
numeros = [3, 1, 4]
print(*numeros)                 # equivale a print(3, 1, 4)

# Mesclando dicionários
padrao = {"tema": "claro", "fonte": 12}
usuario = {"fonte": 14}
config = {**padrao, **usuario}  # {'tema': 'claro', 'fonte': 14}

nome = "Ana"
saldo = 1234.5678

print(f"{nome=}")              # nome='Ana' — ótimo para debug
print(f"{saldo:.2f}")          # 1234.57
print(f"{saldo:>12,.2f}")      # '    1,234.57' — alinhado à direita, 12 casas
print(f"{0.157:.1%}")          # 15.7%
print(f"{255:08b}")            # 11111111 em binário com zeros à esquerda

from datetime import datetime
agora = datetime.now()
print(f"{agora:%d/%m/%Y %H:%M}")  # 05/07/2026 14:30

def f(valores=[]):
    valores.append(len(valores))
    return valores

print(f())
print(f())
print(f([9]))
print(f())

linhas = [[0] * 3] * 3
linhas[0][0] = 1
print([linha[0] for linha in linhas])

frutas = ["maçã", "banana", "uva"]

frutas.append("manga")        # O(1) — adiciona no fim
frutas.insert(0, "kiwi")      # O(n) — desloca tudo!
frutas.pop()                  # O(1) — remove do fim
frutas.pop(0)                 # O(n) — desloca tudo!
"uva" in frutas               # O(n) — varre a lista

frutas.sort()                            # ordena in-place
ordenadas = sorted(frutas, reverse=True) # retorna nova lista
frutas.sort(key=len)                     # ordena pelo tamanho da string

from collections import deque

fila = deque([1, 2, 3])
fila.appendleft(0)   # O(1)
fila.popleft()       # O(1) — perfeito para filas (FIFO)

quadrados = [n**2 for n in range(10)]
pares = [n for n in range(20) if n % 2 == 0]

# Com if/else no valor (repare: o if/else vem ANTES do for)
rotulos = ["par" if n % 2 == 0 else "ímpar" for n in range(5)]

# Aninhada — achatar matriz
matriz = [[1, 2], [3, 4], [5, 6]]
achatada = [x for linha in matriz for x in linha]  # [1, 2, 3, 4, 5, 6]

usuario = {"nome": "Ana", "idade": 30}

# Acesso seguro
usuario.get("email")               # None (sem explodir)
usuario.get("email", "sem email")  # valor padrão

# setdefault: pega o valor ou cria se não existir
usuario.setdefault("tags", []).append("admin")

# Iteração
for chave, valor in usuario.items():
    print(chave, valor)

# Dict comprehension
precos = {"arroz": 20, "feijão": 8, "carne": 45}
caros = {nome: p for nome, p in precos.items() if p > 10}

# Inverter um dicionário
invertido = {v: k for k, v in precos.items()}

from collections import Counter, defaultdict

# Counter — contagem instantânea
palavras = "o rato roeu a roupa do rei o rato fugiu".split()
contagem = Counter(palavras)
print(contagem.most_common(2))   # [('o', 2), ('rato', 2)]

# defaultdict — dicionário com valor padrão automático
agrupados = defaultdict(list)
pessoas = [("TI", "Ana"), ("RH", "Bruno"), ("TI", "Carla")]
for depto, nome in pessoas:
    agrupados[depto].append(nome)   # sem precisar checar se a chave existe
print(dict(agrupados))  # {'TI': ['Ana', 'Carla'], 'RH': ['Bruno']}

permitidos = {"admin", "editor", "viewer"}

"admin" in permitidos    # O(1)! Muito mais rápido que lista para busca

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a & b)   # interseção: {3, 4}
print(a | b)   # união: {1, 2, 3, 4, 5, 6}
print(a - b)   # diferença: {1, 2}
print(a ^ b)   # diferença simétrica: {1, 2, 5, 6}

# Uso clássico: remover duplicatas
emails = ["a@x.com", "b@x.com", "a@x.com"]
unicos = list(dict.fromkeys(emails))   # preserva a ordem, ao contrário de set()

coordenadas = {(0, 0): "origem", (1, 2): "ponto A"}   # tupla como chave ✓

from collections import namedtuple
Ponto = namedtuple("Ponto", ["x", "y"])
p = Ponto(3, 4)
print(p.x, p.y)   # 3 4 — legível, imutável e leve

def relatorio(titulo, *linhas, separador="-", **metadados):
    print(titulo)
    print(separador * len(titulo))
    for linha in linhas:
        print(linha)
    for chave, valor in metadados.items():
        print(f"[{chave}: {valor}]")

relatorio(
    "Vendas Q1",
    "Janeiro: 100", "Fevereiro: 150",
    separador="=",
    autor="Ana", versao=2,
)

def criar_usuario(nome, *, admin=False, ativo=True):
    ...

criar_usuario("Ana", admin=True)    # ✓
criar_usuario("Ana", True)          # ✗ TypeError — tudo após * exige nome

def gritar(texto):  return texto.upper() + "!"
def sussurrar(texto): return texto.lower() + "..."

# Funções podem ser guardadas, passadas e retornadas
estilos = {"grito": gritar, "sussurro": sussurrar}
print(estilos["grito"]("olá"))   # OLÁ!

# Passadas como argumento (higher-order functions)
nomes = ["ana", "BRUNO", "Carla"]
print(sorted(nomes, key=str.lower))          # ordena ignorando maiúsculas
print(max(["oi", "python", "sim"], key=len)) # 'python'

produtos = [("arroz", 20), ("feijão", 8), ("carne", 45)]

# Ordenar pelo preço
por_preco = sorted(produtos, key=lambda p: p[1])

# Melhor ainda, sem lambda:
from operator import itemgetter
por_preco = sorted(produtos, key=itemgetter(1))

def criar_multiplicador(fator):
    def multiplicar(x):
        return x * fator      # `fator` fica capturado na closure
    return multiplicar

dobrar = criar_multiplicador(2)
triplicar = criar_multiplicador(3)
print(dobrar(10), triplicar(10))   # 20 30

def calcular_juros(principal: float, taxa: float, meses: int) -> float:
    """Calcula o montante com juros compostos.

    Args:
        principal: valor inicial investido.
        taxa: taxa mensal em decimal (0.01 = 1%).
        meses: quantidade de meses.

    Returns:
        Montante final.

    Raises:
        ValueError: se algum argumento for negativo.
    """
    if principal < 0 or taxa < 0 or meses < 0:
        raise ValueError("argumentos não podem ser negativos")
    return principal * (1 + taxa) ** meses

def ler_numero(texto):
    try:
        n = int(texto)
    except ValueError:
        print(f"'{texto}' não é um número válido")
        return None
    else:
        # roda só se NÃO houve exceção
        print("conversão ok")
        return n
    finally:
        # roda SEMPRE — usado para limpeza (fechar arquivos, conexões...)
        print("fim da tentativa")

# RUIM — engole qualquer erro, inclusive bugs seus
try:
    processar()
except Exception:
    pass    # 🚨 nunca faça isso

# BOM — trata o que você sabe tratar
try:
    with open("dados.json") as f:
        dados = json.load(f)
except FileNotFoundError:
    dados = {}                        # padrão razoável
except json.JSONDecodeError as e:
    raise ValueError(f"arquivo corrompido: {e}") from e

class SaldoInsuficienteError(Exception):
    """Levantada quando o saque excede o saldo."""
    def __init__(self, saldo, valor):
        self.saldo = saldo
        self.valor = valor
        super().__init__(f"saldo {saldo:.2f} insuficiente para sacar {valor:.2f}")

def sacar(saldo, valor):
    if valor > saldo:
        raise SaldoInsuficienteError(saldo, valor)
    return saldo - valor

try:
    sacar(100, 500)
except SaldoInsuficienteError as e:
    print(e)            # saldo 100.00 insuficiente para sacar 500.00
    print(e.valor)      # 500 — dados estruturados disponíveis

# LBYL — "olhe antes de pular" (sujeito a condição de corrida)
if "email" in usuario:
    enviar(usuario["email"])

# EAFP — pythônico
try:
    enviar(usuario["email"])
except KeyError:
    pass

import json
def carregar_config(caminho):
    f = open(caminho)
    return json.load(f)

from pathlib import Path

pasta = Path("relatorios")
arquivo = pasta / "2026" / "vendas.csv"    # / monta caminhos multiplataforma

print(arquivo.name)      # vendas.csv
print(arquivo.stem)      # vendas
print(arquivo.suffix)    # .csv
print(arquivo.parent)    # relatorios/2026

arquivo.parent.mkdir(parents=True, exist_ok=True)  # cria pastas
print(arquivo.exists())

# Listar todos os .csv recursivamente
for csv in Path(".").rglob("*.csv"):
    print(csv, csv.stat().st_size, "bytes")

from pathlib import Path

# Jeito rápido para arquivos pequenos
conteudo = Path("notas.txt").read_text(encoding="utf-8")
Path("saida.txt").write_text("olá\n", encoding="utf-8")

# Jeito clássico com with (fecha o arquivo automaticamente)
with open("grande.log", encoding="utf-8") as f:
    for linha in f:              # itera linha a linha SEM carregar tudo na memória
        if "ERROR" in linha:
            print(linha.rstrip())

# Modos: "r" ler, "w" sobrescrever, "a" anexar, "rb"/"wb" binário
with open("log.txt", "a", encoding="utf-8") as f:
    f.write("nova linha\n")

import json
from pathlib import Path

usuario = {"nome": "Ana", "idade": 30, "tags": ["admin", "dev"], "ativo": True}

# Objeto Python → string JSON
texto = json.dumps(usuario, ensure_ascii=False, indent=2)

# String JSON → objeto Python
dados = json.loads('{"a": 1, "b": [true, null]}')
print(dados)   # {'a': 1, 'b': [True, None]}  ← repare a conversão de tipos

# Direto com arquivos
with open("usuario.json", "w", encoding="utf-8") as f:
    json.dump(usuario, f, ensure_ascii=False, indent=2)

with open("usuario.json", encoding="utf-8") as f:
    carregado = json.load(f)

import csv

# Escrevendo com DictWriter
funcionarios = [
    {"nome": "Ana", "depto": "TI", "salario": 9000},
    {"nome": "Bruno", "depto": "RH", "salario": 6500},
]

with open("func.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["nome", "depto", "salario"])
    writer.writeheader()
    writer.writerows(funcionarios)

# Lendo com DictReader
with open("func.csv", newline="", encoding="utf-8") as f:
    for linha in csv.DictReader(f):
        print(linha["nome"], float(linha["salario"]))  # tudo vem como string!

class ContaBancaria:
    # atributo de CLASSE — compartilhado por todas as instâncias
    taxa_manutencao = 0.01

    def __init__(self, titular, saldo=0):
        # atributos de INSTÂNCIA
        self.titular = titular
        self.saldo = saldo

    def depositar(self, valor):
        if valor <= 0:
            raise ValueError("depósito deve ser positivo")
        self.saldo += valor

    def sacar(self, valor):
        if valor > self.saldo:
            raise ValueError("saldo insuficiente")
        self.saldo -= valor

conta = ContaBancaria("Ana", 100)
conta.depositar(50)
print(conta.saldo)   # 150

class Carrinho:
    def __init__(self):
        self._itens = []

    def adicionar(self, produto, preco):
        self._itens.append((produto, preco))

    def __len__(self):                    # len(carrinho)
        return len(self._itens)

    def __contains__(self, produto):      # "arroz" in carrinho
        return any(p == produto for p, _ in self._itens)

    def __iter__(self):                   # for item in carrinho
        return iter(self._itens)

    def __repr__(self):                   # representação para devs (debug)
        return f"Carrinho({self._itens!r})"

    def __str__(self):                    # representação para usuários (print)
        return f"Carrinho com {len(self)} itens"

c = Carrinho()
c.adicionar("arroz", 20)
print(len(c), "arroz" in c)   # 1 True
print(c)                      # Carrinho com 1 itens

class Ponto:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __eq__(self, outro):
        if not isinstance(outro, Ponto):
            return NotImplemented
        return (self.x, self.y) == (outro.x, outro.y)

    def __add__(self, outro):
        return Ponto(self.x + outro.x, self.y + outro.y)

from dataclasses import dataclass, field

@dataclass
class Produto:
    nome: str
    preco: float
    tags: list[str] = field(default_factory=list)  # NUNCA use lista como default direto
    em_estoque: bool = True

    def aplicar_desconto(self, pct: float) -> None:
        self.preco *= (1 - pct)

p1 = Produto("Teclado", 199.9)
p2 = Produto("Teclado", 199.9)
print(p1)          # Produto(nome='Teclado', preco=199.9, tags=[], em_estoque=True)
print(p1 == p2)    # True — __eq__ de graça

# Variações úteis:
@dataclass(frozen=True)      # imutável — pode ser chave de dict
class Coordenada:
    lat: float
    lon: float

class Temperatura:
    def __init__(self, celsius):
        self.celsius = celsius     # passa pelo setter abaixo!

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, valor):
        if valor < -273.15:
            raise ValueError("abaixo do zero absoluto")
        self._celsius = valor

    @property
    def fahrenheit(self):          # atributo calculado, somente leitura
        return self._celsius * 9 / 5 + 32

t = Temperatura(25)
print(t.fahrenheit)   # 77.0 — sem parênteses, parece atributo
t.celsius = -300      # ValueError

class Funcionario:
    def __init__(self, nome, salario):
        self.nome = nome
        self.salario = salario

    def pagamento_mensal(self):
        return self.salario

class Vendedor(Funcionario):
    def __init__(self, nome, salario, comissao):
        super().__init__(nome, salario)   # reaproveita o __init__ do pai
        self.comissao = comissao

    def pagamento_mensal(self):           # sobrescrita (override)
        return super().pagamento_mensal() + self.comissao

class Motor:
    def ligar(self): print("vrum")

class Carro:
    def __init__(self):
        self.motor = Motor()     # Carro TEM um motor (composição)

    def ligar(self):
        self.motor.ligar()

from abc import ABC, abstractmethod

class Notificador(ABC):
    @abstractmethod
    def enviar(self, destinatario: str, mensagem: str) -> None: ...

class NotificadorEmail(Notificador):
    def enviar(self, destinatario, mensagem):
        print(f"[EMAIL para {destinatario}] {mensagem}")

class NotificadorSMS(Notificador):
    def enviar(self, destinatario, mensagem):
        print(f"[SMS para {destinatario}] {mensagem}")

def alertar_todos(notificador: Notificador, usuarios: list[str]):
    for u in usuarios:
        notificador.enviar(u, "Sistema fora do ar!")

alertar_todos(NotificadorSMS(), ["Ana", "Bruno"])

from typing import Protocol

class TemArea(Protocol):
    def area(self) -> float: ...

class Circulo:
    def __init__(self, r): self.r = r
    def area(self) -> float: return 3.14159 * self.r ** 2

def imprimir_area(forma: TemArea):     # aceita QUALQUER classe com .area()
    print(f"Área: {forma.area():.2f}")

imprimir_area(Circulo(2))   # funciona sem herdar de nada

class Usuario:
    def __init__(self, nome, email):
        self.nome, self.email = nome, email

    @classmethod
    def de_dict(cls, dados: dict):        # construtor alternativo — padrão comuníssimo
        return cls(dados["nome"], dados["email"])

    @staticmethod
    def email_valido(email: str) -> bool: # função utilitária agrupada na classe
        return "@" in email and "." in email.split("@")[-1]

u = Usuario.de_dict({"nome": "Ana", "email": "ana@x.com"})

numeros = [1, 2, 3]
it = iter(numeros)      # chama numeros.__iter__()
print(next(it))         # 1
print(next(it))         # 2
print(next(it))         # 3
# next(it) agora levanta StopIteration — é assim que o for sabe parar

def contagem_regressiva(n):
    print("começando!")
    while n > 0:
        yield n          # pausa aqui e devolve n; retoma na próxima chamada
        n -= 1

g = contagem_regressiva(3)
print(next(g))   # começando! \n 3
print(next(g))   # 2
for resto in g:  # continua de onde parou
    print(resto) # 1

def linhas_com_erro(caminho):
    with open(caminho, encoding="utf-8") as f:
        for linha in f:
            if "ERROR" in linha:
                yield linha.strip()

# Processa um log de 10 GB usando alguns KB de memória:
for erro in linhas_com_erro("servidor.log"):
    print(erro)

# Lista: cria 1 milhão de números na memória
quadrados_lista = [n**2 for n in range(1_000_000)]

# Gerador: cria um de cada vez
quadrados_gen = (n**2 for n in range(1_000_000))

# Perfeito para agregações:
total = sum(n**2 for n in range(1_000_000))
tem_par = any(n % 2 == 0 for n in [1, 3, 5, 8])       # True — para no primeiro
todos_positivos = all(n > 0 for n in [1, 2, -3])      # False

def ler(caminho):
    with open(caminho, encoding="utf-8") as f:
        yield from (linha.strip() for linha in f)   # yield from delega

def filtrar_erros(linhas):
    return (l for l in linhas if "ERROR" in l)

def extrair_timestamp(linhas):
    return (l.split(" ")[0] for l in linhas)

# Pipeline lazy: nada roda até o for consumir
pipeline = extrair_timestamp(filtrar_erros(ler("servidor.log")))
for ts in pipeline:
    print(ts)

from itertools import chain, islice, groupby, product, combinations, count

# chain — juntar iteráveis sem criar lista intermediária
for x in chain([1, 2], (3, 4), "ab"):
    print(x, end=" ")                    # 1 2 3 4 a b

# islice — fatiar um gerador (geradores não aceitam [0:5])
primeiros = list(islice(count(10), 5))   # [10, 11, 12, 13, 14]

# groupby — agrupar consecutivos (a entrada precisa estar ORDENADA pela chave!)
vendas = [("TI", 100), ("TI", 200), ("RH", 50)]
for depto, grupo in groupby(vendas, key=lambda v: v[0]):
    print(depto, sum(v for _, v in grupo))   # TI 300 / RH 50

# combinações e produto cartesiano
print(list(combinations("ABC", 2)))      # [('A','B'), ('A','C'), ('B','C')]
print(list(product([1, 2], "ab")))       # [(1,'a'), (1,'b'), (2,'a'), (2,'b')]

import functools
import time

def cronometrar(func):
    @functools.wraps(func)          # preserva nome e docstring da original
    def wrapper(*args, **kwargs):
        inicio = time.perf_counter()
        resultado = func(*args, **kwargs)
        duracao = time.perf_counter() - inicio
        print(f"{func.__name__} levou {duracao:.4f}s")
        return resultado
    return wrapper

@cronometrar
def processar():
    time.sleep(0.5)
    return "ok"

processar()   # processar levou 0.5003s

import functools, time

def tentar_novamente(vezes=3, espera=1.0):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for tentativa in range(1, vezes + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if tentativa == vezes:
                        raise
                    print(f"tentativa {tentativa} falhou ({e}); aguardando {espera}s")
                    time.sleep(espera)
        return wrapper
    return decorator

@tentar_novamente(vezes=3, espera=2)
def chamar_api():
    ...

import functools

@functools.lru_cache(maxsize=None)     # memoização automática
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)

print(fib(100))    # instantâneo; sem cache seria inviável

@functools.cache   # Python 3.9+, equivale a lru_cache(maxsize=None)
def config_pesada():
    ...

from contextlib import contextmanager
import time

@contextmanager
def cronometro(nome):
    inicio = time.perf_counter()
    try:
        yield                # aqui roda o corpo do with
    finally:
        print(f"[{nome}] {time.perf_counter() - inicio:.3f}s")

with cronometro("consulta ao banco"):
    time.sleep(0.2)
# [consulta ao banco] 0.200s

@contextmanager
def transacao(conexao):
    try:
        yield conexao
        conexao.commit()
    except Exception:
        conexao.rollback()
        raise

# uso:
# with transacao(conn) as c:
#     c.execute("INSERT ...")

def saudacao(nome: str, vezes: int = 1) -> str:
    return f"Olá, {nome}! " * vezes

# Coleções (Python 3.9+: use os tipos nativos em minúsculo)
def media(valores: list[float]) -> float: ...
def contagem() -> dict[str, int]: ...
def coordenada() -> tuple[float, float]: ...

# Optional: pode ser o tipo OU None (sintaxe moderna com |)
def buscar_usuario(id: int) -> dict | None: ...

# Union: um de vários tipos
def processar(entrada: str | bytes) -> None: ...

from typing import Any, Callable, Iterable, TypedDict, Literal

# Callable[[tipos_dos_args], tipo_retorno]
def aplicar(f: Callable[[int], int], valores: Iterable[int]) -> list[int]:
    return [f(v) for v in valores]

# Literal — restringe a valores específicos
def mover(direcao: Literal["norte", "sul", "leste", "oeste"]) -> None: ...

# TypedDict — dicionários com formato conhecido (comum em respostas de API)
class UsuarioDict(TypedDict):
    id: int
    nome: str
    email: str

def formatar(u: UsuarioDict) -> str:
    return f"{u['nome']} <{u['email']}>"

# Aliases de tipo
Matriz = list[list[float]]
def transpor(m: Matriz) -> Matriz: ...

from typing import TypeVar

T = TypeVar("T")

def primeiro(itens: list[T]) -> T | None:
    return itens[0] if itens else None

x = primeiro([1, 2, 3])       # o verificador infere: int | None
y = primeiro(["a", "b"])      # str | None

pip install mypy
mypy meu_modulo.py

def dobro(n: int) -> int:
    return n * 2

dobro("olá")   # mypy: error: Argument 1 to "dobro" has incompatible type "str"

pip install pytest

# src/calculadora.py
def dividir(a: float, b: float) -> float:
    if b == 0:
        raise ValueError("divisão por zero")
    return a / b

# tests/test_calculadora.py
import pytest
from src.calculadora import dividir

def test_divisao_simples():
    assert dividir(10, 2) == 5

def test_divisao_por_zero_levanta_erro():
    with pytest.raises(ValueError, match="divisão por zero"):
        dividir(1, 0)

def test_resultado_float():
    assert dividir(1, 3) == pytest.approx(0.333, abs=0.001)  # nunca compare floats com ==

pytest            # roda tudo
pytest -v         # verboso
pytest -k zero    # só testes com "zero" no nome

import pytest
from src.validadores import email_valido

@pytest.mark.parametrize("email, esperado", [
    ("ana@empresa.com", True),
    ("sem-arroba.com", False),
    ("@sem-nome.com", False),
    ("ana@sem-ponto", False),
    ("", False),
])
def test_email_valido(email, esperado):
    assert email_valido(email) is esperado

import pytest

@pytest.fixture
def carrinho_cheio():
    from src.loja import Carrinho
    c = Carrinho()
    c.adicionar("arroz", 20.0)
    c.adicionar("feijão", 8.0)
    return c

def test_total(carrinho_cheio):            # basta pedir pelo nome
    assert carrinho_cheio.total() == 28.0

def test_remover(carrinho_cheio):          # cada teste recebe um carrinho NOVO
    carrinho_cheio.remover("arroz")
    assert carrinho_cheio.total() == 8.0

@pytest.fixture
def arquivo_temporario(tmp_path):          # tmp_path é fixture nativa do pytest
    caminho = tmp_path / "dados.txt"
    caminho.write_text("conteúdo de teste")
    yield caminho
    # código após o yield roda na finalização (aqui tmp_path já se limpa sozinho)

# src/clima.py
import requests

def temperatura_atual(cidade: str) -> float:
    resp = requests.get(f"https://api.clima.com/{cidade}")
    resp.raise_for_status()
    return resp.json()["temp"]

# tests/test_clima.py
from unittest.mock import patch, Mock
from src.clima import temperatura_atual

def test_temperatura_atual():
    resposta_falsa = Mock()
    resposta_falsa.json.return_value = {"temp": 25.5}

    with patch("src.clima.requests.get", return_value=resposta_falsa) as get_falso:
        assert temperatura_atual("SP") == 25.5
        get_falso.assert_called_once_with("https://api.clima.com/SP")

from concurrent.futures import ThreadPoolExecutor
import requests, time

URLS = [f"https://httpbin.org/delay/1" for _ in range(5)]

def baixar(url):
    return requests.get(url, timeout=10).status_code

inicio = time.perf_counter()
with ThreadPoolExecutor(max_workers=5) as pool:
    resultados = list(pool.map(baixar, URLS))
print(resultados, f"{time.perf_counter() - inicio:.1f}s")
# 5 requisições de 1s cada terminam em ~1s em vez de ~5s

from concurrent.futures import ThreadPoolExecutor, as_completed

with ThreadPoolExecutor(max_workers=5) as pool:
    futuros = {pool.submit(baixar, url): url for url in URLS}
    for futuro in as_completed(futuros):
        url = futuros[futuro]
        try:
            print(url, "->", futuro.result())
        except Exception as e:
            print(url, "falhou:", e)

from concurrent.futures import ProcessPoolExecutor

def calcular_pesado(n):
    return sum(i * i for i in range(n))

if __name__ == "__main__":       # OBRIGATÓRIO com multiprocessing no Windows
    with ProcessPoolExecutor() as pool:
        resultados = list(pool.map(calcular_pesado, [10**7] * 4))
    print(resultados)
# Usa os 4+ núcleos de verdade — o GIL não atrapalha porque são processos separados

import asyncio
import httpx    # pip install httpx — o "requests" com suporte async

async def baixar(client: httpx.AsyncClient, url: str) -> int:
    resp = await client.get(url)     # enquanto espera, outras tarefas rodam
    return resp.status_code

async def main():
    urls = ["https://httpbin.org/delay/1"] * 5
    async with httpx.AsyncClient(timeout=10) as client:
        # gather dispara tudo "ao mesmo tempo"
        resultados = await asyncio.gather(*(baixar(client, u) for u in urls))
    print(resultados)

asyncio.run(main())    # ~1s para as 5 requisições

import requests

# GET com query params (?q=python&page=2)
resp = requests.get(
    "https://api.github.com/search/repositories",
    params={"q": "python", "per_page": 3},
    timeout=10,                     # SEMPRE defina timeout em produção
)
resp.raise_for_status()             # levanta exceção em 4xx/5xx
dados = resp.json()
for repo in dados["items"]:
    print(repo["full_name"], repo["stargazers_count"])

# POST com JSON
resp = requests.post(
    "https://httpbin.org/post",
    json={"nome": "Ana", "email": "ana@x.com"},   # json= já serializa e põe o header
    headers={"Authorization": "Bearer meu-token"},
    timeout=10,
)

# Tratamento de erros completo
try:
    resp = requests.get("https://api.exemplo.com/dados", timeout=10)
    resp.raise_for_status()
except requests.Timeout:
    print("a API demorou demais")
except requests.HTTPError as e:
    print(f"erro HTTP {e.response.status_code}")
except requests.RequestException as e:   # classe-mãe de todos os erros da lib
    print(f"falha de conexão: {e}")