Sumário
Propaganda
Python Fluente Luciano Ramalho Novatec Sumário Prefácio............................................................................................................................. 17 Parte I ■ Prólogo................................................................................................. 27 Capítulo 1 ■ Modelo de dados do Python.............................................................................28 Um baralho pythônico.....................................................................................29 Como os métodos especiais são usados............................................................ 33 Emulando tipos numéricos..........................................................................34 Representação em string..............................................................................36 Operadores aritméticos............................................................................... 37 Valor booleano de um tipo definido pelo usuário......................................... 37 Visão geral dos métodos especiais....................................................................38 Por que len não é um método?.......................................................................... 39 Resumo do capítulo.........................................................................................40 Leituras complementares................................................................................. 41 Parte II ■ Estruturas de dados.............................................................................. 43 Capítulo 2 ■ Uma coleção de sequências..............................................................................44 Visão geral das sequências embutidas............................................................... 45 List comprehensions e expressões geradoras.....................................................46 List comprehensions e legibilidade...............................................................46 Comparação entre listcomps e map/filter.....................................................48 Produtos cartesianos...................................................................................49 Expressões geradoras..................................................................................50 Tuplas não são apenas listas imutáveis.............................................................. 52 Tuplas como registros.................................................................................. 52 Desempacotamento de tuplas...................................................................... 53 Desempacotamento de tuplas aninhadas...................................................... 55 Tuplas nomeadas......................................................................................... 56 Tuplas como listas imutáveis........................................................................ 58 7 8 Python Fluente Fatiamento...................................................................................................... 59 Por que as fatias e os intervalos excluem o último item................................. 59 Objetos slice...............................................................................................60 Fatiamento multidimensional e reticências................................................... 62 Atribuição de valores a fatias....................................................................... 62 Usando + e * com sequências............................................................................63 Criando listas de listas................................................................................64 Atribuições combinadas e sequências...............................................................65 O enigma da atribuição +=..........................................................................67 list.sort e a função embutida sorted.................................................................. 69 Administrando sequências ordenadas com bisect.............................................. 71 Pesquisando com bisect............................................................................... 71 Inserção com bisect.insort........................................................................... 74 Quando uma lista não é a resposta................................................................... 75 Arrays......................................................................................................... 75 Memory Views............................................................................................ 78 NumPy e SciPy...........................................................................................80 Deques e outras filas...................................................................................82 Resumo do capítulo.........................................................................................86 Leituras complementares................................................................................. 87 Capítulo 3 ■ Dicionários e conjuntos....................................................................................93 Tipos genéricos de mapeamento.......................................................................94 dict comprehensions........................................................................................96 Visão geral dos métodos comuns a mapeamentos.............................................. 97 Tratando chaves ausentes com setdefault.....................................................98 Mapeamentos com consulta de chave flexível.................................................. 101 defaultdict: outra abordagem para chaves ausentes..................................... 101 Método __missing__ ............................................................................... 102 Variações de dict............................................................................................ 105 Criando subclasses de UserDict...................................................................... 106 Mapeamentos imutáveis................................................................................. 108 Teoria dos conjuntos...................................................................................... 109 Literais de set............................................................................................ 111 Set comprehensions................................................................................... 113 Operações de conjuntos............................................................................ 113 Por dentro de dict e set................................................................................... 116 Um experimento para testar o desempenho............................................... 116 Tabelas hash em dicionários...................................................................... 118 Consequências práticas de como os dicionários funcionam........................ 121 Como os conjuntos funcionam – consequências práticas............................ 125 Resumo do capítulo....................................................................................... 125 Leituras complementares............................................................................... 126 Sumário 9 Capítulo 4 ■ Texto versus bytes......................................................................................... 129 Falhas de caracteres....................................................................................... 130 O essencial sobre bytes.................................................................................. 131 Structs e memory views............................................................................. 134 Codificadores/decodificadores básicos............................................................ 135 Entendendo os problemas de codificação/decodificação.................................. 137 Lidando com UnicodeEncodeError............................................................ 138 Lidando com UnicodeDecodeError............................................................ 139 SyntaxError ao carregar módulos com codificação inesperada.................... 140 Como descobrir a codificação de uma sequência de bytes........................... 142 BOM: um gremlin útil............................................................................... 142 Lidando com arquivos-texto........................................................................... 144 Defaults de codificação: um hospício......................................................... 147 Normalizando Unicode para comparações mais seguras................................. 150 Case folding.............................................................................................. 153 Funções utilitárias para comparações normalizadas................................... 154 “Normalização” extrema: removendo acentos............................................ 155 Ordenação de texto Unicode.......................................................................... 159 Ordenação com o Unicode Collation Algorithm ........................................ 161 Base de dados Unicode................................................................................... 161 APIs de modo dual para str e bytes................................................................. 163 str versus bytes em expressões regulares.................................................... 163 str versus bytes em funções de os............................................................... 165 Resumo do capítulo....................................................................................... 167 Leituras complementares............................................................................... 169 Parte III ■ Funções como objetos........................................................................174 Capítulo 5 ■ Funções de primeira classe............................................................................. 175 Tratando uma função como um objeto........................................................... 176 Funções de ordem superior............................................................................. 177 Substitutos modernos para map, filter e reduce.......................................... 178 Funções anônimas......................................................................................... 180 As sete variações de objetos invocáveis........................................................... 181 Tipos invocáveis definidos pelo usuário.......................................................... 182 Introspecção de função.................................................................................. 183 De parâmetros posicionais a parâmetros exclusivamente nomeados................ 185 Obtendo informações sobre parâmetros......................................................... 187 Anotações de função...................................................................................... 192 Pacotes para programação funcional............................................................... 194 Módulo operator....................................................................................... 194 Congelando argumentos com functools.partial.......................................... 198 10 Python Fluente Resumo do capítulo.......................................................................................200 Leituras complementares............................................................................... 201 Capítulo 6 ■ Padrões de projeto com funções de primeira classe......................................... 205 Estudo de caso: refatorando Strategy.............................................................. 206 Strategy clássico........................................................................................ 206 Strategy orientado a função....................................................................... 210 Escolhendo a melhor estratégia: abordagem simples................................... 213 Encontrando estratégias em um módulo.................................................... 214 Command..................................................................................................... 216 Resumo do capítulo....................................................................................... 218 Leituras complementares............................................................................... 219 Capítulo 7 ■ Decoradores de função e closures................................................................... 222 Básico sobre decoradores................................................................................223 Quando Python executa os decoradores......................................................... 224 Padrão Strategy melhorado com decorador..................................................... 226 Regras para escopo de variáveis...................................................................... 228 Closures........................................................................................................ 232 Declaração nonlocal....................................................................................... 235 Implementando um decorador simples........................................................... 237 Funcionamento......................................................................................... 238 Decoradores da biblioteca-padrão................................................................... 240 Memoização com functools.lru_cache....................................................... 240 Funções genéricas com dispatch simples.................................................... 243 Decoradores empilhados................................................................................ 246 Decoradores parametrizados.......................................................................... 247 Um decorador de registro parametrizado................................................... 247 Decorador clock parametrizado................................................................. 249 Resumo do capítulo....................................................................................... 252 Leituras complementares............................................................................... 253 Parte IV ■ Práticas de orientação a objetos........................................................ 257 Capítulo 8 ■ Referências a objetos, mutabilidade e reciclagem.......................................... 258 Variáveis não são caixas................................................................................. 259 Identidade, igualdade e apelidos..................................................................... 260 Escolhendo entre == e is........................................................................... 262 A relativa imutabilidade das tuplas............................................................ 263 Cópias são rasas por padrão........................................................................... 264 Cópias profundas e rasas de objetos quaisquer........................................... 267 Sumário 11 Parâmetros de função como referências.......................................................... 268 Tipos mutáveis como default de parâmetros: péssima ideia......................... 270 Programação defensiva com parâmetros mutáveis...................................... 272 del e coleta de lixo.......................................................................................... 274 Referências fracas.......................................................................................... 276 Esquete com WeakValueDictionary........................................................... 277 Limitações das referências fracas............................................................... 279 Truques de Python com imutáveis..................................................................280 Resumo do capítulo....................................................................................... 282 Leituras complementares............................................................................... 283 Capítulo 9 ■ Um objeto pythônico.....................................................................................288 Representações de objetos.............................................................................. 289 Retorno da classe Vector................................................................................ 289 Um construtor alternativo.............................................................................. 292 classmethod versus staticmethod.................................................................... 293 Apresentações formatadas.............................................................................. 295 Um Vector2d hashable................................................................................... 298 Atributos privados e “protegidos” em Python.................................................. 304 Economizando espaço com o atributo de classe __slots__ ............................. 307 Os problemas com __slots__.................................................................... 309 Sobrescrita de atributos de classe.................................................................... 310 Resumo do capítulo....................................................................................... 312 Leituras complementares............................................................................... 313 Capítulo 10 ■ Hackeando e fatiando sequências................................................................ 318 Vector: um tipo de sequência definido pelo usuário......................................... 319 Vector tomada #1: compatível com Vector2d.................................................. 319 Protocolos e duck typing................................................................................ 322 Vector tomada #2: uma sequência que permite fatiamento.............................. 323 Como funciona o fatiamento..................................................................... 324 Um __getitem__ que considera fatias........................................................ 327 Vector tomada #3: acesso dinâmico a atributos.............................................. 328 Vector tomada #4: hashing e um == mais rápido............................................ 332 Vector tomada #5: formatação....................................................................... 338 Resumo do capítulo....................................................................................... 345 Leituras complementares............................................................................... 347 Capítulo 11 ■ Interfaces: de protocolos a ABCs................................................................... 352 Interfaces e protocolos na cultura de Python................................................... 353 Python curte sequências................................................................................. 355 Monkey-patching para implementar um protocolo em tempo de execução....... 357 Aves aquáticas de Alex Martelli...................................................................... 359 12 Python Fluente Criando subclasses de uma ABC.................................................................... 365 ABCs da biblioteca-padrão............................................................................. 367 ABCs em collections.abc........................................................................... 367 A torre numérica de ABCs......................................................................... 369 Definindo e usando uma ABC........................................................................ 370 Detalhes de sintaxe das ABCs.................................................................... 374 Herdando da ABC Tombola...................................................................... 375 Uma subclasse virtual de Tombola............................................................. 378 Como as subclasses de Tombola foram testadas.............................................. 381 Uso de register na prática............................................................................... 384 Gansos podem se comportar como patos........................................................ 385 Resumo do capítulo....................................................................................... 386 Leituras complementares............................................................................... 389 Capítulo 12 ■ Herança: para o bem ou para o mal.............................................................. 395 Artimanhas da criação de subclasses de tipos embutidos................................ 396 Herança múltipla e ordem de resolução de métodos........................................ 399 Herança múltipla no mundo real....................................................................404 Lidando com herança múltipla....................................................................... 407 1. Faça a distinção entre herança de interface e herança de implementação. 407 2. Deixe as interfaces explícitas com ABCs................................................ 407 3. Use mixins para reutilização de código.................................................. 407 4. Explicite as mixins pelo nome................................................................408 5. Uma ABC também pode ser uma mixin; o contrário não é verdade.........408 6. Não herde de mais de uma classe concreta.............................................408 7. Ofereça classes agregadas aos usuários...................................................409 8. “Prefira composição de objetos à herança de classe.”..............................409 Tkinter: o bom, o ruim e o feio.................................................................. 410 Um exemplo moderno: mixins em views genéricas de Django......................... 411 Resumo do capítulo....................................................................................... 414 Leituras complementares............................................................................... 415 Capítulo 13 ■ Sobrecarga de operadores: o jeito certo........................................................ 419 Básico da sobrecarga de operadores................................................................ 420 Operadores unários....................................................................................... 420 Sobrecarregando + para soma de vetores........................................................ 423 Sobrecarregando * para multiplicação por escalar............................................ 429 Operadores de comparação rica...................................................................... 433 Operadores de atribuição combinada............................................................. 438 Resumo do capítulo....................................................................................... 443 Leituras complementares...............................................................................444 Sumário 13 Parte V ■ Controle de fluxo................................................................................ 449 Capítulo 14 ■ Iteráveis, iteradores e geradores.................................................................. 450 Sentence tomada #1: uma sequência de palavras............................................. 451 Por que sequências são iteráveis: a função iter............................................ 453 Iteráveis versus iteradores............................................................................... 455 Sentence tomada #2: um iterador clássico....................................................... 459 Fazer de Sentence um iterador: péssima ideia.............................................460 Sentence tomada #3: uma função geradora..................................................... 461 Como funciona uma função geradora........................................................ 462 Sentence tomada #4: uma implementação lazy...............................................466 Sentence tomada #5: uma expressão geradora................................................ 467 Expressões geradoras: quando usá-las............................................................ 469 Outro exemplo: gerador de progressão aritmética........................................... 470 Progressão aritmética com itertools........................................................... 473 Funções geradoras na biblioteca-padrão.......................................................... 474 Nova sintaxe em Python 3.3: yield from.......................................................... 485 Funções de redução de iteráveis...................................................................... 486 Uma visão mais detalhada da função iter........................................................ 488 Estudo de caso: geradores em um utilitário para conversão de banco de dados.489 Geradores como corrotinas............................................................................ 491 Resumo do capítulo....................................................................................... 492 Leituras complementares............................................................................... 493 Capítulo 15 ■ Gerenciadores de contexto e blocos else....................................................... 499 Faça isso, então aquilo: blocos else além de if..................................................500 Gerenciadores de contexto e blocos with........................................................ 502 Utilitários de contextlib................................................................................. 507 Usando @contextmanager............................................................................. 508 Resumo do capítulo....................................................................................... 512 Leituras complementares............................................................................... 512 Capítulo 16 ■ Corrotinas................................................................................................... 515 Como as corrotinas evoluíram a partir de geradores........................................ 516 Comportamento básico de um gerador usado como corrotina......................... 517 Exemplo: corrotina para calcular uma média cumulativa................................ 520 Decoradores para preparação de corrotinas.................................................... 522 Término de corrotinas e tratamento de exceção.............................................. 524 Devolvendo um valor a partir de uma corrotina.............................................. 528 Usando yield from......................................................................................... 530 O significado de yield from............................................................................ 536 14 Python Fluente Caso de uso: corrotinas para uma simulação de eventos discretos................... 543 Sobre simulações de eventos discretos........................................................ 543 A simulação da frota de táxis..................................................................... 544 Resumo do capítulo....................................................................................... 552 Leituras complementares............................................................................... 554 Capítulo 17 ■ Concorrência com futures.............................................................................560 Exemplo: downloads da Web em três estilos................................................... 560 Um script para download sequencial......................................................... 563 Fazendo download com concurrent.futures............................................... 565 Onde estão os futures?.............................................................................. 566 E/S bloqueante e a GIL................................................................................... 570 Iniciando processos com concurrent.futures................................................... 571 Fazendo experimentos com Executor.map...................................................... 573 Downloads com exibição de progresso e tratamento de erros.......................... 576 Tratamento de erros nos exemplos da série flags2 ...................................... 581 Usando futures.as_completed................................................................... 584 Alternativas com threading e multiprocessing............................................ 587 Resumo do capítulo....................................................................................... 587 Leituras complementares............................................................................... 588 Capítulo 18 ■ Concorrência com asyncio............................................................................ 594 Thread versus corrotina: uma comparação..................................................... 596 asyncio.Future: não bloqueante por design................................................ 603 yield from com futures, tasks e corrotinas..................................................604 Fazendo download com asyncio e aiohttp....................................................... 605 Dando voltas em chamadas bloqueantes......................................................... 610 Melhorando o script para download com asyncio .......................................... 612 Usando asyncio.as_completed................................................................... 613 Usando um executor para evitar bloqueio do loop de eventos..................... 619 De callbacks a futures e corrotinas................................................................. 620 Fazendo várias requisições para cada download......................................... 623 Escrevendo servidores com asyncio ............................................................... 626 Um servidor TCP com asyncio .................................................................. 627 Um servidor web com aiohttp ................................................................... 632 Clientes mais inteligentes para melhorar a concorrência............................. 636 Resumo do capítulo....................................................................................... 637 Leituras complementares............................................................................... 638 Sumário 15 Parte VI ■ Metaprogramação............................................................................ 643 Capítulo 19 ■ Atributos dinâmicos e propriedades.............................................................644 Processando dados com atributos dinâmicos.................................................. 645 Explorando dados JSON ou similares com atributos dinâmicos.................. 647 O problema do nome de atributo inválido.................................................. 651 Criação flexível de objetos com __new__................................................... 652 Reestruturando o feed da OSCON com shelve........................................... 654 Recuperação de registros relacionados usando propriedades....................... 658 Usando uma propriedade para validação de atributo....................................... 665 LineItem tomada #1: classe para um item de um pedido............................ 665 LineItem tomada #2: uma propriedade com validação............................... 666 Uma visão apropriada das propriedades......................................................... 667 Propriedades encobrem atributos de instância............................................ 669 Documentação de propriedades................................................................. 672 Implementando uma fábrica de propriedades.................................................. 673 Tratando a remoção de atributos.................................................................... 676 Atributos e funções essenciais para tratamento de atributos............................ 677 Atributos especiais que afetam o tratamento de atributos........................... 677 Funções embutidas para tratamento de atributos....................................... 678 Métodos especiais para tratamento de atributos......................................... 679 Resumo do capítulo....................................................................................... 681 Leituras complementares............................................................................... 681 Capítulo 20 ■ Descritores de atributos...............................................................................687 Exemplo de descritor: validação de atributos.................................................. 687 LineItem tomada #3: um descritor simples................................................ 688 LineItem tomada #4: nomes automáticos para atributos de armazenagem.. 693 LineItem tomada #5: um novo tipo descritor............................................. 700 Descritores dominantes e não dominantes...................................................... 703 Descritor dominante................................................................................. 705 Descritor dominante sem __get__............................................................. 706 Descritor não dominante........................................................................... 707 Sobrescrevendo um descritor na classe....................................................... 709 Métodos são descritores................................................................................. 709 Dicas para uso de descritores......................................................................... 712 Docstring de descritores e controle de remoção............................................... 714 Resumo do capítulo....................................................................................... 715 Leituras complementares............................................................................... 716 16 Python Fluente Capítulo 21 ■ Metaprogramação com classes..................................................................... 718 Uma fábrica de classes................................................................................... 719 Um decorador de classe para personalizar descritores..................................... 722 O que acontece quando: tempo de importação versus tempo de execução........ 725 Exercícios dos instantes de avaliação......................................................... 726 Básico sobre metaclasses................................................................................ 730 Exercício do instante de avaliação de metaclasses....................................... 732 Uma metaclasse para personalizar descritores................................................. 736 Método especial __prepare__ de metaclasse................................................... 738 Classes como objetos..................................................................................... 741 Resumo do capítulo....................................................................................... 742 Leituras complementares............................................................................... 743 Posfácio........................................................................................................................... 747 Leituras complementares............................................................................... 749 Apêndice A ■ Scripts auxiliares.......................................................................................... 751 Capítulo 3: teste de desempenho do operador in............................................. 751 Capítulo 3: comparar padrões de bits de hashes.............................................. 754 Capítulo 9: uso de RAM com e sem __slots__................................................ 754 Capítulo 14: script isis2json.py para conversão de banco de dados................... 755 Capítulo 16: simulação de eventos discretos para a frota de táxis..................... 761 Capítulo 17: Exemplos com criptografia......................................................... 766 Capítulo 17: exemplos de cliente HTTP para flags2......................................... 769 Capítulo 19: Scripts e testes para agenda da OSCON...................................... 775 Jargão de Python............................................................................................................. 781 Sobre o autor................................................................................................................... 798 Colofão............................................................................................................................ 799
