Python do zero ao avançado

Conteúdo da trilha

1. 1
   

   1 Nível 1 · 7 tutoriais · 1h 58min

   Ambiente e primeiros programas

   Apresenta o ambiente de desenvolvimento e os elementos mínimos para executar programas em Python. Parte do zero e estabelece a base necessária para trabalhar com decisões, repetições e dados.

   O que você vai aprender

   • Instalar o Python 3, configurar um editor e verificar qual interpretador está em uso.
   • Usar comandos básicos do terminal para localizar e executar arquivos Python, distinguindo scripts do modo interativo.
   • Criar variáveis e expressões com números, textos, valores booleanos e None.
   • Receber entradas, converter tipos e apresentar resultados com print e f-strings.
   • Reconhecer a função da indentação, dos comentários e das mensagens básicas de erro.

   1. 1 Tutorial 1: Preparar o ambiente para Python 3 Ao concluir, você terá o Python 3 e um editor preparados e conseguirá verificar a versão e a localização do interpretador que será usado. Iniciante 20 min
   2. 2 Tutorial 2: Executar Python no modo interativo e em scripts Ao concluir, você conseguirá experimentar comandos no modo interativo, salvar um programa em um arquivo e executá-lo pelo terminal. Iniciante 17 min
   3. 3 Tutorial 3: Criar variáveis e reconhecer tipos básicos Ao concluir, você conseguirá nomear valores, atualizar variáveis e reconhecer os tipos básicos usados em programas Python. Iniciante 15 min
   4. 4 Tutorial 4: Construir expressões numéricas Ao concluir, você conseguirá traduzir cálculos simples em expressões Python e prever como operadores e parênteses determinam os resultados. Iniciante 15 min
   5. 5 Tutorial 5: Apresentar resultados com textos e f-strings Ao concluir, você conseguirá construir mensagens que combinam textos e valores calculados, controlando a apresentação da saída do programa. Iniciante 20 min
   6. 6 Tutorial 6: Ler entradas e converter tipos Ao concluir, você conseguirá receber dados pelo teclado, convertê-los para os tipos necessários e usá-los em um programa sequencial com entrada, cálculo e saída. Iniciante 15 min
   7. 7 Tutorial 7: Localizar e corrigir erros básicos Ao concluir, você conseguirá usar a localização e a mensagem de um erro simples para corrigir problemas comuns de escrita, nomes, tipos, conversões e indentação. Iniciante 16 min
2. 2
   

   2 Nível 2 · 7 tutoriais · 2h 12min

   Decisões e repetições

   Transforma programas sequenciais em programas capazes de escolher caminhos e repetir ações. Introduz o controle de fluxo antes das transformações de coleções e da decomposição em funções.

   O que você vai aprender

   • Construir condições com comparações, operadores lógicos e regras de avaliação booleana.
   • Selecionar comportamentos usando if, elif e else.
   • Repetir ações com while e percorrer textos ou sequências numéricas com for e range.
   • Controlar repetições com break e continue, evitando laços infinitos.
   • Acompanhar a execução de condições e laços para implementar contadores e acumuladores.

   Pré-requisitos

   • Execução de scripts Python.
   • Variáveis, tipos básicos, operadores e entrada e saída de dados.

   1. 1 Tutorial 1: Avaliar condições com comparações Construir comparações entre valores e prever como números, textos e None são avaliados em um contexto booleano. Iniciante 18 min
   2. 2 Tutorial 2: Combinar condições com and, or e not Expressar regras que dependem de várias condições, controlando o agrupamento e reconhecendo quando uma expressão deixa de ser avaliada. Iniciante 18 min
   3. 3 Tutorial 3: Selecionar caminhos com if, elif e else Implementar decisões que executam comportamentos diferentes conforme as condições e acompanhar qual caminho será escolhido. Iniciante 20 min
   4. 4 Tutorial 4: Repetir ações com while Criar repetições controladas por uma condição e garantir que o estado do programa permita encerrá-las. Iniciante 20 min
   5. 5 Tutorial 5: Percorrer textos e intervalos com for e range Executar uma ação para cada caractere de um texto ou número de um intervalo, escolhendo limites e passos adequados. Iniciante 20 min
   6. 6 Tutorial 6: Controlar repetições com break e continue Encerrar um laço antecipadamente ou pular parte de uma iteração sem perder o controle do fluxo de execução. Iniciante 16 min
   7. 7 Tutorial 7: Construir contadores e acumuladores em laços Contar ocorrências e somar valores durante uma repetição, verificando a evolução das variáveis por rastreamento manual. Iniciante 20 min
3. 3
   

   3 Nível 3 · 10 tutoriais · 3h 6min

   Coleções e transformação de dados

   Amplia o trabalho com valores isolados para conjuntos de informações. Usa o controle de fluxo já aprendido para organizar, consultar e transformar dados em memória.

   O que você vai aprender

   • Escolher entre listas, tuplas, dicionários e conjuntos conforme a organização dos dados.
   • Acessar, atualizar e percorrer coleções, incluindo estruturas aninhadas.
   • Manipular textos e sequências com métodos, índices, fatias e desempacotamento.
   • Explicar como referências, mutabilidade e cópias rasas afetam alterações em coleções.
   • Criar compreensões de listas, dicionários e conjuntos para transformações legíveis.

   Pré-requisitos

   • Tipos básicos e operações com textos.
   • Condicionais e laços de repetição.

   1. 1 Tutorial 1: Acessar e recortar textos com índices e fatias Localizar caracteres e extrair trechos de textos usando posições, limites e passos, estabelecendo regras que também serão usadas em outras sequências. Iniciante 13 min
   2. 2 Tutorial 2: Organizar e atualizar dados em listas Criar listas para reunir dados ordenados, consultar seus elementos e modificar seu conteúdo usando operações adequadas. Iniciante 24 min
   3. 3 Tutorial 3: Dividir, unir e normalizar textos Transformar textos com métodos de string e converter entre um texto e uma lista de partes, preservando os resultados das operações. Iniciante 15 min
   4. 4 Tutorial 4: Agrupar e desempacotar valores com tuplas Representar grupos posicionais de valores com tuplas e distribuir os elementos de uma sequência entre variáveis por desempacotamento. Iniciante 16 min
   5. 5 Tutorial 5: Percorrer sequências com enumerate e zip Percorrer sequências mantendo a posição de cada elemento ou associando valores de sequências diferentes, sem gerenciar contadores manualmente. Iniciante 11 min
   6. 6 Tutorial 6: Consultar e atualizar dados com dicionários Organizar informações por chaves, consultar valores com segurança e percorrer ou atualizar os dados de um dicionário. Iniciante 23 min
   7. 7 Tutorial 7: Eliminar duplicatas e comparar grupos com conjuntos Usar conjuntos para representar valores únicos e comparar grupos, distinguindo situações em que listas, tuplas ou dicionários são mais adequados. Iniciante 19 min
   8. 8 Tutorial 8: Consultar e atualizar coleções aninhadas Representar dados em mais de um nível e localizar, modificar ou extrair informações de combinações de listas e dicionários. Iniciante 20 min
   9. 9 Tutorial 9: Controlar referências e cópias de coleções Prever quando uma alteração será visível por outros nomes ou coleções e reconhecer os limites das cópias rasas em estruturas aninhadas. Iniciante 23 min
   10. 10 Tutorial 10: Transformar e filtrar dados com compreensões Construir listas, dicionários e conjuntos com compreensões legíveis, escolhendo laços explícitos quando a transformação exigir lógica mais extensa. Iniciante 22 min
4. 4
   

   4 Nível 4 · 7 tutoriais · 2h 17min

   Funções e decomposição de problemas

   Ensina a dividir programas em unidades reutilizáveis com responsabilidades claras. Essa organização prepara o aluno para módulos, testes e formas mais avançadas de abstração.

   O que você vai aprender

   • Definir funções com parâmetros, valores de retorno e responsabilidades específicas.
   • Usar argumentos posicionais, nomeados, valores padrão, *args e **kwargs, evitando padrões mutáveis problemáticos.
   • Distinguir escopos de variáveis e reduzir dependências de estado global.
   • Documentar entradas e saídas com docstrings e anotações simples de tipos.
   • Decompor problemas em funções e implementar soluções recursivas simples com casos base explícitos.

   Pré-requisitos

   • Controle de fluxo.
   • Manipulação de coleções, referências e mutabilidade.

   1. 1 Tutorial 1: Definir funções com parâmetros e retorno Crie funções que recebam dados, realizem uma operação específica e devolvam resultados para o restante do programa. Iniciante 20 min
   2. 2 Tutorial 2: Controlar o escopo e o estado das funções Preveja quais nomes e alterações são visíveis dentro e fora de uma função e reduza a dependência de variáveis globais. Iniciante 20 min
   3. 3 Tutorial 3: Usar argumentos nomeados e valores padrão Defina funções com opções claras de chamada e valores padrão seguros, sem compartilhar coleções mutáveis por acidente. Iniciante 20 min
   4. 4 Tutorial 4: Receber argumentos variáveis com *args e **kwargs Crie funções que aceitem uma quantidade variável de argumentos e use dados de sequências ou dicionários em chamadas. Intermediário 20 min
   5. 5 Tutorial 5: Documentar funções com docstrings e tipos simples Descreva o uso de uma função com documentação interna e anotações simples que esclareçam suas entradas, saídas e condições de uso. Iniciante 15 min
   6. 6 Tutorial 6: Decompor um programa em funções com responsabilidades claras Transforme um programa concentrado em um único bloco em pequenas funções que cooperam por meio de entradas e resultados explícitos. Intermediário 22 min
   7. 7 Tutorial 7: Resolver problemas com recursão e casos base Implemente soluções recursivas simples, acompanhe suas chamadas e garanta que cada etapa avance até um caso base explícito. Intermediário 20 min
5. 5
   

   5 Nível 5 · 7 tutoriais · 1h 59min

   Módulos, ambientes e dependências

   Leva o código de um único arquivo para projetos organizados e ambientes isolados. Introduz importações e bibliotecas antes de usá-las para persistência, testes e outros recursos especializados.

   O que você vai aprender

   • Separar funções e constantes em módulos e pacotes, utilizando importações explícitas.
   • Distinguir a execução direta de um módulo de sua importação e aplicar a proteção com __name__.
   • Localizar funcionalidades na biblioteca padrão e consultar sua documentação.
   • Criar ambientes virtuais com venv e instalar dependências com pip no interpretador correto.
   • Registrar dependências e versões para reproduzir um ambiente, verificando a procedência dos pacotes.

   Pré-requisitos

   • Criação e execução de arquivos Python pelo terminal.
   • Definição de funções e compreensão de escopos.

   1. 1 Tutorial 1: Separar código em módulos e usar importações explícitas Separar funções e constantes em arquivos reutilizáveis e acessar esses recursos por meio de importações que deixam clara a origem dos nomes. Iniciante 18 min
   2. 2 Tutorial 2: Controlar a execução de módulos com __name__ Fazer um arquivo funcionar tanto como programa executável quanto como módulo reutilizável, sem iniciar interações ou cálculos indevidos durante a importação. Iniciante 12 min
   3. 3 Tutorial 3: Organizar módulos em pacotes locais Organizar módulos relacionados em uma hierarquia de pacotes locais e executá-los preservando a resolução correta das importações. Intermediário 20 min
   4. 4 Tutorial 4: Consultar a biblioteca padrão e sua documentação Localizar recursos já disponíveis no Python e consultar a documentação oficial para usar funções adequadas à tarefa e à versão instalada. Iniciante 13 min
   5. 5 Tutorial 5: Criar ambientes virtuais com venv Criar um ambiente isolado para cada projeto e confirmar que terminal e editor usam o interpretador associado a esse ambiente. Iniciante 18 min
   6. 6 Tutorial 6: Instalar pacotes com pip no ambiente correto Instalar e inspecionar bibliotecas externas no ambiente do projeto, verificando sua procedência antes de executar código de terceiros. Iniciante 20 min
   7. 7 Tutorial 7: Recriar ambientes a partir de requirements.txt Registrar as dependências de um ambiente dedicado ao projeto e usá-las para recriar e conferir outro ambiente, reconhecendo os limites dessa reprodução. Intermediário 18 min
6. 6
   

   6 Nível 6 · 7 tutoriais · 2h 32min

   Exceções, arquivos e persistência

   Permite construir programas que lidam com dados externos e falhas previsíveis. Aplica módulos e coleções à leitura e gravação de informações, usando recursos existentes de gerenciamento de arquivos.

   O que você vai aprender

   • Interpretar rastreamentos de erro e tratar exceções específicas com try, except, else e finally.
   • Validar entradas e sinalizar situações inválidas com raise, sem ocultar falhas inesperadas.
   • Manipular caminhos com pathlib e ler ou gravar arquivos de texto e binários.
   • Usar with para fechar arquivos de forma confiável e definir a codificação de textos.
   • Converter dados entre coleções Python e arquivos JSON ou CSV, tratando falhas de formato e de acesso.

   Pré-requisitos

   • Coleções e conversão de tipos.
   • Funções, importações e uso da biblioteca padrão.

   1. 1 Tutorial 1: Tratar exceções com try, except, else e finally Interpretar um traceback com várias chamadas e tratar falhas esperadas sem esconder erros inesperados, distinguindo os caminhos de execução dos blocos de tratamento. Intermediário 25 min
   2. 2 Tutorial 2: Validar entradas e sinalizar falhas com raise Criar funções que rejeitam entradas inválidas com exceções adequadas e permitir que o código chamador decida como responder às falhas esperadas. Intermediário 18 min
   3. 3 Tutorial 3: Manipular caminhos com pathlib Construir e inspecionar caminhos pelo programa, criar pastas necessárias e reconhecer falhas comuns de acesso ao sistema de arquivos. Iniciante 18 min
   4. 4 Tutorial 4: Ler e gravar arquivos de texto com with Ler, criar e atualizar arquivos de texto com codificação explícita, escolhendo modos de abertura adequados e garantindo o fechamento na saída do bloco. Intermediário 25 min
   5. 5 Tutorial 5: Ler e gravar arquivos binários Preservar o conteúdo de arquivos binários e realizar conversões explícitas entre texto e bytes somente quando houver uma codificação conhecida. Intermediário 16 min
   6. 6 Tutorial 6: Salvar e carregar dados em JSON Persistir coleções compatíveis em JSON e recuperar seus dados, distinguindo erros de sintaxe, incompatibilidades de valores e problemas na estrutura esperada. Intermediário 25 min
   7. 7 Tutorial 7: Ler e gravar dados tabulares em CSV Importar e exportar registros tabulares com o módulo csv, respeitando delimitadores, cabeçalhos e conversões de campos e identificando registros inválidos. Intermediário 25 min
7. 7
   

   7 Nível 7 · 7 tutoriais · 2h 18min

   Modelagem orientada a objetos

   Introduz objetos próprios para representar entidades com estado e comportamento. Vem após funções e módulos para que classes sejam usadas como uma escolha de modelagem, e não como substitutas de toda organização anterior.

   O que você vai aprender

   • Definir classes, inicializar objetos com __init__ e implementar métodos de instância.
   • Distinguir atributos de instância e de classe, evitando compartilhamento acidental de estado.
   • Estabelecer responsabilidades e preservar regras de validade dos objetos.
   • Usar composição, herança, sobrescrita e super, justificando a escolha entre essas abordagens.
   • Aplicar polimorfismo e criar exceções próprias para representar erros do domínio.

   Pré-requisitos

   • Funções, escopos e organização em módulos.
   • Referências, mutabilidade e tratamento de exceções.

   1. 1 Tutorial 1: Criar objetos com classes e métodos de instância Definir uma classe simples, inicializar seus objetos e implementar métodos que consultam ou alteram o estado de cada instância. Iniciante 24 min
   2. 2 Tutorial 2: Distinguir atributos de instância e de classe Escolher onde armazenar cada atributo e corrigir compartilhamentos acidentais de estado entre objetos. Intermediário 16 min
   3. 3 Tutorial 3: Preservar regras de validade em objetos Modelar objetos que mantêm suas regras de validade desde a inicialização até as mudanças de estado, oferecendo operações com responsabilidades claras. Intermediário 20 min
   4. 4 Tutorial 4: Compor objetos com responsabilidades distintas Distribuir responsabilidades entre objetos colaboradores e implementar uma classe que delega parte de suas operações a outros objetos. Intermediário 18 min
   5. 5 Tutorial 5: Especializar classes com herança e super Criar especializações por herança simples, sobrescrever métodos e estender comportamentos com super, escolhendo herança apenas quando a relação entre os tipos a justificar. Intermediário 24 min
   6. 6 Tutorial 6: Aplicar polimorfismo pelo comportamento dos objetos Escrever código que trabalha com diferentes objetos por meio de operações compatíveis, sem depender de verificações de tipo para cada implementação. Intermediário 18 min
   7. 7 Tutorial 7: Criar exceções para erros do domínio Representar falhas específicas da aplicação com classes de exceção próprias e permitir que o código chamador trate cada situação no nível adequado. Intermediário 18 min
8. 8
   

   8 Nível 8 · 9 tutoriais · 2h 35min

   Testes, depuração e qualidade

   Estabelece formas sistemáticas de verificar e diagnosticar programas com funções e classes. Essa base permite explorar recursos avançados e realizar mudanças sem depender apenas de verificações manuais.

   O que você vai aprender

   • Escrever e executar testes automatizados de funções e classes com pytest.
   • Selecionar casos de sucesso, limites e falhas, incluindo a verificação de exceções.
   • Distinguir testes unitários de testes de integração e isolar dependências externas com substitutos de teste.
   • Usar pontos de interrupção, inspeção de variáveis e rastreamentos para localizar defeitos.
   • Registrar eventos com logging e aplicar formatadores e análise estática de estilo para melhorar a manutenção.

   Pré-requisitos

   • Funções e modelagem básica com classes.
   • Exceções, arquivos e importações.
   • Instalação de ferramentas em ambientes virtuais.

   1. 1 Tutorial 1: Escrever e executar testes de funções com pytest Criar testes automatizados para funções, executá-los com pytest no ambiente do projeto e interpretar os resultados das verificações. Intermediário 16 min
   2. 2 Tutorial 2: Selecionar casos de teste e verificar exceções Derivar casos de sucesso, limites e falhas a partir do comportamento esperado de uma operação, verificando também as exceções que ela deve produzir. Intermediário 18 min
   3. 3 Tutorial 3: Testar mudanças de estado em objetos Escrever testes de classes que verificam inicialização, transições de estado, rejeição de operações inválidas e independência entre instâncias. Intermediário 16 min
   4. 4 Tutorial 4: Isolar dependências com substitutos de teste Delimitar testes unitários e substituir colaboradores externos por objetos controlados, tornando os cenários reproduzíveis sem acessar recursos reais. Intermediário 20 min
   5. 5 Tutorial 5: Verificar integração com arquivos temporários Testar a colaboração entre componentes de processamento e persistência usando arquivos reais em diretórios temporários controlados pelo pytest. Intermediário 18 min
   6. 6 Tutorial 6: Investigar falhas com pontos de interrupção Usar o depurador para acompanhar uma execução reproduzível, localizar a origem de valores incorretos e proteger a correção com um teste de regressão. Intermediário 20 min
   7. 7 Tutorial 7: Registrar eventos e exceções com logging Produzir registros de execução úteis para diagnóstico, com níveis apropriados, configuração centralizada e cuidado com informações sensíveis. Intermediário 22 min
   8. 8 Tutorial 8: Padronizar a formatação do código com Ruff Aplicar uma formatação consistente aos arquivos Python e verificar sua conformidade sem confundir padronização visual com correção do programa. Iniciante 10 min
   9. 9 Tutorial 9: Analisar estilo e possíveis defeitos com Ruff Interpretar diagnósticos de análise estática, corrigir problemas simples e aplicar correções automáticas de maneira criteriosa. Intermediário 15 min
9. 9
   

   9 Nível 9 · 8 tutoriais · 2h 25min

   Funções de alta ordem e decoradores

   Explora funções como valores que podem ser recebidos, retornados e combinados. Aprofunda a abstração funcional depois que o aluno já consegue testar comportamentos e reconhecer responsabilidades no código.

   O que você vai aprender

   • Passar funções como argumentos e usá-las para personalizar operações como ordenação.
   • Escolher entre funções nomeadas, expressões lambda e compreensões conforme a legibilidade.
   • Criar closures e explicar a captura de variáveis, o uso de nonlocal e os efeitos da vinculação tardia.
   • Implementar decoradores simples e parametrizados, preservando metadados com functools.wraps.
   • Especializar funções com functools.partial e testar comportamentos adicionados por decoradores.

   Pré-requisitos

   • Parâmetros, retornos, escopos, *args e **kwargs.
   • Referências e mutabilidade.
   • Testes automatizados de funções.

   1. 1 Tutorial 1: Passar funções como argumentos Ao concluir, você será capaz de receber funções como parâmetros para variar o comportamento de uma operação e personalizar a ordenação de listas. Intermediário 18 min
   2. 2 Tutorial 2: Escolher entre lambda, funções nomeadas e compreensões Ao concluir, você será capaz de escrever funções curtas com lambda e escolher uma forma de expressão adequada à tarefa e à legibilidade. Intermediário 12 min
   3. 3 Tutorial 3: Criar closures com estado e nonlocal Ao concluir, você será capaz de retornar funções que conservam acesso ao ambiente de criação e mantêm estado local sem depender de variáveis globais. Intermediário 22 min
   4. 4 Tutorial 4: Controlar a vinculação tardia em closures Ao concluir, você será capaz de diagnosticar capturas inesperadas em funções criadas em laços e escolher quando compartilhar uma variável ou fixar a referência ao valor corrente. Intermediário 15 min
   5. 5 Tutorial 5: Especializar funções com functools.partial Ao concluir, você será capaz de criar versões especializadas de funções existentes, preenchendo antecipadamente parte dos argumentos sem executar a operação original. Intermediário 15 min
   6. 6 Tutorial 6: Criar decoradores com functools.wraps Ao concluir, você será capaz de acrescentar comportamento a funções por meio de decoradores, preservando o encaminhamento das chamadas e os principais metadados da função original. Intermediário 25 min
   7. 7 Tutorial 7: Criar decoradores parametrizados Ao concluir, você será capaz de configurar comportamentos adicionados por decoradores, separando os parâmetros da decoração dos argumentos usados para chamar a função decorada. Intermediário 18 min
   8. 8 Tutorial 8: Testar o comportamento de funções decoradas Ao concluir, você será capaz de verificar tanto o comportamento acrescentado por um decorador quanto as características da função original que devem continuar válidas. Intermediário 20 min
10. 10
    

    10 Nível 10 · 8 tutoriais · 2h 18min

    Iteradores e processamento sob demanda

    Introduz processamento incremental para dados que não precisam ser carregados de uma vez. Aprofunda o funcionamento da iteração sem repetir o ensino dos laços e das coleções prontas.

    O que você vai aprender

    • Distinguir iteráveis de iteradores e explicar o uso de iter, next e StopIteration.
    • Implementar objetos iteráveis com __iter__ e __next__.
    • Criar geradores com yield, expressões geradoras e delegação com yield from.
    • Combinar iteradores com itertools e funções para formar fluxos de transformação sob demanda.
    • Identificar consumo único, esgotamento e retenção de estado ao processar arquivos ou sequências extensas.

    Pré-requisitos

    • Laços, coleções e funções.
    • Classes, métodos e exceções.
    • Leitura de arquivos e funções de alta ordem.

    1. 1 Tutorial 1: Consumir iteradores com iter e next Distinguir uma fonte iterável de um iterador e controlar seu consumo, reconhecendo avanço, esgotamento e possibilidade de iniciar uma nova passagem. Intermediário 15 min
    2. 2 Tutorial 2: Implementar iteráveis e iteradores em classes Criar classes compatíveis com a iteração do Python, separando os dados da fonte do estado de cada percurso quando forem necessárias passagens independentes. Intermediário 20 min
    3. 3 Tutorial 3: Produzir valores sob demanda com yield Escrever funções geradoras que entregam um valor por solicitação e preservam seu progresso entre suspensões, sem construir antecipadamente uma coleção de resultados. Intermediário 18 min
    4. 4 Tutorial 4: Transformar dados com expressões geradoras Expressar transformações e filtros sob demanda e consumir seus resultados em agregações, escolhendo conscientemente entre um gerador e uma coleção materializada. Intermediário 16 min
    5. 5 Tutorial 5: Delegar a produção de valores com yield from Decompor uma função geradora em partes menores e encaminhar os elementos produzidos por outros iteráveis usando yield from. Intermediário 12 min
    6. 6 Tutorial 6: Limitar o consumo de iteradores com itertools Extrair trechos finitos e prefixos condicionais de iteradores, inclusive de fontes potencialmente infinitas, controlando quais elementos são consumidos. Intermediário 16 min
    7. 7 Tutorial 7: Compor fluxos de transformação sob demanda Conectar fontes, filtros, transformações e limites em um fluxo incremental, usando funções e itertools sem criar listas intermediárias desnecessárias. Intermediário 20 min
    8. 8 Tutorial 8: Processar arquivos em fluxos de consumo único Organizar o processamento incremental de arquivos mantendo a fonte disponível durante o consumo, evitando perda de registros e planejando novas passagens quando necessário. Intermediário 21 min
11. 11
    

    11 Nível 11 · 11 tutoriais · 3h 34min

    Modelo de dados e gerenciamento de recursos

    Ensina a integrar classes às convenções da linguagem e a controlar o ciclo de vida de recursos. Usa a base de objetos, decoradores e geradores para criar abstrações com comportamento previsível.

    O que você vai aprender

    • Implementar métodos especiais de representação, comparação, acesso e chamada quando fizerem sentido para o objeto.
    • Preservar a coerência entre igualdade, mutabilidade e hash em objetos usados em conjuntos ou dicionários.
    • Usar dataclasses, properties, métodos de classe e métodos estáticos em situações apropriadas.
    • Explicar o protocolo de descritores e aplicá-lo quando houver necessidade real de reutilizar o controle de atributos.
    • Criar gerenciadores de contexto com __enter__ e __exit__ ou contextlib, garantindo a liberação de recursos mesmo diante de exceções.

    Pré-requisitos

    • Classes, composição, herança e polimorfismo.
    • Decoradores e geradores.
    • Exceções, uso de with e testes automatizados.

    1. 1 Tutorial 1: Definir representações com __repr__ e __str__ Ao concluir, você poderá definir representações úteis de objetos para diagnóstico e apresentação, integrando suas classes a repr, str, print e f-strings. Intermediário 12 min
    2. 2 Tutorial 2: Definir igualdade e ordenação entre objetos Ao concluir, você poderá estabelecer comparações coerentes para objetos de domínio e permitir sua ordenação quando essa operação tiver significado. Avançado 22 min
    3. 3 Tutorial 3: Manter igualdade e hash coerentes Ao concluir, você poderá decidir se uma classe deve aceitar hash e implementar esse comportamento sem comprometer consultas em dicionários e conjuntos. Avançado 20 min
    4. 4 Tutorial 4: Integrar coleções próprias à sintaxe de acesso Ao concluir, você poderá oferecer tamanho, acesso por colchetes, pertencimento e alterações controladas em uma coleção própria, mantendo convenções familiares do Python. Avançado 22 min
    5. 5 Tutorial 5: Criar objetos chamáveis com __call__ Ao concluir, você poderá criar instâncias que funcionam como operações chamáveis e usar seu estado para configurar ou acompanhar chamadas. Intermediário 12 min
    6. 6 Tutorial 6: Controlar atributos com property Ao concluir, você poderá manter uma interface de atributo enquanto calcula valores ou valida atribuições, sem expor diretamente a organização interna do objeto. Intermediário 16 min
    7. 7 Tutorial 7: Definir métodos de classe e métodos estáticos Ao concluir, você poderá definir construtores alternativos e operações associadas a um tipo, escolhendo corretamente entre classmethod, staticmethod e funções de módulo. Intermediário 15 min
    8. 8 Tutorial 8: Modelar objetos de dados com dataclasses Ao concluir, você poderá usar dataclasses para reduzir código repetitivo em objetos de dados, controlando inicialização, representação, comparação e comportamento de hash. Intermediário 25 min
    9. 9 Tutorial 9: Reutilizar controle de atributos com descritores Ao concluir, você poderá implementar um descritor reutilizável para controlar atributos de várias classes e explicar sua participação na resolução de atributos. Avançado 25 min
    10. 10 Tutorial 10: Criar gerenciadores de contexto com classes Ao concluir, você poderá implementar o protocolo usado por with para adquirir e liberar recursos, incluindo caminhos de falha sem supressão acidental de exceções. Avançado 25 min
    11. 11 Tutorial 11: Criar gerenciadores de contexto com contextlib Ao concluir, você poderá expressar ciclos simples de aquisição e liberação com contextlib.contextmanager, usando um gerador sem comprometer a propagação de falhas. Avançado 20 min
12. 12
    

    12 Nível 12 · 11 tutoriais · 3h 38min

    Tipagem e contratos de interface

    Torna explícitos os contratos de componentes que já usam abstrações avançadas. Prepara interfaces verificáveis para aplicações maiores, sem confundir análise estática com validação em tempo de execução.

    O que você vai aprender

    • Anotar coleções, valores opcionais, uniões e funções recebidas como argumentos.
    • Definir tipos genéricos que preservem relações entre entradas e saídas.
    • Descrever interfaces com Protocol e classes abstratas, distinguindo contratos estruturais e nominais.
    • Executar um verificador de tipos e corrigir incompatibilidades sem recorrer indiscriminadamente a Any.
    • Separar garantias de tipagem estática de validações necessárias para dados externos em tempo de execução.

    Pré-requisitos

    • Anotações simples de funções.
    • Herança, polimorfismo e protocolos do modelo de dados.
    • Funções de alta ordem, iteradores e geradores.

    1. 1 Tutorial 1: Verificar anotações com mypy Executar o mypy em módulos anotados, interpretar seus diagnósticos e corrigir incompatibilidades sem desativar a verificação com Any. Intermediário 18 min
    2. 2 Tutorial 2: Anotar coleções e estruturas aninhadas Expressar os tipos de elementos, chaves e valores de coleções, incluindo estruturas aninhadas, e nomear anotações extensas com aliases. Intermediário 18 min
    3. 3 Tutorial 3: Tratar valores opcionais e uniões de tipos Representar valores que admitem tipos alternativos e organizar condições para que cada operação seja aplicada somente aos tipos compatíveis. Intermediário 18 min
    4. 4 Tutorial 4: Anotar funções recebidas e retornadas com Callable Descrever assinaturas de funções usadas como valores e verificar se funções, closures ou objetos chamáveis atendem ao contrato esperado. Intermediário 16 min
    5. 5 Tutorial 5: Preservar relações de tipos em funções genéricas Definir funções genéricas que preservem a relação entre os tipos recebidos e devolvidos, sem perder essa informação em object, Any ou uniões desnecessárias. Avançado 22 min
    6. 6 Tutorial 6: Escolher contratos de coleções e iteradores Anotar entradas e saídas conforme as operações realmente necessárias, permitindo diferentes coleções e fontes incrementais sem exigir tipos concretos por conveniência. Avançado 18 min
    7. 7 Tutorial 7: Definir classes genéricas com parâmetros de tipo Criar classes reutilizáveis que preservem o tipo dos dados armazenados e explicar por que algumas substituições entre classes parametrizadas são inseguras. Avançado 24 min
    8. 8 Tutorial 8: Definir interfaces estruturais com Protocol Formalizar contratos de colaboradores com Protocol e verificar implementações independentes sem exigir uma classe base compartilhada. Avançado 22 min
    9. 9 Tutorial 9: Definir contratos nominais com classes abstratas Criar interfaces baseadas em herança explícita com ABC e abstractmethod, distinguindo suas garantias das oferecidas por Protocol. Avançado 20 min
    10. 10 Tutorial 10: Descrever registros com TypedDict Representar dicionários com campos conhecidos e tipos específicos por chave, distinguindo campos ausentes de campos cujo valor pode ser None. Intermediário 18 min
    11. 11 Tutorial 11: Converter dados externos em valores validados e tipados Construir uma fronteira de entrada que receba dados externos sem garantias, valide sua estrutura e suas regras e entregue valores com um contrato estático confiável. Avançado 24 min
13. 13
    

    13 Nível 13 · 12 tutoriais · 3h 53min

    Concorrência e programação assíncrona

    Amplia programas sequenciais para a coordenação de tarefas simultâneas. Exige domínio de funções, exceções e recursos para lidar com falhas, cancelamento e estado compartilhado de forma controlada.

    O que você vai aprender

    • Distinguir concorrência de paralelismo e tarefas limitadas por entrada e saída de tarefas limitadas por processamento.
    • Escolher entre threads, processos e asyncio, considerando o GIL quando habilitado no CPython.
    • Executar tarefas com concurrent.futures e compreender os requisitos de comunicação e serialização entre processos.
    • Criar e coordenar corrotinas com async, await e asyncio sem bloquear indevidamente o laço de eventos.
    • Controlar limites de concorrência, tempos de espera, cancelamento e exceções, protegendo estado compartilhado contra condições de corrida.

    Pré-requisitos

    • Funções, classes e organização de módulos.
    • Exceções e gerenciamento de recursos.
    • Iteradores, geradores e contratos de interface.

    1. 1 Tutorial 1: Escolher entre threads, processos e asyncio Ao concluir, você será capaz de escolher um modelo de concorrência conforme o tipo de tarefa, as necessidades de compartilhamento de dados e as características do interpretador. Intermediário 15 min
    2. 2 Tutorial 2: Executar tarefas com ThreadPoolExecutor Ao concluir, você será capaz de executar funções independentes em um conjunto de threads e recuperar seus resultados ou falhas sem perder a associação com as entradas. Intermediário 20 min
    3. 3 Tutorial 3: Controlar espera e encerramento de tarefas em executores Ao concluir, você será capaz de limitar esperas, cancelar trabalho ainda não iniciado e solicitar a parada cooperativa de funções executadas em threads. Avançado 22 min
    4. 4 Tutorial 4: Proteger estado compartilhado entre threads Ao concluir, você será capaz de identificar atualizações concorrentes inseguras e proteger uma regra de estado com threading.Lock, evitando bloqueios desnecessários. Avançado 20 min
    5. 5 Tutorial 5: Executar funções em processos com ProcessPoolExecutor Ao concluir, você será capaz de distribuir funções entre processos com entradas e saídas serializáveis, organizando o programa para funcionar sem depender de memória global herdada. Avançado 22 min
    6. 6 Tutorial 6: Criar corrotinas com async e await Ao concluir, você será capaz de escrever e executar corrotinas simples, distinguindo espera cooperativa de chamadas que bloqueiam o laço de eventos. Intermediário 15 min
    7. 7 Tutorial 7: Gerenciar tarefas e cancelamento no asyncio Ao concluir, você será capaz de iniciar corrotinas como tarefas concorrentes, observar seus resultados e solicitar cancelamento preservando a limpeza de recursos. Avançado 20 min
    8. 8 Tutorial 8: Coordenar tarefas com asyncio.TaskGroup Ao concluir, você será capaz de manter tarefas relacionadas em um escopo comum que aguarda sua finalização, coordena cancelamentos diante de falhas e apresenta os erros sem abandonar tarefas. Avançado 25 min
    9. 9 Tutorial 9: Aplicar tempos de espera a operações assíncronas Ao concluir, você será capaz de delimitar o tempo de espera de uma operação ou de um conjunto de operações assíncronas e tratar o esgotamento desse prazo sem ocultar cancelamentos externos. Avançado 18 min
    10. 10 Tutorial 10: Integrar chamadas bloqueantes ao asyncio Ao concluir, você será capaz de chamar funções síncronas a partir de corrotinas sem executá-las diretamente no laço de eventos, escolhendo o executor e o ciclo de vida adequados. Avançado 20 min
    11. 11 Tutorial 11: Proteger estado compartilhado entre corrotinas Ao concluir, você será capaz de identificar regras de estado vulneráveis a intercalações em await e protegê-las com asyncio.Lock quando a exclusão mútua for necessária. Avançado 16 min
    12. 12 Tutorial 12: Limitar operações assíncronas com Semaphore Ao concluir, você será capaz de controlar quantas operações assíncronas acessam um recurso ao mesmo tempo e limitar a criação de tarefas sem confundir essas duas responsabilidades. Avançado 20 min
14. 14
    

    14 Nível 14 · 11 tutoriais · 3h 47min

    Desempenho, algoritmos e memória

    Ensina a decidir o que otimizar com base em medições, e não em suposições. Reúne o conhecimento de coleções, processamento incremental e concorrência para avaliar custos e preservar a correção.

    O que você vai aprender

    • Estimar custos de tempo e memória com notação O grande para operações e algoritmos comuns.
    • Medir trechos de código com timeit e localizar gargalos com ferramentas como cProfile e tracemalloc.
    • Escolher estruturas e estratégias adequadas, incluindo buscas com bisect, filas com deque e prioridades com heapq.
    • Avaliar os efeitos de cópias, materialização de dados, caches e referências mantidas sobre o uso de memória.
    • Comparar soluções sequenciais e concorrentes com cargas representativas, confirmando ganhos e executando testes após cada mudança.

    Pré-requisitos

    • Coleções, mutabilidade e decomposição de problemas.
    • Geradores e processamento sob demanda.
    • Testes automatizados e modelos de concorrência.

    1. 1 Tutorial 1: Estimar tempo e memória com notação O grande Estime como o trabalho e a memória necessária crescem com o tamanho da entrada, distinguindo limites assintóticos de tempos medidos em uma máquina. Intermediário 25 min
    2. 2 Tutorial 2: Medir trechos de código com timeit Construa medições repetíveis de pequenas operações e compare implementações equivalentes sem confundir preparação, execução e variação do ambiente. Intermediário 22 min
    3. 3 Tutorial 3: Localizar gargalos de execução com cProfile Analise a distribuição do tempo entre chamadas de funções para escolher uma hipótese de otimização apoiada em evidências. Intermediário 20 min
    4. 4 Tutorial 4: Reduzir buscas repetidas com índices em memória Substitua varreduras repetidas por índices com dicionários ou conjuntos quando o ganho de consulta justificar a construção e a memória adicional. Intermediário 18 min
    5. 5 Tutorial 5: Buscar em sequências ordenadas com bisect Use busca binária para localizar posições e intervalos em sequências ordenadas, contabilizando também o custo de ordenar e inserir elementos. Intermediário 18 min
    6. 6 Tutorial 6: Implementar filas eficientes com deque Escolha deque para cargas com inserções e remoções nas extremidades, evitando deslocamentos repetidos de elementos em listas. Intermediário 15 min
    7. 7 Tutorial 7: Gerenciar prioridades com heapq Mantenha uma coleção que permite retirar repetidamente o item de menor prioridade sem ordenar todos os elementos após cada alteração. Intermediário 20 min
    8. 8 Tutorial 8: Localizar alocações de memória com tracemalloc Meça o pico de memória rastreada e localize trechos associados ao crescimento de alocações, reconhecendo o que tracemalloc consegue observar. Avançado 20 min
    9. 9 Tutorial 9: Reduzir o pico e a retenção de memória Use medições para reduzir a quantidade de dados mantida ao mesmo tempo, eliminando cópias dispensáveis e referências que prolongam a vida de estruturas auxiliares. Avançado 22 min
    10. 10 Tutorial 10: Controlar tempo e memória de caches com lru_cache Aplique cache a cálculos adequados e avalie se a reutilização compensa a memória retida, os custos de consulta e as exigências de invalidação. Avançado 22 min
    11. 11 Tutorial 11: Comparar desempenho sequencial e concorrente Conduza uma comparação de ponta a ponta entre soluções sequenciais e concorrentes, confirmando ganhos em cargas representativas e preservando o contrato do programa. Avançado 25 min
15. 15
    

    15 Nível 15 · 10 tutoriais · 3h 30min

    Arquitetura e distribuição de aplicações

    Integra a trilha na construção de uma aplicação de linha de comando instalável. Acrescenta decisões de arquitetura, empacotamento e validação da entrega para transformar código funcional em software reutilizável.

    O que você vai aprender

    • Definir requisitos e separar regras de negócio, acesso a dados e interface de linha de comando em componentes com contratos claros.
    • Implementar uma interface com argparse, configuração externa e mensagens de erro adequadas ao usuário.
    • Configurar metadados, dependências e pontos de entrada em pyproject.toml e gerar distribuições instaláveis.
    • Automatizar verificações de estilo, tipagem e testes, incluindo testes de integração da aplicação empacotada.
    • Validar instalação e execução em um ambiente limpo e documentar uso, limitações e decisões de arquitetura e desempenho.

    Pré-requisitos

    • Organização em módulos, ambientes virtuais e gerenciamento de dependências.
    • Persistência, modelagem de objetos e contratos de interface.
    • Testes, depuração e logging.
    • Critérios de escolha de concorrência e análise de desempenho.

    1. 1 Tutorial 1: Definir requisitos verificáveis para uma aplicação de linha de comando Delimitar uma aplicação de linha de comando para consultar e atualizar um catálogo local em JSON, definindo comportamentos e critérios de aceitação que orientarão sua implementação e entrega. Intermediário 15 min
    2. 2 Tutorial 2: Separar domínio, persistência e interface Organizar a aplicação em componentes com contratos claros, mantendo as regras do catálogo independentes do terminal e do formato de armazenamento. Avançado 25 min
    3. 3 Tutorial 3: Criar comandos e opções com argparse Expor os casos de uso da aplicação por uma interface de terminal com argumentos, opções, subcomandos e ajuda gerada pelo argparse. Intermediário 20 min
    4. 4 Tutorial 4: Carregar configurações externas com precedência explícita Resolver a configuração da aplicação a partir de padrões, arquivo TOML, variáveis de ambiente e opções da CLI, com regras claras para conflitos e valores inválidos. Intermediário 20 min
    5. 5 Tutorial 5: Traduzir falhas em mensagens e códigos de saída Estabelecer um contrato de sucesso e falha para a CLI, separando resultados, mensagens ao usuário e informações de diagnóstico. Intermediário 15 min
    6. 6 Tutorial 6: Configurar uma distribuição com pyproject.toml Preparar o projeto para instalação, declarando seus metadados, dependências e comando de terminal em pyproject.toml. Intermediário 25 min
    7. 7 Tutorial 7: Gerar e inspecionar wheel e sdist Construir os artefatos da aplicação e conferir se contêm os arquivos e metadados necessários para distribuição, sem incluir dados locais indevidos. Intermediário 20 min
    8. 8 Tutorial 8: Testar a aplicação instalada em um ambiente limpo Escrever testes de integração que instalam a wheel em um ambiente novo e executam o comando real fora da pasta do projeto, detectando problemas ocultos pela instalação de desenvolvimento. Avançado 25 min
    9. 9 Tutorial 9: Automatizar as verificações do projeto com Nox Criar uma rotina reproduzível que execute formatação, lint, tipagem, testes e validação da distribuição, sinalizando falhas antes da entrega. Avançado 25 min
    10. 10 Tutorial 10: Documentar uso, limitações e decisões da aplicação Preparar a documentação da entrega com instruções verificadas de instalação e uso, limites conhecidos e justificativas das decisões de arquitetura e desempenho. Intermediário 20 min