Oficina Python Fluente

Capa de Fluent Python Second Edition (O'Reilly, 2022)

A Oficina Python Fluente é uma atividade presencial na sede do Garoa Hacker Clube, baseada no livro Python Fluente, Segunda Edição

Sobre o Python Fluente

Fluent Python ou Python Fluente é um livro intermediáro/avançado sobre a linguagem Python, escrito por Luciano Ramalho, publicado originalmente nos EUA pela O'Reilly Media em 2015 (first edition) e 2022 (second edition).

A primeira edição foi publicada em 9 idiomas (inglês, português, japonês, russo, coreano, francês, polonês, chinês simplificado, chinês tradicional), e tem excelentes avaliações nas livrarias online ao redor do mundo.

O texto integral de Python Fluente Segunda Edição em português está online, de graça, sob uma licença Creative Commons. A primeira edição em português está esgotada.

A segunda edição em inglês, polonês, russo, ou chinês pode ser adquirida nas livrarias que trabalham com estes idiomas.

Formato

24 encontros de 3h abordando temas dos 24 capítulos do Python Fluente, Segunda Edição.

Cada oficina terá momentos expositivos e exercícios. Traga seu notebook com Python instalado!

As sessões não serão oferecidas em vídeo ao vivo, nem publicadas depois. É uma atividade 100% presencial.

Pré-requisitos

• Saber programar em qualquer linguagem de programação que tenha classes.

• Noções básicas de Python, equivalentes aos capítulos 1 a 9 do Tutorial de Python.

Na dúvida, recomendo revisar o índice do Tutorial de Python para identificar se você precisa estudar algum ponto para melhor aproveitar esta oficina.

Datas e horários

Os encontros semanais acontecerão às terças-feiras, de 19:00 a 22:00, a partir do dia 30/jul/2024 na Sede do Garoa Hacker Clube.

Veja a data de cadas capítulo na lista de tópicos abaixo.

Inscrições e preços

A oficina é gratuita, mas cada participante precisa pegar um ingresso. O primeiro encontro lotou, mas há uma lista de espera:

https://forms.gle/qc7NEpimrehShMqF6

Alimentação

No intervalo podemos pedir pizza, e daí quem quiser paga sua parte (cerca de R$ 25 para 2 ou 3 pedaços). Também é permitido trazer marmita, comer antes, ou ficar com fome.

Temas

Parte I: Estruturas de dados (30/jul a 3/set/2024)

Seis encontros sobre como Python lida de modo uniforme com as estruturas de dados mais importantes e úteis.

Nota: nesses sumários as seções 1.1, 2.1, 3.1... N.1 até 24.1 foram removidas porque no livro elas são "Novidades deste capítulo".

1. O modelo de dados do Python (30/jul/2024)

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?

2. Uma coleção de sequências (6/ago/2024)

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

3. Dicionários e conjuntos (13/ago/2024)

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

4. Texto em Unicode versus Bytes (20/ago/2024)

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

5. Fábricas de classes de dados (27/ago/2024)

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

6. Referências, mutabilidade, e memória (3/set/2024)

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

Parte II: Funções como objetos

Aprenda o poder das funções em Python, evite criar classes sem motivo, e aplique o paradigma funcional quando fizer sentido (4 encontros).

 
    7. Funções como objetos de primeira classe
        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
    8. Dicas de tipo em funções
        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
    9. Decoradores e Clausuras
        9.2. Introdução aos decoradores
        9.3. Quando o 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
    10. Padrões de projetos com funções de primeira classe
        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

Parte III: Classes e protocolos

Toda linguagem com classes implementa a Orientação a Objetos de um modo particular. Conheça OOP no estilo pythônico (6 encontros).

 
    11. Um objeto pythônico
        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
    12. Métodos especiais para sequências
        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
    13. Interfaces, protocolos, e ABCs
        13.1. O mapa de tipagem
        13.3. Dois tipos de protocolos
        13.4. Programando patos
        13.5. Goose typing
        13.6. Protocolos estáticos
    14. Herança: para o bem ou para o mal
        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
    15. Mais dicas de tipo
        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
    16. Sobrecarga de operadores
        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

Parte IV: Controle de fluxo

Python tem mecanismos de controle de fluxo modernos que nem todo mundo domina. Vamos conhecê-los em 5 encontros.

    17. Iteradores, geradores e corrotinas clássicas
        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
    18. Instruções with, match, e blocos else
        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
    19. Modelos de concorrência em Python
        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.
    20. Executores concorrentes
        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
    21. Programação assíncrona
        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

Parte V: Metaprogramação

Um programa Python é também uma estrutura de dados que pode ser alterada em tempo de execução. Veremos como nos 3 encontros finais.

    22. Atributos dinâmicos e propriedades
        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
    23. Descritores de Atributos
        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
    24. Metaprogramação de classes
        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__