Python Tutorial

Release 3.12.5

Guido van Rossum and the Python development team

setembro 02, 2024

Python Software Foundation

Email: docs@[Link]
 Sumário

1 Abrindo seu apetite 3

2 Utilizando o interpretador Python 5

2.1 Chamando o interpretador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Passagem de argumentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.2 Modo interativo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 O interpretador e seu ambiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.1 Ediçã o de có digo-fonte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3 Uma introdução informal ao Python 9

3.1 Usando Python como uma calculadora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.1.1 Nú meros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.1.2 Texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.3 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Primeiros passos para a programaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 Mais ferramentas de controle de fluxo 19

4.1 Comandos if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2 Comandos for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.3 A funçã o range() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.4 Comandos break e continue, e clá usula else, nos laços de repetiçã o . . . . . . . . . . . . . 21
4.5 Comandos pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.6 Instruçõ es match . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.7 Definindo funçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.8 Mais sobre definiçã o de funçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.8.1 Argumentos com valor padrã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.8.2 Argumentos nomeados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.8.3 Parâ metros especiais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.8.4 Listas de argumentos arbitrá rias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.8.5 Desempacotando listas de argumentos . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.8.6 Expressõ es lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.8.7 Strings de documentaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.8.8 Anotaçõ es de funçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.9 Intermezzo: estilo de codificaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

5 Estruturas de dados 37
5.1 Mais sobre listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.1.1 Usando listas como pilhas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.1.2 Usando listas como filas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.1.3 List Comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.1.4 Compreensõ es de lista aninhadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

i
 5.2 A instruçã o del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.3 Tuplas e Sequê ncias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.4 Conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.5 Dicioná rios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.6 Té cnicas de iteraçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.7 Mais sobre condiçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.8 Comparando sequê ncias e outros tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

6 Módulos 49
6.1 Mais sobre mó dulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.1.1 Executando mó dulos como scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.1.2 O caminho de busca dos mó dulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.1.3 Arquivos Python “compilados” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.2 Mó dulos padrõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.3 A funçã o dir() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.4 Pacotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.4.1 Importando * de um pacote . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.4.2 Referê ncias em um mesmo pacote . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.4.3 Pacotes em mú ltiplos diretó rios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

7 Entrada e Saída 59
7.1 Refinando a formataçã o de saída . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.1.1 Strings literais formatadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.1.2 O mé todo format() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7.1.3 Formataçã o manual de string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
7.1.4 Formataçã o de strings à moda antiga . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.2 Leitura e escrita de arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.2.1 Mé todos de objetos arquivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.2.2 Gravando dados estruturados com json . . . . . . . . . . . . . . . . . . . . . . . . . . 65

8 Erros e exceções 67
8.1 Erros de sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
8.2 Exceçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
8.3 Tratamento de exceçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
8.4 Levantando exceçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
8.5 Encadeamento de exceçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
8.6 Exceçõ es definidas pelo usuá rio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
8.7 Definindo açõ es de limpeza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
8.8 Açõ es de limpeza predefinidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
8.9 Criando e tratando vá rias exceçõ es nã o relacionadas . . . . . . . . . . . . . . . . . . . . . . . . . 74
8.10 Enriquecendo exceçõ es com notas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

9 Classes 77
9.1 Uma palavra sobre nomes e objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
9.2 Escopos e espaços de nomes do Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
9.2.1 Exemplo de escopos e espaço de nomes . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
9.3 Uma primeira olhada nas classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
9.3.1 Sintaxe da definiçã o de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
9.3.2 Objetos de Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
9.3.3 Objetos instâ ncia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9.3.4 Objetos mé todo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
9.3.5 Variá veis de classe e instâ ncia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
9.4 Observaçõ es aleató rias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
9.5 Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
9.5.1 Herança mú ltipla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
9.6 Variá veis privadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
9.7 Curiosidades e conclusõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
9.8 Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
9.9 Geradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

ii
 9.10 Expressõ es geradoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

10 Um breve passeio pela biblioteca padrão 91

10.1 Interface com o sistema operacional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
10.2 Caracteres curinga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
10.3 Argumentos de linha de comando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
10.4 Redirecionamento de erros e encerramento do programa . . . . . . . . . . . . . . . . . . . . . . 92
10.5 Reconhecimento de padrõ es em strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
10.6 Matemá tica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
10.7 Acesso à internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.8 Data e hora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.9 Compressã o de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.10 Mediçã o de desempenho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
10.11 Controle de qualidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
10.12 Baterias incluídas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

11 Um breve passeio pela biblioteca padrão — parte II 97

11.1 Formatando a saída . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
11.2 Usando templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
11.3 Trabalhando com formatos biná rios de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
11.4 Multi-threading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
11.5 Gerando logs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
11.6 Referê ncias fracas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
11.7 Ferramentas para trabalhar com listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
11.8 Decimal Floating-Point Arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

12 Ambientes virtuais e pacotes 105

12.1 Introduçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
12.2 Criando ambientes virtuais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
12.3 Gerenciando pacotes com o pip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

13 E agora? 109

14 Edição de entrada interativa e substituição de histórico 111

14.1 Tab Completion e Histó rico de Ediçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
14.2 Alternativas ao interpretador interativo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

15 Floating-Point Arithmetic: Issues and Limitations 113

15.1 Erro de representaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

16 Anexo 119
16.1 Modo interativo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
16.1.1 Tratamento de erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
16.1.2 Scripts Python executá veis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
16.1.3 Arquivo de inicializaçã o do modo interativo . . . . . . . . . . . . . . . . . . . . . . . . 120
16.1.4 Mó dulos de customizaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

A Glossário 121

B Sobre esses documentos 137

B.1 Contribuidores da Documentaçã o Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

C História e Licença 139

C.1 Histó ria do software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
C.2 Termos e condiçõ es para acessar ou usar Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
C.2.1 ACORDO DE LICENCIAMENTO DA PSF PARA PYTHON 3.12.5 . . . . . . . . . . 140
C.2.2 ACORDO DE LICENCIAMENTO DA [Link] PARA PYTHON 2.0 . . . . . . 141
C.2.3 CONTRATO DE LICENÇA DA CNRI PARA O PYTHON 1.6.1 . . . . . . . . . . . . 142
C.2.4 ACORDO DE LICENÇA DA CWI PARA PYTHON 0.9.0 A 1.2 . . . . . . . . . . . . . 143

iii
 C.2.5 LICENÇA BSD DE ZERO CLÁUSULA PARA CÓDIGO NA DOCUMENTAÇÃO DO
PYTHON 3.12.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
C.3 Licenças e Reconhecimentos para Software Incorporado . . . . . . . . . . . . . . . . . . . . . . 144
C.3.1 Mersenne Twister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
C.3.2 Soquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
C.3.3 Serviços de soquete assíncrono . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
C.3.4 Gerenciamento de cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
C.3.5 Rastreamento de execuçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
C.3.6 Funçõ es UUencode e UUdecode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
C.3.7 Chamadas de procedimento remoto XML . . . . . . . . . . . . . . . . . . . . . . . . . 147
C.3.8 test_epoll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
C.3.9 kqueue de seleçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
C.3.10 SipHash24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
C.3.11 strtod e dtoa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
C.3.12 OpenSSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
C.3.13 expat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
C.3.14 libffi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
C.3.15 zlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
C.3.16 cfuhash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
C.3.17 libmpdec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
C.3.18 Conjunto de testes C14N do W3C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
C.3.19 Audioop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
C.3.20 asyncio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

D Direitos autorais 159

Índice 161

iv
 Python Tutorial, Release 3.12.5

Python é uma linguagem fá cil de aprender e poderosa. Ela tem estruturas de dados de alto nível eficientes e uma
abordagem simples mas efetiva de programaçã o orientada a objetos. A elegâ ncia de sintaxe e a tipagem dinâ mica
de Python aliadas com sua natureza interpretativa, o fazem a linguagem ideal para programas e desenvolvimento de
aplicaçõ es rá pidas em diversas á reas e na maioria das plataformas.
O interpretador Python e a extensiva biblioteca padrã o estã o disponíveis gratuitamente em có digo ou na forma biná ria
para todas as maiores plataformas no endereço eletrô nico do Python, [Link] e pode ser livremente
distribuído. O mesmo endereço conté m distribuiçõ es de diversos mó dulos, programas e ferramentas gratuitos pro-
duzidos por terceiros e documentaçã o adicional.
O interpretador Python pode ser facilmente estendido com novas funçõ es e tipos de dados implementados em C ou
C++ (ou outras linguagens chamadas a partir de C). Python també m é adequada como uma linguagem de extensã o
para aplicaçõ es personalizá veis.
Este tutorial introduz informalmente o leitor aos conceitos bá sicos e aos recursos da linguagem e do sistema Python. É
mais fá cil se você possuir um interpretador Python para uma experiê ncia prá tica, mas os exemplos sã o autossuficientes
e, portanto, o tutorial pode apenas ser lido off-line també m.
Para uma descriçã o detalhada dos mó dulos e objetos padrõ es, veja library-index. Em reference-index você encontra
uma definiçã o mais formal da linguagem. Para escrever extensõ es em C ou C++ leia extending-index e c-api-index.
Existe també m uma sé rie de livros que cobrem Python em profundidade.
Este tutorial nã o espera ser abrangente e cobrir todos os recursos ou mesmo os recursos mais usados. Ele busca
introduzir diversos dos recursos mais notá veis do Python e lhe dará uma boa ideia do sabor e estilo da linguagem.
Depois de lê -lo, você terá condiçõ es de ler e escrever programas e mó dulos Python e estará pronto para aprender
mais sobre os diversos mó dulos descritos em library-index.
O Glossário també m vale a pena ser estudado.

Sumário 1
Python Tutorial, Release 3.12.5

2 Sumário
 CAPÍTULO 1

Abrindo seu apetite

Se você trabalha muito com computadores, acabará encontrando alguma tarefa que gostaria de automatizar. Por
exemplo, você pode querer fazer busca-e-troca em um grande nú mero de arquivos de texto, ou renomear e reorganizar
um monte de arquivos de fotos de uma maneira complicada. Talvez você gostaria de escrever um pequeno banco de
dados personalizado, ou um aplicativo GUI especializado, ou um jogo simples.
Se você é um desenvolvedor de software profissional, pode ter que trabalhar com vá rias bibliotecas C/C++/Java, mas
o tradicional ciclo escrever/compilar/testar/recompilar é muito lento. Talvez você esteja escrevendo um conjunto de
testes para uma biblioteca e está achando tedioso codificar os testes. Ou talvez você tenha escrito um programa que
poderia utilizar uma linguagem de extensã o, e você nã o quer conceber e implementar toda uma nova linguagem para
sua aplicaçã o.
Python é a linguagem para você .
Você pode escrever um script shell do Unix ou arquivos batch do Windows para algumas dessas tarefas, mas os
scripts shell sã o melhores para mover arquivos e alterar dados de texto, nã o sã o adequados para aplicativos GUI
ou jogos. Você pode escrever um programa C/C++/Java, mas pode levar muito tempo de desenvolvimento para
obter até mesmo um primeiro rascunho de programa. O Python é mais simples de usar, está disponível nos sistemas
operacionais Windows, macOS e Unix e ajudará você a terminar o trabalho mais rapidamente.
Python é fá cil de usar, sem deixar de ser uma linguagem de programaçã o de verdade, oferecendo muito mais estru-
turaçã o e suporte para programas extensos do que shell scripts ou arquivos de lote oferecem. Por outro lado, Python
també m oferece melhor verificaçã o de erros do que C, e por ser uma linguagem de muito alto nível, ela possui tipos
nativos de alto nível, tais como dicioná rios e vetores (arrays) flexíveis. Devido ao suporte nativo a uma variedade
de tipos de dados, Python é aplicá vel a um domínio de problemas muito mais vasto do que Awk ou até mesmo Perl,
ainda assim muitas tarefas sã o pelo menos tã o fá ceis em Python quanto nessas linguagens.
Python permite que você organize seu programa em mó dulos que podem ser reutilizados em outros programas escritos
em Python. A linguagem provê uma vasta coleçã o de mó dulos que podem ser utilizados como base para sua aplicaçã o
— ou como exemplos para estudo e aprofundamento. Alguns desses mó dulos implementam manipulaçã o de arquivos,
chamadas do sistema, sockets, e até mesmo acesso a bibliotecas de construçã o de interfaces grá ficas, como Tk.
Python é uma linguagem interpretada, por isso você pode economizar um tempo considerá vel durante o desenvol-
vimento, uma vez que nã o há necessidade de compilaçã o e vinculaçã o (linking). O interpretador pode ser usado
interativamente, o que torna fá cil experimentar diversas características da linguagem, escrever programas “descar-
tá veis”, ou testar funçõ es em um desenvolvimento debaixo para cima (bottom-up). É també m uma ú til calculadora
de mesa.
Python permite a escrita de programas compactos e legíveis. Programas escritos em Python sã o tipicamente mais
curtos do que seus equivalentes em C, C++ ou Java, por diversas razõ es:

3
Python Tutorial, Release 3.12.5

• os tipos de alto nível permitem que você expresse operaçõ es complexas em um ú nico comando;
• a definiçã o de bloco é feita por indentaçã o ao invé s de marcadores de início e fim de bloco;
• nã o há necessidade de declaraçã o de variá veis ou parâ metros formais;
Python é extensível: se você sabe como programar em C, é fá cil adicionar funçõ es ou mó dulos diretamente no
interpretador, seja para desempenhar operaçõ es críticas em má xima velocidade, ou para vincular programas Python
a bibliotecas que só estejam disponíveis em formato biná rio (como uma biblioteca grá fica de terceiros). Uma vez que
você tenha sido fisgado, você pode vincular o interpretador Python a uma aplicaçã o escrita em C e utilizá -la como
linguagem de comandos ou extensã o para esta aplicaçã o.
A propó sito, a linguagem foi batizada a partir do famoso programa da BBC “Monty Python’s Flying Circus” e nã o
tem nada a ver com ré pteis. Fazer referê ncias a citaçõ es do programa na documentaçã o nã o é só permitido, como
també m é encorajado!
Agora que você está entusiasmado com Python, vai querer conhecê -la com mais detalhes. Partindo do princípio que
a melhor maneira de aprender uma linguagem é usando-a, você está agora convidado a fazê -lo com este tutorial.
No pró ximo capítulo, a mecâ nica de utilizaçã o do interpretador é explicada. Essa informaçã o, ainda que mundana,
é essencial para a experimentaçã o dos exemplos apresentados mais tarde.
O resto do tutorial introduz diversos aspectos do sistema e linguagem Python por intermé dio de exemplos. Serã o
abordadas expressõ es simples, comandos, tipos, funçõ es e mó dulos. Finalmente, serã o explicados alguns conceitos
avançados como exceçõ es e classes definidas pelo usuá rio.

4 Capítulo 1. Abrindo seu apetite

 CAPÍTULO 2

Utilizando o interpretador Python

2.1 Chamando o interpretador

O interpretador Python é frequentemente instalado como /usr/local/bin/python3.12 nas má quinas onde
está disponível; adicionando /usr/local/bin ao caminho de busca da shell de seu Unix torna-se possível iniciá -
-lo digitando o comando:

python3.12

no shell.1 Considerando que a escolha do diretó rio onde o interpretador está é uma opçã o de instalaçã o, outros locais
sã o possíveis; verifique com seu guru local de Python ou administrador do sistema local. (Por exemplo, /usr/
local/python é um local alternativo popular.)
Em má quinas Windows onde você instalou Python a partir da Microsoft Store, o comando python3.12 estará
disponível. Se você tem o lançador [Link] instalado, você pode usar o comando py. Veja setting-envvars para outras
maneiras de executar o Python.
Digitando um caractere de fim-de-arquivo (Control-D no Unix, Control-Z no Windows) diretamente no
prompt força o interpretador a sair com status de saída zero. Se isso nã o funcionar, você pode sair do interpre-
tador digitando o seguinte comando: quit().
Os recursos de ediçã o de linha do interpretador incluem ediçã o interativa, substituiçã o de histó rico e complemento
de có digo, em sistemas com suporte à biblioteca GNU Readline. Talvez a verificaçã o mais rá pida para ver se o
suporte à ediçã o de linha de comando está disponível é digitando Control-P no primeiro prompt oferecido pelo
Python. Se for emitido um bipe, você terá a ediçã o da linha de comando; veja Apê ndice Edição de entrada interativa
e substituição de histórico para uma introduçã o à s combinaçõ es. Se nada acontecer, ou se ^P aparecer na tela, a
ediçã o da linha de comando nã o está disponível; você só poderá usar backspace para remover caracteres da linha
atual.
O interpretador trabalha de forma semelhante a uma shell de Unix: quando chamado com a saída padrã o conectada
a um console de terminal, ele lê e executa comandos interativamente; quando chamado com um nome de arquivo
como argumento, ou com redirecionamento da entrada padrã o para ler um arquivo, o interpretador lê e executa o
script contido no arquivo.
Uma segunda forma de iniciar o interpretador é python -c comando [arg] ..., que executa uma ou mais
instruçõ es especificadas na posiçã o comando, analogamente à opçã o de shell -c. Considerando que comandos Python
1 No Unix, o interpretador Python 3.x nã o é instalado por padrã o com o executá vel nomeado python, entã o nã o vai conflitar com um

executá vel Python 2.x instalado simultaneamente.

5
Python Tutorial, Release 3.12.5

frequentemente tê m espaços em branco (ou outros caracteres que sã o especiais para a shell) é aconselhá vel que todo
o comando esteja entre as aspas.
Alguns mó dulos Python sã o també m ú teis como scripts. Estes podem ser chamados usando python -m módulo
[arg] ... que executa o arquivo fonte do módulo como se você tivesse digitado seu caminho completo na linha
de comando.
Quando um arquivo de script é utilizado, à s vezes é ú til executá -lo e logo em seguida entrar em modo interativo. Isto
pode ser feito acrescentando o argumento -i antes do nome do script.
Todas as opçõ es de linha de comando sã o descritas em using-on-general.

2.1.1 Passagem de argumentos

Quando sã o de conhecimento do interpretador, o nome do script e demais argumentos da linha de comando da shell
sã o acessíveis ao pró prio script atravé s da variá vel argv do mó dulo sys. Pode-se acessar essa lista executando
import sys. Essa lista tem sempre ao menos um elemento; quando nenhum script ou argumento for passado
para o interpretador, [Link][0] será uma string vazia. Quando o nome do script for '-' (significando en-
trada padrã o), o conteú do de [Link][0] será '-'. Quando for utilizado -c comando, [Link][0] con-
terá '-c'. Quando for utilizado -m módulo, [Link][0] conterá o caminho completo do mó dulo localizado.
Opçõ es especificadas apó s -c comando ou -m módulo nã o serã o consumidas pelo interpretador mas deixadas em
[Link] para serem tratadas pelo comando ou mó dulo.

2.1.2 Modo interativo

Quando os comandos sã o lidos a partir do console, diz-se que o interpretador está em modo interativo. Nesse modo
ele solicita um pró ximo comando atravé s do prompt primário, tipicamente trê s sinais de maior (>>>); para linhas de
continuaçã o do comando atual, o prompt secundário padrã o é formado por trê s pontos (...). O interpretador exibe
uma mensagem de boas vindas, informando seu nú mero de versã o e um aviso de copyright antes de exibir o primeiro
prompt:

$ python3.12
Python 3.12 (default, April 4 2022, 09:25:04)
[GCC 10.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Linhas de continuaçã o sã o necessá rias em construçõ es multi-linha. Como exemplo, dê uma olhada nesse comando
if:

>>> the_world_is_flat = True

>>> if the_world_is_flat:
... print("Be careful not to fall off!")
...
Be careful not to fall off!

Para mais informaçõ es sobre o modo interativo, veja Modo interativo.

6 Capítulo 2. Utilizando o interpretador Python

 Python Tutorial, Release 3.12.5

2.2 O interpretador e seu ambiente

2.2.1 Edição de código-fonte

Por padrã o, arquivos fonte de Python sã o tratados com codificaçã o UTF-8. Nessa codificaçã o, caracteres de muitos
idiomas no mundo podem ser usados simultaneamente em literais string, identificadores e comentá rios — embora
a biblioteca padrã o use apenas caracteres ASCII para identificadores, uma convençã o que qualquer có digo portá vel
deve seguir. Para exibir todos esses caracteres corretamente, seu editor deve reconhecer que o arquivo é UTF-8 e
deve usar uma fonte com suporte a todos os caracteres no arquivo.
Para declarar uma codificaçã o diferente da padrã o, uma linha de comentá rio especial deve ser adicionada como
primeira linha do arquivo. A sintaxe é essa:

# -*- coding: encoding -*-

onde encoding é uma das codecs vá lidas com suporte do Python.
Por exemplo, para declarar que a codificaçã o Windows-1252 deve ser usada, a primeira linha do seu arquivo fonte
deve ser:

# -*- coding: cp1252 -*-

Uma exceçã o para a regra da primeira linha é quando o có digo-fonte inicia com uma linha com UNIX “shebang”.
Nesse caso, a declaraçã o de codificaçã o deve ser adicionada como a segunda linha do arquivo. Por exemplo:

#!/usr/bin/env python3
# -*- coding: cp1252 -*-

2.2. O interpretador e seu ambiente 7

Python Tutorial, Release 3.12.5

8 Capítulo 2. Utilizando o interpretador Python

 CAPÍTULO 3

Uma introdução informal ao Python

Nos exemplos seguintes, pode-se distinguir entrada e saída pela presença ou ausê ncia dos prompts (»> e …): para
repetir o exemplo, você deve digitar tudo apó s o prompt, quando o mesmo aparece; linhas que nã o começarem com
um prompt sã o na verdade as saídas geradas pelo interpretador. Observe que quando aparece uma linha contendo
apenas o prompt secundá rio você deve digitar uma linha em branco; é assim que se encerra um comando de mú ltiplas
linhas.
Muitos exemplos neste manual, mesmo aqueles inscritos na linha de comando interativa, incluem comentá rios. Co-
mentá rios em Python começam com o caractere cerquilha ‘#’ e estende até o final da linha. Um comentá rio pode
aparecer no inicio da linha ou apó s espaço em branco ou có digo, mas nã o dentro de uma string literal. O caracterer
cerquilha dentro de uma string literal é apenas uma cerquilha. Como os comentá rios sã o para esclarecer o có digo e
nã o sã o interpretados pelo Python, eles podem ser omitidos ao digitar exemplos.
Alguns exemplos:

# this is the first comment

spam = 1 # and this is the second comment
# ... and now a third!
text = "# This is not a comment because it's inside quotes."

3.1 Usando Python como uma calculadora

Vamos experimentar alguns comandos simples em Python. Inicie o interpretador e aguarde o prompt primá rio, >>>.
(Nã o deve demorar muito.)

3.1.1 Números

O interpretador funciona como uma calculadora bem simples: você pode digitar uma expressã o e o resultado será
apresentado. A sintaxe de expressõ es é a usual: operadores +, -, * e / podem ser usadas para realizar operaçõ es
aritmé ticas; parê nteses (()) podem ser usados para agrupar expressõ es. Por exemplo:

>>> 2 + 2
4
>>> 50 - 5*6
20
(continua na pró xima pá gina)

9
Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # division always returns a floating-point number
1.6

Os nú meros inteiros (ex. 2, 4, 20) sã o do tipo int, aqueles com parte fracioná ria (ex. 5.0, 1.6) sã o do tipo
float. Veremos mais sobre tipos numé ricos posteriormente neste tutorial.
Divisã o (/) sempre retorna ponto flutuante (float). Para fazer uma divisão pelo piso e receber um inteiro como
resultado você pode usar o operador //; para calcular o resto você pode usar o %:

>>> 17 / 3 # classic division returns a float

5.666666666666667
>>>
>>> 17 // 3 # floor division discards the fractional part
5
>>> 17 % 3 # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2 # floored quotient * divisor + remainder
17

Com Python, é possível usar o operador ** para calcular potê ncias1 :

>>> 5 ** 2 # 5 squared
25
>>> 2 ** 7 # 2 to the power of 7
128

O sinal de igual ('=') é usado para atribuir um valor a uma variá vel. Depois de uma atribuiçã o, nenhum resultado
é exibido antes do pró ximo prompt:

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

Se uma variá vel nã o é “definida” (nã o tem um valor atribuído), tentar utilizá -la gerará um erro:

>>> n # try to access an undefined variable

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

Há suporte completo para ponto flutuante (float); operadores com operandos de diferentes tipos convertem o inteiro
para ponto flutuante:

>>> 4 * 3.75 - 1
14.0

No modo interativo, o valor da ú ltima expressã o exibida é atribuída a variá vel _. Assim, ao utilizar Python como
uma calculadora, fica mais fá cil prosseguir com os cá lculos, por exemplo:

>>> tax = 12.5 / 100

>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
(continua na pró xima pá gina)
1 Uma vez que ** tem precedê ncia mais alta que -, -3**2 será interpretado como -(3**2) e assim resultará em -9. Para evitar isso e
obter 9, você pode usar (-3)**2.

10 Capítulo 3. Uma introdução informal ao Python

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

>>> round(_, 2)
113.06

Essa variá vel especial deve ser tratada como somente para leitura pelo usuá rio. Nunca lhe atribua explicitamente
um valor — do contrá rio, estaria criando uma outra variá vel (homô nima) independente, que mascararia a variá vel
especial com seu comportamento má gico.
Alé m de int e float, o Python suporta outros tipos de nú meros, tais como Decimal e Fraction. O Python
també m possui suporte nativo a nú meros complexos, e usa os sufixos j ou J para indicar a parte imaginá ria (por
exemplo, 3+5j).

3.1.2 Texto

Python pode manipular texto (representado pelo tipo str, també m chamado de “strings”), bem como nú meros. Isso
inclui caracteres “!”, palavras “coelho”, nomes “Paris”, frases “Eu te protejo.”, etc. “Oba! :)”. Eles
podem ser colocados entre aspas simples ('...') ou aspas duplas ("...") com o mesmo resultado2 .

>>> 'spam eggs' # single quotes

'spam eggs'
>>> "Paris rabbit got your back :)! Yay!" # double quotes
'Paris rabbit got your back :)! Yay!'
>>> '1975' # digits and numerals enclosed in quotes are also strings
'1975'

Para colocar aspas entre aspas, precisamos “escapá -la”, precedendo-as com \. Alternativamente, podemos usar o
outro tipo de aspas:

>>> 'doesn\'t' # use \' to escape the single quote...

"doesn't"
>>> "doesn't" # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

No shell do Python, a definiçã o de string e a string de saída podem parecer diferentes. A funçã o print() produz
uma saída mais legível, omitindo as aspas delimitadoras e imprimindo caracteres de escape e especiais:

>>> s = 'First line.\nSecond line.' # \n means newline

>>> s # without print(), special characters are included in the string
'First line.\nSecond line.'
>>> print(s) # with print(), special characters are interpreted, so \n produces␣
,→new line

First line.
Second line.

Se nã o quiseres que os caracteres sejam precedidos por \ para serem interpretados como caracteres especiais, poderá s
usar strings raw (N.d.T: “crua” ou sem processamento de caracteres de escape) adicionando um r antes da primeira
aspa:

>>> print('C:\some\name') # here \n means newline!

C:\some
ame
(continua na pró xima pá gina)
2 Ao contrá rio de outras linguagens, caracteres especiais como \n tê m o mesmo significado com as aspas simples ('...') e duplas ("...")

. A ú nica diferença entre as duas é que, dentro de aspas simples, você nã o precisa escapar o " (mas você deve escapar a \') e vice-versa.

3.1. Usando Python como uma calculadora 11

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

>>> print(r'C:\some\name') # note the r before the quote
C:\some\name

Há um aspecto sutil nas strings raw: uma string raw nã o pode terminar em um nú mero ímpar de caracteres \; consulte
a entrada do FAQ para mais informaçõ es e soluçõ es alternativas.
As strings literais podem abranger vá rias linhas. Uma maneira é usar as aspas triplas: """...""" ou '''...
'''. O fim das linhas é incluído automaticamente na string, mas é possível evitar isso adicionando uma \ no final.
O seguinte exemplo:

print("""\
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
""")

produz a seguinte saída (observe que a linha inicial nã o está incluída):

Usage: thingy [OPTIONS]

-h Display this usage message
-H hostname Hostname to connect to

Strings podem ser concatenadas (coladas) com o operador +, e repetidas com *:

>>> # 3 times 'un', followed by 'ium'

>>> 3 * 'un' + 'ium'
'unununium'

Duas ou mais strings literais (ou seja, entre aspas) ao lado da outra sã o automaticamente concatenados.

>>> 'Py' 'thon'

'Python'

Esse recurso é particularmente ú til quando você quer quebrar strings longas:

>>> text = ('Put several strings within parentheses '

... 'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

Isso só funciona com duas strings literais, nã o com variá veis ou expressõ es:

>>> prefix = 'Py'

>>> prefix 'thon' # can't concatenate a variable and a string literal
File "<stdin>", line 1
prefix 'thon'
^^^^^^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
File "<stdin>", line 1
('un' * 3) 'ium'
^^^^^
SyntaxError: invalid syntax

Se você quiser concatenar variá veis ou uma variá vel e uma literal, use +:

>>> prefix + 'thon'

'Python'

As strings podem ser indexadas (subscritas), com o primeiro caractere como índice 0. Nã o existe um tipo específico
para caracteres; um caractere é simplesmente uma string cujo tamanho é 1:

12 Capítulo 3. Uma introdução informal ao Python

 Python Tutorial, Release 3.12.5

>>> word = 'Python'

>>> word[0] # character in position 0
'P'
>>> word[5] # character in position 5
'n'

́
Indices també m podem ser nú meros negativos para iniciar a contagem pela direita:

>>> word[-1] # last character

'n'
>>> word[-2] # second-last character
'o'
>>> word[-6]
'P'

Note que dado que -0 é o mesmo que 0, índices negativos começam em -1.
Alé m da indexaçã o, o fatiamento també m é permitido. Embora a indexaçã o seja usada para obter caracteres indivi-
duais, fatiar permite que você obtenha uma substring:

>>> word[0:2] # characters from position 0 (included) to 2 (excluded)

'Py'
>>> word[2:5] # characters from position 2 (included) to 5 (excluded)
'tho'

Os índices do fatiamento possuem padrõ es ú teis; um primeiro índice omitido padrã o é zero, um segundo índice
omitido é por padrã o o tamanho da string sendo fatiada:

>>> word[:2] # character from the beginning to position 2 (excluded)

'Py'
>>> word[4:] # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'on'

Observe como o início sempre está incluído, e o fim sempre é excluído. Isso garante que s[:i] + s[i:] seja
sempre igual a s:

>>> word[:2] + word[2:]

'Python'
>>> word[:4] + word[4:]
'Python'

Uma maneira de lembrar como fatias funcionam é pensar que os índices indicam posiçõ es entre caracteres, onde a
borda esquerda do primeiro caractere é 0. Assim, a borda direita do ú ltimo caractere de uma string de comprimento
n tem índice n, por exemplo:

+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1

A primeira fileira de nú meros indica a posiçã o dos índices 0…6 na string; a segunda fileira indica a posiçã o dos
respectivos índices negativos. Uma fatia de i a j consiste em todos os caracteres entre as bordas i e j, respectivamente.
Para índices positivos, o comprimento da fatia é a diferença entre os índices, se ambos estã o dentro dos limites da
string. Por exemplo, o comprimento de word[1:3] é 2.
A tentativa de usar um índice que seja muito grande resultará em um erro:

3.1. Usando Python como uma calculadora 13

Python Tutorial, Release 3.12.5

>>> word[42] # the word only has 6 characters

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range

No entanto, os índices de fatiamento fora do alcance sã o tratados graciosamente (N.d.T: o termo original “gracefully”
indica robustez no tratamento de erros) quando usados para fatiamento. Um índice maior que o comprimento é
trocado pelo comprimento, um limite superior menor que o limite inferior produz uma string vazia:

>>> word[4:42]
'on'
>>> word[42:]
''

As strings do Python nã o podem ser alteradas — uma string é imutável. Portanto, atribuir a uma posiçã o indexada
na sequê ncia resulta em um erro:

>>> word[0] = 'J'

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Se você precisar de uma string diferente, deverá criar uma nova:

>>> 'J' + word[1:]

'Jython'
>>> word[:2] + 'py'
'Pypy'

A funçã o embutida len() devolve o comprimento de uma string:

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

Ver também

textseq
As strings sã o exemplos de tipos de sequências e suportam as operaçõ es comumente suportadas por esses
tipos.
string-methods
As strings suportam uma grande quantidade de mé todos para transformaçõ es bá sicas e busca.
f-strings
Strings literais que possuem expressõ es embutidas.
formatstrings
Informaçõ es sobre formataçã o de string com o mé todo [Link]().
old-string-formatting
As antigas operaçõ es de formataçã o invocadas quando as strings sã o o operando esquerdo do operador %
sã o descritas com mais detalhes aqui.

14 Capítulo 3. Uma introdução informal ao Python

 Python Tutorial, Release 3.12.5

3.1.3 Listas

Python inclui diversas estruturas de dados compostas, usadas para agrupar outros valores. A mais versá til é list (lista),
que pode ser escrita como uma lista de valores (itens) separados por vírgula, entre colchetes. Os valores contidos na
lista nã o precisam ser todos do mesmo tipo.

>>> squares = [1, 4, 9, 16, 25]

>>> squares
[1, 4, 9, 16, 25]

Como strings (e todos os tipos embutidos de sequência), listas pode ser indexados e fatiados:

>>> squares[0] # indexing returns the item

1
>>> squares[-1]
25
>>> squares[-3:] # slicing returns a new list
[9, 16, 25]

As listas també m suportam operaçõ es como concatenaçã o:

>>> squares + [36, 49, 64, 81, 100]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Diferentemente de strings, que sã o imutáveis, listas sã o mutáveis, ou seja, é possível alterar elementos individuais de
uma lista:

>>> cubes = [1, 8, 27, 65, 125] # something's wrong here

>>> 4 ** 3 # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64 # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

Você també m pode adicionar novos itens no final da lista, usando o método [Link]() (estudaremos mais
a respeito dos mé todos posteriormente):

>>> [Link](216) # add the cube of 6

>>> [Link](7 ** 3) # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

A atribuiçã o simples em Python nunca copia dados. Quando você atribui uma lista a uma variá vel, a variá vel se refere
à lista existente. Quaisquer alteraçõ es que você fizer na lista por meio de uma variá vel serã o vistas por todas as outras
variá veis que se referem a ela.:

>>> rgb = ["Red", "Green", "Blue"]

>>> rgba = rgb
>>> id(rgb) == id(rgba) # they reference the same object
True
>>> [Link]("Alph")
>>> rgb
["Red", "Green", "Blue", "Alph"]

Todas as operaçõ es de fatiamento devolvem uma nova lista contendo os elementos solicitados. Isso significa que o
seguinte fatiamento devolve uma có pia rasa da lista:

>>> correct_rgba = rgba[:]

>>> correct_rgba[-1] = "Alpha"
>>> correct_rgba
["Red", "Green", "Blue", "Alpha"]
(continua na pró xima pá gina)

3.1. Usando Python como uma calculadora 15

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

>>> rgba
["Red", "Green", "Blue", "Alph"]

Atribuiçã o a fatias també m é possível, e isso pode até alterar o tamanho da lista ou remover todos os itens dela:

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

A funçã o embutida len() també m se aplica a listas:

>>> letters = ['a', 'b', 'c', 'd']

>>> len(letters)
4

É possível aninhar listas (criar listas contendo outras listas), por exemplo:

>>> a = ['a', 'b', 'c']

>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2 Primeiros passos para a programação

Claro, podemos usar o Python para tarefas mais complicadas do que somar 2+2. Por exemplo, podemos escrever o
início da sequê ncia de Fibonacci assim:

>>> # Fibonacci series:

>>> # the sum of two elements defines the next
>>> a, b = 0, 1
>>> while a < 10:
... print(a)
... a, b = b, a+b
...
0
1
1
2
3
5
8

16 Capítulo 3. Uma introdução informal ao Python

 Python Tutorial, Release 3.12.5

Este exemplo introduz diversas características ainda nã o mencionadas.

• A primeira linha conté m uma atribuiçã o mú ltipla: as variá veis a e b recebem simultaneamente os novos valores
0 e 1. Na ú ltima linha há outro exemplo de atribuiçã o mú ltipla demonstrando que expressõ es do lado direito
sã o sempre avaliadas primeiro, antes da atribuiçã o. As expressõ es do lado direito sã o avaliadas da esquerda
para a direita.
• O laço de repetiçã o while executa enquanto a condiçã o (aqui: a < 10) permanece verdadeira. Em Python,
como em C, qualquer valor inteiro que nã o seja zero é considerado verdadeiro; zero é considerado falso. A
condiçã o pode també m ser uma cadeia de caracteres ou uma lista, ou qualquer sequê ncia; qualquer coisa com
um tamanho maior que zero é verdadeiro, enquanto sequê ncias vazias sã o falsas. O teste usado no exemplo
é uma comparaçã o simples. Os operadores padrõ es de comparaçã o sã o os mesmos de C: < (menor que), >
(maior que), == (igual), <= (menor ou igual), >= (maior ou igual) e != (diferente).
• O corpo do laço é indentado: indentaçã o em Python é a maneira de agrupar comandos em blocos. No console
interativo padrã o você terá que digitar tab ou espaços para indentar cada linha. Na prá tica você vai preparar
scripts Python mais complicados em um editor de texto; a maioria dos editores de texto tem facilidades de
indentaçã o automá tica. Quando um comando composto é digitado interativamente, deve ser finalizado por
uma linha em branco (já que o interpretador nã o tem como adivinhar qual é a ú ltima linha do comando).
Observe que toda linha de um mesmo bloco de comandos deve ter a mesma indentaçã o.
• The print() function writes the value of the argument(s) it is given. It differs from just writing the expression
you want to write (as we did earlier in the calculator examples) in the way it handles multiple arguments,
floating-point quantities, and strings. Strings are printed without quotes, and a space is inserted between items,
so you can format things nicely, like this:

>>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536

O argumento end pode ser usado para evitar uma nova linha apó s a saída ou finalizar a saída com uma string
diferente:

>>> a, b = 0, 1
>>> while a < 1000:
... print(a, end=',')
... a, b = b, a+b
...
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

3.2. Primeiros passos para a programação 17

Python Tutorial, Release 3.12.5

18 Capítulo 3. Uma introdução informal ao Python

 CAPÍTULO 4

Mais ferramentas de controle de fluxo

Assim como a instruçã o while que acabou de ser apresentada, o Python usa mais algumas que encontraremos neste
capítulo.

4.1 Comandos if

Provavelmente o mais conhecido comando de controle de fluxo é o if. Por exemplo:

>>> x = int(input("Please enter an integer: "))

Please enter an integer: 42
>>> if x < 0:
... x = 0
... print('Negative changed to zero')
... elif x == 0:
... print('Zero')
... elif x == 1:
... print('Single')
... else:
... print('More')
...
More

Pode haver zero ou mais partes elif, e a parte else é opcional. A palavra-chave ‘elif’ é uma abreviaçã o para
‘else if’, e é ú til para evitar indentaçã o excessiva. Uma sequê ncia if … elif … elif … substitui os comandos
switch ou case, encontrados em outras linguagens.
Se você está comparando o mesmo valor com vá rias constantes, ou verificando por tipos ou atributos específicos,
você també m pode achar a instruçã o match ú til. Para mais detalhes veja Instruções match.

19
Python Tutorial, Release 3.12.5

4.2 Comandos for

O comando for em Python é um pouco diferente do que costuma ser em C ou Pascal. Ao invé s de sempre iterar
sobre uma progressã o aritmé tica de nú meros (como no Pascal), ou permitir ao usuá rio definir o passo de iteraçã o e a
condiçã o de parada (como C), o comando for do Python itera sobre os itens de qualquer sequê ncia (seja uma lista
ou uma string), na ordem que aparecem na sequê ncia. Por exemplo:
>>> # Measure some strings:
>>> words = ['cat', 'window', 'defenestrate']
>>> for w in words:
... print(w, len(w))
...
cat 3
window 6
defenestrate 12

Có digo que modifica uma coleçã o sobre a qual está iterando pode ser inseguro. No lugar disso, usualmente você deve
iterar sobre uma có pia da coleçã o ou criar uma nova coleçã o:
# Create a sample collection
users = {'Hans': 'active', 'Éléonore': 'inactive', ' ': 'active'}

# Strategy: Iterate over a copy

for user, status in [Link]().items():
if status == 'inactive':
del users[user]

# Strategy: Create a new collection

active_users = {}
for user, status in [Link]():
if status == 'active':
active_users[user] = status

4.3 A função range()

Se você precisa iterar sobre sequê ncias numé ricas, a funçã o embutida range() é a resposta. Ela gera progressõ es
aritmé ticas:
>>> for i in range(5):
... print(i)
...
0
1
2
3
4

O ponto de parada fornecido nunca é incluído na lista; range(10) gera uma lista com 10 valores, exatamente os
índices vá lidos para uma sequê ncia de comprimento 10. É possível iniciar o intervalo com outro nú mero, ou alterar
a razã o da progressã o (inclusive com passo negativo):
>>> list(range(5, 10))
[5, 6, 7, 8, 9]

>>> list(range(0, 10, 3))

[0, 3, 6, 9]

>>> list(range(-10, -100, -30))

[-10, -40, -70]

20 Capítulo 4. Mais ferramentas de controle de fluxo

 Python Tutorial, Release 3.12.5

Para iterar sobre os índices de uma sequê ncia, combine range() e len() da seguinte forma:
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
... print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb

Na maioria dos casos, poré m, é mais conveniente usar a funçã o enumerate(), veja Técnicas de iteração.
Uma coisa estranha acontece se você imprime um intervalo:
>>> range(10)
range(0, 10)

Em muitos aspectos, o objeto retornado pela funçã o range() se comporta como se fosse uma lista, mas na verdade
nã o é . É um objeto que retorna os itens sucessivos da sequê ncia desejada quando você itera sobre a mesma, mas na
verdade ele nã o gera a lista, economizando espaço.
Dizemos que um objeto é iterável, isso é , candidato a ser alvo de uma funçã o ou construçã o que espera alguma coisa
capaz de retornar sucessivamente seus elementos um de cada vez. Nó s vimos que o comando for é um exemplo de
construçã o, enquanto que um exemplo de funçã o que recebe um iterá vel é sum():
>>> sum(range(4)) # 0 + 1 + 2 + 3
6

Mais tarde, veremos mais funçõ es que retornam iterá veis e tomam iterá veis como argumentos. No capítulo Estruturas
de dados, iremos discutir em mais detalhes sobre list().

4.4 Comandos break e continue, e cláusula else, nos laços de

repetição

A instruçã o break sai imediatamente do laço de repetiçã o mais interno, seja for ou while.
Um laço for ou while pode incluir uma clá usula else.
Em um laço for, a clá usula else é executada apó s o laço atingir sua iteraçã o final.
Em um laço while, ele é executado apó s a condiçã o do laço se tornar falsa.
Em qualquer tipo de laço, a clá usula else não é executada se o laço for encerrado por um break.
Isso é exemplificado no seguinte laço for, que procura por nú meros primos:
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
... print(n, 'equals', x, '*', n//x)
... break
... else:
... # loop fell through without finding a factor
... print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
(continua na pró xima pá gina)

4.4. Comandos break e continue, e cláusula else, nos laços de repetição 21

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

(Sim, o có digo está correto. Olhe atentamente: a clá usula else pertence ao laço for, e não ao comando if.)
Quando usado em um laço, a clá usula else tem mais em comum com a clá usula else de um comando try do que
com a de um comando if: a clá usula else de um comando try executa quando nã o ocorre exceçã o, e o else
de um laço executa quando nã o ocorre um break. Para mais informaçõ es sobre comando try e exceçõ es, veja
Tratamento de exceções.
A instruçã o continue, també m emprestada da linguagem C, continua com a pró xima iteraçã o do laço:

>>> for num in range(2, 10):

... if num % 2 == 0:
... print("Found an even number", num)
... continue
... print("Found an odd number", num)
...
Found an even number 2
Found an odd number 3
Found an even number 4
Found an odd number 5
Found an even number 6
Found an odd number 7
Found an even number 8
Found an odd number 9

4.5 Comandos pass

O comando pass nã o faz nada. Pode ser usada quando a sintaxe exige um comando mas a semâ ntica do programa
nã o requer nenhuma açã o. Por exemplo:

>>> while True:

... pass # Busy-wait for keyboard interrupt (Ctrl+C)
...

Isto é usado muitas vezes para se definir classes mínimas:

>>> class MyEmptyClass:

... pass
...

Outra ocasiã o em que o pass pode ser usado é como um substituto temporá rio para uma funçã o ou bloco condicional,
quando se está trabalhando com có digo novo, ainda indefinido, permitindo que mantenha-se o pensamento num nível
mais abstrato. O pass é silenciosamente ignorado:

>>> def initlog(*args):

... pass # Remember to implement this!
...

22 Capítulo 4. Mais ferramentas de controle de fluxo

 Python Tutorial, Release 3.12.5

4.6 Instruções match

Uma instruçã o match pega uma expressã o e compara seu valor com padrõ es sucessivos fornecidos como um ou mais
blocos de case. Isso é superficialmente semelhante a uma instruçã o switch em C, Java ou JavaScript (e muitas outras
linguagens), mas també m pode extrair componentes (elementos de sequê ncia ou atributos de objeto) do valor em
variá veis, mas muito mais parecido com a correspondê ncia de padrõ es em linguages como Rust ou Haskell. Apenas
o primeiro padrã o que corresponder será executado, podendo també m extrair componentes (elementos de sequê ncia
ou atributos de objetos) do valor para variá veis.
A forma mais simples compara um valor de assunto com um ou mais literais:
def http_error(status):
match status:
case 400:
return "Bad request"
case 404:
return "Not found"
case 418:
return "I'm a teapot"
case _:
return "Something's wrong with the internet"

Observe o ú ltimo bloco: o “nome da variá vel” _ atua como um curinga e nunca falha em corresponder. Se nenhum
caso corresponder, nenhuma das ramificaçõ es será executada.
Você pode combinar vá rios literais em um ú nico padrã o usando | (“ou”):
case 401 | 403 | 404:
return "Not allowed"

Os padrõ es podem se parecer com atribuiçõ es de desempacotamento e podem ser usados para vincular variá veis:
# point is an (x, y) tuple
match point:
case (0, 0):
print("Origin")
case (0, y):
print(f"Y={y}")
case (x, 0):
print(f"X={x}")
case (x, y):
print(f"X={x}, Y={y}")
case _:
raise ValueError("Not a point")

Estude isso com cuidado! O primeiro padrã o tem dois literais e pode ser considerado uma extensã o do padrã o literal
mostrado acima. Mas os pró ximos dois padrõ es combinam um literal e uma variá vel, e a variá vel vincula um valor
do assunto (point). O quarto padrã o captura dois valores, o que o torna conceitualmente semelhante à atribuiçã o
de desempacotamento (x, y) = point.
Se você estiver usando classes para estruturar seus dados, você pode usar o nome da classe seguido por uma lista de
argumentos semelhante a um construtor, mas com a capacidade de capturar atributos em variá veis:
class Point:
def __init__(self, x, y):
self.x = x
self.y = y

def where_is(point):
match point:
case Point(x=0, y=0):
print("Origin")
(continua na pró xima pá gina)

4.6. Instruções match 23

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

case Point(x=0, y=y):
print(f"Y={y}")
case Point(x=x, y=0):
print(f"X={x}")
case Point():
print("Somewhere else")
case _:
print("Not a point")

Você pode usar parâ metros posicionais com algumas classes embutidas que fornecem uma ordem para seus atributos
(por exemplo, classes de dados). Você també m pode definir uma posiçã o específica para atributos em padrõ es
configurando o atributo especial __match_args__ em suas classes. Se for definido como (“x”, “y”), os seguintes
padrõ es sã o todos equivalentes (e todos ligam o atributo y à variá vel var):

Point(1, var)
Point(1, y=var)
Point(x=1, y=var)
Point(y=var, x=1)

Uma maneira recomendada de ler padrõ es é vê -los como uma forma estendida do que você colocaria à esquerda
de uma atribuiçã o, para entender quais variá veis seriam definidas para quê . Apenas os nomes autô nomos (como
var acima) sã o atribuídos por uma instruçã o de correspondê ncia. Nomes pontilhados (como [Link]), nomes de
atributos (o x= e y= acima) ou nomes de classes (reconhecidos pelo “(…)” pró ximo a eles, como Point acima)
nunca sã o atribuídos.
Os padrõ es podem ser aninhados arbitrariamente. Por exemplo, se tivermos uma pequena lista de Pontos, com
__match_args__ adicionado, poderíamos correspondê -la assim:

class Point:
__match_args__ = ('x', 'y')
def __init__(self, x, y):
self.x = x
self.y = y

match points:
case []:
print("No points")
case [Point(0, 0)]:
print("The origin")
case [Point(x, y)]:
print(f"Single point {x}, {y}")
case [Point(0, y1), Point(0, y2)]:
print(f"Two on the Y axis at {y1}, {y2}")
case _:
print("Something else")

Podemos adicionar uma clá usula if a um padrã o, conhecido como “guarda”. Se a guarda for falsa, match continua
para tentar o pró ximo bloco de caso. Observe que a captura de valor ocorre antes que a guarda seja avaliada:

match point:
case Point(x, y) if x == y:
print(f"Y=X at {x}")
case Point(x, y):
print(f"Not on the diagonal")

Vá rios outros recursos importantes desta instruçã o:

• Assim como desempacotar atribuiçõ es, os padrõ es de tupla e lista tê m exatamente o mesmo significado e
realmente correspondem a sequê ncias arbitrá rias. Uma exceçã o importante é que eles nã o correspondem a
iteradores ou strings.
• Os padrõ es de sequê ncia tê m suporte ao desempacotamento estendido: [x, y, *rest] e (x, y,

24 Capítulo 4. Mais ferramentas de controle de fluxo

 Python Tutorial, Release 3.12.5

*rest) funcionam de forma semelhante ao desempacotamento de atribuiçõ es. O nome depois de * també m
pode ser _, entã o (x, y, *_) corresponde a uma sequê ncia de pelo menos dois itens sem ligar os itens
restantes.
• Padrõ es de mapeamento: {"bandwidth": b, "latency": l} captura os valores "bandwidth" e
"latency" de um dicioná rio. Diferente dos padrõ es de sequê ncia, chaves extra sã o ignoradas. Um desem-
pacotamento como **rest també m é permitido. (Mas **_ seria redundante, entã o nã o é permitido.)
• Subpadrõ es podem ser capturados usando a palavra reservada as

case (Point(x1, y1), Point(x2, y2) as p2): ...

Vai capturar o segundo elemento da entrada como p2 (se a entrada for uma sequê ncia de dois pontos)
• A maioria dos literais sã o comparados por igualdade, no entando os singletons True, False e None sã o
comparados por identidade.
• Padrõ es podem usar constantes nomeadas. Estas devem ser nomes pontilhados para prevenir que sejam inter-
pretadas como variá veis de captura:

from enum import Enum

class Color(Enum):
RED = 'red'
GREEN = 'green'
BLUE = 'blue'

color = Color(input("Enter your choice of 'red', 'blue' or 'green': "))

match color:
case [Link]:
print("I see red!")
case [Link]:
print("Grass is green")
case [Link]:
print("I'm feeling the blues :(")

Para uma explicaçã o mais detalhada e exemplos adicionais, você pode olhar PEP 636 que foi escrita em formato de
tutorial.

4.7 Definindo funções

Podemos criar uma funçã o que escreve a sé rie de Fibonacci até um limite arbitrá rio:

>>> def fib(n): # write Fibonacci series up to n

... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Now call the function we just defined:
>>> fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

A palavra reservada def inicia a definição de uma funçã o. Ela deve ser seguida do nome da funçã o e da lista de
parâ metros formais entre parê nteses. Os comandos que formam o corpo da funçã o começam na linha seguinte e
devem ser indentados.
Opcionalmente, a primeira linha do corpo da funçã o pode ser uma literal string, cujo propó sito é documentar a funçã o.
Se presente, essa string chama-se docstring. (Há mais informaçã o sobre docstrings na seçã o Strings de documentação.)
Existem ferramentas que utilizam docstrings para produzir automaticamente documentaçã o online ou para imprimir,

4.7. Definindo funções 25

Python Tutorial, Release 3.12.5

ou ainda, permitir que o usuá rio navegue interativamente pelo có digo. É uma boa prá tica incluir sempre docstrings
em suas funçõ es, portanto, tente fazer disso um há bito.
A execução de uma funçã o cria uma nova tabela de símbolos para as variá veis locais da funçã o. Mais precisamente,
todas as atribuiçõ es de variá veis numa funçã o sã o armazenadas na tabela de símbolos local; referê ncias a variá veis
sã o buscadas primeiro na tabela de símbolos local, em seguida na tabela de símbolos locais de funçõ es delimitadoras
ou circundantes, depois na tabela de símbolos global e, finalmente, na tabela de nomes da pró pria linguagem. Em-
bora possam ser referenciadas, variá veis globais e de funçõ es externas nã o podem ter atribuiçõ es (a menos que seja
utilizado o comando global, para variá veis globais, ou nonlocal, para variá veis de funçõ es externas).
Os parâ metros reais (argumentos) de uma chamada de funçã o sã o introduzidos na tabela de símbolos local da funçã o
no momento da chamada; portanto, argumentos sã o passados por valor (onde o valor é sempre uma referência para
objeto, nã o o valor do objeto).1 Quando uma funçã o chama outra funçã o, ou chama a si mesma recursivamente, uma
nova tabela de símbolos é criada para tal chamada.
Uma definiçã o de funçã o associa o nome da funçã o com o objeto funçã o na tabela de símbolos atual. O interpretador
reconhece o objeto apontado pelo nome como uma funçã o definida pelo usuá rio. Outros nomes també m podem
apontar para o mesmo objeto funçã o e també m pode ser usados pra acessar a funçã o:

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

Conhecendo outras linguagens, pode-se questionar que fib nã o é uma funçã o, mas um procedimento, pois ela nã o
devolve um valor. Na verdade, mesmo funçõ es que nã o usam o comando return devolvem um valor, ainda que
pouco interessante. Esse valor é chamado None (é um nome embutido). O interpretador interativo evita escrever
None quando ele é o ú nico resultado de uma expressã o. Mas se quiser vê -lo pode usar a funçã o print():

>>> fib(0)
>>> print(fib(0))
None

É fá cil escrever uma funçã o que retorna uma lista de nú meros da sé rie de Fibonacci, ao invé s de exibi-los:

>>> def fib2(n): # return Fibonacci series up to n

... """Return a list containing the Fibonacci series up to n."""
... result = []
... a, b = 0, 1
... while a < n:
... [Link](a) # see below
... a, b = b, a+b
... return result
...
>>> f100 = fib2(100) # call it
>>> f100 # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Este exemplo demonstra novos recursos de Python:

• A instruçã o return finaliza a execuçã o e retorna um valor da funçã o. return sem qualquer expressã o
como argumento retorna None. Atingir o final da funçã o també m retorna None.
• A instruçã o [Link](a) chama um método do objeto lista result. Um mé todo é uma funçã o
que ‘pertence’ a um objeto, e é chamada [Link], onde obj é um objeto qualquer (pode ser
uma expressã o), e nomemetodo é o nome de um mé todo que foi definido pelo tipo do objeto. Tipos dife-
rentes definem mé todos diferentes. Mé todos de diferentes tipos podem ter o mesmo nome sem ambiguidade.
(É possível definir seus pró prios tipos de objetos e mé todos, utilizando classes, veja em Classes) O mé todo
append(), mostrado no exemplo é definido para objetos do tipo lista; adiciona um novo elemento ao final
da lista. Neste exemplo, ele equivale a result = result + [a], só que mais eficiente.
1 Na verdade, passagem por referência para objeto seria uma descriçã o melhor, pois, se um objeto mutá vel for passado, quem chamou verá as

alteraçõ es feitas por quem foi chamado (por exemplo, a inclusã o de itens em uma lista).

26 Capítulo 4. Mais ferramentas de controle de fluxo

 Python Tutorial, Release 3.12.5

4.8 Mais sobre definição de funções

É possível definir funçõ es com um nú mero variá vel de argumentos. Existem trê s formas, que podem ser combinadas.

4.8.1 Argumentos com valor padrão

A mais ú til das trê s é especificar um valor padrã o para um ou mais argumentos. Isso cria uma funçã o que pode ser
invocada com menos argumentos do que os que foram definidos. Por exemplo:

def ask_ok(prompt, retries=4, reminder='Please try again!'):

while True:
reply = input(prompt)
if reply in {'y', 'ye', 'yes'}:
return True
if reply in {'n', 'no', 'nop', 'nope'}:
return False
retries = retries - 1
if retries < 0:
raise ValueError('invalid user response')
print(reminder)

Essa funçã o pode ser chamada de vá rias formas:

• fornecendo apenas o argumento obrigató rio: ask_ok('Do you really want to quit?')
• fornecendo um dos argumentos opcionais: ask_ok('OK to overwrite the file?', 2)
• ou fornecendo todos os argumentos: ask_ok('OK to overwrite the file?', 2, 'Come
on, only yes or no!')
Este exemplo també m introduz a palavra-chave in, que verifica se uma sequê ncia conté m ou nã o um determinado
valor.
Os valores padrõ es sã o avaliados no momento da definiçã o da funçã o, e no escopo em que a funçã o foi definida,
portanto:

i = 5

def f(arg=i):
print(arg)

i = 6
f()

irá exibir 5.
Aviso importante: Valores padrõ es sã o avaliados apenas uma vez. Isso faz diferença quando o valor é um objeto
mutá vel, como uma lista, dicioná rio, ou instâ ncias de classes. Por exemplo, a funçã o a seguir acumula os argumentos
passados, nas chamadas subsequentes:

def f(a, L=[]):

[Link](a)
return L

print(f(1))
print(f(2))
print(f(3))

Isso exibirá :

4.8. Mais sobre definição de funções 27

Python Tutorial, Release 3.12.5

[1]
[1, 2]
[1, 2, 3]

Se nã o quiser que o valor padrã o seja compartilhado entre chamadas subsequentes, pode reescrever a funçã o assim:

def f(a, L=None):

if L is None:
L = []
[Link](a)
return L

4.8.2 Argumentos nomeados

Funçõ es també m podem ser chamadas usando argumentos nomeados da forma chave=valor. Por exemplo, a
funçã o a seguir:

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):

print("-- This parrot wouldn't", action, end=' ')
print("if you put", voltage, "volts through it.")
print("-- Lovely plumage, the", type)
print("-- It's", state, "!")

aceita um argumento obrigató rio (voltage) e trê s argumentos opcionais (state, action, e type). Esta funçã o
pode ser chamada de qualquer uma dessas formas:

parrot(1000) # 1 positional argument

parrot(voltage=1000) # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM') # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000) # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump') # 3 positional arguments
parrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword

mas todas as formas a seguir seriam invá lidas:

parrot() # required argument missing

parrot(voltage=5.0, 'dead') # non-keyword argument after a keyword argument
parrot(110, voltage=220) # duplicate value for the same argument
parrot(actor='John Cleese') # unknown keyword argument

Em uma chamada de funçã o, argumentos nomeados devem vir depois dos argumentos posicionais. Todos os ar-
gumentos nomeados passados devem corresponder com argumentos aceitos pela funçã o (ex. actor nã o é um
argumento nomeado vá lido para a funçã o parrot), mas sua ordem é irrelevante. Isto també m inclui argumentos
obrigató rios (ex.: parrot(voltage=1000) funciona). Nenhum argumento pode receber mais de um valor. Eis
um exemplo que nã o funciona devido a esta restriçã o:

>>> def function(a):

... pass
...
>>> function(0, a=0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for argument 'a'

Quando um ú ltimo parâ metro formal no formato **nome está presente, ele recebe um dicioná rio (veja typesmap-
ping) contendo todos os argumentos nomeados, exceto aqueles que correspondem a um parâ metro formal. Isto pode
ser combinado com um parâ metro formal no formato *nome (descrito na pró xima subseçã o) que recebe uma tupla
contendo os argumentos posicionais, alé m da lista de parâ metros formais. (*nome deve ocorrer antes de **nome.)
Por exemplo, se definirmos uma funçã o assim:

28 Capítulo 4. Mais ferramentas de controle de fluxo

 Python Tutorial, Release 3.12.5

def cheeseshop(kind, *arguments, **keywords):

print("-- Do you have any", kind, "?")
print("-- I'm sorry, we're all out of", kind)
for arg in arguments:
print(arg)
print("-" * 40)
for kw in keywords:
print(kw, ":", keywords[kw])

Pode ser chamada assim:

cheeseshop("Limburger", "It's very runny, sir.",

"It's really very, VERY runny, sir.",
shopkeeper="Michael Palin",
client="John Cleese",
sketch="Cheese Shop Sketch")

e, claro, exibiria:

-- Do you have any Limburger ?

-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch

Observe que a ordem em que os argumentos nomeados sã o exibidos é garantida para corresponder à ordem em que
foram fornecidos na chamada da funçã o.

4.8.3 Parâmetros especiais

Por padrã o, argumentos podem ser passadas para uma funçã o Python tanto por posiçã o quanto explicitamente pelo
nome. Para uma melhor legibilidade e desempenho, faz sentido restringir a maneira pelo qual argumentos possam
ser passados, assim um desenvolvedor precisa apenas olhar para a definiçã o da funçã o para determinar se os itens
sã o passados por posiçã o, por posiçã o e nome, ou por nome.
A definiçã o de uma funçã o pode parecer com:

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):

----------- ---------- ----------
| | |
| Positional or keyword |
| - Keyword only
-- Positional only

onde / e * sã o opcionais. Se usados, esses símbolos indicam o tipo de parâ metro pelo qual os argumentos podem ser
passados para as funçõ es: somente-posicional, posicional-ou-nomeado, e somente-nomeado. Parâ metros nomeados
sã o també m conhecidos como parâ metros palavra-chave.

4.8. Mais sobre definição de funções 29

Python Tutorial, Release 3.12.5

Argumentos posicional-ou-nomeados

Se / e * nã o estã o presentes na definiçã o da funçã o, argumentos podem ser passados para uma funçã o por posiçã o
ou por nome.

Parâmetros somente-posicionais

Olhando com um pouco mais de detalhes, é possível definir certos parâ metros como somente-posicional. Se somente-
-posicional, a ordem do parâ metro importa, e os parâ metros nã o podem ser passados por nome. Parâ metros somente-
-posicional sã o colocados antes de / (barra). A / é usada para logicamente separar os argumentos somente-posicional
dos demais parâ metros. Se nã o existe uma / na definiçã o da funçã o, nã o existe parâ metros somente-posicionais.
Parâ metros apó s a / podem ser posicional-ou-nomeado ou somente-nomeado.

Argumentos somente-nomeados

Para definir parâ metros como somente-nomeado, indicando que o parâ metro deve ser passado por argumento nome-
ado, colocamos um * na lista de argumentos imediatamente antes do primeiro parâ metro somente-nomeado.

Exemplos de funções

Considere o seguinte exemplo de definiçã o de funçã o com atençã o redobrada para os marcadores / e *:

>>> def standard_arg(arg):

... print(arg)
...
>>> def pos_only_arg(arg, /):
... print(arg)
...
>>> def kwd_only_arg(*, arg):
... print(arg)
...
>>> def combined_example(pos_only, /, standard, *, kwd_only):
... print(pos_only, standard, kwd_only)

A definiçã o da primeira funçã o, standard_arg, a forma mais familiar, nã o coloca nenhuma restriçã o para a
chamada da funçã o e argumentos podem ser passados por posiçã o ou nome:

>>> standard_arg(2)
2

>>> standard_arg(arg=2)
2

A segunda funçã o pos_only_arg está restrita ao uso de parâ metros somente posicionais, uma vez que existe uma
/ na definiçã o da funçã o:

>>> pos_only_arg(1)
1

>>> pos_only_arg(arg=1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pos_only_arg() got some positional-only arguments passed as keyword␣
,→arguments: 'arg'

A terceira funçã o kwd_only_args permite somente argumentos nomeados como indicado pelo * na definiçã o da
funçã o:

30 Capítulo 4. Mais ferramentas de controle de fluxo

 Python Tutorial, Release 3.12.5

>>> kwd_only_arg(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given

>>> kwd_only_arg(arg=3)
3

E a ú ltima usa as trê s convençõ es de chamada na mesma definiçã o de funçã o:

>>> combined_example(1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: combined_example() takes 2 positional arguments but 3 were given

>>> combined_example(1, 2, kwd_only=3)

1 2 3

>>> combined_example(1, standard=2, kwd_only=3)

1 2 3

>>> combined_example(pos_only=1, standard=2, kwd_only=3)

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: combined_example() got some positional-only arguments passed as keyword␣
,→arguments: 'pos_only'

Finalmente, considere essa definiçã o de funçã o que possui uma potencial colisã o entre o argumento posicional name
e **kwds que possui name como uma chave:

def foo(name, **kwds):

return 'name' in kwds

Nã o é possível essa chamada devolver True, uma vez que a chave 'name' sempre será aplicada para o primeiro
parâ metro. Por exemplo:

>>> foo(1, **{'name': 2})

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'name'
>>>

Mas usando / (somente argumentos posicionais), isso é possível já que permite name como um argumento posicional
e 'name' como uma chave nos argumentos nomeados:

>>> def foo(name, /, **kwds):

... return 'name' in kwds
...
>>> foo(1, **{'name': 2})
True

Em outras palavras, o nome de parâ metros somente-posicional podem ser usados em **kwds sem ambiguidade.

4.8. Mais sobre definição de funções 31

Python Tutorial, Release 3.12.5

Recapitulando

A situaçã o irá determinar quais parâ metros usar na definiçã o da funçã o:

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):

Como guia:
• Use somente-posicional se você nã o quer que o nome do parâ metro esteja disponível para o usuá rio. Isso é
ú til quando nomes de parâ metros nã o tem um significado real, se você quer forçar a ordem dos argumentos da
funçã o quando ela é chamada ou se você precisa ter alguns parâ metros posicionais e alguns nomeados.
• Use somente-nomeado quando os nomes tem significado e a definiçã o da funçã o fica mais clara deixando esses
nomes explícitos ou se você quer evitar que usuá rios confiem na posiçã o dos argumentos que estã o sendo
passados.
• Para uma API, use somente-posicional para evitar quebras na mudança da API se os nomes dos parâ metros
forem alterados no futuro.

4.8.4 Listas de argumentos arbitrárias

Finalmente, a opçã o menos usada é especificar que a funçã o pode ser chamada com um nú mero arbitrá rio de argu-
mentos. Esses argumentos serã o empacotados em uma tupla (ver Tuplas e Sequências). Antes dos argumentos em
nú mero variá vel, zero ou mais argumentos normais podem estar presentes.
def write_multiple_items(file, separator, *args):
[Link]([Link](args))

Normalmente, esses argumentos variádicos estarã o no final da lista de parâ metros formais, porque eles englobam
todos os argumentos de entrada restantes, que sã o passados para a funçã o. Quaisquer parâ metros formais que ocorrem
apó s o parâ metro *args sã o argumentos ‘somente-nomeados’ , o que significa que eles só podem ser usados como
chave-valor, em vez de argumentos posicionais:
>>> def concat(*args, sep="/"):
... return [Link](args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'[Link]'

4.8.5 Desempacotando listas de argumentos

A situaçã o inversa ocorre quando os argumentos já estã o numa lista ou tupla mas ela precisa ser explodida para
invocarmos uma funçã o que requer argumentos posicionais separados. Por exemplo, a funçã o range() espera
argumentos separados, start e stop. Se os valores já estiverem juntos em uma lista ou tupla, escreva a chamada de
funçã o com o operador * para desempacotá -los da sequê ncia:
>>> list(range(3, 6)) # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args)) # call with arguments unpacked from a list
[3, 4, 5]

Da mesma forma, dicioná rios podem produzir argumentos nomeados com o operador **:
>>> def parrot(voltage, state='a stiff', action='voom'):
... print("-- This parrot wouldn't", action, end=' ')
... print("if you put", voltage, "volts through it.", end=' ')
(continua na pró xima pá gina)

32 Capítulo 4. Mais ferramentas de controle de fluxo

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

... print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin
,→' demised !

4.8.6 Expressões lambda

Pequenas funçõ es anô nimas podem ser criadas com a palavra-chave lambda. Esta funçã o retorna a soma de seus
dois argumentos: lambda a, b: a+b. As funçõ es lambda podem ser usadas sempre que objetos funçã o fo-
rem necessá rios. Eles sã o sintaticamente restritos a uma ú nica expressã o. Semanticamente, eles sã o apenas açú car
sintá tico para uma definiçã o de funçã o normal. Como definiçõ es de funçõ es aninhadas, as funçõ es lambda podem
referenciar variá veis contidas no escopo:

>>> def make_incrementor(n):

... return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

O exemplo acima usa uma expressã o lambda para retornar uma funçã o. Outro uso é passar uma pequena funçã o
como um argumento:

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> [Link](key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

4.8.7 Strings de documentação

Aqui estã o algumas convençõ es sobre o conteú do e formataçã o de strings de documentaçã o, també m conhecidas
como docstrings.
A primeira linha deve sempre ser curta, um resumo conciso do propó sito do objeto. Por brevidade, nã o deve expli-
citamente se referir ao nome ou tipo do objeto, uma vez que estas informaçõ es estã o disponíveis por outros meios
(exceto se o nome da funçã o for o pró prio verbo que descreve a finalidade da funçã o). Essa linha deve começar com
letra maiú scula e terminar com ponto.
Se existem mais linhas na string de documentaçã o, a segunda linha deve estar em branco, separando visualmente o
resumo do resto da descriçã o. As linhas seguintes devem conter um ou mais pará grafos descrevendo as convençõ es
de chamada ao objeto, seus efeitos colaterais, etc.
O analisador Python nã o remove a indentaçã o de literais string multilinha. Portanto, ferramentas que processem
strings de documentaçã o precisam lidar com isso, quando desejá vel. Existe uma convençã o para isso. A primeira
linha nã o vazia apó s a linha de sumá rio determina a indentaçã o para o resto da string de documentaçã o. (Nã o
podemos usar a primeira linha para isso porque ela em geral está adjacente à s aspas que iniciam a string, portanto
sua indentaçã o real nã o fica aparente.) Espaços em branco “equivalentes” a essa indentaçã o sã o entã o removidos do
início das demais linhas da string. Linhas com indentaçã o menor nã o devem ocorrer, mas se ocorrerem, todos os
espaços à sua esquerda sã o removidos. A equivalê ncia de espaços em branco deve ser testada apó s a expansã o das
tabulaçõ es (8 espaços, normalmente).
Eis um exemplo de uma string de documentaçã o multilinha:

4.8. Mais sobre definição de funções 33

Python Tutorial, Release 3.12.5

>>> def my_function():

... """Do nothing, but document it.
...
... No, really, it doesn't do anything.
... """
... pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.

No, really, it doesn't do anything.

4.8.8 Anotações de função

Anotaçõ es de funçã o sã o informaçõ es de metadados completamente opcionais sobre os tipos usados pelas funçõ es
definidas pelo usuá rio (veja PEP 3107 e PEP 484 para mais informaçõ es).
Anotações sã o armazenadas no atributo __annotations__ da funçã o como um dicioná rio e nã o tem nenhum
efeito em qualquer outra parte da funçã o. Anotaçõ es de parâ metro sã o definidas por dois-pontos (“:”) apó s o nome
do parâ metro, seguida por uma expressã o que quando avaliada determina o valor da anotaçã o. Anotaçõ es do tipo do
retorno sã o definidas por um literal ->, seguida por uma expressã o, entre a lista de parâ metro e os dois-pontos que
marcam o fim da instruçã o def . O exemplo a seguir possui um argumento obrigató rio, um argumento opcional e o
valor de retorno anotados:

>>> def f(ham: str, eggs: str = 'eggs') -> str:

... print("Annotations:", f.__annotations__)
... print("Arguments:", ham, eggs)
... return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

4.9 Intermezzo: estilo de codificação

Agora que está prestes a escrever có digos mais longos e complexos em Python, é um bom momento para falar sobre
estilo de codificação. A maioria das linguagens podem ser escritas (ou formatadas) em diferentes estilos; alguns sã o
mais legíveis do que outros. Tornar o seu có digo mais fá cil de ler, para os outros, é sempre uma boa ideia, e adotar
um estilo de codificaçã o agradá vel ajuda bastante.
Em Python, a PEP 8 tornou-se o guia de estilo adotado pela maioria dos projetos; promove um estilo de codificaçã o
muito legível e visualmente agradá vel. Todo desenvolvedor Python deve lê -lo em algum momento; eis os pontos mais
importantes, selecionados para você :
• Use indentaçã o com 4 espaços, e nã o use tabulaçõ es.
4 espaços sã o um bom meio termo entre indentaçã o estreita (permite maior profundidade de aninhamento) e
indentaçã o larga (mais fá cil de ler). Tabulaçõ es trazem complicaçõ es, e o melhor é nã o usar.
• Quebre as linhas de modo que nã o excedam 79 caracteres.
Isso ajuda os usuá rios com telas pequenas e torna possível abrir vá rios arquivos de có digo lado a lado em telas
maiores.
• Deixe linhas em branco para separar funçõ es e classes, e blocos de có digo dentro de funçõ es.
• Quando possível, coloque comentá rios em uma linha pró pria.
• Escreva strings de documentaçã o.

34 Capítulo 4. Mais ferramentas de controle de fluxo

 Python Tutorial, Release 3.12.5

• Use espaços ao redor de operadores e apó s vírgulas, mas nã o diretamente dentro de parê nteses, colchetes e
chaves: a = f(1, 2) + g(3, 4).
• Nomeie suas classes e funçõ es de forma consistente; a convençã o é usar MaiusculoCamelCase para
classes e minusculo_com_sublinhado para funçõ es e mé todos. Sempre use self como o nome para
o primeiro argumento dos mé todos (veja Uma primeira olhada nas classes para mais informaçõ es sobre classes
e mé todos).
• Nã o use codificaçõ es exó ticas se o seu có digo é feito para ser usado em um contexto internacional. O padrã o
do Python, UTF-8, ou mesmo ASCII puro funciona bem em qualquer caso.
• Da mesma forma, nã o use caracteres nã o-ASCII em identificadores se houver apenas a menor chance de pessoas
falando um idioma diferente ler ou manter o có digo.

4.9. Intermezzo: estilo de codificação 35

Python Tutorial, Release 3.12.5

36 Capítulo 4. Mais ferramentas de controle de fluxo

 CAPÍTULO 5

Estruturas de dados

Esse capítulo descreve algumas coisas que você já aprendeu em detalhes e adiciona algumas coisas novas també m.

5.1 Mais sobre listas

O tipo de dado lista tem ainda mais mé todos. Aqui estã o apresentados todos os mé todos de objetos do tipo lista:
[Link](x)
Adiciona um item ao fim da lista. Equivalente a a[len(a):] = [x].
[Link](iterable)
Prolonga a lista, adicionando no fim todos os elementos do argumento iterable passado como parâ metro. Equi-
valente a a[len(a):] = iterable.
[Link](i, x)
Insere um item em uma dada posiçã o. O primeiro argumento é o índice do elemento antes do qual será feita
a inserçã o, assim [Link](0, x) insere um elemento na frente da lista e [Link](len(a), x) e
equivale a [Link](x).
[Link](x)
Remove o primeiro item encontrado na lista cujo valor é igual a x. Se nã o existir valor igual, uma exceçã o
ValueError é levantada.
[Link]([i ])
Remove o item na posiçã o fornecida na lista e retorna. Se nenhum índice for especificado, [Link]() remove
e retorna o ú ltimo item da lista. Levanta um IndexError se a lista estiver vazia ou o índice estiver fora do
intervalo da lista.
[Link]()
Remove todos os itens de uma lista. Equivalente a del a[:].
[Link](x[, start [, end ]])
Devolve o índice base-zero do primeiro item cujo valor é igual a x, levantando ValueError se este valor
nã o existe.
Os argumentos opcionais start e end sã o interpretados como nas notaçõ es de fatiamento e sã o usados para
limitar a busca para uma subsequê ncia específica da lista. O índice retornado é calculado relativo ao começo
da sequê ncia inteira e nã o referente ao argumento start.

37
Python Tutorial, Release 3.12.5

[Link](x)
Devolve o nú mero de vezes em que x aparece na lista.
[Link](*, key=None, reverse=False)
Ordena os itens na lista (os argumentos podem ser usados para personalizar a ordenaçã o, veja a funçã o
sorted() para maiores explicaçõ es).
[Link]()
Inverte a ordem dos elementos na lista.
[Link]()
Devolve uma có pia rasa da lista. Equivalente a a[:].
Um exemplo que usa a maior parte dos mé todos das listas:

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']

>>> [Link]('apple')
2
>>> [Link]('tangerine')
0
>>> [Link]('banana')
3
>>> [Link]('banana', 4) # Find next banana starting at position 4
6
>>> [Link]()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> [Link]('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> [Link]()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> [Link]()
'pear'

Você pode ter percebido que mé todos como insert, remove ou sort, que apenas modificam a lista, nã o tê m
valor de retorno impresso – eles retornam o None padrã o.1 Isto é um princípio de design para todas as estruturas de
dados mutá veis em Python.
Outro aspecto que você pode notar é que nem todos os dados podem ser classificados ou comparados. Por exemplo,
[None, 'hello', 10] nã o é ordená vel porque os inteiros nã o podem ser comparados a strings e None nã o
pode ser comparado a outros tipos. Alé m disso, há alguns tipos que nã o tê m uma relaçã o de ordenaçã o definida. Por
exemplo, 3+4j < 5+7j nã o é uma comparaçã o vá lida.

5.1.1 Usando listas como pilhas

Os mé todos de lista tornam muito fá cil utilizar listas como pilhas, onde o item adicionado por ú ltimo é o primeiro a
ser recuperado (política “ú ltimo a entrar, primeiro a sair”). Para adicionar um item ao topo da pilha, use append().
Para recuperar um item do topo da pilha use pop() sem nenhum índice explícito. Por exemplo:

>>> stack = [3, 4, 5]

>>> [Link](6)
>>> [Link](7)
>>> stack
[3, 4, 5, 6, 7]
>>> [Link]()
7
(continua na pró xima pá gina)
1Outras linguagens podem retornar o objeto modificado, o que permite encadeamento de mé todos, como
d->insert("a")->remove("b")->sort();.

38 Capítulo 5. Estruturas de dados

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

>>> stack
[3, 4, 5, 6]
>>> [Link]()
6
>>> [Link]()
5
>>> stack
[3, 4]

5.1.2 Usando listas como filas

Você també m pode usar uma lista como uma fila, onde o primeiro item adicionado é o primeiro a ser recuperado
(política “primeiro a entrar, primeiro a sair”); poré m, listas nã o sã o eficientes para esta finalidade. Embora appends e
pops no final da lista sejam rá pidos, fazer inserts ou pops no início da lista é lento (porque todos os demais elementos
tê m que ser deslocados).
Para implementar uma fila, use a classe [Link] que foi projetada para permitir appends e pops
eficientes nas duas extremidades. Por exemplo:
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> [Link]("Terry") # Terry arrives
>>> [Link]("Graham") # Graham arrives
>>> [Link]() # The first to arrive now leaves
'Eric'
>>> [Link]() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

5.1.3 List Comprehensions

Compreensõ es de lista fornece uma maneira concisa de criar uma lista. Aplicaçõ es comuns sã o criar novas listas
onde cada elemento é o resultado de alguma operaçã o aplicada a cada elemento de outra sequê ncia ou iterá vel, ou
criar uma subsequê ncia de elementos que satisfaçam uma certa condiçã o. (N.d.T. o termo original em inglê s é list
comprehensions, muito utilizado no Brasil; també m se usa a abreviaçã o listcomp).
Por exemplo, suponha que queremos criar uma lista de quadrados, assim:
>>> squares = []
>>> for x in range(10):
... [Link](x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Note que isto cria (ou sobrescreve) uma variá vel chamada x que ainda existe apó s o té rmino do laço. Podemos
calcular a lista dos quadrados sem qualquer efeito colateral usando:
squares = list(map(lambda x: x**2, range(10)))

ou, de maneira equivalente:

squares = [x**2 for x in range(10)]

que é mais conciso e legível.

Um compreensã o de lista consiste de um par de colchetes contendo uma expressã o seguida de uma clá usula for, e
entã o zero ou mais clá usulas for ou if. O resultado será uma nova lista resultante da avaliaçã o da expressã o no

5.1. Mais sobre listas 39

Python Tutorial, Release 3.12.5

contexto das clá usulas for e if. Por exemplo, essa compreensã o combina os elementos de duas listas se eles forem
diferentes:

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]

[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

e é equivalente a:

>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... [Link]((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

Note como a ordem das instruçõ es for e if é a mesma em ambos os trechos.

Se a expressã o é uma tupla (ex., (x, y) no exemplo anterior), ela deve ser inserida entre parê nteses.

>>> vec = [-4, -2, 0, 2, 4]

>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [[Link]() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # create a list of 2-tuples like (number, square)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)]
File "<stdin>", line 1
[x, x**2 for x in range(6)]
^^^^^^^
SyntaxError: did you forget parentheses around the comprehension target?
>>> # flatten a list using a listcomp with two 'for'
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Compreensõ es de lista podem conter expressõ es complexas e funçõ es aninhadas:

>>> from math import pi

>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

40 Capítulo 5. Estruturas de dados

 Python Tutorial, Release 3.12.5

5.1.4 Compreensões de lista aninhadas

A expressã o inicial em uma compreensã o de lista pode ser qualquer expressã o arbitrá ria, incluindo outra compreensã o
de lista.
Observe este exemplo de uma matriz 3x4 implementada como uma lista de 3 listas de comprimento 4:
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]

A compreensã o de lista abaixo transpõ e as linhas e colunas:

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Como vimos na seçã o anterior, a compreensã o de lista interna é computada no contexto da clá usula for seguinte,
portanto o exemplo acima equivale a:
>>> transposed = []
>>> for i in range(4):
... [Link]([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

e isso, por sua vez, faz o mesmo que isto:

>>> transposed = []
>>> for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... [Link](transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Na prá tica, você deve dar preferê ncia a funçõ es embutidas em vez de instruçõ es complexas. A funçã o zip() resolve
muito bem este caso de uso:
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

Veja Desempacotando listas de argumentos para entender o uso do asterisco neste exemplo.

5.2 A instrução del

Existe uma maneira de remover um item de uma lista usando seu índice no lugar do seu valor: a instruçã o del. Ele
difere do mé todo pop() que devolve um valor. A instruçã o del pode també m ser utilizada para remover fatias de
uma lista ou limpar a lista inteira (que fizemos antes por atribuiçã o de uma lista vazia à fatia a[:]). Por exemplo:
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
(continua na pró xima pá gina)

5.2. A instrução del 41

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

del també m pode ser usado para remover totalmente uma variá vel:
>>> del a

Referenciar a variá vel a depois de sua remoçã o constitui erro (pelo menos até que seja feita uma nova atribuiçã o para
ela). Encontraremos outros usos para a instruçã o del mais tarde.

5.3 Tuplas e Sequências

Vimos que listas e strings tê m muitas propriedades em comum, como indexaçã o e operaçõ es de fatiamento. Elas sã o
dois exemplos de sequências (veja typesseq). Como Python é uma linguagem em evoluçã o, outros tipos de sequê ncias
podem ser adicionados. Existe ainda um outro tipo de sequê ncia padrã o na linguagem: a tupla.
Uma tupla consiste em uma sequê ncia de valores separados por vírgulas, por exemplo:
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
>>> t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
>>> v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

Como você pode ver no trecho acima, na saída do console as tuplas sã o sempre envolvidas por parê nteses, assim
tuplas aninhadas podem ser lidas corretamente. Na criaçã o, tuplas podem ser envolvidas ou nã o por parê nteses,
desde que o contexto nã o exija os parê nteses (como no caso da tupla dentro de uma expressã o maior). Nã o é possível
atribuir itens individuais de uma tupla, contudo é possível criar tuplas que contenham objetos mutá veis, como listas.
Apesar de tuplas serem similares a listas, elas sã o frequentemente utilizadas em situaçõ es diferentes e com propó sitos
distintos. Tuplas sã o imutáveis, e usualmente conté m uma sequê ncia heterogê nea de elementos que sã o acessados via
desempacotamento (ver a seguir nessa seçã o) ou índice (ou mesmo por um atributo no caso de namedtuples).
Listas sã o mutáveis, e seus elementos geralmente sã o homogê neos e sã o acessados iterando sobre a lista.
Um problema especial é a criaçã o de tuplas contendo 0 ou 1 itens: a sintaxe usa certos truques para acomodar estes
casos. Tuplas vazias sã o construídas por um par de parê nteses vazios; uma tupla unitá ria é construída por um ú nico
valor e uma vírgula entre parê nteses (nã o basta colocar um ú nico valor entre parê nteses). Feio, mas funciona. Por
exemplo:
>>> empty = ()
>>> singleton = 'hello', # <-- note trailing comma
>>> len(empty)
0
(continua na pró xima pá gina)

42 Capítulo 5. Estruturas de dados

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

>>> len(singleton)
1
>>> singleton
('hello',)

A instruçã o t = 12345, 54321, 'bom dia!' é um exemplo de empacotamento de tupla: os valores 12345,
54321 e 'bom dia!' sã o empacotados em uma tupla. A operaçã o inversa també m é possível:

>>> x, y, z = t

Isso é chamado, apropriadamente, de desempacotamento de sequência e funciona para qualquer sequê ncia no lado
direito. O desempacotamento de sequê ncia requer que haja tantas variá veis no lado esquerdo do sinal de igual, quanto
existem de elementos na sequê ncia. Observe que a atribuiçã o mú ltipla é , na verdade, apenas uma combinaçã o de
empacotamento de tupla e desempacotamento de sequê ncia.

5.4 Conjuntos

Python també m inclui um tipo de dados para conjuntos, chamado set. Um conjunto é uma coleçã o desordenada
de elementos, sem elementos repetidos. Usos comuns para conjuntos incluem a verificaçã o eficiente da existê ncia
de objetos e a eliminaçã o de itens duplicados. Conjuntos també m suportam operaçõ es matemá ticas como uniã o,
interseçã o, diferença e diferença simé trica.
Chaves ou a funçã o set() podem ser usados para criar conjuntos. Note: para criar um conjunto vazio você precisa
usar set(), nã o {}; este ú ltimo cria um dicioná rio vazio, uma estrutura de dados que discutiremos na pró xima
seçã o.
Uma pequena demonstraçã o:

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words

>>>
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

Da mesma forma que compreensão de listas, compreensõ es de conjunto també m sã o suportadas:

>>> a = {x for x in 'abracadabra' if x not in 'abc'}

>>> a
{'r', 'd'}

5.4. Conjuntos 43
Python Tutorial, Release 3.12.5

5.5 Dicionários

Outra estrutura de dados muito ú til embutida em Python é o dicionário, cujo tipo é dict (ver typesmapping).
Dicioná rios sã o també m chamados de “memó ria associativa” ou “vetor associativo” em outras linguagens. Diferente
de sequê ncias que sã o indexadas por inteiros, dicioná rios sã o indexados por chaves (keys), que podem ser de qualquer
tipo imutá vel (como strings e inteiros). Tuplas també m podem ser chaves se contiverem apenas strings, inteiros ou
outras tuplas. Se a tupla contiver, direta ou indiretamente, qualquer valor mutá vel, nã o poderá ser chave. Listas nã o
podem ser usadas como chaves porque podem ser modificadas internamente pela atribuiçã o em índices ou fatias, e
por mé todos como append() e extend().
Um bom modelo mental é imaginar um dicioná rio como um conjunto nã o-ordenado de pares chave:valor, onde as
chaves sã o ú nicas em uma dada instâ ncia do dicioná rio. Dicioná rios sã o delimitados por chaves: {}, e conté m uma
lista de pares chave:valor separada por vírgulas. Dessa forma també m será exibido o conteú do de um dicioná rio no
console do Python. O dicioná rio vazio é {}.
As principais operaçõ es em um dicioná rio sã o armazenar e recuperar valores a partir de chaves. També m é possível
remover um par chave:valor com o comando del. Se você armazenar um valor utilizando uma chave já presente, o
antigo valor será substituído pelo novo. Se tentar recuperar um valor usando uma chave inexistente, será gerado um
erro.
Executar list(d) em um dicioná rio devolve a lista de todas as chaves presentes no dicioná rio, na ordem de inserçã o
(se desejar ordená -las basta usar a funçã o sorted(d)). Para verificar a existê ncia de uma chave, use o operador
in.
A seguir, um exemplo de uso do dicioná rio:

>>> tel = {'jack': 4098, 'sape': 4139}

>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

O construtor dict() produz dicioná rios diretamente de sequê ncias de pares chave-valor:

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])

{'sape': 4139, 'guido': 4127, 'jack': 4098}

Alé m disso, as compreensõ es de dicioná rios podem ser usadas para criar dicioná rios a partir de expressõ es arbitrá rias
de chave e valor:

>>> {x: x**2 for x in (2, 4, 6)}

{2: 4, 4: 16, 6: 36}

Quando chaves sã o strings simples, é mais fá cil especificar os pares usando argumentos nomeados no construtor:

>>> dict(sape=4139, guido=4127, jack=4098)

{'sape': 4139, 'guido': 4127, 'jack': 4098}

44 Capítulo 5. Estruturas de dados

 Python Tutorial, Release 3.12.5

5.6 Técnicas de iteração

Ao iterar sobre dicioná rios, a chave e o valor correspondente podem ser obtidos simultaneamente usando o mé todo
items().

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}

>>> for k, v in [Link]():
... print(k, v)
...
gallahad the pure
robin the brave

Ao iterar sobre sequê ncias, a posiçã o e o valor correspondente podem ser obtidos simultaneamente usando a funçã o
enumerate().

>>> for i, v in enumerate(['tic', 'tac', 'toe']):

... print(i, v)
...
0 tic
1 tac
2 toe

Para percorrer duas ou mais sequê ncias ao mesmo tempo, as entradas podem ser pareadas com a funçã o zip().

>>> questions = ['name', 'quest', 'favorite color']

>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.

Para percorrer uma sequê ncia em ordem inversa, chame a funçã o reversed() com a sequê ncia na ordem original.

>>> for i in reversed(range(1, 10, 2)):

... print(i)
...
9
7
5
3
1

Para percorrer uma sequê ncia de maneira ordenada, use a funçã o sorted(), que retorna uma lista ordenada com
os itens, mantendo a sequê ncia original inalterada.

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> for i in sorted(basket):
... print(i)
...
apple
apple
banana
orange
orange
pear

Usar set() em uma sequê ncia elimina elementos duplicados. O uso de sorted() em combinaçã o com set()
sobre uma sequê ncia é uma maneira idiomá tica de fazer um loop sobre elementos exclusivos da sequê ncia na ordem
de classificaçã o.

5.6. Técnicas de iteração 45

Python Tutorial, Release 3.12.5

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear

Às vezes é tentador alterar uma lista enquanto você itera sobre ela; poré m, costuma ser mais simples e seguro criar
uma nova lista.

>>> import math

>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
... if not [Link](value):
... filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]

5.7 Mais sobre condições

As condiçõ es de controle usadas nas instruçõ es while e if podem conter quaisquer operadores, nã o apenas com-
paraçõ es.
Os operadores de comparaçã o in e not in fazem testes de inclusã o que determinam se um valor está (ou nã o está )
em um contê iner. Os operadores is e is not comparam se dois objetos sã o realmente o mesmo objeto. Todos
os operadores de comparaçã o possuem a mesma prioridade, que é menor que a prioridade de todos os operadores
numé ricos.
Comparaçõ es podem ser encadeadas: Por exemplo a < b == c testa se a é menor que b e també m se b é igual
a c.
Comparaçõ es podem ser combinadas atravé s de operadores booleanos and e or, e o resultado de uma comparaçã o
(ou de qualquer outra expressã o), pode ter seu valor booleano negado atravé s de not. Estes possuem menor prio-
ridade que os demais operadores de comparaçã o. Entre eles, not é o de maior prioridade e or o de menor. Dessa
forma, a condiçã o A and not B or C é equivalente a (A and (not B)) or C. Naturalmente, parê nteses
podem ser usados para expressar o agrupamento desejado.
Os operadores booleanos and e or sã o operadores curto-circuito: seus argumentos sã o avaliados da esquerda para a
direita, e a avaliaçã o encerra quando o resultado é determinado. Por exemplo, se A e C sã o expressõ es verdadeiras,
mas B é falsa, entã o A and B and C nã o chega a avaliar a expressã o C. Em geral, quando usado sobre valores
gené ricos e nã o como booleanos, o valor do resultado de um operador curto-circuito é o ú ltimo valor avaliado na
expressã o.
É possível atribuir o resultado de uma comparaçã o ou outra expressã o booleana para uma variá vel. Por exemplo:

>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'

>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'

Observe que no Python, ao contrá rio de C, a atribuiçã o dentro de expressõ es deve ser feita explicitamente com o
operador morsa :=. Isso evita uma classe comum de problemas encontrados nos programas C: digitar = em uma
expressã o quando == era o planejado.

46 Capítulo 5. Estruturas de dados

 Python Tutorial, Release 3.12.5

5.8 Comparando sequências e outros tipos

Objetos sequê ncia podem ser comparados com outros objetos sequê ncia, desde que o tipo das sequê ncias seja o
mesmo. A comparaçã o utiliza a ordem lexicográ fica: primeiramente os dois primeiros itens sã o comparados, e se
diferirem isto determinará o resultado da comparaçã o, caso contrá rio os pró ximos dois itens serã o comparados, e
assim por diante até que se tenha exaurido alguma das sequê ncias. Se em uma comparaçã o de itens, os mesmos
forem també m sequê ncias (aninhadas), entã o é disparada recursivamente outra comparaçã o lexicográ fica. Se todos
os itens da sequê ncia forem iguais, entã o as sequê ncias sã o ditas iguais. Se uma das sequê ncias é uma subsequê ncia
da outra, entã o a subsequê ncia é a menor. A comparaçã o lexicográ fica de strings utiliza codificaçã o Unicode para
definir a ordenaçã o. Alguns exemplos de comparaçõ es entre sequê ncias do mesmo tipo:

(1, 2, 3) < (1, 2, 4)

[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)

Note que comparar objetos de tipos diferentes com < ou > é permitido desde que os objetos possuam os mé todos
de comparaçã o apropriados. Por exemplo, tipos numé ricos mistos sã o comparados de acordo com os seus valo-
res numé ricos, portanto 0 é igual a 0.0, etc. Em caso contrá rio, ao invé s de fornecer uma ordenaçã o arbitrá ria, o
interpretador levantará um TypeError.

5.8. Comparando sequências e outros tipos 47

Python Tutorial, Release 3.12.5

48 Capítulo 5. Estruturas de dados

 CAPÍTULO 6

Módulos

Ao sair e entrar de novo no interpretador Python, as definiçõ es anteriores (funçõ es e variá veis) sã o perdidas. Portanto,
se quiser escrever um programa maior, será mais eficiente usar um editor de texto para preparar as entradas para o
interpretador, e executá -lo usando o arquivo como entrada. Isso é conhecido como criar um script. Se o programa
se torna ainda maior, é uma boa prá tica dividi-lo em arquivos menores, para facilitar a manutençã o. També m é
preferível usar um arquivo separado para uma funçã o que você escreveria em vá rios programas diferentes, para nã o
copiar a definiçã o de funçã o em cada um deles.
Para permitir isso, Python tem uma maneira de colocar as definiçõ es em um arquivo e entã o usá -las em um script ou
em uma execuçã o interativa do interpretador. Tal arquivo é chamado de módulo; definiçõ es de um mó dulo podem
ser importadas para outros mó dulos, ou para o mó dulo principal (a coleçã o de variá veis a que você tem acesso num
script executado como um programa e no modo calculadora).
Um mó dulo é um arquivo contendo definiçõ es e instruçõ es Python. O nome do arquivo é o nome do mó dulo acrescido
do sufixo .py. Dentro de um mó dulo, o nome do mó dulo (como uma string) está disponível como o valor da variá vel
global __name__. Por exemplo, use seu editor de texto favorito para criar um arquivo chamado [Link] no
diretó rio atual com o seguinte conteú do:

# Fibonacci numbers module

def fib(n): # write Fibonacci series up to n

a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()

def fib2(n): # return Fibonacci series up to n

result = []
a, b = 0, 1
while a < n:
[Link](a)
a, b = b, a+b
return result

Agora, entre no interpretador Python e importe esse mó dulo com o seguinte comando:

>>> import fibo

Isso nã o adiciona os nomes das funçõ es definidas em fibo diretamente ao espaço de nomes atual (veja Escopos e

49
Python Tutorial, Release 3.12.5

espaços de nomes do Python para mais detalhes); isso adiciona somente o nome do mó dulo fibo. Usando o nome
do mó dulo você pode acessar as funçõ es:

>>> [Link](1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'

Se você pretende usar uma funçã o muitas vezes, você pode atribui-lá a um nome local:

>>> fib = [Link]

>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

6.1 Mais sobre módulos

Um mó dulo pode conter tanto instruçõ es executá veis quanto definiçõ es de funçõ es e classes. Essas instruçõ es servem
para inicializar o mó dulo. Eles sã o executados somente na primeira vez que o mó dulo é encontrado em uma instruçã o
de importaçã o.1 (També m rodam se o arquivo é executado como um script.)
Cada mó dulo tem seu pró prio espaço de nomes privado, que é usado como espaço de nomes global para todas
as funçõ es definidas no mó dulo. Assim, o autor de um mó dulo pode usar variá veis globais no seu mó dulo sem
se preocupar com conflitos acidentais com as variá veis globais do usuá rio. Por outro lado, se você precisar usar
uma variá vel global de um mó dulo, poderá fazê -lo com a mesma notaçã o usada para se referir à s suas funçõ es,
[Link].
Mó dulos podem importar outros mó dulos. É costume, poré m nã o obrigató rio, colocar todas as instruçõ es import
no início do mó dulo (ou script , se preferir). As definiçõ es do mó dulo importado, se colocados no nível de um mó dulo
(fora de quaisquer funçõ es ou classes), elas sã o adicionadas a espaço de nomes global da mó dulo.
Existe uma variante da instruçã o import que importa definiçõ es de um mó dulo diretamente para o espaço de nomes
do mó dulo importador. Por exemplo:

>>> from fibo import fib, fib2

>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Isso nã o coloca o nome do mó dulo de onde foram feitas as importaçõ es no espaço de nomes local (assim, no exemplo,
fibo nã o está definido).
Existe ainda uma variante que importa todos os nomes definidos em um mó dulo:

>>> from fibo import *

>>> fib(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Isso importa todos as declaraçõ es de nomes, exceto aqueles que iniciam com um sublinhado (_). Na maioria dos
casos, programadores Python nã o usam esta facilidade porque ela introduz um conjunto desconhecido de nomes no
ambiente, podendo esconder outros nomes previamente definidos.
Note que, em geral, a prá tica do import * de um mó dulo ou pacote é desaprovada, uma vez que muitas vezes
dificulta a leitura do có digo. Contudo, é aceitá vel para diminuir a digitaçã o em sessõ es interativas.
Se o nome do mó dulo é seguido pela palavra-chave as, o nome a seguir é vinculado diretamente ao mó dulo impor-
tado.
1 [#] Na verdade, definiçõ es de funçõ es també m sã o ‘instruçõ es’ que sã o ‘executados’; a execuçã o da definiçã o de uma funçã o adiciona o nome

da funçã o no espaço de nomes global do mó dulo.

50 Capítulo 6. Módulos
 Python Tutorial, Release 3.12.5

>>> import fibo as fib

>>> [Link](500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Isto efetivamente importa o mó dulo, da mesma maneira que import fibo fará , com a ú nica diferença de estar
disponível com o nome fib.
També m pode ser utilizado com a palavra-chave from, com efeitos similares:

>>> from fibo import fib as fibonacci

>>> fibonacci(500)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Nota

For efficiency reasons, each module is only imported once per interpreter session. Therefore, if you change
your modules, you must restart the interpreter – or, if it’s just one module you want to test interactively, use
[Link](), e.g. import importlib; [Link](modulename).

6.1.1 Executando módulos como scripts

Quando você rodar um mó dulo Python com

python [Link] <arguments>

o có digo no mó dulo será executado, da mesma forma que quando é importado, mas com a variá vel __name__ com
valor "__main__". Isto significa que adicionando este có digo ao final do seu mó dulo:

if __name__ == "__main__":
import sys
fib(int([Link][1]))

você pode tornar o arquivo utilizá vel tanto como script quanto como um mó dulo importá vel, porque o có digo que
analisa a linha de comando só roda se o mó dulo é executado como arquivo “principal”:

$ python [Link] 50
0 1 1 2 3 5 8 13 21 34

Se o mó dulo é importado, o có digo nã o é executado:

>>> import fibo

>>>

Isso é frequentemente usado para fornecer uma interface de usuá rio conveniente para um mó dulo, ou para realizar
testes (rodando o mó dulo como um script executa um conjunto de testes).

6.1.2 O caminho de busca dos módulos

Quando um mó dulo chamado spam é importado, o interpretador procura um mó dulo embutido com este nome.
Estes nomes de mó dulo sã o listados em sys.builtin_module_names. Se nã o encontra, procura um arquivo
chamado [Link] em uma lista de diretó rios incluídos na variá vel [Link]. A [Link] é inicializada com
estes locais:
• O diretó rio que conté m o script importador (ou o diretó rio atual quando nenhum arquivo é especificado).
• A variá vel de ambiente PYTHONPATH (uma lista de nomes de diretó rios, com a mesma sintaxe da variá vel de
ambiente PATH).

6.1. Mais sobre módulos 51

Python Tutorial, Release 3.12.5

• O padrã o dependente da instalaçã o (por convençã o, incluindo um diretó rio site-packages, tratado pelo
mó dulo site).
Mais detalhes em sys-path-init.

Nota

Nos sistemas de arquivos que suportam links simbó licos, o diretó rio contendo o script de entrada é resultante
do diretó rio apontado pelo link simbó lico. Em outras palavras o diretó rio que conté m o link simbó lico não é
adicionado ao caminho de busca de mó dulos.

Apó s a inicializaçã o, programas Python podem modificar [Link]. O diretó rio que conté m o script sendo execu-
tado é colocado no início da lista de caminhos, à frente do caminho da biblioteca padrã o. Isto significa que mó dulos
nesse diretó rio serã o carregados, no lugar de mó dulos com o mesmo nome na biblioteca padrã o. Isso costuma ser
um erro, a menos que seja intencional. Veja a seçã o Módulos padrões para mais informaçõ es.

6.1.3 Arquivos Python “compilados”

Para acelerar o carregamento de mó dulos, o Python guarda versõ es compiladas de cada mó dulo no diretó rio
__pycache__ com o nome [Link]ã[Link], onde a versã o corresponde ao formato do arquivo com-
pilado; geralmente contê m o nú mero da versã o Python utilizada. Por exemplo, no CPython release 3.3 a versã o
compilada de [Link] será guardada como __pycache__/[Link]. Esta convençã o de no-
mes permite a coexistê ncia de mó dulos compilados de diferentes releases e versõ es de Python.
O Python verifica a data de modificaçã o do arquivo fonte mediante a versã o compilada, para ver se está desatualizada
e precisa ser recompilada. É um processo completamente automá tico. Alé m disso, os mó dulos compilados sã o
independentes de plataforma, portanto a mesma biblioteca pode ser compartilhada entre sistemas de arquiteturas
diferentes.
O Python nã o verifica as versõ es compiladas em duas circunstâ ncias. Primeiro, sempre recompila e nã o armazena
o resultado para mó dulos carregados diretamente da linha de comando. Segundo, nã o verifica se nã o houver um
mó dulo fonte. Para suportar uma distribuiçã o sem fontes (somente as versõ es compiladas), o mó dulo compilado
deve estar no diretó rio de fontes, e nã o deve haver um mó dulo fonte.
Algumas dicas para especialistas:
• Você pode usar as opçõ es -O ou -OO no comando Python para reduzir o tamanho de um mó dulo compilado.
A opçã o -O remove as instruçõ es assert, e a opçã o -OO remove, alé m das instruçõ es assert, as strings de
documentaçõ es. Como alguns programas podem contar com essa disponibilidade, só use essa opçã o se souber
o que está fazendo. Mó dulos “otimizados” tem uma marcaçã o opt- e sã o geralmente de menor tamanho.
Futuros releases podem mudar os efeitos da otimizaçã o.
• Um programa nã o roda mais rá pido quando é lido de um arquivo .pyc do que quando lido de um arquivo
.py; a ú nica coisa que é mais rá pida com arquivos .pyc é sua velocidade de carregamento.
• O mó dulo compileall pode criar arquivos .pyc para todos os mó dulos de um diretó rio.
• Há mais detalhes desse processo, incluindo um fluxograma de decisõ es, no PEP 3147.

52 Capítulo 6. Módulos
 Python Tutorial, Release 3.12.5

6.2 Módulos padrões

O Python traz uma biblioteca padrã o de mó dulos, descrita em um documento em separado, a Referê ncia da Biblioteca
Python (doravante “Referê ncia da Biblioteca”). Alguns mó dulos estã o embutidos no interpretador; estes possibilitam
acesso a operaçõ es que nã o sã o parte do nú cleo da linguagem, mas estã o no interpretador seja por eficiê ncia ou para
permitir o acesso a chamadas do sistema operacional. O conjunto destes mó dulos é uma opçã o de configuraçã o que
depende també m da plataforma utilizada. Por exemplo, o mó dulo winreg só está disponível em sistemas Windows.
Existe um mó dulo que requer especial atençã o: sys, que é embutido em qualquer interpretador Python. As variá veis
sys.ps1 e sys.ps2 definem as strings utilizadas como prompt primá rio e secundá rio:

>>> import sys

>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>

Essas variá veis só estã o definidas se o interpretador está em modo interativo.
A variá vel [Link] conté m uma lista de strings que determina os caminhos de busca de mó dulos conhecidos pelo
interpretador. Ela é inicializada para um caminho padrã o, determinado pela variá vel de ambiente PYTHONPATH,
ou por um valor padrã o embutido, se PYTHONPATH nã o estiver definida. Você pode modificá -la com as operaçõ es
típicas de lista, por exemplo:

>>> import sys

>>> [Link]('/ufs/guido/lib/python')

6.3 A função dir()

A funçã o embutida dir() é usada para descobrir quais nomes sã o definidos por um mó dulo. Ela devolve uma lista
ordenada de strings:

>>> import fibo, sys

>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)
['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',
'__interactivehook__', '__loader__', '__name__', '__package__', '__spec__',
'__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',
'_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',
'_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',
'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',
'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',
'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info',
'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',
'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth',
'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',
'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',
'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',
'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',
'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',
'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'pycache_prefix',
'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'setdlopenflags',
'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr',
(continua na pró xima pá gina)

6.2. Módulos padrões 53

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', 'version_info',
'warnoptions']

Sem argumentos, dir() lista os nomes atualmente definidos:

>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = [Link]
>>> dir()
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']

Observe que ela lista todo tipo de nomes: variá veis, mó dulos, funçõ es, etc.
dir() nã o lista os nomes de variá veis e funçõ es embutidas. Esta lista está disponível no mó dulo padrã o builtins:

>>> import builtins

>>> dir(builtins)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',
'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',
'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',
'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
'FileExistsError', 'FileNotFoundError', 'FloatingPointError',
'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',
'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',
'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',
'MemoryError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented',
'NotImplementedError', 'OSError', 'OverflowError',
'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',
'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',
'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',
'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',
'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',
'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',
'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',
'__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',
'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',
'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',
'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',
'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',
'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',
'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',
'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property',
'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',
'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars',
'zip']

6.4 Pacotes

Os pacotes sã o uma maneira de estruturar o “espaço de nomes” dos mó dulos Python, usando “nomes de mó dulo com
pontos”. Por exemplo, o nome do mó dulo A.B designa um submó dulo chamado B, em um pacote chamado A. Assim
como o uso de mó dulos evita que os autores de mó dulos diferentes tenham que se preocupar com nomes de variá veis
globais, o uso de nomes de mó dulos com pontos evita que os autores de pacotes com muitos mó dulos, como NumPy
ou Pillow, tenham que se preocupar com os nomes dos mó dulos uns dos outros.
Suponha que você queira projetar uma coleçã o de mó dulos (um “pacote”) para o gerenciamento uniforme de arquivos
de som. Existem muitos formatos diferentes (normalmente identificados pela extensã o do nome de arquivo, por
exemplo .wav, .aiff, .au), de forma que você pode precisar criar e manter uma crescente coleçã o de mó dulos de
conversã o entre formatos. Ainda podem existir muitas operaçõ es diferentes, passíveis de aplicaçã o sobre os arquivos

54 Capítulo 6. Módulos
 Python Tutorial, Release 3.12.5

de som (mixagem, eco, equalizaçã o, efeito stereo artificial). Logo, possivelmente você també m estará escrevendo
uma coleçã o sempre crescente de mó dulos para aplicar estas operaçõ es. Eis uma possível estrutura para o seu pacote
(expressa em termos de um sistema de arquivos hierá rquico):

sound/ Top-level package

__init__.py Initialize the sound package
formats/ Subpackage for file format conversions
__init__.py
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
...
effects/ Subpackage for sound effects
__init__.py
[Link]
[Link]
[Link]
...
filters/ Subpackage for filters
__init__.py
[Link]
[Link]
[Link]
...

Ao importar esse pacote, Python busca pelo subdiretó rio com mesmo nome, nos diretó rios listados em [Link].
Os arquivos __init__.py sã o necessá rios para que o Python trate diretó rios contendo o arquivo como pacotes
(a menos que se esteja usando um pacote de espaço de nomes, um recurso relativamente avançado). Isso impede
que diretó rios com um nome comum, como string, ocultem, involuntariamente, mó dulos vá lidos que ocorrem
posteriormente no caminho de busca do mó dulo. No caso mais simples, __init__.py pode ser apenas um arquivo
vazio, mas pode també m executar có digo de inicializaçã o do pacote, ou configurar a variá vel __all__, descrita mais
adiante.
Usuá rios do pacote podem importar mó dulos individuais, por exemplo:

import [Link]

Isso carrega o submó dulo [Link]. Ele deve ser referenciado com seu nome completo, como em:

[Link](input, output, delay=0.7, atten=4)

Uma maneira alternativa para a importaçã o desse mó dulo é :

from [Link] import echo

Isso carrega o submó dulo echo sem necessidade de mencionar o prefixo do pacote no momento da utilizaçã o, assim:

[Link](input, output, delay=0.7, atten=4)

També m é possível importar diretamente uma ú nica variá vel ou funçã o:

from [Link] import echofilter

Novamente, isso carrega o submó dulo echo, mas a funçã o echofilter() está acessível diretamente sem prefixo:

echofilter(input, output, delay=0.7, atten=4)

Observe que ao utilizar from pacote import item, o item pode ser um subpacote, submó dulo, classe, funçã o
ou variá vel. A instruçã o import primeiro testa se o item está definido no pacote, senã o presume que é um mó dulo

6.4. Pacotes 55
Python Tutorial, Release 3.12.5

e tenta carregá -lo. Se falhar em encontrar o mó dulo, uma exceçã o ImportError é levantada.
Em oposiçã o, em uma construçã o como import [Link], cada item, com exceçã o do
ú ltimo, deve ser um pacote. O ú ltimo pode ser també m um pacote ou mó dulo, mas nunca uma classe, funçã o ou
variá vel contida em um mó dulo.

6.4.1 Importando * de um pacote

Agora, o que acontece quando um usuá rio escreve from [Link] import * ? Idealmente, poderia
se esperar que este comando vasculhasse o sistema de arquivos, encontrasse todos os submó dulos presentes no pacote,
e os importasse. Isso poderia demorar muito e a importaçã o de submó dulos pode ocasionar efeitos colaterais, que
somente deveriam ocorrer quando o submó dulo é explicitamente importado.
A ú nica soluçã o é o autor do pacote fornecer um índice explícito do pacote. A instruçã o import usa a seguinte
convençã o: se o arquivo __init__.py do pacote define uma lista chamada __all__, entã o esta lista indica
os nomes dos mó dulos a serem importados quando a instruçã o from pacote import * é acionada. Fica a
cargo do autor do pacote manter esta lista atualizada, inclusive fica a seu crité rio excluir inteiramente o suporte a
importaçã o direta de todo o pacote atravé s de from pacote import *. Por exemplo, o arquivo sounds/
effects/__init__.py poderia conter apenas:

__all__ = ["echo", "surround", "reverse"]

Isso significaria que from [Link] import * importaria os trê s submó dulos nomeados do pacote
[Link].
Esteja ciente de que os submó dulos podem ficar sobrepostos por nomes definidos localmente. Por exemplo, se você
adicionou uma funçã o reverse ao arquivo sound/effects/__init__.py, usar from [Link]
import * só importaria os dois submó dulos echo e surround, mas não o submó dulo reverse, porque ele
fica sobreposto pela funçã o reverse definida localmente:

__all__ = [
"echo", # refers to the '[Link]' file
"surround", # refers to the '[Link]' file
"reverse", # !!! refers to the 'reverse' function now !!!
]

def reverse(msg: str): # <-- this name shadows the '[Link]' submodule
return msg[::-1] # in the case of a 'from [Link] import *'

Se __all__ nã o estiver definido, a instruçã o from [Link] import * nã o importa todos os submó -
dulos do pacote [Link] no espaço de nomes atual. Há apenas garantia que o pacote [Link]
foi importado (possivelmente executando qualquer có digo de inicializaçã o em __init__.py) juntamente com os
nomes definidos no pacote. Isso inclui todo nome definido em __init__.py bem como em qualquer submó dulo
importado a partir deste. També m inclui quaisquer submó dulos do pacote que tenham sido carregados explicitamente
por instruçõ es import anteriores. Considere o có digo abaixo:

import [Link]
import [Link]
from [Link] import *

Nesse exemplo, os mó dulos echo e surround sã o importados no espaço de nomes atual, no momento em que a
instruçã o from...import é executada, pois estã o definidos no pacote [Link]. (Isso també m funci-
ona quando __all__ estiver definida.)
Apesar de que certos mó dulos sã o projetados para exportar apenas nomes conforme algum crité rio quando se faz
import *, ainda assim essa sintaxe é considerada uma prá tica ruim em có digo de produçã o.
Lembre-se, nã o há nada errado em usar from pacote import submodulo_especifico! De fato, essa
é a notaçã o recomendada, a menos que o mó dulo importado necessite usar submó dulos com o mesmo nome, de
diferentes pacotes.

56 Capítulo 6. Módulos
 Python Tutorial, Release 3.12.5

6.4.2 Referências em um mesmo pacote

Quando pacotes sã o estruturados em subpacotes (como no pacote sound do exemplo), pode-se usar a sintaxe de
importaçõ es absolutas para se referir aos submó dulos de pacotes irmã os (o que na prá tica é uma forma de fazer
um import relativo, a partir da base do pacote). Por exemplo, se o mó dulo [Link] precisa
usar o mó dulo echo do pacote [Link], é preciso importá -lo com from [Link] import
echo.
També m é possível escrever imports relativos, com a forma from module import name. Esses imports usam
pontos para indicar o pacote pai e o atual, envolvidos no import relativo. Do mó dulo surround, por exemplo,
pode-se usar:

from . import echo

from .. import formats
from ..filters import equalizer

Note que imports relativos sã o baseados no nome do mó dulo atual. Uma vez que o nome do mó dulo principal é
sempre "__main__", mó dulos destinados ao uso como mó dulo principal de um aplicativo Python devem sempre
usar imports absolutos.

6.4.3 Pacotes em múltiplos diretórios

Pacotes possuem mais um atributo especial, __path__. Inicializado como uma lista contendo o nome do diretó rio
onde está o arquivo __init__.py do pacote, antes do có digo naquele arquivo ser executado. Esta variá vel pode
ser modificada; isso afeta a busca futura de mó dulos e subpacotes contidos no pacote.
Apesar de nã o ser muito usado, esse mecanismo permite estender o conjunto de mó dulos encontrados em um pacote.

6.4. Pacotes 57
Python Tutorial, Release 3.12.5

58 Capítulo 6. Módulos
 CAPÍTULO 7

Entrada e Saída

Existem vá rias maneiras de apresentar a saída de um programa; os dados podem ser exibidos em forma legível para
seres humanos, ou escritos em arquivos para uso posterior. Este capítulo apresentará algumas das possibilidades.

7.1 Refinando a formatação de saída

Até agora vimos duas maneiras de exibir valores: expressões e a funçã o print(). (Uma outra maneira é utilizar o
mé todo write() de objetos do tipo arquivo; o arquivo saída padrã o pode ser referenciado como [Link].
Veja a Referê ncia da Biblioteca Python para mais informaçõ es sobre isso.)
Muitas vezes se deseja mais controle sobre a formataçã o da saída do que simplesmente exibir valores separados por
espaço. Existem vá rias maneiras de formatar a saída.
• Para usar strings literais formatadas, comece uma string com f ou F, antes de abrir as aspas ou aspas triplas.
Dentro dessa string, pode-se escrever uma expressã o Python entre caracteres { e }, que podem se referir a
variá veis, ou valores literais.

>>> year = 2016

>>> event = 'Referendum'
>>> f'Results of the {year} {event}'
'Results of the 2016 Referendum'

• The [Link]() method of strings requires more manual effort. You’ll still use { and } to mark where
a variable will be substituted and can provide detailed formatting directives, but you’ll also need to provide the
information to be formatted. In the following code block there are two examples of how to format variables:

>>> yes_votes = 42_572_654

>>> total_votes = 85_705_149
>>> percentage = yes_votes / total_votes
>>> '{:-9} YES votes {:2.2%}'.format(yes_votes, percentage)
' 42572654 YES votes 49.67%'

Notice how the yes_votes are padded with spaces and a negative sign only for negative numbers. The
example also prints percentage multiplied by 100, with 2 decimal places and followed by a percent sign
(see formatspec for details).
• Finalmente, pode-se fazer todo o tratamento da saída usando as operaçõ es de fatiamento e concatenaçã o de
strings para criar qualquer layout que se possa imaginar. O tipo string possui alguns mé todos que realizam

59
Python Tutorial, Release 3.12.5

operaçõ es ú teis para preenchimento de strings para uma determinada largura de coluna.
Quando nã o é necessá rio sofisticar a saída, mas apenas exibir algumas variá veis com propó sito de depuraçã o, pode-se
converter qualquer valor para uma string com as funçõ es repr() ou str().
A funçã o str() serve para retornar representaçõ es de valores que sejam legíveis para as pessoas, enquanto repr()
é para gerar representaçõ es que o interpretador Python consegue ler (ou levantará uma exceçã o SyntaxError,
se nã o houver sintaxe equivalente). Para objetos que nã o tê m uma representaçã o adequada para consumo humano,
str() devolve o mesmo valor que repr(). Muitos valores, tal como nú meros ou estruturas, como listas e dicio-
ná rios, tê m a mesma representaçã o usando quaisquer das funçõ es. Strings, em particular, tê m duas representaçõ es
distintas.
Alguns exemplos:

>>> s = 'Hello, world.'

>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print(s)
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
>>> hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> # The argument to repr() may be any Python object:
>>> repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"

O mó dulo string conté m uma classe Template que oferece ainda outra maneira de substituir valores em strings,
usando espaços reservados como $x e substituindo-os por valores de um dicioná rio, mas oferece muito menos con-
trole da formataçã o.

7.1.1 Strings literais formatadas

Strings literais formatadas (també m chamadas f-strings, para abreviar) permite que se inclua o valor de expressõ es
Python dentro de uma string, prefixando-a com f ou F e escrevendo expressõ es na forma {expression}.
Um especificador opcional de formato pode ser incluído apó s a expressã o. Isso permite maior controle sobre como
o valor é formatado. O exemplo a seguir arredonda pi para trê s casas decimais:

>>> import math

>>> print(f'The value of pi is approximately {[Link]:.3f}.')
The value of pi is approximately 3.142.

Passando um inteiro apó s o ':' fará com que o campo tenha um nú mero mínimo de caracteres de largura. Isso é
ú til para alinhar colunas.

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}

>>> for name, phone in [Link]():
... print(f'{name:10} ==> {phone:10d}')
...
Sjoerd ==> 4127
Jack ==> 4098
Dcab ==> 7678

60 Capítulo 7. Entrada e Saída

 Python Tutorial, Release 3.12.5

Outros modificadores podem ser usados para converter o valor antes de ser formatado. '!a' aplica a funçã o
ascii(), '!s' aplica a funçã o str() e '!r' aplica a funçã o repr()

>>> animals = 'eels'

>>> print(f'My hovercraft is full of {animals}.')
My hovercraft is full of eels.
>>> print(f'My hovercraft is full of {animals!r}.')
My hovercraft is full of 'eels'.

O especificador = pode ser usado para expandir uma expressã o para o texto da expressã o, um sinal de igual e, entã o,
a representaçã o da expressã o avaliada:

>>> bugs = 'roaches'

>>> count = 13
>>> area = 'living room'
>>> print(f'Debugging {bugs=} {count=} {area=}')
Debugging bugs='roaches' count=13 area='living room'

Veja expressõ es autodocumentadas para mais informaçõ es sobre o especificador =. Para obter uma referê ncia sobre
essas especificaçõ es de formato, consulte o guia de referê ncia para a formatspec.

7.1.2 O método format()

Um uso bá sico do mé todo [Link]() tem esta forma:

>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))

We are the knights who say "Ni!"

As chaves e seus conteú dos (chamados campos de formataçã o) sã o substituídos pelos objetos passados para o mé todo
[Link](). Um nú mero nas chaves pode ser usado para referenciar a posiçã o do objeto passado no mé todo
[Link]().

>>> print('{0} and {1}'.format('spam', 'eggs'))

spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam

Se argumentos nomeados sã o passados para o mé todo [Link](), seus valores serã o referenciados usando o
nome do argumento:

>>> print('This {food} is {adjective}.'.format(

... food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.

Argumentos posicionais e nomeados podem ser combinados à vontade:

>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',

... other='Georg'))
The story of Bill, Manfred, and Georg.

Se uma string de formataçã o é muito longa, e nã o se deseja quebrá -la, pode ser bom fazer referê ncia aos valores a
serem formatados por nome, em vez de posiçã o. Isto pode ser feito passando um dicioná rio usando colchetes '[]'
para acessar as chaves.

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}

>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
... 'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Isto també m pode ser feito passando o dicioná rio table como argumentos nomeados com a notaçã o **.

7.1. Refinando a formatação de saída 61

Python Tutorial, Release 3.12.5

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}

>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

This is particularly useful in combination with the built-in function vars(), which returns a dictionary containing
all local variables:

>>> table = {k: str(v) for k, v in vars().items()}

>>> message = " ".join([f'{k}: ' + '{' + k +'};' for k in [Link]()])
>>> print([Link](**table))
__name__: __main__; __doc__: None; __package__: None; __loader__: ...

Como exemplo, as linhas seguintes produzem um conjunto de colunas alinhadas, com alguns inteiros e seus quadrados
e cubos:

>>> for x in range(1, 11):

... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

Para uma visã o completa da formataçã o de strings com [Link](), veja a seçã o formatstrings.

7.1.3 Formatação manual de string

Aqui está a mesma tabela de quadrados e cubos, formatados manualmente:

>>> for x in range(1, 11):

... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... # Note use of 'end' on previous line
... print(repr(x*x*x).rjust(4))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

(Note que o espaço entre cada coluna foi adicionado pela forma que a funçã o print() funciona: sempre adiciona
espaços entre seus argumentos.)
O mé todo [Link]() justifica uma string à direita, num campo de tamanho definido, acrescentando espaços à
esquerda. De forma similar, os mé todos [Link](), justifica à esquerda, e [Link](), para centralizar.
Esses mé todos nã o escrevem nada, apenas retornam uma nova string. Se a string de entrada é muito longa, os
mé todos nã o truncarã o a saída, e retornarã o a mesma string, sem mudança; isso vai atrapalhar o layout da coluna,
mas geralmente é melhor do que a alternativa, que estaria distorcendo o valor. (Se realmente quiser truncar, sempre
se pode adicionar uma operaçã o de fatiamento, como em [Link](n)[:n].)

62 Capítulo 7. Entrada e Saída

 Python Tutorial, Release 3.12.5

Existe ainda o mé todo [Link]() que preenche uma string numé rica com zeros à esquerda, e sabe lidar com
sinais positivos e negativos:

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

7.1.4 Formatação de strings à moda antiga

The % operator (modulo) can also be used for string formatting. Given format % values (where format is a
string), % conversion specifications in format are replaced with zero or more elements of values. This operation is
commonly known as string interpolation. For example:

>>> import math

>>> print('The value of pi is approximately %5.3f.' % [Link])
The value of pi is approximately 3.142.

Mais informaçã o pode ser encontrada na seçã o old-string-formatting.

7.2 Leitura e escrita de arquivos

open() retorna um objeto arquivo, e é mais utilizado com dois argumentos posicionais e um argumento nomeado:
open(filename, mode, encoding=None)

>>> f = open('workfile', 'w', encoding="utf-8")

O primeiro argumento é uma string contendo o nome do arquivo. O segundo argumento é outra string, contendo
alguns caracteres que descrevem o modo como o arquivo será usado. modo pode ser 'r' quando o arquivo será
apenas lido, 'w' para escrever (se o arquivo já existir seu conteú do pré vio será apagado), e 'a' para abrir o arquivo
para adiçã o; qualquer escrita será adicionada ao final do arquivo. A opçã o 'r+' abre o arquivo tanto para leitura
como para escrita. O argumento modo é opcional, em caso de omissã o será presumido 'r'.
Normalmente, arquivos sã o abertos no modo texto, o que significa que você lê strings de e para o arquivo, o qual
está em um codificaçã o específica. Se a codificação nã o for especificada, o padrã o irá depender da plataforma (veja
open()). Como o UTF-8 é o padrã o mais moderno, encoding="utf-8" é recomendado a nã o ser que você
precise utilizar uma codificação diferente. Adicionando 'b' ao modo irá abrir o o arquivo em modo binário. Dados
no modo biná rio sã o lidos e escritos como objetos bytes. Você nã o pode especificar a codificação quando estiver
abrindo os arquivos em modo biná rio.
Em modo texto, o padrã o durante a leitura é converter terminadores de linha específicos da plataforma (\n no Unix, \
r\n no Windows) para apenas \n. Ao escrever no modo de texto, o padrã o é converter as ocorrê ncias de \n de volta
para os finais de linha específicos da plataforma. Essa modificaçã o de bastidores nos dados do arquivo é adequada
para arquivos de texto, mas corromperá dados biná rios, como arquivos JPEG ou EXE. Tenha muito cuidado para só
usar o modo biná rio, ao ler e gravar esses arquivos.
É uma boa prá tica usar a palavra-chave with ao lidar com arquivos. A vantagem é que o arquivo é fechado corre-
tamente apó s o té rmino de sua utilizaçã o, mesmo que uma exceçã o seja levantada em algum momento. Usar with
també m é muito mais curto que escrever seu bloco equivalente try-finally:

>>> with open('workfile', encoding="utf-8") as f:

... read_data = [Link]()

>>> # We can check that the file has been automatically closed.
>>> [Link]
True

7.2. Leitura e escrita de arquivos 63

Python Tutorial, Release 3.12.5

Se você nã o está usando a palavra reservada with, entã o você deveria chamar [Link]() para fechar o arquivo
e imediatamente liberar qualquer recurso do sistema usado por ele.

Aviso

Chamar [Link]() sem usar a palavra reservada with ou chamar [Link]() pode resultar nos argumentos
de [Link]() nã o serem completamente escritos no disco, mesmo se o programa for encerrado com ê xito.

Depois que um arquivo é fechado, seja por uma instruçã o with ou chamando [Link](), as tentativas de usar o
arquivo falharã o automaticamente.

>>> [Link]()
>>> [Link]()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file.

7.2.1 Métodos de objetos arquivo

Para simplificar, o resto dos exemplos nesta seçã o presumem que um objeto arquivo chamado f já foi criado.
Para ler o conteú do de um arquivo, chame [Link](tamanho), que lê um punhado de dados devolvendo-os como
uma string (em modo texto) ou bytes (em modo biná rio). tamanho é um argumento numé rico opcional. Quando
tamanho é omitido ou negativo, todo o conteú do do arquivo é lido e devolvido; se o arquivo é duas vezes maior
que memó ria da má quina, o problema é seu. Caso contrá rio, no má ximo tamanho caracteres (em modo texto) ou
tamanho bytes (em modo biná rio) sã o lidos e devolvidos. Se o fim do arquivo for atingido, [Link]() devolve uma
string vazia ('').

>>> [Link]()
'This is the entire file.\n'
>>> [Link]()
''

O mé todo [Link]() lê uma ú nica linha do arquivo; o caractere de quebra de linha (\n) é mantido ao final da
string, e só é omitido na ú ltima linha do arquivo, se o arquivo nã o terminar com uma quebra de linha. Isso elimina a
ambiguidade do valor retornado; se [Link]() retorna uma string vazia, o fim do arquivo foi atingido. Linhas
em branco sã o representadas por um '\n' – uma string contendo apenas o caractere terminador de linha.

>>> [Link]()
'This is the first line of the file.\n'
>>> [Link]()
'Second line of the file\n'
>>> [Link]()
''

Uma maneira alternativa de ler linhas do arquivo é iterar diretamente pelo objeto arquivo. É eficiente, rá pido e resulta
em có digo mais simples:

>>> for line in f:

... print(line, end='')
...
This is the first line of the file.
Second line of the file

Se desejar ler todas as linhas de um arquivo em uma lista, pode-se usar list(f) ou [Link]().
[Link](string) escreve o conteú do de string para o arquivo, retornando o nú mero de caracteres escritos.

64 Capítulo 7. Entrada e Saída

 Python Tutorial, Release 3.12.5

>>> [Link]('This is a test\n')

15

Outros tipos de objetos precisam ser convertidos – seja para uma string (em modo texto) ou para bytes (em modo
biná rio) – antes de escrevê -los:

>>> value = ('the answer', 42)

>>> s = str(value) # convert the tuple to string
>>> [Link](s)
18

[Link]() retorna um inteiro dando a posiçã o atual do objeto arquivo, no arquivo representado, como nú mero de
bytes desde o início do arquivo, no modo biná rio, e um nú mero ininteligível, quando no modo de texto.
Para mudar a posiçã o, use [Link](offset, de_onde). A nova posiçã o é computada pela soma do desloca-
mento offset a um ponto de referê ncia especificado pelo argumento de-onde. Se o valor de de_onde é 0,a referê ncia
é o início do arquivo, 1 refere-se à posiçã o atual, e 2 refere-se ao fim do arquivo. Este argumento pode ser omitido
e o valor padrã o é 0, usando o início do arquivo como referê ncia.

>>> f = open('workfile', 'rb+')

>>> [Link](b'0123456789abcdef')
16
>>> [Link](5) # Go to the 6th byte in the file
5
>>> [Link](1)
b'5'
>>> [Link](-3, 2) # Go to the 3rd byte before the end
13
>>> [Link](1)
b'd'

Em arquivos texto (abertos sem um b, em modo string), somente seeks relativos ao início do arquivo serã o permitidos
(exceto se for indicado o final do arquivo, com seek(0, 2)) e o ú nico valor vá lido para offset sã o aqueles retornados
por chamada à [Link](), ou zero. Qualquer outro valor para offset produz um comportamento indefinido.
Objetos arquivo tem alguns mé todos adicionais, como isatty() e truncate() que nã o sã o usados com
frequê ncia; consulte a Biblioteca de Referê ncia para um guia completo de objetos arquivo.

7.2.2 Gravando dados estruturados com json

Strings podem ser facilmente gravadas e lidas em um arquivo. Nú meros dã o um pouco mais de trabalho, já que o
mé todo read() só retorna strings, que terã o que ser passadas para uma funçã o como int(), que pega uma string
como '123' e retorna seu valor numé rico 123. Quando você deseja salvar tipos de dados mais complexos, como
listas e dicioná rios aninhados, a aná lise e serializaçã o manual tornam-se complicadas.
Ao invé s de ter usuá rios constantemente escrevendo e depurando có digo para gravar tipos complicados de dados
em arquivos, o Python permite que se use o popular formato de troca de dados chamado JSON (JavaScript Object
Notation). O mó dulo padrã o chamado json pode pegar hierarquias de dados em Python e convertê -las em repre-
sentaçõ es de strings; esse processo é chamado serialização. Reconstruir os dados estruturados da representaçã o string
é chamado desserialização. Entre serializar e desserializar, a string que representa o objeto pode ser armazenada em
um arquivo, ou estrutura de dados, ou enviada por uma conexã o de rede para alguma outra má quina.

Nota

O formato JSON é comumente usado por aplicativos modernos para permitir troca de dados. Pessoas que pro-
gramam já estã o familiarizadas com esse formato, o que o torna uma boa opçã o para interoperabilidade.

Um objeto x, pode ser visualizado na sua representaçã o JSON com uma simples linha de có digo:

7.2. Leitura e escrita de arquivos 65

Python Tutorial, Release 3.12.5

>>> import json

>>> x = [1, 'simple', 'list']
>>> [Link](x)
'[1, "simple", "list"]'

Outra variaçã o da funçã o dumps(), chamada dump(), serializa o objeto para um arquivo texto. Se f é um arquivo
texto aberto para escrita, podemos fazer isto:

[Link](x, f)

Para decodificar o objeto novamente, se f é um objeto arquivo binário ou arquivo texto que foi aberto para leitura:

x = [Link](f)

Nota

Arquivos JSON devem ser codificados em UTF-8. Use encoding="utf-8" quando abrir um arquivo JSON
como um arquivo texto tanto para leitura quanto para escrita.

Essa té cnica de serializaçã o simples pode manipular listas e dicioná rios, mas a serializaçã o de instâ ncias de classes
arbitrá rias no JSON requer um pouco mais de esforço. A referê ncia para o mó dulo json conté m uma explicaçã o
disso.

Ver também

O mó dulo pickle

Ao contrá rio do JSON, pickle é um protocolo que permite a serializaçã o de objetos Python arbitrariamente com-
plexos. Por isso, é específico do Python e nã o pode ser usado para se comunicar com aplicativos escritos em
outros linguagens. També m é inseguro por padrã o: desserializar dados de pickle, provenientes de uma fonte nã o
confiá vel, pode executar có digo arbitrá rio, se os dados foram criados por um invasor habilidoso.

66 Capítulo 7. Entrada e Saída

 CAPÍTULO 8

Erros e exceções

Até agora mensagens de erro foram apenas mencionadas, mas se você testou os exemplos, talvez tenha esbarrado em
algumas. Existem pelo menos dois tipos distintos de erros: erros de sintaxe e exceções.

8.1 Erros de sintaxe

Erros de sintaxe, també m conhecidos como erros de parse, sã o provavelmente os mais frequentes entre aqueles que
ainda estã o aprendendo Python:

>>> while True print('Hello world')

File "<stdin>", line 1
while True print('Hello world')
^^^^^
SyntaxError: invalid syntax

O analisador sintá tico repete a linha invá lida e apresenta uma pequena ‘seta’ apontando para o ponto da linha em que
o erro foi detectado. O erro deve ter sido causado pela ausê ncia do símbolo que precede a seta. No exemplo, o erro
foi detectado na funçã o print(), uma vez que um dois-pontos (':') está faltando antes dela. O nome de arquivo
e nú mero de linha sã o exibidos para que você possa rastrear o erro no texto do script.

8.2 Exceções

Mesmo que um comando ou expressã o estejam sintaticamente corretos, talvez ocorra um erro na hora de sua exe-
cuçã o. Erros detectados durante a execuçã o sã o chamados exceções e nã o sã o necessariamente fatais: logo veremos
como tratá -las em programas Python. A maioria das exceçõ es nã o sã o tratadas pelos programas e acabam resultando
em mensagens de erro:

>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
(continua na pró xima pá gina)

67
Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

A ú ltima linha da mensagem de erro indica o que aconteceu. Exceçõ es surgem com diferentes tipos, e o tipo é exibido
como parte da mensagem: os tipos no exemplo sã o ZeroDivisionError, NameError e TypeError. A
string exibida como sendo o tipo da exceçã o é o nome da exceçã o embutida que ocorreu. Isso é verdade para todas
exceçõ es pré -definidas em Python, mas nã o é necessariamente verdade para exceçõ es definidas pelo usuá rio (embora
seja uma convençã o ú til). Os nomes das exceçõ es padrõ es sã o identificadores embutidos (nã o palavras reservadas).
O resto da linha é um detalhamento que depende do tipo da exceçã o ocorrida e sua causa.
A parte anterior da mensagem de erro apresenta o contexto onde ocorreu a exceçã o. Essa informaçã o é denominada
stack traceback (situaçã o da pilha de execuçã o). Em geral, conté m uma lista de linhas do có digo-fonte, sem apresentar,
no entanto, linhas lidas da entrada padrã o.
bltin-exceptions lista as exceçõ es pré -definidas e seus significados.

8.3 Tratamento de exceções

É possível escrever programas que tratam exceçõ es específicas. Observe o exemplo seguinte, que pede dados ao
usuá rio até que um inteiro vá lido seja fornecido, ainda permitindo que o programa seja interrompido (utilizando
Control-C ou seja lá o que for que o sistema operacional suporte); note que uma interrupçã o gerada pelo usuá rio
será sinalizada pela exceçã o KeyboardInterrupt.

>>> while True:

... try:
... x = int(input("Please enter a number: "))
... break
... except ValueError:
... print("Oops! That was no valid number. Try again...")
...

A instruçã o try funciona da seguinte maneira:

• Primeiramente, a cláusula try (o conjunto de instruçõ es entre as palavras reservadas try e except ) é exe-
cutada.
• Se nenhuma exceçã o ocorrer, a cláusula except é ignorada e a execuçã o da instruçã o try é finalizada.
• Se ocorrer uma exceçã o durante a execuçã o de uma clá usura try, as instruçõ es remanescentes na clá usula
sã o ignoradas. Se o tipo da exceçã o ocorrida tiver sido previsto em algum except, essa cláusura except é
executada, e entã o depois a execuçã o continua apó s o bloco try/except.
• Se a exceçã o levantada nã o corresponder a nenhuma exceçã o listada na cláusula de exceção, entã o ela é entregue
a uma instruçã o try mais externa. Se nã o existir nenhum tratador previsto para tal exceçã o, trata-se de uma
exceção não tratada e a execuçã o do programa termina com uma mensagem de erro.
A instruçã o try pode ter uma ou mais cláusula de exceção, para especificar mú ltiplos tratadores para diferentes
exceçõ es. No má ximo um ú nico tratador será executado. Tratadores só sã o sensíveis à s exceçõ es levantadas no
interior da cláusula de tentativa, e nã o à s que tenham ocorrido no interior de outro tratador numa mesma instruçã o
try. Uma cláusula de exceção pode ser sensível a mú ltiplas exceçõ es, desde que as especifique em uma tupla, por
exemplo:

... except (RuntimeError, TypeError, NameError):

... pass

68 Capítulo 8. Erros e exceções

 Python Tutorial, Release 3.12.5

Uma classe em uma clá usula except corresponde a exceçõ es que sã o instâ ncias da pró pria classe ou de uma de suas
classes derivadas (mas o contrá rio nã o é vá lido — uma cláusula except listando uma classe derivada nã o corresponde
a instâ ncias de suas classes base). Por exemplo, o seguinte có digo irá mostrar B, C, D nessa ordem:

class B(Exception):
pass

class C(B):
pass

class D(C):
pass

for cls in [B, C, D]:

try:
raise cls()
except D:
print("D")
except C:
print("C")
except B:
print("B")

Se a ordem das cláusulas de exceção fosse invertida (except B no início), seria exibido B, B, B — somente a
primeira cláusula de exceção compatível é ativada.
Quando uma exceçã o ocorre, ela pode estar associada a valores chamados argumentos da exceçã o. A presença e os
tipos dos argumentos dependem do tipo da exceçã o.
A cláusula except pode especificar uma variá vel apó s o nome da exceçã o. A variá vel está vinculada à instâ ncia de
exceçã o que normalmente possui um atributo args que armazena os argumentos. Por conveniê ncia, os tipos de
exceçã o embutidos definem __str__() para exibir todos os argumentos sem acessar explicitamente .args.

>>> try:
... raise Exception('spam', 'eggs')
... except Exception as inst:
... print(type(inst)) # the exception type
... print([Link]) # arguments stored in .args
... print(inst) # __str__ allows args to be printed directly,
... # but may be overridden in exception subclasses
... x, y = [Link] # unpack args
... print('x =', x)
... print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs

A saída __str__() da exceçã o é exibida como a ú ltima parte (“detalhe”) da mensagem para exceçõ es nã o tratadas.
BaseException é a classe base comum de todas as exceçõ es. Uma de suas subclasses, Exception, é a classe
base de todas as exceçõ es nã o fatais. Exceçõ es que nã o sã o subclasses de Exception normalmente nã o sã o tratadas,
pois sã o usadas para indicar que o programa deve terminar. Elas incluem SystemExit que é kevantada por sys.
exit() e KeyboardInterrupt que é levantada quando um usuá rio deseja interromper o programa.
Exception pode ser usada como um curinga que captura (quase) tudo. No entanto, é uma boa prá tica ser o
mais específico possível com os tipos de exceçõ es que pretendemos manipular e permitir que quaisquer exceçõ es
inesperadas se propaguem.
O padrã o mais comum para lidar com Exception é imprimir ou registrar a exceçã o e entã o levantá -la novamente
(permitindo que um chamador lide com a exceçã o també m):

8.3. Tratamento de exceções 69

Python Tutorial, Release 3.12.5

import sys

try:
f = open('[Link]')
s = [Link]()
i = int([Link]())
except OSError as err:
print("OS error:", err)
except ValueError:
print("Could not convert data to an integer.")
except Exception as err:
print(f"Unexpected {err=}, {type(err)=}")
raise

A construçã o try … except possui uma cláusula else opcional, que quando presente, deve ser colocada depois de
todas as outras clá usulas. É ú til para um có digo que precisa ser executado se nenhuma exceçã o foi levantada. Por
exemplo:

for arg in [Link][1:]:

try:
f = open(arg, 'r')
except OSError:
print('cannot open', arg)
else:
print(arg, 'has', len([Link]()), 'lines')
[Link]()

É melhor usar a clá usula else do que adicionar có digo adicional à clá usula try porque ela evita que acidentalmente
seja tratada uma exceçã o que nã o foi levantada pelo có digo protegido pela construçã o com as instruçõ es try …
except.
Os manipuladores de exceçã o nã o tratam apenas exceçõ es que ocorrem imediatamente na cláusula try, mas també m
aquelas que ocorrem dentro de funçõ es que sã o chamadas (mesmo indiretamente) na cláusula try. Por exemplo:

>>> def this_fails():

... x = 1/0
...
>>> try:
... this_fails()
... except ZeroDivisionError as err:
... print('Handling run-time error:', err)
...
Handling run-time error: division by zero

8.4 Levantando exceções

A instruçã o raise permite ao programador forçar a ocorrê ncia de um determinado tipo de exceçã o. Por exemplo:

>>> raise NameError('HiThere')

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: HiThere

O argumento de raise indica a exceçã o a ser levantada. Esse argumento deve ser uma instâ ncia de exceçã o ou uma
classe de exceçã o (uma classe que deriva de BaseException, tal como Exception ou uma de suas subclasses).
Se uma classe de exceçã o for passada, será implicitamente instanciada invocando o seu construtor sem argumentos:

raise ValueError # shorthand for 'raise ValueError()'

70 Capítulo 8. Erros e exceções

 Python Tutorial, Release 3.12.5

Caso você precise determinar se uma exceçã o foi levantada ou nã o, mas nã o quer manipular o erro, uma forma
simples de instruçã o raise permite que você levante-a novamente:

>>> try:
... raise NameError('HiThere')
... except NameError:
... print('An exception flew by!')
... raise
...
An exception flew by!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
NameError: HiThere

8.5 Encadeamento de exceções

Se uma exceçã o nã o tratada ocorrer dentro de uma seçã o except, ela terá a exceçã o sendo tratada anexada a ela e
incluída na mensagem de erro:

>>> try:
... open("[Link]")
... except OSError:
... raise RuntimeError("unable to handle error")
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
FileNotFoundError: [Errno 2] No such file or directory: '[Link]'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):

File "<stdin>", line 4, in <module>
RuntimeError: unable to handle error

Para indicar que uma exceçã o é uma consequê ncia direta de outra, a instruçã o raise permite uma clá usula opcional
from:

# exc must be exception instance or None.

raise RuntimeError from exc

Isso pode ser ú til quando você está transformando exceçõ es. Por exemplo:

>>> def func():

... raise ConnectionError
...
>>> try:
... func()
... except ConnectionError as exc:
... raise RuntimeError('Failed to open database') from exc
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
File "<stdin>", line 2, in func
ConnectionError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):

File "<stdin>", line 4, in <module>
RuntimeError: Failed to open database

8.5. Encadeamento de exceções 71

Python Tutorial, Release 3.12.5

Ele també m permite desabilitar o encadeamento automá tico de exceçõ es usando o idioma from None:

>>> try:
... open('[Link]')
... except OSError:
... raise RuntimeError from None
...
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
RuntimeError

Para mais informaçõ es sobre os mecanismos de encadeamento, veja bltin-exceptions.

8.6 Exceções definidas pelo usuário

Programas podem definir novos tipos de exceçõ es, atravé s da criaçã o de uma nova classe (veja Classes para mais
informaçõ es sobre classes Python). Exceçõ es devem ser derivadas da classe Exception, direta ou indiretamente.
As classes de exceçã o podem ser definidas para fazer qualquer coisa que qualquer outra classe pode fazer, mas geral-
mente sã o mantidas simples, geralmente oferecendo apenas um nú mero de atributos que permitem que informaçõ es
sobre o erro sejam extraídas por manipuladores para a exceçã o.
É comum que novas exceçõ es sejam definidas com nomes terminando em “Error”, semelhante a muitas exceçõ es
embutidas.
Muitos mó dulos padrã o definem suas pró prias exceçõ es para relatar erros que podem ocorrer nas funçõ es que definem.

8.7 Definindo ações de limpeza

A instruçã o try possui outra clá usula opcional, cuja finalidade é permitir a implementaçã o de açõ es de limpeza, que
sempre devem ser executadas independentemente da ocorrê ncia de exceçõ es. Como no exemplo:

>>> try:
... raise KeyboardInterrupt
... finally:
... print('Goodbye, world!')
...
Goodbye, world!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterrupt

Se uma clá usula finally estiver presente, a clá usula finally será executada como a ú ltima tarefa antes da
conclusã o da instruçã o try. A clá usula finally executa se a instruçã o try produz uma exceçã o. Os pontos a
seguir discutem casos mais complexos quando ocorre uma exceçã o:
• Se ocorrer uma exceçã o durante a execuçã o da clá usula try, a exceçã o poderá ser tratada por uma clá usula
except. Se a exceçã o nã o for tratada por uma clá usula except, a exceçã o será gerada novamente apó s a
execuçã o da clá usula finally.
• Uma exceçã o pode ocorrer durante a execuçã o de uma clá usula except ou else. Novamente, a exceçã o é
re-levantada depois que finally é executada.
• Se a clá usula finally executa uma instruçã o break, continue ou return, as exceçõ es nã o sã o levan-
tadas novamente.
• Se a instruçã o try atingir uma instruçã o break, continue ou return, a clá usula finally será exe-
cutada imediatamente antes da execuçã o da instruçã o break, continue ou return.

72 Capítulo 8. Erros e exceções

 Python Tutorial, Release 3.12.5

• Se uma clá usula finally incluir uma instruçã o return, o valor retornado será aquele da instruçã o return
da clá usula finally, nã o o valor da instruçã o return da clá usula try.
Por exemplo:

>>> def bool_return():

... try:
... return True
... finally:
... return False
...
>>> bool_return()
False

Um exemplo mais complicado:

>>> def divide(x, y):

... try:
... result = x / y
... except ZeroDivisionError:
... print("division by zero!")
... else:
... print("result is", result)
... finally:
... print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

Como você pode ver, a clá usula finally é executada em todos os casos. A exceçã o TypeError levantada pela
divisã o de duas strings nã o é tratada pela clá usula except e portanto é re-levantada depois que a clá usula finally
é executada.
Em aplicaçã o do mundo real, a clá usula finally é ú til para liberar recursos externos (como arquivos ou conexõ es
de rede), independentemente do uso do recurso ter sido bem sucedido ou nã o.

8.8 Ações de limpeza predefinidas

Alguns objetos definem açõ es de limpeza padrõ es para serem executadas quando o objeto nã o é mais necessá rio,
independentemente da operaçã o que estava usando o objeto ter sido ou nã o bem sucedida. Veja o exemplo a seguir,
que tenta abrir um arquivo e exibir seu conteú do na tela.

for line in open("[Link]"):

print(line, end="")

O problema com esse có digo é que ele deixa o arquivo aberto um período indeterminado depois que o có digo é
executado. Isso nã o chega a ser problema em scripts simples, mas pode ser um problema para grandes aplicaçõ es.
A palavra reservada with permite que objetos como arquivos sejam utilizados com a certeza de que sempre serã o
prontamente e corretamente finalizados.

8.8. Ações de limpeza predefinidas 73

Python Tutorial, Release 3.12.5

with open("[Link]") as f:
for line in f:
print(line, end="")

Depois que a instruçã o é executada, o arquivo f é sempre fechado, mesmo se ocorrer um problema durante o pro-
cessamento das linhas. Outros objetos que, como arquivos, fornecem açõ es de limpeza predefinidas as indicarã o em
suas documentaçõ es.

8.9 Criando e tratando várias exceções não relacionadas

Existem situaçõ es em que é necessá rio relatar vá rias exceçõ es que ocorreram. Isso geralmente ocorre em estruturas
de simultaneidade, quando vá rias tarefas podem ter falhado em paralelo, mas també m há outros casos de uso em que
é desejá vel continuar a execuçã o e coletar vá rios erros em vez de levantar a primeira exceçã o.
O ExceptionGroup integrado envolve uma lista de instâ ncias de exceçã o para que elas possam ser levantadas
juntas. É uma exceçã o em si, portanto, pode ser capturada como qualquer outra exceçã o.

>>> def f():

... excs = [OSError('error 1'), SystemError('error 2')]
... raise ExceptionGroup('there were problems', excs)
...
>>> f()
+ Exception Group Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| File "<stdin>", line 3, in f
| ExceptionGroup: there were problems
+-+---------------- 1 ----------------
| OSError: error 1
+---------------- 2 ----------------
| SystemError: error 2
+------------------------------------
>>> try:
... f()
... except Exception as e:
... print(f'caught {type(e)}: e')
...
caught <class 'ExceptionGroup'>: e
>>>

Usando except* em vez de except, podemos manipular seletivamente apenas as exceçõ es no grupo que cor-
respondem a um determinado tipo. No exemplo a seguir, que mostra um grupo de exceçã o aninhado, cada clá usula
except* extrai do grupo exceçõ es de um certo tipo enquanto permite que todas as outras exceçõ es se propaguem
para outras clá usulas e eventualmente sejam levantadas novamente.

>>> def f():

... raise ExceptionGroup(
... "group1",
... [
... OSError(1),
... SystemError(2),
... ExceptionGroup(
... "group2",
... [
... OSError(3),
... RecursionError(4)
... ]
... )
... ]
... )
(continua na pró xima pá gina)

74 Capítulo 8. Erros e exceções

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

...
>>> try:
... f()
... except* OSError as e:
... print("There were OSErrors")
... except* SystemError as e:
... print("There were SystemErrors")
...
There were OSErrors
There were SystemErrors
+ Exception Group Traceback (most recent call last):
| File "<stdin>", line 2, in <module>
| File "<stdin>", line 2, in f
| ExceptionGroup: group1
+-+---------------- 1 ----------------
| ExceptionGroup: group2
+-+---------------- 1 ----------------
| RecursionError: 4
+------------------------------------
>>>

Observe que as exceçõ es aninhadas em um grupo de exceçõ es devem ser instâ ncias, nã o tipos. Isso ocorre porque,
na prá tica, as exceçõ es normalmente seriam aquelas que já foram levantadas e capturadas pelo programa, seguindo
o seguinte padrã o:

>>> excs = []
... for test in tests:
... try:
... [Link]()
... except Exception as e:
... [Link](e)
...
>>> if excs:
... raise ExceptionGroup("Test Failures", excs)
...

8.10 Enriquecendo exceções com notas

Quando uma exceçã o é criada para ser levantada, geralmente é inicializada com informaçõ es que descrevem o erro
ocorrido. Há casos em que é ú til adicionar informaçõ es apó s a captura da exceçã o. Para este propó sito, as exce-
çõ es possuem um mé todo add_note(note) que aceita uma string e a adiciona à lista de notas da exceçã o. A
renderizaçã o de traceback padrã o inclui todas as notas, na ordem em que foram adicionadas, apó s a exceçã o.

>>> try:
... raise TypeError('bad type')
... except Exception as e:
... e.add_note('Add some information')
... e.add_note('Add some more information')
... raise
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
TypeError: bad type
Add some information
Add some more information
>>>

Por exemplo, ao coletar exceçõ es em um grupo de exceçõ es, podemos querer adicionar informaçõ es de contexto para
os erros individuais. A seguir, cada exceçã o no grupo tem uma nota indicando quando esse erro ocorreu.

8.10. Enriquecendo exceções com notas 75

Python Tutorial, Release 3.12.5

>>> def f():

... raise OSError('operation failed')
...
>>> excs = []
>>> for i in range(3):
... try:
... f()
... except Exception as e:
... e.add_note(f'Happened in Iteration {i+1}')
... [Link](e)
...
>>> raise ExceptionGroup('We have some problems', excs)
+ Exception Group Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| ExceptionGroup: We have some problems (3 sub-exceptions)
+-+---------------- 1 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 3, in <module>
| File "<stdin>", line 2, in f
| OSError: operation failed
| Happened in Iteration 1
+---------------- 2 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 3, in <module>
| File "<stdin>", line 2, in f
| OSError: operation failed
| Happened in Iteration 2
+---------------- 3 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 3, in <module>
| File "<stdin>", line 2, in f
| OSError: operation failed
| Happened in Iteration 3
+------------------------------------
>>>

76 Capítulo 8. Erros e exceções

 CAPÍTULO 9

Classes

Classes proporcionam uma forma de organizar dados e funcionalidades juntos. Criar uma nova classe cria um novo
“tipo” de objeto, permitindo que novas “instâ ncias” desse tipo sejam produzidas. Cada instâ ncia da classe pode ter
atributos anexados a ela, para manter seu estado. Instâ ncias da classe també m podem ter mé todos (definidos pela
classe) para modificar seu estado.
Em comparaçã o com outras linguagens de programaçã o, o mecanismo de classes de Python introduz a programaçã o
orientada a objetos sem acrescentar muitas novidades de sintaxe ou semâ ntica. É uma mistura de mecanismos equi-
valentes encontrados em C++ e Modula-3. As classes em Python oferecem todas as características tradicionais da
programaçã o orientada a objetos: o mecanismo de herança permite mú ltiplas classes base (herança mú ltipla), uma
classe derivada pode sobrescrever quaisquer mé todos de uma classe ancestral, e um mé todo pode invocar outro mé -
todo homô nimo de uma classe ancestral. Objetos podem armazenar uma quantidade arbitrá ria de dados de qualquer
tipo. Assim como acontece com os mó dulos, as classes fazem parte da natureza dinâ mica de Python: sã o criadas em
tempo de execuçã o, e podem ser alteradas apó s sua criaçã o.
Usando a terminologia de C++, todos os membros de uma classe (incluindo dados) sã o públicos (veja exceçã o abaixo
Variáveis privadas), e todos as funçõ es membro sã o virtuais. Como em Modula-3, nã o existem atalhos para referen-
ciar membros do objeto de dentro dos seus mé todos: o mé todo (funçã o definida em uma classe) é declarado com um
primeiro argumento explícito representando o objeto (instâ ncia da classe), que é fornecido implicitamente pela cha-
mada ao mé todo. Como em Smalltalk, classes sã o objetos. Isso fornece uma semâ ntica para importar e renomear.
Ao contrá rio de C++ ou Modula-3, tipos pré -definidos podem ser utilizados como classes base para extensõ es por
herança pelo usuá rio. També m, como em C++, a maioria dos operadores (aritmé ticos, indexaçã o, etc) podem ser
redefinidos por instâ ncias de classe.
(Na falta de uma terminologia universalmente aceita para falar sobre classes, ocasionalmente farei uso de termos
comuns em Smalltalk ou C++. Eu usaria termos de Modula-3, já que sua semâ ntica de orientaçã o a objetos é mais
pró xima da de Python, mas creio que poucos leitores já ouviram falar dessa linguagem.)

77
Python Tutorial, Release 3.12.5

9.1 Uma palavra sobre nomes e objetos

Objetos tê m individualidade, e vá rios nomes (em diferentes escopos) podem ser vinculados a um mesmo objeto. Isso
é chamado de apelidamento em outras linguagens. Geralmente, esta característica nã o é muito apreciada, e pode
ser ignorada com segurança ao lidar com tipos imutá veis (nú meros, strings, tuplas). Entretanto, apelidamento pode
ter um efeito surpreendente na semâ ntica do có digo Python envolvendo objetos mutá veis como listas, dicioná rios e
a maioria dos outros tipos. Isso pode ser usado em benefício do programa, porque os apelidos funcionam de certa
forma como ponteiros. Por exemplo, passar um objeto como argumento é barato, pois só um ponteiro é passado na
implementaçã o; e se uma funçã o modifica um objeto passado como argumento, o invocador verá a mudança — isso
elimina a necessidade de ter dois mecanismos de passagem de parâ metros como em Pascal.

9.2 Escopos e espaços de nomes do Python

Antes de introduzir classes, é preciso falar das regras de escopo em Python. Definiçõ es de classe fazem alguns
truques com espaços de nomes. Portanto, primeiro é preciso entender claramente como escopos e espaços de nomes
funcionam, para entender o que está acontecendo. Esse conhecimento é muito ú til para qualquer programador Python
avançado.
Vamos começar com algumas definiçõ es.
Um espaço de nomes é um mapeamento que associa nomes a objetos. Atualmente, sã o implementados como dici-
oná rios em Python, mas isso nã o é perceptível (a nã o ser pelo desempenho), e pode mudar no futuro. Exemplos
de espaços de nomes sã o: o conjunto de nomes pré -definidos (funçõ es como abs() e as exceçõ es pré -definidas);
nomes globais em um mó dulo; e nomes locais na invocaçã o de uma funçã o. De certa forma, os atributos de um
objeto també m formam um espaço de nomes. O mais importante é saber que nã o existe nenhuma relaçã o entre
nomes em espaços de nomes distintos. Por exemplo, dois mó dulos podem definir uma funçã o de nome maximize
sem confusã o — usuá rios dos mó dulos devem prefixar a funçã o com o nome do mó dulo, para evitar colisã o.
A propó sito, utilizo a palavra atributo para qualquer nome depois de um ponto. Na expressã o [Link], por exem-
plo, real é um atributo do objeto z. Estritamente falando, referê ncias para nomes em mó dulos sã o atributos: na
expressã o [Link], modname é um objeto mó dulo e funcname é um de seus atributos. Neste
caso, existe um mapeamento direto entre os atributos de um mó dulo e os nomes globais definidos no mó dulo: eles
compartilham o mesmo espaço de nomes!1
Atributos podem ser somente leitura ou para leitura e escrita. No segundo caso, é possível atribuir um novo va-
lor ao atributo. Atributos de mó dulos sã o passíveis de atribuiçã o: você pode escrever modname.the_answer
= 42. Atributos que aceitam escrita també m podem ser apagados atravé s da instruçã o del. Por exemplo, del
modname.the_answer removerá o atributo the_answer do objeto referenciado por modname.
Espaços de nomes sã o criados em momentos diferentes e possuem diferentes ciclos de vida. O espaço de nomes
que conté m os nomes embutidos é criado quando o interpretador inicializa e nunca é removido. O espaço de nomes
global de um mó dulo é criado quando a definiçã o do mó dulo é lida, e normalmente duram até a terminaçã o do
interpretador. Os comandos executados pela invocaçã o do interpretador, pela leitura de um script com programa
principal, ou interativamente, sã o parte do mó dulo chamado __main__, e portanto possuem seu pró prio espaço de
nomes. (Os nomes embutidos possuem seu pró prio espaço de nomes no mó dulo chamado builtins.).
O espaço de nomes local de uma funçã o é criado quando a funçã o é invocada, e apagado quando a funçã o retorna
ou levanta uma exceçã o que nã o é tratada na pró pria funçã o. (Na verdade, uma forma melhor de descrever o que
realmente acontece é que o espaço de nomes local é “esquecido” quando a funçã o termina.) Naturalmente, cada
invocaçã o recursiva de uma funçã o tem seu pró prio espaço de nomes.
Um escopo é uma regiã o textual de um programa Python onde um espaço de nomes é diretamente acessível. Aqui,
“diretamente acessível” significa que uma referê ncia sem um prefixo qualificador permite o acesso ao nome.
Ainda que escopos sejam determinados estaticamente, eles sã o usados dinamicamente. A qualquer momento durante
a execuçã o, existem 3 ou 4 escopos aninhados cujos espaços de nomes sã o diretamente acessíveis:
1 Exceto por uma coisa. Os objetos mó dulo tê m um atributo secreto e somente para leitura chamado __dict__ que retorna o dicioná rio

usado para implementar o espaço de nomes do mó dulo; o nome __dict__ é um atributo, mas nã o um nome global. Obviamente, usar isso viola
a abstraçã o da implementaçã o do espaço de nomes, e deve ser restrito a coisas como depuradores post-mortem.

78 Capítulo 9. Classes
 Python Tutorial, Release 3.12.5

• o escopo mais interno, que é acessado primeiro, contem os nomes locais

• os escopos das funçõ es que envolvem a funçã o atual, que sã o acessados a partir do escopo mais pró ximo,
contê m nomes nã o-locais, mas també m nã o-globais
• o penú ltimo escopo conté m os nomes globais do mó dulo atual
• e o escopo mais externo (acessado por ú ltimo) conté m os nomes das funçõ es embutidas e demais objetos
pré -definidos do interpretador
Se um nome é declarado no escopo global, entã o todas as referê ncias e atribuiçõ es de valores vã o diretamente para
o penú ltimo escopo, que conté m os nomes globais do mó dulo. Para alterar variá veis declaradas fora do escopo mais
interno, a instruçã o nonlocal pode ser usada; caso contrá rio, todas essas variá veis serã o apenas para leitura (a
tentativa de atribuir valores a essas variá veis simplesmente criará uma nova variá vel local, no escopo interno, nã o
alterando nada na variá vel de nome idê ntico fora dele).
Normalmente, o escopo local referencia os nomes locais da funçã o corrente no texto do programa. Fora de funçõ es,
o escopo local referencia os nomes do escopo global: espaço de nomes do mó dulo. Definiçõ es de classes adicionam
um outro espaço de nomes ao escopo local.
É importante perceber que escopos sã o determinados estaticamente, pelo texto do có digo-fonte: o escopo global de
uma funçã o definida em um mó dulo é o espaço de nomes deste mó dulo, sem importar de onde ou por qual apelido a
funçã o é invocada. Por outro lado, a busca de nomes é dinâ mica, ocorrendo durante a execuçã o. Poré m, a evoluçã o
da linguagem está caminhando para uma resoluçã o de nomes está tica, em “tempo de compilaçã o”, portanto nã o conte
com a resoluçã o dinâ mica de nomes! (De fato, variá veis locais já sã o resolvidas estaticamente.)
Uma peculiaridade especial do Python é que – se nenhuma instruçã o global ou nonlocal estiver em vigor –
as atribuiçõ es de nomes sempre entram no escopo mais interno. As atribuiçõ es nã o copiam dados — elas apenas
vinculam nomes aos objetos. O mesmo vale para exclusõ es: a instruçã o del x remove a ligaçã o de x do espaço
de nomes referenciado pelo escopo local. De fato, todas as operaçõ es que introduzem novos nomes usam o escopo
local: em particular, instruçõ es import e definiçõ es de funçõ es ligam o mó dulo ou o nome da funçã o no escopo
local.
A instruçã o global pode ser usada para indicar que certas variá veis residem no escopo global ao invé s do local; a
instruçã o nonlocal indica que variá veis particulares estã o em um espoco mais interno e devem ser recuperadas lá .

9.2.1 Exemplo de escopos e espaço de nomes

Este é um exemplo que demonstra como se referir aos diferentes escopos e aos espaços de nomes, e como global
e nonlocal pode afetar ligaçã o entre as variá veis:

def scope_test():
def do_local():
spam = "local spam"

def do_nonlocal():
nonlocal spam
spam = "nonlocal spam"

def do_global():
global spam
spam = "global spam"

spam = "test spam"

do_local()
print("After local assignment:", spam)
do_nonlocal()
print("After nonlocal assignment:", spam)
do_global()
print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

9.2. Escopos e espaços de nomes do Python 79

Python Tutorial, Release 3.12.5

A saída do có digo de exemplo é :

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

Observe como uma atribuiçã o local (que é o padrã o) nã o altera o vínculo de scope_test a spam. A instruçã o
nonlocal mudou o vínculo de scope_test de spam e a atribuiçã o global alterou a ligaçã o para o nível do mó dulo.
Você també m pode ver que nã o havia nenhuma ligaçã o anterior para spam antes da atribuiçã o global.

9.3 Uma primeira olhada nas classes

Classes introduzem novidades sintá ticas, trê s novos tipos de objetos, e també m alguma semâ ntica nova.

9.3.1 Sintaxe da definição de classe

A forma mais simples de definir uma classe é :

class ClassName:
<statement-1>
.
.
.
<statement-N>

Definiçõ es de classe, assim como definiçõ es de funçã o (instruçõ es def), precisam ser executadas antes que tenham
qualquer efeito. (Você pode colocar uma definiçã o de classe dentro do teste condicional de um if ou dentro de uma
funçã o.)
Na prá tica, as instruçõ es dentro da definiçã o de classe geralmente serã o definiçõ es de funçõ es, mas outras instruçõ es
sã o permitidas, e à s vezes sã o bem ú teis — voltaremos a este tema depois. Definiçõ es de funçõ es dentro da classe
normalmente tê m um forma peculiar de lista de argumentos, determinada pela convençã o de chamada a mé todos —
isso també m será explicado mais tarde.
Quando se inicia a definiçã o de classe, um novo espaço de nomes é criado, e usado como escopo local — assim, todas
atribuiçõ es a variá veis locais ocorrem nesse espaço de nomes. Em particular, funçõ es definidas aqui sã o vinculadas
a nomes nesse escopo.
Quando uma definiçã o de classe é finalizada normalmente (até o fim), um objeto classe é criado. Este objeto encapsula
o conteú do do espaço de nomes criado pela definiçã o da classe; aprenderemos mais sobre objetos classe na pró xima
seçã o. O escopo local (que estava vigente antes da definiçã o da classe) é reativado, e o objeto classe é vinculado ao
identificador da classe nesse escopo (ClassName no exemplo).

9.3.2 Objetos de Class

Objetos classe suportam dois tipos de operaçõ es: referências a atributos e instanciação.
Referências a atributos de classe utilizam a sintaxe padrã o utilizada para quaisquer referê ncias a atributos em Python:
[Link]. Nomes de atributos vá lidos sã o todos os nomes presentes dentro do espaço de nomes da classe, quando
o objeto classe foi criado. Portanto, se a definiçã o de classe tem esta forma:
class MyClass:
"""A simple example class"""
i = 12345

def f(self):
return 'hello world'

80 Capítulo 9. Classes
 Python Tutorial, Release 3.12.5

entã o MyClass.i e MyClass.f sã o referê ncias a atributo vá lidas, retornando, respectivamente, um inteiro e um
objeto funçã o. Atributos de classe podem receber valores, pode-se modificar o valor de MyClass.i num atribui-
çã o. __doc__ també m é um atributo vá lido da classe, retornando a docstring associada à classe: "A simple
example class".
Para instanciar uma classe, usa-se a mesma sintaxe de invocar uma funçã o. Apenas finja que o objeto classe do
exemplo é uma funçã o sem parâ metros, que devolve uma nova instâ ncia da classe. Por exemplo (presumindo a classe
acima):

x = MyClass()

cria uma nova instância da classe e atribui o objeto resultante à variá vel local x.
A operaçã o de instanciaçã o (“invocar” um objeto classe) cria um objeto vazio. Muitas classes preferem criar no-
vos objetos com um estado inicial predeterminado. Para tanto, a classe pode definir um mé todo especial chamado
__init__(), assim:

def __init__(self):
[Link] = []

Quando uma classe define um mé todo __init__(), o processo de instanciaçã o automaticamente invoca
__init__() sobre a instâ ncia recé m criada. Em nosso exemplo, uma nova instâ ncia já inicializada pode ser
obtida desta maneira:

x = MyClass()

Naturalmente, o mé todo __init__() pode ter parâ metros para maior flexibilidade. Neste caso, os argumentos
fornecidos na invocaçã o da classe serã o passados para o mé todo __init__(). Por exemplo,

>>> class Complex:

... def __init__(self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

9.3.3 Objetos instância

Agora o que podemos fazer com objetos de instâ ncia? As ú nicas operaçõ es compreendidas por objetos de instâ ncia
sã o os atributos de referê ncia. Existem duas maneiras vá lidas para nomear atributos: atributos de dados e mé todos.
Atributos de dados correspondem a “variá veis de instâ ncia” em Smalltalk, e a “membros de dados” em C++. Atributos
de dados nã o precisam ser declarados. Assim como variá veis locais, eles passam a existir na primeira vez em que é
feita uma atribuiçã o. Por exemplo, se x é uma instâ ncia da MyClass criada acima, o pró ximo trecho de có digo irá
exibir o valor 16, sem deixar nenhum rastro:

[Link] = 1
while [Link] < 10:
[Link] = [Link] * 2
print([Link])
del [Link]

The other kind of instance attribute reference is a method. A method is a function that “belongs to” an object.
Nomes de mé todos vá lidos de uma instâ ncia dependem de sua classe. Por definiçã o, cada atributo de uma classe que
é uma funçã o corresponde a um mé todo das instâ ncias. Em nosso exemplo, x.f é uma referê ncia de mé todo vá lida
já que MyClass.f é uma funçã o, enquanto x.i nã o é , já que MyClass.i nã o é uma funçã o. Entretanto, x.f
nã o é o mesmo que MyClass.f. A referê ncia x.f acessa um objeto mé todo e a MyClass.f acessa um objeto
funçã o.

9.3. Uma primeira olhada nas classes 81

Python Tutorial, Release 3.12.5

9.3.4 Objetos método

Normalmente, um mé todo é chamado imediatamente apó s ser referenciado:

x.f()

No exemplo MyClass, o resultado da expressã o acima será a string 'hello world'. No entanto, nã o é obri-
gató rio invocar o mé todo imediatamente: como x.f é també m um objeto ele pode ser atribuído a uma variá vel e
invocado depois. Por exemplo:

xf = x.f
while True:
print(xf())

exibirá o texto hello world até o mundo acabar.

O que ocorre precisamente quando um mé todo é invocado? Você deve ter notado que x.f() foi chamado sem
nenhum argumento, poré m a definiçã o da funçã o f() especificava um argumento. O que aconteceu com esse ar-
gumento? Certamente Python levanta uma exceçã o quando uma funçã o que declara um argumento é invocada sem
nenhum argumento — mesmo que o argumento nã o seja usado no corpo da funçã o…
Na verdade, pode-se supor a resposta: a particularidade sobre os mé todos é que o objeto da instâ ncia é passado como
o primeiro argumento da funçã o. Em nosso exemplo, a chamada x.f() é exatamente equivalente a MyClass.
f(x). Em geral, chamar um mé todo com uma lista de n argumentos é equivalente a chamar a funçã o correspondente
com uma lista de argumentos que é criada inserindo o objeto de instâ ncia do mé todo antes do primeiro argumento.
Em geral, os mé todos funcionam da seguinte forma. Quando um atributo de uma instâ ncia, nã o relacionado a dados,
é referenciado, a classe da instâ ncia é pesquisada. Se o nome é um atributo de classe vá lido que é um objeto funçã o,
referê ncias ao objeto de instâ ncia e ao objeto funçã o serã o empacotadas em um objeto mé todo. Quando o objeto
mé todo é chamado com uma lista de argumentos, uma nova lista de argumentos é construída a partir do objeto de
instâ ncia e da lista de argumentos, e o objeto funçã o é chamado com essa nova lista de argumentos.

9.3.5 Variáveis de classe e instância

De forma geral, variá veis de instâ ncia sã o variá veis que indicam dados que sã o ú nicos a cada instâ ncia individual, e
variá veis de classe sã o variá veis de atributos e de mé todos que sã o comuns a todas as instâ ncias de uma classe:

class Dog:

kind = 'canine' # class variable shared by all instances

def __init__(self, name):

[Link] = name # instance variable unique to each instance

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> [Link] # shared by all dogs
'canine'
>>> [Link] # shared by all dogs
'canine'
>>> [Link] # unique to d
'Fido'
>>> [Link] # unique to e
'Buddy'

Como vimos em Uma palavra sobre nomes e objetos, dados compartilhados podem causar efeitos inesperados quando
envolvem objetos (mutáveis), como listas ou dicioná rios. Por exemplo, a lista tricks do có digo abaixo nã o deve ser
usada como variá vel de classe, pois assim seria compartilhada por todas as instâ ncias de Dog:

82 Capítulo 9. Classes
 Python Tutorial, Release 3.12.5

class Dog:

tricks = [] # mistaken use of a class variable

def __init__(self, name):

[Link] = name

def add_trick(self, trick):

[Link](trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> [Link] # unexpectedly shared by all dogs
['roll over', 'play dead']

Em vez disso, o modelo correto da classe deve usar uma variá vel de instâ ncia:

class Dog:

def __init__(self, name):

[Link] = name
[Link] = [] # creates a new empty list for each dog

def add_trick(self, trick):

[Link](trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> [Link]
['roll over']
>>> [Link]
['play dead']

9.4 Observações aleatórias

Se um mesmo nome de atributo ocorre tanto na instâ ncia quanto na classe, a busca pelo atributo prioriza a instâ ncia:

>>> class Warehouse:

... purpose = 'storage'
... region = 'west'
...
>>> w1 = Warehouse()
>>> print([Link], [Link])
storage west
>>> w2 = Warehouse()
>>> [Link] = 'east'
>>> print([Link], [Link])
storage east

Atributos de dados podem ser referenciados por mé todos da pró pria instâ ncia, bem como por qualquer outro usuá rio
do objeto (també m chamados “clientes” do objeto). Em outras palavras, classes nã o servem para implementar tipos
puramente abstratos de dados. De fato, nada em Python torna possível assegurar o encapsulamento de dados — tudo
é baseado em convençã o. (Por outro lado, a implementaçã o de Python, escrita em C, pode esconder completamente
detalhes de um objeto e controlar o acesso ao objeto, se necessá rio; isto pode ser utilizado por extensõ es de Python
escritas em C.)

9.4. Observações aleatórias 83

Python Tutorial, Release 3.12.5

Clientes devem utilizar atributos de dados com cuidado, pois podem bagunçar invariantes assumidas pelos mé todos ao
esbarrar em seus atributos de dados. Note que clientes podem adicionar atributos de dados a suas pró prias instâ ncias,
sem afetar a validade dos mé todos, desde que seja evitado o conflito de nomes. Novamente, uma convençã o de
nomenclatura poupa muita dor de cabeça.
Nã o existe atalho para referenciar atributos de dados (ou outros mé todos!) de dentro de um mé todo. Isso aumenta a
legibilidade dos mé todos: nã o há como confundir variá veis locais com variá veis da instâ ncia quando lemos rapida-
mente um mé todo.
Frequentemente, o primeiro argumento de um mé todo é chamado self. Isso nã o passa de uma convençã o: o
identificador self nã o é uma palavra reservada nem possui qualquer significado especial em Python. Mas note que,
ao seguir essa convençã o, seu có digo se torna legível por uma grande comunidade de desenvolvedores Python e é
possível que alguma IDE dependa dessa convençã o para analisar seu có digo.
Qualquer objeto funçã o que é atributo de uma classe, define um mé todo para as instâ ncias dessa classe. Nã o é
necessá rio que a definiçã o da funçã o esteja textualmente embutida na definiçã o da classe. Atribuir um objeto funçã o
a uma variá vel local da classe é vá lido. Por exemplo:

# Function defined outside the class

def f1(self, x, y):
return min(x, x+y)

class C:
f = f1

def g(self):
return 'hello world'

h = g

Agora f, g e h sã o todos atributos da classe C que referenciam funçõ es, e consequentemente sã o todos mé todos de
instâ ncias da classe C, onde h é exatamente equivalente a g. No entanto, essa prá tica serve apenas para confundir o
leitor do programa.
Mé todos podem invocar outros mé todos usando atributos de mé todo do argumento self:

class Bag:
def __init__(self):
[Link] = []

def add(self, x):

[Link](x)

def addtwice(self, x):

[Link](x)
[Link](x)

Mé todos podem referenciar nomes globais da mesma forma que funçõ es comuns. O escopo global associado a um
mé todo é o mó dulo contendo sua definiçã o na classe (a classe propriamente dita nunca é usada como escopo global!).
Ainda que seja raro justificar o uso de dados globais em um mé todo, há diversos usos legítimos do escopo global.
Por exemplo, funçõ es e mó dulos importados no escopo global podem ser usados por mé todos, bem como as funçõ es
e classes definidas no pró prio escopo global. Provavelmente, a classe contendo o mé todo em questã o també m foi
definida neste escopo global. Na pró xima seçã o veremos razõ es pelas quais um mé todo pode querer referenciar sua
pró pria classe.
Cada valor é um objeto e, portanto, tem uma classe (també m chamada de tipo). Ela é armazenada como object.
__class__.

84 Capítulo 9. Classes
 Python Tutorial, Release 3.12.5

9.5 Herança

Obviamente, uma característica da linguagem nã o seria digna do nome “classe” se nã o suportasse herança. A sintaxe
para uma classe derivada é assim:

class DerivedClassName(BaseClassName):
<statement-1>
.
.
.
<statement-N>

O identificador BaseClassName deve estar definido em um espaço de nomes acessível do escopo que conté m a
definiçã o da classe derivada. No lugar do nome da classe base, també m sã o aceitas outras expressõ es. Isso é muito
ú til, por exemplo, quando a classe base é definida em outro mó dulo:

class DerivedClassName([Link]):

A execuçã o de uma definiçã o de classe derivada procede da mesma forma que a de uma classe base. Quando o objeto
classe é construído, a classe base é lembrada. Isso é utilizado para resolver referê ncias a atributos. Se um atributo
requisitado nã o for encontrado na classe, ele é procurado na classe base. Essa regra é aplicada recursivamente se a
classe base por sua vez for derivada de outra.
Nã o há nada de especial sobre instanciaçã o de classes derivadas: DerivedClassName() cria uma nova instâ ncia
da classe. Referê ncias a mé todos sã o resolvidas da seguinte forma: o atributo correspondente é procurado atravé s da
cadeia de classes base, e referê ncias a mé todos sã o vá lidas se essa procura produzir um objeto funçã o.
Classes derivadas podem sobrescrever mé todos das suas classes base. Uma vez que mé todos nã o possuem privilé gios
especiais quando invocam outros mé todos no mesmo objeto, um mé todo na classe base que invoca um outro mé todo
da mesma classe base pode, efetivamente, acabar invocando um mé todo sobreposto por uma classe derivada. (Para
programadores C++ isso significa que todos os mé todos em Python sã o realmente virtuais.)
Um mé todo sobrescrito em uma classe derivada, de fato, pode querer estender, em vez de simplesmente substituir,
o mé todo da classe base, de mesmo nome. Existe uma maneira simples de chamar diretamente o mé todo da classe
base: apenas chame [Link](self, arguments). Isso é geralmente ú til para os
clientes també m. (Note que isto só funciona se a classe base estiver acessível como BaseClassName no escopo
global).
Python tem duas funçõ es embutidas que trabalham com herança:
• Use isinstance() para verificar o tipo de uma instâ ncia: isinstance(obj, int) será True so-
mente se obj.__class__ é a classe int ou alguma classe derivada de int.
• Use issubclass() para verificar herança entre classes: issubclass(bool, int) é True porque
bool é uma subclasse de int. Poré m, issubclass(float, int) é False porque float nã o é
uma subclasse de int.

9.5.1 Herança múltipla

Python també m suporta uma forma de herança mú ltipla. Uma definiçã o de classe com vá rias classes bases tem esta
forma:

class DerivedClassName(Base1, Base2, Base3):

<statement-1>
.
.
.
<statement-N>

Para a maioria dos casos mais simples, pense na pesquisa de atributos herdados de uma classe pai como o primeiro
nível de profundidade, da esquerda para a direita, nã o pesquisando duas vezes na mesma classe em que há uma

9.5. Herança 85
Python Tutorial, Release 3.12.5

sobreposiçã o na hierarquia. Assim, se um atributo nã o é encontrado em DerivedClassName, é procurado em

Base1, depois, recursivamente, nas classes base de Base1, e se nã o for encontrado lá , é pesquisado em Base2 e
assim por diante.
De fato, é um pouco mais complexo que isso; a ordem de resoluçã o de mé todos muda dinamicamente para suportar
chamadas cooperativas para super(). Essa abordagem é conhecida em outras linguagens de herança mú ltipla
como chamar-o-pró ximo-mé todo, e é mais poderosa que a chamada à funçã o super, encontrada em linguagens de
herança ú nica.
A ordenaçã o dinâ mica é necessá ria porque todos os casos de herança mú ltipla exibem um ou mais relacionamentos
de diamante (em que pelo menos uma das classes bases pode ser acessada por meio de vá rios caminhos da classe mais
inferior). Por exemplo, todas as classes herdam de object, portanto, qualquer caso de herança mú ltipla fornece
mais de um caminho para alcançar object. Para evitar que as classes base sejam acessadas mais de uma vez,
o algoritmo dinâ mico lineariza a ordem de pesquisa, de forma a preservar a ordenaçã o da esquerda para a direita,
especificada em cada classe, que chama cada pai apenas uma vez, e que é monotô nica (significando que uma classe
pode ser subclassificada sem afetar a ordem de precedê ncia de seus pais). Juntas, essas propriedades tornam possível
projetar classes confiá veis e extensíveis com herança mú ltipla. Para mais detalhes, veja python_2.3_mro.

9.6 Variáveis privadas

Variá veis de instâ ncia “privadas”, que nã o podem ser acessadas, exceto em mé todos do pró prio objeto, nã o existem
em Python. No entanto, existe uma convençã o que é seguida pela maioria dos programas em Python: um nome
prefixado com um sublinhado (por exemplo: _spam ) deve ser tratado como uma parte nã o-pú blica da API (seja
uma funçã o, um mé todo ou um atributo de dados). Tais nomes devem ser considerados um detalhe de implementaçã o
e sujeito a alteraçã o sem aviso pré vio.
Uma vez que existe um caso de uso vá lido para a definiçã o de atributos privados em classes (especificamente para
evitar conflitos com nomes definidos em subclasses), existe um suporte limitado a identificadores privados em classes,
chamado desfiguração de nomes. Qualquer identificador no formato __spam (pelo menos dois sublinhados no início,
e no má ximo um sublinhado no final) é textualmente substituído por _classname__spam, onde classname
é o nome da classe atual com sublinhado(s) iniciais omitidos. Essa desfiguraçã o independe da posiçã o sintá tica do
identificador, desde que ele apareça dentro da definiçã o de uma classe.

Ver também

The private name mangling specifications for details and special cases.

A desfiguraçã o de nomes é ú til para que subclasses possam sobrescrever mé todos sem quebrar invocaçõ es de mé todos
dentro de outra classe. Por exemplo:

class Mapping:
def __init__(self, iterable):
self.items_list = []
self.__update(iterable)

def update(self, iterable):

for item in iterable:
self.items_list.append(item)

__update = update # private copy of original update() method

class MappingSubclass(Mapping):

def update(self, keys, values):

# provides new signature for update()
# but does not break __init__()
for item in zip(keys, values):
self.items_list.append(item)

86 Capítulo 9. Classes
 Python Tutorial, Release 3.12.5

O exemplo acima deve funcionar mesmo se MappingSubclass introduzisse um identificador __update uma
vez que é substituído por _Mapping__update na classe Mapping e _MappingSubclass__update na
classe MappingSubclass, respectivamente.
Note que as regras de desfiguraçã o de nomes foram projetadas para evitar acidentes; ainda é possível acessar ou mo-
dificar uma variá vel que é considerada privada. Isso pode ser ú til em certas circunstâ ncias especiais, como depuraçã o
de có digo.
Có digo passado para exec() ou eval() nã o considera o nome da classe que invocou como sendo a classe corrente;
isso é semelhante ao funcionamento da instruçã o global, cujo efeito se aplica somente ao có digo que é compilado
junto. A mesma restriçã o se aplica à s funçõ es getattr(), setattr() e delattr(), e quando acessamos
diretamente o __dict__ da classe.

9.7 Curiosidades e conclusões

Às vezes, é ú til ter um tipo semelhante ao “record” de Pascal ou ao “struct” de C, para agrupar alguns itens de dados.
A maneira pythô nica para este fim é usar dataclasses:

from dataclasses import dataclass

@dataclass
class Employee:
name: str
dept: str
salary: int

>>> john = Employee('john', 'computer lab', 1000)

>>> [Link]
'computer lab'
>>> [Link]
1000

Um trecho de có digo Python que espera um tipo de dado abstrato em particular, pode receber, ao invé s disso, uma
classe que imita os mé todos que aquele tipo suporta. Por exemplo, se você tem uma funçã o que formata dados
obtidos de um objeto do tipo “arquivo”, pode definir uma classe com mé todos read() e readline() que obté m
os dados de um “buffer de caracteres” e passar como argumento.
Mé todos de instâ ncia tê m atributos també m: m.__self__ é o objeto instâ ncia com o mé todo m(), e m.
__func__ é o objeto funçã o correspondente ao mé todo.

9.8 Iteradores

Você já deve ter notado que pode usar laços for com a maioria das coleçõ es em Python:

for element in [1, 2, 3]:

print(element)
for element in (1, 2, 3):
print(element)
for key in {'one':1, 'two':2}:
print(key)
for char in "123":
print(char)
for line in open("[Link]"):
print(line, end='')

Esse estilo de acesso é claro, conciso e conveniente. O uso de iteradores permeia e unifica o Python. Nos bas-
tidores, a instruçã o for chama iter() no objeto contê iner. A funçã o retorna um objeto iterador que define
o mé todo __next__() que acessa elementos no contê iner, um de cada vez. Quando nã o há mais elementos,

9.7. Curiosidades e conclusões 87

Python Tutorial, Release 3.12.5

__next__() levanta uma exceçã o StopIteration que informa ao for para terminar. Você pode chamar o
mé todo __next__() usando a funçã o embutida next(); este exemplo mostra como tudo funciona:

>>> s = 'abc'
>>> it = iter(s)
>>> it
<str_iterator object at 0x10c90e650>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
next(it)
StopIteration

Observando o mecanismo por trá s do protocolo dos iteradores, fica fá cil adicionar esse comportamento à s suas classes.
Defina um mé todo __iter__() que retorna um objeto que tenha um mé todo __next__(). Se uma classe já
define __next__(), entã o __iter__() pode simplesmente retornar self:

class Reverse:
"""Iterator for looping over a sequence backwards."""
def __init__(self, data):
[Link] = data
[Link] = len(data)

def __iter__(self):
return self

def __next__(self):
if [Link] == 0:
raise StopIteration
[Link] = [Link] - 1
return [Link][[Link]]

>>> rev = Reverse('spam')

>>> iter(rev)
<__main__.Reverse object at 0x00A1DB50>
>>> for char in rev:
... print(char)
...
m
a
p
s

9.9 Geradores

Geradores sã o uma ferramenta simples e poderosa para criar iteradores. Sã o escritos como funçõ es normais mas
usam a instruçã o yield quando precisam retornar dados. Cada vez que next() é chamado, o gerador volta ao
ponto onde parou (lembrando todos os valores de dados e qual instruçã o foi executada pela ú ltima vez). Um exemplo
mostra como geradores podem ser trivialmente fá ceis de criar:

def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]

88 Capítulo 9. Classes
 Python Tutorial, Release 3.12.5

>>> for char in reverse('golf'):

... print(char)
...
f
l
o
g

Qualquer coisa que possa ser feita com geradores també m pode ser feita com iteradores baseados numa classe, como
descrito na seçã o anterior. O que torna geradores tã o compactos é que os mé todos __iter__() e __next__()
sã o criados automaticamente.
Outro ponto chave é que as variá veis locais e o estado da execuçã o sã o preservados automaticamente entre as cha-
madas. Isto torna a funçã o mais fá cil de escrever e muito mais clara do que uma implementaçã o usando variá veis de
instâ ncia como [Link] e [Link].
Alé m disso, quando geradores terminam, eles levantam StopIteration automaticamente. Combinados, todos
estes aspectos tornam a criaçã o de iteradores tã o fá cil quanto escrever uma funçã o normal.

9.10 Expressões geradoras

Alguns geradores simples podem ser codificados, de forma sucinta, como expressõ es, usando uma sintaxe semelhante
a compreensõ es de lista, mas com parê nteses em vez de colchetes. Essas expressõ es sã o projetadas para situaçõ es em
que o gerador é usado imediatamente, pela funçã o que o engloba. As expressõ es geradoras sã o mais compactas, mas
menos versá teis do que as definiçõ es completas do gerador, e tendem a usar menos memó ria do que as compreensõ es
de lista equivalentes.
Exemplos:

>>> sum(i*i for i in range(10)) # sum of squares

285

>>> xvec = [10, 20, 30]

>>> yvec = [7, 5, 3]
>>> sum(x*y for x,y in zip(xvec, yvec)) # dot product
260

>>> unique_words = set(word for line in page for word in [Link]())

>>> valedictorian = max(([Link], [Link]) for student in graduates)

>>> data = 'golf'

>>> list(data[i] for i in range(len(data)-1, -1, -1))
['f', 'l', 'o', 'g']

9.10. Expressões geradoras 89

Python Tutorial, Release 3.12.5

90 Capítulo 9. Classes
 CAPÍTULO 10

Um breve passeio pela biblioteca padrão

10.1 Interface com o sistema operacional

O mó dulo os fornece dú zias de funçõ es para interagir com o sistema operacional:

>>> import os
>>> [Link]() # Return the current working directory
'C:\\Python312'
>>> [Link]('/server/accesslogs') # Change current working directory
>>> [Link]('mkdir today') # Run the command mkdir in the system shell
0

Certifique-se de usar a forma import os ao invé s de from os import *. Isso evitará que [Link]()
oculte a funçã o open() que opera de forma muito diferente.
As funçõ es embutidas dir() e help() sã o ú teis como um sistema de ajuda interativa para lidar com mó dulos
grandes como os:

>>> import os
>>> dir(os)
<returns a list of all module functions>
>>> help(os)
<returns an extensive manual page created from the module's docstrings>

Para tarefas de gerenciamento cotidiano de arquivos e diretó rios, o mó dulo shutil fornece uma interface de alto
nível que é mais simples de usar:

>>> import shutil

>>> [Link]('[Link]', '[Link]')
'[Link]'
>>> [Link]('/build/executables', 'installdir')
'installdir'

91
Python Tutorial, Release 3.12.5

10.2 Caracteres curinga

O mó dulo glob fornece uma funçã o para criar listas de arquivos a partir de buscas em diretó rios usando caracteres
curinga:

>>> import glob

>>> [Link]('*.py')
['[Link]', '[Link]', '[Link]']

10.3 Argumentos de linha de comando

Scripts geralmente precisam processar argumentos passados na linha de comando. Esses argumentos sã o armazena-
dos como uma lista no atributo argv do mó dulo sys. Por exemplo, consideremos o arquivo [Link] a seguir:

# File [Link]
import sys
print([Link])

Aqui está a saída da execuçã o python [Link] one two three na linha de comando:

['[Link]', 'one', 'two', 'three']

O mó dulo argparse fornece um mecanismo mais sofisticado para processar argumentos de linha de comando. O
script seguinte extrai e exibe um ou mais nomes de arquivos e um nú mero de linhas opcional:

import argparse

parser = [Link](
prog='top',
description='Show top lines from each file')
parser.add_argument('filenames', nargs='+')
parser.add_argument('-l', '--lines', type=int, default=10)
args = parser.parse_args()
print(args)

Quando executada a linha de comando python [Link] --lines=5 [Link] [Link], o script de-
fine [Link] para 5 e [Link] para ['[Link]', '[Link]'].

10.4 Redirecionamento de erros e encerramento do programa

O mó dulo sys també m possui atributos para stdin, stdout e stderr. O ú ltimo é usado para emitir avisos e mensagens
de erros visíveis mesmo quando stdout foi redirecionado:

>>> [Link]('Warning, log file not found starting a new one\n')

Warning, log file not found starting a new one

A forma mais direta de encerrar um script é usando [Link]().

92 Capítulo 10. Um breve passeio pela biblioteca padrão

 Python Tutorial, Release 3.12.5

10.5 Reconhecimento de padrões em strings

O mó dulo re fornece ferramentas para lidar com processamento de strings atravé s de expressõ es regulares. Para
reconhecimento de padrõ es complexos, expressõ es regulares oferecem uma soluçã o sucinta e eficiente:

>>> import re
>>> [Link](r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> [Link](r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

Quando as exigê ncias sã o simples, mé todos de strings sã o preferíveis por serem mais fá ceis de ler e depurar:

>>> 'tea for too'.replace('too', 'two')

'tea for two'

10.6 Matemática

The math module gives access to the underlying C library functions for floating-point math:

>>> import math

>>> [Link]([Link] / 4)
0.70710678118654757
>>> [Link](1024, 2)
10.0

O mó dulo random fornece ferramentas para gerar seleçõ es aleató rias:

>>> import random

>>> [Link](['apple', 'pear', 'banana'])
'apple'
>>> [Link](range(100), 10) # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> [Link]() # random float
0.17970987693706186
>>> [Link](6) # random integer chosen from range(6)
4

O mó dulo statistics calcula as propriedades estatísticas bá sicas (a mé dia, a mediana, a variaçã o, etc.) de dados
numé ricos:

>>> import statistics

>>> data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]
>>> [Link](data)
1.6071428571428572
>>> [Link](data)
1.25
>>> [Link](data)
1.3720238095238095

O projeto SciPy <[Link] tem muitos outros mó dulos para cá lculos numé ricos.

10.5. Reconhecimento de padrões em strings 93

Python Tutorial, Release 3.12.5

10.7 Acesso à internet

Há diversos mó dulos para acesso e processamento de protocolos da internet. Dois dos mais simples sã o urllib.
request para efetuar download de dados a partir de URLs e smtplib para enviar mensagens de correio eletrô nico:

>>> from [Link] import urlopen

>>> with urlopen('[Link] as response:
... for line in response:
... line = [Link]() # Convert bytes to a str
... if [Link]('datetime'):
... print([Link]()) # Remove trailing newline
...
datetime: 2022-01-01T01:36:47.689215+00:00

>>> import smtplib

>>> server = [Link]('localhost')
>>> [Link]('soothsayer@[Link]', 'jcaesar@[Link]',
... """To: jcaesar@[Link]
... From: soothsayer@[Link]
...
... Beware the Ides of March.
... """)
>>> [Link]()

(Note que o segundo exemplo precisa de um servidor de email rodando em localhost.)

10.8 Data e hora

O mó dulo datetime fornece classes para manipulaçã o de datas e horas nas mais variadas formas. Apesar da
disponibilidade de aritmé tica com data e hora, o foco da implementaçã o é na extraçã o eficiente dos membros para
formataçã o e manipulaçã o. O mó dulo també m oferece objetos que levam os fusos horá rios em consideraçã o.

>>> # dates are easily constructed and formatted

>>> from datetime import date
>>> now = [Link]()
>>> now
[Link](2003, 12, 2)
>>> [Link]("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'

>>> # dates support calendar arithmetic

>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> [Link]
14368

10.9 Compressão de dados

Formatos comuns de arquivamento e compressã o de dados estã o disponíveis diretamente atravé s de alguns mó dulos,
entre eles: zlib, gzip, bz2, lzma, zipfile and tarfile.

>>> import zlib

>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = [Link](s)
(continua na pró xima pá gina)

94 Capítulo 10. Um breve passeio pela biblioteca padrão

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

>>> len(t)
37
>>> [Link](t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979

10.10 Medição de desempenho

Alguns usuá rios de Python desenvolvem um interesse profundo pelo desempenho relativo de diferentes abordagens
para o mesmo problema. Python oferece uma ferramenta de mediçã o que esclarece essas dú vidas rapidamente.
Por exemplo, pode ser tentador usar o empacotamento e desempacotamento de tuplas ao invé s da abordagem tradici-
onal de permutar os argumentos. O mó dulo timeit rapidamente mostra uma modesta vantagem de desempenho:

>>> from timeit import Timer

>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791

Em contraste com a granularidade fina do mó dulo timeit, os mó dulos profile e pstats oferecem ferramentas
para identificar os trechos mais críticos em grandes blocos de có digo.

10.11 Controle de qualidade

Uma das abordagens usadas no desenvolvimento de software de alta qualidade é escrever testes para cada funçã o à
medida que é desenvolvida e executar esses testes frequentemente durante o processo de desenvolvimento.
O mó dulo doctest oferece uma ferramenta para realizar um trabalho de varredura e validaçã o de testes escritos
nas strings de documentaçã o (docstrings) de um programa. A construçã o dos testes é tã o simples quanto copiar uma
chamada típica juntamente com seus resultados e colá -los na docstring. Isto aprimora a documentaçã o, fornecendo
ao usuá rio um exemplo real, e permite que o mó dulo doctest verifique se o có digo continua fiel à documentaçã o:

def average(values):
"""Computes the arithmetic mean of a list of numbers.

>>> print(average([20, 30, 70]))

40.0
"""
return sum(values) / len(values)

import doctest
[Link]() # automatically validate the embedded tests

O mó dulo unittest nã o é tã o simples de usar quanto o mó dulo doctest, mas permite que um conjunto muito
maior de testes seja mantido em um arquivo separado:

import unittest

class TestStatisticalFunctions([Link]):

def test_average(self):
[Link](average([20, 30, 70]), 40.0)
[Link](round(average([1, 5, 7]), 1), 4.3)
with [Link](ZeroDivisionError):
(continua na pró xima pá gina)

10.10. Medição de desempenho 95

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

average([])
with [Link](TypeError):
average(20, 30, 70)

[Link]() # Calling from the command line invokes all tests

10.12 Baterias incluídas

Python tem uma filosofia de “baterias incluídas”. Isso fica mais evidente atravé s da sofisticaçã o e robustez dos seus
maiores pacotes. Por exemplo:
• Os mó dulos [Link] e [Link] tornam a implementaçã o de chamadas remotas (remote
procedure calls) em uma tarefa quase trivial. Apesar dos nomes dos mó dulos, nenhum conhecimento direto
ou manipulaçã o de XML é necessá rio.
• O pacote email é uma biblioteca para gerenciamento de mensagens de correio eletrô nico, incluindo MIME
e outros baseados no RFC 2822. Diferente dos mó dulos smtplib e poplib que apenas enviam e rece-
bem mensagens, o pacote de email tem um conjunto completo de ferramentas para construir ou decodificar
a estrutura de mensagens complexas (incluindo anexos) e para implementaçã o de protocolos de codificaçã o e
cabeçalhos.
• O pacote json oferece um suporte robusto para analisar este popular formato para troca de dados. O mó dulo
csv oferece suporte para leitura e escrita direta em arquivos no formato Comma-Separated Value, comumente
suportado por bancos de dados e planilhas. O processamento XML é fornecido pelos pacotes [Link].
ElementTree, [Link] e [Link]. Juntos, esses mó dulos e pacotes simplificam muito a troca de
informaçõ es entre aplicativos Python e outras ferramentas.
• O mó dulo sqlite3 é um wrapper para a biblioteca de banco de dados SQLite, fornecendo um banco de
dados persistente que pode ser atualizado e acessado usando sintaxe SQL ligeiramente fora do padrã o.
• Internacionalizaçã o está disponível atravé s de diversos mó dulos, como gettext, locale, e o pacote
codecs.

96 Capítulo 10. Um breve passeio pela biblioteca padrão

 CAPÍTULO 11

Um breve passeio pela biblioteca padrão — parte II

Este segundo passeio apresenta alguns mó dulos avançados que atendem necessidades de programaçã o profissional.
Estes mó dulos raramente aparecem em scripts pequenos.

11.1 Formatando a saída

O mó dulo reprlib fornece uma versã o de repr() personalizado para exibiçõ es abreviadas de contê ineres grandes
ou profundamente aninhados:

>>> import reprlib

>>> [Link](set('supercalifragilisticexpialidocious'))
"{'a', 'c', 'd', 'e', 'f', 'g', ...}"

O mó dulo pprint oferece um controle mais sofisticado na exibiçã o tanto de objetos embutidos quanto aqueles
criados pelo usuá rio de maneira que fique legível para o interpretador. Quando o resultado é maior que uma linha, o
“pretty printer” acrescenta quebras de linha e indentaçã o para revelar as estruturas de maneira mais clara:

>>> import pprint

>>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',
... 'yellow'], 'blue']]]
...
>>> [Link](t, width=30)
[[[['black', 'cyan'],
'white',
['green', 'red']],
[['magenta', 'yellow'],
'blue']]]

O mó dulo textwrap formata pará grafos de texto para que caibam em uma dada largura de tela:

>>> import textwrap

>>> doc = """The wrap() method is just like fill() except that it returns
... a list of strings instead of one big string with newlines to separate
... the wrapped lines."""
...
>>> print([Link](doc, width=40))
The wrap() method is just like fill()
(continua na pró xima pá gina)

97
Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

except that it returns a list of strings
instead of one big string with newlines
to separate the wrapped lines.

O mó dulo locale acessa uma base de dados de formatos específicos a determinada cultura. O atributo de agrupa-
mento da funçã o “format” oferece uma forma direta de formatar nú meros com separadores de grupo:
>>> import locale
>>> [Link](locale.LC_ALL, 'English_United States.1252')
'English_United States.1252'
>>> conv = [Link]() # get a mapping of conventions
>>> x = 1234567.8
>>> locale.format_string("%d", x, grouping=True)
'1,234,567'
>>> locale.format_string("%s%.*f", (conv['currency_symbol'],
... conv['frac_digits'], x), grouping=True)
'$1,234,567.80'

11.2 Usando templates

mó dulo string inclui a versá til classe Template com uma sintaxe simplificada, adequada para ser editada por
usuá rios finais. Isso permite que usuá rios personalizem suas aplicaçõ es sem a necessidade de alterar a aplicaçã o.
Em um template sã o colocadas marcaçõ es indicando o local onde o texto variá vel deve ser inserido. Uma marcaçã o
é formada por $ seguido de um identificador Python vá lido (caracteres alfanumé ricos e underscores). Envolvendo-
-se o identificador da marcaçã o entre chaves, permite que ele seja seguido por mais caracteres alfanumé ricos sem a
necessidade de espaços. Escrevendo-se $$ cria-se um ú nico $:
>>> from string import Template
>>> t = Template('${village}folk send $$10 to $cause.')
>>> [Link](village='Nottingham', cause='the ditch fund')
'Nottinghamfolk send $10 to the ditch fund.'

O mé todo substitute() levanta uma exceçã o KeyError quando o identificador de uma marcaçã o nã o é for-
necido em um dicioná rio ou em um argumento nomeado (keyword argument). Para aplicaçõ es que podem receber
dados incompletos fornecidos pelo usuá rio, o mé todo safe_substitute() pode ser mais apropriado — deixará
os marcadores intactos se os dados estiverem faltando:
>>> t = Template('Return the $item to $owner.')
>>> d = dict(item='unladen swallow')
>>> [Link](d)
Traceback (most recent call last):
...
KeyError: 'owner'
>>> t.safe_substitute(d)
'Return the unladen swallow to $owner.'

Subclasses de Template podem especificar um delimitador personalizado. Por exemplo, um utilitá rio para renome-
açã o em lote de fotos pode usar o sinal de porcentagem para marcaçõ es como a data atual, nú mero sequencial da
imagem ou formato do aquivo:
>>> import time, [Link]
>>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
>>> class BatchRename(Template):
... delimiter = '%'
...
>>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format): ')
Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f
(continua na pró xima pá gina)

98 Capítulo 11. Um breve passeio pela biblioteca padrão — parte II

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

>>> t = BatchRename(fmt)
>>> date = [Link]('%d%b%y')
>>> for i, filename in enumerate(photofiles):
... base, ext = [Link](filename)
... newname = [Link](d=date, n=i, f=ext)
... print('{0} --> {1}'.format(filename, newname))

img_1074.jpg --> Ashley_0.jpg

img_1076.jpg --> Ashley_1.jpg
img_1077.jpg --> Ashley_2.jpg

Outra aplicaçã o para templates é separar a ló gica da aplicaçã o dos detalhes de mú ltiplos formatos de saída. Assim
é possível usar templates personalizados para gerar arquivos XML, relató rios em texto puro e relató rios web em
HTML.

11.3 Trabalhando com formatos binários de dados

O mó dulo struct oferece as funçõ es pack() e unpack() para trabalhar com registros biná rios de tamanho
variá vel. O exemplo a seguir mostra como iterar atravé s do cabeçalho de informaçã o num aquivo ZIP sem usar o
mó dulo zipfile. Os có digos de empacotamento "H" e "I" representam nú meros sem sinal de dois e quatro bytes
respectivamente. O "<" indica que os nú meros tê m tamanho padrã o e sã o little-endian (bytes menos significativos
primeiro):
import struct

with open('[Link]', 'rb') as f:

data = [Link]()

start = 0
for i in range(3): # show the first 3 file headers
start += 14
fields = [Link]('<IIIHH', data[start:start+16])
crc32, comp_size, uncomp_size, filenamesize, extra_size = fields

start += 16
filename = data[start:start+filenamesize]
start += filenamesize
extra = data[start:start+extra_size]
print(filename, hex(crc32), comp_size, uncomp_size)

start += extra_size + comp_size # skip to the next header

11.4 Multi-threading

O uso de threads é uma té cnica para desacoplar tarefas que nã o sã o sequencialmente dependentes. Threads podem
ser usadas para melhorar o tempo de resposta de aplicaçõ es que aceitam entradas do usuá rio enquanto outras tarefas
sã o executadas em segundo plano. Um caso relacionado é executar açõ es de entrada e saída (I/O) em uma thread
paralelamente a cá lculos em outra thread.
O có digo a seguir mostra como o mó dulo de alto nível threading pode executar tarefas em segundo plano enquanto
o programa principal continua a sua execuçã o:
import threading, zipfile

class AsyncZip([Link]):
(continua na pró xima pá gina)

11.3. Trabalhando com formatos binários de dados 99

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

def __init__(self, infile, outfile):
[Link].__init__(self)
[Link] = infile
[Link] = outfile

def run(self):
f = [Link]([Link], 'w', zipfile.ZIP_DEFLATED)
[Link]([Link])
[Link]()
print('Finished background zip of:', [Link])

background = AsyncZip('[Link]', '[Link]')

[Link]()
print('The main program continues to run in foreground.')

[Link]() # Wait for the background task to finish

print('Main program waited until background was done.')

O principal desafio para as aplicaçõ es que usam mú ltiplas threads é coordenar as threads que compartilham dados
ou outros recursos. Para esta finalidade, o mó dulo threading oferece alguns mecanismos primitivos de sincronizaçã o,
como travas, eventos, variá veis de condiçã o e semá foros.
Ainda que todas essas ferramentas sejam poderosas, pequenos erros de design podem resultar em problemas difíceis
de serem diagnosticados. Por isso, a abordagem preferida para a coordenaçã o da tarefa é concentrar todo o acesso a
um recurso em um ú nico tó pico e, em seguida, usar o mó dulo queue para alimentar esse segmento com solicitaçõ es
de outros tó picos. Aplicaçõ es que utilizam objetos Queue para comunicaçã o e coordenaçã o inter-thread sã o mais
fá ceis de serem projetados, mais legíveis e mais confiá veis.

11.5 Gerando logs

O mó dulo logging oferece um completo e flexível sistema de log. Da maneira mais simples, mensagens de log sã o
enviadas para um arquivo ou para [Link]:

import logging
[Link]('Debugging information')
[Link]('Informational message')
[Link]('Warning:config file %s not found', '[Link]')
[Link]('Error occurred')
[Link]('Critical error -- shutting down')

Isso produz a seguinte saída:

WARNING:root:Warning:config file [Link] not found

ERROR:root:Error occurred
CRITICAL:root:Critical error -- shutting down

Por padrã o, mensagens informativas e de depuraçã o sã o suprimidas e a saída é enviada para a saída de erros padrã o
(stderr). Outras opçõ es de saída incluem envio de mensagens atravé s de correio eletrô nico, datagramas, sockets
ou para um servidor HTTP. Novos filtros podem selecionar diferentes formas de envio de mensagens, baseadas na
prioridade da mensagem: DEBUG, INFO, WARNING, ERROR e CRITICAL.
O sistema de log pode ser configurado diretamente do Python ou pode ser carregado a partir de um arquivo de
configuraçã o editá vel pelo usuá rio para logs personalizados sem a necessidade de alterar a aplicaçã o.

100 Capítulo 11. Um breve passeio pela biblioteca padrão — parte II

 Python Tutorial, Release 3.12.5

11.6 Referências fracas

Python faz gerenciamento automá tico de memó ria (contagem de referê ncias para a maioria dos objetos e garbage
collection [coleta de lixo] para eliminar ciclos). A memó ria ocupada por um objeto é liberada logo depois da ú ltima
referê ncia a ele ser eliminada.
Essa abordagem funciona bem para a maioria das aplicaçõ es, mas ocasionalmente surge a necessidade de rastrear
objetos apenas enquanto estã o sendo usados por algum outro. Infelizmente rastreá -los cria uma referê ncia, e isso
os fazem permanentes. O mó dulo weakref oferece ferramentas para rastrear objetos sem criar uma referê ncia.
Quando o objeto nã o é mais necessá rio, ele é automaticamente removido de uma tabela de referê ncias fracas e uma
chamada (callback) é disparada. Aplicaçõ es típicas incluem cacheamento de objetos que sã o muito custosos para
criar:

>>> import weakref, gc

>>> class A:
... def __init__(self, value):
... [Link] = value
... def __repr__(self):
... return str([Link])
...
>>> a = A(10) # create a reference
>>> d = [Link]()
>>> d['primary'] = a # does not create a reference
>>> d['primary'] # fetch the object if it is still alive
10
>>> del a # remove the one reference
>>> [Link]() # run garbage collection right away
0
>>> d['primary'] # entry was automatically removed
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
d['primary'] # entry was automatically removed
File "C:/python312/lib/[Link]", line 46, in __getitem__
o = [Link][key]()
KeyError: 'primary'

11.7 Ferramentas para trabalhar com listas

Muitas necessidades envolvendo estruturas de dados podem ser satisfeitas com o tipo embutido lista. Entretanto,
algumas vezes há uma necessidade por implementaçõ es alternativas que sacrificam algumas facilidades em nome de
melhor desempenho.
The array module provides an array object that is like a list that stores only homogeneous data and stores it more
compactly. The following example shows an array of numbers stored as two byte unsigned binary numbers (typecode
"H") rather than the usual 16 bytes per entry for regular lists of Python int objects:

>>> from array import array

>>> a = array('H', [4000, 10, 700, 22222])
>>> sum(a)
26932
>>> a[1:3]
array('H', [10, 700])

The collections module provides a deque object that is like a list with faster appends and pops from the left
side but slower lookups in the middle. These objects are well suited for implementing queues and breadth first tree
searches:

11.6. Referências fracas 101

Python Tutorial, Release 3.12.5

>>> from collections import deque

>>> d = deque(["task1", "task2", "task3"])
>>> [Link]("task4")
>>> print("Handling", [Link]())
Handling task1

unsearched = deque([starting_node])
def breadth_first_search(unsearched):
node = [Link]()
for m in gen_moves(node):
if is_goal(m):
return m
[Link](m)

Alé m de implementaçõ es alternativas de listas, a biblioteca també m oferece outras ferramentas como o mó dulo
bisect com funçõ es para manipulaçã o de listas ordenadas:

>>> import bisect

>>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
>>> [Link](scores, (300, 'ruby'))
>>> scores
[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]

O mó dulo heapq oferece funçõ es para implementaçã o de heaps baseadas em listas normais. O valor mais baixo é
sempre mantido na posiçã o zero. Isso é ú til para aplicaçõ es que acessam repetidamente o menor elemento, mas nã o
querem reordenar a lista toda a cada acesso:

>>> from heapq import heapify, heappop, heappush

>>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
>>> heapify(data) # rearrange the list into heap order
>>> heappush(data, -5) # add a new entry
>>> [heappop(data) for i in range(3)] # fetch the three smallest entries
[-5, 0, 1]

11.8 Decimal Floating-Point Arithmetic

The decimal module offers a Decimal datatype for decimal floating-point arithmetic. Compared to the built-in
float implementation of binary floating point, the class is especially helpful for
• aplicaçõ es financeiras que requerem representaçã o decimal exata,
• controle sobre a precisã o,
• controle sobre arredondamento para satisfazer requisitos legais,
• rastreamento de casas decimais significativas, ou
• aplicaçõ es onde o usuá rio espera que os resultados sejam os mesmos que os dos cá lculos feitos à mã o.
Por exemplo, calcular um imposto de 5% sobre uma chamada telefô nica de 70 centavos devolve diferentes resul-
tados com aritmé tica de ponto flutuante decimal ou biná ria. A diferença torna-se significativa se os resultados sã o
arredondados para o centavo mais pró ximo:

>>> from decimal import *

>>> round(Decimal('0.70') * Decimal('1.05'), 2)
Decimal('0.74')
>>> round(.70 * 1.05, 2)
0.73

102 Capítulo 11. Um breve passeio pela biblioteca padrão — parte II

 Python Tutorial, Release 3.12.5

O resultado de Decimal considera zeros à direita, automaticamente inferindo quatro casas decimais a partir de
multiplicandos com duas casas decimais. O mó dulo Decimal reproduz a aritmé tica como fazemos à mã o e evita pro-
blemas que podem ocorrer quando a representaçã o biná ria do ponto flutuante nã o consegue representar quantidades
decimais com exatidã o.
A representaçã o exata permite à classe Decimal executar cá lculos de mó dulo e testes de igualdade que nã o funci-
onam bem em ponto flutuante biná rio:

>>> Decimal('1.00') % Decimal('.10')

Decimal('0.00')
>>> 1.00 % 0.10
0.09999999999999995

>>> sum([Decimal('0.1')]*10) == Decimal('1.0')

True
>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0
False

O mó dulo decimal implementa a aritmé tica com tanta precisã o quanto necessá ria:

>>> getcontext().prec = 36
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857')

11.8. Decimal Floating-Point Arithmetic 103

Python Tutorial, Release 3.12.5

104 Capítulo 11. Um breve passeio pela biblioteca padrão — parte II

 CAPÍTULO 12

Ambientes virtuais e pacotes

12.1 Introdução

Aplicaçõ es em Python normalmente usam pacotes e mó dulos que nã o vê m como parte da instalaçã o padrã o. Apli-
caçõ es à s vezes necessitam uma versã o específica de uma biblioteca, porque ela requer que algum problema em
particular tenha sido consertado ou foi escrita utilizando-se de uma versã o obsoleta da interface da biblioteca.
Isso significa que talvez nã o seja possível que uma instalaçã o Python preencha os requisitos de qualquer aplicaçã o.
Se uma aplicaçã o A necessita a versã o 1.0 de um mó dulo particular mas a aplicaçã o B necessita a versã o 2.0, os
requisitos entrarã o em conflito e instalar qualquer uma das duas versõ es 1.0 ou 2.0 fará com que uma das aplicaçõ es
nã o consiga executar.
A soluçã o para este problema é criar um ambiente virtual, uma á rvore de diretó rios que conté m uma instalaçã o
Python para uma versã o particular do Python, alé m de uma sé rie de pacotes adicionais.
Diferentes aplicaçõ es podem entã o usar diferentes ambientes virtuais. Para resolver o exemplo anterior de requisitos
conflitantes, a aplicaçã o A deve ter seu pró prio ambiente virtual com a versã o 1.0 instalada enquanto a aplicaçã o B
vai possuir outro ambiente virtual com a versã o 2.0. Se a aplicaçã o B precisar fazer uma atualizaçã o para a versã o
3.0, isso nã o afetará o ambiente da aplicaçã o A.

12.2 Criando ambientes virtuais

The module used to create and manage virtual environments is called venv. venv will install the Python version
from which the command was run (as reported by the --version option). For instance, executing the command
with python3.12 will install version 3.12.
Para criar um ambiente virtual, escolha um diretó rio onde deseja colocá -lo e execute o mó dulo venv como um script
com o caminho do diretó rio:

python -m venv tutorial-env

Isso irá criar o diretó rio tutorial-env se ele nã o existir, e també m criará diretó rios dentro dele contendo uma
có pia do interpretador Python, a biblioteca padrã o e diversos arquivos de suporte.
Um diretó rio de localizaçã o comum para um ambiente virtual é .venv. Esse nome tipicamente manté m o diretó rio
oculto em seu ambiente, portanto é transparente, ao menos tempo que explica o motivo desse diretó rio existir. Tam-
bé m previne conflitos com .env, arquivos de definiçã o de variá veis de ambiente que algumas ferramentas utilizam.

105
Python Tutorial, Release 3.12.5

Uma vez criado seu ambiente virtual, você deve ativá -lo.
No Windows, execute:
tutorial-env\Scripts\activate

No Unix ou no MacOS, executa:

source tutorial-env/bin/activate

(Este script é escrito para o shell bash. Se você usa shells csh ou fish, existem scripts alternativos activate.
csh e [Link] para utilizaçã o.)
Ao ativar seu ambiente virtual haverá uma mudança no prompt do shell para mostrar qual ambiente virtual você
está usando e modificará o ambiente para que quando você executar python ativar a versã o e instalaçã o do Python
particular à quele ambiente. Por exemplo:
$ source ~/envs/tutorial-env/bin/activate
(tutorial-env) $ python
Python 3.5.1 (default, May 6 2016, 10:59:36)
...
>>> import sys
>>> [Link]
['', '/usr/local/lib/[Link]', ...,
'~/envs/tutorial-env/lib/python3.5/site-packages']
>>>

Para desativar um ambiente virtual, digite:

deactivate

no terminal.

12.3 Gerenciando pacotes com o pip

Você pode instalar, atualizar e remover pacotes usando um programa chamado pip. Por padrã o pip irá instalar
pacotes do Python Package Index. Você pode navegar pelo Python Package Index atravé s do seu navegador web.
pip tem uma sé rie de subcomandos: “install”, “uninstall”, “freeze”, etc. (Consulte o guia installing-index para a
documentaçã o completa do pip.)
Você pode instalar a ú ltima versã o de um pacote apenas especificando nome do pacote:
(tutorial-env) $ python -m pip install novas
Collecting novas
Downloading [Link] (136kB)
Installing collected packages: novas
Running [Link] install for novas
Successfully installed novas-[Link]

Você també m pode instalar uma versã o específica de um pacote dando o nome do pacote seguido por == e o nú mero
da versã o:
(tutorial-env) $ python -m pip install requests==2.6.0
Collecting requests==2.6.0
Using cached [Link]
Installing collected packages: requests
Successfully installed requests-2.6.0

Se você executar novamente o comando, pip será notificado de que a versã o já está instalada, e nã o fará nada.
Você pode fornecer um nú mero de versã o diferente para obter essa versã o ou pode executar python -m pip
install --upgrade para atualizar o pacote para a versã o mais recente:

106 Capítulo 12. Ambientes virtuais e pacotes

 Python Tutorial, Release 3.12.5

(tutorial-env) $ python -m pip install --upgrade requests

Collecting requests
Installing collected packages: requests
Found existing installation: requests 2.6.0
Uninstalling requests-2.6.0:
Successfully uninstalled requests-2.6.0
Successfully installed requests-2.7.0

python -m pip uninstall seguido por um ou mais nomes de pacote removerá os pacotes do ambiente vir-
tual.
python -m pip show exibirá informaçõ es sobre um pacote específico:

(tutorial-env) $ python -m pip show requests

---
Metadata-Version: 2.0
Name: requests
Version: 2.7.0
Summary: Python HTTP for Humans.
Home-page: [Link]
Author: Kenneth Reitz
Author-email: me@[Link]
License: Apache 2.0
Location: /Users/akuchling/envs/tutorial-env/lib/python3.4/site-packages
Requires:

python -m pip list exibirá todos os pacotes instalados no ambiente virtual:

(tutorial-env) $ python -m pip list

novas ([Link])
numpy (1.9.2)
pip (7.0.3)
requests (2.7.0)
setuptools (16.0)

python -m pip freeze produzirá uma lista semelhante dos pacotes instalados, mas a saída usa o for-
mato que python -m pip install espera. Uma convençã o comum é colocar esta lista em um arquivo
[Link]:

(tutorial-env) $ python -m pip freeze > [Link]

(tutorial-env) $ cat [Link]
novas==[Link]
numpy==1.9.2
requests==2.7.0

O arquivo [Link] pode ser submetido no controle de versã o e adicionado como parte da aplicaçã o.
Usuá rios poderã o entã o instalar todos os pacotes necessá rios com um install -r:

(tutorial-env) $ python -m pip install -r [Link]

Collecting novas==[Link] (from -r [Link] (line 1))
...
Collecting numpy==1.9.2 (from -r [Link] (line 2))
...
Collecting requests==2.7.0 (from -r [Link] (line 3))
...
Installing collected packages: novas, numpy, requests
Running [Link] install for novas
Successfully installed novas-[Link] numpy-1.9.2 requests-2.7.0

pip tem inú meras outras opçõ es. Consulte o guia installing-index para a documentaçã o completa do pip. Quando
você escrever um pacote e desejar deixá -lo disponível no Python Package Index, consulte o guia de usuá rio para
empacotamento de Python.

12.3. Gerenciando pacotes com o pip 107

Python Tutorial, Release 3.12.5

108 Capítulo 12. Ambientes virtuais e pacotes

 CAPÍTULO 13

E agora?

Ler este tutorial provavelmente reforçou seu interesse em usar Python — você deve estar ansioso para aplicar Python
para resolver problemas do mundo real. Aonde você deveria ir para aprender mais?
Este tutorial é parte do conjunto de documentaçã o da linguagem Python. Alguns outros documentos neste conjunto
sã o:
• library-index:
Você deveria navegar atravé s deste manual, que lhe dará material completo (ainda que breve) de referê ncia
sobre tipos, funçõ es e mó dulos na biblioteca padrã o. A distribuiçã o padrã o do Python inclui muito có digo
adicional. Há mó dulos para ler caixa de correio Unix, baixar documentos via HTTP, gerar nú meros aleató rios,
processar opçõ es de linha de comando, comprimir dados a muitas outras tarefas. Uma lida rá pida da Referê ncia
da Biblioteca lhe dará uma ideia do que está disponível.
• installing-index explica como instalar mó dulos adicionais escritos por outros usuá rios de Python.
• reference-index: Uma explicaçã o detalhada da sintaxe e da semâ ntica de Python. É uma leitura pesada, mas é
ú til como um guia completo da linguagem propriamente dita.
Mais recursos Python:
• [Link] o principal web site sobre Python. Conté m có digo, documentaçã o, e referê ncias para
outras pá ginas relacionadas a Python ao redor da web.
• [Link] acesso rá pido à documentaçã o Python.
• [Link] O Python Package Index, anteriormente apelidado de Cheese Shop1 , é um índice de mó dulos
Python criados pelos usuá rios. Uma vez que você começa a publicar có digo, pode registrar seus pacotes aqui
para que outros possam encontrá -los.
• [Link] O Python Cookbook (livro de receitas de Python) é uma
grande coleçã o de exemplos de có digo, mó dulos maiores e scripts ú [Link]çõ es particularmente notá veis
sã o coletadas em um livro també m chamado Python Cookbook (O’Reilly & Associates, ISBN 0-596-00797-3.)
• [Link] coleta links para vídeo relacionados a Python de conferê ncias e reuniõ es de grupos de
usuá rios.
• [Link] o projeto Scientific Python ( Python Científico) inclui mó dulos para computaçã o e manipu-
laçã o rá pida de vetores e també m hospeda pacotes para coisas similares como á lgebra linear, transformaçõ es
de Fourier, resolvedores nã o-lineares, distribuiçõ es de nú meros aleató rios, aná lise estatística e afins.
1 “Cheese Shop” é o título de um quadro do grupo Monty Python: um freguê s entra em uma loja especializada em queijos, mas qualquer queijo

que ele pede, o balconista diz que está em falta.

109
Python Tutorial, Release 3.12.5

Para reportar questõ es e problemas relacionadas a Python, você pode postar no newsgroup [Link]
ou enviá -los para o grupo de e-mail em python-list@[Link]. O newsgroup e a lista sã o conectados, entã o men-
sagens postadas em um sã o automaticamente encaminhadas ao outro. Há centenas de postagem diá rias perguntando
(e respondendo) perguntas, sugerindo novas funcionalidades e anunciando novos mó dulos. E-mails arquivados estã o
disponíveis em [Link] Existe també m o grupo de discussã o da comunidade brasileira de
Python: python-brasil no Google Groups ([Link] com discussõ es de ó timo
nível té cnico.
Antes de postar, certifique-se de checar a lista de Perguntas Frequentes (Frequently Asked Questions , també m
chamada de FAQ). A FAQ responde muitas das perguntas que aparecem com frequê ncia e pode já conter a soluçã o
para o seu problema.

110 Capítulo 13. E agora?

 CAPÍTULO 14

Edição de entrada interativa e substituição de histórico

Algumas versõ es do interpretador Python suportam a ediçã o da linha de entrada atual e a substituiçã o da histó ria,
semelhante à s habilidade encontradas no shell Korn e no shell GNU Bash. Isso é implementado usando a biblioteca
GNU Readline, que oferece suporte a vá rios estilos de ediçã o. Esta biblioteca possui sua pró pria documentaçã o, que
nã o vamos duplicar aqui.

14.1 Tab Completion e Histórico de Edição

A conclusã o dos nomes de variá veis e mó dulos é ativado automaticamente na inicializaçã o do interpretador para que
a tecla Tab invoque a funçã o de conclusã o. Ele analisa os nomes das instruçõ es Python, as variá veis locais atuais
e os nomes dos mó dulos disponíveis. Para expressõ es pontilhadas como string.a, ele avaliará a expressã o até o
'.' final e entã o sugerirá conclusõ es dos atributos do objeto resultante. Observe que isso pode executar o có digo
definido pelo aplicativo se um objeto com um mé todo __getattr__() faz parte da expressã o. A configuraçã o
padrã o també m guarda seu histó rico em um arquivo chamado .python_history no seu diretó rio de usuá rio. O
histó rico estará disponível novamente durante a pró xima sessã o de interpretaçã o interativa.

14.2 Alternativas ao interpretador interativo

Esta facilidade é um enorme passo em frente em comparaçã o com as versõ es anteriores do interpretador; No en-
tanto, alguns desejos sã o deixados: seria bom se a indentaçã o adequada fosse sugerida nas linhas de continuaçã o (o
analisador sabe se é necessá rio um token de recuo). O mecanismo de conclusã o pode usar a tabela de símbolos do
interpretador. Um comando para verificar (ou mesmo sugerir) parê nteses, aspas, etc., també m seria ú til.
Um interpretador interativo aprimorado e alternativo que existe há algum tempo é o IPython, que apresenta a con-
clusã o da guia, a exploraçã o de objetos e o gerenciamento de histó rico avançado. També m pode ser completamente
personalizado e incorporado em outras aplicaçõ es. Outro ambiente interativo aprimorado similar é bpython.

111
Python Tutorial, Release 3.12.5

112 Capítulo 14. Edição de entrada interativa e substituição de histórico

 CAPÍTULO 15

Floating-Point Arithmetic: Issues and Limitations

Os nú meros de ponto flutuante sã o representados no hardware do computador como fraçõ es de base 2 (biná rias). Por
exemplo, a fraçã o decimal 0.625 tem valor 6/10 + 2/100 + 5/1000, e da mesma forma a fraçã o binária 0.101
tem valor 0/2 + 0/4 + 1/8. Essas duas fraçõ es tê m valores idê nticos, a ú nica diferença real é que a primeira é escrita
em notaçã o fracioná ria de base 10 e a segunda em base 2.
Infelizmente, muitas fraçõ es decimais nã o podem ser representadas precisamente como fraçõ es biná rias. O resultado
é que, em geral, os nú meros decimais de ponto flutuante que você digita acabam sendo armazenados de forma apenas
aproximada, na forma de nú meros biná rios de ponto flutuante.
O problema é mais fá cil de entender primeiro em base 10. Considere a fraçã o 1/3. Podemos representá -la aproxi-
madamente como uma fraçã o base 10:

0.3

ou melhor,

0.33

ou melhor,

0.333

e assim por diante. Nã o importa quantos dígitos você está disposto a escrever, o resultado nunca será exatamente
1/3, mas será uma aproximaçã o de cada vez melhor de 1/3.
Da mesma forma, nã o importa quantos dígitos de base 2 estejas disposto a usar, o valor decimal 0.1 nã o pode ser
representado exatamente como uma fraçã o de base 2. No sistema de base 2, 1/10 é uma fraçã o biná ria que se repete
infinitamente:

0.0001100110011001100110011001100110011001100110011...

Se parares em qualquer nú mero finito de bits, obterá s uma aproximaçã o. Hoje em dia, na maioria dos computadores,
as casas decimais sã o aproximados usando uma fraçã o biná ria onde o numerado utiliza os primeiros 53 bits iniciando
no bit mais significativo e tendo como denominador uma potê ncia de dois. No caso de 1/10, a fraçã o biná ria seria
602879701896397 / 2 ** 55 o que chega bem perto, mas mesmo assim, nã o é igual ao valor original de
1/10.
É fá cil esquecer que o valor armazenado é uma aproximaçã o da fraçã o decimal original, devido à forma como os
pontos flutuantes sã o exibidos no interpretador interativo. O Python exibe apenas uma aproximaçã o decimal do

113
Python Tutorial, Release 3.12.5

verdadeiro valor decimal da aproximaçã o biná ria armazenada pela má quina. Se o Python exibisse o verdadeiro valor
decimal da aproximaçã o biná ria que representa o decimal 0.1, seria necessá rio mostrar:

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

Isto conté m muito mais dígitos do que é o esperado e utilizado pela grande maioria dos desenvolvedores, portanto, o
Python limita o nú mero de dígitos exibidos, apresentando um valor arredondado, ao invé s de mostrar todas as casas
decimais:

>>> 1 / 10
0.1

Lembre-se, mesmo que o resultado impresso seja o valor exato de 1/10, o valor que verdadeiramente estará armaze-
nado será uma fraçã o biná ria representá vel que mais se aproxima.
Curiosamente, existem muitos nú meros decimais diferentes que compartilham a mesma fra-
çã o biná ria aproximada. Por exemplo, os nú meros 0.1 ou o 0.10000000000000001 e 0.
1000000000000000055511151231257827021181583404541015625 sã o todos aproximaçõ es
de 3602879701896397 / 2 ** 55. Como todos esses valores decimais compartilham um mesma de
aproximaçã o, qualquer um poderá ser exibido enquanto for preservado o invariante eval(repr(x)) == x.
Historicamente, o prompt do Python e a funçã o embutida repr() utilizariam o que contivesse 17 dígitos signifi-
cativos, 0.10000000000000001. Desde a versã o do Python 3.1, o Python (na maioria dos sistemas) agora é
possível optar pela forma mais reduzida, exibindo simplesmente o nú mero 0.1.
Note that this is in the very nature of binary floating point: this is not a bug in Python, and it is not a bug in your
code either. You’ll see the same kind of thing in all languages that support your hardware’s floating-point arithmetic
(although some languages may not display the difference by default, or in all output modes).
Para obter um valor mais agradá vel, poderá s utilizar a formataçã o de sequê ncia de caracteres para produzir um
nú mero limitado de dígitos significativos:

>>> format([Link], '.12g') # give 12 significant digits

'3.14159265359'

>>> format([Link], '.2f') # give 2 digits after the point

'3.14'

>>> repr([Link])
'3.141592653589793'

É importante perceber que tudo nã o passa de pura ilusã o: estas simplesmente arredondando a exibição da verdadeira
maquinaria do valor.
Uma ilusã o pode gerar outra. Por exemplo, uma vez que 0.1 nã o é exatamente 1/10, somar trê s vezes o valor 0.1,
nã o garantirá que o resultado seja exatamente 0.3, isso porque:

>>> 0.1 + 0.1 + 0.1 == 0.3

False

Inclusive, uma vez que o 0.1 nã o consegue aproximar-se do valor exato de 1/10 e 0.3 nã o pode se aproximar mais do
valor exato de 3/10, temos entã o que o pré -arredondamento com a funçã o round() nã o servirá como ajuda:

>>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)

False

Embora os nú meros nã o possam se aproximar mais dos exatos valores que desejamos, a funçã o [Link]()
poderá ser ú til para comparar valores inexatos:

>>> [Link](0.1 + 0.1 + 0.1, 0.3)

True

114 Capítulo 15. Floating-Point Arithmetic: Issues and Limitations

 Python Tutorial, Release 3.12.5

Alternativamente, a funçã o round() pode ser usada para comparar aproximaçõ es aproximadas:

>>> round([Link], ndigits=2) == round(22 / 7, ndigits=2)

True

Binary floating-point arithmetic holds many surprises like this. The problem with “0.1” is explained in precise detail
below, in the “Representation Error” section. See Examples of Floating Point Problems for a pleasant summary of
how binary floating point works and the kinds of problems commonly encountered in practice. Also see The Perils
of Floating Point for a more complete account of other common surprises.
As that says near the end, “there are no easy answers.” Still, don’t be unduly wary of floating point! The errors in
Python float operations are inherited from the floating-point hardware, and on most machines are on the order of no
more than 1 part in 2**53 per operation. That’s more than adequate for most tasks, but you do need to keep in mind
that it’s not decimal arithmetic and that every float operation can suffer a new rounding error.
Embora existam casos patoló gicos, na maior parte das vezes, terá s como resultado final o valor esperado, se sim-
plesmente arredondares a exibiçã o final dos resultados para a quantidade de dígitos decimais que esperas a funçã o
str() geralmente será o suficiente, e , para seja necessá rio um valor refinado, veja os especificadores de formato
[Link]() contido na seçã o formatstrings.
Para as situaçõ es que exijam uma representaçã o decimal exata, experimente o mó dulo decimal que possui, a
implementaçã o de uma adequada aritmé tica decimal bastante utilizada nas aplicaçõ es contá beis e pelas aplicaçõ es
que demandam alta precisã o.
Uma outra forma de obter uma aritmé tica exata tem suporte pelo mó dulo fracções que implementa a aritmé tica
baseada em nú meros racionais (portanto, os nú meros fracioná rios como o 1/3 conseguem uma representaçã o precisa).
Caso necessites fazer um intenso uso das operaçõ es de ponto flutuante, é importante que conheças o pacote NumPy e,
també m é importante dizer, que existem diversos pacotes destinados ao trabalho intenso com operaçõ es matemá ticas
e estatísticas que sã o fornecidas pelo projeto SciPy. Veja <[Link]
O Python fornece ferramentas que podem ajudar nessas raras ocasiõ es em que realmente faz necessá rio conhecer o
valor exato de um ponto flutuante. O mé todo float.as_integer_ratio() expressa o valor de um nú mero
do tipo float em sua forma fracioná ria:

>>> x = 3.14159
>>> x.as_integer_ratio()
(3537115888337719, 1125899906842624)

Uma vez que a relaçã o seja exata, será possível utiliza-la para obter, sem que haja quaisquer perda do valor original:

>>> x == 3537115888337719 / 1125899906842624

True

O mé todo [Link]() expressa um ponto flutuante em hexadecimal (base 16), o mesmo també m retornará o
valor exato pelo computador:

>>> [Link]()
'0x1.921f9f01b866ep+1'

Sua precisa representaçã o hexadecimal poderá ser utilizada para reconstruir o valor exato do ponto flutuante:

>>> x == [Link]('0x1.921f9f01b866ep+1')
True

Como a representaçã o será exata, é interessante utilizar valores confiá veis em diferentes versõ es do Python (inde-
pendente da plataforma) e a troca de dados entre idiomas diferentes que forneçam o mesmo formato (como o Java e
o C99).
Uma outra ferramenta que poderá ser ú til é a funçã o sum() que ajuda a mitigar a perda de precisã o durante a soma.
Ele usa precisã o estendida para etapas intermediá rias de arredondamento, pois os valores serã o adicionados a um
total em execuçã o. Isso poderá fazer a diferença na precisã o geral de forma que os erros nã o se acumulem chegando
ao ponto de afetar o resultado final:

115
Python Tutorial, Release 3.12.5

>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0
False
>>> sum([0.1] * 10) == 1.0
True

The [Link]() goes further and tracks all of the “lost digits” as values are added onto a running total so that
the result has only a single rounding. This is slower than sum() but will be more accurate in uncommon cases where
large magnitude inputs mostly cancel each other out leaving a final sum near zero:
>>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,
... -143401161400469.7, 266262841.31058735, -0.003244936839808227]
>>> float(sum(map(Fraction, arr))) # Exact summation with single rounding
8.042173697819788e-13
>>> [Link](arr) # Single rounding
8.042173697819788e-13
>>> sum(arr) # Multiple roundings in extended precision
8.042178034628478e-13
>>> total = 0.0
>>> for x in arr:
... total += x # Multiple roundings in standard precision
...
>>> total # Straight addition has no correct digits!
-0.0051575902860057365

15.1 Erro de representação

Esta seçã o explica o exemplo do “0.1” em detalhes, e mostra como poderá s realizar uma aná lise exata de casos
semelhantes. Presumimos que tenhas uma familiaridade bá sica com a representaçã o biná ria de ponto flutuante.
Erro de representação refere-se ao fato de que algumas fraçõ es decimais (a maioria, na verdade) nã o podem ser
representadas exatamente como fraçõ es biná rias (base 2). Esta é a principal razã o por que o Python (ou Perl, C,
C++, Java, Fortran, e muitas outras) frequentemente nã o exibe o nú mero decimal exato conforme o esperado:
Por que isso acontece? 1/10 nã o é representado exatamente sendo fraçã o biná ria. Desde pelo menos 2000, quase
todas as má quinas usam aritmé tica biná ria de ponto flutuante da IEEE 754 e quase todas as plataformas representam
pontos flutuante do Python como valores binary64 de “double precision” (dupla precisã o) da IEEE 754. Os valores
binary64 da IEEE 754 tê m 53 bits de precisã o, por isso na entrada o computador se esforça para converter “0.1”
para a fraçã o mais pró xima que puder, na forma J/2**N onde J é um nú mero inteiro contendo exatamente 53 bits.
Reescrevendo:
1 / 10 ~= J / (2**N)

como
J ~= 2**N / 10

e recordando que J tenha exatamente 53 bits (é >= 2**52, mas < 2**53), o melhor valor para N é 56:
>>> 2**52 <= 2**56 // 10 < 2**53
True

Ou seja, 56 é o ú nico valor de N que deixa J com exatamente 53 bits. Portanto, o melhor valor que conseguimos
obter pra J será aquele que possui o quociente arredondado:
>>> q, r = divmod(2**56, 10)
>>> r
6

Uma vez que o resto seja maior do que a metade de 10, a melhor aproximaçã o que poderá ser obtida se arredondarmos
para cima:

116 Capítulo 15. Floating-Point Arithmetic: Issues and Limitations

 Python Tutorial, Release 3.12.5

>>> q+1
7205759403792794

Portanto, a melhor aproximaçã o possível de 1/10 como um “IEEE 754 double precision” é :

7205759403792794 / 2 ** 56

Dividir o numerador e o denominador por dois reduzirá a fraçã o para:

3602879701896397 / 2 ** 55

Note que, como arredondamos para cima, esse valor é , de fato, um pouco maior que 1/10; se nã o tivé ssemos ar-
redondado para cima, o quociente teria sido um pouco menor que 1/10. Mas em nenhum caso seria possível obter
exatamente o valor 1/10!
Por isso, o computador nunca “vê ” 1/10: o que ele vê é exatamente a fraçã o que é obtida pra cima, a melhor aproxi-
maçã o “IEEE 754 double” possível é :

>>> 0.1 * 2 ** 55
3602879701896397.0

Se multiplicarmos essa fraçã o por 10**55, podemos ver o valor contendo os 55 dígitos mais significativos:

>>> 3602879701896397 * 10 ** 55 // 2 ** 55
1000000000000000055511151231257827021181583404541015625

o que significa que o nú mero exato armazenado no computador é igual ao valor decimal
0.1000000000000000055511151231257827021181583404541015625. Em vez de exibir o valor decimal
completo, muitas linguagens (incluindo versõ es mais antigas do Python), arredondam o resultado para 17 dígitos
significativos:

>>> format(0.1, '.17f')

'0.10000000000000001'

Mó dulos como o fractions e o decimal tornam esses cá lculos muito mais fá ceis:

>>> from decimal import Decimal

>>> from fractions import Fraction

>>> Fraction.from_float(0.1)
Fraction(3602879701896397, 36028797018963968)

>>> (0.1).as_integer_ratio()
(3602879701896397, 36028797018963968)

>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')

>>> format(Decimal.from_float(0.1), '.17')

'0.10000000000000001'

15.1. Erro de representação 117

Python Tutorial, Release 3.12.5

118 Capítulo 15. Floating-Point Arithmetic: Issues and Limitations

 CAPÍTULO 16

Anexo

16.1 Modo interativo

16.1.1 Tratamento de erros

Quando um erro ocorre, o interpretador exibe uma mensagem de erro e um stack trace (rastreamento de pilha). Se
estiver no modo interativo, ele volta para o prompt primá rio; se a entrada veio de um arquivo, a execuçã o termina com
um status de saída nonzero (diferente de zero) apó s a exibiçã o do stack trace. (Exceçõ es tratadas por uma clá usula
except numa declaraçã o try nã o sã o consideradas erros, nesse contexto.) Alguns erros sã o irremediavelmente
graves e causam té rminos de execuçã o com status de saída nonzero; isso pode acontecer devido a inconsistê ncias
internas e em alguns casos por falta de memó ria. Todas as mensagens de erro sã o escritas no fluxo de erros padrã o;
a saída normal resultante da execuçã o de comandos é escrita no canal de saída padrã o.
Digitar o caractere de interrupçã o (geralmente Control-C ou Delete) em prompts primá rios ou secundá rios
causam a interrupçã o da entrada de dados e o retorno ao prompt primá rio.1 Digitar a interrupçã o durante a execuçã o
de um comando levanta a exceçã o KeyboardInterrupt, que pode ser tratada por uma declaraçã o try.

16.1.2 Scripts Python executáveis

Em sistemas Unix similares ao BSD, scripts Python podem ser executados diretamente, tal como scripts shell, se
tiverem a linha de có digo

#!/usr/bin/env python3

(presumindo que o interpretador está na PATH do usuá rio) no começo do script e configurando o arquivo no modo
executá vel. Os dois primeiros caracteres do arquivo devem ser #!. Em algumas plataformas, essa primeira linha deve
terminar com uma quebra de linha em estilo Unix ('\n'), e nã o em estilo windows ('\r\n'). Note que o caractere
'#' (em inglê s chamado de hash, ou pound etc.), é usado em Python para marcar o início de um comentá rio.
O script pode receber a permissã o para atuar em modo executá vel atravé s do comando chmod.

$ chmod +x [Link]

1 Um problema com a package GNU Readline pode impedir que isso aconteça.

119
Python Tutorial, Release 3.12.5

Em sistemas Windows, nã o existe a noçã o de um “modo executá vel”. O instalador Python associa automaticamente
os arquivos .py com o [Link], de forma que um clique duplo num arquivo Python o executará como um
script. A extensã o pode ser també m .pyw, o que omite a janela de console que normalmente aparece.

16.1.3 Arquivo de inicialização do modo interativo

Quando se usa o Python no modo interativo, pode ser ú til definir alguns comandos que sejam executados automati-
camente toda vez que o interpretador for inicializado. Isso pode ser feito configurando-se uma variá vel de ambiente
chamada PYTHONSTARTUP para que ela aponte para o arquivo contendo esses comandos. Isso é similar ao recurso
.profile das shells Unix.
Esse arquivo será lido apenas em sessõ es do modo interativo, e nã o quando Python lê comandos de um script, tam-
pouco quando /dev/tty é passado explicitamente como a origem dos comandos (neste caso, teremos um compor-
tamento similar a uma sessã o interativa padrã o). Ele é executado no mesmo namespace (espaço de nomes) em que
os comandos interativos sã o executados, de modo que os objetos que ele define ou importa possam ser usados sem
qualificaçã o na sessã o interativa. També m é possível alterar os prompts sys.ps1 e sys.ps2 no mesmo arquivo.
Caso deseje usar um arquivo de inicializaçã o adicional a partir do atual diretó rio de trabalho, você pode programá -
-lo no arquivo de inicializaçã o global usando um có digo parecido com if [Link]('.pythonrc.
py'): exec(open('.[Link]').read()). Se quiser usar o arquivo de inicializaçã o num script,
será necessá rio fazê -lo explicitamente no script:

import os
filename = [Link]('PYTHONSTARTUP')
if filename and [Link](filename):
with open(filename) as fobj:
startup_file = [Link]()
exec(startup_file)

16.1.4 Módulos de customização

Python oferece dois hooks que permitem sua customizaçã o: sitecustomize e usercustomize. Para entender como
funcionam, primeiro você deve localizar o diretó rio site-packages do usuá rio. Inicie o Python e execute este có digo:

>>> import site

>>> [Link]()
'/home/user/.local/lib/python3.x/site-packages'

Agora você pode criar um arquivo chamado [Link] neste diretó rio e colocar qualquer coisa que
quiser dentro. Isto vai afetar toda invocaçã o do Python, a menos que seja iniciado com a opçã o -s para desabilitar
a importaçã o automá tica.
sitecustomize funciona da mesma forma, mas normalmente é criado por um administrador do computador no dire-
tó rio site-packages global e é importado antes de usercustomize. Veja a documentaçã o do mó dulo site para mais
detalhes.

120 Capítulo 16. Anexo

 APÊNDICE A

Glossário

>>>
O prompt padrã o do console interativo do Python. Normalmente visto em exemplos de có digo que podem ser
executados interativamente no interpretador.
...
Pode se referir a:
• O prompt padrã o do shell interativo do Python ao inserir o có digo para um bloco de có digo recuado,
quando dentro de um par de delimitadores correspondentes esquerdo e direito (parê nteses, colchetes,
chaves ou aspas triplas) ou apó s especificar um decorador.
• A constante embutida Ellipsis.
2to3
Uma ferramenta que tenta converter có digo Python 2.x em có digo Python 3.x tratando a maioria das incom-
patibilidades que podem ser detectadas com aná lise do có digo-fonte e navegaçã o na á rvore sintá tica.
O 2to3 está disponível na biblioteca padrã o como lib2to3; um ponto de entrada é disponibilizado como
Tools/scripts/2to3. Veja 2to3-reference.
classe base abstrata
Classes bases abstratas complementam tipagem pato, fornecendo uma maneira de definir interfaces quando
outras té cnicas, como hasattr(), seriam desajeitadas ou sutilmente erradas (por exemplo, com mé todos
má gicos). CBAs introduzem subclasses virtuais, classes que nã o herdam de uma classe mas ainda sã o reco-
nhecidas por isinstance() e issubclass(); veja a documentaçã o do mó dulo abc. Python vem com
muitas CBAs embutidas para estruturas de dados (no mó dulo [Link]), nú meros (no mó dulo
numbers), fluxos (no mó dulo io), localizadores e carregadores de importaçã o (no mó dulo importlib.
abc). Você pode criar suas pró prias CBAs com o mó dulo abc.
anotação
Um ró tulo associado a uma variá vel, um atributo de classe ou um parâ metro de funçã o ou valor de retorno,
usado por convençã o como dica de tipo.
Anotaçõ es de variá veis locais nã o podem ser acessadas em tempo de execuçã o, mas anotaçõ es de variá veis
globais, atributos de classe e funçõ es sã o armazenadas no atributo especial __annotations__ de mó dulos,
classes e funçõ es, respectivamente.
Veja anotação de variável, anotação de função, PEP 484 e PEP 526, que descrevem esta funcionalidade.
Veja també m annotations-howto para as melhores prá ticas sobre como trabalhar com anotaçõ es.

121
Python Tutorial, Release 3.12.5

argumento
Um valor passado para uma função (ou método) ao chamar a funçã o. Existem dois tipos de argumento:
• argumento nomeado: um argumento precedido por um identificador (por exemplo, name=) na chamada
de uma funçã o ou passada como um valor em um dicioná rio precedido por **. Por exemplo, 3 e 5 sã o
ambos argumentos nomeados na chamada da funçã o complex() a seguir:

complex(real=3, imag=5)
complex(**{'real': 3, 'imag': 5})

• argumento posicional: um argumento que nã o é um argumento nomeado. Argumentos posicionais po-
dem aparecer no início da lista de argumentos e/ou podem ser passados com elementos de um iterável
precedido por *. Por exemplo, 3 e 5 sã o ambos argumentos posicionais nas chamadas a seguir:

complex(3, 5)
complex(*(3, 5))

Argumentos sã o atribuídos à s variá veis locais nomeadas no corpo da funçã o. Veja a seçã o calls para as regras
de atribuiçã o. Sintaticamente, qualquer expressã o pode ser usada para representar um argumento; avaliada a
expressã o, o valor é atribuído à variá vel local.
Veja també m o termo parâmetro no glossá rio, a pergunta no FAQ sobre a diferença entre argumentos e parâ -
metros e PEP 362.
gerenciador de contexto assíncrono
Um objeto que controla o ambiente visto numa instruçã o async with por meio da definiçã o dos mé todos
__aenter__() e __aexit__(). Introduzido pela PEP 492.
gerador assíncrono
Uma funçã o que retorna um iterador gerador assíncrono. É parecida com uma funçã o de corrotina definida
com async def exceto pelo fato de conter instruçõ es yield para produzir uma sé rie de valores que podem
ser usados em um laço async for.
Normalmente se refere a uma funçã o geradora assíncrona, mas pode se referir a um iterador gerador assín-
crono em alguns contextos. Em casos em que o significado nã o esteja claro, usar o termo completo evita a
ambiguidade.
Uma funçã o geradora assíncrona pode conter expressõ es await e també m as instruçõ es async for e
async with.
iterador gerador assíncrono
Um objeto criado por uma funçã o geradora assíncrona.
Este é um iterador assíncrono que, quando chamado usando o mé todo __anext__(), retorna um objeto
aguardá vel que executará o corpo da funçã o geradora assíncrona até a pró xima expressã o yield.
Cada yield suspende temporariamente o processamento, lembrando o estado de execuçã o do local (incluindo
variá veis locais e instruçõ es try pendentes). Quando o iterador gerador assíncrono é efetivamente retomado
com outro aguardá vel retornado por __anext__(), ele inicia de onde parou. Veja PEP 492 e PEP 525.
iterável assíncrono
Um objeto que pode ser usado em uma instruçã o async for. Deve retornar um iterador assíncrono do seu
mé todo __aiter__(). Introduzido por PEP 492.
iterador assíncrono
Um objeto que implementa os mé todos __aiter__() e __anext__(). __anext__() deve retornar
um objeto aguardável. async for resolve os aguardá veis retornados por um mé todo __anext__() do
iterador assíncrono até que ele levante uma exceçã o StopAsyncIteration. Introduzido pela PEP 492.
atributo
Um valor associado a um objeto que é geralmente referenciado pelo nome separado por um ponto. Por exemplo,
se um objeto o tem um atributo a esse seria referenciado como o.a.
É possível dar a um objeto um atributo cujo nome nã o seja um identificador conforme definido por identifiers,
por exemplo usando setattr(), se o objeto permitir. Tal atributo nã o será acessível usando uma expressã o

122 Apêndice A. Glossário

 Python Tutorial, Release 3.12.5

pontilhada e, em vez disso, precisaria ser recuperado com getattr().

aguardável
Um objeto que pode ser usado em uma expressã o await. Pode ser uma corrotina ou um objeto com um
mé todo __await__(). Veja també m a PEP 492.
BDFL
Abreviaçã o da expressã o da língua inglesa “Benevolent Dictator for Life” (em portuguê s, “Ditador Benevolente
Vitalício”), referindo-se a Guido van Rossum, criador do Python.
arquivo binário
Um objeto arquivo capaz de ler e gravar em objetos bytes ou similar. Exemplos de arquivos biná rios sã o arquivos
abertos no modo biná rio ('rb', 'wb' ou 'rb+'), [Link], [Link], e
instâ ncias de [Link] e [Link].
Veja també m arquivo texto para um objeto arquivo capaz de ler e gravar em objetos str.
referência emprestada
Na API C do Python, uma referê ncia emprestada é uma referê ncia a um objeto que nã o é dona da referê ncia.
Ela se torna um ponteiro solto se o objeto for destruído. Por exemplo, uma coleta de lixo pode remover a
ú ltima referência forte para o objeto e assim destruí-lo.
Chamar Py_INCREF() na referência emprestada é recomendado para convertê -lo, internamente, em uma
referência forte, exceto quando o objeto nã o pode ser destruído antes do ú ltimo uso da referê ncia emprestada.
A funçã o Py_NewRef() pode ser usada para criar uma nova referência forte.
objeto byte ou similar
Um objeto com suporte ao o bufferobjects e que pode exportar um buffer C contíguo. Isso inclui todos os objetos
bytes, bytearray e [Link], alé m de muitos objetos memoryview comuns. Objetos byte ou
similar podem ser usados para vá rias operaçõ es que funcionam com dados biná rios; isso inclui compactaçã o,
salvamento em um arquivo biná rio e envio por um soquete.
Algumas operaçõ es precisam que os dados biná rios sejam mutá veis. A documentaçã o geralmente se refere
a eles como “objetos byte ou similar para leitura e escrita”. Exemplos de objetos de buffer mutá vel incluem
bytearray e um memoryview de um bytearray. Outras operaçõ es exigem que os dados biná rios
sejam armazenados em objetos imutá veis (“objetos byte ou similar para somente leitura”); exemplos disso
incluem bytes e a memoryview de um objeto bytes.
bytecode
O có digo-fonte Python é compilado para bytecode, a representaçã o interna de um programa em Python no
interpretador CPython. O bytecode també m é mantido em cache em arquivos .pyc e .pyo, de forma que
executar um mesmo arquivo é mais rá pido na segunda vez (a recompilaçã o dos fontes para bytecode nã o é
necessá ria). Esta “linguagem intermediá ria” é adequada para execuçã o em uma máquina virtual, que executa
o có digo de má quina correspondente para cada bytecode. Tenha em mente que nã o se espera que bytecodes
sejam executados entre má quinas virtuais Python diferentes, nem que se mantenham está veis entre versõ es de
Python.
Uma lista de instruçõ es bytecode pode ser encontrada na documentaçã o para o mó dulo dis.
chamável
Um chamá vel é um objeto que pode ser chamado, possivelmente com um conjunto de argumentos (veja ar-
gumento), com a seguinte sintaxe:

callable(argument1, argument2, argumentN)

Uma função, e por extensã o um método, é um chamá vel. Uma instâ ncia de uma classe que implementa o
mé todo __call__() també m é um chamá vel.
função de retorno
També m conhecida como callback, é uma funçã o sub-rotina que é passada como um argumento a ser executado
em algum ponto no futuro.
classe
Um modelo para criaçã o de objetos definidos pelo usuá rio. Definiçõ es de classe normalmente conté m defini-
çõ es de mé todos que operam sobre instâ ncias da classe.

123
Python Tutorial, Release 3.12.5

variável de classe
Uma variá vel definida em uma classe e destinada a ser modificada apenas no nível da classe (ou seja, nã o em
uma instâ ncia da classe).
número complexo
Uma extensã o ao familiar sistema de nú meros reais em que todos os nú meros sã o expressos como uma soma
de uma parte real e uma parte imaginá ria. Nú meros imaginá rios sã o mú ltiplos reais da unidade imaginá ria
(a raiz quadrada de -1), normalmente escrita como i em matemá tica ou j em engenharia. O Python tem
suporte nativo para nú meros complexos, que sã o escritos com esta ú ltima notaçã o; a parte imaginá ria escrita
com um sufixo j, [Link]., 3+1j. Para ter acesso aos equivalentes para nú meros complexos do mó dulo math,
utilize cmath. O uso de nú meros complexos é uma funcionalidade matemá tica bastante avançada. Se você
nã o sabe se irá precisar deles, é quase certo que você pode ignorá -los sem problemas.
gerenciador de contexto
Um objeto que controla o ambiente visto numa instruçã o with por meio da definiçã o dos mé todos
__enter__() e __exit__(). Veja PEP 343.
variável de contexto
Uma variá vel que pode ter valores diferentes, dependendo do seu contexto. Isso é semelhante ao armazena-
mento local de threads, no qual cada thread pode ter um valor diferente para uma variá vel. No entanto, com
variá veis de contexto, pode haver vá rios contextos em uma thread e o principal uso para variá veis de contexto
é acompanhar as variá veis em tarefas assíncronas simultâ neas. Veja contextvars.
contíguo
Um buffer é considerado contíguo exatamente se for contíguo C ou contíguo Fortran. Os buffers de dimensã o
zero sã o contíguos C e Fortran. Em vetores unidimensionais, os itens devem ser dispostos na memó ria pró ximos
um do outro, em ordem crescente de índices, começando do zero. Em vetores multidimensionais contíguos C,
o ú ltimo índice varia mais rapidamente ao visitar itens em ordem de endereço de memó ria. No entanto, nos
vetores contíguos do Fortran, o primeiro índice varia mais rapidamente.
corrotina
Corrotinas sã o uma forma mais generalizada de sub-rotinas. Sub-rotinas tem a entrada iniciada em um ponto,
e a saída em outro ponto. Corrotinas podem entrar, sair, e continuar em muitos pontos diferentes. Elas podem
ser implementadas com a instruçã o async def. Veja també m PEP 492.
função de corrotina
Uma funçã o que retorna um objeto do tipo corrotina. Uma funçã o de corrotina pode ser definida com a
instruçã o async def, e pode conter as palavras chaves await, async for, e async with. Isso foi
introduzido pela PEP 492.
CPython
A implementaçã o canô nica da linguagem de programaçã o Python, como disponibilizada pelo [Link].
O termo “CPython” é usado quando necessá rio distinguir esta implementaçã o de outras como Jython ou
IronPython.
decorador
Uma funçã o que retorna outra funçã o, geralmente aplicada como uma transformaçã o de funçã o usando a
sintaxe @wrapper. Exemplos comuns para decoradores sã o classmethod() e staticmethod().
A sintaxe do decorador é meramente um açú car sintá tico, as duas definiçõ es de funçõ es a seguir sã o semanti-
camente equivalentes:

def f(arg):
...
f = staticmethod(f)

@staticmethod
def f(arg):
...

O mesmo conceito existe para as classes, mas nã o é comumente utilizado. Veja a documentaçã o de definiçõ es
de funçã o e definiçõ es de classe para obter mais informaçõ es sobre decoradores.

124 Apêndice A. Glossário

 Python Tutorial, Release 3.12.5

descritor
Qualquer objeto que define os mé todos __get__(), __set__() ou __delete__(). Quando um atri-
buto de classe é um descritor, seu comportamento de associaçã o especial é acionado no acesso a um atributo.
Normalmente, ao se utilizar a.b para se obter, definir ou excluir, um atributo dispara uma busca no objeto
chamado b no dicioná rio de classe de a, mas se b for um descritor, o respectivo mé todo descritor é chamado.
Compreender descritores é a chave para um profundo entendimento de Python pois eles sã o a base de muitas
funcionalidades incluindo funçõ es, mé todos, propriedades, mé todos de classe, mé todos está ticos e referê ncias
para superclasses.
Para obter mais informaçõ es sobre os mé todos dos descritores, veja: descriptors ou o Guia de Descritores.
dicionário
Um vetor associativo em que chaves arbitrá rias sã o mapeadas para valores. As chaves podem ser quaisquer
objetos que possuam os mé todos __hash__() e __eq__(). Isso é chamado de hash em Perl.
compreensão de dicionário
Uma maneira compacta de processar todos ou parte dos elementos de um iterá vel e retornar um dicioná rio
com os resultados. results = {n: n ** 2 for n in range(10)} gera um dicioná rio contendo
a chave n mapeada para o valor n ** 2. Veja comprehensions.
visão de dicionário
Os objetos retornados por [Link](), [Link]() e [Link]() sã o chamados de visõ es
de dicioná rio. Eles fornecem uma visã o dinâ mica das entradas do dicioná rio, o que significa que quando o
dicioná rio é alterado, a visã o reflete essas alteraçõ es. Para forçar a visã o de dicioná rio a se tornar uma lista
completa use list(dictview). Veja dict-views.
docstring
Abreviatura de “documentation string” (string de documentaçã o). Uma string literal que aparece como pri-
meira expressã o numa classe, funçã o ou mó dulo. Ainda que sejam ignoradas quando a suíte é executada, é
reconhecida pelo compilador que a coloca no atributo __doc__ da classe, funçã o ou mó dulo que a encap-
sula. Como ficam disponíveis por meio de introspecçã o, docstrings sã o o lugar canô nico para documentaçã o
do objeto.
tipagem pato
També m conhecida como duck-typing, é um estilo de programaçã o que nã o verifica o tipo do objeto para
determinar se ele possui a interface correta; em vez disso, o mé todo ou atributo é simplesmente chamado
ou utilizado (“Se se parece com um pato e grasna como um pato, entã o deve ser um pato.”) Enfatizando
interfaces ao invé s de tipos específicos, o có digo bem desenvolvido aprimora sua flexibilidade por permitir
substituiçã o polimó rfica. Tipagem pato evita necessidade de testes que usem type() ou isinstance().
(Note, poré m, que a tipagem pato pode ser complementada com o uso de classes base abstratas.) Ao invé s
disso, sã o normalmente empregados testes hasattr() ou programaçã o EAFP.
EAFP
Iniciais da expressã o em inglê s “easier to ask for forgiveness than permission” que significa “é mais fá cil pedir
perdã o que permissã o”. Este estilo de codificaçã o comum no Python assume a existê ncia de chaves ou atributos
vá lidos e captura exceçõ es caso essa premissa se prove falsa. Este estilo limpo e rá pido se caracteriza pela
presença de vá rias instruçõ es try e except. A té cnica diverge do estilo LBYL, comum em outras linguagens
como C, por exemplo.
expressão
Uma parte da sintaxe que pode ser avaliada para algum valor. Em outras palavras, uma expressã o é a acumula-
çã o de elementos de expressã o como literais, nomes, atributos de acesso, operadores ou chamadas de funçõ es,
todos os quais retornam um valor. Em contraste com muitas outras linguagens, nem todas as construçõ es
de linguagem sã o expressõ es. També m existem instruções, as quais nã o podem ser usadas como expressõ es,
como, por exemplo, while. Atribuiçõ es també m sã o instruçõ es, nã o expressõ es.
módulo de extensão
Um mó dulo escrito em C ou C++, usando a API C do Python para interagir tanto com có digo de usuá rio
quanto do nú cleo.
f-string
Literais string prefixadas com 'f' ou 'F' sã o conhecidas como “f-strings” que é uma abreviaçã o de formatted
string literals. Veja també m PEP 498.

125
Python Tutorial, Release 3.12.5

objeto arquivo
Um objeto que expõ e uma API orientada a arquivos (com mé todos tais como read() ou write()) para
um recurso subjacente. Dependendo da maneira como foi criado, um objeto arquivo pode mediar o acesso a
um arquivo real no disco ou outro tipo de dispositivo de armazenamento ou de comunicaçã o (por exemplo a
entrada/saída padrã o, buffers em memó ria, soquetes, pipes, etc.). Objetos arquivo també m sã o chamados de
objetos arquivo ou similares ou fluxos.
Atualmente há trê s categorias de objetos arquivo: arquivos binários brutos, arquivos binários em buffer e
arquivos textos. Suas interfaces estã o definidas no mó dulo io. A forma canô nica para criar um objeto arquivo
é usando a funçã o open().
objeto arquivo ou similar
Um sinô nimo do termo objeto arquivo.
tratador de erros e codificação do sistema de arquivos
Tratador de erros e codificaçã o usado pelo Python para decodificar bytes do sistema operacional e codificar
Unicode para o sistema operacional.
A codificaçã o do sistema de arquivos deve garantir a decodificaçã o bem-sucedida de todos os bytes abaixo
de 128. Se a codificaçã o do sistema de arquivos falhar em fornecer essa garantia, as funçõ es da API podem
levantar UnicodeError.
As funçõ es [Link]() e [Link]() po-
dem ser usadas para obter o tratador de erros e codificaçã o do sistema de arquivos.
O tratador de erros e codificação do sistema de arquivos sã o configurados na inicializaçã o do Python pela
funçã o PyConfig_Read(): veja os membros filesystem_encoding e filesystem_errors
do PyConfig.
Veja també m codificação da localidade.
localizador
Um objeto que tenta encontrar o carregador para um mó dulo que está sendo importado.
There are two types of finder: meta path finders for use with sys.meta_path, and path entry finders for
use with sys.path_hooks.
See importsystem and importlib for much more detail.
divisão pelo piso
Divisã o matemá tica que arredonda para baixo para o inteiro mais pró ximo. O operador de divisã o pelo piso é
//. Por exemplo, a expressã o 11 // 4 retorna o valor 2 ao invé s de 2.75, que seria retornado pela divisã o
de ponto flutuante. Note que (-11) // 4 é -3 porque é -2.75 arredondado para baixo. Consulte a PEP
238.
função
Uma sé rie de instruçõ es que retorna algum valor para um chamador. També m pode ser passado zero ou mais
argumentos que podem ser usados na execuçã o do corpo. Veja també m parâmetro, método e a seçã o function.
anotação de função
Uma anotação de um parâ metro de funçã o ou valor de retorno.
Anotaçõ es de funçã o sã o comumente usados por dicas de tipo: por exemplo, essa funçã o espera receber dois
argumentos int e també m é esperado que devolva um valor int:

def sum_two_numbers(a: int, b: int) -> int:

return a + b

A sintaxe de anotaçã o de funçã o é explicada na seçã o function.

Veja anotação de variável e PEP 484, que descrevem esta funcionalidade. Veja també m annotations-howto
para as melhores prá ticas sobre como trabalhar com anotaçõ es.
__future__
A instruçã o future, from __future__ import <feature>, direciona o compilador a compilar o
mó dulo atual usando sintaxe ou semâ ntica que será padrã o em uma versã o futura de Python. O mó dulo

126 Apêndice A. Glossário

 Python Tutorial, Release 3.12.5

__future__ documenta os possíveis valores de feature. Importando esse mó dulo e avaliando suas variá veis,
você pode ver quando um novo recurso foi inicialmente adicionado à linguagem e quando será (ou se já é ) o
padrã o:

>>> import __future__

>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

coleta de lixo
També m conhecido como garbage collection, é o processo de liberar a memó ria quando ela nã o é mais utilizada.
Python executa a liberaçã o da memó ria atravé s da contagem de referê ncias e um coletor de lixo cíclico que é
capaz de detectar e interromper referê ncias cíclicas. O coletor de lixo pode ser controlado usando o mó dulo
gc.
gerador
Uma funçã o que retorna um iterador gerador. É parecida com uma funçã o normal, exceto pelo fato de conter
expressõ es yield para produzir uma sé rie de valores que podem ser usados em um laço “for” ou que podem
ser obtidos um de cada vez com a funçã o next().
Normalmente refere-se a uma funçã o geradora, mas pode referir-se a um iterador gerador em alguns contextos.
Em alguns casos onde o significado desejado nã o está claro, usar o termo completo evita ambiguidade.
iterador gerador
Um objeto criado por uma funçã o geradora.
Cada yield suspende temporariamente o processamento, memorizando o estado da execuçã o local (incluindo
variá veis locais e instruçõ es try pendentes). Quando o iterador gerador retorna, ele se recupera do ú ltimo ponto
onde estava (em contrapartida as funçõ es que iniciam uma nova execuçã o a cada vez que sã o invocadas).
expressão geradora
Uma expressã o que retorna um iterador. Parece uma expressã o normal, seguido de uma clá usula for definindo
uma variá vel de loop, um range, e uma clá usula if opcional. A expressã o combinada gera valores para uma
funçã o encapsuladora:

>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81

285

função genérica
Uma funçã o composta por vá rias funçõ es implementando a mesma operaçã o para diferentes tipos. Qual im-
plementaçã o deverá ser usada durante a execuçã o é determinada pelo algoritmo de despacho.
Veja també m a entrada despacho único no glossá rio, o decorador [Link](), e a
PEP 443.
tipo genérico
Um tipo que pode ser parametrizado; tipicamente uma classe contê iner tal como list ou dict. Usado para
dicas de tipo e anotações.
Para mais detalhes, veja tipo apelido gené rico, PEP 483, PEP 484, PEP 585, e o mó dulo typing.
GIL
Veja bloqueio global do interpretador.
bloqueio global do interpretador
O mecanismo utilizado pelo interpretador CPython para garantir que apenas uma thread execute o bytecode
Python por vez. Isto simplifica a implementaçã o do CPython ao fazer com que o modelo de objetos (incluindo
tipos embutidos críticos como o dict) ganhem segurança implícita contra acesso concorrente. Travar todo o
interpretador facilita que o interpretador em si seja multitarefa, à s custas de muito do paralelismo já provido
por má quinas multiprocessador.
No entanto, alguns mó dulos de extensã o, tanto da biblioteca padrã o quanto de terceiros, sã o desenvolvidos de
forma a liberar o GIL ao realizar tarefas computacionalmente muito intensas, como compactaçã o ou cá lculos
de hash. Alé m disso, o GIL é sempre liberado nas operaçõ es de E/S.

127
Python Tutorial, Release 3.12.5

No passado, esforços para criar um interpretador que lidasse plenamente com threads (travando dados com-
partilhados numa granularidade bem mais fina) nã o foram bem sucedidos devido a queda no desempenho ao
serem executados em processadores de apenas um nú cleo. Acredita-se que superar essa questã o de desempe-
nho acabaria tornando a implementaçã o muito mais complicada e bem mais difícil de manter.
pyc baseado em hash
Um arquivo de cache em bytecode que usa hash ao invé s do tempo, no qual o arquivo de có digo-fonte foi
modificado pela ú ltima vez, para determinar a sua validade. Veja pyc-invalidation.
hasheável
Um objeto é hasheável se tem um valor de hash que nunca muda durante seu ciclo de vida (precisa ter um
mé todo __hash__()) e pode ser comparado com outros objetos (precisa ter um mé todo __eq__()).
Objetos hasheá veis que sã o comparados como iguais devem ter o mesmo valor de hash.
A hasheabilidade faz com que um objeto possa ser usado como uma chave de dicioná rio e como um membro
de conjunto, pois estas estruturas de dados utilizam os valores de hash internamente.
A maioria dos objetos embutidos imutá veis do Python sã o hasheá veis; containers mutá veis (tais como listas
ou dicioná rios) nã o sã o; containers imutá veis (tais como tuplas e frozensets) sã o hasheá veis apenas se os seus
elementos sã o hasheá veis. Objetos que sã o instâ ncias de classes definidas pelo usuá rio sã o hasheá veis por
padrã o. Todos eles comparam de forma desigual (exceto entre si mesmos), e o seu valor hash é derivado a
partir do seu id().
IDLE
Um ambiente de desenvolvimento e aprendizado integrado para Python. idle é um editor bá sico e um ambiente
interpretador que vem junto com a distribuiçã o padrã o do Python.
imutável
Um objeto que possui um valor fixo. Objetos imutá veis incluem nú meros, strings e tuplas. Estes objetos nã o
podem ser alterados. Um novo objeto deve ser criado se um valor diferente tiver de ser armazenado. Objetos
imutá veis tê m um papel importante em lugares onde um valor constante de hash seja necessá rio, como por
exemplo uma chave em um dicioná rio.
caminho de importação
Uma lista de localizaçõ es (ou entradas de caminho) que sã o buscadas pelo localizador baseado no caminho
por mó dulos para importar. Durante a importaçã o, esta lista de localizaçõ es usualmente vem a partir de sys.
path, mas para subpacotes ela també m pode vir do atributo __path__ de pacotes-pai.
importação
O processo pelo qual o có digo Python em um mó dulo é disponibilizado para o có digo Python em outro mó dulo.
importador
Um objeto que localiza e carrega um mó dulo; Tanto um localizador e o objeto carregador.
interativo
Python tem um interpretador interativo, o que significa que você pode digitar instruçõ es e expressõ es no prompt
do interpretador, executá -los imediatamente e ver seus resultados. Apenas execute python sem argumentos
(possivelmente selecionando-o a partir do menu de aplicaçõ es de seu sistema operacional). O interpretador
interativo é uma maneira poderosa de testar novas ideias ou aprender mais sobre mó dulos e pacotes (lembre-se
do comando help(x)).
interpretado
Python é uma linguagem interpretada, em oposiçã o à quelas que sã o compiladas, embora esta distinçã o possa
ser nebulosa devido à presença do compilador de bytecode. Isto significa que os arquivos-fontes podem ser
executados diretamente sem necessidade explícita de se criar um arquivo executá vel. Linguagens interpretadas
normalmente tê m um ciclo de desenvolvimento/depuraçã o mais curto que as linguagens compiladas, apesar
de seus programas geralmente serem executados mais lentamente. Veja també m interativo.
desligamento do interpretador
Quando solicitado para desligar, o interpretador Python entra em uma fase especial, onde ele gradualmente
libera todos os recursos alocados, tais como mó dulos e vá rias estruturas internas críticas. Ele també m faz
diversas chamadas para o coletor de lixo. Isto pode disparar a execuçã o de có digo em destrutores definidos
pelo usuá rio ou funçã o de retorno de referê ncia fraca. Có digo executado durante a fase de desligamento pode

128 Apêndice A. Glossário

 Python Tutorial, Release 3.12.5

encontrar diversas exceçõ es, pois os recursos que ele depende podem nã o funcionar mais (exemplos comuns
sã o os mó dulos de bibliotecas, ou os mecanismos de avisos).
A principal razã o para o interpretador desligar, é que o mó dulo __main__ ou o script sendo executado
terminou sua execuçã o.
iterável
Um objeto capaz de retornar seus membros um de cada vez. Exemplos de iterá veis incluem todos os tipos de
sequê ncia (tais como list, str e tuple) e alguns tipos de nã o-sequê ncia, como o dict, objetos arquivos,
alé m dos objetos de quaisquer classes que você definir com um mé todo __iter__() ou __getitem__()
que implementam a semâ ntica de sequência .
Iterá veis podem ser usados em um laço for e em vá rios outros lugares em que uma sequê ncia é necessá -
ria (zip(), map(), …). Quando um objeto iterá vel é passado como argumento para a funçã o embutida
iter(), ela retorna um iterador para o objeto. Este iterador é adequado para se varrer todo o conjunto de
valores. Ao usar iterá veis, normalmente nã o é necessá rio chamar iter() ou lidar com os objetos iteradores
em si. A instruçã o for faz isso automaticamente para você , criando uma variá vel temporá ria para armazenar
o iterador durante a execuçã o do laço. Veja també m iterador, sequência, e gerador.
iterador
Um objeto que representa um fluxo de dados. Repetidas chamadas ao mé todo __next__() de um iterador
(ou passando o objeto para a funçã o embutida next()) vã o retornar itens sucessivos do fluxo. Quando
nã o houver mais dados disponíveis uma exceçã o StopIteration será levantada. Neste ponto, o objeto
iterador se esgotou e quaisquer chamadas subsequentes a seu mé todo __next__() vã o apenas levantar a
exceçã o StopIteration novamente. Iteradores precisam ter um mé todo __iter__() que retorne o
objeto iterador em si, de forma que todo iterador també m é iterá vel e pode ser usado na maioria dos lugares
em que um iterá vel é requerido. Uma notá vel exceçã o é có digo que tenta realizar passagens em mú ltiplas
iteraçõ es. Um objeto contê iner (como uma list) produz um novo iterador a cada vez que você passá -lo para
a funçã o iter() ou utilizá -lo em um laço for. Tentar isso com o mesmo iterador apenas iria retornar o
mesmo objeto iterador esgotado já utilizado na iteraçã o anterior, como se fosse um contê iner vazio.
Mais informaçõ es podem ser encontradas em typeiter.
Detalhes da implementação do CPython: O CPython nã o aplica consistentemente o requisito que um ite-
rador define __iter__().
função chave
Uma funçã o chave ou funçã o colaçã o é um chamá vel que retorna um valor usado para ordenaçã o ou classifi-
caçã o. Por exemplo, [Link]() é usada para produzir uma chave de ordenaçã o que leva o locale
em consideraçã o para fins de ordenaçã o.
Uma porçã o de ferramentas no Python aceitam funçõ es chave para controlar como os elementos sã o ordenados
ou agrupados. Algumas delas incluem min(), max(), sorted(), [Link](), [Link](),
[Link](), [Link]() e [Link]().
Há vá rias maneiras de se criar funçõ es chave. Por exemplo, o mé todo [Link]() pode servir como uma
funçã o chave para ordenaçõ es insensíveis à caixa. Alternativamente, uma funçã o chave ad-hoc pode ser cons-
truída a partir de uma expressã o lambda, como lambda r: (r[0], r[2]). Alé m disso, operator.
attrgetter(), [Link]() e [Link]() sã o trê s construto-
res de funçã o chave. Consulte o HowTo de Ordenaçã o para ver exemplos de como criar e utilizar funçõ es
chave.
argumento nomeado
Veja argumento.
lambda
Uma funçã o de linha anô nima consistindo de uma ú nica expressão, que é avaliada quando a funçã o é chamada.
A sintaxe para criar uma funçã o lambda é lambda [parameters]: expression
LBYL
Iniciais da expressã o em inglê s “look before you leap”, que significa algo como “olhe antes de pisar”. Este estilo
de codificaçã o testa as pré -condiçõ es explicitamente antes de fazer chamadas ou buscas. Este estilo contrasta
com a abordagem EAFP e é caracterizada pela presença de muitas instruçõ es if.

129
Python Tutorial, Release 3.12.5

Em um ambiente multithread, a abordagem LBYL pode arriscar a introduçã o de uma condiçã o de corrida
entre “o olhar” e “o pisar”. Por exemplo, o có digo if key in mapping: return mapping[key]
pode falhar se outra thread remover key do mapping apó s o teste, mas antes da olhada. Esse problema pode
ser resolvido com bloqueios ou usando a abordagem EAFP.
lista
Uma sequência embutida no Python. Apesar do seu nome, é mais pró ximo de um vetor em outras linguagens
do que uma lista encadeada, como o acesso aos elementos é da ordem O(1).
compreensão de lista
Uma maneira compacta de processar todos ou parte dos elementos de uma sequê ncia e retornar os resultados
em uma lista. result = ['{:#04x}'.format(x) for x in range(256) if x % 2 ==
0] gera uma lista de strings contendo nú meros hexadecimais (0x..) no intervalo de 0 a 255. A clá usula if é
opcional. Se omitida, todos os elementos no range(256) serã o processados.
carregador
Um objeto que carrega um mó dulo. Deve definir um mé todo chamado load_module(). Um carregador
é normalmente devolvido por um localizador. Veja a PEP 302 para detalhes e [Link]
para um classe base abstrata.
codificação da localidade
No Unix, é a codificaçã o da localidade do LC_CTYPE, que pode ser definida com locale.
setlocale(locale.LC_CTYPE, new_locale).
No Windows, é a pá gina de có digo ANSI (ex: "cp1252").
No Android e no VxWorks, o Python usa "utf-8" como a codificaçã o da localidade.
[Link]() pode ser usado para obter a codificaçã o da localidade.
Veja també m tratador de erros e codificação do sistema de arquivos.
método mágico
Um sinô nimo informal para um método especial.
mapeamento
Um objeto contê iner que tem suporte a pesquisas de chave arbitrá ria e implementa os mé todos especifi-
cados nas [Link] ou [Link] classes base
abstratas. Exemplos incluem dict, [Link], [Link]
e [Link].
localizador de metacaminho
Um localizador retornado por uma busca de sys.meta_path. Localizadores de metacaminho sã o relacio-
nados a, mas diferentes de, localizadores de entrada de caminho.
Veja [Link] para os mé todos que localizadores de metacaminho imple-
mentam.
metaclasse
A classe de uma classe. Definiçõ es de classe criam um nome de classe, um dicioná rio de classe e uma lista
de classes base. A metaclasse é responsá vel por receber estes trê s argumentos e criar a classe. A maioria das
linguagens de programaçã o orientadas a objetos provê uma implementaçã o default. O que torna o Python
especial é o fato de ser possível criar metaclasses personalizadas. A maioria dos usuá rios nunca vai preci-
sar deste recurso, mas quando houver necessidade, metaclasses possibilitam soluçõ es poderosas e elegantes.
Metaclasses tê m sido utilizadas para gerar registros de acesso a atributos, para incluir proteçã o contra acesso
concorrente, rastrear a criaçã o de objetos, implementar singletons, dentre muitas outras tarefas.
Mais informaçõ es podem ser encontradas em metaclasses.
método
Uma funçã o que é definida dentro do corpo de uma classe. Se chamada como um atributo de uma instâ ncia
daquela classe, o mé todo receberá a instâ ncia do objeto como seu primeiro argumento (que comumente é
chamado de self). Veja função e escopo aninhado.
ordem de resolução de métodos
Ordem de resoluçã o de mé todos é a ordem em que os membros de uma classe base sã o buscados durante a

130 Apêndice A. Glossário

 Python Tutorial, Release 3.12.5

pesquisa. Veja python_2.3_mro para detalhes do algoritmo usado pelo interpretador do Python desde a versã o
2.3.
módulo
Um objeto que serve como uma unidade organizacional de có digo Python. Os mó dulos tê m um espaço de
nomes contendo objetos Python arbitrá rios. Os mó dulos sã o carregados pelo Python atravé s do processo de
importação.
Veja també m pacote.
módulo spec
Um espaço de nomes que conté m as informaçõ es relacionadas à importaçã o usadas para carregar um mó dulo.
Uma instâ ncia de [Link].
MRO
Veja ordem de resolução de métodos.
mutável
Objeto mutá vel é aquele que pode modificar seus valor mas manter seu id(). Veja també m imutável.
tupla nomeada
O termo “tupla nomeada” é aplicado a qualquer tipo ou classe que herda de tupla e cujos elementos indexá veis
també m sã o acessíveis usando atributos nomeados. O tipo ou classe pode ter outras funcionalidades també m.
Diversos tipos embutidos sã o tuplas nomeadas, incluindo os valores retornados por [Link]() e
[Link](). Outro exemplo é sys.float_info:

>>> sys.float_info[1] # indexed access

1024
>>> sys.float_info.max_exp # named field access
1024
>>> isinstance(sys.float_info, tuple) # kind of tuple
True

Algumas tuplas nomeadas sã o tipos embutidos (tal como os exemplos acima). Alternativamente, uma tupla
nomeada pode ser criada a partir de uma definiçã o de classe regular, que herde de tuple e que defina campos
nomeados. Tal classe pode ser escrita a mã o, ou ela pode ser criada herdando [Link] ou
com uma funçã o fá brica [Link](). As duas ú ltimas té cnicas també m adicionam
alguns mé todos extras, que podem nã o ser encontrados quando foi escrita manualmente, ou em tuplas nomeadas
embutidas.
espaço de nomes
O lugar em que uma variá vel é armazenada. Espaços de nomes sã o implementados como dicioná rios. Existem
os espaços de nomes local, global e nativo, bem como espaços de nomes aninhados em objetos (em mé to-
dos). Espaços de nomes suportam modularidade ao prevenir conflitos de nomes. Por exemplo, as funçõ es
__builtin__.open() e [Link]() sã o diferenciadas por seus espaços de nomes. Espaços de nomes
també m auxiliam na legibilidade e na manutenibilidade ao torar mais claro quais mó dulos implementam uma
funçã o. Escrever [Link]() ou [Link](), por exemplo, deixa claro que estas funçõ es
sã o implementadas pelos mó dulos random e itertools respectivamente.
pacote de espaço de nomes
Um pacote da PEP 420 que serve apenas como container para sub pacotes. Pacotes de espaços de nomes
podem nã o ter representaçã o física, e especificamente nã o sã o como um pacote regular porque eles nã o tem
um arquivo __init__.py.
Veja també m módulo.
escopo aninhado
A habilidade de referir-se a uma variá vel em uma definiçã o de fechamento. Por exemplo, uma funçã o definida
dentro de outra pode referenciar variá veis da funçã o externa. Perceba que escopos aninhados por padrã o
funcionam apenas por referê ncia e nã o por atribuiçã o. Variá veis locais podem ler e escrever no escopo mais
interno. De forma similar, variá veis globais podem ler e escrever para o espaço de nomes global. O nonlocal
permite escrita para escopos externos.

131
Python Tutorial, Release 3.12.5

classe estilo novo

Antigo nome para o tipo de classes agora usado para todos os objetos de classes. Em versõ es anteriores do
Python, apenas classes estilo podiam usar recursos novos e versá teis do Python, tais como __slots__,
descritores, propriedades, __getattribute__(), mé todos de classe, e mé todos está ticos.
objeto
Qualquer dado que tenha estado (atributos ou valores) e comportamento definidos (mé todos). També m a
ú ltima classe base de qualquer classe estilo novo.
pacote
Um módulo Python é capaz de conter submó dulos ou recursivamente, subpacotes. Tecnicamente, um pacote
é um mó dulo Python com um atributo __path__.
Veja també m pacote regular e pacote de espaço de nomes.
parâmetro
Uma entidade nomeada na definiçã o de uma função (ou mé todo) que específica um argumento (ou em alguns
casos, argumentos) que a funçã o pode receber. Existem cinco tipos de parâ metros:
• posicional-ou-nomeado: especifica um argumento que pode ser tanto posicional quanto nomeado. Esse
é o tipo padrã o de parâ metro, por exemplo foo e bar a seguir:

def func(foo, bar=None): ...

• somente-posicional: especifica um argumento que pode ser fornecido apenas por posiçã o. Parâ metros
somente-posicionais podem ser definidos incluindo o caractere / na lista de parâ metros da definiçã o da
funçã o apó s eles, por exemplo posonly1 e posonly2 a seguir:

def func(posonly1, posonly2, /, positional_or_keyword): ...

• somente-nomeado: especifica um argumento que pode ser passado para a funçã o somente por nome.
Parâ metros somente-nomeados podem ser definidos com um simples parâ metro var-posicional ou um *
antes deles na lista de parâ metros na definiçã o da funçã o, por exemplo kw_only1 and kw_only2 a seguir:

def func(arg, *, kw_only1, kw_only2): ...

• var-posicional: especifica que uma sequê ncia arbitrá ria de argumentos posicionais pode ser fornecida
(em adiçã o a qualquer argumento posicional já aceito por outros parâ metros). Tal parâ metro pode ser
definido colocando um * antes do nome do parâ metro, por exemplo args a seguir:

def func(*args, **kwargs): ...

• var-nomeado: especifica que, arbitrariamente, muitos argumentos nomeados podem ser fornecidos (em
adiçã o a qualquer argumento nomeado já aceito por outros parâ metros). Tal parâ metro pode definido
colocando-se ** antes do nome, por exemplo kwargs no exemplo acima.
Parâ metros podem especificar tanto argumentos opcionais quanto obrigató rios, assim como valores padrã o
para alguns argumentos opcionais.
Veja o termo argumento no glossá rio, a pergunta sobre a diferença entre argumentos e parâ metros, a classe
[Link], a seçã o function e a PEP 362.
entrada de caminho
Um local ú nico no caminho de importação que o localizador baseado no caminho consulta para encontrar
mó dulos a serem importados.
localizador de entrada de caminho
Um localizador retornado por um chamá vel em sys.path_hooks (ou seja, um gancho de entrada de ca-
minho) que sabe como localizar os mó dulos entrada de caminho.
Veja [Link] para os mé todos que localizadores de entrada de caminho
implementam.

132 Apêndice A. Glossário

 Python Tutorial, Release 3.12.5

gancho de entrada de caminho

Um chamá vel na lista sys.path_hooks que retorna um localizador de entrada de caminho caso saiba como
localizar mó dulos em uma entrada de caminho específica.
localizador baseado no caminho
Um dos localizadores de metacaminho padrã o que procura por um caminho de importação de mó dulos.
objeto caminho ou similar
Um objeto representando um caminho de sistema de arquivos. Um objeto caminho ou similar é ou um objeto
str ou bytes representando um caminho, ou um objeto implementando o protocolo [Link]. Um
objeto que suporta o protocolo [Link] pode ser convertido para um arquivo de caminho do sistema
str ou bytes, atravé s da chamada da funçã o [Link](); [Link]() e [Link]()
podem ser usadas para garantir um str ou bytes como resultado, respectivamente. Introduzido na PEP
519.
PEP
Proposta de melhoria do Python. Uma PEP é um documento de design que fornece informaçã o para a co-
munidade Python, ou descreve uma nova funcionalidade para o Python ou seus predecessores ou ambientes.
PEPs devem prover uma especificaçã o té cnica concisa e um racional para funcionalidades propostas.
PEPs tê m a intençã o de ser os mecanismos primá rios para propor novas funcionalidades significativas, para
coletar opiniõ es da comunidade sobre um problema, e para documentar as decisõ es de design que foram
adicionadas ao Python. O autor da PEP é responsá vel por construir um consenso dentro da comunidade e
documentar opiniõ es dissidentes.
Veja PEP 1.
porção
Um conjunto de arquivos em um ú nico diretó rio (possivelmente armazenado em um arquivo zip) que contri-
buem para um pacote de espaço de nomes, conforme definido em PEP 420.
argumento posicional
Veja argumento.
API provisória
Uma API provisó ria é uma API que foi deliberadamente excluída das bibliotecas padrõ es com compatibilidade
retroativa garantida. Enquanto mudanças maiores para tais interfaces nã o sã o esperadas, contanto que elas
sejam marcadas como provisó rias, mudanças retroativas incompatíveis (até e incluindo a remoçã o da interface)
podem ocorrer se consideradas necessá rias pelos desenvolvedores principais. Tais mudanças nã o serã o feitas
gratuitamente – elas irã o ocorrer apenas se sé rias falhas fundamentais forem descobertas, que foram esquecidas
anteriormente a inclusã o da API.
Mesmo para APIs provisó rias, mudanças retroativas incompatíveis sã o vistas como uma “soluçã o em ú ltimo
caso” - cada tentativa ainda será feita para encontrar uma resoluçã o retroativa compatível para quaisquer pro-
blemas encontrados.
Esse processo permite que a biblioteca padrã o continue a evoluir com o passar do tempo, sem se prender em
erros de design problemá ticos por períodos de tempo prolongados. Veja PEP 411 para mais detalhes.
pacote provisório
Veja API provisória.
Python 3000
Apelido para a linha de lançamento da versã o do Python 3.x (cunhada há muito tempo, quando o lançamento
da versã o 3 era algo em um futuro muito distante.) Esse termo possui a seguinte abreviaçã o: “Py3k”.
Pythônico
Uma ideia ou um pedaço de có digo que segue de perto os idiomas mais comuns da linguagem Python, ao
invé s de implementar có digos usando conceitos comuns a outros idiomas. Por exemplo, um idioma comum
em Python é fazer um loop sobre todos os elementos de uma iterá vel usando a instruçã o for. Muitas outras
linguagens nã o tê m esse tipo de construçã o, entã o as pessoas que nã o estã o familiarizadas com o Python usam
um contador numé rico:

133
Python Tutorial, Release 3.12.5

for i in range(len(food)):
print(food[i])

Ao contrá rio do mé todo limpo, ou entã o, Pythô nico:

for piece in food:

print(piece)

nome qualificado
Um nome pontilhado (quando 2 termos sã o ligados por um ponto) que mostra o “path” do escopo global de um
mó dulo para uma classe, funçã o ou mé todo definido num determinado mó dulo, conforme definido pela PEP
3155. Para funçõ es e classes de nível superior, o nome qualificado é o mesmo que o nome do objeto:

>>> class C:
... class D:
... def meth(self):
... pass
...
>>> C.__qualname__
'C'
>>> C.D.__qualname__
'C.D'
>>> [Link].__qualname__
'[Link]'

Quando usado para se referir a mó dulos, o nome totalmente qualificado significa todo o caminho pontilhado
para o mó dulo, incluindo quaisquer pacotes pai, por exemplo: [Link]:

>>> import [Link]

>>> [Link].__name__
'[Link]'

contagem de referências
O nú mero de referê ncias a um objeto. Quando a contagem de referê ncias de um objeto cai para zero, ele
é desalocado. Alguns objetos sã o “imortais” e tê m contagens de referê ncias que nunca sã o modificadas e,
portanto, os objetos nunca sã o desalocados. A contagem de referê ncias geralmente nã o é visível para o có digo
Python, mas é um elemento-chave da implementaçã o do CPython. Os programadores podem chamar a funçã o
[Link]() para retornar a contagem de referê ncias para um objeto específico.
pacote regular
Um pacote tradicional, como um diretó rio contendo um arquivo __init__.py.
Veja també m pacote de espaço de nomes.
__slots__
Uma declaraçã o dentro de uma classe que economiza memó ria pré -declarando espaço para atributos de ins-
tâ ncias, e eliminando dicioná rios de instâ ncias. Apesar de popular, a té cnica é um tanto quanto complicada
de acertar, e é melhor se for reservada para casos raros, onde existe uma grande quantidade de instâ ncias em
uma aplicaçã o onde a memó ria é crítica.
sequência
Um iterável com suporte para acesso eficiente a seus elementos atravé s de índices inteiros via mé todo especial
__getitem__() e que define o mé todo __len__() que devolve o tamanho da sequê ncia. Alguns tipos
de sequê ncia embutidos sã o: list, str, tuple, e bytes. Note que dict també m tem suporte para
__getitem__() e __len__(), mas é considerado um mapeamento e nã o uma sequê ncia porque a busca
usa uma chave imutável arbitrá ria em vez de inteiros.
A classe base abstrata [Link] define uma interface mais rica que vai alé m de
apenas __getitem__() e __len__(), adicionando count(), index(), __contains__(), e
__reversed__(). Tipos que implementam essa interface podem ser explicitamente registrados usando
register(). Para mais documentaçã o sobre mé todos de sequê ncias em geral, veja Operaçõ es comuns de
sequê ncias.

134 Apêndice A. Glossário

 Python Tutorial, Release 3.12.5

compreensão de conjunto
Uma maneira compacta de processar todos ou parte dos elementos em iterá vel e retornar um conjunto com os
resultados. results = {c for c in 'abracadabra' if c not in 'abc'} gera um con-
junto de strings {'r', 'd'}. Veja comprehensions.
despacho único
Uma forma de despacho de função genérica onde a implementaçã o é escolhida com base no tipo de um ú nico
argumento.
fatia
Um objeto geralmente contendo uma parte de uma sequência. Uma fatia é criada usando a notaçã o de subscrito
[] pode conter també m até dois pontos entre nú meros, como em variable_name[1:3:5]. A notaçã o
de suporte (subscrito) utiliza objetos slice internamente.
método especial
Um mé todo que é chamado implicitamente pelo Python para executar uma certa operaçã o em um tipo, como
uma adiçã o por exemplo. Tais mé todos tem nomes iniciando e terminando com dois underscores. Mé todos
especiais estã o documentados em specialnames.
instrução
Uma instruçã o é parte de uma suíte (um “bloco” de có digo). Uma instruçã o é ou uma expressão ou uma de
vá rias construçõ es com uma palavra reservada, tal como if, while ou for.
verificador de tipo estático
Uma ferramenta externa que lê o có digo Python e o analisa, procurando por problemas como tipos incorretos.
Consulte també m dicas de tipo e o mó dulo typing.
referência forte
Na API C do Python, uma referê ncia forte é uma referê ncia a um objeto que pertence ao có digo que conté m
a referê ncia. A referê ncia forte é obtida chamando Py_INCREF() quando a referê ncia é criada e liberada
com Py_DECREF() quando a referê ncia é excluída.
A funçã o Py_NewRef() pode ser usada para criar uma referê ncia forte para um objeto. Normalmente, a
funçã o Py_DECREF() deve ser chamada na referê ncia forte antes de sair do escopo da referê ncia forte, para
evitar o vazamento de uma referê ncia.
Veja també m referência emprestada.
codificador de texto
Uma string em Python é uma sequê ncia de pontos de có digo Unicode (no intervalo U+0000–U+10FFFF).
Para armazenar ou transferir uma string, ela precisa ser serializada como uma sequê ncia de bytes.
A serializaçã o de uma string em uma sequê ncia de bytes é conhecida como “codificaçã o” e a recriaçã o da string
a partir de uma sequê ncia de bytes é conhecida como “decodificaçã o”.
Há uma variedade de diferentes serializaçõ es de texto codecs, que sã o coletivamente chamadas de “codificaçõ es
de texto”.
arquivo texto
Um objeto arquivo apto a ler e escrever objetos str. Geralmente, um arquivo texto, na verdade, acessa um fluxo
de dados de bytes e captura o codificador de texto automaticamente. Exemplos de arquivos texto sã o: arquivos
abertos em modo texto ('r' or 'w'), [Link], [Link], e instâ ncias de [Link].
Veja també m arquivo binário para um objeto arquivo apto a ler e escrever objetos byte ou similar.
aspas triplas
Uma string que está definida com trê s ocorrê ncias de aspas duplas (”) ou apó strofos (‘). Enquanto elas nã o
fornecem nenhuma funcionalidade nã o disponível com strings de aspas simples, elas sã o ú teis para inú meras
razõ es. Elas permitem que você inclua aspas simples e duplas nã o escapadas dentro de uma string, e elas
podem utilizar mú ltiplas linhas sem o uso de caractere de continuaçã o, fazendo-as especialmente ú teis quando
escrevemos documentaçã o em docstrings.
tipo
O tipo de um objeto Python determina qual tipo de objeto ele é ; cada objeto tem um tipo. Um tipo de objeto
é acessível pelo atributo __class__ ou pode ser recuperado com type(obj).

135
Python Tutorial, Release 3.12.5

tipo alias
Um sinô nimo para um tipo, criado atravé s da atribuiçã o do tipo para um identificador.
Tipos alias sã o ú teis para simplificar dicas de tipo. Por exemplo:

def remove_gray_shades(
colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
pass

pode tornar-se mais legível desta forma:

Color = tuple[int, int, int]

def remove_gray_shades(colors: list[Color]) -> list[Color]:

pass

Veja typing e PEP 484, a qual descreve esta funcionalidade.

dica de tipo
Uma anotação que especifica o tipo esperado para uma variá vel, um atributo de classe, ou um parâ metro de
funçã o ou um valor de retorno.
Dicas de tipo sã o opcionais e nã o sã o forçadas pelo Python, mas elas sã o ú teis para verificadores de tipo estático.
Eles també m ajudam IDEs a completar e refatorar có digo.
Dicas de tipos de variá veis globais, atributos de classes, e funçõ es, mas nã o de variá veis locais, podem ser
acessadas usando typing.get_type_hints().
Veja typing e PEP 484, a qual descreve esta funcionalidade.
novas linhas universais
Uma maneira de interpretar fluxos de textos, na qual todos estes sã o reconhecidos como caracteres de fim de
linha: a convençã o para fim de linha no Unix '\n', a convençã o no Windows '\r\n', e a antiga convençã o
no Macintosh '\r'. Veja PEP 278 e PEP 3116, bem como [Link]() para uso adicional.
anotação de variável
Uma anotação de uma variá vel ou um atributo de classe.
Ao fazer uma anotaçã o de uma variá vel ou um atributo de classe, a atribuiçã o é opcional:

class C:
field: 'annotation'

Anotaçõ es de variá veis sã o normalmente usadas para dicas de tipo: por exemplo, espera-se que esta variá vel
receba valores do tipo int:

count: int = 0

A sintaxe de anotaçã o de variá vel é explicada na seçã o annassign.

Veja anotação de função, PEP 484 e PEP 526, que descrevem esta funcionalidade. Veja també m annotations-
-howto para as melhores prá ticas sobre como trabalhar com anotaçõ es.
ambiente virtual
Um ambiente de execuçã o isolado que permite usuá rios Python e aplicaçõ es instalarem e atualizarem pacotes
Python sem interferir no comportamento de outras aplicaçõ es Python em execuçã o no mesmo sistema.
Veja també m venv.
máquina virtual
Um computador definido inteiramente em software. A má quina virtual de Python executa o bytecode emitido
pelo compilador de bytecode.
Zen do Python
Lista de princípios de projeto e filosofias do Python que sã o ú teis para a compreensã o e uso da linguagem. A
lista é exibida quando se digita “import this” no console interativo.

136 Apêndice A. Glossário

 APÊNDICE B

Sobre esses documentos

Esses documentos sã o gerados a partir de reStructuredText pelo Sphinx, um processador de documentos especifica-
mente escrito para documentaçã o Python.
O desenvolvimento da documentaçã o e de suas ferramentas é um esforço totalmente voluntá rio, como Python em
si. Se você quer contribuir, por favor dê uma olhada na pá gina reporting-bugs para informaçõ es sobre como fazer.
Novos voluntá rios sã o sempre bem-vindos!
Agradecimentos especiais para:
• Fred L. Drake, Jr., o criador do primeiro conjunto de ferramentas para documentar Python e escritor de boa
parte do conteú do;
• O projeto Docutils por criar reStructuredText e o pacote Docutils;
• Fredrik Lundh, pelo seu projeto de referê ncia alternativa em Python, do qual Sphinx pegou muitas boas ideias.

B.1 Contribuidores da Documentação Python

Muitas pessoas tem contribuído para a linguagem Python, sua biblioteca padrã o e sua documentaçã o. Veja
Misc/ACKS na distribuiçã o do có digo do Python para ver uma lista parcial de contribuidores.
Tudo isso só foi possível com o esforço e a contribuiçã o da comunidade Python, por isso temos essa maravilhosa
documentaçã o – Obrigado a todos!

137
Python Tutorial, Release 3.12.5

138 Apêndice B. Sobre esses documentos

 APÊNDICE C

História e Licença

C.1 História do software

O Python foi criado no início dos anos 1990 por Guido van Rossum na Stichting Mathematisch Centrum (CWI,
veja [Link] na Holanda como um sucessor de uma linguagem chamada ABC. Guido continua a ser o
principal autor de Python, embora inclua muitas contribuiçõ es de outros.
Em 1995, Guido continuou seu trabalho em Python na Corporaçã o para Iniciativas Nacionais de Pesquisa (CNRI,
veja [Link] em Reston, Virgínia, onde lançou vá rias versõ es do software.
Em maio de 2000, Guido e a equipe principal de desenvolvimento do Python mudaram-se para o [Link] para
formar a equipe BeOpen PythonLabs. Em outubro do mesmo ano, a equipe da PythonLabs mudou para a Digital
Creations (agora Zope Corporation; veja [Link] Em 2001, formou-se a Python Software Foundation
(PSF, veja [Link] uma organizaçã o sem fins lucrativos criada especificamente para possuir
propriedade intelectual relacionada a Python. A Zope Corporation é um membro patrocinador do PSF.
Todas as versõ es do Python sã o de có digo aberto (consulte [Link] para a definiçã o de có digo aberto).
Historicamente, a maioria, mas nã o todas, versõ es do Python també m sã o compatíveis com GPL; a tabela abaixo
resume os vá rios lançamentos.

Versão Derivada de Ano Proprietário Compatível com a GPL?

0.9.0 a 1.2 n/a 1991-1995 CWI sim
1.3 a 1.5.2 1.2 1995-1999 CNRI sim
1.6 1.5.2 2000 CNRI nã o
2.0 1.6 2000 [Link] nã o
1.6.1 1.6 2001 CNRI nã o
2.1 2.0+1.6.1 2001 PSF nã o
2.0.1 2.0+1.6.1 2001 PSF sim
2.1.1 2.1+2.0.1 2001 PSF sim
2.1.2 2.1.1 2002 PSF sim
2.1.3 2.1.2 2002 PSF sim
2.2 e acima 2.1.1 2001-agora PSF sim

Nota

139
Python Tutorial, Release 3.12.5

Compatível com a GPL nã o significa que estamos distribuindo Python sob a GPL. Todas as licenças do Python,
ao contrá rio da GPL, permitem distribuir uma versã o modificada sem fazer alteraçõ es em có digo aberto. As
licenças compatíveis com a GPL possibilitam combinar o Python com outro software lançado sob a GPL; os
outros nã o.

Graças aos muitos voluntá rios externos que trabalharam sob a direçã o de Guido para tornar esses lançamentos pos-
síveis.

C.2 Termos e condições para acessar ou usar Python

O software e a documentaçã o do Python sã o licenciados sob o Acordo de Licenciamento PSF.

A partir do Python 3.8.6, exemplos, receitas e outros có digos na documentaçã o sã o licenciados duplamente sob o
Acordo de Licenciamento PSF e a Licença BSD de Zero Cláusula.
Alguns softwares incorporados ao Python estã o sob licenças diferentes. As licenças sã o listadas com o có digo abran-
gido por essa licença. Veja Licenças e Reconhecimentos para Software Incorporado para uma lista incompleta dessas
licenças.

C.2.1 ACORDO DE LICENCIAMENTO DA PSF PARA PYTHON 3.12.5

1. This LICENSE AGREEMENT is between the Python Software Foundation␣

,→("PSF"), and

the Individual or Organization ("Licensee") accessing and otherwise␣

,→using Python

3.12.5 software in source or binary form and its associated␣

,→documentation.

2. Subject to the terms and conditions of this License Agreement, PSF␣

,→hereby

grants Licensee a nonexclusive, royalty-free, world-wide license to␣

,→reproduce,

analyze, test, perform and/or display publicly, prepare derivative␣

,→works,

distribute, and otherwise use Python 3.12.5 alone or in any derivative

version, provided, however, that PSF's License Agreement and PSF's␣
,→notice of

copyright, i.e., "Copyright © 2001-2023 Python Software Foundation; All␣

,→Rights

Reserved" are retained in Python 3.12.5 alone or in any derivative␣

,→version

prepared by Licensee.

3. In the event Licensee prepares a derivative work that is based on or

incorporates Python 3.12.5 or any part thereof, and wants to make the
derivative work available to others as provided herein, then Licensee␣
,→hereby

agrees to include in any such work a brief summary of the changes made␣
,→to Python

3.12.5.

4. PSF is making Python 3.12.5 available to Licensee on an "AS IS" basis.

PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY␣
,→OF

140 Apêndice C. História e Licença

 Python Tutorial, Release 3.12.5

EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY␣

,→REPRESENTATION OR
WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR␣
,→THAT THE

USE OF PYTHON 3.12.5 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 3.12.5
FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A␣
,→RESULT OF

MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 3.12.5, OR ANY␣

,→DERIVATIVE

THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

6. This License Agreement will automatically terminate upon a material␣

,→breach of

its terms and conditions.

7. Nothing in this License Agreement shall be deemed to create any␣

,→relationship

of agency, partnership, or joint venture between PSF and Licensee. ␣

,→This License

Agreement does not grant permission to use PSF trademarks or trade name␣
,→in a

trademark sense to endorse or promote products or services of Licensee,␣

,→or any

third party.

8. By copying, installing or otherwise using Python 3.12.5, Licensee agrees

to be bound by the terms and conditions of this License Agreement.

C.2.2 ACORDO DE LICENCIAMENTO DA [Link] PARA PYTHON 2.0

ACORDO DE LICENCIAMENTO DA BEOPEN DE FONTE ABERTA DO PYTHON VERSÃO 1

1. This LICENSE AGREEMENT is between [Link] ("BeOpen"), having an office at
160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization
("Licensee") accessing and otherwise using this software in source or binary
form and its associated documentation ("the Software").

2. Subject to the terms and conditions of this BeOpen Python License Agreement,
BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license
to reproduce, analyze, test, perform and/or display publicly, prepare derivative
works, distribute, and otherwise use the Software alone or in any derivative
version, provided, however, that the BeOpen Python License is retained in the
Software, alone or in any derivative version prepared by Licensee.

3. BeOpen is making the Software available to Licensee on an "AS IS" basis.

BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF
EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING,
MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF
ADVISED OF THE POSSIBILITY THEREOF.

5. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.
(continua na pró xima pá gina)

C.2. Termos e condições para acessar ou usar Python 141

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

6. This License Agreement shall be governed by and interpreted in all respects

by the law of the State of California, excluding conflict of law provisions.
Nothing in this License Agreement shall be deemed to create any relationship of
agency, partnership, or joint venture between BeOpen and Licensee. This License
Agreement does not grant permission to use BeOpen trademarks or trade names in a
trademark sense to endorse or promote products or services of Licensee, or any
third party. As an exception, the "BeOpen Python" logos available at
[Link] may be used according to the permissions
granted on that web page.

7. By copying, installing or otherwise using the software, Licensee agrees to be

bound by the terms and conditions of this License Agreement.

C.2.3 CONTRATO DE LICENÇA DA CNRI PARA O PYTHON 1.6.1

1. This LICENSE AGREEMENT is between the Corporation for National Research

Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191
("CNRI"), and the Individual or Organization ("Licensee") accessing and
otherwise using Python 1.6.1 software in source or binary form and its
associated documentation.

2. Subject to the terms and conditions of this License Agreement, CNRI hereby
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python 1.6.1 alone or in any derivative version,
provided, however, that CNRI's License Agreement and CNRI's notice of copyright,
i.e., "Copyright © 1995-2001 Corporation for National Research Initiatives; All
Rights Reserved" are retained in Python 1.6.1 alone or in any derivative version
prepared by Licensee. Alternately, in lieu of CNRI's License Agreement,
Licensee may substitute the following text (omitting the quotes): "Python 1.6.1
is made available subject to the terms and conditions in CNRI's License
Agreement. This Agreement together with Python 1.6.1 may be located on the
internet using the following unique, persistent identifier (known as a handle):
1895.22/1013. This Agreement may also be obtained from a proxy server on the
internet using the following URL: [Link]

3. In the event Licensee prepares a derivative work that is based on or

incorporates Python 1.6.1 or any part thereof, and wants to make the derivative
work available to others as provided herein, then Licensee hereby agrees to
include in any such work a brief summary of the changes made to Python 1.6.1.

4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" basis. CNRI
MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,
BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE
THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

6. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.

7. This License Agreement shall be governed by the federal intellectual property

law of the United States, including without limitation the federal copyright
law, and, to the extent such U.S. federal law does not apply, by the law of the
(continua na pró xima pá gina)

142 Apêndice C. História e Licença

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

Commonwealth of Virginia, excluding Virginia's conflict of law provisions.
Notwithstanding the foregoing, with regard to derivative works based on Python
1.6.1 that incorporate non-separable material that was previously distributed
under the GNU General Public License (GPL), the law of the Commonwealth of
Virginia shall govern this License Agreement only as to issues arising under or
with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in
this License Agreement shall be deemed to create any relationship of agency,
partnership, or joint venture between CNRI and Licensee. This License Agreement
does not grant permission to use CNRI trademarks or trade name in a trademark
sense to endorse or promote products or services of Licensee, or any third
party.

8. By clicking on the "ACCEPT" button where indicated, or by copying, installing

or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and
conditions of this License Agreement.

C.2.4 ACORDO DE LICENÇA DA CWI PARA PYTHON 0.9.0 A 1.2

Copyright © 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The

Netherlands. All rights reserved.

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted, provided that
the above copyright notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting documentation, and that
the name of Stichting Mathematisch Centrum or CWI not be used in advertising or
publicity pertaining to distribution of the software without specific, written
prior permission.

STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT
OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.

C.2.5 LICENÇA BSD DE ZERO CLÁUSULA PARA CÓDIGO NA DOCUMENTAÇÃO

DO PYTHON 3.12.5

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

C.2. Termos e condições para acessar ou usar Python 143

Python Tutorial, Release 3.12.5

C.3 Licenças e Reconhecimentos para Software Incorporado

Esta seçã o é uma lista incompleta, mas crescente, de licenças e reconhecimentos para softwares de terceiros incor-
porados na distribuiçã o do Python.

C.3.1 Mersenne Twister

A extensã o C _random subjacente ao mó dulo random inclui có digo baseado em um download de [Link]
[Link]/~m-mat/MT/MT2002/[Link]. A seguir estã o os comentá rios literais do có -
digo original:

A C-program for MT19937, with initialization improved 2002/1/26.

Coded by Takuji Nishimura and Makoto Matsumoto.

Before using, initialize the state by using init_genrand(seed)

or init_by_array(init_key, key_length).

Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

3. The names of its contributors may not be used to endorse or promote

products derived from this software without specific prior written
permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Any feedback is very welcome.

[Link]
email: m-mat @ [Link] (remove space)

144 Apêndice C. História e Licença

 Python Tutorial, Release 3.12.5

C.3.2 Soquetes

O mó dulo socket usa as funçõ es getaddrinfo() e getnameinfo(), que sã o codificadas em arquivos de
origem separados do Projeto WIDE, [Link]

Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the project nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

C.3.3 Serviços de soquete assíncrono

Os mó dulos [Link] e [Link] contê m o seguinte aviso:

Copyright 1996 by Sam Rushing

All Rights Reserved

Permission to use, copy, modify, and distribute this software and

its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of Sam
Rushing not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

C.3. Licenças e Reconhecimentos para Software Incorporado 145

Python Tutorial, Release 3.12.5

C.3.4 Gerenciamento de cookies

O mó dulo [Link] conté m o seguinte aviso:

Copyright 2000 by Timothy O'Malley <timo@[Link]>

All Rights Reserved

Permission to use, copy, modify, and distribute this software

and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Timothy O'Malley not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.

Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

C.3.5 Rastreamento de execução

O mó dulo trace conté m o seguinte aviso:

portions copyright 2001, Autonomous Zones Industries, Inc., all rights...

err... reserved and offered to the public under the terms of the
Python 2.2 license.
Author: Zooko O'Whielacronx
[Link]
[Link]

Copyright 2000, Mojam Media, Inc., all rights reserved.

Author: Skip Montanaro

Copyright 1999, Bioreason, Inc., all rights reserved.

Author: Andrew Dalke

Copyright 1995-1997, Automatrix, Inc., all rights reserved.

Author: Skip Montanaro

Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved.

Permission to use, copy, modify, and distribute this Python software and
its associated documentation for any purpose without fee is hereby
granted, provided that the above copyright notice appears in all copies,
and that both that copyright notice and this permission notice appear in
supporting documentation, and that the name of neither Automatrix,
Bioreason or Mojam Media be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.

146 Apêndice C. História e Licença

 Python Tutorial, Release 3.12.5

C.3.6 Funções UUencode e UUdecode

O mó dulo uu conté m o seguinte aviso:

Copyright 1994 by Lance Ellinghouse

Cathedral City, California Republic, United States of America.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Lance Ellinghouse
not be used in advertising or publicity pertaining to distribution
of the software without specific, written prior permission.
LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Modified by Jack Jansen, CWI, July 1995:

- Use binascii module to do the actual line-by-line conversion
between ascii and binary. This results in a 1000-fold speedup. The C
version is still 5 times faster, though.
- Arguments more compliant with Python standard

C.3.7 Chamadas de procedimento remoto XML

O mó dulo [Link] conté m o seguinte aviso:

The XML-RPC client interface is

Copyright (c) 1999-2002 by Secret Labs AB

Copyright (c) 1999-2002 by Fredrik Lundh

By obtaining, using, and/or copying this software and/or its

associated documentation, you agree that you have read, understood,
and will comply with the following terms and conditions:

Permission to use, copy, modify, and distribute this software and

its associated documentation for any purpose and without fee is
hereby granted, provided that the above copyright notice appears in
all copies, and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Secret Labs AB or the author not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.

SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.

C.3. Licenças e Reconhecimentos para Software Incorporado 147

Python Tutorial, Release 3.12.5

C.3.8 test_epoll

O mó dulo test.test_epoll conté m o seguinte aviso:

Copyright (c) 2001-2006 Twisted Matrix Laboratories.

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be

included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

C.3.9 kqueue de seleção

O mó dulo select conté m o seguinte aviso para a interface do kqueue:

Copyright (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes
All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

148 Apêndice C. História e Licença

 Python Tutorial, Release 3.12.5

C.3.10 SipHash24

O arquivo Python/pyhash.c conté m a implementaçã o de Marek Majkowski do algoritmo SipHash24 de Dan

Bernstein. Conté m a seguinte nota:

<MIT License>
Copyright (c) 2013 Marek Majkowski <marek@[Link]>

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
</MIT License>

Original location:
[Link]

Solution inspired by code from:

Samuel Neves (supercop/crypto_auth/siphash24/little)
djb (supercop/crypto_auth/siphash24/little2)
Jean-Philippe Aumasson ([Link]

C.3.11 strtod e dtoa

O arquivo Python/dtoa.c, que fornece as funçõ es C dtoa e strtod para conversã o de duplas de C para e de strings,
é derivado do arquivo com o mesmo nome de David M. Gay, atualmente disponível em [Link]
20220517033456/[Link] O arquivo original, conforme recuperado em 16 de março de
2009, conté m os seguintes avisos de direitos autorais e de licenciamento:

/****************************************************************
*
* The author of this software is David M. Gay.
*
* Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose without fee is hereby granted, provided that this entire notice
* is included in all copies of any software which is or includes a copy
* or modification of this software and in all copies of the supporting
* documentation for such software.
*
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
* OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
*
***************************************************************/

C.3. Licenças e Reconhecimentos para Software Incorporado 149

Python Tutorial, Release 3.12.5

C.3.12 OpenSSL

Os mó dulos hashlib, posix, ssl, crypt usam a biblioteca OpenSSL para desempenho adicional se forem
disponibilizados pelo sistema operacional. Alé m disso, os instaladores do Windows e do Mac OS X para Python
podem incluir uma có pia das bibliotecas do OpenSSL, portanto incluímos uma có pia da licença do OpenSSL aqui:
Para o lançamento do OpenSSL 3.0, e lançamentos posteriores derivados deste, se aplica a Apache License v2:

Apache License
Version 2.0, January 2004
[Link]

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by

the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity

exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.

"Object" form shall mean any form resulting from mechanical

transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or

Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object

form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including

the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
(continua na pró xima pá gina)

150 Apêndice C. História e Licença

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity

on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of

this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of

this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the

Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:

(a) You must give any other recipients of the Work or

Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its

distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 151

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.

You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,

any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or

agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,

whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing

the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

152 Apêndice C. História e Licença

 Python Tutorial, Release 3.12.5

C.3.13 expat

A extensã o pyexpat é construída usando uma có pia incluída das fontes de expatriadas, a menos que a compilaçã o
esteja configurada --with-system-expat:

Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
and Clark Cooper

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

C.3.14 libffi

A extensã o C _ctypes subjacente ao mó dulo ctypes é construída usando uma có pia incluída das fontes do libffi,
a menos que a construçã o esteja configurada com --with-system-libffi:

Copyright (c) 1996-2008 Red Hat, Inc and others.

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
``Software''), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

C.3. Licenças e Reconhecimentos para Software Incorporado 153

Python Tutorial, Release 3.12.5

C.3.15 zlib

A extensã o zlib é construída usando uma có pia incluída das fontes zlib se a versã o do zlib encontrada no sistema
for muito antiga para ser usada na construçã o:

Copyright (C) 1995-2011 Jean-loup Gailly and Mark Adler

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

Jean-loup Gailly Mark Adler

jloup@[Link] madler@[Link]

C.3.16 cfuhash

A implementaçã o da tabela de hash usada pelo tracemalloc é baseada no projeto cfuhash:

Copyright (c) 2005 Don Owens

All rights reserved.

This code is released under the BSD license:

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.

* Neither the name of the author nor the names of its

contributors may be used to endorse or promote products derived
from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
(continua na pró xima pá gina)

154 Apêndice C. História e Licença

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.

C.3.17 libmpdec

A extensã o C _decimal subjacente ao mó dulo decimal é construída usando uma có pia incluída da biblioteca
libmpdec, a menos que a construçã o esteja configurada com --with-system-libmpdec:

Copyright (c) 2008-2020 Stefan Krah. All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

C.3.18 Conjunto de testes C14N do W3C

O conjunto de testes C14N 2.0 no pacote test (Lib/test/xmltestdata/c14n-20/) foi recuperado do site
do W3C em [Link] e é distribuído sob a licença BSD de 3 clá usulas:

Copyright (c) 2013 W3C(R) (MIT, ERCIM, Keio, Beihang),

All Rights Reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

* Redistributions of works must retain the original copyright notice,

this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the original copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the W3C nor the names of its contributors may be
used to endorse or promote products derived from this work without
specific prior written permission.

(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 155

Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

C.3.19 Audioop

O mó dulo audioop usa a base de có digo no arquivo g771.c do projeto SoX. [Link]
files/sox/12.17.7/[Link]
Este có digo-fonte é um produto da Sun Microsystems, Inc. e é fornecido para uso irrestrito. Os usuá rios
podem copiar ou modificar este có digo-fonte sem custo.
SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLU-
DING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTI-
CULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRAC-
TICE.
Sun source code is provided with no support and without any obligation on the part of Sun Microsystems,
Inc. to assist in its use, correction, modification or enhancement.
SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE INFRIN-
GEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE OR
ANY PART THEREOF.
In no event will Sun Microsystems, Inc. be liable for any lost revenue or profits or other special, indirect
and consequential damages, even if Sun has been advised of the possibility of such damages.
Sun Microsystems, Inc. 2550 Garcia Avenue Mountain View, California 94043

C.3.20 asyncio

Partes do mó dulo asyncio sã o incorporadas do uvloop 0.16, que é distribuído sob a licença MIT:

Copyright (c) 2015-2021 MagicStack Inc. [Link]

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be

included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
(continua na pró xima pá gina)

156 Apêndice C. História e Licença

 Python Tutorial, Release 3.12.5

(continuaçã o da pá gina anterior)

OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

C.3. Licenças e Reconhecimentos para Software Incorporado 157

Python Tutorial, Release 3.12.5

158 Apêndice C. História e Licença

 APÊNDICE D

Direitos autorais

Python e essa documentaçã o é :

Copyright © 2001-2023 Python Software Foundation. Todos os direitos reservados.
Copyright © 2000 [Link]. Todos os direitos reservados.
Copyright © 1995-2000 Corporation for National Research Initiatives. Todos os direitos reservados.
Copyright © 1991-1995 Stichting Mathematisch Centrum. Todos os direitos reservados.

Veja: História e Licença para informaçõ es completas de licença e permissõ es.

159
Python Tutorial, Release 3.12.5

160 Apêndice D. Direitos autorais

 Índice

Não alfabético C
..., 121 caminho
# (cerquilha) módulo pesquisa, 51
comentário, 9 caminho de importação, 128
* (asterisco) carregador, 130
em chamadas de função, 32 chamável, 123
** classe, 123
em chamadas de função, 32 classe base abstrata, 121
2to3, 121 classe estilo novo, 132
: (dois pontos) codificação
anotações de função, 34 estilo, 34
-> codificação da localidade, 130
anotações de função, 34 codificador de texto, 135
>>>, 121 coleta de lixo, 127
__all__, 56 compreensão de conjunto, 135
__future__, 126 compreensão de dicionário, 125
__slots__, 134 compreensão de lista, 130
contagem de referências, 134
A contíguo, 124
aguardável, 123 contíguo C, 124
ambiente virtual, 136 contíguo Fortran, 124
annotations corrotina, 124
função, 34 CPython, 124
anotação, 121
anotação de função, 126 D
anotação de variável, 136 decorador, 124
API provisória, 133 descritor, 125
argumento, 122 desfiguração
argumento nomeado, 129 nome, 86
argumento posicional, 133 desligamento do interpretador, 128
arquivo despacho único, 135
objeto, 63 dica de tipo, 136
arquivo binário, 123 dicionário, 125
arquivo texto, 135 divisão pelo piso, 126
aspas triplas, 135 docstring, 125
atributo, 122 docstrings, 25, 33

B E
BDFL, 123 EAFP, 125
bloqueio global do interpretador, 127 entrada de caminho, 132
builtins escopo aninhado, 131
módulo, 54 espaço de nomes, 131
bytecode, 123 especial

161
Python Tutorial, Release 3.12.5

método, 135 lista, 130

estilo localizador, 126
codificação, 34 localizador baseado no caminho, 133
expressão, 125 localizador de entrada de caminho, 132
expressão geradora, 127 localizador de metacaminho, 130

F M
f-string, 125 mágico
fatia, 135 método, 130
for mapeamento, 130
instrução, 20 máquina virtual, 136
função, 126 metaclasse, 130
annotations, 34 método, 130
função chave, 129 especial, 135
função de corrotina, 124 mágico, 130
função de retorno, 123 objeto, 81
função embutida método especial, 135
help, 91 método mágico, 130
open, 63 módulo, 131
função genérica, 127 builtins, 54
json, 65
G pesquisa caminho, 51
gancho de entrada de caminho, 133 sys, 53
gerador, 127 módulo de extensão, 125
gerador assíncrono, 122 módulo spec, 131
gerenciador de contexto, 124 MRO, 131
gerenciador de contexto assíncrono, mutável, 131
122
GIL, 127 N
nome
H desfiguração, 86
hasheável, 128 nome qualificado, 134
help novas linhas universais, 136
função embutida, 91 número complexo, 124

I O
IDLE, 128 objeto, 132
importação, 128 arquivo, 63
importador, 128 método, 81
imutável, 128 objeto arquivo, 126
instrução, 135 objeto arquivo ou similar, 126
for, 20 objeto byte ou similar, 123
interativo, 128 objeto caminho ou similar, 133
interpretado, 128 open
iterador, 129 função embutida, 63
iterador assíncrono, 122 ordem de resolução de métodos, 130
iterador gerador, 127
iterador gerador assíncrono, 122 P
iterável, 129 pacote, 132
iterável assíncrono, 122 pacote de espaço de nomes, 131
pacote provisório, 133
J pacote regular, 134
json parâmetro, 132
módulo, 65 PATH, 51, 119
PEP, 133
L pesquisa
lambda, 129 caminho, módulo, 51
LBYL, 129 porção, 133

162 Índice
 Python Tutorial, Release 3.12.5

Propostas de Melhorias do Python PYTHONPATH, 51, 53

PEP 1, 133 PYTHONSTARTUP, 120
PEP 8, 34 variável de classe, 124
PEP 238, 126 variável de contexto, 124
PEP 278, 136 verificador de tipo estático, 135
PEP 302, 130 visão de dicionário, 125
PEP 343, 124
PEP 362, 122, 132 Z
PEP 411, 133 Zen do Python, 136
PEP 420, 131, 133
PEP 443, 127
PEP 483, 127
PEP 484, 34, 121, 126, 127, 136
PEP 492, 122124
PEP 498, 125
PEP 519, 133
PEP 525, 122
PEP 526, 121, 136
PEP 585, 127
PEP 636, 25
PEP 3107, 34
PEP 3116, 136
PEP 3147, 52
PEP 3155, 134
pyc baseado em hash, 128
Python 3000, 133
Pythônico, 133
PYTHONPATH, 51, 53
PYTHONSTARTUP, 120

R
referência emprestada, 123
referência forte, 135
RFC
RFC 2822, 96

S
sequência, 134
sitecustomize, 120
strings, documentação, 25, 33
sys
módulo, 53

T
tipagem pato, 125
tipo, 135
tipo alias, 136
tipo genérico, 127
tratador de erros e codificação do
sistema de arquivos, 126
tupla nomeada, 131

U
usercustomize, 120

V
variável de ambiente
PATH, 51, 119

Índice 163