Python Fluente

803 Pages·2015·66.272 MB·Portuguese Brazilian

by  Luciano Ramalho

O'REILLY
PROGRAMACÁO CLAftA. CONCISA £ EFlCl£NTE
novatec
Luciano Ra malho
FOTOS ORIGINAIS DESSE EBOOK
https://lbry.tv/python_fluente_2015_impar
https://lbry.tv/python_fluente_2015_par
QUER SER MAIS LIVRE?
Gigantes portais mundiais de compartilhamento de ebooks e
artigos científicos, com mais de 2 milhões de documentos.
Acesse:
http://libgen.is/
https://b-ok.lat/
Grupo de Telegram com mais de 70 mil ebooks em português.
Acesse:
https://t.me/REVISTAVIRTUALBR
Plataforma descentralizada de reprodução e hospedagem de
arquivos garantida por blockchain.
• Prática como youtube
• Descentralizada e à prova de censura como torrent
• Facilitadora de transações financeiras como bitcoin
Acesse:
http://lbry.tv/
Livro: Contra a Propriedade Intelectual
Acesse:
https://www.mises.org.br/Ebook.aspx?id=29
Python Fluente
Python Fluente
Luciano Ramalho
Novatec
Para Marta, com todo o meu amor.
Authorized Portuguese translation of the English edition of tilled Fluent Python, ISBN 9781491946008 © 2015
Luciano Ramalha This translation is published and sold by permission of O'Reilly Medifl. Inc., which owns or
controls all rights to publish and sell the same.
Tradução em português autoritada da edição em inglês da obra Fluent Python, ISBN 9781491946008 © 2015 Lu­
ciano Ramalha Esta tradução é publicada e vendida com a permissão da O’Reilly Media. Inc., que detém iodos
os direitos para publicação e venda desta obra.
© Novatec Editora Ltda. 2015.
Todos os direitos reservados e protegidos pela Lei 9610 de I9/02/I99& p proibida o rcproduçflo desta obra, mesmo
parcial, por qualquer processa sem prévia autorixaçâo, por escrita do autor e da Editora.
Editor Rubens Prates
Assistente editorial: Priscila A. \bshimatsu
Tradução: Lúcia A. Kinoshita
Revisão técnica da tradução: Luciano Ramalho
Revisão gramatical: Marta Almeida de Sã
Editoração eletrônica: Carolina Kuwabatn
ISBN; 978-85-7322-462-5
Histórico de impressões:
Junho 2020 Quinta reimpressão
Outubro/2015 Primeira edição
Novatec Editora Ltda.
Rua Luls Antônio dos Santos 110
02460-000 - São Paula SP - Brasil
Tel: *55 11 2959-6529
Email novatec(a*novatcacom.br
Site: www novateacom.br
Twitter: twittcr.com/novateceditora
Facebook iacebook.com/novatec
Linkcdln: hnkedin.com/in/novatec
GRA20200603
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..............................................................................................................$
Tuplas como listas imutáveis.........................................................................................58
7
Python Fluente
8
Fatiamento..............................................................................................................................
Por que as fatias e os intervalos excluem o último item........................................59
Objetos slice.......................................................................................................................
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
diet 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 diet....................................................... 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 diet e set..........
116
Um experimento para testar o desempenho
116
Tabelas hash em dicionários.
118
Consequências práticas de como os'dicker tos'funcionam
121
125
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 dasse.................................................................. 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