# Tipos básicos
nome: str = "Maria"
idade: int = 30
altura: float = 1.72
ativo: bool = True
nada: None = None

# Verificação de tipo em tempo de execução
print(type(nome))           # <class 'str'>
print(isinstance(idade, int))  # True
print(isinstance(42, (int, float)))  # True — aceita tupla de tipos

# Type hints avançados (módulo typing)
from typing import Union, Optional

def buscar_usuario(id: int) -> Optional[str]:
    """Retorna o nome do usuário ou None se não encontrado."""
    usuarios = {1: "Ana", 2: "Carlos"}
    return usuarios.get(id)

# Union para múltiplos tipos
def processar(valor: Union[int, str]) -> str:
    return str(valor)

# Python 3.10+ — sintaxe simplificada com |
def processar_novo(valor: int | str) -> str:
    return str(valor)

# Coleções tipadas
from typing import TypeAlias

Coordenada: TypeAlias = tuple[float, float]
ponto: Coordenada = (23.55, -46.63)

nomes: list[str] = ["Ana", "Bruno", "Clara"]
config: dict[str, int] = {"timeout": 30, "retries": 3}

# if / elif / else
nota = 8.5
if nota >= 9:
    conceito = "A"
elif nota >= 7:
    conceito = "B"
elif nota >= 5:
    conceito = "C"
else:
    conceito = "D"

# Operador ternário
status = "aprovado" if nota >= 7 else "reprovado"

# Walrus operator (:=) — Python 3.8+
dados = [1, 2, 3, 4, 5, 6, 7, 8]
if (n := len(dados)) > 5:
    print(f"Lista grande com {n} elementos")

# while com walrus operator
import re
texto = "contato: email@teste.com e admin@site.com.br"
padrao = re.compile(r'[\w.]+@[\w.]+')
pos = 0
while (match := padrao.search(texto, pos)):
    print(f"Email encontrado: {match.group()}")
    pos = match.end()

# for com range e enumerate
frutas = ["maçã", "banana", "manga"]
for i, fruta in enumerate(frutas, start=1):
    print(f"{i}. {fruta}")

# break e continue
for num in range(100):
    if num % 2 == 0:
        continue  # pula pares
    if num > 10:
        break      # para no 11
    print(num)

# match-case — Python 3.10+ (structural pattern matching)
def analisar_comando(comando: str) -> str:
    match comando.split():
        case ["sair"]:
            return "Encerrando..."
        case ["mover", direcao]:
            return f"Movendo para {direcao}"
        case ["atacar", alvo, *modificadores]:
            mods = ", ".join(modificadores) if modificadores else "nenhum"
            return f"Atacando {alvo} com modificadores: {mods}"
        case _:
            return "Comando desconhecido"

print(analisar_comando("mover norte"))       # Movendo para norte
print(analisar_comando("atacar dragão fogo"))  # Atacando dragão com modificadores: fogo

# Função com type hints e valor padrão
def saudacao(nome: str, formal: bool = False) -> str:
    if formal:
        return f"Prezado(a) {nome}, bom dia."
    return f"Oi, {nome}!"

# *args e **kwargs
def log_evento(*args: str, **kwargs: str) -> None:
    print("Argumentos:", args)
    print("Opções:", kwargs)

log_evento("login", "sucesso", usuario="ana", ip="192.168.1.1")

# Lambda
quadrado = lambda x: x ** 2
ordenar_por_idade = sorted(
    [("Ana", 30), ("Bruno", 25)],
    key=lambda p: p[1]
)

# Closures
def criar_multiplicador(fator: int):
    def multiplicar(n: int) -> int:
        return n * fator
    return multiplicar

dobro = criar_multiplicador(2)
print(dobro(5))  # 10

# Decorators
import functools
import time

def cronometrar(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        inicio = time.perf_counter()
        resultado = func(*args, **kwargs)
        fim = time.perf_counter()
        print(f"{func.__name__} executou em {fim - inicio:.4f}s")
        return resultado
    return wrapper

@cronometrar
def processar_dados(n: int) -> list[int]:
    return [i ** 2 for i in range(n)]

# functools — partial e lru_cache
from functools import partial, lru_cache

potencia_de_2 = partial(pow, 2)
print(potencia_de_2(10))  # 1024

@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(50))  # 12586269025 — calculado instantaneamente com cache

# List — mutável e ordenada
numeros = [3, 1, 4, 1, 5]
numeros.append(9)
numeros.sort()
fatiado = numeros[1:4]  # [1, 3, 4]

# Dict — pares chave-valor
pessoa = {"nome": "Ana", "idade": 30}
pessoa["cidade"] = "São Paulo"
nome = pessoa.get("nome", "desconhecido")

# Set — valores únicos, sem ordem
tags = {"python", "web", "api"}
tags.add("django")
comuns = tags & {"python", "java"}  # interseção: {"python"}

# Tuple — imutável
coordenada = (-23.55, -46.63)
lat, lon = coordenada  # unpacking

# collections — deque, defaultdict, Counter, namedtuple
from collections import deque, defaultdict, Counter, namedtuple

# deque — fila de alta performance
fila = deque(maxlen=3)
fila.append("a")
fila.append("b")
fila.append("c")
fila.append("d")  # "a" é removido automaticamente
print(list(fila))  # ['b', 'c', 'd']

# defaultdict — valor padrão automático
contagem_letras = defaultdict(int)
for letra in "abracadabra":
    contagem_letras[letra] += 1

# Counter — contagem direta
palavras = ["python", "java", "python", "go", "python", "java"]
ranking = Counter(palavras)
print(ranking.most_common(2))  # [('python', 3), ('java', 2)]

# namedtuple
Ponto = namedtuple("Ponto", ["x", "y"])
p = Ponto(3, 4)
print(f"x={p.x}, y={p.y}")

# dataclasses — a forma moderna
from dataclasses import dataclass, field

@dataclass
class Produto:
    nome: str
    preco: float
    tags: list[str] = field(default_factory=list)

    @property
    def preco_formatado(self) -> str:
        return f"R$ {self.preco:.2f}"

cafe = Produto("Café", 12.90, ["bebida", "quente"])
print(cafe.preco_formatado)  # R$ 12.90

# List comprehension
pares = [x for x in range(20) if x % 2 == 0]
quadrados = [x ** 2 for x in range(10)]

# List comprehension aninhada
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
achatada = [num for linha in matriz for num in linha]

# Dict comprehension
nomes = ["ana", "bruno", "clara"]
tamanhos = {nome: len(nome) for nome in nomes}
# {'ana': 3, 'bruno': 5, 'clara': 5}

# Set comprehension
iniciais = {nome[0].upper() for nome in nomes}  # {'A', 'B', 'C'}

# Generator expression — avaliação preguiçosa (lazy)
soma_grandes = sum(x ** 2 for x in range(1_000_000) if x % 3 == 0)

# Função geradora com yield
def ler_em_blocos(arquivo: str, tamanho: int = 1024):
    with open(arquivo, "r") as f:
        while (bloco := f.read(tamanho)):
            yield bloco

# itertools essenciais
import itertools

# chain — concatena iteráveis
todos = list(itertools.chain([1, 2], [3, 4], [5]))  # [1, 2, 3, 4, 5]

# islice — fatiamento de iteradores
primeiros_5 = list(itertools.islice(range(100), 5))  # [0, 1, 2, 3, 4]

# groupby — agrupar elementos ordenados
dados = [("fruta", "maçã"), ("legume", "cenoura"), ("fruta", "banana")]
dados.sort(key=lambda x: x[0])
for tipo, grupo in itertools.groupby(dados, key=lambda x: x[0]):
    print(f"{tipo}: {[item[1] for item in grupo]}")

# product — produto cartesiano
cores = ["vermelho", "azul"]
tamanhos = ["P", "M", "G"]
combinacoes = list(itertools.product(cores, tamanhos))

# f-strings — a forma preferida (Python 3.6+)
nome = "Maria"
idade = 28
print(f"Nome: {nome}, Idade: {idade}")
print(f"Ano de nascimento: {2026 - idade}")
print(f"PI: {3.14159:.2f}")         # PI: 3.14
print(f"{'centro':^20}")            # centralizado em 20 chars
print(f"{1000000:,.2f}")            # 1,000,000.00
print(f"{'python':>10}")            # alinhado à direita

# f-strings com expressões (Python 3.12+ — debug)
x = 42
print(f"{x = }")  # x = 42

# .format() — ainda útil para templates
template = "Olá, {nome}! Você tem {msgs} mensagens."
print(template.format(nome="Carlos", msgs=5))

# Métodos de string úteis
texto = "  Python é incrível  "
print(texto.strip())             # "Python é incrível"
print(texto.lower())             # "  python é incrível  "
print("python".capitalize())    # "Python"
print("um-dois-três".split("-"))  # ['um', 'dois', 'três']
print(", ".join(["a", "b", "c"]))  # "a, b, c"
print("Python" in texto)          # True
print(texto.replace("incrível", "fantástico"))

# Raw strings e multiline
caminho = r"C:\Users\maria\documentos"  # sem escapar \
sql = """
    SELECT nome, idade
    FROM usuarios
    WHERE ativo = true
    ORDER BY nome
"""

# Regex básico com re
import re

texto = "Meu CEP é 01310-100 e o outro é 04538-133"
ceps = re.findall(r"\d{5}-\d{3}", texto)
print(ceps)  # ['01310-100', '04538-133']

# Substituição com regex
limpo = re.sub(r"[^\w\s]", "", "Olá, mundo! Python #1")
print(limpo)  # "Olá mundo Python 1"

# Compilar regex para reutilização
padrao_email = re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+")
emails = padrao_email.findall("contato: ana@teste.com, suporte@empresa.com.br")

# try / except / else / finally
def dividir(a: float, b: float) -> float:
    try:
        resultado = a / b
    except ZeroDivisionError:
        print("Erro: divisão por zero!")
        return 0.0
    except TypeError as e:
        print(f"Erro de tipo: {e}")
        return 0.0
    else:
        print("Divisão realizada com sucesso")
        return resultado
    finally:
        print("Operação de divisão finalizada")

# Capturar múltiplas exceções
try:
    valor = int("abc")
except (ValueError, TypeError) as e:
    print(f"Erro de conversão: {e}")

# Exceções customizadas
class SaldoInsuficienteError(Exception):
    def __init__(self, saldo: float, valor: float):
        self.saldo = saldo
        self.valor = valor
        super().__init__(
            f"Saldo R${saldo:.2f} insuficiente para saque de R${valor:.2f}"
        )

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

# Context manager com with
with open("arquivo.txt", "w", encoding="utf-8") as f:
    f.write("Olá, Python!")

# Context manager customizado
from contextlib import contextmanager

@contextmanager
def timer(descricao: str):
    import time
    inicio = time.perf_counter()
    try:
        yield
    finally:
        duracao = time.perf_counter() - inicio
        print(f"{descricao}: {duracao:.4f}s")

with timer("processamento"):
    sum(range(1_000_000))

# re-raise com contexto
try:
    resultado = int("abc")
except ValueError as e:
    raise RuntimeError("Falha ao processar entrada") from e

# Classe com type hints, property, e dunder methods
class ContaBancaria:
    def __init__(self, titular: str, saldo: float = 0.0) -> None:
        self.titular = titular
        self._saldo = saldo
        self._historico: list[str] = []

    @property
    def saldo(self) -> float:
        return self._saldo

    @saldo.setter
    def saldo(self, valor: float) -> None:
        if valor < 0:
            raise ValueError("Saldo não pode ser negativo")
        self._saldo = valor

    def depositar(self, valor: float) -> None:
        self._saldo += valor
        self._historico.append(f"+R${valor:.2f}")

    def __repr__(self) -> str:
        return f"ContaBancaria(titular='{self.titular}', saldo={self._saldo:.2f})"

    def __len__(self) -> int:
        return len(self._historico)

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, ContaBancaria):
            return NotImplemented
        return self.titular == other.titular

# @staticmethod e @classmethod
class Validador:
    formatos_aceitos = [".csv", ".json", ".parquet"]

    @staticmethod
    def validar_email(email: str) -> bool:
        return "@" in email and "." in email.split("@")[-1]

    @classmethod
    def de_config(cls, config: dict) -> "Validador":
        instancia = cls()
        instancia.formatos_aceitos = config.get("formatos", cls.formatos_aceitos)
        return instancia

# Herança
class ContaPoupanca(ContaBancaria):
    def __init__(self, titular: str, saldo: float = 0.0, taxa: float = 0.005):
        super().__init__(titular, saldo)
        self.taxa = taxa

    def render_juros(self) -> None:
        juros = self._saldo * self.taxa
        self.depositar(juros)

# Protocol — tipagem estrutural (duck typing com type hints)
from typing import Protocol

class Enviavel(Protocol):
    def enviar(self, destino: str) -> bool: ...

class Email:
    def enviar(self, destino: str) -> bool:
        print(f"Enviando email para {destino}")
        return True

class SMS:
    def enviar(self, destino: str) -> bool:
        print(f"Enviando SMS para {destino}")
        return True

def notificar(mensageiro: Enviavel, destino: str) -> bool:
    return mensageiro.enviar(destino)

# Funciona com qualquer classe que tenha o método enviar()
notificar(Email(), "ana@teste.com")
notificar(SMS(), "+5511999999999")

import asyncio

# Função assíncrona básica
async def buscar_dados(url: str) -> str:
    print(f"Buscando {url}...")
    await asyncio.sleep(1)  # simula I/O
    return f"Dados de {url}"

# Executar uma coroutine
async def main():
    resultado = await buscar_dados("https://api.exemplo.com")
    print(resultado)

asyncio.run(main())

# Executar tarefas em paralelo com gather
async def buscar_tudo():
    urls = [
        "https://api.exemplo.com/users",
        "https://api.exemplo.com/posts",
        "https://api.exemplo.com/comments",
    ]
    resultados = await asyncio.gather(
        *(buscar_dados(url) for url in urls)
    )
    for r in resultados:
        print(r)

asyncio.run(buscar_tudo())

# create_task para controle mais granular
async def pipeline():
    task1 = asyncio.create_task(buscar_dados("https://api.exemplo.com/a"))
    task2 = asyncio.create_task(buscar_dados("https://api.exemplo.com/b"))

    # Podemos fazer outras coisas enquanto as tasks rodam
    print("Tasks criadas, aguardando...")

    dado1 = await task1
    dado2 = await task2
    return dado1, dado2

# Exemplo com aiohttp (instale: pip install aiohttp)
import aiohttp

async def buscar_api(session: aiohttp.ClientSession, url: str) -> dict:
    async with session.get(url) as response:
        return await response.json()

async def main_http():
    async with aiohttp.ClientSession() as session:
        urls = [
            "https://jsonplaceholder.typicode.com/posts/1",
            "https://jsonplaceholder.typicode.com/posts/2",
        ]
        tasks = [buscar_api(session, url) for url in urls]
        resultados = await asyncio.gather(*tasks)
        for post in resultados:
            print(f"Título: {post['title']}")

asyncio.run(main_http())

# Importações
import os
import json
from pathlib import Path
from datetime import datetime, timedelta
from typing import Any

# Importações relativas (dentro de um pacote)
# meu_pacote/
# ├── __init__.py
# ├── utils.py
# └── modelos/
#     ├── __init__.py
#     └── usuario.py

# Em usuario.py:
from ..utils import formatar_nome   # sobe um nível
from . import validacoes             # mesmo nível

# pyproject.toml moderno (substitui setup.py)
# [project]
# name = "meu-pacote"
# version = "1.0.0"
# requires-python = ">=3.11"
# dependencies = [
#     "httpx>=0.27",
#     "pydantic>=2.0",
# ]
#
# [project.optional-dependencies]
# dev = ["pytest", "ruff", "mypy"]
#
# [tool.ruff]
# line-length = 88

# Criando ambiente virtual e instalando dependências
# python -m venv .venv
# source .venv/bin/activate  (Linux/Mac)
# .venv\Scripts\activate     (Windows)
# pip install -r requirements.txt

# Com uv (muito mais rápido):
# uv venv
# uv pip install httpx pydantic

# Estes são comandos de terminal, não Python:

# Ambiente virtual
# python -m venv .venv
# source .venv/bin/activate

# Gerenciamento de pacotes
# pip install pacote
# pip install -r requirements.txt
# pip freeze > requirements.txt
# pip list --outdated

# Com uv (alternativa moderna e rápida)
# uv venv
# uv pip install pacote
# uv pip compile requirements.in -o requirements.txt
# uv run python script.py

# Testes com pytest
# pytest                          # roda todos os testes
# pytest tests/test_api.py        # arquivo específico
# pytest -k "test_login"          # filtrar por nome
# pytest -x                       # para no primeiro erro
# pytest --cov=src                # com cobertura

# Linting e formatação com Ruff
# ruff check .                    # verificar erros
# ruff check --fix .              # corrigir automaticamente
# ruff format .                   # formatar código

# Type checking com mypy
# mypy src/                       # verificar tipos
# mypy --strict src/              # modo estrito

# Executar módulos como script
# python -m http.server 8000      # servidor HTTP simples
# python -m json.tool data.json   # formatar JSON
# python -m timeit "sum(range(100))"  # benchmark rápido

# Unpacking avançado
primeiro, *meio, ultimo = [1, 2, 3, 4, 5]
# primeiro=1, meio=[2, 3, 4], ultimo=5

# enumerate com start
for i, item in enumerate(["a", "b", "c"], start=1):
    print(f"{i}: {item}")

# zip para iterar em paralelo
nomes = ["Ana", "Bruno", "Clara"]
idades = [25, 30, 28]
cidades = ["SP", "RJ", "BH"]
for nome, idade, cidade in zip(nomes, idades, cidades):
    print(f"{nome}, {idade} anos, mora em {cidade}")

# zip com strict (Python 3.10+) — erro se tamanhos diferentes
# for a, b in zip(lista1, lista2, strict=True):

# any() e all()
numeros = [2, 4, 6, 8, 10]
print(all(n % 2 == 0 for n in numeros))  # True — todos pares
print(any(n > 9 for n in numeros))        # True — pelo menos um > 9

# Merge de dicionários com | (Python 3.9+)
config_padrao = {"timeout": 30, "retries": 3, "debug": False}
config_usuario = {"timeout": 60, "debug": True}
config_final = config_padrao | config_usuario
# {'timeout': 60, 'retries': 3, 'debug': True}

# |= para atualizar in-place
config_padrao |= {"nova_opcao": "valor"}

# pathlib — manipulação moderna de caminhos
from pathlib import Path

projeto = Path("/home/usuario/projeto")
config = projeto / "config" / "settings.json"
print(config.exists())
print(config.suffix)       # .json
print(config.stem)         # settings
print(config.parent)       # /home/usuario/projeto/config

# Listar arquivos Python recursivamente
for py_file in projeto.rglob("*.py"):
    print(py_file.name)

# Ler e escrever com pathlib
conteudo = Path("dados.txt").read_text(encoding="utf-8")
Path("saida.txt").write_text("resultado", encoding="utf-8")

# Type guards (Python 3.10+)
from typing import TypeGuard

def is_lista_strings(val: list[object]) -> TypeGuard[list[str]]:
    return all(isinstance(item, str) for item in val)

dados: list[object] = ["a", "b", "c"]
if is_lista_strings(dados):
    # Aqui o mypy sabe que dados é list[str]
    print(dados[0].upper())

# Walrus operator em loops de leitura
# while (linha := input(">>> ")) != "sair":
#     print(f"Você digitou: {linha}")

# Desempenho: usar __slots__ em classes
class PontoRapido:
    __slots__ = ("x", "y")
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y
# Usa menos memória e é mais rápido que classe normal