Sumario 9788575224625

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Posfácio........................................................................................................................... 747
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

Sumario 9788575224625

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Sumario 9788575224625

Uploaded by

Copyright:

Available Formats

Python Fluente

Parte II ■ Estruturas de dados.............................................................................. 43

Capítulo 3 ■ Dicionários e conjuntos....................................................................................93

Capítulo 4 ■ Texto versus bytes......................................................................................... 129

Parte III ■ Funções como objetos........................................................................174

Capítulo 6 ■ Padrões de projeto com funções de primeira classe......................................... 205

Capítulo 7 ■ Decoradores de função e closures................................................................... 222

Parte IV ■ Práticas de orientação a objetos........................................................ 257

Parâmetros de função como referências.......................................................... 268

Capítulo 9 ■ Um objeto pythônico.....................................................................................288

Capítulo 10 ■ Hackeando e fatiando sequências................................................................ 318

Capítulo 11 ■ Interfaces: de protocolos a ABCs................................................................... 352

Criando subclasses de uma ABC.................................................................... 365

Capítulo 12 ■ Herança: para o bem ou para o mal.............................................................. 395

Capítulo 13 ■ Sobrecarga de operadores: o jeito certo........................................................ 419

Parte V ■ Controle de fluxo................................................................................ 449

Capítulo 15 ■ Gerenciadores de contexto e blocos else....................................................... 499

Capítulo 16 ■ Corrotinas................................................................................................... 515

Caso de uso: corrotinas para uma simulação de eventos discretos................... 543

Capítulo 17 ■ Concorrência com futures.............................................................................560

Capítulo 18 ■ Concorrência com asyncio............................................................................ 594

Parte VI ■ Metaprogramação............................................................................ 643

Capítulo 20 ■ Descritores de atributos...............................................................................687

Capítulo 21 ■ Metaprogramação com classes..................................................................... 718

Apêndice A ■ Scripts auxiliares.......................................................................................... 751

Jargão de Python............................................................................................................. 781

Sobre o autor................................................................................................................... 798

You might also like