Curso de Python Avançado

O ponto de partida do topo da trilha: o que você já domina do Intermediário, o que muda quando o objetivo deixa de ser só organizar e passa a ser projetar com intenção. Uma revisão relâmpago da orientação a objetos e dos recursos avançados, e as ferramentas de engenharia que acompanham todo o curso.

• Do intermediário para o avançado: o que muda
• Revisão relâmpago do intermediário
• Seu ambiente e as ferramentas de engenharia

O primeiro pilar da engenharia em Python: declarar os tipos que o seu código espera e devolve. Você aprende os type hints, o módulo typing com Optional, Union, list, dict e Callable, o começo de generics com TypeVar, o Protocol para duck typing tipado e o verificador mypy que confere tudo antes de rodar.

• Type hints: o contrato explícito
• typing: coleções, Optional e Union
• Callable, Any e apelidos de tipo
• Generics com TypeVar e Protocol
• mypy na prática e quando tipar

Como modelar dados com elegância em Python. O decorador @dataclass gera automaticamente o construtor, a representação e a comparação de uma classe de dados. Você aprende field com default_factory, a imutabilidade com frozen, a validação no __post_init__, o Enum para constantes nomeadas e como escolher entre dataclass, namedtuple, dicionário e tupla.

• @dataclass: menos código, mais intenção
• field e default_factory: valores mutáveis
• frozen e __post_init__: imutabilidade e validação
• dataclass, namedtuple, dict e tupla: qual usar
• Enum: constantes nomeadas e seguras

Um estilo de programação que trata funções como valores e evita efeitos colaterais. Você aprende funções puras e imutabilidade, as ferramentas do functools (reduce, partial e o cache do lru_cache), os geradores infinitos e combinadores do itertools, e quando preferir map e filter às compreensões de lista.

• Funções puras e imutabilidade
• map, filter, lambda e compreensões
• functools: reduce e partial
• lru_cache: memoização sem esforço
• itertools: iteradores poderosos

O decorador simples do Intermediário era só o começo. Aqui você aprende a preservar a identidade da função com functools.wraps, a construir decoradores que recebem argumentos, a decorar classes inteiras, a empilhar decoradores na ordem certa e a reconhecer os padrões que aparecem em qualquer código profissional: log, cronômetro, cache, validação e retry.

• Recap do decorador e o functools.wraps
• Decorador que recebe argumentos
• Decorar uma classe inteira
• Empilhar decoradores e a ordem de aplicação
• Casos reais: log, cronômetro, cache, validação e retry

O comando with que você usa para abrir arquivos guarda um mecanismo elegante por baixo: o context manager, que garante a limpeza de um recurso aconteça o que acontecer. Aqui você aprende o protocolo __enter__ e __exit__, o atalho com @contextlib.contextmanager e yield, e monta seus próprios gerenciadores para arquivos, locks, transações e cronômetros.

• Por que o with existe
• O protocolo __enter__ e __exit__
• O atalho: @contextlib.contextmanager
• Ferramentas do contextlib: ExitStack e suppress
• Casos reais: arquivos, locks, transações e cronômetro

Por trás de todo for existe o protocolo do iterador, e por trás dele está o poder dos geradores. Aqui você desce ao __iter__ e __next__, monta pipelines preguiçosos que processam dados enormes com pouca memória, delega com yield from, dompteia sequências infinitas com islice e conhece o send, o passo que faz a ponte para a programação assíncrona.

• O protocolo do iterador por dentro
• Generator expressions e a memória
• Delegação com yield from
• Pipelines preguiçosos e geradores infinitos
• send e corrotinas: a ponte para o async

O primeiro passo para lidar com muitas tarefas ao mesmo tempo. Você entende a diferença entre concorrência e paralelismo, o famoso GIL e o que ele implica, cria threads na prática, aprende a evitar a race condition com Lock, coordena produtor e consumidor com fila e usa o ThreadPoolExecutor para trabalho de I/O em lote.

• Concorrência, paralelismo e o GIL
• Criando threads com threading
• Race condition e o Lock
• Fila e o padrão produtor-consumidor
• ThreadPoolExecutor na prática

Outra forma de fazer muitas tarefas de I/O ao mesmo tempo, sem threads. Você entende por que a espera desperdiça tempo, escreve corrotinas com async def e await, roda o event loop com asyncio.run, dispara várias tarefas juntas com asyncio.gather e aprende quando async é melhor que threads e quando não é.

• O problema do I/O que espera
• Corrotinas: async def e await
• O event loop e asyncio.run
• Rodando várias tarefas com gather
• Async ou threads: como escolher

O coração do projeto de software em Python. Você aprende a proteger atributos com @property e validação, a criar métodos de classe e estáticos, a fazer suas classes se integrarem à linguagem com os métodos dunder, a economizar memória com __slots__, a entender herança múltipla e a ordem de resolução de métodos, e a escolher entre composição e herança com critério.

• property: getter, setter e validação
• classmethod e staticmethod
• Métodos dunder: integrando à linguagem
• Herança múltipla e a ordem de resolução
• Composição, herança e __slots__

O andar de baixo da orientação a objetos em Python. Aqui você descobre que classes também são objetos, entende como type() fabrica classes, o que é uma metaclass e quando (raramente) vale usar, e como os descritores fazem @property funcionar por dentro. Poder de verdade, para usar com parcimônia.

• Tudo é objeto: até as classes
• O que é uma metaclass
• Descritores: como @property funciona por dentro
• Interceptar atributos: __getattr__ e amigos
• __init_subclass__: o atalho para quase tudo

O módulo que separa um script que funciona de um programa em que se pode confiar. Você desenha uma hierarquia de exceções própria do seu domínio, encadeia erros sem perder a causa, usa o módulo logging no lugar do print e adota uma postura defensiva: validar cedo e falhar de forma clara.

• Uma hierarquia de exceções do seu domínio
• raise from: encadear erros sem perder a causa
• else, finally e o estilo EAFP
• O módulo logging: adeus, print
• Programação defensiva: validar cedo, falhar claro

Testar de verdade, do jeito profissional. Você troca os asserts soltos pelo pytest, o framework de testes mais usado do Python, e aprende a organizar o teste com fixtures, cobrir muitos casos com parametrize, testar erros e dependências com pytest.raises e mocks, medir cobertura e adotar o ciclo TDD.

• pytest: o teste que só usa assert
• Fixtures: preparar o cenário do teste
• parametrize e testar exceções
• Mocks e monkeypatch: isolar dependências
• Cobertura e TDD na prática

Antes de acelerar qualquer código, você precisa saber onde ele é lento. Este módulo ensina a medir com timeit, a achar o gargalo real com cProfile e pstats, a raciocinar sobre complexidade sem matemática pesada, a escolher a estrutura de dados certa e a usar memoização e geradores. A regra é uma só: meça primeiro, otimize depois.

• Medir antes de otimizar com timeit
• Achar o gargalo com cProfile e pstats
• Complexidade e a estrutura de dados certa
• Estruturas eficientes: deque, heapq e bisect
• Memoização com lru_cache e geradores para memória

Escrever funções que funcionam é só metade do trabalho de engenharia. A outra metade é organizar tudo num projeto navegável, com estrutura de pacote clara, imports bem resolvidos, estilo consistente e princípios de design que mantêm o código fácil de mudar. Este módulo reúne a estrutura de projetos, o pyproject.toml, PEP 8, SOLID e os padrões pythônicos de código limpo.

• Estrutura de projeto e pacotes
• pyproject.toml e imports bem resolvidos
• PEP 8 e ferramentas de estilo
• Princípios SOLID em Python
• Padrões pythônicos e código limpo

Chegou a hora de juntar tudo. Neste módulo você constrói, passo a passo, uma mini biblioteca de utilidades tipada e testada, o pacote catalogo, para gerenciar produtos e preços. Cada aula acrescenta uma camada: dataclasses e Enum, decoradores próprios e context manager, exceções e logging, e por fim testes com pytest e empacotamento. É o código que prova, para você mesmo, que você projeta software.

• Visão do projeto e arquitetura
• Dataclasses tipadas e Enum do domínio
• Decoradores próprios e context manager
• Exceções próprias e logging
• Testes com pytest, empacotamento e encerramento