Python Cookbook - Novatec Editora

Python Cookbook
David Beazley
Brian K. Jones
Novatec
Authorized Portuguese translation of the English edition of titled Python Cookbook, 3rd Edition, ISBN 978-1-44934037-7 © 2013, David Beazley and Brian K. Jones. This translation is published and sold by permission of O'Reilly
Media, Inc., the owner of all rights to publish and sell the same.
Tradução em português autorizada da edição em inglês do título Python Cookbook, 3rd Edition, ISBN 978-1-44934037-7 © 2013, David Beazley e Brian K. Jones. Esta tradução é publicada e vendida com a permissão da O'Reilly
Media, Inc., detentora de todos os direitos para publicação e venda desta obra.
© Novatec Editora Ltda. 2013.
Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998.
É proibida a reprodução desta obra, mesmo parcial, por qualquer processo, sem prévia autorização, por escrito,
do autor e da Editora.
Editor: Rubens Prates
Tradução: Lúcia A. Kinoshita
Revisão técnica: Aurelio Jargas
Revisão gramatical: Marta Almeida de Sá
Editoração eletrônica: Carolina Kuwabata
ISBN: 978-85-7522-332-1
Histórico de impressões:
Novembro/2013
Primeira edição
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110
02460-000 – São Paulo, SP – Brasil
Tel.: +55 11 2959-6529
Fax: +55 11 2950-8869
Email: [email protected]
Site: www.novatec.com.br
Twitter: twitter.com/novateceditora
Facebook: facebook.com/novatec
LinkedIn: linkedin.com/in/novatec
Sumário
Prefácio.............................................................................................................................................13
Capítulo 1 ■ Estruturas de dados e algoritmos.....................................................................................18
1.1. Desempacotar uma sequência em variáveis separadas...............................................18
1.2. Desempacotar elementos de iteráveis de tamanho arbitrário.................................... 20
1.3. Manter os últimos N itens...................................................................................... 23
1.4. Encontrar os N itens maiores ou menores............................................................... 25
1.5. Implementar uma fila de prioridades...................................................................... 26
1.6. Mapear chaves a múltiplos valores em um dicionário............................................... 29
1.7. Manter dicionários em ordem................................................................................. 30
1.8. Fazer cálculos com dicionários............................................................................... 32
1.9. Encontrar itens comuns em dois dicionários........................................................... 34
1.10. Remover itens duplicados de uma sequência, preservando a ordem........................ 35
1.11. Dar nome a uma fatia (slice).................................................................................. 37
1.12 Determinar os itens que ocorrem mais frequentemente em uma sequência.............. 38
1.13. Ordenar uma lista de dicionários por meio de uma chave comum.......................... 40
1.14. Ordenar objetos sem suporte nativo para comparação............................................ 42
1.15. Agrupar registros de acordo com um campo.......................................................... 43
1.16. Filtrar elementos de uma sequência....................................................................... 45
1.17. Extrair um subconjunto de um dicionário............................................................. 48
1.18. Mapear nomes a elementos de sequência............................................................... 49
1.19. Transformar e reduzir dados ao mesmo tempo........................................................51
1.20. Combinar múltiplos mapeamentos em um único mapeamento.............................. 53
Capítulo 2 ■ Strings e textos...............................................................................................................56
2.1. Separar strings de acordo com vários delimitadores................................................. 56
2.2. Fazer correspondência de texto no início ou no fim de uma string........................... 57
2.3. Fazer correspondência de strings utilizando padrões de curinga do shell.................. 59
2.4. Fazer correspondência e pesquisa de padrões de texto..............................................61
2.5. Pesquisar e substituir textos................................................................................... 65
2.6. Pesquisar e substituir textos sem diferenciar letras minúsculas de maiúsculas.......... 66
2.7. Especificar uma expressão regular para obter a correspondência mais curta possível. 67
2.8. Escrever uma expressão regular para padrões multilinha......................................... 68
5
6
Python Cookbook
2.9. Normalizar texto Unicode para gerar uma representação padrão.............................. 70
2.10. Trabalhar com caracteres Unicode em expressões regulares..................................... 72
2.11. Remover caracteres indesejados de strings.............................................................. 73
2.12. Sanitizar e limpar textos........................................................................................ 75
2.13. Alinhar strings de texto......................................................................................... 77
2.14. Combinar e concatenar strings.............................................................................. 79
2.15. Interpolar variáveis em strings............................................................................... 82
2.16. Reformatar texto para gerar um número fixo de colunas........................................ 85
2.17. Manipular entidades HTML e XML em textos....................................................... 86
2.18. Extrair tokens de textos........................................................................................ 88
2.19. Escrever um parser descendente recursivo simples...................................................91
2.20. Executar operações de texto em strings de bytes...................................................100
Capítulo 3 ■ Números, datas e horas.................................................................................................104
3.1. Arredondar valores numéricos...............................................................................104
3.2. Realizar cálculos decimais precisos....................................................................... 106
3.3. Formatar números para saída................................................................................108
3.4. Trabalhar com inteiros binários, octais e hexadecimais........................................... 110
3.5. Empacotar e desempacotar inteiros grandes a partir de bytes.................................. 112
3.6. Executar operações matemáticas com números complexos..................................... 114
3.7. Trabalhar com infinito e NaNs............................................................................... 116
3.8. Fazer cálculos com frações.................................................................................... 118
3.9. Fazer cálculos com arrays numéricos grandes......................................................... 119
3.10. Executar cálculos algébricos matriciais e lineares..................................................123
3.11. Selecionar itens aleatoriamente.............................................................................125
3.12. Converter dias para segundos e outras conversões básicas relacionadas com tempo.127
3.13. Determinar o dia da última sexta-feira..................................................................129
3.14. Encontrar o intervalo de datas do mês corrente..................................................... 131
3.15. Converter strings em datetimes............................................................................133
3.16. Manipular datas que envolvem fuso horário.........................................................134
Capítulo 4 ■ Iteradores e geradores..................................................................................................137
4.1. Consumir manualmente um iterador..................................................................... 137
4.2. Delegar iterações..................................................................................................138
4.3. Criar novos padrões de iteração com geradores......................................................139
4.4. Implementar o protocolo do iterador..................................................................... 141
4.5. Iterar ao contrário.................................................................................................144
4.6. Definir funções geradoras com estado extra........................................................... 145
4.7. Obter uma fatia de um iterador.............................................................................146
4.8. Descartar a primeira parte de um iterável..............................................................148
4.9. Iterar por todas as combinações ou permutações possíveis......................................150
4.10. Iterar pelos pares índice-valor de uma sequência...................................................152
Sumário
7
4.11. Iterar por várias sequências simultaneamente.......................................................154
4.12. Iterar pelos itens em contêineres separados...........................................................156
4.13. Criar pipelines para processamento de dados.......................................................158
4.14. Linearizar uma sequência aninhada..................................................................... 161
4.15. Iterar de modo ordenado por iteráveis ordenados e combinados............................162
4.16. Substituir laços while infinitos por um iterador....................................................164
Capítulo 5 ■ Arquivos e I/O...............................................................................................................166
5.1. Ler e escrever dados de texto................................................................................. 166
5.2. Enviar dados de saída para um arquivo.................................................................169
5.3. Apresentar dados com um separador ou com um final de linha diferente.................169
5.4. Ler e escrever dados binários................................................................................. 171
5.5 Escrever em um arquivo que ainda não existe.........................................................173
5.6 Realizar operações de I/O em uma string................................................................ 174
5.7 Ler e escrever em arquivos de dados compactados.................................................. 175
5.8 Iterar por registros de tamanho fixo.......................................................................177
5.9 Ler dados binários em um buffer mutável..............................................................177
5.10 Mapear arquivos binários em memória.................................................................179
5.11 Manipular nomes de caminho...............................................................................182
5.12 Verificar se um arquivo existe...............................................................................183
5.13 Obter uma listagem de diretório...........................................................................185
5.14 Ignorar a codificação de nomes de arquivo............................................................186
5.15 Apresentar nomes indevidos de arquivo................................................................188
5.16 Adicionar ou alterar a codificação de um arquivo aberto........................................190
5.17 Escrever bytes em um arquivo texto......................................................................192
5.18 Encapsular um descritor de arquivo como um objeto arquivo................................193
5.19 Criar arquivos e diretórios temporários.................................................................195
5.20 Comunicar-se usando portas seriais.....................................................................198
5.21 Serializar objetos Python......................................................................................199
Capítulo 6 ■ Codificação e processamento de dados...........................................................................203
6.1. Ler e escrever dados CSV...................................................................................... 203
6.2. Ler e escrever dados JSON................................................................................... 207
6.3 Fazer parse de dados XML simples......................................................................... 212
6.4 Efetuar parse de arquivos XML enormes de modo incremental................................215
6.5 Transformar um dicionário em XML...................................................................... 218
6.6 Fazer parse, modificar e reescrever XML................................................................. 221
6.7 Fazer parse de documentos XML com namespaces..................................................223
6.8 Interagir com um banco de dados relacional..........................................................225
6.9 Decodificar e codificar dígitos hexadecimais.......................................................... 227
6.10 Decodificar e codificar Base64............................................................................. 229
8
Python Cookbook
6.11 Ler e escrever arrays de estruturas binárias........................................................... 230
6.12 Ler estruturas binárias aninhadas e de tamanhos variáveis....................................234
6.13 Sintetizar dados e realizar cálculos estatísticos.......................................................245
Capítulo 7 ■ Funções........................................................................................................................249
7.1 Criar funções que aceitem qualquer quantidade de argumentos...............................249
7.2 Criar funções que aceitem somente argumentos nomeados.................................... 250
7.3 Associar metadados informativos aos argumentos de uma função...........................252
7.4 Retornar múltiplos valores de uma função..............................................................253
7.5 Definir funções com argumentos default............................................................... 254
7.6 Definir funções anônimas ou inline.......................................................................257
7.7 Capturar variáveis em funções anônimas............................................................... 258
7.8 Fazer um callable de n argumentos funcionar como um callable com menos argumentos.260
7.9 Substituir classes com um único método por funções............................................ 263
7.10 Levar um estado extra às funções de callback....................................................... 264
7.11 Definir funções de callback inline........................................................................ 268
7.12 Acessar variáveis definidas em uma closure........................................................... 271
Capítulo 8 ■ Classes e objetos...........................................................................................................275
8.1 Alterar a representação em string de instâncias.......................................................275
8.2 Personalizar a formatação de strings..................................................................... 277
8.3 Fazer os objetos suportarem o protocolo de gerenciamento de contexto...................278
8.4 Economizar memória ao criar uma grande quantidade de instâncias.......................281
8.5 Encapsular nomes em uma classe......................................................................... 282
8.6 Criar atributos gerenciados................................................................................... 284
8.7 Chamar um método da classe pai......................................................................... 288
8.8 Estender uma propriedade em uma subclasse........................................................ 293
8.9 Criar um novo tipo de atributo de classe ou de instância....................................... 297
8.10 Usar propriedades processadas em modo lazy....................................................... 301
8.11 Simplificar a inicialização de estruturas de dados................................................. 304
8.12 Definir uma interface ou uma classe base abstrata................................................ 308
8.13 Implementar um modelo de dados ou um sistema de tipos.....................................311
8.14 Implementar contêineres personalizados............................................................... 318
8.15 Delegar acesso a atributos....................................................................................322
8.16 Definir mais de um construtor em uma classe.......................................................326
8.17 Criar uma instância sem chamar init....................................................................328
8.18 Estender classes com mixins.................................................................................330
8.19 Implementar objetos stateful ou máquinas de estado............................................335
8.20 Chamar um método em um objeto especificando o nome como uma string.......... 341
8.21 Implementar o padrão Visitor.............................................................................. 343
8.22 Implementar o padrão Visitor sem recursão..........................................................347
8.23 Gerenciar memória em estruturas de dados cíclicas..............................................354
Sumário
9
8.24 Fazer as classes suportarem operações de comparação..........................................358
8.25 Cria instâncias em cache..................................................................................... 360
Capítulo 9 ■ Metaprogramação........................................................................................................365
9.1 Colocar um wrapper em torno de uma função....................................................... 365
9.2 Preservar metadados de funções ao criar decoradores.............................................367
9.3 Desfazer o encapsulamento de um decorador........................................................ 369
9.4 Definir um decorador que aceite argumentos.......................................................... 371
9.5 Definir um decorador com atributos ajustáveis pelo usuário...................................372
9.6 Definir um decorador que aceite um argumento opcional.......................................376
9.7 Impor uma verificação de tipos em uma função por meio de um decorador.............378
9.8 Definir decoradores como parte de uma classe....................................................... 382
9.9 Definir decoradores como classes.......................................................................... 384
9.10 Aplicar decoradores a métodos de classe e estáticos.............................................. 387
9.11 Criar decoradores que adicionam argumentos a funções encapsuladas................... 389
9.12 Usar decoradores para modificar definições de classe.............................................392
9.13 Utilizar uma metaclasse para controlar a criação de instâncias...............................394
9.14 Capturar a ordem de definição de atributos de classe.............................................397
9.15 Definir uma metaclasse que aceite argumentos opcionais..................................... 400
9.16 Impor uma assinatura de argumentos em *args e **kwargs.................................... 402
9.17 Impor convenções de codificação em classes......................................................... 406
9.18 Definir classes por meio do próprio programa...................................................... 409
9.19 Inicializar membros de classe no momento da definição........................................ 413
9.20 Implementar múltiplos despachos com anotações de função.................................415
9.21 Evitar métodos repetitivos de propriedades........................................................... 421
9.22 Definir gerenciadores de contexto da maneira fácil................................................423
9.23 Executar código com efeitos colaterais locais.........................................................425
9.24 Fazer parse e análise de código-fonte em Python.................................................. 428
9.25 Fazer o disassembly de bytecodes de Python.........................................................433
Capítulo 10 ■ Módulos e pacotes.......................................................................................................437
10.1 Criar um pacote hierárquico de módulos..............................................................437
10.2 Controlar a importação de tudo.......................................................................... 438
10.3 Importar submódulos de pacote usando nomes relativos.......................................439
10.4 Separar um módulo em vários arquivos................................................................441
10.5 Fazer diretórios separados de código serem importados com um namespace comum.. 444
10.6 Recarregar módulos............................................................................................ 446
10.7 Tornar um diretório ou um arquivo zip executável como um script principal......... 448
10.8 Ler arquivos de dados que estão em um pacote.................................................... 449
10.9 Adicionar diretórios a sys.path............................................................................ 450
10.10 Importar módulos usando um nome especificado em uma string.........................452
10.11 Carregar módulos de um computador remoto usando hooks na importação.........453
10
Python Cookbook
10.12 Inserir patches em módulos na importação.........................................................470
10.13 Instalar pacotes somente para você mesmo..........................................................473
10.14 Criar um novo ambiente Python......................................................................... 474
10.15 Distribuir pacotes...............................................................................................476
Capítulo 11 ■ Redes e programação web...........................................................................................478
11.1 Interagir com serviços HTTP como um cliente......................................................478
11.2 Criar um servidor TCP........................................................................................ 482
11.3 Criar um servidor UDP....................................................................................... 486
11.4 Gerar um intervalo de endereços IP a partir de um endereço CIDR....................... 488
11.5 Criar uma interface simples baseada em REST..................................................... 490
11.6 Implementar uma chamada de procedimento remoto simples usando XML-RPC.. 495
11.7 Efetuar comunicação somente entre interpretadores............................................. 498
11.8 Implementar chamadas de procedimentos remotos.............................................. 500
11.9 Autenticar clientes facilmente............................................................................... 504
11.10 Adicionar SSL a serviços de rede......................................................................... 506
11.11 Passar um descritor de arquivo socket entre processos........................................... 513
11.12 Entender como funciona o I/O orientado a eventos.............................................. 518
11.13 Enviar e receber arrays extensos...........................................................................524
Capítulo 12 ■ Concorrência...............................................................................................................527
12.1 Iniciar e terminar threads......................................................................................527
12.2 Determinar se uma thread foi iniciada..................................................................530
12.3 Efetuar comunicação entre threads.......................................................................534
12.4 Travar seções críticas........................................................................................... 540
12.5 Utilizar lock evitando deadlocks.......................................................................... 543
12.6 Armazenar estados específicos de threads.............................................................547
12.7 Criar um pool de threads.................................................................................... 549
12.8 Realizar programação paralela simples.................................................................553
12.9 Lidar com o GIL (e como parar de se preocupar com ele)......................................557
12.10 Definir uma tarefa do tipo ator...........................................................................561
12.11 Implementar troca de mensagens usando o padrão publish/subscribe.................. 565
12.12 Usar geradores como alternativa às threads......................................................... 569
12.13 Fazer polling em várias filas de threads............................................................... 577
12.14 Disparar um processo daemon no Unix.............................................................. 580
Capítulo 13 ■ Criação de scripts utilitários e administração de sistemas.............................................585
13.1 Aceitar entrada em scripts por meio de redirecionamento, pipes ou arquivos de entrada.. 585
13.2 Terminar um programa com uma mensagem de erro............................................ 586
13.3 Efetuar parse de opções da linha de comando...................................................... 587
13.4 Solicitar uma senha em tempo de execução.......................................................... 590
Sumário
11
13.5 Obter o tamanho do terminal............................................................................... 591
13.6 Executar um comando externo e obter sua saída...................................................592
13.7 Copiar ou mover arquivos e diretórios..................................................................594
13.8 Criar e descompactar arquivos............................................................................ 596
13.9 Localizar arquivos pelo nome...............................................................................597
13.10 Ler arquivos de configuração............................................................................. 598
13.11 Adicionar logging em scripts simples.................................................................. 602
13.12 Adicionar logging em bibliotecas........................................................................ 605
13.13 Criar um cronômetro......................................................................................... 606
13.14 Estabelecer limites quanto ao uso de memória e de CPU..................................... 609
13.15 Iniciar um navegador web...................................................................................610
Capítulo 14 ■ Testes, depuração e exceções.......................................................................................612
14.1 Testar saída enviada ao stdout............................................................................... 612
14.2 Modificar objetos em testes de unidade................................................................ 613
14.3 Testar condições excepcionais em testes de unidade............................................... 617
14.4 Fazer log do resultado do teste em um arquivo...................................................... 619
14.5 Ignorar ou antecipar falhas em testes................................................................... 620
14.6 Lidar com várias exceções....................................................................................622
14.7 Capturar todas as exceções...................................................................................624
14.8 Criar exceções personalizadas..............................................................................625
14.9 Gerar uma exceção em resposta a outra exceção....................................................627
14.10 Gerar novamente a última exceção..................................................................... 630
14.11 Gerar mensagens de aviso (warnings).................................................................. 631
14.12 Depurar falhas básicas de programas...................................................................633
14.13 Gerar um perfil e medir tempos em seu programa...............................................635
14.14 Fazer seus programas executarem mais rapidamente........................................... 638
Capítulo 15 ■ Extensões C.................................................................................................................644
15.1 Acessar código C usando ctypes........................................................................... 646
15.2 Criar um módulo simples de extensão C..............................................................652
15.3 Criar uma função de extensão que opere em arrays...............................................657
15.4 Administrar ponteiros opacos em módulos de extensão C.................................... 660
15.5 Definir e exportar APIs C a partir de módulos de extensão................................... 662
15.6 Chamar o Python a partir do C........................................................................... 667
15.7 Liberar o GIL em extensões C...............................................................................673
15.8 Combinar threads de C e de Python..................................................................... 674
15.9 Encapsular código C com Swig.............................................................................675
15.10 Encapsular código C existente com Cython.........................................................681
15.11 Usar Cython para implementar operações de alto desempenho em arrays............ 688
15.12 Transformar um ponteiro de função em um callable............................................693
15.13 Passar strings terminadas com NULL para bibliotecas C..................................... 694
12
Python Cookbook
15.14 Passar strings Unicode para bibliotecas C........................................................... 699
15.15 Converter strings C para Python........................................................................ 704
15.16 Trabalhar com strings C com codificação duvidosa............................................. 705
15.17 Passar nomes de arquivo a extensões C............................................................... 708
15.18 Passar arquivos abertos para extensões C.............................................................710
15.19 Ler objetos do tipo arquivo a partir do C..............................................................711
15.20 Consumir um iterável a partir do C.................................................................... 714
15.21 Diagnosticar falha de segmentação......................................................................715
Apêndice A ■ Leituras complementares............................................................................................717
Recursos online.......................................................................................................... 717
Livros para aprender sobre Python.............................................................................. 718
Livros mais avançados................................................................................................ 718