Parte I: Estruturas de dados

    1. O modelo de dados de Python
        1.1. Novidades nesse capítulo
        1.2. Um baralho pythônico
        1.3. Como os métodos especiais são utilizados
        1.4. Visão geral dos métodos especiais
        1.5. Por que len não é um método?
        1.6. Resumo do capítulo
        1.7. Para saber mais
    2. Uma coleção de sequências
        2.1. Novidades neste capítulo
        2.2. Uma visão geral das sequências embutidas
        2.3. Compreensões de listas e expressões geradoras
        2.4. Tuplas não são apenas listas imutáveis
        2.5. Desempacotando sequências e iteráveis
        2.6. Pattern matching com sequências
        2.7. Fatiamento
        2.8. Usando + e * com sequências
        2.9. list.sort versus a função embutida sorted
        2.10. Quando uma lista não é a resposta
        2.11. Resumo do capítulo
        2.12. Leitura complementar
    3. Dicionários e conjuntos
        3.1. Novidades nesse capítulo
        3.2. A sintaxe moderna dos dicts
        3.3. Pattern matching com mapeamentos
        3.4. A API padrão dos tipos de mapeamentos
        3.5. Tratamento automático de chaves ausentes
        3.6. Variações de dict
        3.7. Mapeamentos imutáveis
        3.8. Views de dicionários
        3.9. Consequências práticas da forma como dict funciona
        3.10. Teoria dos conjuntos
        3.11. Consequências práticas da forma de funcionamento dos conjuntos
        3.12. Operações de conjuntos em views de dict
        3.13. Resumo do capítulo
        3.14. Leitura complementar
    4. Texto em Unicode versus Bytes
        4.1. Novidades nesse capítulo
        4.2. Questões de caracteres
        4.3. Os fundamentos do byte
        4.4. Codificadores/Decodificadores básicos
        4.5. Entendendo os problemas de codificação/decodificação
        4.6. Processando arquivos de texto
        4.7. Normalizando o Unicode para comparações confiáveis
        4.8. Ordenando texto Unicode
        4.9. O banco de dados do Unicode
        4.10. APIs de modo dual para str e bytes
        4.11. Resumo do capítulo
        4.12. Leitura complementar
    5. Fábricas de classes de dados
        5.1. Novidades nesse capítulo
        5.2. Visão geral das fábricas de classes de dados
        5.3. Tuplas nomeadas clássicas
        5.4. Tuplas nomeadas com tipo
        5.5. Introdução às dicas de tipo
        5.6. Mais detalhes sobre @dataclass
        5.7. A classe de dados como cheiro no código
        5.8. Pattern Matching com instâncias de classes
        5.9. Resumo do Capítulo
        5.10. Leitura complementar
    6. Referências, mutabilidade, e memória
        6.1. Novidades nesse capítulo
        6.2. Variáveis não são caixas
        6.3. Identidade, igualdade e apelidos
        6.4. A princípio, cópias são rasas
        6.5. Parâmetros de função como referências
        6.6. del e coleta de lixo
        6.7. Peças que Python prega com imutáveis
        6.8. Resumo do capítulo
        6.9. Para saber mais

Parte II: Funções como objetos

    7. Funções como objetos de primeira classe
        7.1. Novidades nesse capítulo
        7.2. Tratando uma função como um objeto
        7.3. Funções de ordem superior
        7.4. Funções anônimas
        7.5. Os nove sabores de objetos invocáveis
        7.6. Tipos invocáveis definidos pelo usuário
        7.7. De parâmetros posicionais a parâmetros somente nomeados
        7.8. Pacotes para programação funcional
        7.9. Resumo do capítulo
        7.10. Leitura complementar
    8. Dicas de tipo em funções
        8.1. Novidades nesse capítulo
        8.2. Sobre tipagem gradual
        8.3. Tipagem gradual na prática
        8.4. Tipos são definidos pelas operações possíveis
        8.5. Tipos próprios para anotações
        8.6. Anotando parâmetros apenas posicionais e variádicos
        8.7. Tipos imperfeitos e testes poderosos
        8.8. Resumo do capítulo
        8.9. Para saber mais
    9. Decoradores e Clausuras
        9.1. Novidades nesse capítulo
        9.2. Introdução aos decoradores
        9.3. Quando Python executa decoradores
        9.4. Decoradores de registro
        9.5. Regras de escopo de variáveis
        9.6. Clausuras
        9.7. A declaração nonlocal
        9.8. Implementando um decorador simples
        9.9. Decoradores na biblioteca padrão
        9.10. Decoradores parametrizados
        9.11. Resumo do capítulo
        9.12. Leitura complementar
    10. Padrões de projetos com funções de primeira classe
        10.1. Novidades nesse capítulo
        10.2. Estudo de caso: refatorando Estratégia
        10.3. Padrão Estratégia aperfeiçoado com um decorador
        10.4. O padrão Comando
        10.5. Resumo do Capítulo
        10.6. Leitura complementar

Parte III: Classes e protocolos

    11. Um objeto pythônico
        11.1. Novidades nesse capítulo
        11.2. Representações de objetos
        11.3. A volta da classe Vector
        11.4. Um construtor alternativo
        11.5. classmethod versus staticmethod
        11.6. Exibição formatada
        11.7. Um Vector2d hashable
        11.8. Suportando o pattern matching posicional
        11.9. Listagem completa Vector2d, versão 3
        11.10. Atributos privados e "protegidos" no Python
        11.11. Economizando memória com __slots__
        11.12. Sobrepondo atributos de classe
        11.13. Resumo do capítulo
        11.14. Leitura complementar
    12. Métodos especiais para sequências
        12.1. Novidades nesse capítulo
        12.2. Vector: Um tipo sequência definido pelo usuário
        12.3. Vector versão #1: compatível com Vector2d
        12.4. Protocolos e o duck typing
        12.5. Vector versão #2: Uma sequência fatiável
        12.6. Vector versão #3: acesso dinâmico a atributos
        12.7. Vector versão #4: o hash e um == mais rápido
        12.8. Vector versão #5: Formatando
        12.9. Resumo do capítulo
        12.10. Leitura complementar
    13. Interfaces, protocolos, e ABCs
        13.1. O mapa de tipagem
        13.2. Novidades nesse capítulo
        13.3. Dois tipos de protocolos
        13.4. Programando patos
        13.5. Goose typing
        13.6. Protocolos estáticos
        13.7. Resumo do capítulo
        13.8. Para saber mais
    14. Herança: para o bem ou para o mal
        14.1. Novidades nesse capítulo
        14.2. A função super()
        14.3. É complicado criar subclasses de tipos embutidos
        14.4. Herança múltipla e a Ordem de Resolução de Métodos
        14.5. Classes mixin
        14.6. Herança múltipla no mundo real
        14.7. Lidando com a herança
        14.8. Resumo do capítulo
        14.9. Leitura complementar
    15. Mais dicas de tipo
        15.1. Novidades nesse capítulo
        15.2. Assinaturas sobrepostas
        15.3. TypedDict
        15.4. Coerção de Tipo
        15.5. Lendo dicas de tipo durante a execução
        15.6. Implementando uma classe genérica
        15.7. Variância
        15.8. Implementando um protocolo estático genérico
        15.9. Resumo do capítulo
        15.10. Leitura complementar
    16. Sobrecarga de operadores
        16.1. Novidades nesse capítulo
        16.2. Introdução à sobrecarga de operadores
        16.3. Operadores unários
        16.4. Sobrecarregando + para adição de Vector
        16.5. Sobrecarregando * para multiplicação escalar
        16.6. Usando @ como operador infixo
        16.7. Resumindo os operadores aritméticos
        16.8. Operadores de comparação cheia
        16.9. Operadores de atribuição aumentada
        16.10. Resumo do capítulo
        16.11. Leitura complementar

Parte IV: Controle de fluxo

    17. Iteradores, geradores e corrotinas clássicas
        17.1. Novidades nesse capítulo
        17.2. Uma sequência de palavras
        17.3. Porque sequências são iteráveis: a função iter
        17.4. Iteráveis versus iteradores
        17.5. Classes Sentence com __iter__
        17.6. Sentenças preguiçosas
        17.7. Quando usar expressões geradoras
        17.8. Um gerador de progressão aritmética
        17.9. Funções geradoras na biblioteca padrão
        17.10. Funções de redução de iteráveis
        17.11. Subgeradoras com yield from
        17.12. Tipos iteráveis genéricos
        17.13. Corrotinas clássicas
        17.14. Resumo do capítulo
        17.15. Leitura complementar
    18. Instruções with, match, e blocos else
        18.1. Novidades nesse capítulo
        18.2. Gerenciadores de contexto e a instrução with
        18.3. Pattern matching no lis.py: um estudo de caso
        18.4. Faça isso, então aquilo: os blocos else além do if
        18.5. Resumo do capítulo
        18.6. Para saber mais
    19. Modelos de concorrência em Python
        19.1. Novidades nesse capítulo
        19.2. A visão geral
        19.3. Um pouco de jargão
        19.4. Um "Olá mundo" concorrente
        19.5. O real impacto da GIL
        19.6. Um pool de processos caseiro
        19.7. Python no mundo multi-núcleo.
        19.8. Resumo do capítulo
        19.9. Para saber mais
    20. Executores concorrentes
        20.1. Novidades nesse capítulo
        20.2. Downloads concorrentes da web
        20.3. Iniciando processos com concurrent.futures
        20.4. Experimentando com Executor.map
        20.5. Download com exibição do progresso e tratamento de erro
        20.6. Resumo do capítulo
        20.7. Para saber mais
    21. Programação assíncrona
        21.1. Novidades nesse capítulo
        21.2. Algumas definições.
        21.3. Um exemplo de asyncio: sondando domínios
        21.4. Novo conceito: awaitable ou esperável
        21.5. Downloads com asyncio e HTTPX
        21.6. Gerenciadores de contexto assíncronos
        21.7. Melhorando o download de bandeiras asyncio
        21.8. Delegando tarefas a executores
        21.9. Programando servidores asyncio
        21.10. Iteração assíncrona e iteráveis assíncronos
        21.11. Programação assíncrona além do asyncio: Curio
        21.12. Dicas de tipo para objetos assíncronos
        21.13. Como a programação assíncrona funciona e como não funciona
        21.14. Resumo do capítulo
        21.15. Para saber mais

Parte V: Metaprogramação

    22. Atributos dinâmicos e propriedades
        22.1. Novidades nesse capítulo
        22.2. Processamento de dados com atributos dinâmicos
        22.3. Propriedades computadas
        22.4. Usando uma propriedade para validação de atributos
        22.5. Considerando as propriedades de forma adequada
        22.6. Criando uma fábrica de propriedades
        22.7. Tratando a exclusão de atributos
        22.8. Atributos e funções essenciais para tratamento de atributos
        22.9. Resumo do capítulo
        22.10. Leitura Complementar
    23. Descritores de Atributos
        23.1. Novidades nesse capítulo
        23.2. Exemplo de descritor: validação de atributos
        23.3. Descritores dominantes versus descritores não dominantes
        23.4. Métodos são descritores
        23.5. Dicas para o uso de descritores
        23.6. Docstrings de descritores e a sobreposição de exclusão
        23.7. Resumo do capítulo
        23.8. Leitura complementar
    24. Metaprogramação de classes
        24.1. Novidades nesse capítulo
        24.2. Classes como objetos
        24.3. type: a fábrica de classes embutida
        24.4. Uma função fábrica de classes
        24.5. Apresentando __init_subclass__
        24.6. Melhorando classes com um decorador de classes
        24.7. O que acontece quando: importação versus execução
        24.8. Introdução às metaclasses
        24.9. Uma solução para Checked usando uma metaclasse
        24.10. Metaclasses no mundo real
        24.11. Um hack de metaclasse com __prepare__
        24.12. Para encerrar
        24.13. Resumo do capítulo
        24.14. Leitura complementar
    Posfácio

