Python Tutorial

Release 3.13.0

Guido van Rossum and the Python development team

novembro 09, 2024

Python Software Foundation

Email: docs@python.org
 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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.1 Ediçã o de có digo-fonte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

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 Instruçõ es if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2 Instruçõ es for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.3 A funçã o range() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.4 Instruçõ es break e continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.5 Clá usulas else em laços . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.6 Instruçõ es pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.7 Instruçõ es match . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.8 Definindo funçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.9 Mais sobre definiçã o de funçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.9.1 Argumentos com valor padrã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.9.2 Argumentos nomeados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.9.3 Parâ metros especiais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.9.4 Listas de argumentos arbitrá rias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.9.5 Desempacotando listas de argumentos . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.9.6 Expressõ es lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.9.7 Strings de documentaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.9.8 Anotaçõ es de funçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.10 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 Compreensõ es de lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

i
 5.1.4 Compreensõ es de lista aninhadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
8.9 Criando e tratando vá rias exceçõ es nã o relacionadas . . . . . . . . . . . . . . . . . . . . . . . . . 74
8.10 Enriquecendo exceçõ es com notas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

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

ii
 9.9 Geradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
9.10 Expressõ es geradoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

10 Um breve passeio pela biblioteca padrão 93

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

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

11.1 Formatando a saída . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
11.2 Usando templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
11.3 Trabalhando com formatos biná rios de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
11.4 Multi-threading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
11.5 Gerando logs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
11.6 Referê ncias fracas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
11.7 Ferramentas para trabalhar com listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
11.8 Aritmé tica decimal com ponto flutuante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

12 Ambientes virtuais e pacotes 107

12.1 Introduçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
12.2 Criando ambientes virtuais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
12.3 Gerenciando pacotes com o pip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

13 E agora? 111

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

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

15 Aritmética de ponto flutuante: problemas e limitações 115

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

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

A Glossário 123

B Sobre esses documentos 141

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

C História e Licença 143

C.1 Histó ria do software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
C.2 Termos e condiçõ es para acessar ou usar Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
C.2.1 ACORDO DE LICENCIAMENTO DA PSF PARA PYTHON 3.13.0 . . . . . . . . . . 144
C.2.2 ACORDO DE LICENCIAMENTO DA BEOPEN.COM PARA PYTHON 2.0 . . . . . . 145
C.2.3 CONTRATO DE LICENÇA DA CNRI PARA O PYTHON 1.6.1 . . . . . . . . . . . . 145
C.2.4 ACORDO DE LICENÇA DA CWI PARA PYTHON 0.9.0 A 1.2 . . . . . . . . . . . . . 147

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

D Direitos autorais 163

Índice 165

iv
 Python Tutorial, Release 3.13.0

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 sintaxe elegante e a tipagem dinâ mica do
Python, aliadas com sua natureza interpretativa, o tornam uma linguagem ideal para fazer scripts e desenvolvimento
de aplicaçõ es rá pidas em diversas á reas e na maioria das plataformas.
O interpretador do Python e sua extensiva biblioteca padrã o estã o disponíveis gratuitamente na forma de có digo ou
biná ria para todas as principais plataformas no endereço eletrô nico do Python, https://www.python.org/, e pode ser
livremente distribuído. O mesmo endereço conté m distribuiçõ es e indicaçõ es de diversos mó dulos, programas e
ferramentas gratuitos produzidos por terceiros e documentaçã o adicional.
O interpretador do Python pode ser facilmente estendido com novas funçõ es e tipos de dados implementados em
C ou C++ (ou outras linguagens chamá veis a partir de C). Python també m é adequado 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.13.0

2 Sumário
 CAPÍTULO 1

Abrindo seu apetite

Se você trabalha bastante com computadores, eventualmente perceberá que há alguma tarefa que gostaria de auto-
matizar. Por exemplo, pode querer realizar uma busca e substituiçã o em um grande nú mero de arquivos de texto ou
renomear e reorganizar um conjunto de fotos de maneira complexa. Talvez deseje criar um pequeno banco de dados
personalizado, uma aplicaçã o GUI especializada 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 aplicaçõ es 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 desen-
volvimento, uma vez que nã o há necessidade de compilaçã o e ligaçã 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.13.0

• 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 mó dulos ou funçõ es embutidas direta-
mente 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ê se entusiasmou com o Python, vai querer conhecê -lo com mais detalhes. Partindo do princípio que
a melhor maneira de aprender uma linguagem é usando-a, este tutorial lhe convida para fazê -lo com o interpretador
do Python enquanto você o lê .
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, instruçõ es, 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.13 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.13

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.13 estará
disponível. Se você tem o lançador py.exe instalado, você pode usar o comando py. Veja setting-envvars para outras
maneiras de executar o Python.
Digitar 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 interpretador 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
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.
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.13.0

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, sys.argv[0] será uma string vazia. Quando o nome do script for '-' (significando entrada padrã o),
o conteú do de sys.argv[0] será '-'. Quando for utilizado -c comando, sys.argv[0] conterá '-c'. Quando
for utilizado -m módulo, sys.argv[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 sys.argv 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.13
Python 3.13 (default, April 4 2023, 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:

>>> o_mundo_é_plano = True

>>> if o_mundo_é_plano:
... print("Cuidado para não cair da borda!")
...
Cuidado para não cair da borda!

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

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 -*-

6 Capítulo 2. Utilizando o interpretador Python

 Python Tutorial, Release 3.13.0

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.13.0

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 caractere
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:

# este é o primeiro comentário

spam = 1 # e este é o segundo comentário
# ... e agora um terceiro!
text = "# Este não é um comentário por estar entre aspas."

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
>>> (50 - 5*6) / 4
5.0
(continua na pró xima pá gina)

9
Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> 8 / 5 # divisão sempre retorna um número de ponto flutuante
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 # divisão clássica retorna um ponto flutuante

5.666666666666667
>>>
>>> 17 // 3 # divisão pelo piso descarta a parte fracionária
5
>>> 17 % 3 # o operador % retorna o resto da divisão
2
>>> 5 * 3 + 2 # quociente do piso * divisor + restante
17

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

>>> 5 ** 2 # 5 ao quadrado
25
>>> 2 ** 7 # 2 à potência de 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:

>>> largura = 20
>>> altura = 5 * 9
>>> largura * altura
900

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

>>> n # tenta acessar uma variável não definida

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:

>>> taxa = 12.5 / 100

>>> preço = 100.50
>>> preço * taxa
12.5625
>>> preço + _
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.13.0

(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:

>>> 'd\'água' # use \' para escapar a aspa simples...

"d'água"
>>> "d'água" # ...ou use aspas duplas
"d'água"
>>> '"Sim", eles disseram.'
'"Sim", eles disseram.'
>>> "\"Sim\", eles disseram."
'"Sim", eles disseram.'
>>> '"Copo d\'água", eles pediram.'
'"Copo d'água", eles pediram.'

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 = 'Primeira linha.\nSegunda linha.' # \n significa nova linha

>>> s # sem print(), caracteres especiais são incluídos na string
'Primeira linha.\nSegunda linha.'
>>> print(s) # com print(), caracteres especiais são interpretados, então \n␣
,→produz nova linha

Primeira linha.
Segunda linha.

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:\algum\nome') # aqui \n significa nova linha!

C:\algum
(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.13.0

(continuaçã o da pá gina anterior)

ome
>>> print(r'C:\algum\nome') # observe o r antes das aspas
C:\algum\nome

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. No
exemplo a seguir, a nova linha no início nã o é incluída:

>>> print("""\
... Uso: coisinha [OPÇÕES]
... -h Exibe esta mensagem de uso
... -H hostname Hostname para se conectar
... """)
Usage: coisinha [OPÇÕES]
-h Exibe esta mensagem de ajuda
-H hostname Hostname para se conectar

>>>

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

>>> # 3 vezes 'un', seguido por '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:

>>> texto = ('Coloque várias strings dentro de parênteses '

... 'para fazer com que elas sejam concatenadas.')
>>> texto
'Coloque várias strings dentro de parênteses para fazer com que elas sejam␣
,→concatenadas.'

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

>>> prefixo = 'Py'

>>> prefixo 'thon' # não é possível concatenar uma variável e um literal de string
File "<stdin>", line 1
prefixi '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 +:

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

 Python Tutorial, Release 3.13.0

>>> prefixo + '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:

>>> palavra = 'Python'

>>> palavra[0] # caractere na posição 0
'P'
>>> palavra[5] # caractere na posição 5
'n'

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

>>> palavra[-1] # último caractere

'n'
>>> palavra[-2] # penúltimo caractere
'o'
>>> palavra[-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:

>>> palavra[0:2] # caracteres da posição 0 (incluída) até 2 (excluída)

'Py'
>>> palavra[2:5] # caracteres da posição 2 (incluída) até 5 (excluída)
'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:

>>> palavra[:2] # caracteres do início até a posição 2 (excluída)

'Py'
>>> palavra[4:] # caracteres da posição 4 (incluída) até o fim
'on'
>>> palavra[-2:] # caracteres da penúltima (incluída) até o fim
'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:

>>> palavra[:2] + palavra[2:]

'Python'
>>> palavra[:4] + palavra[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

3.1. Usando Python como uma calculadora 13

Python Tutorial, Release 3.13.0

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:

>>> palavra[42] # a palavra só tem 6 caracteres

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:

>>> palavra[4:42]
'on'
>>> palavra[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:

>>> palavra[0] = 'J'

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> palavra[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' + palavra[1:]

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

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

>>> s = 'supercalifragilisticexpialidoce'
>>> len(s)
31

µ 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.

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

 Python Tutorial, Release 3.13.0

formatstrings
Informaçõ es sobre formataçã o de string com o mé todo str.format().
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.

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.

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

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

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

>>> quadrados[0] # indexação retorna o item

1
>>> quadrados[-1]
25
>>> quadrados[-3:] # fatiamento retorna uma nova lista
[9, 16, 25]

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

>>> quadrados + [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:

>>> cubos = [1, 8, 27, 65, 125] # algo errado aqui

>>> 4 ** 3 # o cubo de 4 é 64, não 65!
64
>>> cubos[3] = 64 # substitui o valor errado
>>> cubos
[1, 8, 27, 64, 125]

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

>>> cubos.append(216) # adiciona o cubo de 6

>>> cubos.append(7 ** 3) # e o cubo de 7
>>> cubos
[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 = ["Vermelho", "Verde", "Azul"]

>>> rgba = rgb
>>> id(rgb) == id(rgba) # elas referenciam o mesmo objeto
True
>>> rgba.append("Alf")
(continua na pró xima pá gina)

3.1. Usando Python como uma calculadora 15

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> rgb
["Vermelho", "Verde", "Azul", "Alf"]

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:

>>> rgba_correto = rgba[:]

>>> rgba_correto[-1] = "Alfa"
>>> rgba_correto
["Vermelho", "Verde", "Azul", "Alfa"]
>>> rgba
["Vermelho", "Verde", "Azul", "Alf"]

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

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

>>> letras
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # substitui alguns valores
>>> letras[2:5] = ['C', 'D', 'E']
>>> letras
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # agora remove-os
>>> letras[2:5] = []
>>> letras
['a', 'b', 'f', 'g']
>>> # limpa a lista substituindo todos os elementos por uma lista vazia
>>> letras[:] = []
>>> letras
[]

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

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

>>> len(letras)
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:

>>> # Sequência de Fibonacci:

>>> # a soma de dois elementos define a próxima
(continua na pró xima pá gina)

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

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> a, b = 0, 1
>>> while a < 10:
... print(a)
... a, b = b, a+b
...
0
1
1
2
3
5
8

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.
• A funçã o print() escreve o valor dos argumentos fornecidos. É diferente de apenas escrever a expressã o no
interpretador (como fizemos anteriormente nos exemplos da calculadora) pela forma como lida com mú ltiplos
argumentos, quantidades de ponto flutuante e strings. As strings sã o impressas sem aspas, e um espaço é
inserido entre os itens, assim você pode formatar bem o resultado, dessa forma:

>>> i = 256*256
>>> print('O valor de i é', i)
O valor de i é 65536

O argumento nomeado 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.13.0

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 Instruções if
Provavelmente a mais conhecida instruçã o de controle de fluxo é o if. Por exemplo:

>>> x = int(input("Insira um número inteiro: "))

Insira um número inteiro: 42
>>> if x < 0:
... x = 0
... print('Negativo alterado para zero')
... elif x == 0:
... print('Zero')
... elif x == 1:
... print('Um')
... else:
... print('Mais')
...
Mais

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 as instruçõ es 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.

4.2 Instruções for

A instruçã o 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), a instruçã o 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:

19
Python Tutorial, Release 3.13.0

>>> # Mede algumas strings:

>>> palavras = ['gato', 'janela', 'defenestrar']
>>> for p in palavras:
... print(p, len(p))
...
gato 4
janela 6
defenestrar 11

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:

# Cria uma amostra de coleção

users = {'Hans': 'active', 'Éléonore': 'inactive', ' ': 'active'}

# Estratégia: iterar por uma cópia

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

# Estratégia: criar uma nova coleção

active_users = {}
for user, status in users.items():
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]

Para iterar sobre os índices de uma sequê ncia, combine range() e len() da seguinte forma:

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

 Python Tutorial, Release 3.13.0

>>> a = ['Maria', 'tinha', 'um', 'carneirinho']

>>> for i in range(len(a)):
... print(i, a[i])
...
0 Maria
1 tinha
2 um
3 carneirinho

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 a instruçã o 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 Instruções break e continue

A instruçã o break sai imediatamente do laço de repetiçã o mais interno, seja for ou while:

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

... for x in range(2, n):
... if n % x == 0:
... print(f"{n} igual a {x} * {n//x}")
... break
...
4 igual a 2 * 2
6 igual a 2 * 3
8 igual a 2 * 4
9 equals 3 * 3

A instruçã o continue continua com a pró xima iteraçã o do laço:

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

... if num % 2 == 0:
... print(f"Encontrado um número par {num}")
... continue
... print(f"Encontrado um número ímpar {num}")
...
Encontrado um número par 2
Encontrado um número ímpar 3
Encontrado um número par 4
Encontrado um número ímpar 5
Encontrado um número par 6
(continua na pró xima pá gina)

4.4. Instruções break e continue 21

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

Encontrado um número ímpar 7
Encontrado um número par 8
Encontrado um número ímpar 9

4.5 Cláusulas else em laços

Em um laço for ou while a instruçã o break pode ser pareada com uma clá usula else. Se o laço terminar sem
executar o break, a clá usula else será executada.
Em um laço for, a clá usula else é executada apó s o laço finalizar sua iteraçã o final, ou seja, se nã o ocorrer nenhuma
interrupçã o.
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 foi encerrado por um break. Claro, outras
maneiras de encerrar o laço mais cedo, como um return ou uma exceçã o levantada, també m pularã o a execuçã o
da clá usula else.
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, 'igual a', x, '*', n//x)
... break
... else:
... # a iteração passou direto sem encontrar um fator
... print(n, 'é um número primo')
...
2 é um número primo
3 é um número primo
4 igual a 2 * 2
5 é um número primo
6 igual a 2 * 3
7 é um número primo
8 igual a 2 * 4
9 igual a 3 * 3

(Sim, este é o có digo correto. Observe atentamente: a clá usula else pertence ao laço for, não à instruçã o if.)
Uma maneira de pensar na clá usula else é imaginá -la pareada com o if dentro do laço. Conforme o laço é executado,
ele executará uma sequê ncia como if/if/if/else. O if está dentro do laço, encontrado vá rias vezes. Se a condiçã o for
verdadeira, um break acontecerá . Se a condiçã o nunca for verdadeira, a clá usula else fora do laçoserá executada.
Quando usado em um laço, a clá usula else tem mais em comum com a clá usula else de uma instruçã o try do que
com a de instruçõ es if: a clá usula else de uma instruçã o try é executada quando nã o ocorre exceçã o, e a clá usula
else de um laço é executada quando nã o ocorre um break. Para mais informaçõ es sobre instruçã o try e exceçõ es,
veja Tratamento de exceções.

4.6 Instruções pass

A instruçã o pass nã o faz nada. Pode ser usada quando a sintaxe exige uma instruçã o, mas a semâ ntica do programa
nã o requer nenhuma açã o. Por exemplo:

>>> while True:

... pass # Ocupado, aguardando interrupção por teclado (Ctrl+C)
...

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

 Python Tutorial, Release 3.13.0

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

>>> class MinhaClasseVazia:

... 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 # Lembre-se de implementar isso!
...

4.7 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 "Não permitido"

Os padrõ es podem se parecer com atribuiçõ es de desempacotamento e podem ser usados para vincular variá veis:

# ponto é uma tupla (x, y)

match ponto:
case (0, 0):
print("Origem")
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("Não é um ponto")

4.7. Instruções match 23

Python Tutorial, Release 3.13.0

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 (ponto). O quarto padrã o captura dois valores, o que o torna conceitualmente semelhante à atribuiçã o
de desempacotamento (x, y) = ponto.
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 Ponto:
def __init__(self, x, y):
self.x = x
self.y = y

def onde_está(ponto):
match ponto:
case Ponto(x=0, y=0):
print("Origem")
case Ponto(x=0, y=y):
print(f"Y={y}")
case Ponto(x=x, y=0):
print(f"X={x}")
case Ponto():
print("Em outro lugar")
case _:
print("Não é um ponto")

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 vinculam o atributo y à variá vel var):

Ponto(1, var)
Ponto(1, y=var)
Ponto(x=1, y=var)
Ponto(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 foo.bar), nomes de
atributos (o x= e y= acima) ou nomes de classes (reconhecidos pelo “(…)” pró ximo a eles, como Ponto 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 Ponto:
__match_args__ = ('x', 'y')
def __init__(self, x, y):
self.x = x
self.y = y

match pontos:
case []:
print("Sem pontos")
case [Ponto(0, 0)]:
print("A origem")
case [Ponto(x, y)]:
print(f"Ponto único {x}, {y}")
case [Ponto(0, y1), Ponto(0, y2)]:
(continua na pró xima pá gina)

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

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

print(f"Dois do eixo Y em {y1}, {y2}")
case _:
print("Outra coisa")

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 ponto:
case Ponto(x, y) if x == y:
print(f"Y=X at {x}")
case Ponto(x, y):
print(f"Não está na 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, *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 de-
sempacotamento como **rest també m é permitido. (Mas **_ seria redundante, entã o nã o é permitido.)
• Subpadrõ es podem ser capturados usando a palavra reservada as:

case (Ponto(x1, y1), Ponto(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 Cor(Enum):
VERMELHO = 'vermelho'
VERDE = 'verde'
AZUL = 'azul'

cor = Cor(input("Insira sua escolha de 'vermelho, 'azul' ou 'verde': "))

match color:
case Cor.VERMELHO:
print("Eu vejo vermelho!")
case Cor.VERDE:
print("Grama é verde")
case Cor.AZUL:
print("O céu é azul :)")

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

4.7. Instruções match 25

Python Tutorial, Release 3.13.0

4.8 Definindo funções

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

>>> def fib(n): # escreve série de Fibonacci menor que n

... """Imprime uma série de Fibonacci menor que n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Agora chamamos a função que acabamos de definir:
>>> 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. As instruçõ es 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,
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. Embora
possam ser referenciadas, variá veis globais e de funçõ es externas nã o podem ter atribuiçõ es (a menos que seja utilizada
a instruçã o 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 a instruçã o 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:
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.13.0

>>> def fib2(n): # retorna série de Fibonacci até n

... """Retorna uma lista contendo a série de Fibonacci até n."""
... resultado = []
... a, b = 0, 1
... while a < n:
... resultado.append(a) # veja abaixo
... a, b = b, a+b
... return resultado
...
>>> f100 = fib2(100) # chama-o
>>> f100 # escreve o resultado
[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 result.append(a) chama um método do objeto lista result. Um mé todo é uma funçã o que
‘pertence’ a um objeto, e é chamada obj.nomemetodo, onde obj é um objeto qualquer (pode ser uma expres-
sã o), e nomemetodo é o nome de um mé todo que foi definido pelo tipo do objeto. Tipos diferentes 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.

4.9 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.9.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 pergunta_ok(mensagem, tentativas=4, lembrete='Por favor, tente novamente!'):

while True:
resposta = input(mensagem)
if resposta in {'s', 'sim', 'é}:
return True
if resposta in {'n', 'não', 'nah'}:
return False
tentativas = tentativas - 1
if tentativas < 0:
raise ValueError('resposta inválida de usuário')
print(lembrete)

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.

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

Python Tutorial, Release 3.13.0

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=[]):

L.append(a)
return L

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

Isso exibirá :

[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 = []
L.append(a)
return L

4.9.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 papagaio(voltagem, estado='é um cadáver', ação='voar', tipo='Azul Norueguês'):

print("-- Este papagaio não conseguiria", ação, end=' ')
print("nem se você desse um choque de", voltagem, "de volts nele.")
print("-- Plumagem formosa, o", tipo)
print("-- Ele", estado, "!")

aceita um argumento obrigató rio (voltagem) e trê s argumentos opcionais (estado, ação, e tipo). Esta funçã o
pode ser chamada de qualquer uma dessas formas:

papagaio(1000) # 1 argumento posicional

papagaio(voltagem=1000) # 1 argumento nomeado
papagaio(voltagem=1000000, ação='fazer VOOOOOM') # 2 argumentos nomeados
papagaio(ação='fazer VOOOOOM', voltagem=1000000) # 2 argumentos nomeados
papagaio('um milhão', 'sem vida', 'pular') # 3 argumentos posicionais
papagaio('mil', estado='estaria no céu') # 1 posicional, 1 argumento

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

 Python Tutorial, Release 3.13.0

mas todas as formas a seguir seriam invá lidas:

papagaio() # faltando argumento obrigatório

papagaio(voltagem=5.0, 'morto') # argumento não nomeado após um argumento nomeado
papagaio(110, voltagem=220) # valor duplicado para o mesmo argumento
papagaio(ator='John Cleese') # argumento nomeado desconhecido

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

>>> def função(a):

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

Quando um ú ltimo parâ metro formal no formato **nome está presente, ele recebe um dicioná rio (veja typesmapping)
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:

def loja_de_queijos(tipo, *argumentos, **argumentos_nomeados):

print("-- Você tem algum", tipo, "?")
print("-- Lamento, acabou o", tipo)
for arg in argumentos:
print(arg)
print("-" * 40)
for kw in argumentos_nomeados:
print(kw, ":", argumentos_nomeados[kw])

Pode ser chamada assim:

loja_de_queijos("Limburger", "Está muito mole, senhor",

"Está realmente muito, MUITO mole, senhor.",
vendedor="Michael Palin",
cliente="John Cleese",
sketch="Sketch da Loja de Queijos")

e, claro, exibiria:

-- Você tem algum Limburger ?

-- Lamento, acabou o Limburger
Está muito mole, senhor.
Está realmente muito, MUITO mole, senhor.
----------------------------------------
vendedor : Michael Palin
cliente : 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.9. Mais sobre definição de funções 29

Python Tutorial, Release 3.13.0

4.9.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_ou_kwd, *, kwd1, kwd2):

----------- ---------- ----------
| | |
| Posicional ou nomeado |
| - Somente nomeado
-- Somente posicional

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.

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 arg_padrão(arg):

... print(arg)
...
>>> def arg_somente_pos(arg, /):
... print(arg)
...
>>> def arg_somente_nom(*, arg):
... print(arg)
...
>>> def exemplo_combinado(somente_pos, /, padrão, *, somente_nom):
... print(somente_pos, padrão, somente_nom)

A definiçã o da primeira funçã o, arg_padrão, 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:

>>> arg_padrão(2)
2
(continua na pró xima pá gina)

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

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> arg_padrão(arg=2)
2

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

>>> arg_somente_pos(1)
1

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

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

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

>>> arg_somente_nom(arg=3)
3

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

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

>>> exemplo_combinado(1, 2, somente_nom=3)

1 2 3

>>> exemplo_combinado(1, padrão=2, somente_nom=3)

1 2 3

>>> exemplo_combinado(somente_pos=1, padrão=2, somente_nom=3)

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

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

def foo(nome, **kwds):

return 'nome' in kwds

Nã o é possível essa chamada devolver True, uma vez que o argumento nomeado 'nome' sempre será aplicado para
o primeiro parâ metro. Por exemplo:

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

Traceback (most recent call last):
(continua na pró xima pá gina)

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

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'nome'
>>>

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

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

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

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

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

def f(pos1, pos2, /, pos_ou_nom *, nom1, nom2):

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.9.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 escreve_vários_itens(arquivo, separador, *args):

file.write(separador.join(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 sep.join(args)
...
>>> concat("terra", "marte", "vênus")
'terra/marte/vênus'
>>> concat("terra", "marte", "vênus", sep=".")
'terra.marte.vênus'

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

 Python Tutorial, Release 3.13.0

4.9.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)) # chamada normal com argumentos separados

[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args)) # chamada com argumentos desempacotados a partir␣
,→de uma lista

[3, 4, 5]

Da mesma forma, dicioná rios podem produzir argumentos nomeados com o operador **:

>>> def papagaio(voltagem, estado='um cadáver', ação='voar'):

... print("-- Este papagaio não conseguiria", ação, end=' ')
... print("nem se você desse um choque de", voltagem, "de volts nele.", end='
,→')

... print("Ele", estado, "!")

...
>>> d = {"voltagem": "quatro milhões", "estado": "está realmente morto", "ação":
,→"voar"}

>>> papagaio(**d)
-- Este papagaio não conseguiria voar nem se você desse um choque de quatro␣
,→milhões de volts nele. Ele está realmente morto !

4.9.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 forem ne-
cessá 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 cria_incrementador(n):

... return lambda x: x + n
...
>>> f = cria_incrementador(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, 'um'), (2, 'dois'), (3, 'três), (4, 'quatro')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'quatro'), (1, 'um'), (3, 'três'), (2, 'dois')]

4.9.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.

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

Python Tutorial, Release 3.13.0

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:

>>> def minha_função():

... """Faz nada, mas documenta-a.
...
... Não, é sério, ela faz nada mesmo.
... """
... pass
...
>>> print(minha_função.__doc__)
Faz nada, mas documenta-a.

Não, é sério, ela faz nada mesmo.

4.9.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, ovos: str = 'ovos') -> str:

... print("Anotações:", f.__annotations__)
... print("Argumentos:", ham, ovos)
... return ham + ' e ' + ovos
...
>>> f('spam')
Anotações: {'ham': <class 'str'>, 'return': <class 'str'>, 'ovos': <class 'str'>}
Argumentos: spam ovos
'spam e ovos'

4.10 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

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

 Python Tutorial, Release 3.13.0

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.
• 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.10. Intermezzo: estilo de codificação 35

Python Tutorial, Release 3.13.0

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:
list.append(x)
Adiciona um item ao fim da lista. Similar a a[len(a):] = [x].
list.extend(iterable)
Estende a lista, adicionando no fim todos os elementos do argumento iterá vel passado como parâ metro. Similar
a a[len(a):] = iterable.
list.insert(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 a.insert(0, x) insere um elemento na frente da lista e a.insert(len(a), x) e
equivale a a.append(x).
list.remove(x)
Remove o primeiro item encontrado na lista cujo valor é igual a x. Se nã o existir valor igual, uma exceçã o
ValueError é levantada.

[]
list.pop( i )
Remove o item na posiçã o fornecida na lista e retorna. Se nenhum índice for especificado, a.pop() 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.
list.clear()
Remove todos os itens de uma lista. Similar a del a[:].
[ [
list.index(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.13.0

list.count(x)
Devolve o nú mero de vezes em que x aparece na lista.
list.sort(*, 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).

list.reverse()
Inverte a ordem dos elementos na lista.
list.copy()
Devolve uma có pia rasa da lista. Similar a a[:].
Um exemplo que usa a maior parte dos mé todos das listas:

>>> frutas = ['laranja', 'maçã', 'pera', 'banana', 'kiwi', 'maçã', 'banana']

>>> frutas.count('maçã')
2
>>> frutas.count('tangerina')
0
>>> frutas.index('banana')
3
>>> frutas.index('banana', 4) # Encontra a próxima banana iniciando da posição 4
6
>>> frutas.reverse()
>>> frutas
['banana', 'maçã', 'kiwi', 'banana', 'pera', 'maçã', 'laranja']
>>> frutas.append('uva')
>>> frutas
['banana', 'maçã', 'kiwi', 'banana', 'pera', 'maçã', 'laranja', 'uva']
>>> frutas.sort()
>>> frutas
['maçã', 'maçã', 'banana', 'banana', 'uva', 'kiwi', 'laranja', 'pera']
>>> frutas.pop()
'pera'

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:

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

>>> pilha.append(6)
>>> pilha.append(7)
>>> pilha
[3, 4, 5, 6, 7]
>>> pilha.pop()
(continua na pró xima pá gina)
1 Outras 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.13.0

(continuaçã o da pá gina anterior)

7
>>> pilha
[3, 4, 5, 6]
>>> pilha.pop()
6
>>> pilha.pop()
5
>>> pilha
[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 collections.deque que foi projetada para permitir appends e pops efi-
cientes nas duas extremidades. Por exemplo:

>>> from collections import deque

>>> fila = deque(["Erik", "João", "Miguel"])
>>> fila.append("Tiago") # Tiago chega
>>> fila.append("George") # George chega
>>> fila.popleft() # O primeiro a chegar agora sai
'Erik'
>>> fila.popleft() # O segundo a chegar agora sai
'João'
>>> fila # A fila restante na ordem de chegada
deque(['Miguel', 'Tiago', 'George'])

5.1.3 Compreensões de lista

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:

>>> quadrados = []
>>> for x in range(10):
... quadrados.append(x**2)
...
>>> quadrados
[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:

quadrados = list(map(lambda x: x**2, range(10)))

ou, de maneira equivalente:

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

que é mais conciso e legível.

5.1. Mais sobre listas 39

Python Tutorial, Release 3.13.0

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
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:

>>> combos = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combos.append((x, y))
...
>>> combos
[(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]

>>> # cria uma nova lista com os valores dobrados
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filtra a lista para excluir números negativos
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # aplica uma função para todos os elementos
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # chama um método em cada elemento
>>> frutafresca = [' banana', ' baga-de-logan ', 'maracujá ']
>>> [arma.strip() for arma in frutafresca]
['banana', 'baga-de-logan', 'maracujá']
>>> # cria uma lista de tuplas de 2 elementos como (número, quadrado)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # a tupla deve estar entre parênteses, do contrário um erro é levantado
>>> [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?
>>> # achatamento de uma lista usando uma compreensão de lista com dois '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.13.0

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:

>>> matriz = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]

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

>>> [[linha[i] for linha in matriz] 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:

>>> transposta = []
>>> for i in range(4):
... transposta.append([row[i] for linha in matriz])
...
>>> transposta
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

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

>>> transposta = []
>>> for i in range(4):
... # as 3 linhas a seguir implementam uma compreensão de lista aninhada
... linha_transposta = []
... for linha in matriz:
... linha_transposta.append(linha[i])
... transposta.append(linha_transposta)
...
>>> transposta
[[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(*matriz))
[(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]
(continua na pró xima pá gina)

5.2. A instrução del 41

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> del a[2:4]
>>> 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, 'olá!'
>>> t[0]
12345
>>> t
(12345, 54321, 'olá!')
>>> # Tuplas pode ser aninhadas:
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'olá!'), (1, 2, 3, 4, 5))
>>> # Tuplas são imutáveis:
>>> t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # mas elas podem conter objetos mutáveis:
>>> 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:
>>> vazio = ()
>>> singleton = 'olá', # <!- note a linha ao final vazia >>> len(vazio)
(continua na pró xima pá gina)

42 Capítulo 5. Estruturas de dados

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

0
>>> len(singleton)
1
>>> singleton
('olá',)

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:

>>> cesta = {'maçã', 'laranja', 'maçã', 'pera', 'laranja', 'banana'}

>>> print(cesta) # mostra que itens duplicados foram␣
,→removidos

{'laranja', 'banana', 'pera', 'maçã'}

>>> 'laranja' in cesta # teste de pertinência rápido
True
>>> 'crabgrass' in cesta
False

>>> # Demonstra operações de conjunto em letras únicas de duas palavras

>>>
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # letras únicas em a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letras em a, mas não em b
{'r', 'd', 'b'}
>>> a | b # letras em a ou em b ou ambos
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letras em ambos a e b
{'a', 'c'}
>>> a ^ b # letras em a ou b, mas não em ambos
{'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.13.0

5.5 Dicionários
Outra estrutura de dados muito ú til embutida em Python é o dicionário, cujo tipo é dict (ver typesmapping). Dici-
oná 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.13.0

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().

>>> cavaleiros = {'gallahad': 'o puro', 'robin': 'o bravo'}

>>> for k, v in cavaleiros.items():
... print(k, v)
...
gallahad o puro
robin o bravo

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(['jogo', 'da', 'velha']):

... print(i, v)
...
0 jogo
1 da
2 velha

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

>>> perguntas = ['Nome', 'Missão', 'Cor favorita']

>>> respostas = ['Lancelot', 'o santo graal', 'azul']
>>> for q, a in zip(perguntas, respostas):
... print('{0}? É {1}.'.format(q, a))
...
Nome? É Lancelot.
Missão? É o santo graal.
Cor favorita? É azul.

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.

>>> cesta = ['maçã', 'laranja', 'maçã', 'pera', 'laranja', 'banana']

>>> for i in sorted(cesta):
... print(i)
...
maçã
maçã
banana
laranja
laranja
pera

Usar set() em uma sequê ncia elimina elementos duplicados. O uso de sorted() em combinaçã o com set()

5.6. Técnicas de iteração 45

Python Tutorial, Release 3.13.0

sobre uma sequê ncia é uma maneira idiomá tica de fazer um loop sobre elementos exclusivos da sequê ncia na ordem
de classificaçã o.

>>> cesta = ['maçã', 'laranja', 'maçã', 'pera', 'laranja', 'banana']

>>> for i in sorted(cesta):
... print(i)
...
maçã
maçã
banana
laranja
laranja
pera

À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

>>> dados_brutos = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> dados_filtrados = []
>>> for valor in dados_brutos:
... if not math.isnan(value):
... dados_filtrados.append(valor)
...
>>> dados_filtrados
[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 prioridade
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'

46 Capítulo 5. Estruturas de dados

 Python Tutorial, Release 3.13.0

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.

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.13.0

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 fibo.py no diretó rio
atual com o seguinte conteú do:

# Módulo de números de Fibonacci

def fib(n): # escreve a série de Fibonacci até n

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

def fib2(n): # retorna a série de Fibonacci até n

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

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

>>> import fibo

49
Python Tutorial, Release 3.13.0

Isso nã o adiciona os nomes das funçõ es definidas em fibo diretamente ao espaço de nomes atual (veja Escopos e
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:

>>> fibo.fib(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 = fibo.fib

>>> 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,
nomemodulo.nomeitem.

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 importado.
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.13.0

>>> import fibo as fib

>>> fib.fib(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
importlib.reload(), e.g. import importlib; importlib.reload(modulename).

6.1.1 Executando módulos como scripts

Quando você rodar um mó dulo Python com

python fibo.py <argumentos>

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(sys.argv[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 fibo.py 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
spam.py em uma lista de diretó rios incluídos na variá vel sys.path. A sys.path é 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).
• O padrã o dependente da instalaçã o (por convençã o, incluindo um diretó rio site-packages, tratado pelo
mó dulo site).

6.1. Mais sobre módulos 51

Python Tutorial, Release 3.13.0

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 sys.path. 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 modulo.versão.pyc, onde a versã o corresponde ao formato do arquivo compilado;
geralmente contê m o nú mero da versã o Python utilizada. Por exemplo, no CPython release 3.3 a versã o compilada
de spam.py será guardada como __pycache__/spam.cpython-33.pyc. Esta convençã o de nomes 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.

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
'>>> '
(continua na pró xima pá gina)

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

(continuaçã o da pá gina anterior)

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

Essas variá veis só estã o definidas se o interpretador está em modo interativo.
A variá vel sys.path 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

>>> sys.path.append('/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',
'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 = fibo.fib
>>> dir()
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']

Observe que ela lista todo tipo de nomes: variá veis, mó dulos, funçõ es, etc.

6.3. A função dir() 53

Python Tutorial, Release 3.13.0

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
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/ pacote de nível superior

__init__.py Inicializa o pacote de som
formats/ Subpacote para as conversões entre formatos de␣
,→arquivos

__init__.py
wavread.py
wavwrite.py
(continua na pró xima pá gina)

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

(continuaçã o da pá gina anterior)

aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
effects/ Subpacote para efeitos de som
__init__.py
echo.py
surround.py
reverse.py
...
filters/ Subpacote para filtros
__init__.py
equalizer.py
vocoder.py
karaoke.py
...

Ao importar esse pacote, Python busca pelo subdiretó rio com mesmo nome, nos diretó rios listados em sys.path.
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 sound.effects.echo

Isso carrega o submó dulo sound.effects.echo. Ele deve ser referenciado com seu nome completo, como em:

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

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

from sound.effects import echo

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

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

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

from sound.effects.echo 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
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 item.subitem.subsubitem, cada item, com exceçã o do ú l-
timo, 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. Pacotes 55
Python Tutorial, Release 3.13.0

6.4.1 Importando * de um pacote

Agora, o que acontece quando um usuá rio escreve from sound.effects 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 con-
vençã 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 sound.effects import * importaria os trê s submó dulos nomeados do pacote
sound.effects.
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 sound.effects
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", # refere-se ao arquivo 'echo.py'
"surround", # refere-se ao arquivo 'surround.py'
"reverse", # !!! refere-se à função 'reverse' agora !!!
]

def reverse(msg: str): # <-- este nome ofusca o submódulo 'reverse.py'

return msg[::-1] # no caso de uma importação 'from sound.effects import␣
,→*'

Se __all__ nã o estiver definido, a instruçã o from sound.effects import * nã o importa todos os submó dulos
do pacote sound.effects no espaço de nomes atual. Há apenas garantia que o pacote sound.effects foi im-
portado (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 impor-
tado 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 sound.effects.echo
import sound.effects.surround
from sound.effects 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 sound.effects. (Isso també m funciona
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.13.0

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 sound.filters.vocoder precisa usar o
mó dulo echo do pacote sound.effects, é preciso importá -lo com from sound.effects 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 sequência de strings 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.13.0

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 sys.stdout.
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.

>>> ano = 2016

>>> evento = 'Referendo'
>>> f'Resultados do {evento} {ano}'
'Resultados do Referendo 2016'

• O mé todo de strings str.format() requer mais esforço manual. Ainda será necessá rio usar { e } para marcar
onde a variá vel será substituída e pode-se incluir diretivas de formataçã o detalhadas, mas també m precisará
incluir a informaçã o a ser formatada. No bloco de có digo a seguir há dois exemplos de como formatar variá veis:

>>> votos_sim = 42_572_654

>>> votos_totais = 85_705_149
>>> porcentagem = votos_sim / votos_totais
>>> '{:-9} votos SIM {:2.2%}'.format(votos_sim, porcentagem)
' 42572654 votos SIM 49.67%'

Observe como yes_votes sã o preenchidos com espaços e um sinal negativo apenas para nú meros negativos.
O exemplo també m imprime percentage multiplicado por 100, com 2 casas decimais e seguido por um sinal
de porcentagem (veja formatspec para detalhes).
• 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
operaçõ es ú teis para preenchimento de strings para uma determinada largura de coluna.

59
Python Tutorial, Release 3.13.0

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 dicioná rios, tê m
a mesma representaçã o usando quaisquer das funçõ es. Strings, em particular, tê m duas representaçõ es distintas.
Alguns exemplos:

>>> s = 'Olá, mundo.'

>>> str(s)
'Olá, mundo.'
>>> repr(s)
"'Olá, mundo.'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'O valor de x é ' + repr(x) + ' e de y é ' + repr(y) + '...'
>>> print(s)
O valor de x é 32.5 e de y é 40000...
>>> # A repr() da string adiciona aspas e contrabarras:
>>> olá = 'olá, mundo\n'
>>> olás = repr(olá)
>>> print(olás)
'olá, mundo\n'
>>> # O argumento de repr() pode ser qualquer objeto Python:
>>> repr((x, y, ('spam', 'ovos')))
"(32.5, 40000, ('spam', 'ovos'))"

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 controle
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'O valor de pi é aproximadamente {math.pi:.3f}.')
O valor de pi é aproximadamente 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.

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

>>> for nome, telefone in tabela.items():
... print(f'{n9me:10} ==> {telefone:10d}')
...
Sjoerd ==> 4127
Jack ==> 4098
Dcab ==> 7678

60 Capítulo 7. Entrada e Saída

 Python Tutorial, Release 3.13.0

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()

>>> animais = 'enguias'

>>> print(f'Meu hovercraft está cheio de {animais}.')
Meu hovercraft está cheio de enguias.
>>> print(f'Meu hovercraft está cheio de {animais!r}.')
Meu hovercraft está cheio de 'enguias'.

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 str.format() tem esta forma:

>>> print('Nós somos os {} que dizem "{}!"'.format('cavaleiros', 'Ni'))

Nós somos os cavaleiros que dizem "Ni!"

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

>>> print('{0} e {1}'.format('spam', 'ovos'))

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

Se argumentos nomeados sã o passados para o mé todo str.format(), seus valores serã o referenciados usando o
nome do argumento:

>>> print('Este {comida} está {adjetivo}.'.format(

... comida='spam', adjetivo='absolutamente horrível'))
Este spam está absolutamente horrível.

Argumentos posicionais e nomeados podem ser combinados à vontade:

>>> print('A história de {0}, {1} e {outro}.'.format('Bill', 'Manfred',

... outro='Georg'))
A história de Bill, Manfred e 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.

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

>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
... 'Dcab: {0[Dcab]:d}'.format(tabela))
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.13.0

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

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

Isto é particularmente ú til em conjunto com a funçã o embutida vars(), que devolve um dicioná rio contendo todas
as variá veis locais:

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

>>> mensagem = " ".join([f'{k}: ' + '{' + k +'};' for k in tabela.keys()])
>>> print(mensagem.format(**tabela))
__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 str.format(), 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=' ')
... # Observe o uso do 'end' na linha anterior
... 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 str.rjust() justifica uma string à direita, num campo de tamanho definido, acrescentando espaços à
esquerda. De forma similar, os mé todos str.ljust(), justifica à esquerda, e str.center(), 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,

62 Capítulo 7. Entrada e Saída

 Python Tutorial, Release 3.13.0

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 x.ljust(n)[:n].)
Existe ainda o mé todo str.zfill() 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

O operador % (mó dulo) també m pode ser usado para formataçã o de string. Dado formato % valores (onde
formato é uma string), as instâ ncias de % em formato serã o substituídas por zero ou mais elementos de valores.
Essa operaçã o é conhecida como interpolaçã o de string. Por exemplo:

>>> import math

>>> print('O valor de pi é aproximadamente %5.3f.' % math.pi)
O valor de pi é aproximadamente 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('arquivo_de_trabalho', '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('arquivo_de_trabalho', encoding="utf-8") as f:

... read_data = f.read()

>>> # Podemos verificar se o arquivo foi fechado automaticamente.

(continua na pró xima pá gina)

7.2. Leitura e escrita de arquivos 63

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> f.closed
True

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

Á Aviso

Chamar f.write() sem usar a palavra reservada with ou chamar f.close() pode resultar nos argumentos
de f.write() 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 f.close(), as tentativas de usar o
arquivo falharã o automaticamente.

>>> f.close()
>>> f.read()
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 f.read(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, f.read() devolve uma
string vazia ('').

>>> f.read()
'Este é o arquivo inteiro.\n'
>>> f.read()
''

O mé todo f.readline() 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 f.readline() 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.

>>> f.readline()
'Está é a primeira linha do arquivo.\n'
>>> f.readline()
'Segunda linha do arquivo\n'
>>> f.readline()
''

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='')
...
Esta é a primeira linha do arquivo.
Segunda linha do arquivo

64 Capítulo 7. Entrada e Saída

 Python Tutorial, Release 3.13.0

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

>>> f.write('Este é um teste\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 = ('a resposta', 42)

>>> s = str(value) # converte a tupla para string
>>> f.write(s)
18

f.tell() 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 f.seek(offset, de_onde). A nova posiçã o é computada pela soma do deslocamento
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('arquivo_de_trabalho', 'rb+')

>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5) # Vai até o 6º byte no arquivo
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # Vai até o 3º byte antes do fim
13
>>> f.read(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 à f.tell(), 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 represen-
taçõ 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.

7.2. Leitura e escrita de arquivos 65

Python Tutorial, Release 3.13.0

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

>>> import json

>>> x = [1, 'lista', 'simples']
>>> json.dumps(x)
'[1, "lista", "simples"]'

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:

json.dump(x, f)

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

x = json.load(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('Olá mundo')

File "<stdin>", line 1
while True print('Olá mundo')
^^^^^
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>
10 * (1/0)
~^~
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
(continua na pró xima pá gina)

67
Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

File "<stdin>", line 1, in <module>
4 + spam*3
^^^^
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
'2' + 2
~~~~^~~
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("Insira um número: "))
... break
... except ValueError:
... print("Ops! Esse não é um número válido. Tente novamente...")
...

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 ) é execu-
tada.
• 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:

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

 Python Tutorial, Release 3.13.0

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

... pass

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', 'ovos')
... except Exception as inst:
... print(type(inst)) # o tipo da exceção
... print(inst.args) # argumentos armazenados em .args
... print(inst) # __str__ permite imprimir args diretamente,
... # mas pode ser substituído em subclasses de exceção
... x, y = inst.args # desempacota args
... print('x =', x)
... print('y =', y)
...
<class 'Exception'>
('spam', 'ovos')
('spam', 'ovos')
x = spam
y = ovos

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.

8.3. Tratamento de exceções 69

Python Tutorial, Release 3.13.0

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 inespe-
radas 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):

import sys

try:
f = open('meuarquivo.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
print("Erro de E/S:", err)
except ValueError:
print("Não foi possível converter dados para um inteiro.")
except Exception as err:
print(f"Não esperava {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 sys.argv[1:]:

try:
f = open(arg, 'r')
except OSError:
print('não foi possível abrir', arg)
else:
print(arg, 'tem', len(f.readlines()), 'linhas')
f.close()

É 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:
... isso_aqui_falha()
... except ZeroDivisionError as err:
... print('Tratando o erro de tempo execução:', err)
...
Tratando o erro de tempo execução: 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('Olá')

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
(continua na pró xima pá gina)

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

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

raise NameError('Olá')
NameError: Olá

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 # abreviação para 'raise ValueError()'

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('Olá')
... except NameError:
... print('Uma exceção passou por aqui!')
... raise
...
Uma exceção passou por aqui!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
raise NameError('Olá')
NameError: Olá

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("database.sqlite")
... except OSError:
... raise RuntimeError("unable to handle error")
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
open("database.sqlite")
~~~~^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):

File "<stdin>", line 4, in <module>
raise RuntimeError("unable to handle error")
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 deve ser uma instância de exceção ou None.

raise RuntimeError from exc

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

8.5. Encadeamento de exceções 71

Python Tutorial, Release 3.13.0

>>> 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>
func()
~~~~^^
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>
raise RuntimeError('Failed to open database') from exc
RuntimeError: Failed to open database

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

>>> try:
... open('bancodedados.sqlite')
... except OSError:
... raise RuntimeError from None
...
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
raise RuntimeError from None
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
(continua na pró xima pá gina)

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

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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

Se uma clá usula finally estiver presente, a clá usula finally será executada como a ú ltima tarefa antes da con-
clusã 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 levantadas
novamente.
• Se a instruçã o try atingir uma instruçã o break, continue ou return, a clá usula finally será executada
imediatamente antes da execuçã o da instruçã o break, continue ou return.
• 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 retorna_booleano():

... try:
... return True
... finally:
... return False
...
>>> retorna_booleano()
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
(continua na pró xima pá gina)

8.7. Definindo ações de limpeza 73

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
divide("2", "1")
~~~~~~^^^^^^^^^^
File "<stdin>", line 3, in divide
result = x / y
~~^~~
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 linha in open("meuarquivo.txt"):

print(linha, 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.

with open("meuarquivo.txt") as f:
for linha in f:
print(linha, 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('houve problemas', excs)
...
>>> f()
+ Exception Group Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| f()
| ~^^
(continua na pró xima pá gina)

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

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

| File "<stdin>", line 3, in f
| ExceptionGroup: houve problemas (2 sub-exceptions)
+-+---------------- 1 ----------------
| OSError: error 1
+---------------- 2 ----------------
| SystemError: error 2
+------------------------------------
>>> try:
... f()
... except Exception as e:
... print(f'capturada {type(e)}: e')
...
capturada <class 'ExceptionGroup'>: e
>>>

Usando except* em vez de except, podemos manipular seletivamente apenas as exceçõ es no grupo que corres-
pondem 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)
... ]
... )
... ]
... )
...
>>> try:
... f()
... except* OSError as e:
... print("Houve OSErrors")
... except* SystemError as e:
... print("Houve SystemErrors")
...
Houve OSErrors
Houve SystemErrors
+ Exception Group Traceback (most recent call last):
| File "<stdin>", line 2, in <module>
| f()
| ~^^
| File "<stdin>", line 2, in f
| raise ExceptionGroup(
| ...<12 lines>...
| )
| ExceptionGroup: group1
+-+---------------- 1 ----------------
| ExceptionGroup: group2
(continua na pró xima pá gina)

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

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

+-+---------------- 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:
... test.run()
... except Exception as e:
... excs.append(e)
...
>>> if excs:
... raise ExceptionGroup("Falhas no teste", 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('tipo inválido')
... except Exception as e:
... e.add_note('Adiciona algumas informações')
... e.add_note('Adiciona mais algumas informações')
... raise
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
raise TypeError('tipo inválido')
TypeError: tipo inválido
Adiciona algumas informações
Adiciona mais algumas informações
>>>

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.
>>> def f():
... raise OSError('operação falhou')
...
>>> excs = []
>>> for i in range(3):
... try:
... f()
... except Exception as e:
... e.add_note(f'Aconteceu na iteração {i+1}')
... excs.append(e)
...
(continua na pró xima pá gina)

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

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> raise ExceptionGroup('Nós temos alguns problemas', excs)
+ Exception Group Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| raise ExceptionGroup('Nós temos alguns problemas', excs)
| ExceptionGroup: Nós temos alguns problemas (3 sub-exceptions)
+-+---------------- 1 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 3, in <module>
| f()
| ~^^
| File "<stdin>", line 2, in f
| raise OSError('operação falhou')
| OSError: operação falhou
| Aconteceu na iteração 1
+---------------- 2 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 3, in <module>
| f()
| ~^^
| File "<stdin>", line 2, in f
| raise OSError('operação falhou')
| OSError: operação falhou
| Aconteceu na iteração 2
+---------------- 3 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 3, in <module>
| f()
| ~^^
| File "<stdin>", line 2, in f
| raise OSError('operação falhou')
| OSError: operação falhou
| Aconteceu na iteração 3
+------------------------------------
>>>

8.10. Enriquecendo exceções com notas 77

Python Tutorial, Release 3.13.0

78 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.)

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.

79
Python Tutorial, Release 3.13.0

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 z.real, por exemplo,
real é um atributo do objeto z. Estritamente falando, referê ncias para nomes em mó dulos sã o atributos: na expressã o
modname.funcname, 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 valor
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:
• 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).
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.

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

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 teste_de_escopo():
def faz_local():
spam = "spam local"

def faz_nonlocal():
nonlocal spam
spam = "spam não-local"

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

spam = "spam teste"

faz_local()
print("Após atribuição local:", spam)
faz_nonlocal()
print("Após atribuição não-local:", spam)
faz_global()
print("Após atribuição global:", spam)

teste_de_escopo()
print("No escopo global:", spam)

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

Após atribuição local: spam teste

Após atribuição não-local: spam não-local
Após atribuição global: spam não-local
No escopo global: spam global

Observe como uma atribuiçã o local (que é o padrã o) nã o altera o vínculo de teste_de_escopo a spam. A instruçã o
nonlocal mudou o vínculo de teste_de_escopo 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.2. Escopos e espaços de nomes do Python 81

Python Tutorial, Release 3.13.0

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 NomeClasse:
<instrução-1>
.
.
.
<instrução-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 (NomeClasse no exemplo).

9.3.2 Objetos classe

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:
obj.nome. 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 MinhaClasse:
"""Um exemplo de classe simples"""
i = 12345

def f(self):
return 'olá mundo'

entã o MinhaClasse.i e MinhaClasse.f sã o referê ncias a atributo vá lidas, retornando, respectivamente, um in-
teiro e um objeto funçã o. Atributos de classe podem receber valores, pode-se modificar o valor de MinhaClasse.i
num atribuiçã o. __doc__ també m é um atributo vá lido da classe, retornando a docstring associada à classe: "Um
exemplo de classe simples".

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 = MinhaClasse()

cria uma nova instância da classe e atribui o objeto resultante à variá vel local x.

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

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):
self.data = []

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 = MinhaClasse()

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 MinhaClasse criada acima, o pró ximo trecho de có digo
irá exibir o valor 16, sem deixar nenhum rastro:

x.contador = 1
while x.contador < 10:
x.contador = x.contador * 2
print(x.contador)
del x.contador

O outro tipo de referê ncia a um atributo de instâ ncia é um método. Um mé todo é uma funçã o que “pertence a” um
objeto.
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 MinhaClasse.f é uma funçã o, enquanto x.i nã o é , já que MinhaClasse.i nã o é uma funçã o. Entretanto,
x.f nã o é o mesmo que MinhaClasse.f. A referê ncia x.f acessa um objeto mé todo e a MinhaClasse.f acessa
um objeto funçã o.

9.3.4 Objetos método

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

x.f()

No exemplo MinhaClasse, o resultado da expressã o acima será a string "olá mundo". 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:

9.3. Uma primeira olhada nas classes 83

Python Tutorial, Release 3.13.0

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

exibirá o texto olá mundo 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 MinhaClasse.
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 Cachorro:

tipo = 'canino' # variável de classe compartilhada por todas as␣

,→ instâncias

def __init__(self, nome):

self.nome = nome # variável de instância única para cada instância

>>> d = Cachorro('Fido')
>>> e = Cachorro('Buddy')
>>> d.tipo # compartilhada por todos os cachorros
'canino'
>>> e.tipo # compartilhada por todos os cachorros
'canino'
>>> d.nome # exclusiva do d
'Fido'
>>> e.nome # exclusiva do 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 Cachorro:

class Cachorro:

truques = [] # uso incorreto de uma variável de classe

def __init__(self, nome):

self.nome = nome

def adicionar_truque(self, truque):

self.truques.append(truque)
(continua na pró xima pá gina)

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

(continuaçã o da pá gina anterior)

>>> d = Cachorro('Fido')
>>> e = Cachorro('Buddy')
>>> d.adicionar_truque('rolar')
>>> e.adicionar_truque('fingir de morto')
>>> d.truques # inesperadamente compartilhado por todos os cães
['rolar', 'fingir de morto']

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

class Cachorro:

def __init__(self, nome):

self.nome = nome
self.truques = [] # cria uma nova lista vazia para cada cachorro

def adicionar_truque(self, truque):

self.truques.append(truque)

>>> d = Cachorro('Fido')
>>> e = Cachorro('Buddy')
>>> d.adicionar_truque('rolar')
>>> e.adicionar_truque('fingir de morto')
>>> d.truques
['rolar']
>>> e.truques
['fingir de morto']

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 Armazém:

... propósito = 'armazenar'
... região = 'oeste'
...
>>> a1 = Armazém()
>>> print(a1.propósito, a1.região)
armazenar oeste
>>> a2 = Armazém()
>>> a2.região = 'leste'
>>> print(a2.propósito, a2.região)
armazenar leste

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.)
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

9.4. Observações aleatórias 85

Python Tutorial, Release 3.13.0

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:

# Função definida fora da classe

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

class C:
f = f1

def g(self):
return 'olá mundo'

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 Bolsa:
def __init__(self):
self.data = []

def adicionar(self, x):

self.data.append(x)

def adicionar_em_dobro(self, x):

self.adicionar(x)
self.adicionar(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__.

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 NomeClasseDerivada(NomeClasseBase):
<instrução-1>
(continua na pró xima pá gina)

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

(continuaçã o da pá gina anterior)

.
.
.
<instrução-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 NomeClasseDerivada(nomemódulo.NomeClasseBase):

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: NomeClasseDerivada() 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 BaseClassName.methodname(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 somente
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 NomeClasseDerivada(Base1, Base2, Base3):

<instrução-1>
.
.
.
<instrução-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
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.

9.5. Herança 87
Python Tutorial, Release 3.13.0

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

O especificaçõ es de desfiguraçã o de nome privado para detalhes e casos especiais.

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 Mapeamento:
def __init__(self, iterável):
self.lista_itens = []
self.__atualizar(iterável)

def atualizar(self, iterável):

for item in iterável:
self.lista_itens.append(item)

__atualizar = atualizar # cópia privada do método atualizar() original

class SubclasseMapeamento(Mapeamento):

def update(self, chaves, valores):

# fornece nova assinatura para atualizar(),
# mas não quebra __init__()
for item in zip(chaves, valores):
self.lista_itens.append(item)

O exemplo acima deve funcionar mesmo se SubclasseMapeamento introduzisse um identificador

__atualizar uma vez que é substituído por _Mapeamento__atualizar na classe Mapeamento e
_SubclasseMapeamento__atualizar na classe SubclasseMapeamento, 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.

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

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 é compi-
lado 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 Empregado:
nome: str
dept: str
salário: int

>>> joão = Empregado('joão', 'lab de computadores', 1000)

>>> joão.dept
'lab de computadores'
>>> joão.salário
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 elemento in [1, 2, 3]:

print(elemento)
for elemento in (1, 2, 3):
print(elemento)
for chave in {'um':1, 'dois':2}:
print(chave)
for char in "123":
print(char)
for linha in open("meuarquivo.txt"):
print(linha, end='')

Esse estilo de acesso é claro, conciso e conveniente. O uso de iteradores permeia e unifica o Python. Nos bastidores,
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, __next__() le-
vanta 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
(continua na pró xima pá gina)

9.7. Curiosidades e conclusões 89

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

<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 Inverter:
"""Iterador para fazer um laço em uma sequência de trás para frente."""
def __init__(self, dados):
self.dados = dados
self.índice = len(dados)

def __iter__(self):
return self

def __next__(self):
if self.índice == 0:
raise StopIteration
self.índice = self.índice - 1
return self.dados[self.índice]

>>> rev = Interverter('spam')

>>> iter(rev)
<__main__.Interverter 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 inverter(dados):
for índice in range(len(dados)-1, -1, -1):
yield dados[índice]

90 Capítulo 9. Classes
 Python Tutorial, Release 3.13.0

>>> for char in inverter('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 self.index e self.data.
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)) # soma dos quadrados

285

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

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

>>> palavras_únicas = set(palavra for linha página for palavra in linha.split())

>>> orador_da_turma = max((estudante.gpa, estudante.nome) for estudante in␣

,→graduados)

>>> dados = 'golf'

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

9.10. Expressões geradoras 91

Python Tutorial, Release 3.13.0

92 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
>>> os.getcwd() # Retorna o diretório de trabalho atual
'C:\\Python313'
>>> os.chdir('/server/accesslogs') # Altera o diretório de trabalho atual
>>> os.system('mkdir hoje') # Executa o comando mkdir no shell do sistema
0

Certifique-se de usar a forma import os ao invé s de from os import *. Isso evitará que os.open() 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)
<retorna uma lista de todas as funções do módulo>
>>> help(os)
<retorna uma página de manual extensa criada a partir das docstrings do módulo>

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

>>> shutil.copyfile('dados.db', 'arquivo.db')
'arquivo.db'
>>> shutil.move('/build/executáveis', 'dir_instal')
'dir_instal'

93
Python Tutorial, Release 3.13.0

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

>>> glob.glob('*.py')
['primos.py', 'aleatorizar.py', 'aspas.py']

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 demo.py a seguir:

# Arquivo demo.py
import sys
print(sys.argv)

Aqui está a saída da execuçã o python demo.py um dois três na linha de comando:

['demo.py', 'um', 'dois, 'três']

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 = argparse.ArgumentParser(
prog='topo',
description='Mostra as primeiras linhas de cada arquivo')
parser.add_argument('arquivos, nargs='+')
parser.add_argument('-l', '--linhas', type=int, default=10)
args = parser.parse_args()
print(args)

Quando executada na linha de comando python topo.py --linhas=5 alfa.txt beta.txt, o script define
args.linhas para 5 e args.arquivos para ['alfa.txt', 'beta.txt'].

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:

>>> sys.stderr.write('Aviso, arquivo log não encontrado, iniciando um novo\n')

Aviso, arquivo log não encontrado, iniciando um novo

A forma mais direta de encerrar um script é usando sys.exit().

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
>>> re.findall(r'\br[a-z]*', 'o rato roeu a roupa do rei de roma')
['rato', 'roeu', 'roupa', 'rei', 'roma']
(continua na pró xima pá gina)

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

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'o gato de de chapéu')
'o gato de chapéu'

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

>>> 'xá para dois'.replace('xá', 'chá')

'chá para dois'

10.6 Matemática
O mó dulo math oferece acesso à s funçõ es da biblioteca C para matemá tica de ponto flutuante:

>>> import math

>>> math.cos(math.pi / 4)
0.70710678118654757
>>> math.log(1024, 2)
10.0

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

>>> import random

>>> random.choice(['maçã', 'pera', 'banana'])
'maçã'
>>> random.sample(range(100), 10) # amostragem sem reposição
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random() # ponto flutuante aleatório do intervalo [0.0, 1.0)
0.17970987693706186
>>> random.randrange(6) # inteiro aleatório escolhido de 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

>>> dados = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]
>>> statistics.mean(dados)
1.6071428571428572
>>> statistics.median(dados)
1.25
>>> statistics.variance(dados)
1.3720238095238095

O projeto SciPy <https://scipy.org> tem muitos outros mó dulos para cá lculos numé ricos.

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 urllib.request import urlopen

>>> with urlopen('http://worldtimeapi.org/api/timezone/etc/UTC.txt') as response:
... for line in response:
... line = line.decode() # Converte bytes para str
... if line.startswith('datetime'):
... print(line.rstrip()) # Remove nova linha ao final
(continua na pró xima pá gina)

10.6. Matemática 95
Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

...
datetime: 2022-01-01T01:36:47.689215+00:00

>>> import smtplib

>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
... """To: jcaesar@example.org
... From: soothsayer@example.org
...
... Beware the Ides of March.
... """)
>>> server.quit()

(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 dis-
ponibilidade 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.

>>> # datas são facilmente construídas e formatadas

>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%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.'

>>> # datas têm suporte a matemática de calendário

>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
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'A vaca malhada foi molhada por outra vaca molhada e malhada.'
>>> len(s)
60
>>> t = zlib.compress(s)
>>> len(t)
47
>>> zlib.decompress(t)
b'A vaca malhada foi molhada por outra vaca molhada e malhada.'
>>> zlib.crc32(s)
2444551089

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

 Python Tutorial, Release 3.13.0

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 tradi-
cional 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):
"""Calcula a média aritmética da lista de números.

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

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

import doctest
doctest.testmod() # valida automaticamente os testes incorporados

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(unittest.TestCase):

def test_average(self):
self.assertEqual(average([20, 30, 70]), 40.0)
self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
with self.assertRaises(ZeroDivisionError):
average([])
with self.assertRaises(TypeError):
average(20, 30, 70)

unittest.main() # Chamar a partir da linha de comando invoca todos os testes

10.10. Medição de desempenho 97

Python Tutorial, Release 3.13.0

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 xmlrpc.client e xmlrpc.server 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, comu-
mente suportado por bancos de dados e planilhas. O processamento XML é fornecido pelos pacotes xml.
etree.ElementTree, xml.dom e xml.sax. 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.

98 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

>>> reprlib.repr(set('supercalifragilisticexpialidoce'))
"{'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 = [[[['preto', 'ciano'], 'branco', ['verde', 'vermelho']], [['magenta',
... 'amarelo'], 'azul']]]
>>>
>>> pprint.pprint(t, width=30)
[[[['preto', 'ciano'],
'branco',
['verde', 'vermelho']],
[['magenta', 'amarelo'],
'azul']]]

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

>>> import textwrap

>>> doc = """O método wrap() é como fill(), exceto que ele retorna
... uma lista de strings em vez de uma string grande com quebras
... de linha para separar as linhas quebradas."""
...
>>> print(textwrap.fill(doc, width=40))
(continua na pró xima pá gina)

99
Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

O método wrap() é como fill(), exceto
que ele retorna uma lista de strings em
vez de uma string grande com quebras de
linha para separar as linhas quebradas.

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

>>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')
'English_United States.1252'
>>> conv = locale.localeconv() # obtém mapeamento de convenções
>>> 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('O povo de ${vila} envia $$10 para $causa.')
>>> t.substitute(vila='Nottingham', causa='o fundo de recuperação')
'O povo de Nottingham envia $10 para o fundo de recuperação.'

O mé todo substitute() levanta uma exceçã o KeyError quando o identificador de uma marcaçã o nã o é forne-
cido 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('Devolva $item para $dono.')

>>> d = dict(item='a andorinha descarregada')
>>> t.substitute(d)
Traceback (most recent call last):
...
KeyError: 'dono'
>>> t.safe_substitute(d)
'Devolva a andorinha descarregada para $dono.'

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, os.path

>>> arquivos_fotos = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
>>> class RenomeiaEmLote(Template):
... delimiter = '%'
(continua na pró xima pá gina)

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

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

...
>>> formato = input('Informe o estilo de renomeação (%d-data %n-sequencia %f-
,→formato): ')
Informe o estilo de renomeação (%d-data %n-sequencia %f-formato): Ashley_%n%f

>>> t = RenomeiaEmLote(formato)
>>> data = time.strftime('%d%b%y')
>>> for i, nome_arquivo in enumerate(arquivos_fotos):
... base, extensão = os.path.splitext(nome_arquivo)
... novo_nome = t.substitute(d=data, n=i, f=extensão)
... print('{0} --> {1}'.format(nome_arquivo, novo_nome))

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 va-
riá 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('meuarquivo.zip', 'rb') as arq:

dados = arq.read()

inicio = 0
for i in range(3): # mostra o cabeçalho dos 3 primeiros␣
,→arquivos

inicio += 14
campos = struct.unpack('<IIIHH', dados[inicio:inicio+16])
crc32, tamanho_comprimido, tamanho_descomprimido, tamanho_nome_arquivo,␣
,→tamanho_extra = campos

inicio += 16
nome_arquivo = dados[inicio:inicio+tamanho_nome_arquivo]
inicio += tamanho_nome_arquivo
extra = dados[inicio:inicio+tamanho_extra]
print(nome_arquivo, hex(crc32), tamanho_comprimido, tamanho_descomprimido)

inicio += tamanho_extra + tamanho_comprimido # pula para o próximo␣

,→ cabeçalho

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

11.3. Trabalhando com formatos binários de dados 101

Python Tutorial, Release 3.13.0

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(threading.Thread):
def __init__(self, arquivo_entrada, arquivo_saida):
threading.Thread.__init__(self)
self.arquivo_entrada = arquivo_entrada
self.arquivo_saida = arquivo_saida

def run(self):
arq = zipfile.ZipFile(self.arquivo_saida, 'w', zipfile.ZIP_DEFLATED)
arq.write(self.)
arq.close()
print('Finalizou compactação em background de:', self.arquivo_entrada)

background = AsyncZip('meusdados.txt', 'meuarquivo.zip')

background.start()
print('O programa original continua a executar em primeiro plano.')

background.join() # Aguarda a tarefa em background finalizar

print('Programa principal aguardou até a tarefa em background estar finalizada.')

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 sys.stderr:

import logging
logging.debug('Depurando informações')
logging.info('Mensagem informática')
logging.warning('Alerta: arquivo de configuração %s não encontrado', 'server.conf
,→')

logging.error('Ocorreu um erro')
logging.critical('Erro crítico -- desligando')

Isso produz a seguinte saída:

WARNING:root:Alerta:arquivo de configuração server.conf não encontrado

ERROR:root:Ocorreu um erro
CRITICAL:root:Erro crítico -- 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.

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

 Python Tutorial, Release 3.13.0

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.

11.6 Referências fracas

Python faz gerenciamento automá tico de memó ria (contagem de referê ncias para a maioria dos objetos e 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 armazenamento em cache de objetos que sã o muito custosos para
criar:

>>> import weakref, gc

>>> class A:
... def __init__(self, valor):
... self.valor = valor
... def __repr__(self):
... return str(self.valor)
...
>>> a = A(10) # cria uma referência
>>> d = weakref.WeakValueDictionary()
>>> d['primaria'] = a # não cria uma referência
>>> d['primaria'] # busca o objeto se ele estiver ativo
10
>>> del a # remove a referência criada
>>> gc.collect() # roda imediatamente a coleta de lixo
0
>>> d['primaria'] # o acesso foi automaticamente removido
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
d['primaria'] # o acesso foi automaticamente removido
File "C:/python313/lib/weakref.py", line 46, in __getitem__
o = self.data[key]()
KeyError: 'primaria'

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.
O mó dulo array oferece uma classe array, semelhante a uma lista, mas que armazena apenas dados homogê neos
e de maneira mais compacta. O exemplo a seguir mostra um vetor de nú meros armazenados como nú meros biná rios
de dois bytes sem sinal (có digo de tipo "H") ao invé s dos 16 bytes usuais para cada item em uma lista de int:

>>> from array import array

>>> a = array('H', [4000, 10, 700, 22222])
>>> sum(a)
26932
>>> a[1:3]
array('H', [10, 700])

O mó dulo collections oferece um objeto deque que comporta-se como uma lista mas com appends e pops
pela esquerda mais rá pidos, poré m mais lento ao percorrer o meio da sequê ncia. Esses objetos sã o adequados para

11.6. Referências fracas 103

Python Tutorial, Release 3.13.0

implementar filas e buscas em amplitude em á rvores de dados:

>>> from collections import deque

>>> d = deque(["tarefa1", "tarefa2", "tarefa3"])
>>> d.append("tarefa4")
>>> print("Tratando", d.popleft())
Tratando tarefa1

nao_pesquisada = deque([no_inicial])
def busca_em_profundidade(nao_pesquisada):
no = nao_pesquisada.popleft()
for m in gen_moves(no):
if eh_o_alvo(m):
return m
nao_pesquisada.append(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

>>> notas = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
>>> bisect.insort(notas, (300, 'ruby'))
>>> notas
[(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

>>> dados = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
>>> heapify(dados) # reorganiza a lista como um heap
>>> heappush(dados, -5) # adiciona o valor -5 ao heap
>>> [heappop(dados) for i in range(3)] # encontra as 3 menores entradas
[-5, 0, 1]

11.8 Aritmética decimal com ponto flutuante

O mó dulo decimal oferece o tipo Decimal para aritmé tica decimal com ponto flutuante. Comparado a implemen-
taçã o embutida float que usa aritmé tica biná ria de ponto flutuante, a classe é especialmente ú til para:
• 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

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

 Python Tutorial, Release 3.13.0

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 funcionam
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. Aritmética decimal com ponto flutuante 105

Python Tutorial, Release 3.13.0

106 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

O mó dulo usado para criar e gerenciar ambientes virtuais é chamado venv. venv instalará a versã o do Python a partir
da qual o comando foi executado (conforme relatado pela opçã o --version). Por exemplo, executar o comando
com python3.12 instalará a versã o 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.
Uma vez criado seu ambiente virtual, você deve ativá -lo.

107
Python Tutorial, Release 3.13.0

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 activate.fish 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
>>> sys.path
['', '/usr/local/lib/python35.zip', ...,
'~/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 novas-3.1.1.3.tar.gz (136kB)
Installing collected packages: novas
Running setup.py install for novas
Successfully installed novas-3.1.1.3

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 requests-2.6.0-py2.py3-none-any.whl
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:

108 Capítulo 12. Ambientes virtuais e pacotes

 Python Tutorial, Release 3.13.0

(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 virtual.
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: http://python-requests.org
Author: Kenneth Reitz
Author-email: me@kennethreitz.com
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 (3.1.1.3)
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 formato que
python -m pip install espera. Uma convençã o comum é colocar esta lista em um arquivo requirements.
txt:

(tutorial-env) $ python -m pip freeze > requirements.txt

(tutorial-env) $ cat requirements.txt
novas==3.1.1.3
numpy==1.9.2
requests==2.7.0

O arquivo requirements.txt 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 requirements.txt

Collecting novas==3.1.1.3 (from -r requirements.txt (line 1))
...
Collecting numpy==1.9.2 (from -r requirements.txt (line 2))
...
Collecting requests==2.7.0 (from -r requirements.txt (line 3))
...
Installing collected packages: novas, numpy, requests
Running setup.py install for novas
Successfully installed novas-3.1.1.3 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

12.3. Gerenciando pacotes com o pip 109

Python Tutorial, Release 3.13.0

você escrever um pacote e desejar deixá -lo disponível no Python Package Index, consulte o guia de usuá rio para
empacotamento de Python.

110 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:
• https://www.python.org: 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.
• https://docs.python.org: acesso rá pido à documentaçã o Python.
• https://pypi.org: 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.
• https://code.activestate.com/recipes/langs/python/: O Python Cookbook (livro de receitas de Python) é uma
grande coleçã o de exemplos de có digo, mó dulos maiores e scripts ú teis.Contribuiçõ es particularmente notá veis
sã o coletadas em um livro també m chamado Python Cookbook (O’Reilly & Associates, ISBN 0-596-00797-3.)
• https://pyvideo.org coleta links para vídeo relacionados a Python de conferê ncias e reuniõ es de grupos de
usuá rios.
• https://scipy.org: 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.

111
Python Tutorial, Release 3.13.0

Para reportar questõ es e problemas relacionadas a Python, você pode postar no newsgroup comp.lang.python ou
enviá -los para o grupo de e-mail em python-list@python.org. O newsgroup e a lista sã o conectados, entã o mensagens
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 https://mail.python.org/pipermail/. Existe també m o grupo de discussã o da comunidade brasileira de
Python: python-brasil no Google Groups (http://groups.google.com/group/python-brasil), 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.

112 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.

113
Python Tutorial, Release 3.13.0

114 Capítulo 14. Edição de entrada interativa e substituição de histórico

 CAPÍTULO 15

Aritmética de ponto flutuante: problemas e limitações

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

115
Python Tutorial, Release 3.13.0

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 aproxi-
maçã 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 significa-
tivos, 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 que essa é a pró pria natureza do ponto flutuante biná rio: nã o é um bug do Python, e nem é um bug do seu có digo.
Essa situaçã o pode ser observada em todas as linguagens que usam as instruçõ es aritmé ticas de ponto flutuante do
hardware (apesar de algumas linguagens nã o mostrarem a diferença, por padrã o, ou em todos os modos de saída).
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(math.pi, '.12g') # ponto flutuante fornece 12 dígitos significativos

'3.14159265359'

>>> format(math.pi, '.2f') # ponto flutuante fornece 2 dígitos significativos

'3.14'

>>> repr(math.pi)
'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 math.isclose()
poderá ser ú til para comparar valores inexatos:

>>> math.isclose(0.1 + 0.1 + 0.1, 0.3)

True

116 Capítulo 15. Aritmética de ponto flutuante: problemas e limitações

 Python Tutorial, Release 3.13.0

Alternativamente, a funçã o round() pode ser usada para comparar aproximaçõ es aproximadas:

>>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)

True

A aritmé tica biná ria de ponto flutuante conté m muitas surpresas como essa. O problema com “0.1” é explicado em
detalhes precisos abaixo, na seçã o “Erro de representaçã o”. Consulte Exemplos de problemas de ponto flutuante
(em inglê s) para obter um resumo agradá vel de como o ponto flutuante biná rio funciona e os tipos de problemas
comumente encontrados na prá tica. Veja també m Os perigos do ponto flutuante (em inglê s) para um relato mais
completo de outras surpresas comuns.
Como dizemos perto do final, “nã o há respostas fá ceis”. Ainda assim, nã o se percam indevidamente no uso do ponto
flutuante! Os erros nas operaçõ es do tipo float do Python sã o heranças do hardware de ponto flutuante e, a maioria dos
computadores estã o na ordem de nã o mais do que 1 parte em 2**53 por operaçã o. Isso é mais do que o suficiente
para a maioria das tarefas, portanto, é importante lembrar que nã o se trata de uma aritmé tica decimal e que toda
operaçã o com o tipo float poderá via a apresentar novos problemas referentes ao arredondamento.
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
str.format() contido na seçã o formatstrings.

Para as situaçõ es que exijam uma representaçã o decimal exata, experimente o mó dulo decimal que possui, a im-
plementaçã 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 <https://scipy.org>.
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 float.hex() expressa um ponto flutuante em hexadecimal (base 16), o mesmo també m retornará o
valor exato pelo computador:

>>> x.hex()
'0x1.921f9f01b866ep+1'

Sua precisa representaçã o hexadecimal poderá ser utilizada para reconstruir o valor exato do ponto flutuante:

>>> x == float.fromhex('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

117
Python Tutorial, Release 3.13.0

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:

>>> 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

A funçã o math.fsum() vai alé m e rastreia todos os “dígitos perdidos” à medida que os valores sã o adicionados a
um total contínuo, de modo que o resultado tenha apenas um ú nico arredondamento. Isso é mais lento que sum(),
mas será mais preciso em casos incomuns em que entradas de grande magnitude se cancelam, deixando uma soma
final pró xima de zero:

>>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,

... -143401161400469.7, 266262841.31058735, -0.003244936839808227]
>>> float(sum(map(Fraction, arr))) # Soma exata com arredondamento simples
8.042173697819788e-13
>>> math.fsum(arr) # Arredondamento simples
8.042173697819788e-13
>>> sum(arr) # Arredondamentos múltiplos em precisão␣
,→estendida

8.042178034628478e-13
>>> total = 0.0
>>> for x in arr:
... total += x # Arredondamentos múltiplos em precisão padrão
...
>>> total # A adição direta não tem dígitos corretos!
-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:

118 Capítulo 15. Aritmética de ponto flutuante: problemas e limitações

 Python Tutorial, Release 3.13.0

>>> 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:

>>> 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 119

Python Tutorial, Release 3.13.0

120 Capítulo 15. Aritmética de ponto flutuante: problemas e limitações

 CAPÍTULO 16

Anexo

16.1 Modo interativo

Existem duas variantes do REPL interativo. O interpretador bá sico clá ssico é compatível com todas as plataformas
com recursos mínimos de controle de linha.
No Windows, ou em sistemas do tipo Unix com suporte a curses, um novo console interativo é usado por padrã o.
Este oferece suporte a cores, ediçã o multilinha, navegaçã o no histó rico e modo de colagem. Para desabilitar a cor,
veja using-on-controlling-color para detalhes. As teclas de funçã o fornecem algumas funcionalidades adicionais. F1
entra no navegador de ajuda interativo pydoc. F2 permite navegar no histó rico da linha de comando sem saída nem
os prompts »> e …. F3 entra no “modo de colagem”, o que torna mais fá cil colar blocos maiores de có digo. Pressione
F3 para retornar ao prompt normal.

Ao usar o novo console interativo, saia do console digitando exit ou quit. Nã o é necessá rio adicionar parê nteses
de chamada apó s esses comandos.
Se o novo shell interativo nã o for desejado, ele pode ser desabilitado atravé s da variá vel de ambiente
PYTHON_BASIC_REPL.

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 instruçã 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 cau-
sam 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.
1 Um problema com a package GNU Readline pode impedir que isso aconteça.

121
Python Tutorial, Release 3.13.0

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 meuscript.py

Em sistemas Windows, nã o existe a noçã o de um “modo executá vel”. O instalador Python associa automaticamente
os arquivos .py com o python.exe, 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 os.path.isfile('.pythonrc.py'):
exec(open('.pythonrc.py').read()). Se quiser usar o arquivo de inicializaçã o num script, será necessá rio
fazê -lo explicitamente no script:

import os
filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
with open(filename) as fobj:
startup_file = fobj.read()
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

>>> site.getusersitepackages()
'/home/user/.local/lib/python3.x/site-packages'

Agora você pode criar um arquivo chamado usercustomize.py 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.

122 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 console 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.
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 reconhe-
cidas 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 collections.abc), 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.
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:

123
Python Tutorial, Release 3.13.0

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
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.

124 Apêndice A. Glossário

 Python Tutorial, Release 3.13.0

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+'), sys.stdin.buffer, sys.stdout.buffer, e instâ ncias
de io.BytesIO e gzip.GzipFile.
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 array.array, 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:

chamavel(argumento1, argumento2, argumentoN)

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.
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).

125
Python Tutorial, Release 3.13.0

variável de clausura
Uma variável livre referenciada de um escopo aninhado que é definida em um escopo externo em vez de ser
resolvida em tempo de execuçã o a partir dos espaços de nomes embutido ou globais. Pode ser explicitamente
definida com a palavra reservada nonlocal para permitir acesso de gravaçã o, ou implicitamente definida se
a variá vel estiver sendo somente lida.
Por exemplo, na funçã o interna no có digo a seguir, tanto x quanto print sã o variáveis livres, mas somente
x é uma variável de clausura:

def externa():
x = 0
def interna():
nonlocal x
x += 1
print(x)
return interna

Devido ao atributo codeobject.co_freevars (que, apesar do nome, inclui apenas os nomes das variá veis
de clausura em vez de listar todas as variá veis livres referenciadas), o termo mais geral variável livre à s vezes
é usado mesmo quando o significado pretendido é se referir especificamente à s variá veis de clausura.
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, p.ex., 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.
contexto
Este termo tem diferentes significados dependendo de onde e como ele é usado. Alguns significados comuns:
• O estado ou ambiente temporá rio estabelecido por um gerenciador de contexto por meio de uma instruçã o
with.

• A coleçã o de ligaçõ es de chave-valor associadas a um objeto contextvars.Context específico e

acessadas por meio de objetos ContextVar. Veja també m variável de contexto.
• Um objeto contextvars.Context. Veja també m contexto atual.
protocolo de gerenciamento de contexto
Os mé todos __enter__() e __exit__() chamados pela instruçã o with. Veja PEP 343.
gerenciador de contexto
Um objeto que implementa o protocolo de gerenciamento de contexto e controla o ambiente visto em uma
instruçã o with. Veja PEP 343.
variável de contexto
Uma variá vel cujo valor depende de qual contexto é o contexto atual. Os valores sã o acessados por meio de
objetos contextvars.ContextVar. Variá veis de contexto sã o usadas principalmente para isolar o estado
entre tarefas assíncronas simultâ neas.
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.

126 Apêndice A. Glossário

 Python Tutorial, Release 3.13.0

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 python.org.
O termo “CPython” é usado quando necessá rio distinguir esta implementaçã o de outras como Jython ou
IronPython.
contexto atual
O contexto (objeto contextvars.Context) que é usado atualmente pelos objetos ContextVar para acessar
(obter ou definir) os valores de variáveis de contexto. Cada thread tem seu pró prio contexto atual. Frameworks
para executar tarefas assíncronas (veja asyncio) associam cada tarefa a um contexto que se torna o contexto
atual sempre que a tarefa inicia ou retoma a execuçã o.
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.
descritor
Qualquer objeto que define os mé todos __get__(), __set__() ou __delete__(). Quando um atributo
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 dict.keys(), dict.values() e dict.items() 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 di-
cioná 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, é

127
Python Tutorial, Release 3.13.0

reconhecida pelo compilador que a coloca no atributo __doc__ da classe, funçã o ou mó dulo que a encapsula.
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 presume a existê ncia de chaves ou atribu-
tos 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.
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 sys.getfilesystemencoding() e sys.getfilesystemencodeerrors() podem ser usa-
das 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.

128 Apêndice A. Glossário

 Python Tutorial, Release 3.13.0

localizador
Um objeto que tenta encontrar o carregador para um mó dulo que está sendo importado.
Existem dois tipos de localizador: localizadores de metacaminho para uso com sys.meta_path, e localiza-
dores de entrada de caminho para uso com sys.path_hooks.
Veja finders-and-loaders e importlib para muito mais detalhes.
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.
threads livres
Um modelo de threads onde mú ltiplas threads podem simultaneamente executar bytecode Python no mesmo
interpretador. Isso está em contraste com a trava global do interpretador que permite apenas uma thread por
vez executar bytecode Python. Veja PEP 703.
variável livre
Formalmente, conforme definido no modelo de execuçã o de linguagem, uma variá vel livre é qualquer variá vel
usada em um espaço de nomes que nã o seja uma variá vel local naquele espaço de nomes. Veja variável de
clausura para um exemplo. Pragmaticamente, devido ao nome do atributo codeobject.co_freevars, o
termo també m é usado algumas vezes como sinô nimo de variável de clausura.
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 soma_dois_numeros(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 __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().

129
Python Tutorial, Release 3.13.0

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 laço, um intervalo, 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)) # soma dos quadrados 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 functools.singledispatch(), 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 trava global do interpretador.
trava 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 a GIL ao realizar tarefas computacionalmente muito intensas, como compactaçã o ou cá lculos
de hash. Alé m disso, a GIL é sempre liberado nas operaçõ es de E/S.
A partir de Python 3.13, o GIL pode ser desabilitado usando a configuraçã o de construçã o --disable-gil.
Depois de construir Python com essa opçã o, o có digo deve ser executado com a opçã o -X gil=0 ou a variá vel
de ambiente PYTHON_GIL=0 deve estar definida. Esse recurso provê um desempenho melhor para aplicaçõ es
com mú ltiplas threads e torna mais fá cil o uso eficiente de CPUs com mú ltiplos nú cleos. Para mais detalhes,
veja PEP 703.
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

130 Apêndice A. Glossário

 Python Tutorial, Release 3.13.0

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.
imortal
Objetos imortais sã o um detalhe da implementaçã o do CPython introduzida na PEP 683.
Se um objeto é imortal, sua contagem de referências nunca é modificada e, portanto, nunca é desalocado en-
quanto o interpretador está em execuçã o. Por exemplo, True e None sã o imortais no CPython.
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)). Para saber mais sobre modo interativo, veja Modo interativo.
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
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 ter-
minou 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

131
Python Tutorial, Release 3.13.0

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 de que um
iterador defina __iter__(). E també m observe que o CPython com threads livres nã o garante a segurança
do thread das operaçõ es do iterador.
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, locale.strxfrm() é 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 orde-
nados ou agrupados. Algumas delas incluem min(), max(), sorted(), list.sort(), heapq.merge(),
heapq.nsmallest(), heapq.nlargest() e itertools.groupby().
Há vá rias maneiras de se criar funçõ es chave. Por exemplo, o mé todo str.lower() 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(), operator.itemgetter() e operator.methodcaller() sã o trê s construtores de fun-
çã o chave. Consulte o guia 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.
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 travas 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.

132 Apêndice A. Glossário

 Python Tutorial, Release 3.13.0

carregador
Um objeto que carrega um mó dulo. Deve definir um mé todo chamado load_module(). Um carregador é
normalmente devolvido por um localizador. Veja també m:
• finders-and-loaders
• importlib.abc.Loader
• PEP 302
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.
locale.getencoding() 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 especificados nas
collections.abc.Mapping ou collections.abc.MutableMapping classes base abstratas. Exemplos
incluem dict, collections.defaultdict, collections.OrderedDict e collections.Counter.
localizador de metacaminho
Um localizador retornado por uma busca de sys.meta_path. Localizadores de metacaminho sã o relaciona-
dos a, mas diferentes de, localizadores de entrada de caminho.
Veja importlib.abc.MetaPathFinder para os mé todos que localizadores de metacaminho implementam.
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
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.
especificação do módulo
Um espaço de nomes que conté m as informaçõ es relacionadas à importaçã o usadas para carregar um mó dulo.
Uma instâ ncia de importlib.machinery.ModuleSpec.

133
Python Tutorial, Release 3.13.0

Veja també m module-specs.

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 time.localtime() e
os.stat(). Outro exemplo é sys.float_info:

>>> sys.float_info[1] # acesso indexado

1024
>>> sys.float_info.max_exp # acesso a campo nomeado
1024
>>> isinstance(sys.float_info, tuple) # tipo de tupla
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 typing.NamedTuple ou com
uma funçã o fá brica collections.namedtuple(). 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. Exis-
tem os espaços de nomes local, global e nativo, bem como espaços de nomes aninhados em objetos (em
mé todos). Espaços de nomes suportam modularidade ao prevenir conflitos de nomes. Por exemplo, as fun-
çõ es __builtin__.open() e os.open() 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 random.seed() ou itertools.izip(), 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.
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.
escopo otimizado
Um escopo no qual os nomes das variá veis locais de destino sã o conhecidos de forma confiá vel pelo compi-
lador quando o có digo é compilado, permitindo a otimizaçã o do acesso de leitura e gravaçã o a esses nomes.

134 Apêndice A. Glossário

 Python Tutorial, Release 3.13.0

Os espaços de nomes locais para funçõ es, geradores, corrotinas, compreensõ es e expressõ es geradoras sã o
otimizados desta forma. Nota: a maioria das otimizaçõ es de interpretador sã o aplicadas a todos os escopos,
apenas aquelas que dependem de um conjunto conhecido de nomes de variá veis locais e nã o locais sã o restritas
a escopos otimizados.
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 somentepos1 e somentepos2 a seguir:

def func(somentepos1, somentepos2, /, posicional_ou_nomeado): ...

• 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 somente_nom1 and somente_nom2
a seguir:

def func(arg, *, somente_nom1, somente_nom2): ...

• 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
inspect.Parameter, 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 caminho)
que sabe como localizar os mó dulos entrada de caminho.
Veja importlib.abc.PathEntryFinder para os mé todos que localizadores de entrada de caminho im-
plementam.
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.

135
Python Tutorial, Release 3.13.0

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 os.PathLike. Um
objeto que suporta o protocolo os.PathLike pode ser convertido para um arquivo de caminho do sistema
str ou bytes, atravé s da chamada da funçã o os.fspath(); os.fsdecode() e os.fsencode() 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 as formas de escritas mais comuns da linguagem
Python, ao invé s de implementar có digos usando conceitos comuns a outras linguagens. Por exemplo, um
formato comum em Python é fazer um laço 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:

for i in range(len(comida)):
print(comida[i])

Ao contrá rio do mé todo mais limpo, Pythô nico:

136 Apêndice A. Glossário

 Python Tutorial, Release 3.13.0

for parte in comida:

print(parte)

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 metodo(self):
... pass
...
>>> C.__qualname__
'C'
>>> C.D.__qualname__
'C.D'
>>> C.D.metodo.__qualname__
'C.D.metodo'

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: email.mime.text:

>>> import email.mime.text

>>> email.mime.text.__name__
'email.mime.text'

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 sys.
getrefcount() 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.
REPL
Um acrô nimo para “read–eval–print loop”, outro nome para o console interativo do interpretador.
__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 es-
pecial __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 hasheável arbitrá ria em vez de inteiros.
A classe base abstrata collections.abc.Sequence 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.

137
Python Tutorial, Release 3.13.0

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 conjunto 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.
suavemente descontinuado
Uma API suavemente descontinuada nã o deve ser usada em có digo novo, mas é seguro para có digo já existente
usá -la. A API continua documentada e testada, mas nã o será aprimorada mais.
A descontinuaçã o suave, diferentemente da descontinuaçã o normal, nã o planeja remover a API e nã o emitirá
avisos.
Veja PEP 387: Descontinuaçã o suave.
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'), sys.stdin, sys.stdout, e instâ ncias de io.StringIO.
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

138 Apêndice A. Glossário

 Python Tutorial, Release 3.13.0

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 classe de objeto ele é ; cada objeto tem um tipo. Um tipo de objeto
é acessível pelo atributo __class__ ou pode ser recuperado com type(obj).
apelido de tipo
Um sinô nimo para um tipo, criado atravé s da atribuiçã o do tipo para um identificador.
Apelidos de tipo sã o ú teis para simplificar dicas de tipo. Por exemplo:

def remove_tons_de_cinza(
cores: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
pass

pode tornar-se mais legível desta forma:

Cor = tuple[int, int, int]

def remove_tons_de_cinza(cores: list[Cor]) -> list[Cor]:

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 bytes.splitlines() 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:
campo: 'anotação'

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:

contagem: 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.

139
Python Tutorial, Release 3.13.0

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.

140 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!

141
Python Tutorial, Release 3.13.0

142 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 https://www.cwi.nl/) 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 https://www.cnri.reston.va.us/) 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 BeOpen.com para
formar a equipe BeOpen PythonLabs. Em outubro do mesmo ano, a equipe da PythonLabs mudou para a Digital
Creations (agora Zope Corporation; veja https://www.zope.org/). Em 2001, formou-se a Python Software Foundation
(PSF, veja https://www.python.org/psf/), 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 https://opensource.org/ 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 BeOpen.com 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

143
Python Tutorial, Release 3.13.0

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.13.0

1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and
the Individual or Organization ("Licensee") accessing and otherwise using Python
3.13.0 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.13.0 alone or in any derivative
version, provided, however, that PSF's License Agreement and PSF's notice of
copyright, i.e., "Copyright © 2001-2024 Python Software Foundation; All Rights
Reserved" are retained in Python 3.13.0 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.13.0 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.13.0.

4. PSF is making Python 3.13.0 available to Licensee on an "AS IS" basis.

PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF
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.13.0 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 3.13.0
FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 3.13.0, 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

144 Apêndice C. História e Licença

 Python Tutorial, Release 3.13.0

trademark sense to endorse or promote products or services of Licensee, or any

third party.

8. By copying, installing or otherwise using Python 3.13.0, Licensee agrees

to be bound by the terms and conditions of this License Agreement.

C.2.2 ACORDO DE LICENCIAMENTO DA BEOPEN.COM PARA PYTHON 2.0

ACORDO DE LICENCIAMENTO DA BEOPEN DE FONTE ABERTA DO PYTHON VERSÃO 1

1. This LICENSE AGREEMENT is between BeOpen.com ("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.

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
http://www.pythonlabs.com/logos.html 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.

(continua na pró xima pá gina)

C.2. Termos e condições para acessar ou usar Python 145

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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: http://hdl.handle.net/1895.22/1013."

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
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.

146 Apêndice C. História e Licença

 Python Tutorial, Release 3.13.0

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.13.0
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.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 http://www.math.
sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html. A seguir estã o os comentá rios literais do có digo ori-
ginal:

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

(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 147

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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.

http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)

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, https://www.wide.ad.jp/.

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
(continua na pró xima pá gina)

148 Apêndice C. História e Licença

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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 test.support.asynchat e test.support.asyncore 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.4 Gerenciamento de cookies

O mó dulo http.cookies conté m o seguinte aviso:

Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>

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
(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 149

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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
http://zooko.com/
mailto:zooko@zooko.com

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.

C.3.6 Funções UUencode e UUdecode

O codec 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.

(continua na pró xima pá gina)

150 Apêndice C. História e Licença

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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 xmlrpc.client 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.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
(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 151

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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.

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@popcount.org>

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:
https://github.com/majek/csiphash/

(continua na pró xima pá gina)

152 Apêndice C. História e Licença

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

Solution inspired by code from:
Samuel Neves (supercop/crypto_auth/siphash24/little)
djb (supercop/crypto_auth/siphash24/little2)
Jean-Philippe Aumasson (https://131002.net/siphash/siphash24.c)

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 https://web.archive.org/
web/20220517033456/http://www.netlib.org/fp/dtoa.c. 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.12 OpenSSL
Os mó dulos hashlib, posix e ssl usam a biblioteca OpenSSL para desempenho adicional se forem disponibi-
lizados 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
https://www.apache.org/licenses/

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
(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 153

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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
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,
(continua na pró xima pá gina)

154 Apêndice C. História e Licença

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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
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,

(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 155

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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

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

(continua na pró xima pá gina)

156 Apêndice C. História e Licença

 Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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.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.

(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 157

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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@gzip.org madler@alumni.caltech.edu

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
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.

158 Apêndice C. História e Licença

 Python Tutorial, Release 3.13.0

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 https://www.w3.org/TR/xml-c14n2-testcases/ 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.

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,
(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 159

Python Tutorial, Release 3.13.0

(continuaçã o da pá gina anterior)

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 mimalloc
Licença MIT:

Copyright (c) 2018-2021 Microsoft Corporation, Daan Leijen

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.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. http://magic.io

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.

160 Apêndice C. História e Licença

 Python Tutorial, Release 3.13.0

C.3.21 Global Unbounded Sequences (GUS)

O arquivo Python/qsbr.c é adaptado do esquema de recuperaçã o de memó ria segura “Global Unbounded Se-
quences” do FreeBSD em subr_smr.c. O arquivo é distribuído sob a licença BSD de 2 clá usulas:

Copyright (c) 2019,2020 Jeffrey Roberson <jeff@FreeBSD.org>

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 unmodified, 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 ``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 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. Licenças e Reconhecimentos para Software Incorporado 161

Python Tutorial, Release 3.13.0

162 Apêndice C. História e Licença

 APÊNDICE D

Direitos autorais

Python e essa documentaçã o é :

Copyright © 2001-2024 Python Software Foundation. Todos os direitos reservados.
Copyright © 2000 BeOpen.com. 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.

163
Python Tutorial, Release 3.13.0

164 Apêndice D. Direitos autorais

 Índice

Não alfabético C
..., 123 caminho
# (cerquilha) módulo pesquisa, 51
comentário, 9 caminho de importação, 131
* (asterisco) carregador, 133
em chamadas de função, 32 chamável, 125
** classe, 125
em chamadas de função, 33 classe base abstrata, 123
: (dois pontos) classe estilo novo, 134
anotações de função, 34 codificação
-> estilo, 34
anotações de função, 34 codificação da localidade, 133
>>>, 123 codificador de texto, 138
__all__, 56 coleta de lixo, 129
__future__, 129 compreensão de conjunto, 138
__slots__, 137 compreensão de dicionário, 127
compreensão de lista, 132
A contagem de referências, 137
aguardável, 124 contexto, 126
ambiente virtual, 139 contexto atual, 127
annotations contíguo, 126
função, 34 contíguo C, 126
anotação, 123 contíguo Fortran, 126
anotação de função, 129 corrotina, 126
anotação de variável, 139 CPython, 127
apelido de tipo, 139
API provisória, 136 D
argumento, 123 decorador, 127
argumento nomeado, 132 descritor, 127
argumento posicional, 136 desfiguração
arquivo nome, 88
objeto, 63 desligamento do interpretador, 131
arquivo binário, 125 despacho único, 138
arquivo texto, 138 dica de tipo, 139
aspas triplas, 138 dicionário, 127
atributo, 124 divisão pelo piso, 129
docstring, 127
B docstrings, 26, 33
BDFL, 125
builtins E
módulo, 53 EAFP, 128
bytecode, 125 entrada de caminho, 135
escopo aninhado, 134

165
Python Tutorial, Release 3.13.0

escopo otimizado, 134 J

espaço de nomes, 134 json
especial módulo, 65
método, 138
especificação do módulo, 133 L
estilo lambda, 132
codificação, 34 LBYL, 132
expressão, 128 lista, 132
expressão geradora, 130 literal de string formatado, 60
literal de string interpolada, 60
F localizador, 129
f-string, 128 localizador baseado no caminho, 136
fatia, 138 localizador de entrada de caminho, 135
for localizador de metacaminho, 133
instrução, 19
fstring, 60 M
f-string, 60 mágico
função, 129 método, 133
annotations, 34 mapeamento, 133
função chave, 132 máquina virtual, 140
função de corrotina, 127 metaclasse, 133
função de retorno, 125 método, 133
função embutida especial, 138
help, 93 mágico, 133
open, 63 objeto, 83
função genérica, 130 método especial, 138
método mágico, 133
G módulo, 133
gancho de entrada de caminho, 135 builtins, 53
gerador, 129 json, 65
gerador assíncrono, 124 pesquisa caminho, 51
gerenciador de contexto, 126 sys, 52
gerenciador de contexto assíncrono, 124 módulo de extensão, 128
GIL, 130 MRO, 134
mutável, 134
H
hasheável, 130 N
help nome
função embutida, 93 desfiguração, 88
nome qualificado, 137
I novas linhas universais, 139
IDLE, 131 número complexo, 126
imortal, 131
importação, 131 O
importador, 131 objeto, 134
imutável, 131 arquivo, 63
instrução, 138 método, 83
for, 19 objeto arquivo, 128
interativo, 131 objeto arquivo ou similar, 128
interpretado, 131 objeto byte ou similar, 125
iterador, 132 objeto caminho ou similar, 136
iterador assíncrono, 124 open
iterador gerador, 130 função embutida, 63
iterador gerador assíncrono, 124 ordem de resolução de métodos, 133
iterável, 131
iterável assíncrono, 124 P
pacote, 135
pacote de espaço de nomes, 134

166 Índice
 Python Tutorial, Release 3.13.0

pacote provisório, 136 suavemente descontinuado, 138

pacote regular, 137 sys
parâmetro, 135 módulo, 52
PATH, 51, 122
PEP, 136 T
pesquisa threads livres, 129
caminho, módulo, 51 tipagem pato, 128
porção, 136 tipo, 139
Propostas de Melhorias do Python tipo genérico, 130
PEP 1, 136 tratador de erros e codificação do
PEP 8, 35 sistema de arquivos, 128
PEP 238, 129 trava global do interpretador, 130
PEP 278, 139 tupla nomeada, 134
PEP 302, 133
PEP 343, 126 U
PEP 362, 124, 135 usercustomize, 122
PEP 411, 136
PEP 420, 134, 136 V
PEP 443, 130 variável de ambiente
PEP 483, 130 PATH, 51, 122
PEP 484, 34, 123, 129, 130, 139 PYTHON_BASIC_REPL, 121
PEP 492, 124, 126, 127 PYTHON_GIL, 130
PEP 498, 128 PYTHONPATH, 51, 53
PEP 519, 136 PYTHONSTARTUP, 122
PEP 525, 124 variável de classe, 125
PEP 526, 123, 139 variável de clausura, 126
PEP 585, 130 variável de contexto, 126
PEP 636, 25 variável livre, 129
PEP 683, 131 verificador de tipo estático, 138
PEP 703, 129, 130 visão de dicionário, 127
PEP 3107, 34
PEP 3116, 139 Z
PEP 3147, 52
Zen do Python, 140
PEP 3155, 137
protocolo de gerenciamento de contexto,
126
pyc baseado em hash, 130
Python 3000, 136
PYTHON_BASIC_REPL, 121
PYTHON_GIL, 130
Pythônico, 136
PYTHONPATH, 51, 53
PYTHONSTARTUP, 122

R
referência emprestada, 125
referência forte, 138
REPL, 137
RFC
RFC 2822, 98

S
sequência, 137
sitecustomize, 122
string
literal formatado, 60
literal interpolado, 60
strings, documentação, 26, 33

Índice 167