Curso de Python Intermediário

O ponto de partida do segundo degrau da trilha: o que você já domina do Básico, o que muda agora e por que o intermediário é menos sobre novos comandos e mais sobre escrever código organizado. Uma revisão relâmpago do essencial e o ambiente pronto para acompanhar todo o curso.

• Do básico para o intermediário: o que muda
• Revisão relâmpago do básico
• Seu ambiente e o Playground do curso

O primeiro recurso que deixa o seu código visivelmente mais pythônico. Você aprende a transformar aqueles laços de três ou quatro linhas que constroem uma lista em uma única expressão clara, e faz o mesmo com dicionários e conjuntos. No fim, uma prática de verdade: pegar uma lista de alunos e extrair, mapear e resumir os dados só com compreensões.

• O que é uma compreensão de lista
• Compreensão com condição
• Compreensões aninhadas
• Compreensão de dicionário
• Compreensão de conjunto e a espiada em generator
• Prática: transformar dados de alunos

Você já sabe criar funções com def, receber parâmetros e devolver valores. Agora aprende a deixá-las flexíveis e à prova de surpresas: valores padrão, argumentos nomeados, *args e **kwargs para receber quantidade variável, a armadilha do padrão mutável que engana quase todo mundo, o escopo das variáveis e as funções lambda. É o módulo que transforma funções simples em ferramentas reutilizáveis.

• Parâmetros com valor padrão
• Argumentos nomeados e posicionais
• *args e **kwargs: quantidade variável
• A armadilha do padrão mutável
• Escopo local e global
• Funções lambda e prática do módulo

No Python, uma função é um valor como qualquer outro: pode ser guardada em uma variável, passada como argumento e devolvida por outra função. Este módulo mostra o que isso destrava na prática, das funções de ordem superior ao sorted com key, passando por map, filter e closures, sempre com honestidade sobre quando a compreensão continua sendo a escolha mais clara.

• Funções são valores
• Funções de ordem superior
• Ordenar com key
• map e filter
• Closures
• Prática: ordenar e transformar

Todo Python já vem com centenas de ferramentas prontas, testadas por milhões de pessoas, esperando um import. Neste módulo você entende como o import funciona de verdade, aprende a separar seu próprio código em arquivos reaproveitáveis, decifra o famoso if __name__ == "__main__" sem susto e conhece os módulos mais úteis do dia a dia: math, random, datetime e collections.

• O que é um módulo e como o import funciona
• Criando seu próprio módulo
• Matemática e sorte: math e random
• Trabalhando com datas: datetime em visão geral
• Coleções especiais: Counter, defaultdict e namedtuple
• Prática: um utilitário com Counter e random

O passo que separa quem só roda scripts de quem monta projetos de verdade: dar a cada projeto a sua despensa isolada de pacotes com o venv e instalar bibliotecas externas com o pip. Aqui você aprende a criar, ativar e usar um ambiente virtual no Windows, instalar pacotes, congelar as versões em um requirements.txt e rodar um projeto isolado do começo ao fim.

• Por que ambientes virtuais existem
• Criando um ambiente virtual no Windows
• Instalando pacotes com pip
• requirements.txt: a receita do projeto
• Usando um pacote externo na prática
• Prática: montar um projeto isolado

JSON é o formato universal para trocar dados entre programas: APIs, arquivos de configuração e bancos de dados falam JSON. Neste módulo você aprende a converter dados entre Python e JSON com o módulo json, gravar e ler arquivos com acentos preservados, percorrer estruturas aninhadas de listas dentro de dicionários e fecha com uma prática de catálogo de produtos salvo em arquivo.

• O que é JSON e por que ele está em todo lugar
• De Python para JSON com json.dumps
• De JSON para Python com json.loads
• Lendo e gravando arquivos JSON
• Dados aninhados: listas dentro de dicionários
• Prática: um catálogo de produtos em JSON

Boa parte dos dados do mundo real chega em planilhas simples de texto: os arquivos CSV. Neste módulo você aprende a ler e gravar CSV com o módulo csv da biblioteca padrão, a lidar com caminhos de arquivo de forma moderna e segura usando pathlib, e a entender o with por dentro. No fim, você monta um relatório de vendas de verdade: lê um arquivo, soma por categoria e grava um resumo.

• O que é CSV
• Lendo CSV
• Gravando CSV
• pathlib: caminhos modernos
• Context managers: o with a fundo
• Prática: relatório de vendas em CSV

No Básico você aprendeu a evitar que um erro derrube o programa com try e except. Agora você trata falhas de propósito: escolhe o erro certo, usa else e finally, sinaliza problemas com raise, cria as suas próprias exceções e fecha o módulo com uma função de saque que valida tudo e avisa com clareza o que deu errado.

• Relembrando try e except
• Os blocos else e finally
• Levantando erros com raise
• Criando exceções próprias
• Encadeamento e boas práticas
• Prática: validação robusta de um saque

O coração do curso. Aqui você aprende a agrupar dados e comportamento em um mesmo lugar com classes e objetos. Parte do problema de deixar dados soltos, passa pelo construtor __init__, pelo self, pelos métodos e atributos, e termina construindo uma classe ContaBancaria completa, com depósito, saque e uma exibição amigável.

• O que é orientação a objetos
• Criando uma classe
• O método __init__ e o self
• Métodos de instância
• Atributos de classe e de instância
• O método __str__
• Prática: a classe ContaBancaria

O segundo passo da orientação a objetos: reaproveitar uma classe que já funciona em vez de copiá-la. Você monta uma classe base, cria filhas que herdam tudo dela, estende o construtor com super(), sobrescreve métodos e vê o polimorfismo em ação, quando o mesmo comando trata objetos diferentes cada um do seu jeito. Fecha com encapsulamento e uma prática de hierarquia de formas.

• O que é herança
• Criando uma classe filha
• super() e o __init__ da base
• Sobrescrever métodos
• Polimorfismo na prática
• Encapsulamento
• Prática: hierarquia de formas

Um dos recursos que mais assusta quem chega ao intermediário, e um dos mais elegantes quando cai a ficha. Aqui você entende, passo a passo, o que é um decorador: uma função que recebe outra função e devolve uma versão envolvida dela. Vai ver de onde vem o símbolo @, por que o wrapper usa *args e **kwargs, para que serve o functools.wraps e como aplicar tudo em casos reais como medir tempo e registrar chamadas.

• O caminho até o decorador
• A sintaxe do arroba
• Decorador para qualquer função com args e kwargs
• Preservando a identidade com functools.wraps
• Casos de uso reais de decoradores
• Prática: um decorador de log e tempo

Como o Python percorre uma sequência por baixo dos panos e como você pode criar as suas próprias com yield. Este módulo mostra o protocolo de iteração, as funções geradoras, a avaliação preguiçosa que economiza memória, as generator expressions e como encadear geradores em um pipeline de dados. Fecha com uma prática que lê um arquivo grande linha a linha, sem carregar tudo de uma vez.

• O que é um iterável
• Função geradora com yield
• Por que usar geradores
• Generator expressions
• Encadeando geradores
• Prática: processar um arquivo grande

Dois assuntos que aparecem em quase todo programa real: lidar com datas sem se perder em cálculos de calendário e reconhecer padrões de texto com expressões regulares. Você aprende o módulo datetime para criar, formatar e calcular com datas, e o módulo re para validar, buscar e extrair informação de textos.

• Trabalhando com datas
• Formatando e lendo datas
• Cálculos com datas
• O que é uma expressão regular
• Padrões básicos de regex
• Prática: validar e extrair

Como saber que o seu código funciona sem ficar testando tudo na mão a cada mudança. Este módulo mostra por que testar dá liberdade para mexer no código, começa pelo assert que é a base de tudo, apresenta o unittest da biblioteca padrão e o pytest, e ensina a escolher os casos que realmente importam, incluindo os de borda.

• Por que testar o código
• O comando assert
• Testes com unittest
• Conhecendo o pytest
• Testando casos de borda
• Prática: testar uma função

A hora de juntar tudo em um programa de verdade. Você vai construir, passo a passo, uma agenda de contatos de linha de comando: classes para modelar os dados, métodos para operar sobre eles, uma exceção própria para os erros, persistência em JSON, exportação para CSV e testes automatizados. Cada aula evolui o mesmo código, e no fim ele roda por completo.

• A visão do projeto
• Modelando a agenda com classes
• Os métodos da agenda
• Tratando erros com uma exceção própria
• Salvando a agenda em JSON
• Exportar para CSV e o menu
• Testando a agenda e próximos passos