The Python Language Reference

Release 3.13.0

Guido van Rossum and the Python development team

novembro 09, 2024

Python Software Foundation

Email: docs@[Link]
 Sumário

1 Introdução 3
1.1 Implementaçõ es Alternativas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Notaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Análise léxica 5
2.1 Estrutura das linhas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Linhas ló gicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Linhas físicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.3 Comentá rios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.4 Declaraçõ es de codificaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.5 Junçã o de linha explícita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.6 Junçã o de linha implícita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.7 Linhas em branco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.8 Indentaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.9 Espaços em branco entre tokens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Outros tokens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Identificadores e palavras-chave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3.1 Palavras reservadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.2 Palavras reservadas contextuais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.3 Classes reservadas de identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4 Literais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4.1 Literais de string e bytes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4.2 Concatenaçã o de literal de string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.3 Literais de strings formatadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.4 Literais numé ricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4.5 Inteiros literais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4.6 Literais de ponto flutuante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4.7 Literais imaginá rios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5 Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.6 Delimitadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3 Modelo de dados 17
3.1 Objetos, valores e tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 A hierarquia de tipos padrã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.1 None . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.2 NotImplemented . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.3 Ellipsis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.4 [Link] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.5 Sequê ncias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.6 Tipos de conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.7 Mapeamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

i
 3.2.8 Tipos chamá veis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.2.9 Mó dulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.10 Classes personalizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2.11 Instâ ncias de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2.12 Objetos de E/S (també m conhecidos como objetos arquivo) . . . . . . . . . . . . . . . . 30
3.2.13 Tipos internos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.3 Nomes de mé todos especiais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3.1 Personalizaçã o bá sica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3.2 Personalizando o acesso aos atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.3.3 Personalizando a criaçã o de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.3.4 Personalizando verificaçõ es de instâ ncia e subclasse . . . . . . . . . . . . . . . . . . . . 48
3.3.5 Emulando tipos gené ricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.3.6 Emulando objetos chamá veis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.3.7 Emulando de tipos contê ineres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.3.8 Emulando tipos numé ricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.3.9 Gerenciadores de contexto da instruçã o with . . . . . . . . . . . . . . . . . . . . . . . . 55
3.3.10 Customizando argumentos posicionais na classe correspondê ncia de padrã o . . . . . . . . 55
3.3.11 Emulating buffer types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.3.12 Pesquisa de mé todo especial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.4 Corrotinas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.4.1 Objetos aguardá veis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.4.2 Objetos corrotina . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.4.3 Iteradores assíncronos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.4.4 Gerenciadores de contexto assíncronos . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

4 Modelo de execução 61
4.1 Estrutura de um programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2 Nomeaçã o e ligaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2.1 Ligaçã o de nomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2.2 Resoluçã o de nomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.2.3 Escopos de anotaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2.4 Avaliaçã o preguiçosa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2.5 Builtins e execuçã o restrita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.2.6 Interaçã o com recursos dinâ micos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.3 Exceçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

5 O sistema de importação 67
5.1 importlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.2 Pacotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.2.1 Pacotes regulares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.2.2 Pacotes de espaço de nomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.3 Caminho de busca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.3.1 O cache de mó dulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.3.2 Localizadores e carregadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.3.3 Ganchos de importaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.3.4 O metacaminho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.4 Carregando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.4.1 Carregadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.4.2 Submó dulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.4.3 Module specs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.4.4 __path__ attributes on modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.4.5 Representaçõ es do mó dulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.4.6 Invalidaçã o de bytecode em cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.5 O localizador baseado no caminho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.5.1 Localizadores de entrada de caminho . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.5.2 Protocolo do localizador de entrada de caminho . . . . . . . . . . . . . . . . . . . . . . 76
5.6 Substituindo o sistema de importaçã o padrã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5.7 Importaçõ es relativas ao pacote . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

ii
 5.8 Consideraçõ es especiais para __main__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.8.1 __main__.__spec__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.9 Referê ncias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

6 Expressões 79
6.1 Conversõ es aritmé ticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.2 Átomos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.2.1 Identificadores (Nomes) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.2.2 Literais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.2.3 Formas de parê nteses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
6.2.4 Sintaxe de criaçã o de listas, conjuntos e dicioná rios . . . . . . . . . . . . . . . . . . . . . 81
6.2.5 Sintaxes de criaçã o de lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6.2.6 Sintaxes de criaçã o de conjunto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6.2.7 Sintaxes de criaçã o de dicioná rio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6.2.8 Expressõ es geradoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.2.9 Expressõ es yield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.3 Primá rias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.3.1 Referê ncias de atributo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.3.2 Subscriçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.3.3 Fatiamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.3.4 Chamadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.4 Expressã o await . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.5 O operador de potê ncia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.6 Operaçõ es aritmé ticas uná rias e bit a bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
6.7 Operaçõ es biná rias aritmé ticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
6.8 Operaçõ es de deslocamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6.9 Operaçõ es biná rias bit a bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6.10 Comparaçõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
6.10.1 Comparaçõ es de valor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
6.10.2 Operaçõ es de teste de pertinê ncia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
6.10.3 Comparaçõ es de identidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.11 Operaçõ es booleanas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.12 Expressõ es de atribuiçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.13 Expressõ es condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.14 Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.15 Listas de expressõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.16 Ordem de avaliaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.17 Precedê ncia de operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

7 Instruções simples 101

7.1 Instruçõ es de expressã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
7.2 Instruçõ es de atribuiçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
7.2.1 Instruçõ es de atribuiçã o aumentada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.2.2 instruçõ es de atribuiçã o anotado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.3 A instruçã o assert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
7.4 A instruçã o pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
7.5 A instruçã o del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.6 A instruçã o return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.7 A instruçã o yield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.8 A instruçã o raise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
7.9 A instruçã o break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
7.10 A instruçã o continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
7.11 A instruçã o import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
7.11.1 Instruçõ es future . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
7.12 A instruçã o global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
7.13 A instruçã o nonlocal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
7.14 A instruçã o type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

iii
8 Instruções compostas 115
8.1 A instruçã o if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.2 A instruçã o while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.3 A instruçã o for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.4 A instruçã o try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8.4.1 Clá usula except . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8.4.2 Clá usula except* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
8.4.3 Clá usula else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.4.4 Clá usula finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.5 A instruçã o with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
8.6 A instruçã o match . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
8.6.1 Visã o Geral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.6.2 Guards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.6.3 Blocos irrefutá veis de case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.6.4 Padrõ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.7 Definiçõ es de funçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
8.8 Definiçõ es de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
8.9 Corrotinas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
8.9.1 Definiçã o de funçã o de corrotina . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
8.9.2 The async for statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
8.9.3 The async with statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
8.10 Type parameter lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
8.10.1 Generic functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
8.10.2 Generic classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
8.10.3 Generic type aliases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

9 Componentes de Alto Nível 139

9.1 Programas Python completos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
9.2 Entrada de arquivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
9.3 Entrada interativa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
9.4 Entrada de expressã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

10 Especificação Completa da Gramática 141

A Glossário 159

B Sobre esses documentos 177

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

C História e Licença 179

C.1 Histó ria do software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
C.2 Termos e condiçõ es para acessar ou usar Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
C.2.1 ACORDO DE LICENCIAMENTO DA PSF PARA PYTHON 3.13.0 . . . . . . . . . . 180
C.2.2 ACORDO DE LICENCIAMENTO DA [Link] PARA PYTHON 2.0 . . . . . . 181
C.2.3 CONTRATO DE LICENÇA DA CNRI PARA O PYTHON 1.6.1 . . . . . . . . . . . . 181
C.2.4 ACORDO DE LICENÇA DA CWI PARA PYTHON 0.9.0 A 1.2 . . . . . . . . . . . . . 183
C.2.5 LICENÇA BSD DE ZERO CLÁUSULA PARA CÓDIGO NA DOCUMENTAÇÃO DO
PYTHON 3.13.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
C.3 Licenças e Reconhecimentos para Software Incorporado . . . . . . . . . . . . . . . . . . . . . . 183
C.3.1 Mersenne Twister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
C.3.2 Soquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
C.3.3 Serviços de soquete assíncrono . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
C.3.4 Gerenciamento de cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
C.3.5 Rastreamento de execuçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
C.3.6 Funçõ es UUencode e UUdecode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
C.3.7 Chamadas de procedimento remoto XML . . . . . . . . . . . . . . . . . . . . . . . . . 187
C.3.8 test_epoll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
C.3.9 kqueue de seleçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
C.3.10 SipHash24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

iv
 C.3.11 strtod e dtoa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
C.3.12 OpenSSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
C.3.13 expat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
C.3.14 libffi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
C.3.15 zlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
C.3.16 cfuhash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
C.3.17 libmpdec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
C.3.18 Conjunto de testes C14N do W3C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
C.3.19 mimalloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
C.3.20 asyncio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
C.3.21 Global Unbounded Sequences (GUS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

D Direitos autorais 199

Índice 201

v
vi
 The Python Language Reference, Release 3.13.0

Este manual de referê ncia descreve a sintaxe e a “semâ ntica central” da linguagem. É conciso, mas tenta ser exato e
completo. A semâ ntica dos tipos de objetos embutidos nã o essenciais e das funçõ es e mó dulos embutidos é descrita
em library-index. Para uma introduçã o informal à linguagem, consulte tutorial-index. Para programadores em C ou
C++, existem dois manuais adicionais: extending-index descreve a imagem de alto nível de como escrever um mó dulo
de extensã o Python, e o c-api-index descreve as interfaces disponíveis para programadores C/C++ em detalhes.

Sumário 1
The Python Language Reference, Release 3.13.0

2 Sumário
 CAPÍTULO 1

Introdução

Este manual de referê ncia descreve a linguagem de programaçã o Python. O mesmo nã o tem como objetivo de ser
um tutorial.
Enquanto estou tentando ser o mais preciso possível, optei por usar especificaçõ es em inglê s e nã o formal para
tudo, exceto para a sintaxe e aná lise lé xica. Isso deve tornar o documento mais compreensível para o leitor inter-
mediá rio, mas deixará margem para ambiguidades. Consequentemente, caso estivesses vindo de Marte e tentasse
reimplementar o Python a partir deste documento, sozinho, talvez precisarias adivinhar algumas coisas e, na verdade,
provavelmente acabaria por implementar um linguagem bem diferente. Por outro lado, se estiveres usando o Python
e se perguntando quais sã o as regras precisas sobre uma determinada á rea da linguagem, você definitivamente en-
contrá neste documento o que está s procurando. Caso queiras ver uma definiçã o mais formal do linguagem, talvez
possas oferecer seu tempo – ou inventar uma má quina de clonagem :-).
É perigoso adicionar muitos detalhes de implementaçã o num documento de referê ncia de uma linguagem – a im-
plementaçã o pode mudar e outras implementaçõ es da mesma linguagem podem funcionar de forma diferente. Por
outro lado, o CPython é a ú nica implementaçã o de Python em uso de forma generalizada (embora as implementa-
çõ es alternativas continuem a ganhar suporte), e suas peculiaridades e particulares sã o por vezes dignas de serem
mencionadas, especialmente quando a implementaçã o impõ e limitaçõ es adicionais. Portanto, encontrará s poucas
“notas sobre a implementaçã o” espalhadas neste documento.
Cada implementaçã o do Python vem com vá rios mó dulos embutidos e por padrã o. Estes estã o documentados em
library-index. Alguns mó dulos embutidos sã o mencionados ao interagirem de forma significativa com a definiçã o da
linguagem.

1.1 Implementações Alternativas

Embora exista uma implementaçã o do Python que seja, de longe, a mais popular, existem algumas implementaçõ es
alternativas que sã o de de interesse particular e para pú blicos diferentes.
As implementaçõ es conhecidas sã o:
CPython
Esta é a implementaçã o original e a é a versã o do Python que mais vem sendo sendo desenvolvido e a mesma
está escrita com a linguagem C. Novas funcionalidades ou recursos da linguagem aparecerã o por aqui primeiro.
Jython
Versã o do Python implementado em Java. Esta implementaçã o pode ser usada como linguagem de Script em
aplicaçõ es Java, ou pode ser usada para criar aplicativos usando as bibliotecas das classes do Java. També m
vem sendo bastante utilizado para criar testes unitá rios para as bibliotecas do Java. Mais informaçõ es podem
ser encontradas no the Jython website.

3
The Python Language Reference, Release 3.13.0

Python for .NET

Essa implementaçã o utiliza de fato a implementaçã o CPython, mas é uma aplicaçã o gerenciada .NET e dis-
ponibilizada como uma bibliotecas .NET. Foi desenvolvida por Brian Lloyd. Para obter mais informaçõ es,
consulte o site do Python for .NET.
IronPython
Um versã o alternativa do Python para a plataforma .NET. Ao contrá rio do [Link], esta é uma imple-
mentaçã o completa do Python que gera IL e compila o có digo Python diretamente para assemblies .NET. Foi
desenvolvida por Jim Hugunin, o criador original do Jython. Para obter mais informaçõ es, consulte o site do
IronPython.
PyPy
Uma implementaçã o do Python escrita completamente em Python. A mesma suporta vá rios recursos avan-
çados nã o encontrados em outras implementaçõ es, como suporte sem pilhas e um compilador Just in Time.
Um dos objetivos do projeto é incentivar a construçã o de experimentos com a pró pria linguagem, facilitando
a modificaçã o do interpretador (uma vez que o mesmos está escrito em Python). Informaçõ es adicionais estã o
disponíveis no site do projeto PyPy.
Cada uma dessas implementaçõ es varia em alguma forma a linguagem conforme documentado neste manual, ou
introduz informaçõ es específicas alé m do que está coberto na documentaçã o padrã o do Python. Consulte a docu-
mentaçã o específica da implementaçã o para determinar o que é necessá rio sobre a implementaçã o específica que
você está usando.

1.2 Notação
As descriçõ es de aná lise lé xica e sintaxe usam uma notaçã o de gramá tica de Formalismo de Backus-Naur (BNF)
modificada. Ela usa o seguinte estilo de definiçã o:

name ::= lc_letter (lc_letter | "_")*

lc_letter ::= "a"..."z"

A primeira linha diz que um name é um lc_letter seguido de uma sequê ncia de zero ou mais lc_letters e
underscores. Um lc_letter por sua vez é qualquer um dos caracteres simples 'a' atravé s de 'z'. (Esta regra é
aderida pelos nomes definidos nas regras lé xicas e gramá ticas deste documento.)
Cada regra começa com um nome (no caso, o nome definido pela regra) e ::=. Uma barra vertical (|) é usada para
separar alternativas; o mesmo é o operador menos vinculativo nesta notaçã o. Uma estrela (*) significa zero ou mais
repetiçõ es do item anterior; da mesma forma, o sinal de adiçã o (+) significa uma ou mais repetiçõ es, e uma frase entre
colchetes ([ ]) significa zero ou uma ocorrê ncia (em outras palavras, a frase anexada é opcional). Os operadores *
e + se ligam tã o forte quanto possível; parê ntesis sã o usados para o agrupamento. Os literais Strings sã o delimitados
por aspas. O espaço em branco só é significativo para separar os tokens. As regras normalmente estã o contidas numa
ú nica linha; as regras com muitas alternativas podem ser formatadas alternativamente com cada linha apó s o primeiro
começo com uma barra vertical.
Nas definiçõ es lé xicas (como o exemplo acima), sã o utilizadas mais duas convençõ es: dois caracteres literais sepa-
rados por trê s pontos significam a escolha de qualquer caractere ú nico na faixa (inclusiva) fornecida pelos caracteres
ASCII. Uma frase entre colchetes angulares (<...>) fornece uma descriçã o informal do símbolo definido; por exem-
plo, isso poderia ser usado para descrever a notaçã o de ‘caractere de controle’, caso fosse necessá rio.
Embora a notaçã o utilizada seja quase a mesma, há uma grande diferença entre o significado das definiçõ es lexicais
e sintá ticas: uma definiçã o lexical opera nos caracteres individuais da fonte de entrada, enquanto uma definiçã o de
sintaxe opera no fluxo de tokens gerados pelo analisador lé xico. Todos os usos do BNF no pró ximo capítulo (“Lexical
Analysis”) sã o definiçõ es lé xicas; os usos nos capítulos subsequentes sã o definiçõ es sintá ticas.

4 Capítulo 1. Introdução
 CAPÍTULO 2

Análise léxica

Um programa Python é lido por um analisador. A entrada para o analisador é um fluxo de tokens, gerado pelo
analisador léxico. Este capítulo descreve como o analisador lé xico divide um arquivo em tokens.
Python lê o texto do programa como pontos de có digo Unicode; a codificaçã o de um arquivo de origem pode ser
fornecida por uma declaraçã o de codificaçã o que por padrã o é UTF-8, consulte PEP 3120 para obter detalhes. Se o
arquivo de origem nã o puder ser decodificado, uma exceçã o SyntaxError será levantada.

2.1 Estrutura das linhas

Um programa Python é dividido em uma sé rie de linhas lógicas.

2.1.1 Linhas lógicas

O fim de uma linha ló gica é representado pelo token NEWLINE. As declaraçõ es nã o podem cruzar os limites da
linha ló gica, exceto onde NEWLINE for permitido pela sintaxe (por exemplo, entre as declaraçõ es de declaraçõ es
compostas). Uma linha ló gica é construída a partir de uma ou mais linhas físicas seguindo as regras explícitas ou
implícitas que juntam as linhas.

2.1.2 Linhas físicas

Uma linha física é uma sequê ncia de caracteres terminada por uma sequê ncia de fim de linha. Nos arquivos de origem
e cadeias de caracteres, qualquer uma das sequê ncias de terminaçã o de linha de plataforma padrã o pode ser usada -
o formato Unix usando ASCII LF (linefeed), o formato Windows usando a sequê ncia ASCII CR LF (return seguido
de linefeed) ou o antigo formato Macintosh usando o caractere ASCII CR (return). Todos esses formatos podem
ser usados igualmente, independentemente da plataforma. O final da entrada també m serve como um finalizador
implícito para a linha física final.
Ao incorporar o Python, strings de có digo-fonte devem ser passadas para APIs do Python usando as convençõ es C
padrã o para caracteres de nova linha (o caractere \n, representando ASCII LF, será o terminador de linha).

2.1.3 Comentários
Um comentá rio inicia com um caracter cerquilha (#) que nã o é parte de uma string literal, e termina com o fim da
linha física. Um comentá rio significa o fim da linha ló gica a menos que regras de junçã o de linha implicitas sejam
invocadas. Comentá rios sã o ignorados pela sintaxe.

5
The Python Language Reference, Release 3.13.0

2.1.4 Declarações de codificação

Se um comentá rio na primeira ou segunda linha de um script Python corresponde com a expressã o regular
coding[=:]\s*([-\w.]+), esse comentá rio é processado com uma declaraçã o de codificaçã o; o primeiro grupo
dessa expressã o indica a codificaçã o do arquivo do có digo-fonte. A declaraçã o de codificaçã o deve aparecer em
uma linha exclusiva para tal. Se está na segunda linha, a primeira linha també m deve ser uma linha somente com
comentá rio. As formas recomendadas de uma declaraçã o de codificaçã o sã o:

# -*- coding: <nome-codificação> -*-

que é reconhecido també m por GNU Emacs, e

# vim:fileencoding=<nome-codificação>

que é reconhecido pelo VIM de Bram Moolenaar.

Se nenhuma codificaçã o é declarada, a codificaçã o padrã o é UTF-8. Se a codificaçã o implícita ou explícita de um
arquivo é UTF-8, uma marca inicial de ordem de byte UTF-8 (b’xefxbbxbf’) será ignorada em vez de ser um erro de
sintaxe.
Se uma codificaçã o é declarada, o nome da codificaçã o deve ser reconhecida pelo Python (veja standard-encodings).
A codificaçã o é usada por toda aná lise lé xica, incluindo literais strings, comment and identificadores.

2.1.5 Junção de linha explícita

Duas ou mais linhas físicas podem ser juntadas em linhas ló gicas usando o caractere contrabarra (\) da seguinte
forma: quando uma linha física termina com uma contrabarra que nã o é parte da uma literal string ou comentá rio,
ela é juntada com a linha seguinte formando uma ú nica linha ló gica, removendo a contrabarra e o caractere de fim
de linha seguinte. Por exemplo:

if 1900 < year < 2100 and 1 <= month <= 12 \

and 1 <= day <= 31 and 0 <= hour < 24 \
and 0 <= minute < 60 and 0 <= second < 60: # Parece ser uma data válida
return 1

Uma linha terminada em uma contrabarra nã o pode conter um comentá rio. Uma barra invertida nã o continua um
comentá rio. Uma contrabarra nã o continua um token, exceto para strings literais (ou seja, tokens diferentes de strings
literais nã o podem ser divididos em linhas físicas usando uma contrabarra). Uma contrabarra é ilegal em qualquer
outro lugar em uma linha fora de uma string literal.

2.1.6 Junção de linha implícita

Expressõ es entre parê nteses, colchetes ou chaves podem ser quebradas em mais de uma linha física sem a necessidade
do uso de contrabarras. Por exemplo:

month_names = ['Januari', 'Februari', 'Maart', # Estes são os

'April', 'Mei', 'Juni', # nomes holandeses
'Juli', 'Augustus', 'September', # para os meses
'Oktober', 'November', 'December'] # do ano

Linhas continuadas implicitamente podem conter comentá rios. O recuo das linhas de continuaçã o nã o é importante.
Linhas de continuaçã o em branco sã o permitidas. Nã o há token NEWLINE entre linhas de continuaçã o implícitas.
Linhas continuadas implicitamente també m podem ocorrer dentro de strings com aspas triplas (veja abaixo); nesse
caso, eles nã o podem conter comentá rios.

2.1.7 Linhas em branco

Uma linha ló gica que conté m apenas espaços, tabulaçõ es, quebras de pá gina e possivelmente um comentá rio é ig-
norada (ou seja, nenhum token NEWLINE é gerado). Durante a entrada interativa de instruçõ es, o tratamento de

6 Capítulo 2. Análise léxica

 The Python Language Reference, Release 3.13.0

uma linha em branco pode diferir dependendo da implementaçã o do interpretador. No interpretador interativo pa-
drã o, uma linha ló gica totalmente em branco (ou seja, uma que nã o contenha nem mesmo espaço em branco ou um
comentá rio) encerra uma instruçã o de vá rias linhas.

2.1.8 Indentação
O espaço em branco (espaços e tabulaçõ es) no início de uma linha ló gica é usado para calcular o nível de indentaçã o
da linha, que por sua vez é usado para determinar o agrupamento de instruçõ es.
As tabulaçõ es sã o substituídas (da esquerda para a direita) por um a oito espaços, de modo que o nú mero total de
caracteres até e incluindo a substituiçã o seja um mú ltiplo de oito (essa é intencionalmente a mesma regra usada
pelo Unix). O nú mero total de espaços que precedem o primeiro caractere nã o em branco determina o recuo da
linha. O recuo nã o pode ser dividido em vá rias linhas físicas usando contrabarra; o espaço em branco até a primeira
contrabarra determina a indentaçã o.
A indentaçã o é rejeitada como inconsistente se um arquivo de origem mistura tabulaçõ es e espaços de uma forma
que torna o significado dependente do valor de uma tabulaçã o em espaços; uma exceçã o TabError é levantada nesse
caso.
Nota de compatibilidade entre plataformas: devido à natureza dos editores de texto em plataformas nã o-UNIX,
nã o é aconselhá vel usar uma mistura de espaços e tabulaçõ es para o recuo em um ú nico arquivo de origem. Deve-se
notar també m que diferentes plataformas podem limitar explicitamente o nível má ximo de indentaçã o.
Um caractere de quebra de pá gina pode estar presente no início da linha; ele será ignorado para os cá lculos de
indentaçã o acima. Os caracteres de quebra de pá gina que ocorrem em outro lugar alé m do espaço em branco inicial
tê m um efeito indefinido (por exemplo, eles podem redefinir a contagem de espaços para zero).
Os níveis de indentaçã o das linhas consecutivas sã o usados para gerar tokens INDENT e DEDENT, usando uma
pilha, como segue.
Antes da leitura da primeira linha do arquivo, um ú nico zero é colocado na pilha; isso nunca mais será exibido. Os
nú meros colocados na pilha sempre aumentarã o estritamente de baixo para cima. No início de cada linha ló gica, o
nível de indentaçã o da linha é comparado ao topo da pilha. Se for igual, nada acontece. Se for maior, ele é colocado
na pilha e um token INDENT é gerado. Se for menor, deve ser um dos nú meros que aparecem na pilha; todos os
nú meros maiores na pilha sã o retirados e, para cada nú mero retirado, um token DEDENT é gerado. Ao final do
arquivo, um token DEDENT é gerado para cada nú mero restante na pilha que seja maior que zero.
Aqui está um exemplo de um trecho de có digo Python indentado corretamente (embora confuso):

def perm(l):
# Calcula a lista de todas as permutações de l
if len(l) <= 1:
return [l]
r = []
for i in range(len(l)):
s = l[:i] + l[i+1:]
p = perm(s)
for x in p:
[Link](l[i:i+1] + x)
return r

O exemplo a seguir mostra vá rios erros de indentaçã o:

def perm(l): # erro: primeira linha indentada

for i in range(len(l)): # erro: não indentada
s = l[:i] + l[i+1:]
p = perm(l[:i] + l[i+1:]) # erro: indentação inesperada
for x in p:
[Link](l[i:i+1] + x)
return r # erro: desindentação inconsistente

2.1. Estrutura das linhas 7

The Python Language Reference, Release 3.13.0

(Na verdade, os trê s primeiros erros sã o detectados pelo analisador sintá tico; apenas o ú ltimo erro é encontrado pelo
analisador lé xico — o recuo de nã o corresponde a um nível retirado da pilha.)

2.1.9 Espaços em branco entre tokens

Exceto no início de uma linha ló gica ou em string literais, os caracteres de espaço em branco (espaço, tabulaçã o e
quebra de pá gina) podem ser usados alternadamente para separar tokens. O espaço em branco é necessá rio entre dois
tokens somente se sua concatenaçã o puder ser interpretada como um token diferente (por exemplo, ab é um token,
mas a b sã o dois tokens).

2.2 Outros tokens

Alé m de NEWLINE, INDENT e DEDENT, existem as seguintes categorias de tokens: identificadores, palavras-
-chave, literais, operadores e delimitadores. Caracteres de espaço em branco (exceto terminadores de linha, discutidos
anteriormente) nã o sã o tokens, mas servem para delimitar tokens. Onde existe ambiguidade, um token compreende
a string mais longa possível que forma um token legal, quando lido da esquerda para a direita.

2.3 Identificadores e palavras-chave

Identificadores (també m chamados de nomes) sã o descritos pelas seguintes definiçõ es lexicais.
A sintaxe dos identificadores em Python é baseada no anexo do padrã o Unicode UAX-31, com elaboraçã o e alteraçõ es
conforme definido abaixo; veja també m PEP 3131 para mais detalhes.
Dentro do intervalo ASCII (U+0001..U+007F), os caracteres vá lidos para identificadores incluem as letras maiú sculas
e minú sculas A a Z, o sublinhado _ e, exceto pelo primeiro caractere, os dígitos 0 a 9. O Python 3.0 introduziu
caracteres adicionais de fora do intervalo ASCII (veja PEP 3131). Para esses caracteres, a classificaçã o usa a versã o
do Unicode Character Database conforme incluído no mó dulo unicodedata.
Os identificadores tê m comprimento ilimitado. Maiú sculas sã o diferentes de minú sculas.

identifier ::= xid_start xid_continue*

id_start ::= <all characters in general categories Lu, Ll, Lt, Lm, Lo, Nl, the underscore,
id_continue ::= <all characters in id_start, plus characters in the categories Mn, Mc, Nd, Pc
xid_start ::= <all characters in id_start whose NFKC normalization is in "id_start xid_cont
xid_continue ::= <all characters in id_continue whose NFKC normalization is in "id_continue*">

Os có digos de categoria Unicode mencionados acima significam:

• Lu - letras maiú sculas
• Ll - letras minú sculas
• Lt - letras em titlecase
• Lm - letras modificadoras
• Lo - outras letras
• Nl - letras numé ricas
• Mn - marcas sem espaçamento
• Mc - marcas de combinaçã o de espaçamento
• Nd - nú meros decimais
• Pc - pontuaçõ es de conectores
• Other_ID_Start - lista explícita de caracteres em [Link] para oferecer suporte à compatibilidade com
versõ es anteriores
• Other_ID_Continue - igualmente

8 Capítulo 2. Análise léxica

 The Python Language Reference, Release 3.13.0

Todos os identificadores sã o convertidos no formato normal NFKC durante a aná lise; a comparaçã o de identificadores
é baseada no NFKC.
Um arquivo HTML nã o normativo listando todos os caracteres identificadores vá lidos para Unicode 15.1.0 pode ser
encontrado em [Link]

2.3.1 Palavras reservadas

Os seguintes identificadores sã o usados como palavras reservadas, ou palavras-chave da linguagem, e nã o podem ser
usados como identificadores comuns. Eles devem ser escritos exatamente como estã o escritos aqui:

False await else import pass

None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield

2.3.2 Palavras reservadas contextuais

Adicionado na versã o 3.10.
Alguns identificadores sã o reservados apenas em contextos específicos. Elas sã o conhecidas como palavras reservadas
contextuais. Os identificadores match, case, type e _ podem atuar sintaticamente como palavras reservadas em
determinados contextos, mas essa distinçã o é feita no nível do analisador sintá tico, nã o durante a tokenizaçã o.
Como palavras reservadas contextuais, seu uso na gramá tica é possível preservando a compatibilidade com o có digo
existente que usa esses nomes como identificadores.
match, case e _ sã o usadas na instruçã o match, type é usado na instruçã o type.

Alterado na versã o 3.12: type é agora uma palavra reservada contextual.

2.3.3 Classes reservadas de identificadores

Certas classes de identificadores (alé m de palavras reservadas) possuem significados especiais. Essas classes sã o
identificadas pelos padrõ es de caracteres de sublinhado iniciais e finais:
_*
Nã o importado por from module import *.
_
Em um padrã o case de uma instruçã o match, _ é uma palavra reservada contextual que denota um curinga.
Isoladamente, o interpretador interativo disponibiliza o resultado da ú ltima avaliaçã o na variá vel _. (Ele é
armazenado no mó dulo builtins, juntamente com funçõ es embutidas como print.)
Em outros lugares, _ é um identificador comum. Muitas vezes é usado para nomear itens “especiais”, mas nã o
é especial para o Python em si.

® Nota

O nome _ é frequentemente usado em conjunto com internacionalizaçã o; consulte a documentaçã o do

mó dulo gettext para obter mais informaçõ es sobre esta convençã o.
També m é comumente usado para variá veis nã o utilizadas.

__*__
Nomes definidos pelo sistema, informalmente conhecidos como nomes “dunder”. Esses nomes e suas imple-
mentaçõ es sã o definidos pelo interpretador (incluindo a biblioteca padrã o). Os nomes de sistema atuais sã o

2.3. Identificadores e palavras-chave 9

The Python Language Reference, Release 3.13.0

discutidos na seçã o Nomes de métodos especiais e em outros lugares. Provavelmente mais nomes serã o defini-
dos em versõ es futuras do Python. Qualquer uso de nomes __*__, em qualquer contexto, que nã o siga o uso
explicitamente documentado, está sujeito a quebra sem aviso pré vio.
__*
Nomes de classes privadas. Os nomes nesta categoria, quando usados no contexto de uma definiçã o de classe,
sã o reescritos para usar uma forma desfigurada para ajudar a evitar conflitos de nomes entre atributos “privados”
de classes base e derivadas. Consulte a seçã o Identificadores (Nomes).

2.4 Literais
Literais sã o notaçõ es para valores constantes de alguns tipos embutidos.

2.4.1 Literais de string e bytes

Literais de string sã o descritos pelas seguintes definiçõ es lexicais:

stringliteral ::= [stringprefix](shortstring | longstring)

stringprefix ::= "r" | "u" | "R" | "U" | "f" | "F"
| "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF"
shortstring ::= "'" shortstringitem* "'" | '"' shortstringitem* '"'
longstring ::= "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
shortstringitem ::= shortstringchar | stringescapeseq
longstringitem ::= longstringchar | stringescapeseq
shortstringchar ::= <any source character except "\" or newline or the quote>
longstringchar ::= <any source character except "\">
stringescapeseq ::= "\" <any source character>

bytesliteral ::= bytesprefix(shortbytes | longbytes)

bytesprefix ::= "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB"
shortbytes ::= "'" shortbytesitem* "'" | '"' shortbytesitem* '"'
longbytes ::= "'''" longbytesitem* "'''" | '"""' longbytesitem* '"""'
shortbytesitem ::= shortbyteschar | bytesescapeseq
longbytesitem ::= longbyteschar | bytesescapeseq
shortbyteschar ::= <any ASCII character except "\" or newline or the quote>
longbyteschar ::= <any ASCII character except "\">
bytesescapeseq ::= "\" <any ASCII character>

Uma restriçã o sintá tica nã o indicada por essas produçõ es é que nã o sã o permitidos espaços em branco entre o
stringprefix ou bytesprefix e o restante do literal. O conjunto de caracteres de origem é definido pela
declaraçã o de codificaçã o; é UTF-8 se nenhuma declaraçã o de codificaçã o for fornecida no arquivo de origem; veja
a seçã o Declarações de codificação.
Em inglê s simples: ambos os tipos de literais podem ser colocados entre aspas simples (') ou aspas duplas ("). Eles
també m podem ser colocados em grupos correspondentes de trê s aspas simples ou duplas (geralmente chamadas
de strings com aspas triplas). O caractere de contrabarra (\) é usado para dar um significado especial a caracteres
comuns como , que significa ‘nova linha’ quando escapado (\n). També m pode ser usado para caracteres de escape
que, de outra forma, teriam um significado especial, como nova linha, contrabarra ou o caractere de aspas. Veja
sequências de escape abaixo para exemplos.
Literais de bytes sã o sempre prefixados com 'b' ou 'B'; eles produzem uma instâ ncia do tipo bytes em vez do tipo
str. Eles só podem conter caracteres ASCII; bytes com valor numé rico igual ou superior a 128 devem ser expressos
com escapes.
Literais de string e bytes podem opcionalmente ser prefixados com uma letra 'r' ou 'R'; tais construçõ es sã o
chamadas de literais de strings brutas e literais de bytes brutos tratam as contrabarras como caracteres literais. Como
resultado, em literais de string, os escapes '\U' e '\u' em strings brutas nã o sã o tratados de maneira especial.

10 Capítulo 2. Análise léxica

 The Python Language Reference, Release 3.13.0

Adicionado na versã o 3.3: O prefixo 'rb' de literais de bytes brutos foi adicionado como sinô nimo de 'br'.
O suporte para o literal legado unicode (u'value') foi reintroduzido para simplificar a manutençã o de bases de
có digo duplas Python 2.x e 3.x. Consulte PEP 414 para obter mais informaçõ es.
Uma string literal com 'f' ou 'F' em seu prefixo é uma string literal formatada; veja Literais de strings formatadas.
O 'f' pode ser combinado com 'r', mas nã o com 'b' ou 'u', portanto strings formatadas brutas sã o possíveis,
mas literais de bytes formatados nã o sã o.
Em literais com aspas triplas, novas linhas e aspas sem escape sã o permitidas (e sã o retidas), exceto que trê s aspas
sem escape em uma linha encerram o literal. (Uma “aspas” é o caractere usado para abrir o literal, ou seja, ' ou ".)

Sequências de escape
A menos que um prefixo 'r' ou 'R' esteja presente, as sequê ncias de escape em literais de string e bytes sã o inter-
pretadas de acordo com regras semelhantes à quelas usadas pelo Standard C. As sequê ncias de escape reconhecidas
sã o:

Sequência de escape Significado Notas

\<newline> A barra invertida e a nova linha foram ignoradas (1)
\\ Contrabarra (\)
\' Aspas simples (')
\" Aspas duplas (")
\a ASCII Bell (BEL) - um sinal audível é emitido
\b ASCII Backspace (BS) - apaga caractere à esquerda
\f ASCII Formfeed (FF) - quebra de pá gina
\n ASCII Linefeed (LF) - quebra de linha
\r ASCII Carriage Return (CR) - retorno de carro
\t ASCII Horizontal Tab (TAB) - tabulaçã o horizontal
\v ASCII Vertical Tab (VT) - tabulaçã o vertical
\ooo Caractere com valor octal ooo (2,4)
\xhh Caractere com valor hexadecimal hh (3,4)

As sequê ncias de escape apenas reconhecidas em literais de strings sã o:

Sequência de escape Significado Notas

\N{name} Caractere chamado name no banco de dados Unicode (5)
\uxxxx Caractere com valor hexadecimal de 16 bits xxxx (6)
\Uxxxxxxxx Caractere com valor hexadecimal de 32 bits xxxxxxxx (7)

Notas:
(1) Uma contrabarra pode ser adicionada ao fim da linha para ignorar a nova linha:

>>> 'Esta string não vai incluir \

... contrabarras e caracteres de nova linha.'
'Esta string não vai incluir contrabarras e caracteres de nova linha.'

O mesmo resultado pode ser obtido usando strings com aspas triplas, ou parê nteses e concatenação de literal
string.
(2) Como no padrã o C, sã o aceitos até trê s dígitos octais.
Alterado na versã o 3.11: Escapes octais com valor maior que 0o377 produz uma DeprecationWarning.
Alterado na versã o 3.12: Escapes octais com valor maior que 0o377 produzem um SyntaxWarning. Em
uma versã o futura do Python eles serã o eventualmente um SyntaxError.
(3) Ao contrá rio do padrã o C, sã o necessá rios exatamente dois dígitos hexadecimais.

2.4. Literais 11
The Python Language Reference, Release 3.13.0

(4) Em um literal de bytes, os escapes hexadecimais e octais denotam o byte com o valor fornecido. Em uma
literal de string, esses escapes denotam um caractere Unicode com o valor fornecido.
(5) Alterado na versã o 3.3: O suporte para apelidos de nome1 foi adicionado.
(6) Sã o necessá rios exatos quatro dígitos hexadecimais.
(7) Qualquer caractere Unicode pode ser codificado desta forma. Sã o necessá rios exatamente oito dígitos hexa-
decimais.
Ao contrá rio do padrã o C, todas as sequê ncias de escape nã o reconhecidas sã o deixadas inalteradas na string, ou
seja, a contrabarra é deixada no resultado. (Esse comportamento é ú til durante a depuraçã o: se uma sequê ncia de
escape for digitada incorretamente, a saída resultante será mais facilmente reconhecida como quebrada.) També m é
importante observar que as sequê ncias de escape reconhecidas apenas em literais de string se enquadram na categoria
de escapes nã o reconhecidos para literais de bytes.
Alterado na versã o 3.6: Sequê ncias de escape nã o reconhecidas produzem um DeprecationWarning.
Alterado na versã o 3.12: Sequê ncias de escape nã o reconhecidas produzem um SyntaxWarning. Em uma versã o
futura do Python eles serã o eventualmente um SyntaxError.
Mesmo em um literal bruto, as aspas podem ser escapadas com uma contrabarra, mas a barra invertida permanece
no resultado; por exemplo, r"\"" é uma literal de string vá lida que consiste em dois caracteres: uma contrabarra e
aspas duplas; r"\" nã o é uma literal de string vá lida (mesmo uma string bruta nã o pode terminar em um nú mero
ímpar de contrabarras). Especificamente, um literal bruto não pode terminar em uma única contrabarra (já que a
contrabarra escaparia do seguinte caractere de aspas). Observe també m que uma ú nica contrabarra seguida por uma
nova linha é interpretada como esses dois caracteres como parte do literal, não como uma continuaçã o de linha.

2.4.2 Concatenação de literal de string

Sã o permitidos vá rios literais de strings ou bytes adjacentes (delimitados por espaços em branco), possivelmente
usando diferentes convençõ es de delimitaçã o de strings, e seu significado é o mesmo de sua concatenaçã o. Assim,
"hello" 'world' é equivalente a "helloworld". Este recurso pode ser usado para reduzir o nú mero de barras
invertidas necessá rias, para dividir strings longas convenientemente em linhas longas ou até mesmo para adicionar
comentá rios a partes de strings, por exemplo:

[Link]("[A-Za-z_]" # letra ou sublinhado

"[A-Za-z0-9_]*" # letra, dígito ou sublinhado
)

Observe que esse recurso é definido no nível sintá tico, mas implementado em tempo de compilaçã o. O operador ‘+’
deve ser usado para concatenar expressõ es de string em tempo de execuçã o. Observe també m que a concatenaçã o
literal pode usar diferentes estilos de delimitaçã o de strings para cada componente (mesmo misturando strings brutas
e strings com aspas triplas), e literais de string formatados podem ser concatenados com literais de string simples.

2.4.3 Literais de strings formatadas

Adicionado na versã o 3.6.
Um literal de string formatado ou f-string é uma literal de string prefixado com 'f' ou 'F'. Essas strings podem
conter campos de substituiçã o, que sã o expressõ es delimitadas por chaves {}. Embora outros literais de string sempre
tenham um valor constante, strings formatadas sã o, na verdade, expressõ es avaliadas em tempo de execuçã o.
As sequê ncias de escape sã o decodificadas como em literais de string comuns (exceto quando um literal també m é
marcado como uma string bruta). Apó s a decodificaçã o, a gramá tica do conteú do da string é :

f_string ::= (literal_char | "{{" | "}}" | replacement_field)*

replacement_field ::= "{" f_expression ["="] ["!" conversion] [":" format_spec] "}"
f_expression ::= (conditional_expression | "*" or_expr)
("," conditional_expression | "," "*" or_expr)* [","]

1 [Link]

12 Capítulo 2. Análise léxica

 The Python Language Reference, Release 3.13.0

| yield_expression
conversion ::= "s" | "r" | "a"
format_spec ::= (literal_char | replacement_field)*
literal_char ::= <any code point except "{", "}" or NULL>

As partes da string fora das chaves sã o tratadas literalmente, exceto que quaisquer chaves duplas '{{' ou '}}' sã o
substituídas pela chave ú nica correspondente. Uma ú nica chave de abertura '{' marca um campo de substituiçã o, que
começa com uma expressã o Python. Para exibir o texto da expressã o e seu valor apó s a avaliaçã o (ú til na depuraçã o),
um sinal de igual '=' pode ser adicionado apó s a expressã o. Um campo de conversã o, introduzido por um ponto de
exclamaçã o '!', pode vir a seguir. Um especificador de formato també m pode ser anexado, introduzido por dois
pontos ':'. Um campo de substituiçã o termina com uma chave de fechamento '}'.
Expressõ es em literais de string formatadas sã o tratadas como expressõ es regulares do Python entre parê nteses, com
algumas exceçõ es. Uma expressã o vazia nã o é permitida e as expressõ es lambda e de atribuiçã o := devem ser
colocadas entre parê nteses explícitos. Cada expressã o é avaliada no contexto onde o literal de string formatado
aparece, na ordem da esquerda para a direita. As expressõ es de substituiçã o podem conter novas linhas em strings
formatadas entre aspas simples e triplas e podem conter comentá rios. Tudo o que vem depois de um # dentro de
um campo de substituiçã o é um comentá rio (até mesmo colchetes e aspas). Nesse caso, os campos de substituiçã o
deverã o ser fechados em uma linha diferente.

>>> f"abc{a # Este é um comentário }"

... + 3}"
'abc5'

Alterado na versã o 3.7: Antes do Python 3.7, uma expressã o await e compreensõ es contendo uma clá usula async
for eram ilegais nas expressõ es em literais de string formatados devido a um problema com a implementaçã o.

Alterado na versã o 3.12: Antes do Python 3.12, comentá rios nã o eram permitidos dentro de campos de substituiçã o
em f-strings.
Quando o sinal de igual '=' for fornecido, a saída terá o texto da expressã o, o '=' e o valor avaliado. Os espaços
apó s a chave de abertura '{', dentro da expressã o e apó s '=' sã o todos preservados na saída. Por padrã o, '=' faz
com que repr() da expressã o seja fornecida, a menos que haja um formato especificado. Quando um formato é
especificado, o padrã o é o str() da expressã o, a menos que uma conversã o '!r' seja declarada.
Adicionado na versã o 3.8: O sinal de igual '='.
Se uma conversã o for especificada, o resultado da avaliaçã o da expressã o será convertido antes da formataçã o. A
conversã o '!s' chama str() no resultado, '!r' chama repr() e '!a' chama ascii().
O resultado é entã o formatado usando o protocolo format(). O especificador de formato é passado para o mé todo
__format__() da expressã o ou resultado da conversã o. Uma string vazia é passada quando o especificador de
formato é omitido. O resultado formatado é entã o incluído no valor final de toda a string.
Os especificadores de formato de nível superior podem incluir campos de substituiçã o aninhados. Esses campos
aninhados podem incluir seus pró prios campos de conversã o e especificadores de formato, mas podem nã o incluir
campos de substituiçã o aninhados mais profundamente. A minilinguagem do especificador de formato é a mesma
usada pelo mé todo [Link]().
Literais de string formatados podem ser concatenados, mas os campos de substituiçã o nã o podem ser divididos entre
literais.
Alguns exemplos de literais de string formatados:

>>> nome = "Fred"

>>> f"Ele falou que o nome dele é {nome!r}."
"Ele falou que o nome dele é 'Fred'."
>>> f"Ele falou que o nome dele é {repr(nome)}." # repr() é um equivalente a !r
"Ele falou que o nome dele é 'Fred'."
>>> largura = 10
>>> precisão = 4
>>> valor = [Link]("12.34567")
(continua na pró xima pá gina)

2.4. Literais 13
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> f"resultado: {valor:{largura}.{precisão}}" # campos aninhados
'resultado: 12.35'
>>> hoje = datetime(year=2017, month=1, day=27)
>>> f"{hoje:%B %d, %Y}" # usando especificador de formato de data
'January 27, 2017'
>>> f"{hoje=:%B %d, %Y}" # usando especificador de formato de data e depuração
'hoje=January 27, 2017'
>>> número = 1024
>>> f"{número:#0x}" # usando especificador de formato de número inteiro
'0x400'
>>> foo = "bar"
>>> f"{ foo = }" # preserva espaço em branco
" foo = 'bar'"
>>> linha = "Olha a caixa d'água"
>>> f"{linha = }"
'linha = "Olha a caixa d\'água"'
>>> f"{linha = :20}"
"linha = Olha a caixa d'água "
>>> f"{linha = !r:20}"
'linha = "Olha a caixa d\'água"'

É permitido reutilizar o tipo de aspas de f-string externa dentro de um campo de substituiçã o:

>>> a = dict(x=2)
>>> f"abc {a["x"]} def"
'abc 2 def'

Alterado na versã o 3.12: Antes do Python 3.12, a reutilizaçã o do mesmo tipo de aspas da f-string externa dentro de
um campo de substituiçã o nã o era possível.
Contrabarras també m sã o permitidas em campos de substituiçã o e sã o avaliadas da mesma forma que em qualquer
outro contexto:

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

>>> print(f"A lista a contém:\n{"\n".join(a)}")
A lista a contém:
a
b
c

Alterado na versã o 3.12: Antes do Python 3.12, contrabarras nã o eram permitidas dentro de um campo de substi-
tuiçã o em uma f-string.
Literais de string formatados nã o podem ser usados como strings de documentaçã o, mesmo que nã o incluam expres-
sõ es.

>>> def foo():

... f"Não é uma docstring"
...
>>> foo.__doc__ is None
True

Consulte també m PEP 498 para a proposta que adicionou literais de string formatados e [Link](), que usa
um mecanismo de string de formato relacionado.

14 Capítulo 2. Análise léxica

 The Python Language Reference, Release 3.13.0

2.4.4 Literais numéricos

Existem trê s tipos de literais numé ricos: inteiros, nú meros de ponto flutuante e nú meros imaginá rios. Nã o existem
literais complexos (nú meros complexos podem ser formados adicionando um nú mero real e um nú mero imaginá rio).
Observe que os literais numé ricos nã o incluem um sinal; uma frase como -1 é , na verdade, uma expressã o composta
pelo operador uná rio ‘-2’ e o literal 1.

2.4.5 Inteiros literais

Literais inteiros sã o descritos pelas seguintes definiçõ es lé xicas:

integer ::= decinteger | bininteger | octinteger | hexinteger

decinteger ::= nonzerodigit (["_"] digit)* | "0"+ (["_"] "0")*
bininteger ::= "0" ("b" | "B") (["_"] bindigit)+
octinteger ::= "0" ("o" | "O") (["_"] octdigit)+
hexinteger ::= "0" ("x" | "X") (["_"] hexdigit)+
nonzerodigit ::= "1"..."9"
digit ::= "0"..."9"
bindigit ::= "0" | "1"
octdigit ::= "0"..."7"
hexdigit ::= digit | "a"..."f" | "A"..."F"

Nã o há limite para o comprimento de literais inteiros alé m do que pode ser armazenado na memó ria disponível.
Os sublinhados sã o ignorados para determinar o valor numé rico do literal. Eles podem ser usados para agrupar dígitos
para maior legibilidade. Um sublinhado pode ocorrer entre dígitos e apó s especificadores de base como 0x.
Observe que nã o sã o permitidos zeros à esquerda em um nú mero decimal diferente de zero. Isto é para desambiguaçã o
com literais octais de estilo C, que o Python usava antes da versã o 3.0.
Alguns exemplos de literais inteiros:

7 2147483647 0o177 0b100110111

3 79228162514264337593543950336 0o377 0xdeadbeef
100_000_000_000 0b_1110_0101

Alterado na versã o 3.6: Os sublinhados agora sã o permitidos para fins de agrupamento de literais.

2.4.6 Literais de ponto flutuante

Literais de ponto flutuante sã o descritos pelas seguintes definiçõ es lé xicas:

floatnumber ::= pointfloat | exponentfloat

pointfloat ::= [digitpart] fraction | digitpart "."
exponentfloat ::= (digitpart | pointfloat) exponent
digitpart ::= digit (["_"] digit)*
fraction ::= "." digitpart
exponent ::= ("e" | "E") ["+" | "-"] digitpart

Observe que as partes inteiras e expoentes sã o sempre interpretadas usando base 10. Por exemplo, 077e010 é
vá lido e representa o mesmo nú mero que 77e10. O intervalo permitido de literais de ponto flutuante depende da
implementaçã o. Assim como em literais inteiros, os sublinhados sã o permitidos para agrupamento de dígitos.
Alguns exemplos de literais de ponto flutuante:

3.14 10. .001 1e100 3.14e-10 0e0 3.14_15_93

Alterado na versã o 3.6: Os sublinhados agora sã o permitidos para fins de agrupamento de literais.

2.4. Literais 15
The Python Language Reference, Release 3.13.0

2.4.7 Literais imaginários

Os literais imaginá rios sã o descritos pelas seguintes definiçõ es lé xicas:

imagnumber ::= (floatnumber | digitpart) ("j" | "J")

Um literal imaginá rio produz um nú mero complexo com uma parte real igual a 0.0. Os nú meros complexos sã o
representados como um par de nú meros de ponto flutuante e tê m as mesmas restriçõ es em seu alcance. Para criar um
nú mero complexo com uma parte real diferente de zero, adicione um nú mero de ponto flutuante a ele, por exemplo,
(3+4j). Alguns exemplos de literais imaginá rios:

3.14j 10.j 10j .001j 1e100j 3.14e-10j 3.14_15_93j

2.5 Operadores
Os seguintes tokens sã o operadores:

+ - * ** / // % @
<< >> & | ^ ~ :=
< > <= >= == !=

2.6 Delimitadores
Os seguintes tokens servem como delimitadores na gramá tica:

( ) [ ] { }
, : ! . ; @ =
-> += -= *= /= //= %=
@= &= |= ^= >>= <<= **=

O ponto també m pode ocorrer em literais de ponto flutuante e imaginá rio. Uma sequê ncia de trê s períodos tem
um significado especial como um literal de reticê ncias. A segunda metade da lista, os operadores de atribuiçã o
aumentada, servem lexicalmente como delimitadores, mas també m realizam uma operaçã o.
Os seguintes caracteres ASCII imprimíveis tê m um significado especial como parte de outros tokens ou sã o signifi-
cativos para o analisador lé xico:

' " # \

Os seguintes caracteres ASCII imprimíveis nã o sã o usados em Python. Sua ocorrê ncia fora de literais de string e
comentá rios é um erro incondicional:

$ ? `

16 Capítulo 2. Análise léxica

 CAPÍTULO 3

Modelo de dados

3.1 Objetos, valores e tipos

Objetos sã o abstraçõ es do Python para dados. Todos os dados em um programa Python sã o representados por ob-
jetos ou por relaçõ es entre objetos. (De certo modo, e em conformidade com o modelo de Von Neumann de um
“computador com programa armazenado”, có digo també m é representado por objetos.)
Todo objeto tem uma identidade, um tipo e um valor. A identidade de um objeto nunca muda depois de criado; você
pode pensar nisso como endereço de objetos em memó ria. O operador is compara as identidades de dois objetos; a
funçã o id() retorna um inteiro representando sua identidade.
Detalhes da implementação do CPython: Para CPython, id(x) é o endereço de memó ria em que x está armaze-
nado.
O tipo de um objeto determina as operaçõ es que o objeto implementa (por exemplo, “ele tem um comprimento?”)
e també m define os valores possíveis para objetos desse tipo. A funçã o type() retorna o tipo de um objeto (que é
també m um objeto). Como sua identidade, o tipo do objeto també m é imutá vel.1
O valor de alguns objetos pode mudar. Objetos cujos valores podem mudar sã o descritos como mutáveis, objetos
cujo valor nã o pode ser mudado uma vez que foram criados sã o chamados imutáveis. (O valor de um objeto contê iner
imutá vel que conté m uma referê ncia a um objeto mutá vel pode mudar quando o valor deste ú ltimo for mudado; no
entanto o contê iner é ainda assim considerada imutá vel, pois a coleçã o de objetos que conté m nã o pode ser mudada.
Entã o a imutabilidade nã o é estritamente o mesmo do que nã o haver mudanças de valor, é mais sutil.) A mutabilidade
de um objeto é determinada pelo seu tipo; por exemplo, nú meros, strings e tuplas sã o imutá veis, enquanto dicioná rios
e listas sã o mutá veis.
Os objetos nunca sã o destruídos explicitamente; no entanto, quando eles se tornam inacessíveis, eles podem ser
coletados como lixo. Uma implementaçã o tem permissã o para adiar a coleta de lixo ou omiti-la completamente –
é uma questã o de detalhe de implementaçã o como a coleta de lixo é implementada, desde que nenhum objeto que
ainda esteja acessível seja coletado.
Detalhes da implementação do CPython: CPython atualmente usa um esquema de contagem de referê ncias com
detecçã o atrasada (opcional) de lixo ligado ciclicamente, que coleta a maioria dos objetos assim que eles se tornam
inacessíveis, mas nã o é garantido que coletará lixo contendo referê ncias circulares. Veja a documentaçã o do mó dulo
gc para informaçõ es sobre como controlar a coleta de lixo cíclico. Outras implementaçõ es agem de forma diferente
e o CPython pode mudar. Nã o dependa da finalizaçã o imediata dos objetos quando eles se tornarem inacessíveis
(isto é , você deve sempre fechar os arquivos explicitamente).
1 Em alguns casos, é possível alterar o tipo de um objeto, sob certas condiçõ es controladas. No entanto, geralmente nã o é uma boa ideia, pois

pode levar a um comportamento muito estranho se for tratado incorretamente.

17
The Python Language Reference, Release 3.13.0

Observe que o uso dos recursos de rastreamento ou depuraçã o da implementaçã o pode manter os objetos ativos que
normalmente seriam coletá veis. Observe també m que capturar uma exceçã o com uma instruçã o try …except pode
manter os objetos vivos.
Alguns objetos contê m referê ncias a recursos “externos”, como arquivos abertos ou janelas. Entende-se que esses
recursos sã o liberados quando o objeto é coletado como lixo, mas como a coleta de lixo nã o é garantida, tais ob-
jetos també m fornecem uma maneira explícita de liberar o recurso externo, geralmente um mé todo close(). Os
programas sã o fortemente recomendados para fechar explicitamente esses objetos. A instruçã o try …finally e a
instruçã o with fornecem maneiras convenientes de fazer isso.
Alguns objetos contê m referê ncias a outros objetos; eles sã o chamados de contêineres. Exemplos de contê ineres sã o
tuplas, listas e dicioná rios. As referê ncias fazem parte do valor de um contê iner. Na maioria dos casos, quando
falamos sobre o valor de um contê iner, nos referimos aos valores, nã o à s identidades dos objetos contidos; entretanto,
quando falamos sobre a mutabilidade de um contê iner, apenas as identidades dos objetos contidos imediatamente
estã o implícitas. Portanto, se um contê iner imutá vel (como uma tupla) conté m uma referê ncia a um objeto mutá vel,
seu valor muda se esse objeto mutá vel for alterado.
Os tipos afetam quase todos os aspectos do comportamento do objeto. Até mesmo a importâ ncia da identidade do
objeto é afetada em algum sentido: para tipos imutá veis, as operaçõ es que calculam novos valores podem realmente
retornar uma referê ncia a qualquer objeto existente com o mesmo tipo e valor, enquanto para objetos mutá veis isso
nã o é permitido. Por exemplo, apó s a = 1; b = 1, a e b podem ou nã o se referir ao mesmo objeto com o valor
um, dependendo da implementaçã o. Isto ocorre porque int é um tipo imutá vel, entã o a referê ncia a 1 pode ser
reutilizada. Este comportamento depende da implementaçã o usada, entã o nã o deve ser considerada confiá vel, mas
é algo para se estar ciente ao fazer uso de testes de identidade de objeto. No entanto, apó s c = []; d = [], c e
d tê m a garantia de referir-se a duas listas vazias diferentes e ú nicas. (Observe que e = f = [] atribui o mesmo
objeto para e e f.)

3.2 A hierarquia de tipos padrão

Abaixo está uma lista dos tipos que sã o embutidos no Python. Mó dulos de extensã o (escritos em C, Java ou ou-
tras linguagens, dependendo da implementaçã o) podem definir tipos adicionais. Versõ es futuras do Python podem
adicionar tipos à hierarquia de tipo (por exemplo, nú meros racionais, matrizes de inteiros armazenadas de forma
eficiente, etc.), embora tais adiçõ es sejam frequentemente fornecidas por meio da biblioteca padrã o.
Algumas das descriçõ es de tipo abaixo contê m um pará grafo listando “atributos especiais”. Esses sã o atributos que
fornecem acesso à implementaçã o e nã o se destinam ao uso geral. Sua definiçã o pode mudar no futuro.

3.2.1 None
Este tipo possui um ú nico valor. Existe um ú nico objeto com este valor. Este objeto é acessado atravé s do nome
embutido None. É usado para significar a ausê ncia de um valor em muitas situaçõ es, por exemplo, ele é retornado
de funçõ es que nã o retornam nada explicitamente. Seu valor verdade é falso.

3.2.2 NotImplemented
Este tipo possui um ú nico valor. Existe um ú nico objeto com este valor. Este objeto é acessado atravé s do nome
embutido NotImplemented. Os mé todos numé ricos e mé todos de comparaçã o rica devem retornar esse valor se
nã o implementarem a operaçã o para os operandos fornecidos. (O interpretador tentará entã o a operaçã o refletida ou
alguma outra alternativa, dependendo do operador.) Nã o deve ser avaliado em um contexto booleano.
Veja a documentaçã o implementing-the-arithmetic-operations para mais detalhes.
Alterado na versã o 3.9: A avaliaçã o de NotImplemented em um contexto booleano foi descontinuada. Em-
bora atualmente seja avaliada como verdadeiro, é emitida uma exceçã o DeprecationWarning. Levantará uma
TypeError em uma versã o futura do Python.

18 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

3.2.3 Ellipsis
Este tipo possui um ú nico valor. Existe um ú nico objeto com este valor. Este objeto é acessado atravé s do literal ...
ou do nome embutido Ellipsis (reticê ncias). Seu valor verdade é verdadeiro.

3.2.4 [Link]
Esses sã o criados por literais numé ricos e retornados como resultados por operadores aritmé ticos e funçõ es aritmé ti-
cas embutidas. Os objetos numé ricos sã o imutá veis; uma vez criado, seu valor nunca muda. Os nú meros do Python
sã o, obviamente, fortemente relacionados aos nú meros matemá ticos, mas sujeitos à s limitaçõ es da representaçã o
numé rica em computadores.
As representaçõ es de string das classes numé ricas, calculadas por __repr__() e __str__(), tê m as seguintes
propriedades:
• Elas sã o literais numé ricos vá lidos que, quando passados para seu construtor de classe, produzem um objeto
com o valor do numé rico original.
• A representaçã o está na base 10, quando possível.
• Os zeros à esquerda, possivelmente com exceçã o de um ú nico zero antes de um ponto decimal, nã o sã o mos-
trados.
• Os zeros à direita, possivelmente com exceçã o de um ú nico zero apó s um ponto decimal, nã o sã o mostrados.
• Um sinal é mostrado apenas quando o nú mero é negativo.
Python distingue entre inteiros, nú meros de ponto flutuante e nú meros complexos:

[Link]

Estes representam elementos do conjunto matemá tico de inteiros (positivos e negativos).

® Nota

As regras para representaçã o de inteiros tê m como objetivo fornecer a interpretaçã o mais significativa das ope-
raçõ es de deslocamento e má scara envolvendo inteiros negativos.

Existem dois tipos de inteiros:

Inteiros (int)
Estes representam nú meros em um intervalo ilimitado, sujeito apenas à memó ria (virtual) disponível. Para
o propó sito de operaçõ es de deslocamento e má scara, uma representaçã o biná ria é presumida e os nú meros
negativos sã o representados em uma variante do complemento de 2 que dá a ilusã o de uma string infinita de
bits de sinal estendendo-se para a esquerda.
Booleanos (bool)
Estes representam os valores da verdade Falsos e Verdadeiros. Os dois objetos que representam os valores
False e True sã o os ú nicos objetos booleanos. O tipo booleano é um subtipo do tipo inteiro, e os valores
booleanos se comportam como os valores 0 e 1, respectivamente, em quase todos os contextos, com exceçã o
de que, quando convertidos em uma string, as strings "False" ou "True" sã o retornados, respectivamente.

[Link] (float)

Estes representam nú meros de ponto flutuante de precisã o dupla no nível da má quina. Você está à mercê da arquite-
tura da má quina subjacente (e implementaçã o C ou Java) para o intervalo aceito e tratamento de estouro. Python nã o
oferece suporte a nú meros de ponto flutuante de precisã o ú nica; a economia no uso do processador e da memó ria,
que normalmente é o motivo de usá -los, é ofuscada pela sobrecarga do uso de objetos em Python, portanto, nã o há
razã o para complicar a linguagem com dois tipos de nú meros de ponto flutuante.

3.2. A hierarquia de tipos padrão 19

The Python Language Reference, Release 3.13.0

[Link] (complex)

Estes representam nú meros complexos como um par de nú meros de ponto flutuante de precisã o dupla no nível da
má quina. As mesmas advertê ncias se aplicam aos nú meros de ponto flutuante. As partes reais e imaginá rias de um
nú mero complexo z podem ser obtidas atravé s dos atributos somente leitura [Link] e [Link].

3.2.5 Sequências
Estes representam conjuntos ordenados finitos indexados por nú meros nã o negativos. A funçã o embutida len()
retorna o nú mero de itens de uma sequê ncia. Quando o comprimento de uma sequê ncia é n, o conjunto de índices
conté m os nú meros 0, 1, …, n-1. O item i da sequê ncia a é selecionado por a[i]. Algumas sequê ncias, incluindo
sequê ncias embutidas, interpretam subscritos negativos adicionando o comprimento da sequê ncia. Por exemplo,
a[-2] é igual a a[n-2], o penú ltimo item da sequê ncia a com comprimento n.
Sequê ncias també m provê fatiamento: a[i:j] seleciona todos os itens com índice k de forma que i <= k < j. Quando
usada como expressã o, uma fatia é uma sequê ncia do mesmo tipo. O comentá rio acima sobre índices negativos
també m se aplica a posiçõ es de fatias negativas.
Algumas sequê ncias també m suportam “fatiamento estendido” com um terceiro parâ metro de “etapa”: a[i:j:k]
seleciona todos os itens de a com índice x onde x = i + n*k, n >= 0 e i <= x < j.
As sequê ncias sã o distinguidas de acordo com sua mutabilidade:

Sequências imutáveis
Um objeto de um tipo de sequê ncia imutá vel nã o pode ser alterado depois de criado. (Se o objeto contiver referê ncias
a outros objetos, esses outros objetos podem ser mutá veis e podem ser alterados; no entanto, a coleçã o de objetos
diretamente referenciada por um objeto imutá vel nã o pode ser alterada.)
Os tipos a seguir sã o sequê ncias imutá veis:
Strings
Uma string é uma sequê ncia de valores que representam pontos de có digo Unicode. Todos os pontos de có digo
no intervalo U+0000 - U+10FFFF podem ser representados em uma string. Python nã o tem um tipo char;
em vez disso, cada ponto de có digo na string é representado como um objeto string com comprimento 1. A
funçã o embutida ord() converte um ponto de có digo de sua forma de string para um inteiro no intervalo 0
- 10FFFF; chr() converte um inteiro no intervalo 0 - 10FFFF para o objeto de string correspondente de
comprimento 1. [Link]() pode ser usado para converter uma str para bytes usando a codificaçã o
de texto fornecida, e [Link]() pode ser usado para conseguir o oposto.
Tuplas
Os itens de uma tupla sã o objetos Python arbitrá rios. Tuplas de dois ou mais itens sã o formadas por listas de
expressõ es separadas por vírgulas. Uma tupla de um item (um “singleton”) pode ser formada afixando uma
vírgula a uma expressã o (uma expressã o por si só nã o cria uma tupla, já que os parê nteses devem ser usados
para agrupamento de expressõ es). Uma tupla vazia pode ser formada por um par vazio de parê nteses.
Bytes
Um objeto bytes é um vetor imutá vel. Os itens sã o bytes de 8 bits, representados por inteiros no intervalo 0
<= x < 256. Literais de bytes (como b'abc') e o construtor embutido bytes() podem ser usados para criar
objetos bytes. Alé m disso, os objetos bytes podem ser decodificados em strings atravé s do mé todo decode().

Sequências mutáveis
As sequê ncias mutá veis podem ser alteradas apó s serem criadas. As notaçõ es de subscriçã o e fatiamento podem ser
usadas como o destino da atribuiçã o e instruçõ es del (delete, exclusã o).

® Nota

Os mó dulos collections e array fornecem exemplos adicionais de tipos de sequê ncia mutá veis.

Atualmente, existem dois tipos de sequê ncia mutá vel intrínseca:

20 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

Listas
Os itens de uma lista sã o objetos Python arbitrá rios. As listas sã o formadas colocando uma lista de expressõ es
separada por vírgulas entre colchetes. (Observe que nã o há casos especiais necessá rios para formar listas de
comprimento 0 ou 1.)
Vetores de bytes
Um objeto bytearray é um vetor mutá vel. Eles sã o criados pelo construtor embutido bytearray(). Alé m de
serem mutá veis (e, portanto, nã o-hasheá vel), os vetores de bytes fornecem a mesma interface e funcionalidade
que os objetos imutá veis bytes.

3.2.6 Tipos de conjuntos

Estes representam conjuntos finitos e nã o ordenados de objetos ú nicos e imutá veis. Como tal, eles nã o podem ser
indexados por nenhum subscrito. No entanto, eles podem ser iterados, e a funçã o embutida len() retorna o nú mero
de itens em um conjunto. Os usos comuns para conjuntos sã o testes rá pidos de associaçã o, remoçã o de duplicatas de
uma sequê ncia e computaçã o de operaçõ es matemá ticas como interseçã o, uniã o, diferença e diferença simé trica.
Para elementos de conjunto, as mesmas regras de imutabilidade se aplicam à s chaves de dicioná rio. Observe que os
tipos numé ricos obedecem à s regras normais para comparaçã o numé rica: se dois nú meros forem iguais (por exemplo,
1 e 1.0), apenas um deles pode estar contido em um conjunto.

Atualmente, existem dois tipos de conjuntos intrínsecos:

Conjuntos
Estes representam um conjunto mutá vel. Eles sã o criados pelo construtor embutido set() e podem ser mo-
dificados posteriormente por vá rios mé todos, como add().
Conjuntos congelados
Estes representam um conjunto imutá vel. Eles sã o criados pelo construtor embutido frozenset(). Como
um frozenset é imutá vel e hasheável, ele pode ser usado novamente como um elemento de outro conjunto, ou
como uma chave de dicioná rio.

3.2.7 Mapeamentos
Eles representam conjuntos finitos de objetos indexados por conjuntos de índices arbitrá rios. A notaçã o subscrito
a[k] seleciona o item indexado por k do mapeamento a; isso pode ser usado em expressõ es e como alvo de atribui-
çõ es ou instruçõ es del. A funçã o embutida len() retorna o nú mero de itens em um mapeamento.
Atualmente, há um ú nico tipo de mapeamento intrínseco:

Dicionários
Eles representam conjuntos finitos de objetos indexados por valores quase arbitrá rios. Os ú nicos tipos de valores nã o
aceitá veis como chaves sã o os valores que contê m listas ou dicioná rios ou outros tipos mutá veis que sã o comparados
por valor em vez de por identidade de objeto, o motivo é que a implementaçã o eficiente de dicioná rios requer que
o valor de hash de uma chave permaneça constante. Os tipos numé ricos usados para chaves obedecem à s regras
normais para comparaçã o numé rica: se dois nú meros forem iguais (por exemplo, 1 e 1.0), eles podem ser usados
alternadamente para indexar a mesma entrada do dicioná rio.
Dicioná rios preservam a ordem de inserçã o, o que significa que as chaves serã o produzidas na mesma ordem em que
foram adicionadas sequencialmente no dicioná rio. Substituir uma chave existente nã o altera a ordem, no entanto,
remover uma chave e inseri-la novamente irá adicioná -la ao final em vez de manter seu lugar anterior.
Os dicioná rios sã o mutá veis; eles podem ser criados pela notaçã o {} (veja a seçã o Sintaxes de criação de dicionário).
Os mó dulos de extensã o [Link] e [Link] fornecem exemplos adicionais de tipos de mapeamento, assim como
o mó dulo collections.
Alterado na versã o 3.7: Dicioná rios nã o preservavam a ordem de inserçã o nas versõ es do Python anteriores à 3.6.
No CPython 3.6, a ordem de inserçã o foi preservada, mas foi considerada um detalhe de implementaçã o naquela
é poca, em vez de uma garantia da linguagem.

3.2. A hierarquia de tipos padrão 21

The Python Language Reference, Release 3.13.0

3.2.8 Tipos chamáveis

Estes sã o os tipos aos quais a operaçã o de chamada de funçã o (veja a seçã o Chamadas) pode ser aplicada:

Funções definidas pelo usuário

Um objeto funçã o definido pelo usuá rio será criado pela definiçã o de funçã o (veja a seçã o Definições de função). A
mesma deverá ser invocada com uma lista de argumentos contendo o mesmo nú mero de itens que a lista de parâ metros
formais da funçã o.

Atributos especiais de somente leitura

Atributo Significado
Uma referê ncia ao dicionário que conté m as variá-
function.__globals__ veis globais da funçã o – o espaço de nomes global do
mó dulo no qual a funçã o foi definida.
None ou uma tuple de cé lulas que contê m ligaçã o para
function.__closure__ os nomes especificados no atributo co_freevars do
objeto código da funçã o.
Um objeto de cé lula tem o atributo cell_contents.
Isso pode ser usado para obter o valor da cé lula, bem
como definir o valor.

Atributos especiais graváveis

A maioria desses atributos verifica o tipo do valor atribuído:

22 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

Atributo Significado
A string de documentaçã o da funçã o, ou None se indis-
function.__doc__ ponível.

O nome da funçã o. Veja també m: atributos

function.__name__ __name__.

O nome qualificado da funçã o. Veja també m:

function.__qualname__ atributos __qualname__.
Adicionado na versã o 3.3.
O nome do mó dulo em que a funçã o foi definida ou
function.__module__ None se indisponível.

Uma tuple contendo valores de parâmetro padrã o para

function.__defaults__ aqueles parâ metros que possuem padrõ es, ou None se
nenhum parâ metro tiver um valor padrã o.
O objeto código que representa o corpo da funçã o com-
function.__code__ pilada.

O espaço de nomes que provvê atributos de funçã o ar-

function.__dict__ bitrá rios. Veja també m: atributos __dict__.

Um dicionário contendo anotaçõ es de parâmetros.

function.__annotations__ As chaves do dicioná rio sã o os nomes dos parâ metros
e 'return' para a anotaçã o de retorno, se fornecida.
Veja també m: annotations-howto.
Um dicionário contendo padrõ es apenas para parâ-
function.__kwdefaults__ metros somente-nomeados.

Uma tuple contendo os parâmetros de tipo de uma

function.__type_params__ função genérica.
Adicionado na versã o 3.12.

Os objetos de funçã o també m dã o suporte à obtençã o e definiçã o de atributos arbitrá rios, que podem ser usados, por
exemplo, para anexar metadados a funçõ es. A notaçã o de ponto de atributo regular é usada para obter e definir tais
atributos.
Detalhes da implementação do CPython: A implementaçã o atual do CPython provê apenas atributos de funçã o
em funçõ es definidas pelo usuá rio. Atributos de funçã o em funções embutido podem ser suportados no futuro.
Informaçõ es adicionais sobre a definiçã o de uma funçã o podem ser obtidas de seu objeto código (acessível atravé s do
atributo __code__).

Métodos de instância
Um objeto mé todo de instâ ncia combina uma classe, uma instâ ncia de classe e qualquer objeto chamá vel (normal-
mente uma funçã o definida pelo usuá rio).
Atributos especiais de somente leitura:

3.2. A hierarquia de tipos padrão 23

The Python Language Reference, Release 3.13.0

Refere-se ao objeto instâ ncia da classe ao qual o mé todo

method.__self__ é vinculado

Refere-se ao objeto função original

method.__func__

A documentaçã o do mé todo (igual a method.

method.__doc__ __func__.__doc__). Um string se a funçã o ori-
ginal tivesse uma docstring, caso contrá rio None.
O nome do mé todo (mesmo que method.__func__.
method.__name__ __name__)

O nome do mó dulo em que o mé todo foi definido ou

method.__module__ None se indisponível.

Os mé todos també m implementam o acesso (mas nã o a configuraçã o) dos atributos arbitrá rios da funçã o no objeto
função subjacente.
Objetos mé todo definidos pelo usuá rio podem ser criados ao obter um atributo de uma classe (talvez atravé s de uma
instâ ncia dessa classe), se esse atributo for um objeto função definido pelo usuá rio ou um objeto classmethod .
Quando um objeto mé todo de instâ ncia é criado recuperando um objeto função definido pelo usuá rio de uma classe
por meio de uma de suas instâ ncias, seu atributo __self__ é a instâ ncia, e o objeto mé todo é considerado vinculado.
O atributo __func__ do novo mé todo é o objeto da funçã o original.
Quando um objeto mé todo de instâ ncia é criado obtendo um objeto classmethod de uma classe ou instâ ncia, seu
atributo __self__ é a pró pria classe, e seu atributo __func__ é o objeto funçã o subjacente ao mé todo de classe.
Quando um objeto mé todo de instâ ncia é chamado, a funçã o subjacente (__func__) é chamada, inserindo a instâ ncia
de classe (__self__) na frente da lista de argumentos. Por exemplo, quando C é uma classe que conté m uma
definiçã o para uma funçã o f(), e x é uma instâ ncia de C, chamando x.f(1) é equivalente a chamar C.f(x, 1).
Quando um objeto mé todo de instâ ncia é derivado de um objeto classmethod, a “instâ ncia de classe” armazenada
em __self__ será , na verdade, a pró pria classe, de modo que chamar x.f(1) ou C.f(1) é equivalente a chamar
f(C,1) sendo f a funçã o subjacente.

É importante observar que funçõ es definidas pelo usuá rio que sã o atributos de uma instâ ncia de classe nã o sã o
convertidas em mé todos vinculados; isso somente acontece quando a funçã o é um atributo da classe.

Funções geradoras
Uma funçã o ou mé todo que usa a instruçã o yield (veja a seçã o A instrução yield) é chamada de função geradora.
Tal funçã o, quando chamada, sempre retorna um objeto iterator que pode ser usado para executar o corpo da funçã o:
chamar o mé todo iterator.__next__() do iterador fará com que a funçã o seja executada até que forneça um
valor usando a instruçã o yield. Quando a funçã o executa uma instruçã o return ou sai do fim, uma exceçã o
StopIteration é levantada e o iterador terá alcançado o fim do conjunto de valores a serem retornados.

Funções de corrotina
Uma funçã o ou um mé todo que é definida(o) usando async def é chamado de função de corrotina. Tal funçã o,
quando chamada, retorna um objeto de corrotina. Ele pode conter expressõ es await, bem como instruçõ es async
with e async for. Veja també m a seçã o Objetos corrotina.

Funções geradoras assíncronas

Uma funçã o ou um mé todo que é definida(o) usando async def e que usa a instruçã o yield é chamada de função
geradora assíncrona. Tal funçã o, quando chamada, retorna um objeto iterador assíncrono que pode ser usado em
uma instruçã o async for para executar o corpo da funçã o.

24 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

Chamar o mé todo aiterator.__anext__ do iterador assíncrono retornará um aguardável que, quando aguardado,
será executado até fornecer um valor usando a expressã o yield. Quando a funçã o executa uma instruçã o vazia
return ou chega ao final, uma exceçã o StopAsyncIteration é levantada e o iterador assíncrono terá alcançado
o final do conjunto de valores a serem produzidos.

Funções embutidas
Um objeto funçã o embutida é um wrapper em torno de uma funçã o C. Exemplos de funçõ es embutidas sã o len()
e [Link]() (math é um mó dulo embutido padrã o). O nú mero e o tipo dos argumentos sã o determinados pela
funçã o C. Atributos especiais de somente leitura:
• __doc__ é a string de documentaçã o da funçã o, ou None se nã o estiver disponível. Veja function.__doc__.
• __name__ é o nome da funçã o. Veja function.__name__.
• __self__ é definido para None (mas veja o pró ximo item).
• __module__ é o nome do mó dulo no qual a funçã o foi definida ou None se nã o estiver disponível. Veja
function.__module__.

Métodos embutidos
Este é realmente um disfarce diferente de uma funçã o embutida, desta vez contendo um objeto passado para a funçã o
C como um argumento extra implícito. Um exemplo de mé todo embutido é [Link](), presumindo que
alist é um objeto de lista. Nesse caso, o atributo especial de somente leitura __self__ é definido como o objeto
denotado por alist. (O atributo tem a mesma semâ ntica de outros métodos de instância.)

Classes
Classes sã o chamá veis. Esses objetos normalmente agem como fá bricas para novas instâ ncias de si mesmos, mas
variaçõ es sã o possíveis para tipos de classe que substituem __new__(). Os argumentos da chamada sã o passados
para __new__() e, no caso típico, para __init__() para inicializar a nova instâ ncia.

Instâncias de classe
Instâ ncias de classes arbitrá rias podem ser tornados chamá veis definindo um mé todo __call__() em sua classe.

3.2.9 Módulos
Mó dulos sã o uma unidade organizacional bá sica do có digo Python, e sã o criados pelo sistema de importação quando
invocado pela instruçã o import, ou chamando funçõ es como importlib.import_module() e a embutida
__import__(). Um objeto mó dulo tem um espaço de nomes implementado por um objeto dicionário (este
é o dicioná rio referenciado pelo atributo __globals__ das funçõ es definidas no mó dulo). As referê ncias de atri-
butos sã o traduzidas para pesquisas neste dicioná rio, por exemplo, m.x é equivalente a m.__dict__["x"]. Um
objeto mó dulo nã o conté m o objeto có digo usado para inicializar o mó dulo (uma vez que nã o é necessá rio depois
que a inicializaçã o é concluída).
A atribuiçã o de atributo atualiza o dicioná rio de espaço de nomes do mó dulo, por exemplo, m.x = 1 é equivalente
a m.__dict__["x"] = 1.

Atributos relacionados à importação em objetos de módulo

Objetos de mó dulo tê m os seguintes atributos que se relacionam ao sistema de importação. Quando um mó dulo é
criado usando o maquiná rio associado ao sistema de importaçã o, esses atributos sã o preenchidos com base no spec
do mó dulo, antes que o carregador execute e carregue o mó dulo.
Para criar um mó dulo dinamicamente em vez de usar o sistema de importaçã o, é recomendado usar importlib.
util.module_from_spec(), que definirá os vá rios atributos controlados pela importaçã o para valores apropria-
dos. També m é possível usar o construtor [Link] para criar mó dulos diretamente, mas essa té cnica é
mais propensa a erros, pois a maioria dos atributos deve ser definida manualmente no objeto do mó dulo apó s ele ter
sido criado ao usar essa abordagem.

3.2. A hierarquia de tipos padrão 25

The Python Language Reference, Release 3.13.0

Ϫ Cuidado

Com exceçã o de __name__, é fortemente recomendado que você confie no __spec__ e seus atributos em vez
de qualquer um dos outros atributos individuais listados nesta subseçã o. Observe que atualizar um atributo em
__spec__ nã o atualizará o atributo correspondente no pró prio mó dulo:
>>> import typing
>>> typing.__name__, typing.__spec__.name
('typing', 'typing')
>>> typing.__spec__.name = 'spelling'
>>> typing.__name__, typing.__spec__.name
('typing', 'spelling')
>>> typing.__name__ = 'keyboard_smashing'
>>> typing.__name__, typing.__spec__.name
('keyboard_smashing', 'spelling')

module.__name__
O nome usado para identificar exclusivamente o mó dulo no sistema de importaçã o. Para um mó dulo executado
diretamente, isso será definido como "__main__".
This attribute must be set to the fully qualified name of the module. It is expected to match the value of
module.__spec__.name.
module.__spec__
Um registro do estado relacionado ao sistema de importaçã o do mó dulo.
Defina como spec do módulo que foi usado ao importar o mó dulo. Veja Module specs para mais detalhes.
Adicionado na versã o 3.4.
module.__package__
O pacote ao qual um mó dulo pertence.
Se o mó dulo for de nível superior (ou seja, nã o fizer parte de nenhum pacote específico), o atributo deve ser
definido como '' (a string vazia). Caso contrá rio, deve ser definido como o nome do pacote do mó dulo (que
pode ser igual a module.__name__ se o mó dulo em si for um pacote). Veja PEP 366 para mais detalhes.
Este atributo é usado em vez de __name__ para calcular importaçõ es relativas explícitas para mó dulos prin-
cipais. O padrã o é None para mó dulos criados dinamicamente usando o construtor [Link];
use [Link].module_from_spec() em vez disso para garantir que o atributo seja definido como
str.

É fortemente recomendado que você use module.__spec__.parent em vez de module.__package__.

__package__ agora só é usado como fallback se __spec__.parent nã o estiver definido, e esse caminho
de fallback está descontinuado.
Alterado na versã o 3.4: Este atributo agora presume o padrã o None para mó dulos criados dinamicamente
usando o construtor [Link]. Anteriormente, o atributo era opcional.
Alterado na versã o 3.6: Espera-se que o valor de __package__ seja o mesmo que __spec__.parent.
__package__ agora é usado apenas como fallback durante a resoluçã o de importaçã o se __spec__.parent
nã o estiver definido.
Alterado na versã o 3.10: ImportWarning é levantada se uma resoluçã o de importaçã o retorna para
__package__ em vez de __spec__.parent.

Alterado na versã o 3.12: Levanta DeprecationWarning em vez de ImportWarning ao retornar para

__package__ durante a resoluçã o de importaçã o.

Deprecated since version 3.13, will be removed in version 3.15: __package__ deixará de ser definido ou
levado em consideraçã o pelo sistema de importaçã o ou biblioteca padrã o.

26 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

module.__loader__
O objeto carregador que o maquiná rio de importaçã o usou para carregar o mó dulo.
Este atributo é ú til principalmente para introspecçã o, mas pode ser usado para funcionalidades adicionais
específicas do carregador, por exemplo, para obter dados associados a um carregador.
__loader__ assume como padrã o None para mó dulos criados dinamicamente usando o construtor types.
ModuleType; use [Link].module_from_spec() para garantir que o atributo seja definido
como um objeto carregador.
É fortemetne recomendado que você use module.__spec__.loader em vez de module.__loader__.
Alterado na versã o 3.4: Este atributo agora presume o padrã o None para mó dulos criados dinamicamente
usando o construtor [Link]. Anteriormente, o atributo era opcional.
Deprecated since version 3.12, will be removed in version 3.14: A definiçã o __loader__ em um mó dulo en-
quanto falha na definiçã o de __spec__.loader está descontinuado. No Python 3.14, __loader__ deixará
de ser definido ou levado em consideraçã o pelo sistema de importaçã o ou pela biblioteca padrã o.
module.__path__
Uma sequência (possivelmente vazia) de strings enumerando os locais onde os submó dulos do pacote serã o en-
contrados. Mó dulos que nã o sejam de pacote nã o devem ter um atributo __path__. Veja __path__ attributes
on modules para mais detalhes.
É fortemente recomendado que você use module.__spec__.submodule_search_locations em vez
de module.__path__.
module.__file__

module.__cached__
__file__ e __cached__ sã o atributos opcionais que podem ou nã o ser definidos. Ambos os atributos devem
ser um str quando estiverem disponíveis.
__file__ indica o nome do caminho do arquivo do qual o mó dulo foi carregado (se carregado de um arquivo)
ou o nome do caminho do arquivo da biblioteca compartilhada para mó dulos de extensã o carregados dinami-
camente de uma biblioteca compartilhada. Pode estar faltando para certos tipos de mó dulos, como mó dulos
C que estã o estaticamente vinculados ao interpretador, e o sistema de importação pode optar por deixá -lo sem
definiçã o se nã o tiver significado semâ ntico (por exemplo, um mó dulo carregado de um banco de dados).
Se __file__ estiver definido entã o o atributo __cached__ també m pode ser definido, que é o caminho para
qualquer versã o compilada do có digo (por exemplo, um arquivo compilado por byte). O arquivo nã o precisa
existir para configurar esse atributo; o caminho pode simplesmente apontar para onde o arquivo compilado
existiria (veja PEP 3147).
Observe que __cached__ pode ser definido mesmo se __file__ nã o estiver definido. No entanto, esse
cená rio é bastante atípico. Em ú ltima aná lise, o carregador é o que faz uso do spec do mó dulo fornecido pelo
localizador (do qual __file__ e __cached__ sã o derivados). Portanto, se um carregador puder carregar
a partir de um mó dulo em cache, mas nã o carregar a partir de um arquivo, esse cená rio atípico poderá ser
apropriado.
É fortemente recomendado que você use module.__spec__.cached em vez de module.__cached__.
Deprecated since version 3.13, will be removed in version 3.15: A definiçã o __cached__ em um mó dulo en-
quanto falha na definiçã o de __spec__.cached está descontinuado. No Python 3.15, __cached__ deixará
de ser definido ou levado em consideraçã o pelo sistema de importaçã o ou pela biblioteca padrã o.

Other writable attributes on module objects

As well as the import-related attributes listed above, module objects also have the following writable attributes:
module.__doc__
The module’s documentation string, or None if unavailable. See also: __doc__ attributes.

3.2. A hierarquia de tipos padrão 27

The Python Language Reference, Release 3.13.0

module.__annotations__
Um dicioná rio contendo anotações de variável coletadas durante a execuçã o do corpo do mó dulo. Para as
melhores prá ticas sobre como trabalhar com __annotations__, por favor veja annotations-howto.

Module dictionaries
Module objects also have the following special read-only attribute:
module.__dict__
The module’s namespace as a dictionary object. Uniquely among the attributes listed here, __dict__ cannot
be accessed as a global variable from within a module; it can only be accessed as an attribute on module objects.
Detalhes da implementação do CPython: Por causa da maneira como CPython limpa dicioná rios de mó -
dulos, o dicioná rio do mó dulo será limpo quando o mó dulo sair do escopo, mesmo se o dicioná rio ainda tiver
referê ncias ativas. Para evitar isso, copie o dicioná rio ou mantenha o mó dulo por perto enquanto usa seu
dicioná rio diretamente.

3.2.10 Classes personalizadas

Tipos de classe personalizados sã o tipicamente criados por definiçõ es de classe (veja a seçã o Definições de classe).
Uma classe possui um espaço de nomes implementado por um objeto dicioná rio. As referê ncias de atributos de classe
sã o traduzidas para pesquisas neste dicioná rio, por exemplo, C.x é traduzido para C.__dict__["x"] (embora haja
uma sé rie de ganchos que permitem outros meios de localizar atributos). Quando o nome do atributo nã o é encontrado
lá , a pesquisa do atributo continua nas classes base. Essa pesquisa das classes base usa a ordem de resoluçã o de
mé todos C3, que se comporta corretamente mesmo na presença de estruturas de herança em losango, onde há vá rios
caminhos de herança que levam de volta a um ancestral comum. Detalhes adicionais sobre a ordem de resoluçã o de
mé todos (MRO) C3 usado pelo Python podem ser encontrados em python_2.3_mro.
Quando uma referê ncia de atributo de classe (para uma classe C, digamos) produziria um objeto mé todo de classe,
ele é transformado em um objeto mé todo de instâ ncia cujo atributo __self__ é C. Quando produziria um objeto
staticmethod, ele é transformado no objeto encapsulado pelo objeto mé todo está tico. Veja a seçã o Implementando
descritores para outra maneira em que os atributos recuperados de uma classe podem diferir daqueles realmente
contidos em seu __dict__.
As atribuiçõ es de atributos de classe atualizam o dicioná rio da classe, nunca o dicioná rio de uma classe base.
Um objeto classe pode ser chamado (veja acima) para produzir uma instâ ncia de classe (veja abaixo).

28 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

Special attributes

Atributo Significado
The class’s name. See also: __name__ attributes.
type.__name__

The class’s qualified name. See also: __qualname__

type.__qualname__ attributes.

O nome do mó dulo no qual a classe foi definida.

type.__module__

A mapping proxy providing a read-only view of

type.__dict__ the class’s namespace. See also: __dict__
attributes.
A tuple containing the class’s bases. In most ca-
type.__bases__ ses, for a class defined as class X(A, B, C), X.
__bases__ will be exactly equal to (A, B, C).
The class’s documentation string, or None if undefined.
type.__doc__ Not inherited by subclasses.

A dictionary containing variable annotations collected

type.__annotations__ during class body execution. For best practices on wor-
king with __annotations__, please see annotations-
-howto.

Ϫ Cuidado

Accessing the __annotations__ attribute of a

class object directly may yield incorrect results in
the presence of metaclasses. In addition, the attri-
bute may not exist for some classes. Use inspect.
get_annotations() to retrieve class annotati-
ons safely.

A tuple containing the type parameters of a generic

type.__type_params__ class.
Adicionado na versã o 3.12.
A tuple containing names of attributes of this class
type.__static_attributes__ which are assigned through self.X from any function
in its body.
Adicionado na versã o 3.13.
The line number of the first line of the class definition,
type.__firstlineno__ including decorators. Setting the __module__ attri-
bute removes the __firstlineno__ item from the
type’s dictionary.
Adicionado na versã o 3.13.
The tuple of classes that are considered when looking
type.__mro__ for base classes during method resolution.

Special methods
In addition to the special attributes described above, all Python classes also have the following two methods available:

[Link]()
This method can be overridden by a metaclass to customize the method resolution order for its instances. It is

3.2. A hierarquia de tipos padrão 29

The Python Language Reference, Release 3.13.0

called at class instantiation, and its result is stored in __mro__.

type.__subclasses__()
Each class keeps a list of weak references to its immediate subclasses. This method returns a list of all those
references still alive. The list is in definition order. Example:

>>> class A: pass

>>> class B(A): pass
>>> A.__subclasses__()
[<class 'B'>]

3.2.11 Instâncias de classe

Uma instâ ncia de classe é criada chamando um objeto classe (veja acima). Uma instâ ncia de classe tem um espaço de
nomes implementado como um dicioná rio que é o primeiro lugar no qual as referê ncias de atributos sã o pesquisadas.
Quando um atributo nã o é encontrado lá , e a classe da instâ ncia possui um atributo com esse nome, a pesquisa continua
com os atributos da classe. Se for encontrado um atributo de classe que seja um objeto funçã o definido pelo usuá rio,
ele é transformado em um objeto mé todo de instâ ncia cujo atributo __self__ é a instâ ncia. Mé todos está ticos e
mé todos de classe també m sã o transformados; veja acima em “Classes”. Veja a seçã o Implementando descritores para
outra maneira em que os atributos de uma classe recuperados atravé s de suas instâ ncias podem diferir dos objetos
realmente armazenados no __dict__ da classe. Se nenhum atributo de classe for encontrado, e a classe do objeto
tiver um mé todo __getattr__(), este é chamado para satisfazer a pesquisa.
As atribuiçõ es e exclusõ es de atributos atualizam o dicioná rio da instâ ncia, nunca o dicioná rio de uma classe. Se a
classe tem um mé todo __setattr__() ou __delattr__(), ele é chamado ao invé s de atualizar o dicioná rio da
instâ ncia diretamente.
As instâ ncias de classe podem fingir ser nú meros, sequê ncias ou mapeamentos se tiverem mé todos com certos nomes
especiais. Veja a seçã o Nomes de métodos especiais.

Special attributes
object.__class__
A classe à qual pertence uma instâ ncia de classe.
object.__dict__
A dictionary or other mapping object used to store an object’s (writable) attributes. Not all instances have a
__dict__ attribute; see the section on __slots__ for more details.

3.2.12 Objetos de E/S (também conhecidos como objetos arquivo)

O objeto arquivo representa um arquivo aberto. Vá rios atalhos estã o disponíveis para criar objetos arquivos: a funçã o
embutida open(), e també m [Link](), [Link]() e o mé todo makefile() de objetos soquete (e talvez
por outras funçõ es ou mé todos fornecidos por mó dulos de extensã o).
Os objetos [Link], [Link] e [Link] sã o inicializados para objetos arquivo que correspondem aos
fluxos de entrada, saída e erro padrã o do interpretador; eles sã o todos abertos em modo texto e, portanto, seguem a
interface definida pela classe abstrata [Link].

3.2.13 Tipos internos

Alguns tipos usados internamente pelo interpretador sã o expostos ao usuá rio. Suas definiçõ es podem mudar com
versõ es futuras do interpretador, mas sã o mencionadas aqui para fins de integridade.

Objetos código
Objetos có digo representam có digo Python executá vel compilados em bytes ou bytecode. A diferença entre um objeto
có digo e um objeto funçã o é que o objeto funçã o conté m uma referê ncia explícita aos globais da funçã o (o mó dulo
no qual foi definida), enquanto um objeto có digo nã o conté m nenhum contexto; també m os valores de argumento
padrã o sã o armazenados no objeto funçã o, nã o no objeto có digo (porque eles representam os valores calculados em

30 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

tempo de execuçã o). Ao contrá rio dos objetos funçã o, os objetos có digo sã o imutá veis e nã o contê m referê ncias
(direta ou indiretamente) a objetos mutá veis.

3.2. A hierarquia de tipos padrão 31

The Python Language Reference, Release 3.13.0

Atributos especiais de somente leitura

O nome da funçã o
codeobject.co_name

O nome completo da funçã o

codeobject.co_qualname Adicionado na versã o 3.11.

O nú mero total de parâmetros posicionais (incluindo

codeobject.co_argcount parâ metros somente-posicionais e parâ metros com va-
lores padrã o) que a funçã o possui
O nú mero de parâmetros somente-posicionais (in-
codeobject.co_posonlyargcount cluindo argumentos com valores padrã o) que a funçã o
possui
O nú mero de parâmetros somente-nomeados (incluindo
codeobject.co_kwonlyargcount argumentos com valores padrã o) que a funçã o possui

O nú mero de variáveis locais usadas pela funçã o (in-

codeobject.co_nlocals cluindo parâ metros)

Uma tuple contendo os nomes das variá veis locais na

codeobject.co_varnames funçã o (começando com os nomes dos parâ metros)

A tuple containing the names of local variables that

codeobject.co_cellvars are referenced from at least one nested scope inside the
function
A tuple containing the names of free (closure) vari-
codeobject.co_freevars ables that a nested scope references in an outer scope.
See also function.__closure__.
Note: references to global and builtin names are not in-
cluded.
Uma string representando a sequê ncia de instruçõ es by-
codeobject.co_code tecode na funçã o

Um tuple contendo os literais usados pelo bytecode na

codeobject.co_consts funçã o

Um tuple contendo os nomes usados pelo bytecode na

codeobject.co_names funçã o

O nome do arquivo do qual o có digo foi compilado

codeobject.co_filename

O nú mero da linha da primeira linha da funçã o

codeobject.co_firstlineno

Uma string que codifica o mapeamento de bytecode

codeobject.co_lnotab compensa para nú meros de linha. Para obter detalhes,
consulte o có digo-fonte do interpretador.
Obsoleto desde a versã o 3.12: This attribute of code
objects is deprecated, and may be removed in Python
3.15.
O tamanho de pilha necessá rio do objeto có digo
codeobject.co_stacksize

Um nú mero inteiro codificando uma sé rie de sinali-

codeobject.co_flags zadores para o interpretador.

32 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

Os seguintes bits sinalizadores sã o definidos para co_flags: o bit 0x04 é definido se a funçã o usa a sintaxe
*arguments para aceitar um nú mero arbitrá rio de argumentos posicionais; o bit 0x08 é definido se a funçã o usa
a sintaxe **keywords para aceitar argumentos nomeados arbitrá rios; o bit 0x20 é definido se a funçã o for um
gerador. Veja inspect-module-co-flags para detalhes na semâ ntica de cada sinalizadores que podem estar presentes.
Declaraçõ es de recursos futuros (from __future__ import division) també m usam bits em co_flags para
indicar se um objeto có digo foi compilado com um recurso específico habilitado: o bit 0x2000 é definido se a funçã o
foi compilada com divisã o futura habilitada; os bits 0x10 e 0x1000 foram usados em versõ es anteriores do Python.
Outros bits em co_flags sã o reservados para uso interno.
Se um objeto có digo representa uma funçã o, o primeiro item em co_consts é a string de documentaçã o da funçã o,
ou None se indefinido.

Métodos de objetos código

codeobject.co_positions()
Retorna um iterá vel das posiçõ es no có digo-fonte de cada instruçã o bytecode no objeto có digo.
O iterador retorna tuples contendo (start_line, end_line, start_column, end_column). A i-
-nésima tupla corresponde à posiçã o do có digo-fonte que compilou para a i-nésima unidade de có digo. As
informaçõ es da coluna sã o deslocamentos de bytes utf-8 indexados em 0 na linha de có digo fornecida.
A informaçã o posicional pode estar ausente. Veja uma lista nã o-exaustiva de casos onde isso pode acontecer:
• Executando o interpretador com no_debug_ranges -X.
• Carregando um arquivo pyc compilado com no_debug_ranges -X.
• Tuplas posicionais correspondendo a instruçõ es artificiais.
• Nú meros de linha e coluna que nã o podem ser representados devido a limitaçõ es específicas de imple-
mentaçã o.
Quando isso ocorre, alguns ou todos elementos da tupla podem ser None.
Adicionado na versã o 3.11.

® Nota

Esse recurso requer o armazenamento de posiçõ es de coluna no objeto có digo, o que pode resultar em
um pequeno aumento no uso de memó ria do interpretador e no uso de disco para arquivos Python com-
pilados. Para evitar armazenar as informaçõ es extras e/ou desativar a exibiçã o das informaçõ es extras
de rastreamento, use a opçã o de linha de comando no_debug_ranges -X ou a variá vel de ambiente
PYTHONNODEBUGRANGES.

codeobject.co_lines()
Retorna um iterador que produz informaçõ es sobre intervalos sucessivos de bytecodes. Cada item gerado é
uma tuple de (start, end, lineno):
• start (um int) representa o deslocamento (inclusivo) do início do intervalo bytecode
• end (um int) representa o deslocamento (exclusivo) do fim do intervalo bytecode
• lineno é um int representando o nú mero da linha do intervalo do bytecode, ou None se os bytecodes
no intervalo fornecido nã o tiverem nú mero de linha
Os itens gerados terã o as seguintes propriedades:
• O primeiro intervalo gerado terá um start de 0.
• Os intervalos (start, end) serã o nã o decrescentes e consecutivos. Ou seja, para qualquer par de
tuples, o start do segundo será igual ao end do primeiro.

• Nenhum intervalo será inverso: end >= start para todos os trios.

3.2. A hierarquia de tipos padrão 33

The Python Language Reference, Release 3.13.0

• A ú ltima tuple gerada terá end igual ao tamanho do bytecode.

Intervalos de largura zero, onde start == end, sã o permitidos. Intervalos de largura zero sã o usados para
linhas que estã o presentes no có digo-fonte, mas foram eliminadas pelo compilador de bytecode.
Adicionado na versã o 3.10.

µ Ver também

PEP 626 - Números de linha precisos para depuração e outras ferramentas.

A PEP que introduziu o mé todo co_lines().

[Link](**kwargs)
Retorna uma có pia do objeto de có digo com novos valores para os campos especificados.
Objetos de có digo també m sã o suportados pela funçã o gené rica [Link]().
Adicionado na versã o 3.8.

Objetos quadro
Objetos quadro representam quadros de execuçã o. Eles podem ocorrer em objetos traceback e també m sã o passados
para funçõ es de rastreamento registradas.

Atributos especiais de somente leitura

Aponta para o quadro de pilha anterior (em direçã o ao

frame.f_back chamador), ou None se este for o quadro de pilha mais
abaixo.
O objeto código sendo executado neste quadro. Acessar
frame.f_code este atributo levanta um evento de auditoria object.
__getattr__ com os argumentos obj e "f_code".
O mapeamento usado pelo quadro para procurar va-
frame.f_locals riáveis locais. Se o quadro se referir a um escopo
otimizado, isso pode retornar um objeto proxy write-
-through.
Alterado na versã o 3.13: Retorna um proxy para esco-
pos otimizados.
O dicioná rio usado pelo quadro para procurar variáveis
frame.f_globals globais

O dicioná rio usado pelo quadro para procurar nomes

frame.f_builtins embutidos (intrínsecos)

A “instruçã o precisa” do objeto quadro (este é um ín-

frame.f_lasti dice na string bytecode do objeto código)

34 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

Atributos especiais graváveis

Se nã o for None, esta é uma funçã o chamada para

frame.f_trace vá rios eventos durante a execuçã o do có digo (isso é
usado por depuradores). Normalmente, um evento
é disparado para cada nova linha de origem (veja
f_trace_lines).
Defina este atributo como False para desabilitar o aci-
frame.f_trace_lines onamento de um evento de rastreamento para cada li-
nha de origem.
Defina este atributo para True para permitir que even-
frame.f_trace_opcodes tos por opcode sejam solicitados. Observe que isso
pode levar a um comportamento indefinido do inter-
pretador se as exceçõ es levantadas pela funçã o de ras-
treamento escaparem para a funçã o que está sendo ras-
treada.
O nú mero da linha atual do quadro – escrever para isso
frame.f_lineno de dentro de uma funçã o de rastreamento faz saltar para
a linha dada (apenas para o quadro mais abaixo). Um
depurador pode implementar um comando Jump (tam-
bé m conhecido como Set Next Statement) escrevendo
para esse atributo.

Métodos de objetos quadro

Objetos quadro tê m suporte a um mé todo:

[Link]()
Este mé todo limpa todas as referê ncias a variáveis locais mantidas pelo quadro. Alé m disso, se o quadro
pertencer a um gerador, o gerador é finalizado. Isso ajuda a quebrar os ciclos de referê ncia que envolvem
objetos quadro (por exemplo, ao capturar uma exceçã o e armazenar seu traceback para uso posterior).
RuntimeError é levantada se o quadro estiver em execuçã o ou suspenso.

Adicionado na versã o 3.4.

Alterado na versã o 3.13: Tentar limpar um quadro suspenso levanta RuntimeError (como sempre foi o caso
para quadros em execuçã o).

Objetos traceback
Objetos traceback representam o stack trace (situaçã o da pilha de execuçã o) de uma exceçã o. Um objeto traceback
é criado implicitamente quando ocorre uma exceçã o e també m pode ser criado explicitamente chamando types.
TracebackType.

Alterado na versã o 3.7: Objetos traceback agora podem ser instanciados explicitamente a partir de có digo Python.
Para tracebacks criados implicitamente, quando a busca por um manipulador de exceçã o desenrola a pilha de execu-
çã o, em cada nível desenrolado um objeto traceback é inserido na frente do traceback atual. Quando um manipulador
de exceçã o é inserido, o stack trace é disponibilizado para o programa. (Veja a seçã o A instrução try.) É acessível
como o terceiro item da tupla retornada por sys.exc_info(), e como o atributo __traceback__ da exceçã o
capturada.
Quando o programa nã o conté m um manipulador adequado, o stack trace é escrito (formatado de maneira ade-
quada) no fluxo de erro padrã o; se o interpretador for interativo, ele també m é disponibilizado ao usuá rio como
sys.last_traceback.

Para tracebacks criados explicitamente, cabe ao criador do traceback determinar como os atributos tb_next devem
ser vinculados para formar um stack trace completo.
Atributos especiais de somente leitura:

3.2. A hierarquia de tipos padrão 35

The Python Language Reference, Release 3.13.0

Aponta para o quadro de execuçã o do nível atual.

traceback.tb_frame Acessar este atributo levanta um evento de audito-
ria object.__getattr__ com os argumentos obj e
"tb_frame".
Fornece o nú mero da linha onde ocorreu a exceçã o
traceback.tb_lineno

Indica a “instruçã o precisa”.

traceback.tb_lasti

O nú mero da linha e a ú ltima instruçã o no traceback podem diferir do nú mero da linha do seu objeto quadro se a
exceçã o ocorreu em uma instruçã o try sem clá usula except correspondente ou com uma clá usula finally .
traceback.tb_next
O atributo especial de escrita tb_next é o pró ximo nível no stack trace (em direçã o ao quadro onde a exceçã o
ocorreu), ou None se nã o houver pró ximo nível.
Alterado na versã o 3.7: Este atributo agora é gravá vel

Objetos slice
Objetos slice sã o usados para representar fatias para mé todos __getitem__(). Eles també m sã o criados pela funçã o
embutida slice().
Atributos especiais de somente leitura: start é o limite inferior; stop é o limite superior; step é o valor da diferença
entre elementos subjacentes; cada um desses atributos é None se omitido. Esses atributos podem ter qualquer tipo.
Objetos slice tê m suporte a um mé todo:
[Link](self, length)
Este mé todo recebe um ú nico argumento inteiro length e calcula informaçõ es sobre a fatia que o objeto slice
descreveria se aplicado a uma sequê ncia de itens de length. Ele retorna uma tupla de trê s inteiros; respectiva-
́
mente, estes sã o os índices start e stop e o step ou comprimento de avanços da fatia. Indices ausentes ou fora
dos limites sã o tratados de maneira consistente com fatias regulares.

Objetos método estático

Objetos mé todo está tico fornecem uma forma de transformar objetos funçã o em objetos mé todos descritos acima.
Um objeto mé todo está tico é um invó lucro em torno de qualquer outro objeto, comumente um objeto mé todo definido
pelo usuá rio. Quando um objeto mé todo está tico é recuperado de uma classe ou de uma instâ ncia de classe, o objeto
retornado é o objeto encapsulado, do qual nã o está sujeito a nenhuma transformaçã o adicional. Objetos mé todo
está tico també m sã o chamá veis. Objetos mé todo está tico sã o criados pelo construtor embutido staticmethod().

Objetos método de classe

Um objeto mé todo de classe, como um objeto mé todo está tico, é um invó lucro em torno de outro objeto que altera a
maneira como esse objeto é recuperado de classes e instâ ncias de classe. O comportamento dos objetos mé todo de
classe apó s tal recuperaçã o é descrito acima, sob “métodos de instância”. Objetos mé todo de classe sã o criados pelo
construtor embutido classmethod().

3.3 Nomes de métodos especiais

Uma classe pode implementar certas operaçõ es que sã o chamadas por sintaxe especial (como operaçõ es aritmé ticas
ou indexaçã o e fatiamento), definindo mé todos com nomes especiais. Esta é a abordagem do Python para sobrecarga
de operador, permitindo que as classes definam seu pró prio comportamento em relaçã o aos operadores da lingua-
gem. Por exemplo, se uma classe define um mé todo chamado __getitem__(), e x é uma instâ ncia desta classe,

36 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

entã o x[i] é aproximadamente equivalente a type(x).__getitem__(x, i). Exceto onde mencionado, as ten-
tativas de executar uma operaçã o levantam uma exceçã o quando nenhum mé todo apropriado é definido (tipicamente
AttributeError ou TypeError).

Definir um mé todo especial para None indica que a operaçã o correspondente nã o está disponível. Por exemplo, se
uma classe define __iter__() para None, a classe nã o é iterá vel, entã o chamar iter() em suas instâ ncias irá
levantar um TypeError (sem retroceder para __getitem__()).2
Ao implementar uma classe que emula qualquer tipo embutido, é importante que a emulaçã o seja implementada
apenas na medida em que faça sentido para o objeto que está sendo modelado. Por exemplo, algumas sequê ncias
podem funcionar bem com a recuperaçã o de elementos individuais, mas extrair uma fatia pode nã o fazer sentido.
(Um exemplo disso é a interface NodeList no Document Object Model do W3C.)

3.3.1 Personalização básica

object.__new__(cls , ... )[ ]
Chamado para criar uma nova instâ ncia da classe cls. __new__() é um mé todo está tico (é um caso especial,
entã o você nã o precisa declará -lo como tal) que recebe a classe da qual uma instâ ncia foi solicitada como seu
primeiro argumento. Os argumentos restantes sã o aqueles passados para a expressã o do construtor do objeto
(a chamada para a classe). O valor de retorno de __new__() deve ser a nova instâ ncia do objeto (geralmente
uma instâ ncia de cls).
Implementaçõ es típicas criam uma nova instâ ncia da classe invocando o mé todo __new__() da superclasse
usando super().__new__(cls[, ...]) com os argumentos apropriados e, em seguida, modificando a
instâ ncia recé m-criada conforme necessá rio antes de retorná -la.
Se __new__() é chamado durante a construçã o do objeto e retorna uma instâ ncia de cls, entã o o mé todo
__init__() da nova instâ ncia será chamado como __init__(self[, ...]), onde self é a nova instâ ncia
e os argumentos restantes sã o os mesmos que foram passados para o construtor do objeto.
Se __new__() nã o retornar uma instâ ncia de cls, entã o o mé todo __init__() da nova instâ ncia nã o será
invocado.
__new__() destina-se principalmente a permitir que subclasses de tipos imutá veis (como int, str ou tupla)
personalizem a criaçã o de instâ ncias. També m é comumente substituído em metaclasses personalizadas para
personalizar a criaçã o de classes.
object.__init__(self , ... ) [ ]
Chamado apó s a instâ ncia ter sido criada (por __new__()), mas antes de ser retornada ao chamador. Os
argumentos sã o aqueles passados para a expressã o do construtor da classe. Se uma classe base tem um mé todo
__init__(), o mé todo __init__() da classe derivada, se houver, deve chamá -lo explicitamente para garan-
tir a inicializaçã o apropriada da parte da classe base da instâ ncia; por exemplo: super().__init__([args.
..]).

Porque __new__() e __init__() trabalham juntos na construçã o de objetos (__new__() para criá -lo e
__init__() para personalizá -lo), nenhum valor diferente de None pode ser retornado por __init__();
fazer isso fará com que uma TypeError seja levantada em tempo de execuçã o.
object.__del__(self )
Chamado quando a instâ ncia está prestes a ser destruída. També m é chamada de finalizador ou (incorre-
tamente) de destruidor. Se uma classe base tem um mé todo __del__(), o mé todo __del__() da classe
derivada, se houver, deve chamá -lo explicitamente para garantir a exclusã o adequada da parte da classe base
da instâ ncia.
É possível (embora nã o recomendado!) para o mé todo __del__() adiar a destruiçã o da instâ ncia criando uma
nova referê ncia a ela. Isso é chamado de ressurreição de objeto. Depende se a implementaçã o de __del__()
é chamado uma segunda vez quando um objeto ressuscitado está prestes a ser destruído; a implementaçã o atual
do CPython chama-o apenas uma vez.
2 The __hash__(), __iter__(), __reversed__(), __contains__(), __class_getitem__() and __fspath__() methods have

special handling for this. Others will still raise a TypeError, but may do so by relying on the behavior that None is not callable.

3.3. Nomes de métodos especiais 37

The Python Language Reference, Release 3.13.0

Nã o há garantia de que os mé todos __del__() sejam chamados para objetos que ainda existem quando o
interpretador sai. [Link] fornece uma maneira direta de registrar uma funçã o de limpeza a ser
chamada quando um objeto é coletado como lixo.

® Nota

del x nã o chama diretamente x.__del__() – o primeiro diminui a contagem de referê ncias para x em
um, e o segundo só é chamado quando a contagem de referê ncias de x atinge zero.

Detalhes da implementação do CPython: É possível que um ciclo de referê ncia impeça que a contagem de
referê ncia de um objeto chegue a zero. Neste caso, mais tarde, o ciclo será detectado e deletado pelo coletor de
lixo cíclico. Uma causa comum de referê ncias cíclicas é quando uma exceçã o foi capturada em uma variá vel
local. O locals do quadro entã o referencia a exceçã o, que referencia seu pró prio traceback, que referencia o
locals de todos os quadros capturados no traceback.

µ Ver também

Documentaçã o do mó dulo gc.

Á Aviso

Devido à s circunstâ ncias precá rias sob as quais os mé todos __del__() sã o invocados, as exceçõ es que
ocorrem durante sua execuçã o sã o ignoradas e um aviso é impresso em [Link] em seu lugar. Em
particular:
• __del__() pode ser chamado quando um có digo arbitrá rio está sendo executado, incluindo de
qualquer thread arbitrá ria. Se __del__() precisa bloquear ou invocar qualquer outro recurso de
bloqueio, pode ocorrer um impasse, pois o recurso já pode ter sido levado pelo có digo que é inter-
rompido para executar __del__().
• __del__() pode ser executado durante o encerramento do interpretador. Como consequê ncia, as
variá veis globais que ele precisa acessar (incluindo outros mó dulos) podem já ter sido excluídas ou
definidas como None. Python garante que os globais cujo nome comece com um ú nico sublinhado
sejam excluídos de seu mó dulo antes que outros globais sejam excluídos; se nenhuma outra referê ncia
a tais globais existir, isso pode ajudar a garantir que os mó dulos importados ainda estejam disponíveis
no momento em que o mé todo __del__() for chamado.

object.__repr__(self )
Chamado pela funçã o embutida repr() para calcular a representaçã o da string “oficial” de um objeto. Se
possível, isso deve parecer uma expressã o Python vá lida que pode ser usada para recriar um objeto com o
mesmo valor (dado um ambiente apropriado). Se isso nã o for possível, uma string no formato <...alguma
descrição útil...> deve ser retornada. O valor de retorno deve ser um objeto string. Se uma classe
define __repr__(), mas nã o __str__(), entã o __repr__() també m é usado quando uma representaçã o
de string “informal” de instâ ncias daquela classe é necessá ria.
This is typically used for debugging, so it is important that the representation is information-rich and unambi-
guous. A default implementation is provided by the object class itself.
object.__str__(self )
Called by str(object), the default __format__() implementation, and the built-in function print(), to
compute the “informal” or nicely printable string representation of an object. The return value must be a str
object.
Este mé todo difere de object.__repr__() por nã o haver expectativa de que __str__() retorne uma
expressã o Python vá lida: uma representaçã o mais conveniente ou concisa pode ser usada.
A implementaçã o padrã o definida pelo tipo embutido object chama object.__repr__().

38 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

object.__bytes__(self )
Called by bytes to compute a byte-string representation of an object. This should return a bytes object. The
object class itself does not provide this method.

object.__format__(self, format_spec)
Chamado pela funçã o embutida format() e, por extensã o, avaliaçã o de literais de string formatadas e o
mé todo [Link](), para produzir uma representaçã o de string “formatada” de um objeto. O argumento
format_spec é uma string que conté m uma descriçã o das opçõ es de formataçã o desejadas. A interpretaçã o do
argumento format_spec depende do tipo que implementa __format__(), entretanto a maioria das classes
delegará a formataçã o a um dos tipos embutidos ou usará uma sintaxe de opçã o de formataçã o semelhante.
Consulte formatspec para uma descriçã o da sintaxe de formataçã o padrã o.
O valor de retorno deve ser um objeto string.
The default implementation by the object class should be given an empty format_spec string. It delegates to
__str__().
Alterado na versã o 3.4: O mé todo __format__ do pró prio object levanta uma TypeError se passada qual-
quer string nã o vazia.
Alterado na versã o 3.7: object.__format__(x, '') é agora equivalente a str(x) em vez de
format(str(x), '').

object.__lt__(self, other)
object.__le__(self, other)
object.__eq__(self, other)
object.__ne__(self, other)
object.__gt__(self, other)
object.__ge__(self, other)
Esses sã o os chamados mé todos de “comparaçã o rica”. A correspondê ncia entre os símbolos do operador e
os nomes dos mé todos é a seguinte: x<y chama x.__lt__(y), x<=y chama x.__le__(y), x==y chama
x.__eq__(y), x!=y chama x.__ne__(y), x>y chama x.__gt__(y) e x>=y chama x.__ge__(y).

Um mé todo de comparaçã o rica pode retornar o singleton NotImplemented se nã o implementar a operaçã o
para um determinado par de argumentos. Por convençã o, False e True sã o retornados para uma compa-
raçã o bem-sucedida. No entanto, esses mé todos podem retornar qualquer valor, portanto, se o operador de
comparaçã o for usado em um contexto booleano (por exemplo, na condiçã o de uma instruçã o if), Python irá
chamar bool() no valor para determinar se o resultado for verdadeiro ou falso.
Por padrã o, object implementa __eq__() usando is, retornando NotImplemented no caso de uma com-
paraçã o falsa: True if x is y else NotImplemented. Para __ne__(), por padrã o ele delega para
__eq__() e inverte o resultado a menos que seja NotImplemented. Nã o há outras relaçõ es implícitas en-
tre os operadores de comparaçã o ou implementaçõ es padrã o; por exemplo, o valor verdadeiro de (x<y or
x==y) nã o implica x<=y. Para gerar operaçõ es de ordenaçã o automaticamente a partir de uma ú nica operaçã o
raiz, consulte functools.total_ordering().
By default, the object class provides implementations consistent with Comparações de valor: equality compa-
res according to object identity, and order comparisons raise TypeError. Each default method may generate
these results directly, but may also return NotImplemented.
Veja o pará grafo sobre __hash__() para algumas notas importantes sobre a criaçã o de objetos hasheáveis
que implementam operaçõ es de comparaçã o personalizadas e sã o utilizá veis como chaves de dicioná rio.
Nã o há versõ es de argumentos trocados desses mé todos (a serem usados quando o argumento esquerdo nã o
tem suporte à operaçã o, mas o argumento direito sim); em vez disso, __lt__() e __gt__() sã o o reflexo
um do outro, __le__() e __ge__() sã o o reflexo um do outro, e __eq__() e __ne__() sã o seu pró prio
reflexo. Se os operandos sã o de tipos diferentes e o tipo do operando direito é uma subclasse direta ou indireta
do tipo do operando esquerdo, o mé todo refletido do operando direito tem prioridade, caso contrá rio, o mé todo
do operando esquerdo tem prioridade. Subclasse virtual nã o é considerada.
Quando nenhum mé todo apropriado retorna qualquer valor diferente de NotImplemented, os operadores ==
e != retornarã o para is e is not, respectivamente.

3.3. Nomes de métodos especiais 39

The Python Language Reference, Release 3.13.0

object.__hash__(self )
Chamado pela funçã o embutida hash() e para operaçõ es em membros de coleçõ es com hash incluindo set,
frozenset e dict. O mé todo __hash__() deve retornar um inteiro. A ú nica propriedade necessá ria é que
os objetos que sã o comparados iguais tenham o mesmo valor de hash; é aconselhá vel misturar os valores hash
dos componentes do objeto que també m desempenham um papel na comparaçã o dos objetos, empacotando-os
em uma tupla e fazendo o hash da tupla. Exemplo:

def __hash__(self):
return hash(([Link], [Link], [Link]))

® Nota

hash() trunca o valor retornado do mé todo __hash__() personalizado de um objeto para o tamanho de
um Py_ssize_t. Isso é normalmente 8 bytes em compilaçõ es de 64 bits e 4 bytes em compilaçõ es de
32 bits. Se o __hash__() de um objeto deve interoperar em compilaçõ es de tamanhos de bits diferentes,
certifique-se de verificar a largura em todas as compilaçõ es com suporte. Uma maneira fá cil de fazer isso
é com python -c "import sys; print(sys.hash_info.width)".

Se uma classe nã o define um mé todo __eq__(), ela també m nã o deve definir uma operaçã o __hash__(); se
define __eq__() mas nã o __hash__(), suas instâ ncias nã o serã o utilizá veis como itens em coleçõ es hasheá -
veis. Se uma classe define objetos mutá veis e implementa um mé todo __eq__(), ela nã o deve implementar
__hash__(), uma vez que a implementaçã o de coleçõ es hasheáveis requer que o valor hash de uma chave
seja imutá vel (se o valor hash do objeto mudar, estará no balde de hash errado).
User-defined classes have __eq__() and __hash__() methods by default (inherited from the object class);
with them, all objects compare unequal (except with themselves) and x.__hash__() returns an appropriate
value such that x == y implies both that x is y and hash(x) == hash(y).
Uma classe que sobrescreve __eq__() e nã o define __hash__() terá seu __hash__() implicitamente de-
finido como None. Quando o mé todo __hash__() de uma classe é None, as instâ ncias da classe levantam
uma TypeError apropriada quando um programa tenta recuperar seu valor hash, e també m será identificado
corretamente como nã o-hasheá vel ao verificar isinstance(obj, [Link]).
Se uma classe que substitui __eq__() precisa manter a implementaçã o de __hash__() de uma classe base,
o interpretador deve ser informado disso explicitamente pela configuraçã o __hash__ = <ClasseBase>.
__hash__.

Se uma classe que nã o substitui __eq__() deseja suprimir o suporte a hash, deve incluir __hash__ =
None na definiçã o de classe. Uma classe que define seu pró prio __hash__() que levanta explicitamente
uma TypeError seria incorretamente identificada como hasheá vel por uma chamada isinstance(obj,
[Link]).

® Nota

Por padrã o, os valores __hash__() dos objetos str e bytes sã o “salgados” com um valor aleató rio impre-
visível. Embora permaneçam constantes em um processo individual do Python, eles nã o sã o previsíveis
entre invocaçõ es repetidas do Python.
Isso se destina a fornecer proteçã o contra uma negaçã o de serviço causada por entradas cuidadosamente
escolhidas que exploram o pior caso de desempenho de uma inserçã o de dicioná rio, complexidade O(n2 ).
Consulte [Link] para obter detalhes.
Alterar os valores de hash afeta a ordem de iteraçã o dos conjuntos. Python nunca deu garantias sobre essa
ordem (e normalmente varia entre compilaçõ es de 32 e 64 bits).
Consulte també m PYTHONHASHSEED.

Alterado na versã o 3.3: Aleatorizaçã o de hash está habilitada por padrã o.

40 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

object.__bool__(self )
Called to implement truth value testing and the built-in operation bool(); should return False or True.
When this method is not defined, __len__() is called, if it is defined, and the object is considered true if its
result is nonzero. If a class defines neither __len__() nor __bool__() (which is true of the object class
itself), all its instances are considered true.

3.3.2 Personalizando o acesso aos atributos

Os seguintes mé todos podem ser definidos para personalizar o significado do acesso aos atributos (uso, atribuiçã o ou
exclusã o de [Link]) para instâ ncias de classe.
object.__getattr__(self, name)
Called when the default attribute access fails with an AttributeError (either __getattribute__() raises
an AttributeError because name is not an instance attribute or an attribute in the class tree for self; or
__get__() of a name property raises AttributeError). This method should either return the (computed)
attribute value or raise an AttributeError exception. The object class itself does not provide this method.
Note that if the attribute is found through the normal mechanism, __getattr__() is not called. (This is
an intentional asymmetry between __getattr__() and __setattr__().) This is done both for efficiency
reasons and because otherwise __getattr__() would have no way to access other attributes of the instance.
Note that at least for instance variables, you can take total control by not inserting any values in the instance
attribute dictionary (but instead inserting them in another object). See the __getattribute__() method
below for a way to actually get total control over attribute access.
object.__getattribute__(self, name)
Chamado incondicionalmente para implementar acessos a atributo para instâ ncias da classe. Se a classe tam-
bé m define __getattr__(), o ú ltimo nã o será chamado a menos que __getattribute__() o chame
explicitamente ou levante um AttributeError. Este mé todo deve retornar o valor do atributo (calculado)
ou levantar uma exceçã o AttributeError. Para evitar recursã o infinita neste mé todo, sua implementaçã o
deve sempre chamar o mé todo da classe base com o mesmo nome para acessar quaisquer atributos de que
necessita, por exemplo, object.__getattribute__(self, name).

® Nota

Este mé todo ainda pode ser ignorado ao procurar mé todos especiais como resultado de invocaçã o implícita
por meio da sintaxe da linguagem ou built-in functions. Consulte Pesquisa de método especial.

Para acessos a certos atributos sensíveis, levanta um evento de auditoria object.__getattr__ com os ar-
gumentos obj e name.
object.__setattr__(self, name, value)
Chamado quando se tenta efetuar uma atribuiçã o de atributos. Esse mé todo é chamado em vez do mecanismo
normal (ou seja, armazena o valor no dicioná rio da instâ ncia). name é o nome do atributo, value é o valor a
ser atribuído a ele.
Se __setattr__() deseja atribuir a um atributo de instâ ncia, ele deve chamar o mé todo da classe base com
o mesmo nome, por exemplo, object.__setattr__(self, name, value).
Para atribuiçõ es de certos atributos sensíveis, levanta um evento de auditoria object.__setattr__ com os
argumentos obj, name e value.
object.__delattr__(self, name)
Como __setattr__(), mas para exclusã o de atributo em vez de atribuiçã o. Este mé todo só deve ser imple-
mentado se del [Link] for significativo para o objeto.
Para exclusõ es a certos atributos sensíveis, levanta um evento de auditoria object.__delattr__ com os
argumentos obj e name.
object.__dir__(self )
Called when dir() is called on the object. An iterable must be returned. dir() converts the returned iterable
to a list and sorts it.

3.3. Nomes de métodos especiais 41

The Python Language Reference, Release 3.13.0

Personalizando acesso a atributos de módulos

Os nomes especiais __getattr__ e __dir__ també m podem ser usados para personalizar o acesso aos atributos
dos mó dulos. A funçã o __getattr__ no nível do mó dulo deve aceitar um argumento que é o nome de um atributo e
retornar o valor calculado ou levantar uma exceçã o AttributeError. Se um atributo nã o for encontrado em um ob-
jeto de mó dulo por meio da pesquisa normal, por exemplo object.__getattribute__(), entã o __getattr__
é pesquisado no mó dulo __dict__ antes de levantar AttributeError. Se encontrado, ele é chamado com o nome
do atributo e o resultado é retornado.
The __dir__ function should accept no arguments, and return an iterable of strings that represents the names ac-
cessible on module. If present, this function overrides the standard dir() search on a module.
Para uma personalizaçã o mais refinada do comportamento do mó dulo (definiçã o de atributos, propriedades etc.),
pode-se definir o atributo __class__ de um objeto de mó dulo para uma subclasse de [Link]. Por
exemplo:

import sys
from types import ModuleType

class VerboseModule(ModuleType):
def __repr__(self):
return f'Verbose {self.__name__}'

def __setattr__(self, attr, value):

print(f'Setting {attr}...')
super().__setattr__(attr, value)

[Link][__name__].__class__ = VerboseModule

® Nota

Definir __getattr__ no mó dulo e configurar o __class__ do mó dulo só afeta as pesquisas feitas usando a
sintaxe de acesso ao atributo – acessar diretamente os globais do mó dulo (seja por có digo dentro do mó dulo, ou
por meio de uma referê ncia ao dicioná rio global do mó dulo) nã o tem efeito.

Alterado na versã o 3.5: O atributo de mó dulo __class__ pode agora ser escrito.
Adicionado na versã o 3.7: Atributos de mó dulo __getattr__ e __dir__.

µ Ver também

PEP 562 - __getattr__ e __dir__ de módulo

Descreve as funçõ es __getattr__ e __dir__ nos mó dulos.

Implementando descritores
The following methods only apply when an instance of the class containing the method (a so-called descriptor class)
appears in an owner class (the descriptor must be in either the owner’s class dictionary or in the class dictionary for
one of its parents). In the examples below, “the attribute” refers to the attribute whose name is the key of the property
in the owner class’ __dict__. The object class itself does not implement any of these protocols.
object.__get__(self, instance, owner=None)
Chamado para obter o atributo da classe proprietá ria (acesso ao atributo da classe) ou de uma instâ ncia dessa
classe (acesso ao atributo da instâ ncia). O argumento opcional owner é a classe proprietá ria, enquanto instance
é a instâ ncia pela qual o atributo foi acessado, ou None quando o atributo é acessado por meio de owner.
Este mé todo deve retornar o valor do atributo calculado ou levantar uma exceçã o AttributeError.

42 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

PEP 252 especifica que __get__() é um chamá vel com um ou dois argumentos. Os pró prios descritores
embutidos do Python implementam esta especificaçã o; no entanto, é prová vel que algumas ferramentas de ter-
ceiros tenham descritores que requerem ambos os argumentos. A implementaçã o de __getattribute__()
do pró prio Python sempre passa em ambos os argumentos sejam eles requeridos ou nã o.
object.__set__(self, instance, value)
Chamado para definir o atributo em uma instâ ncia instance da classe proprietá ria para um novo valor, value.
Observe que adicionar __set__() ou __delete__() altera o tipo de descritor para um “descritor de dados”.
Consulte Invocando descritores para mais detalhes.
object.__delete__(self, instance)
Chamado para excluir o atributo em uma instâ ncia instance da classe proprietá ria.
Instâ ncias de descritores també m podem ter o atributo __objclass__ presente:
object.__objclass__
O atributo __objclass__ é interpretado pelo mó dulo inspect como sendo a classe onde este objeto foi
definido (configurar isso apropriadamente pode ajudar na introspecçã o em tempo de execuçã o dos atributos
dinâ micos da classe). Para chamá veis, pode indicar que uma instâ ncia do tipo fornecido (ou uma subclasse)
é esperada ou necessá ria como o primeiro argumento posicional (por exemplo, CPython define este atributo
para mé todos nã o acoplados que sã o implementados em C).

Invocando descritores
Em geral, um descritor é um atributo de objeto com “comportamento de ligaçã o”, cujo acesso ao atributo foi substi-
tuído por mé todos no protocolo do descritor: __get__(), __set__() e __delete__(). Se qualquer um desses
mé todos for definido para um objeto, é considerado um descritor.
O comportamento padrã o para acesso ao atributo é obter, definir ou excluir o atributo do dicioná rio de um ob-
jeto. Por exemplo, a.x tem uma cadeia de pesquisa começando com a.__dict__['x'], depois type(a).
__dict__['x'], e continunando pelas classes bases de type(a) excluindo metaclasses.
No entanto, se o valor pesquisado for um objeto que define um dos mé todos do descritor, Python pode substituir
o comportamento padrã o e invocar o mé todo do descritor. Onde isso ocorre na cadeia de precedê ncia depende de
quais mé todos descritores foram definidos e como eles foram chamados.
O ponto de partida para a invocaçã o do descritor é uma ligaçã o, a.x. Como os argumentos sã o montados depende
de a:
Chamada direta
A chamada mais simples e menos comum é quando o có digo do usuá rio invoca diretamente um mé todo des-
critor: x.__get__(a).
Ligação de instâncias
Se estiver ligando a uma instâ ncia de objeto, a.x é transformado na chamada: type(a).__dict__['x'].
__get__(a, type(a)).
Ligação de classes
Se estiver ligando a uma classe, A.x é transformado na chamada: A.__dict__['x'].__get__(None, A).
Ligação de super
Uma pesquisa pontilhada, ou dotted lookup, como super(A, a).x procura a.__class__.__mro__ por
uma classe base B seguindo A e entã o retorna B.__dict__['x'].__get__(a, A). Se nã o for um descritor,
x é retornado inalterado.

Para ligaçõ es de instâ ncias, a precedê ncia de invocaçã o do descritor depende de quais mé todos do descritor sã o
definidos. Um descritor pode definir qualquer combinaçã o de __get__(), __set__() e __delete__(). Se ele
nã o definir __get__(), entã o acessar o atributo retornará o pró prio objeto descritor, a menos que haja um valor no
dicioná rio de instâ ncia do objeto. Se o descritor define __set__() e/ou __delete__(), é um descritor de dados;
se nã o definir nenhum, é um descritor sem dados. Normalmente, os descritores de dados definem __get__()
e __set__(), enquanto os descritores sem dados tê m apenas o mé todo __get__(). Descritores de dados com
__get__() e __set__() (e/ou __delete__()) definidos sempre substituem uma redefiniçã o em um dicioná rio
de instâ ncia. Em contraste, descritores sem dados podem ser substituídos por instâ ncias.

3.3. Nomes de métodos especiais 43

The Python Language Reference, Release 3.13.0

Os mé todos Python (incluindo aqueles decorados com @staticmethod and @classmethod) sã o implementados
como descritores sem dados. Assim, as instâ ncias podem redefinir e substituir mé todos. Isso permite que instâ ncias
individuais adquiram comportamentos que diferem de outras instâ ncias da mesma classe.
A funçã o property() é implementada como um descritor de dados. Da mesma forma, as instâ ncias nã o podem
substituir o comportamento de uma propriedade.

__slots__
__slots__ permite-nos declarar explicitamente membros de dados (como propriedades) e negar a criaçã o de
__dict__ e __weakref__ (a menos que explicitamente declarado em __slots__ ou disponível em uma classe base.)
O espaço economizado com o uso de __dict__ pode ser significativo. A velocidade de pesquisa de atributos també m
pode ser significativamente melhorada.
object.__slots__
Esta variá vel de classe pode ser atribuída a uma string, iterá vel ou sequê ncia de strings com nomes de variá veis
usados por instâ ncias. __slots__ reserva espaço para as variá veis declaradas e evita a criaçã o automá tica de
__dict__ e __weakref__ para cada instâ ncia.
Observaçõ es ao uso de __slots__:
• Ao herdar de uma classe sem __slots__, os atributos __dict__ e __weakref__ das instâ ncias sempre estarã o
acessíveis.
• Sem uma variá vel __dict__, as instâ ncias nã o podem ser atribuídas a novas variá veis nã o listadas na definiçã o
__slots__. As tentativas de atribuir a um nome de variá vel nã o listado levantam AttributeError. Se a
atribuiçã o dinâ mica de novas variá veis for desejada, entã o adicione '__dict__' à sequê ncia de strings na
declaraçã o de __slots__.
• Sem uma variá vel __weakref__ para cada instâ ncia, as classes que definem __slots__ nã o suportam
referências fracas para suas instâ ncias. Se for necessá rio um suporte de referê ncia fraca, adicione
'__weakref__' à sequê ncia de strings na declaraçã o __slots__.
• __slots__ sã o implementados no nível de classe criando descritores para cada nome de variá vel. Como re-
sultado, os atributos de classe nã o podem ser usados para definir valores padrã o para variá veis de instâ ncia
definidas por __slots__; caso contrá rio, o atributo de classe substituiria a atribuiçã o do descritor.
• The action of a __slots__ declaration is not limited to the class where it is defined. __slots__ declared in parents
are available in child classes. However, instances of a child subclass will get a __dict__ and __weakref__
unless the subclass also defines __slots__ (which should only contain names of any additional slots).
• Se uma classe define um slot també m definido em uma classe base, a variá vel de instâ ncia definida pelo slot
da classe base fica inacessível (exceto por recuperar seu descritor diretamente da classe base). Isso torna o
significado do programa indefinido. No futuro, uma verificaçã o pode ser adicionada para evitar isso.
• TypeError será levantada se __slots__ nã o vazios forem definidos para uma classe derivada de um tipo em-
butido "variable-length" como int, bytes e tuple.
• Qualquer iterável nã o string pode ser atribuído a __slots__.
• Se um dicionário for usado para atribuir __slots__, as chaves do dicioná rio serã o usadas como os nomes
dos slots. Os valores do dicioná rio podem ser usados para fornecer strings de documentaçã o (docstrings) por
atributo que serã o reconhecidos por [Link]() e exibidos na saída de help().
• __class__ assignment works only if both classes have the same __slots__.
• A herança mú ltipla com vá rias classes bases com slots pode ser usada, mas apenas uma classe base tem per-
missã o para ter atributos criados por slots (as outras classes bases devem ter layouts de slots vazios) – violaçõ es
levantam TypeError.
• Se um iterador for usado para __slots__, um descritor é criado para cada um dos valores do iterador. No
entanto, o atributo __slots__ será um iterador vazio.

44 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

3.3.3 Personalizando a criação de classe

Sempre que uma classe herda de outra classe, __init_subclass__() é chamado na classe base. Dessa forma,
é possível escrever classes que alteram o comportamento das subclasses. Isso está intimamente relacionado aos
decoradores de classe, mas onde decoradores de classe afetam apenas a classe específica à qual sã o aplicados,
__init_subclass__ aplica-se apenas a futuras subclasses da classe que define o mé todo.

classmethod object.__init_subclass__(cls)
Este mé todo é chamado sempre que a classe que conté m é uma subclasse. cls é entã o a nova subclasse. Se
definido como um mé todo de instâ ncia normal, esse mé todo é convertido implicitamente em um mé todo de
classe.
Keyword arguments which are given to a new class are passed to the parent class’s __init_subclass__.
For compatibility with other classes using __init_subclass__, one should take out the needed keyword
arguments and pass the others over to the base class, as in:

class Philosopher:
def __init_subclass__(cls, /, default_name, **kwargs):
super().__init_subclass__(**kwargs)
cls.default_name = default_name

class AustralianPhilosopher(Philosopher, default_name="Bruce"):

pass

A implementaçã o padrã o de object.__init_subclass__ nã o faz nada, mas levanta um erro se for cha-
mada com quaisquer argumentos.

® Nota

A dica da metaclasse metaclass é consumida pelo resto da maquinaria de tipo, e nunca é passada para
implementaçõ es __init_subclass__. A metaclasse real (em vez da dica explícita) pode ser acessada
como type(cls).

Adicionado na versã o 3.6.

Quando uma classe é criada, type.__new__() verifica as variá veis de classe e faz chamadas a funçõ es de retorno
(callback) para aqueles com um gancho __set_name__().
object.__set_name__(self, owner, name)
Chamado automaticamente no momento em que a classe proprietá ria owner é criada. O objeto foi atribuído a
name nessa classe:

class A:
x = C() # Automatically calls: x.__set_name__(A, 'x')

Se a variá vel de classe for atribuída apó s a criaçã o da classe, __set_name__() nã o será chamado automati-
camente. Se necessá rio, __set_name__() pode ser chamado diretamente:

class A:
pass

c = C()
A.x = c # The hook is not called
c.__set_name__(A, 'x') # Manually invoke the hook

Consulte Criando o objeto classe para mais detalhes.

Adicionado na versã o 3.6.

3.3. Nomes de métodos especiais 45

The Python Language Reference, Release 3.13.0

Metaclasses
Por padrã o, as classes sã o construídas usando type(). O corpo da classe é executado em um novo espaço de nomes
e o nome da classe é vinculado localmente ao resultado de type(name, bases, namespace).
O processo de criaçã o da classe pode ser personalizado passando o argumento nomeado metaclass na linha de
definiçã o da classe, ou herdando de uma classe existente que incluiu tal argumento. No exemplo a seguir, MyClass
e MySubclass sã o instâ ncias de Meta:

class Meta(type):
pass

class MyClass(metaclass=Meta):
pass

class MySubclass(MyClass):
pass

Quaisquer outros argumentos nomeados especificados na definiçã o de classe sã o transmitidos para todas as operaçõ es
de metaclasse descritas abaixo.
Quando uma definiçã o de classe é executada, as seguintes etapas ocorrem:
• entradas de MRO sã o resolvidas;
• a metaclasse apropriada é determinada;
• o espaço de nomes da classe é preparada;
• o corpo da classe é executado;
• o objeto da classe é criado.

Resolvendo entradas de MRO

object.__mro_entries__(self, bases)
Se uma classe base que aparece em uma definiçã o de classe nã o é uma instâ ncia de type, entã o um mé todo
__mro_entries__() é procurado na base. Se um mé todo __mro_entries__() é encontrado, a base é
substituída pelo resultado de uma chamada para __mro_entries__() ao criar a classe. O mé todo é chamado
com a tupla de bases original passada como parâ metro bases, e deve retornar uma tupla de classes que serã o
usadas no lugar da base. A tupla retornada pode estar vazia: nesses casos, a base original é ignorada.

µ Ver também

types.resolve_bases()
Dinamicamente resolve bases que nã o sã o instâ ncias de type.
types.get_original_bases()
Recupera as “bases originais” de uma classe antes das modificaçõ es feitas por __mro_entries__().
PEP 560
Suporte bá sico para mó dulo typing e tipos gené ricos.

Determinando a metaclasse apropriada

A metaclasse apropriada para uma definiçã o de classe é determinada da seguinte forma:
• se nenhuma classe base e nenhuma metaclasse explícita forem fornecidas, entã o type() é usada;
• se uma metaclasse explícita é fornecida e não é uma instâ ncia de type(), entã o ela é usada diretamente como
a metaclasse;
• se uma instâ ncia de type() é fornecida como a metaclasse explícita, ou classes bases sã o definidas, entã o a
metaclasse mais derivada é usada.

46 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

A metaclasse mais derivada é selecionada a partir da metaclasse explicitamente especificada (se houver) e das me-
taclasses (ou seja, type(cls)) de todas as classes bases especificadas. A metaclasse mais derivada é aquela que é
um subtipo de todas essas metaclasses candidatas. Se nenhuma das metaclasses candidatas atender a esse crité rio, a
definiçã o de classe falhará com TypeError.

Preparando o espaço de nomes da classe

Uma vez identificada a metaclasse apropriada, o espaço de nomes da classe é preparado. Se a metaclasse
tiver um atributo __prepare__, ela será chamada como namespace = metaclass.__prepare__(name,
bases, **kwds) (onde os argumentos nomeados adicionais, se houver, vê m da definiçã o de classe). O mé todo
__prepare__ deve ser implementado como um classmethod. O espaço de nomes retornado por __prepare__
é passado para __new__, mas quando o objeto classe final é criado, o espaço de nomes é copiado para um novo
dict.
Se a metaclasse nã o tiver o atributo __prepare__, entã o o espaço de nomes da classe é inicializado como um
mapeamento ordenado vazio.

µ Ver também

PEP 3115 - Metaclasses no Python 3000

Introduzido o gancho de espaço de nomes __prepare__

Executando o corpo da classe

O corpo da classe é executado (aproximadamente) como exec(body, globals(), namespace). A principal
diferença de uma chamada normal para exec() é que o escopo lé xico permite que o corpo da classe (incluindo
quaisquer mé todos) faça referê ncia a nomes dos escopos atual e externo quando a definiçã o de classe ocorre dentro
de uma funçã o.
No entanto, mesmo quando a definiçã o de classe ocorre dentro da funçã o, os mé todos definidos dentro da classe ainda
nã o podem ver os nomes definidos no escopo da classe. Variá veis de classe devem ser acessadas atravé s do primeiro
parâ metro de instâ ncia ou mé todos de classe, ou atravé s da referê ncia implícita com escopo lé xico __class__
descrita na pró xima seçã o.

Criando o objeto classe

Uma vez que o espaço de nomes da classe tenha sido preenchido executando o corpo da classe, o objeto classe é
criado chamando metaclass(name, bases, namespace, **kwds) (os argumentos adicionais passados aqui
sã o os mesmos passados para __prepare__).
Este objeto classe é aquele que será referenciado pela chamada a super() sem argumentos. __class__ é uma
referê ncia de clausura implícita criada pelo compilador se algum mé todo no corpo da classe se referir a __class__
ou super. Isso permite que a forma de argumento zero de super() identifique corretamente a classe sendo definida
com base no escopo lé xico, enquanto a classe ou instâ ncia que foi usada para fazer a chamada atual é identificada
com base no primeiro argumento passado para o mé todo.
Detalhes da implementação do CPython: No CPython 3.6 e posterior, a cé lula __class__ é passada para a
metaclasse como uma entrada de __classcell__ no espaço de nomes da classe. Se estiver presente, deve ser
propagado até a chamada a type.__new__ para que a classe seja inicializada corretamente. Nã o fazer isso resultará
em um RuntimeError no Python 3.8.
Quando usada a metaclasse padrã o type, ou qualquer metaclasse que chame type.__new__, as seguintes etapas
de personalizaçã o adicionais sã o executadas depois da criaçã o do objeto classe:
1) O mé todo type.__new__ coleta todos os atributos no espaço de nomes da classe que definem um mé todo
__set_name__();

2) Esses mé todos __set_name__ sã o chamados com a classe sendo definida e o nome atribuído para este atributo
específico;
3) O gancho __init_subclass__() é chamado na classe base imediata da nova classe em sua ordem de reso-
luçã o de mé todo.

3.3. Nomes de métodos especiais 47

The Python Language Reference, Release 3.13.0

Depois que o objeto classe é criado, ele é passado para os decoradores de classe incluídos na definiçã o de classe (se
houver) e o objeto resultante é vinculado ao espaço de nomes local como a classe definida.
When a new class is created by type.__new__, the object provided as the namespace parameter is copied to a new
ordered mapping and the original object is discarded. The new copy is wrapped in a read-only proxy, which becomes
the __dict__ attribute of the class object.

µ Ver também

PEP 3135 - Novo super

Descreve a referê ncia de clausura implícita de __class__

Usos para metaclasses

Os usos potenciais para metaclasses sã o ilimitados. Algumas ideias que foram exploradas incluem enumeradores,
criaçã o de log, verificaçã o de interface, delegaçã o automá tica, criaçã o automá tica de propriedade, proxies, estruturas
e travamento/sincronizaçã o automá tico/a de recursos.

3.3.4 Personalizando verificações de instância e subclasse

Os seguintes mé todos sã o usados para substituir o comportamento padrã o das funçõ es embutidas isinstance() e
issubclass().

Em particular, a metaclasse [Link] implementa esses mé todos a fim de permitir a adiçã o de classes base
abstratas (ABCs) como “classes base virtuais” para qualquer classe ou tipo (incluindo tipos embutidos), incluindo
outras ABCs.
type.__instancecheck__(self, instance)
Retorna verdadeiro se instance deve ser considerada uma instâ ncia (direta ou indireta) da classe class. Se
definido, chamado para implementar isinstance(instance, class).
type.__subclasscheck__(self, subclass)
Retorna verdadeiro se subclass deve ser considerada uma subclasse (direta ou indireta) da classe class. Se
definido, chamado para implementar issubclass(subclass, class).
Observe que esses mé todos sã o pesquisados no tipo (metaclasse) de uma classe. Eles nã o podem ser definidos como
mé todos de classe na classe real. Isso é consistente com a pesquisa de mé todos especiais que sã o chamados em
instâ ncias, apenas neste caso a pró pria instâ ncia é uma classe.

µ Ver também

PEP 3119 - Introduzindo classes base abstratas

Includes the specification for customizing isinstance() and issubclass() behavior through
__instancecheck__() and __subclasscheck__(), with motivation for this functionality in the con-
text of adding Abstract Base Classes (see the abc module) to the language.

3.3.5 Emulando tipos genéricos

Quando estiver usando anotações de tipo, é frequentemente ú til parametrizar um tipo genérico usando a notaçã o de
colchetes do Python. Por exemplo, a anotaçã o list[int] pode ser usada para indicar uma list em que todos os
seus elementos sã o do tipo int.

µ Ver também

PEP 484 - Dicas de tipo

Apresenta a estrutura do Python para anotaçõ es de tipo

48 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

Tipos Generic Alias

Documentaçã o de objetos que representam classes gené ricas parametrizadas
Generics, genéricos definidos pelo usuário e [Link]
Documentaçã o sobre como implementar classes gené ricas que podem ser parametrizadas em tempo de
execuçã o e compreendidas por verificadores de tipo está tico.

Uma classe pode geralmente ser parametrizada somente se ela define o mé todo de classe especial
__class_getitem__().

classmethod object.__class_getitem__(cls, key)

Retorna um objeto que representa a especializaçã o de uma classe gené rica por argumentos de tipo encontrados
em key.
Quando definido em uma classe, __class_getitem__() é automaticamente um mé todo de classe. Assim,
nã o é necessá rio que seja decorado com @classmethod quando de sua definiçã o.

O propósito de __class_getitem__
O propó sito de __class_getitem__() é permitir a parametrizaçã o em tempo de execuçã o de classes gené ricas
da biblioteca padrã o, a fim de aplicar mais facilmente dicas de tipo a essas classes.
Para implementar classes gené ricas personalizadas que podem ser parametrizadas em tempo de execuçã o e com-
preendidas por verificadores de tipo está ticos, os usuá rios devem herdar de uma classe da biblioteca padrã o que já
implementa __class_getitem__(), ou herdar de [Link], que possui sua pró pria implementaçã o de
__class_getitem__().
Implementaçõ es personalizadas de __class_getitem__() em classes definidas fora da biblioteca padrã o podem
nã o ser compreendidas por verificadores de tipo de terceiros, como o mypy. O uso de __class_getitem__() em
qualquer classe para fins diferentes de dicas de tipo é desencorajado.

__class_getitem__ versus __getitem__

Normalmente, a subscription de um objeto usando colchetes chamará o mé todo de instâ ncia __getitem__() de-
finido na classe do objeto. No entanto, se o objeto sendo subscrito for ele mesmo uma classe, o mé todo de classe
__class_getitem__() pode ser chamado em seu lugar. __class_getitem__() deve retornar um objeto Ge-
nericAlias se estiver devidamente definido.
Apresentado com a expressão obj[x], o interpretador de Python segue algo parecido com o seguinte processo para
decidir se __getitem__() ou __class_getitem__() deve ser chamado:

from inspect import isclass

def subscribe(obj, x):

"""Return the result of the expression 'obj[x]'"""

class_of_obj = type(obj)

# If the class of obj defines __getitem__,

# call class_of_obj.__getitem__(obj, x)
if hasattr(class_of_obj, '__getitem__'):
return class_of_obj.__getitem__(obj, x)

# Else, if obj is a class and defines __class_getitem__,

# call obj.__class_getitem__(x)
elif isclass(obj) and hasattr(obj, '__class_getitem__'):
return obj.__class_getitem__(x)

# Else, raise an exception

(continua na pró xima pá gina)

3.3. Nomes de métodos especiais 49

The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

else:
raise TypeError(
f"'{class_of_obj.__name__}' object is not subscriptable"
)

Em Python, todas as classes sã o elas mesmas instâ ncias de outras classes. A classe de uma classe é conhecida
como metaclasse dessa classe, e a maioria das classes tem a classe type como sua metaclasse. type nã o define
__getitem__(), o que significa que expressõ es como list[int], dict[str, float] e tuple[str, bytes]
resultam em chamadas para __class_getitem__():

>>> # list has class "type" as its metaclass, like most classes:
>>> type(list)
<class 'type'>
>>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)
True
>>> # "list[int]" calls "list.__class_getitem__(int)"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type(list[int])
<class '[Link]'>

No entanto, se uma classe tiver uma metaclasse personalizada que define __getitem__(), subscrever a classe pode
resultar em comportamento diferente. Um exemplo disso pode ser encontrado no mó dulo enum:

>>> from enum import Enum

>>> class Menu(Enum):
... """A breakfast menu"""
... SPAM = 'spam'
... BACON = 'bacon'
...
>>> # Enum classes have a custom metaclass:
>>> type(Menu)
<class '[Link]'>
>>> # EnumMeta defines __getitem__,
>>> # so __class_getitem__ is not called,
>>> # and the result is not a GenericAlias object:
>>> Menu['SPAM']
<[Link]: 'spam'>
>>> type(Menu['SPAM'])
<enum 'Menu'>

µ Ver também

PEP 560 - Suporte básico para módulo typing e tipos genéricos

Introduz __class_getitem__(), e define quando uma subscrição resulta na chamada de
__class_getitem__() em vez de __getitem__()

3.3.6 Emulando objetos chamáveis

[
object.__call__(self , args... ) ]
Called when the instance is “called” as a function; if this method is defined, x(arg1, arg2, ...) roughly
translates to type(x).__call__(x, arg1, ...). The object class itself does not provide this method.

50 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

3.3.7 Emulando de tipos contêineres

The following methods can be defined to implement container objects. None of them are provided by the object
class itself. Containers usually are sequences (such as lists or tuples) or mappings (like dictionaries), but can
represent other containers as well. The first set of methods is used either to emulate a sequence or to emulate a
mapping; the difference is that for a sequence, the allowable keys should be the integers k for which 0 <= k < N
where N is the length of the sequence, or slice objects, which define a range of items. It is also recommended
that mappings provide the methods keys(), values(), items(), get(), clear(), setdefault(), pop(),
popitem(), copy(), and update() behaving similar to those for Python’s standard dictionary objects. The
[Link] module provides a MutableMapping abstract base class to help create those methods from a
base set of __getitem__(), __setitem__(), __delitem__(), and keys(). Mutable sequences should provide
methods append(), count(), index(), extend(), insert(), pop(), remove(), reverse() and sort(),
like Python standard list objects. Finally, sequence types should implement addition (meaning concatenation) and
multiplication (meaning repetition) by defining the methods __add__(), __radd__(), __iadd__(), __mul__(),
__rmul__() and __imul__() described below; they should not define other numerical operators. It is recommen-
ded that both mappings and sequences implement the __contains__() method to allow efficient use of the in
operator; for mappings, in should search the mapping’s keys; for sequences, it should search through the values. It
is further recommended that both mappings and sequences implement the __iter__() method to allow efficient
iteration through the container; for mappings, __iter__() should iterate through the object’s keys; for sequences,
it should iterate through the values.
object.__len__(self )
Called to implement the built-in function len(). Should return the length of the object, an integer >= 0. Also,
an object that doesn’t define a __bool__() method and whose __len__() method returns zero is considered
to be false in a Boolean context.
Detalhes da implementação do CPython: In CPython, the length is required to be at most [Link].
If the length is larger than [Link] some features (such as len()) may raise OverflowError. To
prevent raising OverflowError by truth value testing, an object must define a __bool__() method.
object.__length_hint__(self )
Called to implement operator.length_hint(). Should return an estimated length for the object (which
may be greater or less than the actual length). The length must be an integer >= 0. The return value may also
be NotImplemented, which is treated the same as if the __length_hint__ method didn’t exist at all. This
method is purely an optimization and is never required for correctness.
Adicionado na versã o 3.4.

® Nota

O fatiamento é feito exclusivamente com os trê s mé todos a seguir. Uma chamada como
a[1:2] = b

é traduzida com
a[slice(1, 2, None)] = b

e assim por diante. Os itens de fatia ausentes sã o sempre preenchidos com None.

object.__getitem__(self, key)
Called to implement evaluation of self[key]. For sequence types, the accepted keys should be integers.
Optionally, they may support slice objects as well. Negative index support is also optional. If key is of an
inappropriate type, TypeError may be raised; if key is a value outside the set of indexes for the sequence
(after any special interpretation of negative values), IndexError should be raised. For mapping types, if key
is missing (not in the container), KeyError should be raised.

® Nota

3.3. Nomes de métodos especiais 51

The Python Language Reference, Release 3.13.0

Os loops for esperam que uma IndexError seja levantada para índices ilegais para permitir a detecçã o
apropriada do fim da sequê ncia.

® Nota

When subscripting a class, the special class method __class_getitem__() may be called instead of
__getitem__(). See __class_getitem__ versus __getitem__ for more details.

object.__setitem__(self, key, value)

Chamado para implementar a atribuiçã o de self[key]. Mesma nota que para __getitem__(). Isso só
deve ser implementado para mapeamentos se os objetos suportarem alteraçõ es nos valores das chaves, ou
se novas chaves puderem ser adicionadas, ou para sequê ncias se os elementos puderem ser substituídos. As
mesmas exceçõ es devem ser levantadas para valores key impró prios do mé todo __getitem__().
object.__delitem__(self, key)
Chamado para implementar a exclusã o de self[key]. Mesma nota que para __getitem__(). Isso só deve
ser implementado para mapeamentos se os objetos suportarem remoçõ es de chaves, ou para sequê ncias se os
elementos puderem ser removidos da sequê ncia. As mesmas exceçõ es devem ser levantadas para valores key
impró prios do mé todo __getitem__().
object.__missing__(self, key)
Chamado por dict.__getitem__() para implementar self[key] para subclasses de dicioná rio quando a
chave nã o estiver no dicioná rio.
object.__iter__(self )
This method is called when an iterator is required for a container. This method should return a new iterator
object that can iterate over all the objects in the container. For mappings, it should iterate over the keys of the
container.
object.__reversed__(self )
Chamado (se presente) pelo reversed() embutido para implementar a iteraçã o reversa. Ele deve retornar
um novo objeto iterador que itera sobre todos os objetos no contê iner na ordem reversa.
Se o mé todo __reversed__() nã o for fornecido, o reversed() embutido voltará a usar o protocolo de
sequê ncia (__len__() e __getitem__()). Objetos que suportam o protocolo de sequê ncia só devem for-
necer __reversed__() se eles puderem fornecer uma implementaçã o que seja mais eficiente do que aquela
fornecida por reversed().
Os operadores de teste de associaçã o (in e not in) sã o normalmente implementados como uma iteraçã o atravé s de
um contê iner. No entanto, os objetos contê iner podem fornecer o seguinte mé todo especial com uma implementaçã o
mais eficiente, que també m nã o requer que o objeto seja iterá vel.
object.__contains__(self, item)
Chamado para implementar operadores de teste de associaçã o. Deve retornar verdadeiro se item estiver em
self, falso caso contrá rio. Para objetos de mapeamento, isso deve considerar as chaves do mapeamento em vez
dos valores ou pares de itens-chave.
Para objetos que nã o definem __contains__(), o teste de associaçã o primeiro tenta a iteraçã o via
__iter__(), depois o protocolo de iteraçã o de sequê ncia antigo via __getitem__(), consulte esta seção
em a referência da linguagem.

3.3.8 Emulando tipos numéricos

Os mé todos a seguir podem ser definidos para emular objetos numé ricos. Mé todos correspondentes a operaçõ es que
nã o sã o suportadas pelo tipo particular de nú mero implementado (por exemplo, operaçõ es bit a bit para nú meros nã o
inteiros) devem ser deixados indefinidos.
object.__add__(self, other)

52 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

object.__sub__(self, other)
object.__mul__(self, other)
object.__matmul__(self, other)
object.__truediv__(self, other)
object.__floordiv__(self, other)
object.__mod__(self, other)
object.__divmod__(self, other)
object.__pow__(self, other , modulo ) [ ]
object.__lshift__(self, other)
object.__rshift__(self, other)
object.__and__(self, other)
object.__xor__(self, other)
object.__or__(self, other)
These methods are called to implement the binary arithmetic operations (+, -, *, @, /, //, %, divmod(),
pow(), **, <<, >>, &, ^, |). For instance, to evaluate the expression x + y, where x is an instance of a class
that has an __add__() method, type(x).__add__(x, y) is called. The __divmod__() method should
be the equivalent to using __floordiv__() and __mod__(); it should not be related to __truediv__().
Note that __pow__() should be defined to accept an optional third argument if the ternary version of the
built-in pow() function is to be supported.
If one of those methods does not support the operation with the supplied arguments, it should return
NotImplemented.
object.__radd__(self, other)
object.__rsub__(self, other)
object.__rmul__(self, other)
object.__rmatmul__(self, other)
object.__rtruediv__(self, other)
object.__rfloordiv__(self, other)
object.__rmod__(self, other)
object.__rdivmod__(self, other)
object.__rpow__(self, other , modulo ) [ ]
object.__rlshift__(self, other)
object.__rrshift__(self, other)
object.__rand__(self, other)
object.__rxor__(self, other)
object.__ror__(self, other)
These methods are called to implement the binary arithmetic operations (+, -, *, @, /, //, %, divmod(),
pow(), **, <<, >>, &, ^, |) with reflected (swapped) operands. These functions are only called if the left
operand does not support the corresponding operation3 and the operands are of different types.4 For instance,
to evaluate the expression x - y, where y is an instance of a class that has an __rsub__() method, type(y).
__rsub__(y, x) is called if type(x).__sub__(x, y) returns NotImplemented.

Note que terná rio pow() nã o tentará chamar __rpow__() (as regras de coerçã o se tornariam muito compli-
cadas).

3 “Does not support” here means that the class has no such method, or the method returns NotImplemented. Do not set the method to None

if you want to force fallback to the right operand’s reflected method—that will instead have the opposite effect of explicitly blocking such fallback.
4 For operands of the same type, it is assumed that if the non-reflected method – such as __add__() – fails then the overall operation is not

supported, which is why the reflected method is not called.

3.3. Nomes de métodos especiais 53

The Python Language Reference, Release 3.13.0

® Nota

Se o tipo do operando direito for uma subclasse do tipo do operando esquerdo e essa subclasse fornecer
uma implementaçã o diferente do mé todo refletido para a operaçã o, este mé todo será chamado antes do
mé todo nã o refletido do operando esquerdo. Esse comportamento permite que as subclasses substituam as
operaçõ es de seus ancestrais.

object.__iadd__(self, other)
object.__isub__(self, other)
object.__imul__(self, other)
object.__imatmul__(self, other)
object.__itruediv__(self, other)
object.__ifloordiv__(self, other)
object.__imod__(self, other)
[
object.__ipow__(self, other , modulo ) ]
object.__ilshift__(self, other)
object.__irshift__(self, other)
object.__iand__(self, other)
object.__ixor__(self, other)
object.__ior__(self, other)
These methods are called to implement the augmented arithmetic assignments (+=, -=, *=, @=, /=, //=, %=,
**=, <<=, >>=, &=, ^=, |=). These methods should attempt to do the operation in-place (modifying self) and
return the result (which could be, but does not have to be, self). If a specific method is not defined, or if that
method returns NotImplemented, the augmented assignment falls back to the normal methods. For instance,
if x is an instance of a class with an __iadd__() method, x += y is equivalent to x = x.__iadd__(y)
. If __iadd__() does not exist, or if x.__iadd__(y) returns NotImplemented, x.__add__(y) and y.
__radd__(x) are considered, as with the evaluation of x + y. In certain situations, augmented assignment
can result in unexpected errors (see faq-augmented-assignment-tuple-error), but this behavior is in fact part of
the data model.
object.__neg__(self )
object.__pos__(self )
object.__abs__(self )
object.__invert__(self )
Chamado para implementar as operaçõ es aritmé ticas uná rias (-, +, abs() e ~).
object.__complex__(self )
object.__int__(self )
object.__float__(self )
Chamado para implementar as funçõ es embutidas complex(), int() e float(). Deve retornar um valor
do tipo apropriado.
object.__index__(self )
Chamado para implementar [Link](), e sempre que o Python precisar converter sem perdas o
objeto numé rico em um objeto inteiro (como no fatiamento ou nas funçõ es embutidas bin(), hex() e oct()).
A presença deste mé todo indica que o objeto numé rico é do tipo inteiro. Deve retornar um nú mero inteiro.
Se __int__(), __float__() e __complex__() nã o estiverem definidos, funçõ es embutidas correspon-
dentes int(), float() e complex() recorre a __index__().
[
object.__round__(self , ndigits ) ]
object.__trunc__(self )
object.__floor__(self )

54 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

object.__ceil__(self )
Chamado para implementar as funçõ es embutidas round() e trunc(), floor() e ceil() de math. A
menos que ndigits sejam passados para __round__() todos estes mé todos devem retornar o valor do objeto
truncado para um Integral (tipicamente um int).
The built-in function int() falls back to __trunc__() if neither __int__() nor __index__() is defined.
Alterado na versã o 3.11: The delegation of int() to __trunc__() is deprecated.

3.3.9 Gerenciadores de contexto da instrução with

Um gerenciador de contexto é um objeto que define o contexto de tempo de execuçã o a ser estabelecido ao executar
uma instruçã o with. O gerenciador de contexto lida com a entrada e a saída do contexto de tempo de execuçã o
desejado para a execuçã o do bloco de có digo. Os gerenciadores de contexto sã o normalmente invocados usando a
instruçã o with (descrita na seçã o A instrução with), mas també m podem ser usados invocando diretamente seus
mé todos.
Os usos típicos de gerenciadores de contexto incluem salvar e restaurar vá rios tipos de estado global, travar e destravar
recursos, fechar arquivos abertos, etc.
For more information on context managers, see typecontextmanager. The object class itself does not provide the
context manager methods.
object.__enter__(self )
Insere o contexto de tempo de execuçã o relacionado a este objeto. A instruçã o with vinculará o valor de
retorno deste mé todo ao(s) alvo(s) especificado(s) na clá usula as da instruçã o, se houver.
object.__exit__(self, exc_type, exc_value, traceback)
Sai do contexto de tempo de execuçã o relacionado a este objeto. Os parâ metros descrevem a exceçã o que fez
com que o contexto fosse encerrado. Se o contexto foi encerrado sem exceçã o, todos os trê s argumentos serã o
None.

Se uma exceçã o for fornecida e o mé todo desejar suprimir a exceçã o (ou seja, evitar que ela seja propagada),
ele deve retornar um valor verdadeiro. Caso contrá rio, a exceçã o será processada normalmente ao sair deste
mé todo.
Note that __exit__() methods should not reraise the passed-in exception; this is the caller’s responsibility.

µ Ver também

PEP 343 - A instrução “with”

A especificaçã o, o histó rico e os exemplos para a instruçã o Python with.

3.3.10 Customizando argumentos posicionais na classe correspondência de pa-

drão
When using a class name in a pattern, positional arguments in the pattern are not allowed by default, i.e. case
MyClass(x, y) is typically invalid without special support in MyClass. To be able to use that kind of pattern, the
class needs to define a __match_args__ attribute.
object.__match_args__
Essa variá vel de classe pode ser atribuída a uma tupla de strings. Quando essa classe é usada em uma classe
padrã o com argumentos posicionais, cada argumento posicional será convertido para um argumento nomeado,
usando correspondê ncia de valor em __match_args__ como palavra reservada. A ausê ncia desse atributo é
equivalente a defini-lo como ()
Por exemplo, se MyClass.__match_args__ é ("left", "center", "right") significa que case
MyClass(x, y) é equivalente a case MyClass(left=x, center=y). Note que o nú mero de argumentos
no padrã o deve ser menor ou igual ao nú mero de elementos em __match_args__; caso seja maior, a tentativa de
correspondê ncia de padrã o irá levantar uma TypeError.

3.3. Nomes de métodos especiais 55

The Python Language Reference, Release 3.13.0

Adicionado na versã o 3.10.

µ Ver também

PEP 634 - Correspondência de Padrão Estrutural

A especificaçã o para a instruçã o Python match

3.3.11 Emulating buffer types

The buffer protocol provides a way for Python objects to expose efficient access to a low-level memory array. This
protocol is implemented by builtin types such as bytes and memoryview, and third-party libraries may define
additional buffer types.
While buffer types are usually implemented in C, it is also possible to implement the protocol in Python.
object.__buffer__(self, flags)
Called when a buffer is requested from self (for example, by the memoryview constructor). The flags argument
is an integer representing the kind of buffer requested, affecting for example whether the returned buffer is read-
-only or writable. [Link] provides a convenient way to interpret the flags. The method must
return a memoryview object.
object.__release_buffer__(self, buffer)
Called when a buffer is no longer needed. The buffer argument is a memoryview object that was previously
returned by __buffer__(). The method must release any resources associated with the buffer. This method
should return None. Buffer objects that do not need to perform any cleanup are not required to implement this
method.
Adicionado na versã o 3.12.

µ Ver também

PEP 688 - Making the buffer protocol accessible in Python

Introduces the Python __buffer__ and __release_buffer__ methods.
[Link]
ABC for buffer types.

3.3.12 Pesquisa de método especial

Para classes personalizadas, as invocaçõ es implícitas de mé todos especiais só tê m garantia de funcionar corretamente
se definidas em um tipo de objeto, nã o no dicioná rio de instâ ncia do objeto. Esse comportamento é o motivo pelo
qual o có digo a seguir levanta uma exceçã o:

>>> class C:
... pass
...
>>> c = C()
>>> c.__len__ = lambda: 5
>>> len(c)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: object of type 'C' has no len()

The rationale behind this behaviour lies with a number of special methods such as __hash__() and __repr__()
that are implemented by all objects, including type objects. If the implicit lookup of these methods used the con-
ventional lookup process, they would fail when invoked on the type object itself:

56 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

>>> 1 .__hash__() == hash(1)

True
>>> int.__hash__() == hash(int)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: descriptor '__hash__' of 'int' object needs an argument

A tentativa incorreta de invocar um mé todo nã o vinculado de uma classe dessa maneira é à s vezes referida como
“confusã o de metaclasse” e é evitada ignorando a instâ ncia ao pesquisar mé todos especiais:

>>> type(1).__hash__(1) == hash(1)

True
>>> type(int).__hash__(int) == hash(int)
True

In addition to bypassing any instance attributes in the interest of correctness, implicit special method lookup generally
also bypasses the __getattribute__() method even of the object’s metaclass:

>>> class Meta(type):

... def __getattribute__(*args):
... print("Metaclass getattribute invoked")
... return type.__getattribute__(*args)
...
>>> class C(object, metaclass=Meta):
... def __len__(self):
... return 10
... def __getattribute__(*args):
... print("Class getattribute invoked")
... return object.__getattribute__(*args)
...
>>> c = C()
>>> c.__len__() # Explicit lookup via instance
Class getattribute invoked
10
>>> type(c).__len__(c) # Explicit lookup via type
Metaclass getattribute invoked
10
>>> len(c) # Implicit lookup
10

Bypassing the __getattribute__() machinery in this fashion provides significant scope for speed optimisations
within the interpreter, at the cost of some flexibility in the handling of special methods (the special method must be
set on the class object itself in order to be consistently invoked by the interpreter).

3.4 Corrotinas
3.4.1 Objetos aguardáveis
An awaitable object generally implements an __await__() method. Coroutine objects returned from async def
functions are awaitable.

® Nota

The generator iterator objects returned from generators decorated with [Link]() are also awaitable,
but they do not implement __await__().

3.4. Corrotinas 57
The Python Language Reference, Release 3.13.0

object.__await__(self )
Must return an iterator. Should be used to implement awaitable objects. For instance, [Link]
implements this method to be compatible with the await expression. The object class itself is not awaitable
and does not provide this method.

® Nota

The language doesn’t place any restriction on the type or value of the objects yielded by the iterator returned
by __await__, as this is specific to the implementation of the asynchronous execution framework (e.g.
asyncio) that will be managing the awaitable object.

Adicionado na versã o 3.5.

µ Ver também

PEP 492 para informaçõ es adicionais sobre objetos aguardá veis.

3.4.2 Objetos corrotina

Coroutine objects are awaitable objects. A coroutine’s execution can be controlled by calling __await__() and
iterating over the result. When the coroutine has finished executing and returns, the iterator raises StopIteration,
and the exception’s value attribute holds the return value. If the coroutine raises an exception, it is propagated by
the iterator. Coroutines should not directly raise unhandled StopIteration exceptions.
As corrotinas també m tê m os mé todos listados abaixo, que sã o aná logos aos dos geradores (ver Métodos de iterador
gerador). No entanto, ao contrá rio dos geradores, as corrotinas nã o suportam diretamente a iteraçã o.
Alterado na versã o 3.5.2: É uma RuntimeError para aguardar uma corrotina mais de uma vez.
[Link](value)
Starts or resumes execution of the coroutine. If value is None, this is equivalent to advancing the iterator
returned by __await__(). If value is not None, this method delegates to the send() method of the iterator
that caused the coroutine to suspend. The result (return value, StopIteration, or other exception) is the
same as when iterating over the __await__() return value, described above.
[Link](value)
[ [
[Link](type , value , traceback ]])
Raises the specified exception in the coroutine. This method delegates to the throw() method of the iterator
that caused the coroutine to suspend, if it has such a method. Otherwise, the exception is raised at the suspen-
sion point. The result (return value, StopIteration, or other exception) is the same as when iterating over
the __await__() return value, described above. If the exception is not caught in the coroutine, it propagates
back to the caller.
Alterado na versã o 3.12: A segunda assinatura (tipo[, valor[, traceback]]]) foi descontinuada e pode ser remo-
vida em uma versã o futura do Python.
[Link]()
Faz com que a corrotina se limpe e saia. Se a corrotina for suspensa, este mé todo primeiro delega para o
mé todo close() do iterador que causou a suspensã o da corrotina, se tiver tal mé todo. Entã o ele levanta
GeneratorExit no ponto de suspensã o, fazendo com que a corrotina se limpe imediatamente. Por fim, a
corrotina é marcada como tendo sua execuçã o concluída, mesmo que nunca tenha sido iniciada.
Objetos corrotina sã o fechados automaticamente usando o processo acima quando estã o prestes a ser destruí-
dos.

58 Capítulo 3. Modelo de dados

 The Python Language Reference, Release 3.13.0

3.4.3 Iteradores assíncronos

Um iterador assíncrono pode chamar có digo assíncrono em seu mé todo __anext__.
Os iteradores assíncronos podem ser usados em uma instruçã o async for.
The object class itself does not provide these methods.
object.__aiter__(self )
Deve retornar um objeto iterador assíncrono.
object.__anext__(self )
Deve retornar um aguardável resultando em um pró ximo valor do iterador. Deve levantar um erro
StopAsyncIteration quando a iteraçã o terminar.
Um exemplo de objeto iterá vel assíncrono:

class Reader:
async def readline(self):
...

def __aiter__(self):
return self

async def __anext__(self):

val = await [Link]()
if val == b'':
raise StopAsyncIteration
return val

Adicionado na versã o 3.5.

Alterado na versã o 3.7: Prior to Python 3.7, __aiter__() could return an awaitable that would resolve to an
asynchronous iterator.
Starting with Python 3.7, __aiter__() must return an asynchronous iterator object. Returning anything else will
result in a TypeError error.

3.4.4 Gerenciadores de contexto assíncronos

Um gerenciador de contexto assíncrono é um gerenciador de contexto que é capaz de suspender a execuçã o em seus
mé todos __aenter__ e __aexit__.
Os gerenciadores de contexto assíncronos podem ser usados em uma instruçã o async with.
The object class itself does not provide these methods.
object.__aenter__(self )
Semantically similar to __enter__(), the only difference being that it must return an awaitable.
object.__aexit__(self, exc_type, exc_value, traceback)
Semantically similar to __exit__(), the only difference being that it must return an awaitable.
Um exemplo de uma classe gerenciadora de contexto assíncrona:

class AsyncContextManager:
async def __aenter__(self):
await log('entering context')

async def __aexit__(self, exc_type, exc, tb):

await log('exiting context')

Adicionado na versã o 3.5.

3.4. Corrotinas 59
The Python Language Reference, Release 3.13.0

60 Capítulo 3. Modelo de dados

 CAPÍTULO 4

Modelo de execução

4.1 Estrutura de um programa

Um programa Python é construído a partir de blocos de có digo. Um bloco é um pedaço do texto do programa Python
que é executado como uma unidade. A seguir estã o os blocos: um mó dulo, um corpo de funçã o e uma definiçã o
de classe. Cada comando digitado interativamente é um bloco. Um arquivo de script (um arquivo fornecido como
entrada padrã o para o interpretador ou especificado como argumento de linha de comando para o interpretador)
é um bloco de có digo. Um comando de script (um comando especificado na linha de comando do interpretador
com a opçã o -c) é um bloco de có digo. Um mó dulo executado sobre um script de nível superior (como o mó dulo
__main__) a partir da linha de comando usando um argumento -m també m é um bloco de có digo. O argumento da
string passado para as funçõ es embutidas eval() e exec() é um bloco de có digo.
Um bloco de có digo é executado em um quadro de execução. Um quadro conté m algumas informaçõ es administra-
tivas (usadas para depuraçã o) e determina onde e como a execuçã o continua apó s a conclusã o do bloco de có digo.

4.2 Nomeação e ligação

4.2.1 Ligação de nomes
Nomes referem-se a objetos. Os nomes sã o introduzidos por operaçõ es de ligaçã o de nomes.
As seguintes construçõ es ligam nomes:
• parâ metros formais para funçõ es,
• definiçõ es de classe,
• definiçõ es de funçã o,
• expressõ es de atribuiçã o,
• alvos que sã o identificadores se ocorrerem em uma atribuiçã o:
– cabeçalho de laço for,
– depois de as em uma instruçã o with, clá usula except, clá usula except* ou no padrã o as na corres-
pondê ncia de padrõ es estruturais,
– em um padrã o de captura na correspondê ncia de padrõ es estruturais
• instruçõ es import.

61
The Python Language Reference, Release 3.13.0

• instruçõ es type.
• listas de parâmetros de tipo.
A instruçã o import no formato from ... import * liga todos os nomes definidos no mó dulo importado, exceto
aqueles que começam com um sublinhado. Este formulá rio só pode ser usado no nível do mó dulo.
Um alvo ocorrendo em uma instruçã o del també m é considerado ligado a esse propó sito (embora a semâ ntica real
seja para desligar do nome).
Cada atribuiçã o ou instruçã o de importaçã o ocorre dentro de um bloco definido por uma definiçã o de classe ou funçã o
ou no nível do mó dulo (o bloco de có digo de nível superior).
Se um nome está ligado a um bloco, é uma variá vel local desse bloco, a menos que declarado como nonlocal ou
global. Se um nome está ligado a nível do mó dulo, é uma variá vel global. (As variá veis do bloco de có digo do
mó dulo sã o locais e globais.) Se uma variá vel for usada em um bloco de có digo, mas nã o definida lá , é uma variável
livre.
Cada ocorrê ncia de um nome no texto do programa se refere à ligação daquele nome estabelecido pelas seguintes
regras de resoluçã o de nome.

4.2.2 Resolução de nomes

O escopo define a visibilidade de um nome dentro de um bloco. Se uma variá vel local é definida em um bloco, seu
escopo inclui esse bloco. Se a definiçã o ocorrer em um bloco de funçã o, o escopo se estende a quaisquer blocos
contidos no bloco de definiçã o, a menos que um bloco contido introduza uma ligaçã o diferente para o nome.
Quando um nome é usado em um bloco de có digo, ele é resolvido usando o escopo envolvente mais pró ximo. O
conjunto de todos esses escopos visíveis a um bloco de có digo é chamado de ambiente do bloco.
Quando um nome nã o é encontrado, uma exceçã o NameError é levantada. Se o escopo atual for um escopo de
funçã o e o nome se referir a uma variá vel local que ainda nã o foi associada a um valor no ponto onde o nome é usado,
uma exceçã o UnboundLocalError é levantada. UnboundLocalError é uma subclasse de NameError.
Se a operaçã o de ligaçã o de nomes ocorre dentro de um bloco de có digo, todos os usos do nome dentro do bloco sã o
tratadas como referê ncias para o bloco atual. Isso pode. Isso pode levar a erros quando um nome é usado em um
bloco antes de ser vinculado. Esta regra é sutil. Python carece de declaraçõ es e permite que as operaçõ es de ligaçã o
de nomes ocorram em qualquer lugar dentro de um bloco de có digo. As variá veis locais de um bloco de có digo
podem ser determinadas pela varredura de todo o texto do bloco para operaçõ es de ligaçã o de nome. Veja the FAQ
entry on UnboundLocalError para exemplos.
Se a instruçã o global ocorrer dentro de um bloco, todos os usos dos nomes especificados na instruçã o referem-se
à s ligaçõ es desses nomes no espaço de nomes de nível superior. Os nomes sã o resolvidos no espaço de nomes de
nível superior pesquisando o espaço de nomes global, ou seja, o espaço de nomes do mó dulo que conté m o bloco
de có digo, e o espaço de nomes embutido, o espaço de nomes do mó dulo builtins. O espaço de nomes global
é pesquisado primeiro. Se os nomes nã o forem encontrados lá , o espaço de nomes embutidos será pesquisado em
seguida. Se os nomes també m nã o forem encontrados no espaço de nomes embutido, novas variá veis sã o criadas no
espaço de nomes global. A instruçã o global deve preceder todos os usos dos nomes listados.
A instruçã o global tem o mesmo escopo que uma operaçã o de ligaçã o de nome no mesmo bloco. Se o escopo mais
pró ximo de uma variá vel livre contiver uma instruçã o global, a variá vel livre será tratada como global.
A instruçã o nonlocal faz com que os nomes correspondentes se refiram a variá veis previamente vinculadas no
escopo da funçã o delimitadora mais pró xima. A exceçã o SyntaxError é levantada em tempo de compilaçã o se o
nome fornecido nã o existir em nenhum escopo de funçã o delimitador. Parâmetros de tipo nã o podem ser vinculadas
novamente com a instruçã o nonlocal.
O espaço de nomes de um mó dulo é criado automaticamente na primeira vez que um mó dulo é importado. O mó dulo
principal de um script é sempre chamado de __main__.
Blocos de definiçã o de classe e argumentos para exec() e eval() sã o especiais no contexto de resoluçã o de nome.
Uma definiçã o de classe é uma instruçã o executá vel que pode usar e definir nomes. Essas referê ncias seguem as regras
normais para resoluçã o de nome, com exceçã o de que variá veis locais nã o vinculadas sã o pesquisadas no espaço de
nomes global global. O espaço de nomes global da definiçã o de classe se torna o dicioná rio de atributos da classe. O
escopo dos nomes definidos em um bloco de classe é limitado ao bloco de classe; ele nã o se estende aos blocos de

62 Capítulo 4. Modelo de execução

 The Python Language Reference, Release 3.13.0

có digo de mé todos. Isso inclui compreensõ es e expressõ es geradoras, mas nã o inclui escopos de anotação, que tê m
acesso a seus escopos de classe delimitadores. Isso significa que o seguinte falhará :

class A:
a = 42
b = list(a + i for i in range(10))

Poré m, o seguinte vai funcionar:

class A:
type Alias = Nested
class Nested: pass

print([Link].__value__) # <type '[Link]'>

4.2.3 Escopos de anotação

As instruçõ es type e listas de parâmetros de tipo introduzem escopos de anotação, que se comportam principalmente
como escopos de funçã o, mas com algumas exceçõ es discutidas abaixo. Anotações atualmente nã o usam escopos de
anotaçã o, mas espera-se que elas usem escopos de anotaçã o no Python 3.13 quando PEP 649 for implementada.
Os escopos de anotaçã o sã o usados nos seguintes contextos:
• Listas de parâ metros de tipo para apelidos de tipo genérico.
• Listas de parâ metros de tipo para funções genéricas. As anotaçõ es de uma funçã o gené rica sã o executadas
dentro do escopo de anotaçã o, mas seus padrõ es e decoradores nã o.
• Listas de parâ metros de tipo para classes genéricas. As classes base e argumentos nomeados de uma classe
gené rica sã o executadas dentro do escopo de anotaçã o, mas seus decoradores nã o.
• Os limites, restriçõ es e valores padrã o para parâ metros de tipo (avaliados preguiçosamente).
• O valor dos apelidos de tipo (avaliado preguiçosamente).
Escopos de anotaçã o diferenciam-se de escopos de funçã o nas seguintes formas:
• Os escopos de anotaçã o tê m acesso ao espaço de nomes da classe delimitadora. Se um escopo de anotaçã o
estiver imediatamente dentro de um escopo de classe ou dentro de outro escopo de anotaçã o que esteja ime-
diatamente dentro de um escopo de classe, o có digo no escopo de anotaçã o poderá usar nomes definidos no
escopo de classe como se fosse executado diretamente no corpo da classe. Isto contrasta com funçõ es regulares
definidas dentro de classes, que nã o podem acessar nomes definidos no escopo da classe.
• Expressõ es em escopos de anotaçã o nã o podem conter expressõ es yield, yield from, await ou := 1.
(Essas expressõ es sã o permitidas em outros escopos contidos no escopo de anotaçã o.)
• Nomes definidos em escopos de anotaçã o nã o podem ser vinculados novamente com instruçõ es nonlocal
em escopos internos. Isso inclui apenas parâ metros de tipo, pois nenhum outro elemento sintá tico que pode
aparecer nos escopos de anotaçã o pode introduzir novos nomes.
• Embora os escopos de anotaçã o tenham um nome interno, esse nome nã o é refletido no nome qualificado dos
objetos definidos dentro do escopo. Em vez disso, o __qualname__ de tais objetos é como se o objeto fosse
definido no escopo delimitador.
Adicionado na versã o 3.12: Escopos de anotaçã o foram introduzidos no Python 3.12 como parte da PEP 695.
Alterado na versã o 3.13: Os escopos de anotaçã o també m sã o usados para padrõ es de parâ metros de tipo, conforme
introduzido pela PEP 696.

4.2.4 Avaliação preguiçosa

Os valores dos apelidos de tipo criados atravé s da instruçã o type sã o avaliados preguiçosamente. O mesmo se aplica
aos limites, restriçõ es e valores padrã o de variá veis de tipo criadas atravé s da sintaxe do parâmetro de tipo. Isso
significa que eles nã o sã o avaliados quando o apelido de tipo ou a variá vel de tipo é criado. Em vez disso, eles sã o
avaliados apenas quando isso é necessá rio para resolver um acesso de atributo.

4.2. Nomeação e ligação 63

The Python Language Reference, Release 3.13.0

Exemplo:

>>> type Alias = 1/0

>>> Alias.__value__
Traceback (most recent call last):
...
ZeroDivisionError: division by zero
>>> def func[T: 1/0](): pass
>>> T = func.__type_params__[0]
>>> T.__bound__
Traceback (most recent call last):
...
ZeroDivisionError: division by zero

Aqui a exceçã o é levantada apenas quando o atributo __value__ do apelido de tipo ou o atributo __bound__ da
variá vel de tipo é acessado.
Esse comportamento é ú til principalmente para referê ncias a tipos que ainda nã o foram definidos quando o alias
de tipo ou variá vel de tipo é criado. Por exemplo, a avaliaçã o preguiçosa permite a criaçã o de apelidos de tipo
mutuamente recursivos:

from typing import Literal

type SimpleExpr = int | Parenthesized

type Parenthesized = tuple[Literal["("], Expr, Literal[")"]]
type Expr = SimpleExpr | tuple[SimpleExpr, Literal["+", "-"], Expr]

Valores avaliados preguiçosamente sã o avaliados em escopo de anotação, o que significa que os nomes que apare-
cem dentro do valor avaliado preguiçosamente sã o pesquisados como se fossem usados no escopo imediatamente
envolvente.
Adicionado na versã o 3.12.

4.2.5 Builtins e execução restrita

Detalhes da implementação do CPython: Os usuá rios nã o devem tocar em __builtins__; é estritamente um
detalhe de implementaçã o. Usuá rios que desejam substituir valores no espaço de nomes interno devem import o
mó dulo builtins e modificar seus atributos apropriadamente.
O espaço de nomes builtins associado com a execuçã o de um bloco de có digo é encontrado procurando o nome
__builtins__ em seu espaço de nomes global; este deve ser um dicioná rio ou um mó dulo (no ú ltimo caso, o
dicioná rio do mó dulo é usado). Por padrã o, quando no mó dulo __main__, __builtins__ é o mó dulo embutido
builtins; quando em qualquer outro mó dulo, __builtins__ é um apelido para o dicioná rio do pró prio mó dulo
builtins.

4.2.6 Interação com recursos dinâmicos

A resoluçã o de nome de variá veis livres ocorre em tempo de execuçã o, nã o em tempo de compilaçã o. Isso significa
que o có digo a seguir imprimirá 42:

i = 10
def f():
print(i)
i = 42
f()

As funçõ es eval() e exec() nã o tê m acesso ao ambiente completo para resoluçã o de nome. Os nomes podem ser
resolvidos nos espaços de nomes locais e globais do chamador. Variá veis livres nã o sã o resolvidas no espaço de nomes
mais pró ximo, mas no espaço de nomes global.1 As funçõ es exec() e eval() possuem argumentos opcionais para
1 Essa limitaçã o ocorre porque o có digo executado por essas operaçõ es nã o está disponível no momento em que o mó dulo é compilado.

64 Capítulo 4. Modelo de execução

 The Python Language Reference, Release 3.13.0

substituir o espaço de nomes global e local. Se apenas um espaço de nomes for especificado, ele será usado para
ambos.

4.3 Exceções
As exceçõ es sã o um meio de romper o fluxo normal de controle de um bloco de có digo para tratar erros ou outras
condiçõ es excepcionais. Uma exceçã o é levantada no ponto em que o erro é detectado; ele pode ser tratado pelo
bloco de có digo circundante ou por qualquer bloco de có digo que invocou direta ou indiretamente o bloco de có digo
onde ocorreu o erro.
O interpretador Python levanta uma exceçã o quando detecta um erro em tempo de execuçã o (como divisã o por zero).
Um programa Python també m pode levantar explicitamente uma exceçã o com a instruçã o raise. Os tratadores de
exceçã o sã o especificados com a instruçã o try … except. A clá usula finally de tal declaraçã o pode ser usada
para especificar o có digo de limpeza que nã o trata a exceçã o, mas é executado se uma exceçã o ocorreu ou nã o no
có digo anterior.
Python usa o modelo de “terminaçã o” da manipulaçã o de erros: um manipulador de exceçã o pode descobrir o que
aconteceu e continuar a execuçã o em um nível externo, mas nã o pode reparar a causa do erro e tentar novamente a
operaçã o com falha (exceto reinserindo a parte incorreta de có digo de cima).
Quando uma exceçã o nã o é manipulada, o interpretador encerra a execuçã o do programa ou retorna ao seu laço
principal interativo. Em ambos os casos, ele exeibe um traceback (situaçã o da pilha de execuçã o), exceto quando a
exceçã o é SystemExit.
As exceçõ es sã o identificadas por instâ ncias de classe. A clá usula except é selecionada dependendo da classe da
instâ ncia: ela deve referenciar a classe da instâ ncia ou uma classe base não-virtual dela. A instâ ncia pode ser recebida
pelo manipulador e pode conter informaçõ es adicionais sobre a condiçã o excepcional.

® Nota

As mensagens de exceçã o nã o fazem parte da API do Python. Seu conteú do pode mudar de uma versã o do Python
para outra sem aviso e nã o deve ser invocado pelo có digo que será executado em vá rias versõ es do interpretador.

Veja també m a descriçã o da declaraçã o try na seçã o A instrução try e a instruçã o raise na seçã o A instrução raise.

4.3. Exceções 65
The Python Language Reference, Release 3.13.0

66 Capítulo 4. Modelo de execução

 CAPÍTULO 5

O sistema de importação

O có digo Python em um módulo obté m acesso ao có digo em outro mó dulo pelo processo de importação dele. A
instruçã o import é a maneira mais comum de invocar o mecanismo de importaçã o, mas nã o é a ú nica maneira.
Funçõ es como importlib.import_module() e a funçã o embutida __import__() també m podem ser usadas
para chamar o mecanismo de importaçã o.
A instruçã o import combina duas operaçõ es; ela procura o mó dulo nomeado e vincula os resultados dessa pesquisa
a um nome no escopo local. A operaçã o de busca da instruçã o import é definida como uma chamada para a funçã o
__import__(), com os argumentos apropriados. O valor de retorno de __import__() é usado para executar a
operaçã o de ligaçã o de nome da instruçã o import. Veja a instruçã o import para os detalhes exatos da operaçã o de
ligaçã o desse nome.
Uma chamada direta para __import__() realiza apenas a pesquisa do mó dulo e, se encontrada, a operaçã o de
criaçã o do mó dulo. Embora certos efeitos colaterais possam ocorrer, como a importaçã o de pacotes pai e a atualizaçã o
de vá rios caches (incluindo [Link]), apenas a instruçã o import realiza uma operaçã o de ligaçã o de nome.
Quando uma instruçã o import é executada, a funçã o embutida padrã o __import__() é chamada. Outros me-
canismos para chamar o sistema de importaçã o (como importlib.import_module()) podem optar por ignorar
__import__() e usar suas pró prias soluçõ es para implementar a semâ ntica de importaçã o.
Quando um mó dulo é importado pela primeira vez, o Python procura pelo mó dulo e, se encontrado, cria um ob-
jeto de mó dulo1 , inicializando-o. Se o mó dulo nomeado nã o puder ser encontrado, uma ModuleNotFoundError
será levantada. O Python implementa vá rias estraté gias para procurar o mó dulo nomeado quando o mecanismo de
importaçã o é chamado. Essas estraté gias podem ser modificadas e estendidas usando vá rios ganchos descritos nas
seçõ es abaixo.
Alterado na versã o 3.3: O sistema de importaçã o foi atualizado para implementar completamente a segunda fase
da PEP 302. Nã o há mais um mecanismo de importaçã o implícito – o sistema completo de importaçã o é exposto
atravé s de sys.meta_path. Alé m disso, o suporte nativo a pacote de espaço de nomes foi implementado (consulte
PEP 420).

5.1 importlib
O mó dulo importlib fornece uma API rica para interagir com o sistema de importaçã o. Por exemplo, importlib.
import_module() fornece uma API mais simples e recomendada do que a funçã o embutida __import__()
para chamar o mecanismo de importaçã o. Consulte a documentaçã o da biblioteca importlib para obter detalhes
adicionais.
1 Veja [Link].

67
The Python Language Reference, Release 3.13.0

5.2 Pacotes
O Python possui apenas um tipo de objeto de mó dulo e todos os mó dulos sã o desse tipo, independentemente de o
mó dulo estar implementado em Python, C ou qualquer outra coisa. Para ajudar a organizar os mó dulos e fornecer
uma hierarquia de nomes, o Python tem o conceito de pacotes.
Você pode pensar em pacotes como os diretó rios em um sistema de arquivos e os mó dulos como arquivos nos
diretó rios, mas nã o tome essa analogia muito literalmente, já que pacotes e mó dulos nã o precisam se originar do
sistema de arquivos. Para os fins desta documentaçã o, usaremos essa analogia conveniente de diretó rios e arquivos.
Como os diretó rios do sistema de arquivos, os pacotes sã o organizados hierarquicamente e os pró prios pacotes podem
conter subpacotes e mó dulos regulares.
É importante ter em mente que todos os pacotes sã o mó dulos, mas nem todos os mó dulos sã o pacotes. Ou, dito de
outra forma, os pacotes sã o apenas um tipo especial de mó dulo. Especificamente, qualquer mó dulo que contenha um
atributo __path__ é considerado um pacote.
Todo mó dulo tem um nome. Nomes de subpacotes sã o separados do nome do pacote por um ponto, semelhante à
sintaxe de acesso aos atributos padrã o do Python. Assim pode ter um pacote chamado email, que por sua vez tem
um subpacote chamado [Link] e um mó dulo dentro dele chamado [Link].

5.2.1 Pacotes regulares

O Python define dois tipos de pacotes, pacotes regulares e pacotes de espaço de nomes. Pacotes regulares sã o pacotes
tradicionais, como existiam no Python 3.2 e versõ es anteriores. Um pacote regular é normalmente implementado
como um diretó rio que conté m um arquivo __init__.py. Quando um pacote regular é importado, esse arquivo
__init__.py é executado implicitamente, e os objetos que ele define sã o vinculados aos nomes no espaço de nomes
do pacote. O arquivo __init__.py pode conter o mesmo có digo Python que qualquer outro mó dulo pode conter,
e o Python adicionará alguns atributos adicionais ao mó dulo quando ele for importado.
Por exemplo, o layout do sistema de arquivos a seguir define um pacote parent de nível superior com trê s subpacotes:

parent/
__init__.py
one/
__init__.py
two/
__init__.py
three/
__init__.py

A importaçã o de [Link] vai executar implicitamente parent/__init__.py e parent/one/__init__.

py. Importaçõ es subsequentes de [Link] ou [Link] vã o executar parent/two/__init__.py e
parent/three/__init__.py, respectivamente.

5.2.2 Pacotes de espaço de nomes

Um pacote de espaço de nomes é um composto de vá rias porções, em que cada parte contribui com um subpacote
para o pacote pai. Partes podem residir em locais diferentes no sistema de arquivos. Partes també m podem ser
encontradas em arquivos zip, na rede ou em qualquer outro lugar que o Python pesquisar durante a importaçã o. Os
pacotes de espaço de nomes podem ou nã o corresponder diretamente aos objetos no sistema de arquivos; eles podem
ser mó dulos virtuais que nã o tê m representaçã o concreta.
Os pacotes de espaço de nomes nã o usam uma lista comum para o atributo __path__. Em vez disso, eles usam
um tipo iterá vel personalizado que executará automaticamente uma nova pesquisa por partes do pacote na pró xima
tentativa de importaçã o dentro desse pacote, se o caminho do pacote pai (ou [Link] para um pacote de nível
superior) for alterado.
Com pacotes de espaço de nomes, nã o há arquivo pai/__init__.py. De fato, pode haver vá rios diretó rios pai
encontrados durante a pesquisa de importaçã o, onde cada um é fornecido por uma parte diferente. Portanto, pai/um
pode nã o estar fisicamente localizado pró ximo a pai/dois. Nesse caso, o Python criará um pacote de espaço de
nomes para o pacote pai de nível superior sempre que ele ou um de seus subpacotes for importado.

68 Capítulo 5. O sistema de importação

 The Python Language Reference, Release 3.13.0

Veja també m PEP 420 para a especificaçã o de pacotes de espaço de nomes.

5.3 Caminho de busca

Para iniciar a busca, o Python precisa do nome completo do mó dulo (ou pacote, mas para o propó sito dessa exposiçã o,
nã o há diferença) que se quer importar. Esse nome vem de vá rios argumentos passados para a instruçã o import, ou
dos parâ metros das funçõ es importlib.import_module() ou __import__().
Esse nome será usado em vá rias fases da busca da importaçã o, e pode ser um nome com pontos para um submó dulo
como, por exemplo, [Link]. Nesse caso, Python primeiro tenta importar foo, depois [Link] e, finalmente,
[Link]. Se alguma das importaçõ es intermediá rias falharem, uma exceçã o ModuleNotFoundError é le-
vantada.

5.3.1 O cache de módulos

A primeira verificaçã o durante a busca da importaçã o é feita no [Link]. Esse mapeamento serve como um
cache de todos os mó dulos que já foram importados previamente, incluindo os caminhos intermediá rios. Se foo.
[Link] foi previamente importado, [Link] conterá entradas para foo, [Link] e [Link]. Cada
chave terá como valor um objeto mó dulo correspondente.
Durante a importaçã o, o nome do mó dulo é procurado em [Link] e, se estiver presente, o valor associ-
ado é o mó dulo que satisfaz a importaçã o, e o processo termina. Entretanto, se o valor é None, uma exceçã o
ModuleNotFoundError é levantada. Se o nome do mó dulo nã o foi encontrado, Python continuará a busca pelo
mó dulo.
É possível alterar [Link]. Apagar uma chave pode nã o destruir o objeto mó dulo associado (outros mó dulos
podem manter referê ncias para ele), mas a entrada do cache será invalidada para o nome daquele mó dulo, fazendo
Python executar nova busca na pró xima importaçã o. Pode ser atribuído None para a chave, forçando que a pró xima
importaçã o do mó dulo resulte numa exceçã o ModuleNotFoundError.
No entanto, tenha cuidado, pois se você mantiver uma referê ncia para o objeto mó dulo, invalidar sua entrada de cache
em [Link] e, em seguida, reimportar do mó dulo nomeado, os dois mó dulo objetos não serã o os mesmos. Por
outro lado, o [Link]() reutilizará o mesmo objeto mó dulo e simplesmente reinicializará o conteú do
do mó dulo executando novamente o có digo do mó dulo.

5.3.2 Localizadores e carregadores

Se o mó dulo nomeado nã o for encontrado em [Link], entã o o protocolo de importaçã o do Python é invocado
para localizar e carregar o mó dulo. Este protocolo consiste em dois objetos conceituais, localizadores e carregadores.
O trabalho de um localizador é determinar se ele pode localizar o mó dulo nomeado usando qualquer estraté gia que
ele conheça. Objetos que implementam ambas essas interfaces sã o referenciadas como importadores – eles retornam
a si mesmos, quando eles descobrem que eles podem carregar o mó dulo requisitado.
Python inclui um nú mero de localizadores e carregadores padrõ es. O primeiro sabe como localizar mó dulos embuti-
dos, e o segundo sabe como localizar mó dulos congelados. Um terceiro localizador padrã o procura em um caminho
de importação por mó dulos. O caminho de importação é uma lista de localizaçõ es que podem nomear caminhos de
sistema de arquivo ou arquivos zip. Ele també m pode ser estendido para buscar por qualquer recurso localizá vel, tais
como aqueles identificados por URLs.
O mecanismo de importaçã o é extensível, entã o novos localizadores podem ser adicionados para estender o alcance
e o escopo de buscar mó dulos.
Localizadores na verdade nã o carregam mó dulos. Se eles conseguirem encontrar o mó dulo nomeado, eles retornam
uma especificação do módulo, um encapsulamento da informaçã o relacionada a importaçã o do mó dulo, a qual o
mecanismo de importaçã o entã o usa quando o mó dulo é carregado.
As seguintes seçõ es descrevem o protocolo para localizadores e carregadores em mais detalhes, incluindo como você
pode criar e registrar novos para estender o mecanismo de importaçã o.
Alterado na versã o 3.4: Em versõ es anteriores do Python, localizadores retornavam carregadores diretamente, en-
quanto agora eles retornam especificaçõ es de mó dulo, as qual contêm carregadores. Carregadores ainda sã o usados
durante a importaçã o, mas possuem menos responsabilidades.

5.3. Caminho de busca 69

The Python Language Reference, Release 3.13.0

5.3.3 Ganchos de importação

O mecanismo de importaçã o é desenhado para ser extensível; o mecanismo primá rio para isso sã o os ganchos de
importação. Existem dois tipos de ganchos de importaçã o: metaganchos e ganchos de importação de caminho.
Metaganchos sã o chamados no início do processo de importaçã o, antes que qualquer outro processo de importaçã o
tenha ocorrido, que nã o seja busca de cache de [Link]. Isso permite aos metaganchos substituir processa-
mento de [Link], mó dulos congelados ou mesmo mó dulos embutidos. Metaganchos sã o registrados adicionando
novos objetos localizadores a sys.meta_path, conforme descrito abaixo.
Ganchos de caminho de importaçã o sã o chamados como parte do processamento de [Link] (ou package.
__path__), no ponto onde é encontrado o item do caminho associado. Ganchos de caminho de importaçã o sã o
registrados adicionando novos chamá veis para sys.path_hooks, conforme descrito abaixo.

5.3.4 O metacaminho
When the named module is not found in [Link], Python next searches sys.meta_path, which contains
a list of meta path finder objects. These finders are queried in order to see if they know how to handle the named
module. Meta path finders must implement a method called find_spec() which takes three arguments: a name,
an import path, and (optionally) a target module. The meta path finder can use any strategy it wants to determine
whether it can handle the named module or not.
Se o localizador de metacaminho souber como tratar o mó dulo nomeado, ele retorna um objeto com especificaçõ es.
Se ele nã o puder tratar o mó dulo nomeado, ele retorna None. Se o processamento de sys.meta_path alcançar
o fim da sua lista sem retornar uma especificaçã o, entã o ModuleNotFoundError é levantada. Qualquer outras
exceçõ es levantadas sã o simplesmente propagadas para cima, abortando o processo de importaçã o.
The find_spec() method of meta path finders is called with two or three arguments. The first is the fully qualified
name of the module being imported, for example [Link]. The second argument is the path entries to use
for the module search. For top-level modules, the second argument is None, but for submodules or subpackages, the
second argument is the value of the parent package’s __path__ attribute. If the appropriate __path__ attribute
cannot be accessed, a ModuleNotFoundError is raised. The third argument is an existing module object that will
be the target of loading later. The import system passes in a target module only during reload.
O metacaminho pode ser percorrido mú ltiplas vezes para uma requisiçã o de importaçã o individual. Por exemplo,
presumindo que nenhum dos mó dulos envolvidos já tenha sido cacheado, importar [Link] irá primeiro exe-
cutar uma importaçã o de alto nível, chamando mpf.find_spec("foo", None, None) em cada localizador de
metacaminho (mpf). Depois que foo foi importado, [Link] será importado percorrendo o metacaminho uma
segunda vez, chamando mpf.find_spec("[Link]", foo.__path__, None). Uma vez que [Link] tenha
sido importado, a travessia final irá chamar mpf.find_spec("[Link]", [Link].__path__, None).
Alguns localizadores de metacaminho apenas dã o suporte a importaçõ es de alto nível. Estes importadores vã o sempre
retornar None quando qualquer coisa diferente de None for passada como o segundo argumento.
O sys.meta_path padrã o do Python possui trê s localizador de metacaminho, um que sabe como importar mó du-
los embutidos, um que sabe como importar mó dulos congelados, e outro que sabe como importar mó dulos de um
caminho de importação (isto é , o localizador baseado no caminho).
Alterado na versã o 3.4: O mé todo find_spec() dos localizador de metacaminho substituiu find_module(), o
qual agora foi descontinuado. Embora continue a funcionar sem alteraçõ es, a mecanismo de importaçã o só tentará
fazê -lo se o localizador nã o implementar find_spec().
Alterado na versã o 3.10: O uso de find_module() pelo sistema de importaçã o agora levanta ImportWarning.
Alterado na versã o 3.12: find_module() foi removido. Use find_spec().

5.4 Carregando
Se e quando uma especificaçã o do mó dulo for encontrada, o mecanismo de importaçã o irá usá -lo (e o carregador
que ele conté m) durante o carregamento do mó dulo. Aqui está uma aproximaçã o do que acontece durante a etapa
de carregamento de uma importaçã o:

70 Capítulo 5. O sistema de importação

 The Python Language Reference, Release 3.13.0

module = None
if [Link] is not None and hasattr([Link], 'create_module'):
# It is assumed 'exec_module' will also be defined on the loader.
module = [Link].create_module(spec)
if module is None:
module = ModuleType([Link])
# The import-related module attributes get set here:
_init_module_attrs(spec, module)

if [Link] is None:
# unsupported
raise ImportError
if [Link] is None and spec.submodule_search_locations is not None:
# namespace package
[Link][[Link]] = module
elif not hasattr([Link], 'exec_module'):
module = [Link].load_module([Link])
else:
[Link][[Link]] = module
try:
[Link].exec_module(module)
except BaseException:
try:
del [Link][[Link]]
except KeyError:
pass
raise
return [Link][[Link]]

Perceba os seguintes detalhes:

• Se houver um objeto mó dulo existente com o nome fornecido em [Link], a importaçã o já tera retor-
nado ele.
• O mó dulo irá existir em [Link] antes do carregador executar o có digo do mó dulo. Isso é crucial
porque o có digo do mó dulo pode (direta ou indiretamente) importar a si mesmo; adicioná -lo a [Link]
antecipadamente previne recursã o infinita no pior caso e mú ltiplos carregamentos no melhor caso.
• Se o carregamento falhar, o mó dulo com falha – e apenas o mó dulo com falha – é removido de [Link].
Qualquer mó dulo já presente no cache de [Link], e qualquer mó dulo que tenha sido carregado com
sucesso como um efeito colateral, deve permanecer no cache. Isso contrasta com recarregamento, onde mesmo
o mó dulo com falha é mantido em [Link].
• Depois que o mó dulo é criado, mas antes da execuçã o, o mecanismo de importaçã o define os atributos de
mó dulo relacionados a importaçã o (“_init_module_attrs” no exemplo de pseudocó digo acima), assim como
foi resumido em uma seção posterior.
• Execuçã o de mó dulo é o momento chave do carregamento, no qual o espaço de nomes do mó dulo é populado.
Execuçã o é inteiramente delegada para o carregador, o qual pode decidir o que será populado e como.
• O mó dulo criado durante o carregamento e passado para exec_module() pode nã o ser aquele retornado ao final
da importaçã o2 .
Alterado na versã o 3.4: O sistema de importaçã o tem tomado conta das responsabilidades inerentes dos carregadores.
Essas responsabilidades eram anteriormente executadas pelo mé todo [Link].load_module().
2 A implementaçã o de importlib evita usar o valor de retorno diretamente. Em vez disso, ela obté m o objeto do mó dulo procurando o nome

do mó dulo em [Link]. O efeito indireto disso é que um mó dulo importado pode substituir a si mesmo em [Link]. Esse é um
comportamento específico da implementaçã o que nã o tem garantia de funcionar em outras implementaçõ es do Python.

5.4. Carregando 71
The Python Language Reference, Release 3.13.0

5.4.1 Carregadores
Os carregadores de mó dulo fornecem a funçã o crítica de carregamento: execuçã o do mó dulo. O mecanismo de
importaçã o chama o mé todo [Link].exec_module() com um ú nico argumento, o objeto do
mó dulo a ser executado. Qualquer valor retornado de exec_module() é ignorado.
Os carregadores devem atender aos seguintes requisitos:
• Se o mó dulo for um mó dulo Python (em oposiçã o a um mó dulo embutido ou uma extensã o carregada dinami-
camente), o carregador deve executar o có digo do mó dulo no espaço de nomes global do mó dulo (module.
__dict__).

• Se o carregador nã o puder executar o mó dulo, ele deve levantar uma execçã o ImportError, embora qualquer
outra exceçã o levantada durante exec_module() será propagada.
Em muitos casos, o localizador e o carregador podem ser o mesmo objeto; nesses casos o mé todo find_spec()
apenas retornaria uma especificaçã o com o carregador definido como self.
Os carregadores de mó dulo podem optar por criar o objeto do mó dulo durante o carregamento, implementando um
mé todo create_module(). Leva um argumento, a especificaçã o do mó dulo e retorna o novo objeto do mó dulo
para usar durante o carregamento. create_module() nã o precisa definir nenhum atributo no objeto do mó dulo.
Se o mé todo retornar None, o mecanismo de importaçã o criará ele mesmo o novo mó dulo.
Adicionado na versã o 3.4: O mé todo create_module() de carregadores.
Alterado na versã o 3.4: O mé todo load_module() foi substituído por exec_module() e o mecanismo de impor-
taçã o assumiu todas as responsabilidades inerentes de carregamento.
Para compatibilidade com carregadores existentes, o mecanismo de importaçã o usará o mé todo load_module() de
carregadores se ele existir e o carregador també m nã o implementar exec_module(). No entanto, load_module()
foi descontinuado e os carregadores devem implementar exec_module() em seu lugar.
O mé todo load_module() deve implementar toda a funcionalidade inerente de carregamento descrita acima, alé m
de executar o mó dulo. Todas as mesmas restriçõ es se aplicam, com alguns esclarecimentos adicionais:
• Se houver um objeto de mó dulo existente com o nome fornecido em [Link], o carregador deverá usar
esse mó dulo existente. (Caso contrá rio, [Link]() nã o funcionará corretamente.) Se o mó dulo
nomeado nã o existir em [Link], o carregador deverá criar um novo objeto de mó dulo e adicioná -lo a
[Link].

• O mó dulo deve existir em [Link] antes que o carregador execute o có digo do mó dulo, para evitar
recursã o ilimitada ou carregamento mú ltiplo.
• Se o carregamento falhar, o carregador deverá remover quaisquer mó dulos inseridos em [Link], mas
deverá remover apenas o(s) mó dulo(s) com falha, e somente se o pró prio carregador tiver carregado o(s)
mó dulo(s) explicitamente.
Alterado na versã o 3.5: Uma exceçã o DeprecationWarning é levantada quando exec_module() está definido,
mas create_module() nã o.
Alterado na versã o 3.6: Uma exceçã o ImportError é levantada quando exec_module() está definido, mas
create_module() nã o.
Alterado na versã o 3.10: O uso de load_module() vai levantar ImportWarning.

5.4.2 Submódulos
Quando um submó dulo é carregado usando qualquer mecanismo (por exemplo, APIs importlib, as instruçõ es
import ou import-from, ou __import__() embutidas) uma ligaçã o é colocada no espaço de nomes do mó dulo
pai para o objeto submó dulo. Por exemplo, se o pacote spam tiver um submó dulo foo, apó s importar [Link],
spam terá um atributo foo que está vinculado ao submó dulo. Digamos que você tenha a seguinte estrutura de
diretó rios:

spam/
__init__.py
[Link]

72 Capítulo 5. O sistema de importação

 The Python Language Reference, Release 3.13.0

e spam/__init__.py tem a seguinte linha:

from .foo import Foo

entã o executar o seguinte coloca ligaçõ es de nome para foo e Foo no mó dulo spam:

>>> import spam

>>> [Link]
<module '[Link]' from '/tmp/imports/spam/[Link]'>
>>> [Link]
<class '[Link]'>

Dadas as conhecidas regras de ligaçã o de nomes do Python, isso pode parecer surpreendente, mas na verdade é um re-
curso fundamental do sistema de importaçã o. A propriedade invariante é que se você tiver [Link]['spam']
e [Link]['[Link]'] (como faria apó s a importaçã o acima), o ú ltimo deve aparecer como o atributo foo
do primeiro.

5.4.3 Module specs

O mecanismo de importaçã o utiliza diversas informaçõ es sobre cada mó dulo durante a importaçã o, principalmente
antes do carregamento. A maior parte das informaçõ es é comum a todos os mó dulos. O propó sito de uma especifi-
caçã o de mó dulo (spec) é encapsular essas informaçõ es relacionadas à importaçã o por mó dulo.
Usar uma especificaçã o durante a importaçã o permite que o estado seja transferido entre componentes do sistema
de importaçã o, por exemplo. entre o localizador que cria a especificaçã o do mó dulo e o carregador que o executa.
Mais importante ainda, permite que o mecanismo de importaçã o execute as operaçõ es inerentes de carregamento,
enquanto que sem uma especificaçã o de mó dulo o carregador tinha essa responsabilidade.
The module’s spec is exposed as module.__spec__. Setting __spec__ appropriately applies equally to modules
initialized during interpreter startup. The one exception is __main__, where __spec__ is set to None in some cases.
See ModuleSpec for details on the contents of the module spec.
Adicionado na versã o 3.4.

5.4.4 __path__ attributes on modules

The __path__ attribute should be a (possibly empty) sequence of strings enumerating the locations where the pac-
kage’s submodules will be found. By definition, if a module has a __path__ attribute, it is a package.
A package’s __path__ attribute is used during imports of its subpackages. Within the import machinery, it functions
much the same as [Link], i.e. providing a list of locations to search for modules during import. However,
__path__ is typically much more constrained than [Link].

The same rules used for [Link] also apply to a package’s __path__. sys.path_hooks (described below) are
consulted when traversing a package’s __path__.
A package’s __init__.py file may set or alter the package’s __path__ attribute, and this was typically the way
namespace packages were implemented prior to PEP 420. With the adoption of PEP 420, namespace packages
no longer need to supply __init__.py files containing only __path__ manipulation code; the import machinery
automatically sets __path__ correctly for the namespace package.

5.4.5 Representações do módulo

Por padrã o, todos os mó dulos tê m uma representaçã o (repr) utilizá vel, no entanto, dependendo dos atributos definidos
acima e da especificaçã o do mó dulo, você pode controlar mais explicitamente a representaçã o dos objetos mó dulo.
Se o mó dulo tiver uma especificaçã o (__spec__), o mecanismo de importaçã o tentará gerar uma representaçã o
a partir dele. Se isso falhar ou nã o houver nenhuma especificaçã o, o sistema de importaçã o criará uma represen-
taçã o padrã o usando qualquer informaçã o disponível no mó dulo. Ele tentará usar module.__name__, module.
__file__ e module.__loader__ como entrada para a representaçã o, com padrõ es para qualquer informaçã o que
esteja faltando.

5.4. Carregando 73
The Python Language Reference, Release 3.13.0

Arquivo estã o as exatas regras usadas:

• Se o mó dulo tiver um atributo __spec__, a informaçã o na especificaçã o é usada para gerar a representaçã o.
Os atributos “name”, “loader”, “origin” e “has_location” sã o consultados.
• Se o mó dulo tiver um atributo __file__, ele será usado como parte da representaçã o do mó dulo.
• Se o mó dulo nã o tem __file__ mas tem um __loader__ que nã o seja None, entã o a representaçã o do
carregador é usado como parte da representaçã o do mó dulo.
• Caso contrá rio, basta usar o __name__ do mó dulo na representaçã o.
Alterado na versã o 3.12: O uso de module_repr(), descontinuado desde o Python 3.4, foi removido no Python
3.12 e nã o é mais chamado durante a resoluçã o da representaçã o de um mó dulo.

5.4.6 Invalidação de bytecode em cache

Antes do Python carregar o bytecode armazenado em cache de um arquivo .pyc, ele verifica se o cache está atualizado
com o arquivo fonte .py. Por padrã o, o Python faz isso armazenando o registro de data e hora da ú ltima modificaçã o
da fonte e o tamanho no arquivo de cache ao escrevê -lo. No tempo de execuçã o, o sistema de importaçã o valida o
arquivo de cache verificando os metadados armazenados no arquivo de cache em relaçã o aos metadados do có digo-
-fonte.
Python també m oferece suporte a arquivos de cache “baseados em hash”, que armazenam um hash do conteú do do
arquivo fonte em vez de seus metadados. Existem duas variantes de arquivos .pyc baseados em hash: verificados
e nã o verificados. Para arquivos .pyc baseados em hash verificados, o Python valida o arquivo de cache fazendo
hash do arquivo fonte e comparando o hash resultante com o hash no arquivo de cache. Se um arquivo de cache
baseado em hash verificado for invá lido, o Python o regenerará e gravará um novo arquivo de cache baseado em hash
verificado. Para arquivos .pyc baseados em hash nã o verificados, o Python simplesmente presume que o arquivo de
cache é vá lido, se existir. O comportamento de validaçã o de arquivos .pyc baseados em hash pode ser substituído
pelo sinalizador --check-hash-based-pycs.
Alterado na versã o 3.7: Adicionados arquivos .pyc baseados em hash. Anteriormente, o Python oferecia suporte
apenas à invalidaçã o de caches de bytecode baseada em registro de data e hora.

5.5 O localizador baseado no caminho

Conforme mencionado anteriormente, Python vem com vá rios localizadores de metacaminho padrã o. Um deles,
chamado localizador baseado no caminho (PathFinder), pesquisa um caminho de importação, que conté m uma
lista de entradas de caminho. Cada entrada de caminho nomeia um local para procurar mó dulos.
O pró prio localizador baseado no caminho nã o sabe como importar nada. Em vez disso, ele percorre as entradas de
caminho individuais, associando cada uma delas a um localizador de entrada de caminho que sabe como lidar com
esse tipo específico de caminho.
O conjunto padrã o de localizadores de entrada de caminho implementa toda a semâ ntica para localizar mó dulos no
sistema de arquivos, manipulando tipos de arquivos especiais, como có digo-fonte Python (arquivos .py), có digo de
bytes Python (arquivos .pyc) e bibliotecas compartilhadas (por exemplo, arquivos .so). Quando suportado pelo
mó dulo zipimport na biblioteca padrã o, os localizadores de entrada de caminho padrã o també m lidam com o
carregamento de todos esses tipos de arquivos (exceto bibliotecas compartilhadas) de arquivos zip.
As entradas de caminho nã o precisam ser limitadas aos locais do sistema de arquivos. Eles podem referir-se a URLs,
consultas de banco de dados ou qualquer outro local que possa ser especificado como uma string.
O localizador baseado no caminho fornece ganchos e protocolos adicionais para que você possa estender e perso-
nalizar os tipos de entradas de caminho pesquisá veis. Por exemplo, se você quiser oferecer suporte a entradas de
caminho como URLs de rede, poderá escrever um gancho que implemente a semâ ntica HTTP para localizar mó -
dulos na web. Este gancho (um chamá vel) retornaria um localizador de entrada de caminho suportando o protocolo
descrito abaixo, que foi entã o usado para obter um carregador para o mó dulo da web.
Uma palavra de advertê ncia: esta seçã o e a anterior usam o termo localizador, distinguindo-os usando os termos
localizador de metacaminho e localizador de entrada de caminho. Esses dois tipos de localizadores sã o muito se-
melhantes, oferecem suporte a protocolos semelhantes e funcionam de maneira semelhante durante o processo de

74 Capítulo 5. O sistema de importação

 The Python Language Reference, Release 3.13.0

importaçã o, mas é importante ter em mente que eles sã o sutilmente diferentes. Em particular, os localizadores de
metacaminho operam no início do processo de importaçã o, conforme a travessia de sys.meta_path.
Por outro lado, os localizadores de entrada de caminho sã o, em certo sentido, um detalhe de implementaçã o do
localizador baseado no caminho e, de fato, se o localizador baseado no caminho fosse removido de sys.meta_path,
nenhuma semâ ntica do localizador de entrada de caminho seria ser invocado.

5.5.1 Localizadores de entrada de caminho

O localizador baseado no caminho é responsá vel por encontrar e carregar mó dulos e pacotes Python cuja localizaçã o
é especificada com uma string entrada de caminho. A maioria das entradas de caminho nomeiam locais no sistema
de arquivos, mas nã o precisam ser limitadas a isso.
Como um localizador de metacaminho, o localizador baseado no caminho implementa o protocolo find_spec()
descrito anteriormente, no entanto, ele expõ e ganchos adicionais que podem ser usados para personalizar como os
mó dulos sã o encontrados e carregado do caminho de importação.
Trê s variá veis sã o usadas pelo localizador baseado no caminho, [Link], sys.path_hooks e sys.
path_importer_cache. Os atributos __path__ em objetos de pacote també m sã o usados. Eles fornecem ma-
neiras adicionais de personalizar o mecanismo de importaçã o.
[Link] conté m uma lista de strings fornecendo locais de pesquisa para mó dulos e pacotes. Ele é inicializado
a partir da variá vel de ambiente PYTHONPATH e vá rios outros padrõ es específicos de instalaçã o e implementaçã o.
Entradas em [Link] podem nomear diretó rios no sistema de arquivos, arquivos zip e potencialmente outros
“locais” (veja o mó dulo site) que devem ser pesquisados por mó dulos, como URLs, ou consultas ao banco de
dados. Apenas strings devem estar presentes em [Link]; todos os outros tipos de dados sã o ignorados.
O localizador baseado no caminho é um localizador de metacaminho, entã o o mecanismo de importaçã o inicia a
pesquisa no caminho de importação chamando o mé todo find_spec() do localizador baseado no caminho conforme
descrito anteriormente. Quando o argumento path para find_spec() for fornecido, será uma lista de caminhos
de string a serem percorridos – normalmente o atributo __path__ de um pacote para uma importaçã o dentro desse
pacote. Se o argumento path for None, isso indica uma importaçã o de nível superior e [Link] é usado.
O localizador baseado no caminho itera sobre cada entrada no caminho de pesquisa e, para cada uma delas, procura
um localizador de entrada de caminho (PathEntryFinder) apropriado para a entrada do caminho. Como esta
pode ser uma operaçã o custosa (por exemplo, pode haver sobrecargas de chamada stat() para esta pesquisa), o
localizador baseado no caminho manté m um cache mapeando entradas de caminho para localizadores de entrada
de caminho. Este cache é mantido em sys.path_importer_cache (apesar do nome, este cache na verdade
armazena objetos localizadores em vez de ser limitado a objetos importador). Desta forma, a dispendiosa busca pelo
localizador de entrada de caminho de local específico de uma entrada de caminho só precisa ser feita uma vez. O
có digo do usuá rio é livre para remover entradas de cache de sys.path_importer_cache, forçando o localizador
baseado no caminho a realizar a pesquisa de entrada de caminho novamente.
Se a entrada de caminho nã o estiver presente no cache, o localizador baseado no caminho itera sobre cada chamá vel
em sys.path_hooks. Cada um dos ganchos de entrada de caminho nesta lista é chamado com um ú nico argumento,
a entrada de caminho a ser pesquisada. Este chamá vel pode retornar um localizador de entrada de caminho que pode
manipular a entrada de caminho ou pode levantar ImportError. Um ImportError é usado pelo localizador
baseado no caminho para sinalizar que o gancho nã o consegue encontrar um localizador de entrada de caminho para
aquela entrada de caminho. A exceçã o é ignorada e a iteraçã o com o caminho de importação continua. O gancho
deve esperar um objeto string ou bytes; a codificaçã o de objetos bytes depende do gancho (por exemplo, pode ser
uma codificaçã o de sistema de arquivos, UTF-8 ou outra coisa) e, se o gancho nã o puder decodificar o argumento,
ele deve levantar ImportError.
Se a iteraçã o sys.path_hooks terminar sem que nenhum localizador de entrada de caminho seja retornado, o mé -
todo find_spec() do localizador baseado no caminho armazenará None em sys.path_importer_cache (para
indicar que nã o há um localizador para esta entrada de caminho) e retornará None, indicando que este localizador
de metacaminho nã o conseguiu encontrar o mó dulo.
Se um localizador de entrada de caminho for retornado por um dos chamá veis de gancho de entrada de caminho em
sys.path_hooks, entã o o seguinte protocolo é usado para solicitar ao localizador uma especificaçã o de mó dulo,
que é entã o usada ao carregar o mó dulo.

5.5. O localizador baseado no caminho 75

The Python Language Reference, Release 3.13.0

O diretó rio de trabalho atual – denotado por uma string vazia – é tratado de forma ligeiramente diferente de outras
entradas em [Link]. Primeiro, se o diretó rio de trabalho atual for considerado inexistente, nenhum valor será
armazenado em sys.path_importer_cache. Segundo, o valor para o diretó rio de trabalho atual é pesquisado
novamente para cada pesquisa de mó dulo. Terceiro, o caminho usado para sys.path_importer_cache e re-
tornado por [Link].find_spec() será o diretó rio de trabalho atual real e nã o a
string vazia.

5.5.2 Protocolo do localizador de entrada de caminho

Para dar suporte a importaçõ es de mó dulos e pacotes inicializados e també m contribuir com partes para pacotes de
espaço de nomes, os localizadores de entrada de caminho devem implementar o mé todo find_spec().
find_spec() recebe dois argumentos: o nome totalmente qualificado do mó dulo que está sendo importado e o
mó dulo de destino (opcional). find_spec() retorna uma especificaçã o totalmente preenchida para o mó dulo. Esta
especificaçã o sempre terá “loader” definido (com uma exceçã o).
Para indicar ao maquiná rio de importaçã o que a especificaçã o representa uma porção de espaço de nomes, o locali-
zador de entrada de caminho define submodule_search_locations como uma lista contendo a porçã o.
Alterado na versã o 3.4: find_spec() substituiu find_loader() e find_module(), ambos descontinuados,
mas serã o usados se find_spec() nã o estiver definido.
Os localizadores de entrada de caminho mais antigos podem implementar um desses dois mé todos descontinuados
em vez de find_spec(). Os mé todos ainda sã o respeitados para fins de compatibilidade com versõ es anteriores.
No entanto, se find_spec() for implementado no localizador de entrada de caminho, os mé todos legados serã o
ignorados.
find_loader() recebe um argumento, o nome totalmente qualificado do mó dulo que está sendo importado.
find_loader() retorna uma tupla 2 onde o primeiro item é o carregador e o segundo item é uma porção de
espaço de nomes.
Para compatibilidade com versõ es anteriores de outras implementaçõ es do protocolo de importaçã o, muitos locali-
zadores de entrada de caminho també m dã o suporte ao mesmo mé todo tradicional find_module() que os loca-
lizadores de metacaminho. No entanto, os mé todos find_module() do localizador de entrada de caminho nunca
sã o chamados com um argumento path (espera-se que eles registrem as informaçõ es de caminho apropriadas da
chamada inicial para o gancho de caminho).
O mé todo find_module() em localizadores de entrada de caminho foi descontinuado, pois nã o permite que o
localizador de entrada de caminho contribua com porçõ es para pacotes de espaço de nomes. Se find_loader()
e find_module() existirem em um localizador de entrada de caminho, o sistema de importaçã o sempre chamará
find_loader() em preferê ncia a find_module().
Alterado na versã o 3.10: Chamadas para find_module() e find_loader() pelo sistema de importaçã o vã o
levantar ImportWarning.
Alterado na versã o 3.12: find_module() e find_loader() foram removidos.

5.6 Substituindo o sistema de importação padrão

O mecanismo mais confiá vel para substituir todo o sistema de importaçã o é excluir o conteú do padrã o de sys.
meta_path, substituindo-o inteiramente por um gancho de metacaminho personalizado.

Se for aceitá vel alterar apenas o comportamento de instruçõ es de importaçã o sem afetar outras APIs que acessam o
sistema de importaçã o, entã o substituir a funçã o embutida __import__() pode ser suficiente. Essa té cnica també m
pode ser empregada no nível do mó dulo para alterar apenas o comportamento de instruçõ es de importaçã o dentro
desse mó dulo.
Para impedir seletivamente a importaçã o de alguns mó dulos de um gancho no início do metacaminho (em vez de
desabilitar o sistema de importaçã o padrã o completamente), é suficiente levantar ModuleNotFoundError direta-
mente de find_spec() em vez de retornar None. O ú ltimo indica que a busca do metacaminho deve continuar,
enquanto levantar uma exceçã o a encerra imediatamente.

76 Capítulo 5. O sistema de importação

 The Python Language Reference, Release 3.13.0

5.7 Importações relativas ao pacote

Importaçõ es relativas usam caracteres de ponto no início. Um ú nico ponto no início indica uma importaçã o relativa,
começando com o pacote atual. Dois ou mais pontos no início indicam uma importaçã o relativa para o(s) pai(s) do
pacote atual, um nível por ponto apó s o primeiro. Por exemplo, dado o seguinte layout de pacote:

package/
__init__.py
subpackage1/
__init__.py
[Link]
[Link]
subpackage2/
__init__.py
[Link]
[Link]

Em subpackage1/[Link] ou subpackage1/__init__.py, as seguintes sã o importaçõ es relativas vá lidas:

from .moduleY import spam

from .moduleY import spam as ham
from . import moduleY
from ..subpackage1 import moduleY
from ..[Link] import eggs
from ..moduleA import foo

Importaçõ es absolutas podem usar a sintaxe import <> ou from <> import <>, mas importaçõ es relativas po-
dem usar apenas a segunda forma; o motivo para isso é que:

import [Link]

deve expor [Link] como uma expressã o utilizá vel, mas .moduleY nã o é uma expressã o vá lida.

5.8 Considerações especiais para __main__

O mó dulo __main__ é um caso especial em relaçã o ao sistema de importaçã o do Python. Conforme observado em
em outro lugar, o mó dulo __main__ é inicializado diretamente na inicializaçã o do interpretador, muito parecido
com sys e builtins. No entanto, diferentemente desses dois, ele nã o se qualifica estritamente como um mó dulo
integrado. Isso ocorre porque a maneira como __main__ é inicializado depende dos sinalizadores e outras opçõ es
com as quais o interpretador é invocado.

5.8.1 __main__.__spec__
Dependendo de como __main__ é inicializado, __main__.__spec__ é definido apropriadamente ou como None.
Quando o Python é iniciado com a opçã o -m, __spec__ é definido como a especificaçã o do mó dulo ou pacote
correspondente. __spec__ també m é preenchido quando o mó dulo __main__ é carregado como parte da execuçã o
de um diretó rio, arquivo zip ou outra entrada [Link].
Nos demais casos, __main__.__spec__ é definido como None, pois o có digo usado para preencher o __main__
nã o corresponde diretamente a um mó dulo importá vel:
• prompt interativo
• opçã o -c
• executar a partir de stdin
• executar diretamente de um arquivo de có digo-fonte ou bytecode

5.7. Importações relativas ao pacote 77

The Python Language Reference, Release 3.13.0

Note que __main__.__spec__ é sempre None no ú ltimo caso, mesmo se o arquivo pudesse ser importado direta-
mente como um mó dulo. Use a opçã o -m se metadados de mó dulo vá lidos forem desejados em __main__.
Note també m que mesmo quando __main__ corresponde a um mó dulo importá vel e __main__.__spec__ é defi-
nido adequadamente, eles ainda sã o considerados mó dulos distintos. Isso se deve ao fato de que os blocos protegidos
por verificaçõ es if __name__ == "__main__": sã o executados somente quando o mó dulo é usado para preen-
cher o espaço de nomes __main__, e nã o durante a importaçã o normal.

5.9 Referências
O maquiná rio de importaçã o evoluiu consideravelmente desde os primeiros dias do Python. A especificaçã o ori-
ginal para pacotes ainda está disponível para leitura, embora alguns detalhes tenham mudado desde a escrita desse
documento.
A especificaçã o original para sys.meta_path era PEP 302, com extensã o subsequente em PEP 420.
PEP 420 introduziu pacotes de espaço de nomes para Python 3.3. PEP 420 també m introduziu o protocolo
find_loader() como uma alternativa ao find_module().

PEP 366 descreve a adiçã o do atributo __package__ para importaçõ es relativas explícitas em mó dulos principais.
PEP 328 introduziu importaçõ es relativas absolutas e explícitas e inicialmente propô s __name__ para semâ ntica.
PEP 366 eventualmente especificaria __package__.
PEP 338 define mó dulos de execuçã o como scripts.
PEP 451 adiciona o encapsulamento do estado de importaçã o por mó dulo em objetos de especificaçã o. Ele també m
descarrega a maioria das responsabilidades inerentes dos carregadores de volta para o maquiná rio de importaçã o.
Essas mudanças permitem a descontinuaçã o de vá rias APIs no sistema de importaçã o e també m a adiçã o de novos
mé todos para localizadores e carregadores.

78 Capítulo 5. O sistema de importação

 CAPÍTULO 6

Expressões

Este capítulo explica o significado dos elementos das expressõ es em Python.

Notas de sintaxe: Neste e nos capítulos seguintes, a notaçã o BNF estendida será usada para descrever a sintaxe, nã o
a aná lise lexical. Quando (uma alternativa de) uma regra de sintaxe tem a forma

name ::= othername

e nenhuma semâ ntica é fornecida, a semâ ntica desta forma de name é a mesma que para othername.

6.1 Conversões aritméticas

Quando uma descriçã o de um operador aritmé tico abaixo usa a frase “os argumentos numé ricos sã o convertidos em
um tipo comum”, isso significa que a implementaçã o do operador para tipos embutidos funciona da seguinte maneira:
• Se um dos argumentos for um nú mero complexo, o outro será convertido em complexo;
• caso contrá rio, se um dos argumentos for um nú mero de ponto flutuante, o outro será convertido em ponto
flutuante;
• caso contrá rio, ambos devem ser inteiros e nenhuma conversã o é necessá ria.
Algumas regras adicionais se aplicam a certos operadores (por exemplo, uma string como um argumento à esquerda
para o operador ‘%’). As extensõ es devem definir seu pró prio comportamento de conversã o.

6.2 Átomos
Os á tomos sã o os elementos mais bá sicos das expressõ es. Os á tomos mais simples sã o identificadores ou literais. As
formas entre parê nteses, colchetes ou chaves també m sã o categorizadas sintaticamente como á tomos. A sintaxe para
á tomos é :

atom ::= identifier | literal | enclosure

enclosure ::= parenth_form | list_display | dict_display | set_display
| generator_expression | yield_atom

79
The Python Language Reference, Release 3.13.0

6.2.1 Identificadores (Nomes)

Um identificador que ocorre como um á tomo é um nome. Veja a seçã o Identificadores e palavras-chave para a
definiçã o lexical e a seçã o Nomeação e ligação para documentaçã o de nomenclatura e ligaçã o.
Quando o nome está vinculado a um objeto, a avaliaçã o do á tomo produz esse objeto. Quando um nome nã o está
vinculado, uma tentativa de avaliá -lo levanta uma exceçã o NameError.

Desfiguração de nome privado

Quando um identificador que ocorre textualmente em uma definiçã o de classe começa com dois ou mais caracteres
de sublinhado e nã o termina com dois ou mais sublinhados, ele é considerado um nome privado daquela classe.

µ Ver também

As especificações de classe.

Mais precisamente, os nomes privados sã o transformados em um formato mais longo antes que o có digo seja ge-
rado para eles. Se o nome transformado tiver mais de 255 caracteres, poderá ocorrer truncamento definido pela
implementaçã o.
A transformaçã o é independente do contexto sintá tico no qual o identificador é usado, mas apenas os seguintes
identificadores privados sã o desfigurados:
• Qualquer nome usado como nome de uma variá vel que é atribuída ou lida ou qualquer nome de um atributo
que está sendo acessado.
O atributo __name__ de funçõ es aninhadas, classes e apelidos de tipo, entretanto, nã o é desfigurado.
• O nome dos mó dulos importados, por exemplo, __spam em import __spam. Se o mó dulo faz parte de um
pacote (ou seja, seu nome conté m um ponto), o nome não é desfigurado, por exemplo, o __foo em import
__foo.bar nã o é desfigurado.

• O nome de um membro importado, por exemplo, __f em from spam import __f.
A regra de transformaçã o está definida da seguinte forma:
• O nome da classe, com os sublinhados iniciais removidos e um ú nico sublinhado inicial inserido, é inserido na
frente do identificador, por exemplo, o identificador __spam ocorrendo em uma classe chamada Foo, _Foo
ou __Foo é transformado em _Foo__spam.
• Se o nome da classe consiste apenas em sublinhados, a transformaçã o é a identidade, por exemplo, o identifi-
cador __spam que ocorre em uma classe chamada _ ou __ é deixado como está .

6.2.2 Literais
Python oferece suporte a strings e bytes literais e vá rios literais numé ricos:

literal ::= stringliteral | bytesliteral

| integer | floatnumber | imagnumber

A avaliaçã o de um literal produz um objeto do tipo fornecido (string, bytes, inteiro, nú mero de ponto flutuante, nú mero
complexo) com o valor fornecido. O valor pode ser aproximado no caso de ponto flutuante e literais imaginá rios
(complexos). Veja a seçã o Literais para detalhes.
Todos os literais correspondem a tipos de dados imutá veis e, portanto, a identidade do objeto é menos importante
que seu valor. Mú ltiplas avaliaçõ es de literais com o mesmo valor (seja a mesma ocorrê ncia no texto do programa
ou uma ocorrê ncia diferente) podem obter o mesmo objeto ou um objeto diferente com o mesmo valor.

80 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

6.2.3 Formas de parênteses

Um forma entre parê nteses é uma lista de expressõ es opcional entre parê nteses:

parenth_form ::= "(" [starred_expression] ")"

Uma lista de expressõ es entre parê nteses produz tudo o que aquela lista de expressõ es produz: se a lista contiver
pelo menos uma vírgula, ela produzirá uma tupla; caso contrá rio, produz a ú nica expressã o que compõ e a lista de
expressõ es.
Um par de parê nteses vazio produz um objeto tupla vazio. Como as tuplas sã o imutá veis, aplicam-se as mesmas
regras dos literais (isto é , duas ocorrê ncias da tupla vazia podem ou nã o produzir o mesmo objeto).
Observe que as tuplas nã o sã o formadas pelos parê nteses, mas sim pelo uso da vírgula. A exceçã o é a tupla vazia,
para a qual os parê nteses são obrigató rios – permitir “nada” sem parê nteses em expressõ es causaria ambiguidades e
permitiria que erros de digitaçã o comuns passassem sem serem detectados.

6.2.4 Sintaxe de criação de listas, conjuntos e dicionários

Para construir uma lista, um conjunto ou um dicioná rio, o Python fornece uma sintaxe especial chamada “sintaxes
de criaçã o” (em inglê s, displays), cada uma delas em dois tipos:
• o conteú do do contê iner é listado explicitamente ou
• eles sã o calculados por meio de um conjunto de instruçõ es de laço e filtragem, chamado de compreensão.
Elementos de sintaxe comuns para compreensõ es sã o:

comprehension ::= assignment_expression comp_for

comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter ::= comp_for | comp_if
comp_if ::= "if" or_test [comp_iter]

A compreensã o consiste em uma ú nica expressã o seguida por pelo menos uma clá usula for e zero ou mais clá usulas
for ou if. Neste caso, os elementos do novo contê iner sã o aqueles que seriam produzidos considerando cada uma
das clá usulas for ou if de um bloco, aninhando da esquerda para a direita, e avaliando a expressã o para produzir
um elemento cada vez que o bloco mais interno é alcançado.
No entanto, alé m da expressã o iterá vel na clá usula for mais à esquerda, a compreensã o é executada em um escopo
aninhado implicitamente separado. Isso garante que os nomes atribuídos na lista de destino nã o “vazem” para o
escopo delimitador.
A expressã o iterá vel na clá usula for mais à esquerda é avaliada diretamente no escopo envolvente e entã o passada
como um argumento para o escopo aninhado implicitamente. Clá usulas for subsequentes e qualquer condiçã o de
filtro na clá usula for mais à esquerda nã o podem ser avaliadas no escopo delimitador, pois podem depender dos
valores obtidos do iterá vel mais à esquerda. Por exemplo: [x*y for x in range(10) for y in range(x,
x+10)].
Para garantir que a compreensã o sempre resulte em um contê iner do tipo apropriado, as expressõ es yield e yield
from sã o proibidas no escopo aninhado implicitamente.

Desde o Python 3.6, em uma funçã o async def , uma clá usula async for pode ser usada para iterar sobre um
iterador assíncrono. Uma compreensã o em uma funçã o async def pode consistir em uma clá usula for ou async
for seguindo a expressã o inicial, pode conter for adicional ou async for e també m pode usar expressõ es await.
Se uma compreensã o conté m clá usulas async for, ou se conté m expressõ es await ou outras compreensõ es assín-
cronas em qualquer lugar, exceto a expressã o iterá vel na clá usula for mais à esquerda, ela é chamada uma compre-
ensão assíncrona. Uma compreensã o assíncrona pode suspender a execuçã o da funçã o de corrotina em que aparece.
Veja també m a PEP 530.
Adicionado na versã o 3.6: Compreensõ es assíncronas foram introduzidas.
Alterado na versã o 3.8: yield e yield from proibidos no escopo aninhado implícito.

6.2. Átomos 81
The Python Language Reference, Release 3.13.0

Alterado na versã o 3.11: Compreensõ es assíncronas agora sã o permitidas dentro de compreensõ es em funçõ es as-
síncronas. As compreensõ es externas tornam-se implicitamente assíncronas.

6.2.5 Sintaxes de criação de lista

Uma sintaxe de criaçã o de lista é uma sé rie possivelmente vazia de expressõ es entre colchetes:

list_display ::= "[" [flexible_expression_list | comprehension] "]"

Uma sintaxe de criaçã o de lista produz um novo objeto de lista, sendo o conteú do especificado por uma lista de
expressõ es ou uma compreensã o. Quando uma lista de expressõ es separadas por vírgulas é fornecida, seus elementos
sã o avaliados da esquerda para a direita e colocados no objeto de lista nessa ordem. Quando uma compreensã o é
fornecida, a lista é construída a partir dos elementos resultantes da compreensã o.

6.2.6 Sintaxes de criação de conjunto

Uma sintaxe de criaçã o definida é denotada por chaves e distinguível de sintaxes de criaçã o de dicioná rio pela falta
de caractere de dois pontos separando chaves e valores:

set_display ::= "{" (flexible_expression_list | comprehension) "}"

Uma sintaxe de criaçã o de conjunto produz um novo objeto de conjunto mutá vel, sendo o conteú do especificado
por uma sequê ncia de expressõ es ou uma compreensã o. Quando uma lista de expressõ es separadas por vírgula é
fornecida, seus elementos sã o avaliados da esquerda para a direita e adicionados ao objeto definido. Quando uma
compreensã o é fornecida, o conjunto é construído a partir dos elementos resultantes da compreensã o.
Um conjunto vazio nã o pode ser construído com {}; este literal constró i um dicioná rio vazio.

6.2.7 Sintaxes de criação de dicionário

Uma sintaxe de criaçã o de dicioná rio é uma sé rie possivelmente vazia de itens de dicioná rio (pares chave/valor)
envolto entre chaves:

dict_display ::= "{" [dict_item_list | dict_comprehension] "}"

dict_item_list ::= dict_item ("," dict_item)* [","]
dict_item ::= expression ":" expression | "**" or_expr
dict_comprehension ::= expression ":" expression comp_for

Uma sintaxe de criaçã o de dicioná rio produz um novo objeto dicioná rio.
Se for fornecida uma sequê ncia separada por vírgulas de itens de dicioná rio, eles sã o avaliados da esquerda para
a direita para definir as entradas do dicioná rio: cada objeto chave é usado como uma chave no dicioná rio para
armazenar o valor correspondente. Isso significa que você pode especificar a mesma chave vá rias vezes na lista de
itens de dicioná rio, e o valor final do dicioná rio para essa chave será o ú ltimo dado.
Um asterisco duplo ** denota desempacotamento do dicionário. Seu operando deve ser um mapeamento. Cada item
de mapeamento é adicionado ao novo dicioná rio. Os valores posteriores substituem os valores já definidos por itens
de dicioná rio anteriores e desempacotamentos de dicioná rio anteriores.
Adicionado na versã o 3.5: Desempacotando em sintaxes de criaçã o de dicioná rio, originalmente proposto pela PEP
448.
Uma compreensã o de dict, em contraste com as compreensõ es de lista e conjunto, precisa de duas expressõ es sepa-
radas por dois pontos, seguidas pelas clá usulas usuais “for” e “if”. Quando a compreensã o é executada, os elementos
chave e valor resultantes sã o inseridos no novo dicioná rio na ordem em que sã o produzidos.
Restriçõ es nos tipos de valores de chave sã o listadas anteriormente na seçã o A hierarquia de tipos padrão. (Para
resumir, o tipo de chave deve ser hasheável, que exclui todos os objetos mutá veis.) Nã o sã o detectadas colisõ es

82 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

entre chaves duplicadas; o ú ltimo valor (textualmente mais à direita na sintaxe de criaçã o) armazenado para um
determinado valor de chave prevalece.
Alterado na versã o 3.8: Antes do Python 3.8, em compreensõ es de dict, a ordem de avaliaçã o de chave e valor nã o
era bem definida. No CPython, o valor foi avaliado antes da chave. A partir de 3.8, a chave é avaliada antes do valor,
conforme proposto pela PEP 572.

6.2.8 Expressões geradoras

Uma expressã o geradora é uma notaçã o geradora compacta entre parê nteses:

generator_expression ::= "(" expression comp_for ")"

Uma expressã o geradora produz um novo objeto gerador. Sua sintaxe é a mesma das compreensõ es, exceto pelo fato
de estar entre parê nteses em vez de colchetes ou chaves.
As variá veis usadas na expressã o geradora sã o avaliadas lentamente quando o mé todo __next__() é chamado
para o objeto gerador (da mesma forma que os geradores normais). No entanto, a expressã o iterá vel na clá usula
for mais à esquerda é avaliada imediatamente, de modo que um erro produzido por ela será emitido no ponto em
que a expressã o do gerador é definida, em vez de no ponto em que o primeiro valor é recuperado. Clá usulas for
subsequentes e qualquer condiçã o de filtro na clá usula for mais à esquerda nã o podem ser avaliadas no escopo
delimitador, pois podem depender dos valores obtidos do iterá vel mais à esquerda. Por exemplo: (x*y for x in
range(10) for y in range(x, x+10)).

Os parê nteses podem ser omitidos em chamadas com apenas um argumento. Veja a seçã o Chamadas para detalhes.
Para evitar interferir com a operaçã o esperada da pró pria expressã o geradora, as expressõ es yield e yield from
sã o proibidas no gerador definido implicitamente.
Se uma expressã o geradora conté m clá usulas async for ou expressõ es await, ela é chamada de expressão gera-
dora assíncrona. Uma expressã o geradora assíncrona retorna um novo objeto gerador assíncrono, que é um iterador
assíncrono (consulte Iteradores assíncronos).
Adicionado na versã o 3.6: Expressõ es geradoras assíncronas foram introduzidas.
Alterado na versã o 3.7: Antes do Python 3.7, as expressõ es geradoras assíncronas só podiam aparecer em corrotinas
async def . A partir da versã o 3.7, qualquer funçã o pode usar expressõ es geradoras assíncronas.

Alterado na versã o 3.8: yield e yield from proibidos no escopo aninhado implícito.

6.2.9 Expressões yield

yield_atom ::= "(" yield_expression ")"

yield_from ::= "yield" "from" expression
yield_expression ::= "yield" yield_list | yield_from
A expressã o yield é usada ao definir uma funçã o generadora ou uma funçã o geradora assíncrona e, portanto, só pode
ser usada no corpo de uma definiçã o de funçã o. Usar uma expressã o yield no corpo de uma funçã o faz com que essa
funçã o seja uma funçã o geradora, e usá -la no corpo de uma funçã o async def faz com que essa funçã o de corrotina
seja uma funçã o geradora assíncrona. Por exemplo:

def gen(): # define uma função geradora

yield 123

async def agen(): # define uma função geradora assíncrona

yield 123

Devido a seus efeitos colaterais no escopo recipiente, as expressõ es yield nã o sã o permitidas como parte dos escopos
definidos implicitamente usados para implementar compreensõ es e expressõ es geradoras.
Alterado na versã o 3.8: Expressõ es yield proibidas nos escopos aninhados implicitamente usados para implementar
compreensõ es e expressõ es geradoras.

6.2. Átomos 83
The Python Language Reference, Release 3.13.0

As funçõ es geradoras sã o descritas abaixo, enquanto as funçõ es geradoras assíncronas sã o descritas separadamente
na seçã o Funções geradoras assíncronas
Quando uma funçã o geradora é chamada, ela retorna um iterador conhecido como gerador. Esse gerador entã o
controla a execuçã o da funçã o geradora. A execuçã o começa quando um dos mé todos do gerador é chamado. Nesse
momento, a execuçã o segue para a primeira expressã o yield, onde é suspensa novamente, retornando o valor de
yield_list ao chamador do gerador, ou None se yield_list é omitido. Por suspenso, queremos dizer que todo
o estado local é retido, incluindo as chamadas atuais de variá veis locais, o ponteiro de instruçã o, a pilha de avaliaçã o
interna e o estado de qualquer tratamento de exceçã o. Quando a execuçã o é retomada chamando um dos mé todos
do gerador, a funçã o pode prosseguir exatamente como se a expressã o yield fosse apenas outra chamada externa. O
valor da expressã o yield apó s a retomada depende do mé todo que retomou a execuçã o. Se __next__() for usado
(tipicamente atravé s de uma for ou do next() embutido) entã o o resultado será None. Caso contrá rio, se send()
for usado, o resultado será o valor passado para esse mé todo.
Tudo isso torna as funçõ es geradoras bastante semelhantes à s corrotinas; cedem mú ltiplas vezes, possuem mais de
um ponto de entrada e sua execuçã o pode ser suspensa. A ú nica diferença é que uma funçã o geradora nã o pode
controlar onde a execuçã o deve continuar apó s o seu rendimento; o controle é sempre transferido para o chamador
do gerador.
Expressõ es yield sã o permitidas em qualquer lugar em uma construçã o try . Se o gerador nã o for retomado antes
de ser finalizado (ao atingir uma contagem de referê ncias zero ou ao ser coletado como lixo), o mé todo close() do
iterador de gerador será chamado, permitindo que quaisquer clá usulas finally pendentes sejam executadas.
Quando yield from <expr> é usado, a expressã o fornecida deve ser iterá vel. Os valores produzidos pela iteraçã o
desse iterá vel sã o passados diretamente para o chamador dos mé todos do gerador atual. Quaisquer valores passados
com send() e quaisquer exceçõ es passadas com throw() sã o passados para o iterador subjacente se ele tiver os
mé todos apropriados. Se este nã o for o caso, entã o send() irá levantar AttributeError ou TypeError, enquanto
throw() irá apenas levantar a exceçã o passada imediatamente.

Quando o iterador subjacente estiver completo, o atributo value da instâ ncia StopIteration gerada torna-se o
valor da expressã o yield. Ele pode ser definido explicitamente ao levantar StopIteration ou automaticamente
quando o subiterador é um gerador (retornando um valor do subgerador).
Alterado na versã o 3.3: Adicionado yield from <expr> para delegar o fluxo de controle a um subiterador.
Os parê nteses podem ser omitidos quando a expressã o yield é a ú nica expressã o no lado direito de uma instruçã o de
atribuiçã o.

µ Ver também

PEP 255 - Geradores simples

A proposta para adicionar geradores e a instruçã o yield ao Python.
PEP 342 - Corrotinas via Geradores Aprimorados
A proposta de aprimorar a API e a sintaxe dos geradores, tornando-os utilizá veis como simples corrotinas.
PEP 380 - Sintaxe para Delegar a um Subgerador
A proposta de introduzir a sintaxe yield_from, facilitando a delegaçã o a subgeradores.
PEP 525 - Geradores assíncronos
A proposta que se expandiu em PEP 492 adicionando recursos de gerador a funçõ es de corrotina.

Métodos de iterador gerador

Esta subseçã o descreve os mé todos de um iterador gerador. Eles podem ser usados para controlar a execuçã o de uma
funçã o geradora.
Observe que chamar qualquer um dos mé todos do gerador abaixo quando o gerador já estiver em execuçã o levanta
uma exceçã o ValueError.
generator.__next__()
Inicia a execuçã o de uma funçã o geradora ou a retoma na ú ltima expressã o yield executada. Quando uma

84 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

funçã o geradora é retomada com um mé todo __next__(), a expressã o yield atual sempre é avaliada como
None. A execuçã o entã o continua para a pró xima expressã o yield, onde o gerador é suspenso novamente, e o
valor de yield_list é retornado para o chamador de __next__(). Se o gerador sair sem produzir outro
valor, uma exceçã o StopIteration será levantada.
Este mé todo é normalmente chamado implicitamente, por exemplo por um laço for, ou pela funçã o embutida
next().

[Link](value)
Retoma a execuçã o e “envia” um valor para a funçã o geradora. O argumento value torna-se o resultado
da expressã o yield atual. O mé todo send() retorna o pró ximo valor gerado pelo gerador, ou levanta
StopIteration se o gerador sair sem produzir outro valor. Quando send() é chamado para iniciar o
gerador, ele deve ser chamado com None como argumento, porque nã o há nenhuma expressã o yield que possa
receber o valor.
[Link](value)
[ [
[Link](type , value , traceback ]])
Levanta uma exceçã o no ponto em que o gerador foi pausado e retorna o pró ximo valor gerado pela funçã o
geradora. Se o gerador sair sem gerar outro valor, uma exceçã o StopIteration será levantada. Se a funçã o
geradora nã o detectar a exceçã o passada ou levanta uma exceçã o diferente, essa exceçã o se propagará para o
chamador.
Em uso típico, isso é chamado com uma ú nica instâ ncia de exceçã o semelhante à forma como a palavra reser-
vada raise é usada.
Para compatibilidade com versõ es anteriores, no entanto, a segunda assinatura é suportada, seguindo uma
convençã o de versõ es mais antigas do Python. O argumento type deve ser uma classe de exceçã o e value
deve ser uma instâ ncia de exceçã o. Se o valor nã o for fornecido, o construtor tipo será chamado para obter
uma instâ ncia. Se traceback for fornecido, ele será definido na exceçã o, caso contrá rio, qualquer atributo
__traceback__ existente armazenado em value poderá ser limpo.
Alterado na versã o 3.12: A segunda assinatura (tipo[, valor[, traceback]]) foi descontinuada e pode ser remo-
vida em uma versã o futura do Python.
[Link]()
Levanta GeneratorExit no ponto onde a funçã o geradora foi pausada. Se a funçã o geradora captura a
exceçã o, e retorna um valor, este valor é retornado de close(). Se a funçã o geradora já estiver fechada ou
levantar GeneratorExit (por nã o capturar a exceçã o), close() retornará None. Se o gerador produzir
um valor, uma exceçã o RuntimeError é levantada. Se o gerador levantar qualquer outra exceçã o, ela será
propagada para o chamador. Se o gerador já saiu devido a uma exceçã o ou saída normal, close() retorna
None e tem nenhum outro efeito.
Alterado na versã o 3.13: Se um gerador retornar um valor ao ser fechado, o valor será retornado por close().

Exemplos
Aqui está um exemplo simples que demonstra o comportamento de geradores e funçõ es geradoras:

>>> def echo(value=None):

... print("A execução inicia quando 'next()' é chamada pela primeira vez.")
... try:
... while True:
... try:
... value = (yield value)
... except Exception as e:
... value = e
... finally:
... print("Não se esqueça de fazer uma limpeza quando 'close()' for␣
,→chamada.")

...
>>> generator = echo(1)
(continua na pró xima pá gina)

6.2. Átomos 85
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

>>> print(next(generator))
A execução inicia quando 'next()' é chamada pela primeira vez.
1
>>> print(next(generator))
None
>>> print([Link](2))
2
>>> [Link](TypeError, "spam")
TypeError('spam',)
>>> [Link]()
Não se esqueça de fazer uma limpeza quando 'close()' for chamada.

Para exemplos usando yield from, consulte a pep-380 em “O que há de novo no Python.”

Funções geradoras assíncronas

A presença de uma expressã o yield em uma funçã o ou mé todo definido usando a async def define ainda mais a
funçã o como uma funçã o geradora assíncrona.
Quando uma funçã o geradora assíncrona é chamada, ela retorna um iterador assíncrono conhecido como objeto ge-
rador assíncrono. Esse objeto controla a execuçã o da funçã o geradora. Um objeto gerador assíncrono é normalmente
usado em uma instruçã o async for em uma funçã o de corrotina de forma aná loga a como um objeto gerador seria
usado em uma instruçã o for.
A chamada de um dos mé todos do gerador assíncrono retorna um objeto aguardável, e a execuçã o começa quando
esse objeto é aguardado. Nesse momento, a execuçã o prossegue até a primeira expressã o yield, onde é suspensa
novamente, retornando o valor de yield_list para a corrotina em aguardo. Assim como ocorre com um gerador,
a suspensã o significa que todo o estado local é mantido, inclusive as ligaçõ es atuais das variá veis locais, o ponteiro de
instruçõ es, a pilha de avaliaçã o interna e o estado de qualquer tratamento de exceçã o. Quando a execuçã o é retomada,
aguardando o pró ximo objeto retornado pelos mé todos do gerador assíncrono, a funçã o pode prosseguir exatamente
como se a expressã o de rendimento fosse apenas outra chamada externa. O valor da expressã o yield apó s a retomada
depende do mé todo que retomou a execuçã o. Se __anext__() for usado, o resultado será None. Caso contrá rio,
se asend() for usado, o resultado será o valor passado para esse mé todo.
Se um gerador assíncrono encerrar mais cedo por break, pela tarefa que fez sua chamada ser cancelada ou por outras
exceçõ es, o có digo de limpeza assíncrona do gerador será executado e possivelmente levantará alguma exceçã o ou
acessará as variá veis de contexto em um contexto inesperado – talvez apó s o tempo de vida das tarefas das quais ele
depende, ou durante o laço de eventos de encerramento quando o gancho de coleta de lixo do gerador assíncrono for
chamado. Para prevenir isso, o chamador deve encerrar explicitamente o gerador assíncrono chamando o mé todo
aclose() para finalizar o gerador e, por fim, desconectá -lo do laço de eventos.
Em uma funçã o geradora assíncrona, expressõ es de yield sã o permitidas em qualquer lugar em uma construçã o
try . No entanto, se um gerador assíncrono nã o for retomado antes de ser finalizado (alcançando uma contagem de
referê ncia zero ou sendo coletado pelo coletor de lixo), entã o uma expressã o de yield dentro de um construçã o try
pode resultar em uma falha na execuçã o das clá usulas pendentes de finally . Nesse caso, é responsabilidade do
laço de eventos ou escalonador que executa o gerador assíncrono chamar o mé todo aclose() do gerador iterador
assíncrono e executar o objeto corrotina resultante, permitindo assim que quaisquer clá usulas pendentes de finally
sejam executadas.
Para cuidar da finalizaçã o apó s o té rmino do laço de eventos, um laço de eventos deve definir uma funçã o finalizer
que recebe um gerador assíncrono e provavelmente chama aclose() e executa a corrotina. Este finalizer pode ser
registrado chamando sys.set_asyncgen_hooks(). Quando iterado pela primeira vez, um gerador assíncrono
armazenará o finalizer registrado para ser chamado na finalizaçã o. Para um exemplo de referê ncia de um mé todo
finalizer, consulte a implementaçã o de [Link].shutdown_asyncgens em Lib/asyncio/base_events.py.
O expressã o yield from <expr> é um erro de sintaxe quando usado em uma funçã o geradora assíncrona.

86 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

Métodos geradores-iteradores assíncronos

Esta subseçã o descreve os mé todos de um iterador gerador assíncrono, que sã o usados para controlar a execuçã o de
uma funçã o geradora.
coroutine agen.__anext__()
Retorna um objeto aguardá vel que, quando executado, começa a executar o gerador assíncrono ou o retoma
na ú ltima expressã o yield executada. Quando uma funçã o geradora assíncrona é retomada com o mé todo
__anext__(), a expressã o yield atual sempre avalia para None no objeto aguardá vel retornado, que, quando
executado, continuará para a pró xima expressã o yield. O valor de yield_list da expressã o yield é o valor da
exceçã o StopIteration levantada pela corrotina em conclusã o. Se o gerador assíncrono sair sem produzir
outro valor, o objeto aguardá vel em vez disso levanta uma exceçã o StopAsyncIteration, sinalizando que
a iteraçã o assíncrona foi concluída.
Este mé todo é normalmente chamado implicitamente por um laço async for.
coroutine [Link](value)
Retorna um objeto aguardá vel que, quando executado, retoma a execuçã o do gerador assíncrono. Assim como
o mé todo send() para um gerador, isso “envia” um valor para a funçã o geradora assíncrona, e o argumento
value se torna o resultado da expressã o de yield atual. O objeto aguardá vel retornado pelo mé todo asend()
retornará o pró ximo valor produzido pelo gerador como o valor da exceçã o StopIteration levantada, ou
lança StopAsyncIteration se o gerador assíncrono sair sem produzir outro valor. Quando asend() é
chamado para iniciar o gerador assíncrono, ele deve ser chamado com None como argumento, pois nã o há
expressã o yield que possa receber o valor.
coroutine [Link](value)
[ [
coroutine [Link](type , value , traceback ]])
Retorna um objeto aguardá vel que gera uma exceçã o do tipo type no ponto em que o gerador assíncrono foi
pausado, e retorna o pró ximo valor produzido pela funçã o geradora como o valor da exceçã o StopIteration
levantada. Se o gerador assíncrono terminar sem produzir outro valor, uma exceçã o StopAsyncIteration é
levantada pelo objeto aguardá vel. Se a funçã o geradora nã o capturar a exceçã o passada ou gerar uma exceçã o
diferente, entã o quando o objeto aguardá vel for executado, essa exceçã o se propagará para o chamador do
objeto aguardá vel.
Alterado na versã o 3.12: A segunda assinatura (tipo[, valor[, traceback]]) foi descontinuada e pode ser remo-
vida em uma versã o futura do Python.
coroutine [Link]()
Retorna um objeto aguardá vel que, quando executado, levantará uma GeneratorExit na funçã o geradora
assíncrona no ponto em que foi pausada. Se a funçã o geradora assíncrona sair de forma normal, se estiver já es-
tiver fechada ou levantar GeneratorExit (nã o capturando a exceçã o), entã o o objeto aguardá vel retornado
levantará uma exceçã o StopIteration. Quaisquer outros objetos aguardá veis retornados por chamadas
subsequentes à funçã o geradora assíncrona levantarã o uma exceçã o StopAsyncIteration. Se a funçã o ge-
radora assíncrona levantar um valor, um RuntimeError será lançado pelo objeto aguardá vel. Se a funçã o
geradora assíncrona levantar qualquer outra exceçã o, ela será propagada para o chamador do objeto aguardá -
vel. Se a funçã o geradora assíncrona já tiver saído devido a uma exceçã o ou saída normal, entã o chamadas
posteriores ao mé todo aclose() retornarã o um objeto aguardá vel que nã o faz nada.

6.3 Primárias
Primá rias representam as operaçõ es mais fortemente vinculadas da linguagem. Sua sintaxe é :

primary ::= atom | attributeref | subscription | slicing | call

6.3. Primárias 87
The Python Language Reference, Release 3.13.0

6.3.1 Referências de atributo

Uma referê ncia de atributo é um primá rio seguido de um ponto e um nome.

attributeref ::= primary "." identifier

A primá ria deve avaliar para um objeto de um tipo que tem suporte a referê ncias de atributo, o que a maioria dos
objetos faz. Este objeto é entã o solicitado a produzir o atributo cujo nome é o identificador. O tipo e o valor produzido
sã o determinados pelo objeto. Vá rias avaliaçõ es da mesma referê ncia de atributo podem produzir diferentes objetos.
Esta produçã o pode ser personalizada substituindo o mé todo __getattribute__() ou o mé todo
__getattr__(). O mé todo __getattribute__() é chamado primeiro e retorna um valor ou levanta
uma AttributeError se o atributo nã o estiver disponível.
Se for levantada uma AttributeError e o objeto tiver um mé todo __getattr__(), esse mé todo será chamado
como alternativa.

6.3.2 Subscrições
A subscriçã o de uma instâ ncia de uma classe de classe de contêiner geralmente selecionará um elemento do contê iner.
A subscriçã o de uma classe genérica geralmente retornará um objeto GenericAlias.

subscription ::= primary "[" flexible_expression_list "]"

Quando um objeto é subscrito, o interpretador avaliará o primá rio e a lista de expressõ es.
O primá rio deve ser avaliado como um objeto que dê suporte à subscriçã o. Um objeto pode prover suporte a subs-
criçã o atravé s da definiçã o de um ou ambos __getitem__() e __class_getitem__(). Quando o primá rio é
subscrito, o resultado avaliado da lista de expressõ es será passado para um desses mé todos. Para mais detalhes sobre
quando __class_getitem__ é chamado em vez de __getitem__, veja __class_getitem__ versus __getitem__.
Se a lista de expressõ es contiver pelo menos uma vírgula ou se alguma das expressõ es for estrelada, ela será avaliada
como uma tuple contendo os itens da lista de expressõ es. Caso contrá rio, a lista de expressõ es será avaliada como
o valor do ú nico membro da lista.
Alterado na versã o 3.11: Expressõ es em uma lista de expressõ es podem ser estreladas. Veja a PEP 646.
Para objetos embutido, existem dois tipos de objetos que oferecem suporte a subscriçã o via __getitem__():
1. Mapeamentos. Se o primá rio for um mapeamento, a lista de expressõ es deve ser avaliada como um objeto cujo
valor é uma das chaves do mapeamento, e a subscriçã o seleciona o valor no mapeamento que corresponde a
essa chave. Um exemplo de classe de mapeamento integrada é a classe dict.
2. Sequê ncias. Se o primá rio for uma sequência, a lista de expressõ es deve ser avaliada como int ou slice
(conforme discutido na seçã o seguinte). Exemplos de classes de sequê ncia embutidas incluem as classes str,
list e tuple.

A sintaxe formal nã o faz nenhuma provisã o especial para índices negativos em sequências. No entanto, todas as
sequê ncias embutidas fornecem um mé todo __getitem__() que interpreta índices negativos adicionando o com-
primento da sequê ncia ao índice para que, por exemplo, x[-1] selecione o ú ltimo item de x. O valor resultante
deve ser um nú mero inteiro nã o negativo menor que o nú mero de itens na sequê ncia, e a subscriçã o seleciona o item
cujo índice é esse valor (contando a partir de zero). Como o suporte para índices negativos e fatiamento ocorre no
mé todo __getitem__() do objeto, as subclasses que substituem esse mé todo precisarã o adicionar explicitamente
esse suporte.
Uma string é um tipo especial de sequê ncia cujos itens sã o caracteres. Um caractere nã o é um tipo de dados
separado, mas uma string de exatamente um caractere.

88 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

6.3.3 Fatiamentos
Um fatiamento seleciona um intervalo de itens em um objeto sequê ncia (por exemplo, uma string, tupla ou lista).
As fatias podem ser usadas como expressõ es ou como alvos em instruçõ es de atribuiçã o ou del. A sintaxe para um
fatiamento:

slicing ::= primary "[" slice_list "]"

slice_list ::= slice_item ("," slice_item)* [","]
slice_item ::= expression | proper_slice
proper_slice ::= [lower_bound] ":" [upper_bound] [ ":" [stride] ]
lower_bound ::= expression
upper_bound ::= expression
stride ::= expression

Há ambiguidade na sintaxe formal aqui: qualquer coisa que se pareça com uma lista de expressõ es també m se parece
com uma lista de fatias, portanto qualquer subscriçã o pode ser interpretada como um fatiamento. Em vez de com-
plicar ainda mais a sintaxe, isso é eliminado pela definiçã o de que, neste caso, a interpretaçã o como uma subscriçã o
tem prioridade sobre a interpretaçã o como um fatiamento (este é o caso se a lista de fatias nã o contiver uma fatia
adequada).
A semâ ntica para um fatiamento é a seguinte. O primá rio é indexado (usando o mesmo mé todo __getitem__()
da subscriçã o normal) com uma chave que é construída a partir da lista de fatias, como segue. Se a lista de fatias
contiver pelo menos uma vírgula, a chave será uma tupla contendo a conversã o dos itens da fatia; caso contrá rio, a
conversã o do item de fatia isolada é a chave. A conversã o de um item de fatia que é uma expressã o é essa expressã o.
A conversã o de uma fatia adequada é um objeto fatia (veja a seçã o A hierarquia de tipos padrão) cujos start, stop e
step atributos sã o os valores das expressõ es fornecidas como limite inferior, limite superior e passo, respectivamente,
substituindo None pelas expressõ es ausentes.

6.3.4 Chamadas
Uma chamada chama um objeto que é um chamá vel (por exemplo, uma função) com uma sé rie possivelmente vazia
de argumentos:

call ::= primary "(" [argument_list [","] | comprehension] ")"

argument_list ::= positional_arguments ["," starred_and_keywords]
["," keywords_arguments]
| starred_and_keywords ["," keywords_arguments]
| keywords_arguments
positional_arguments ::= positional_item ("," positional_item)*
positional_item ::= assignment_expression | "*" expression
starred_and_keywords ::= ("*" expression | keyword_item)
("," "*" expression | "," keyword_item)*
keywords_arguments ::= (keyword_item | "**" expression)
("," keyword_item | "," "**" expression)*
keyword_item ::= identifier "=" expression

Uma vírgula final opcional pode estar presente apó s os argumentos posicionais e nomeados, mas nã o afeta a semâ ntica.
O primá rio deve ser avaliado como um objeto que pode ser chamado (funçõ es definidas pelo usuá rio, funçõ es em-
butidas, mé todos de objetos embutidos, objetos de classe, mé todos de instâ ncias de classe e todos os objetos que
possuem um mé todo __call__() sã o chamá veis). Todas as expressõ es de argumento sã o avaliadas antes da tenta-
tiva de chamada. Consulte a seçã o Definições de função para a sintaxe das listas formais de parâmetros.
Se houver argumentos nomeados, eles serã o primeiro convertidos em argumentos posicionais, como segue. Pri-
meiro, é criada uma lista de slots nã o preenchidos para os parâ metros formais. Se houver N argumentos posicionais,
eles serã o colocados nos primeiros N slots. A seguir, para cada argumento nomeado, o identificador é usado para
determinar o slot correspondente (se o identificador for igual ao primeiro nome formal do parâ metro, o primeiro
slot será usado e assim por diante). Se o slot já estiver preenchido, uma exceçã o TypeError será levantada. Caso

6.3. Primárias 89
The Python Language Reference, Release 3.13.0

contrá rio, o argumento é colocado no slot, preenchendo-o (mesmo que a expressã o seja None, ela preenche o slot).
Quando todos os argumentos forem processados, os slots ainda nã o preenchidos serã o preenchidos com o valor pa-
drã o correspondente da definiçã o da funçã o. (Os valores padrã o sã o calculados, uma vez, quando a funçã o é definida;
assim, um objeto mutá vel, como uma lista ou dicioná rio usado como valor padrã o, será compartilhado por todas as
chamadas que nã o especificam um valor de argumento para o slot correspondente; isso deve geralmente ser evitado.)
Se houver algum slot nã o preenchido para o qual nenhum valor padrã o for especificado, uma exceçã o TypeError
será levantada. Caso contrá rio, a lista de slots preenchidos será usada como lista de argumentos para a chamada.
Detalhes da implementação do CPython: Uma implementaçã o pode fornecer funçõ es integradas cujos parâ me-
tros posicionais nã o possuem nomes, mesmo que sejam ‘nomeados’ para fins de documentaçã o e que, portanto,
nã o possam ser fornecidos por nomes. No CPython, este é o caso de funçõ es implementadas em C que usam
PyArg_ParseTuple() para analisar seus argumentos.

Se houver mais argumentos posicionais do que slots de parâ metros formais, uma exceçã o TypeError será levantada,
a menos que um parâ metro formal usando a sintaxe *identificador esteja presente; neste caso, esse parâ metro
formal recebe uma tupla contendo os argumentos posicionais em excesso (ou uma tupla vazia se nã o houver argu-
mentos posicionais em excesso).
Se algum argumento nomeado nã o corresponder a um nome de parâ metro formal, uma exceçã o TypeError é le-
vantada, a menos que um parâ metro formal usando a sintaxe **identificador esteja presente; neste caso, esse
parâ metro formal recebe um dicioná rio contendo os argumentos nomeados em excesso (usando os nomes como
chaves e os valores dos argumentos como valores correspondentes), ou um (novo) dicioná rio vazio se nã o houver
argumentos nomeados em excesso.
Se a sintaxe *expressão aparecer na chamada da funçã o, expressão deverá ser avaliada como iterável. Os ele-
mentos desses iterá veis sã o tratados como se fossem argumentos posicionais adicionais. Para a chamada f(x1,
x2, *y, x3, x4), se y for avaliado como uma sequê ncia y1, …, yM, isso é equivalente a uma chamada com M+4
argumentos posicionais x1, x2, y1, …, yM, x3, x4.
Uma consequê ncia disso é que embora a sintaxe *expressão possa aparecer depois de argumentos nomeados explí-
citos, ela é processada antes dos argumentos nomeados (e de quaisquer argumentos de **expressão – veja abaixo).
Entã o:

>>> def f(a, b):

... print(a, b)
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2

É incomum que ambos os argumentos nomeados e a sintaxe *expressão sejam usados na mesma chamada, portanto,
na prá tica, essa confusã o nã o surge com frequê ncia.
Se a sintaxe **expressão aparecer na chamada de funçã o, expressão deve ser avaliada como um mapeamento,
cujo conteú do é tratado como argumentos nomeados adicionais. Se um parâ metro que corresponde a uma chave já
recebeu um valor (por um argumento nomeado explícito ou de outro desempacotamento), uma exceçã o TypeError
é levantada.
Quando **expressão é usada, cada chave neste mapeamento deve ser uma string. Cada valor do mapeamento é
atribuído ao primeiro parâ metro formal elegível para atribuiçã o de nomeas cujo nome é igual à chave. Uma chave
nã o precisa ser um identificador Python (por exemplo, "max-temp °F" é aceitá vel, embora nã o corresponda a
nenhum parâ metro formal que possa ser declarado). Se nã o houver correspondê ncia com um parâ metro formal, o
par chave-valor é coletado pelo parâ metro **, se houver, ou se nã o houver, uma exceçã o TypeError é levantada.
Parâ metros formais usando a sintaxe *identificador ou **identificador nã o podem ser usados como slots
de argumentos posicionais ou como nomes de argumentos nomeados.

90 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

Alterado na versã o 3.5: Chamadas de funçã o aceitam qualquer nú mero de desempacotamentos * e **, argumentos
posicionais podem seguir desempacotamentos iterá veis (*) e argumentos nomeados podem seguir desempacotamen-
tos de dicioná rio (**). Originalmente proposto pela PEP 448.
Uma chamada sempre retorna algum valor, possivelmente None, a menos que levanta uma exceçã o. A forma como
esse valor é calculado depende do tipo do objeto chamá vel.
Se for…
uma função definida por usuário:
O bloco de có digo da funçã o é executado, passando-lhe a lista de argumentos. A primeira coisa que o bloco
de có digo fará é vincular os parâ metros formais aos argumentos; isso é descrito na seçã o Definições de função.
Quando o bloco de có digo executa uma instruçã o return, isso especifica o valor de retorno da chamada de
funçã o.
um método embutido ou uma função embutida:
O resultado fica por conta do interpretador; veja built-in-funcs para descriçõ es de funçõ es embutidas e mé todos
embutidos.
um objeto classe:
Uma nova instâ ncia dessa classe é retornada.
um método de instância de classe:
A funçã o correspondente definida pelo usuá rio é chamada, com uma lista de argumentos que é maior que a
lista de argumentos da chamada: a instâ ncia se torna o primeiro argumento.
uma instância de classe:
A classe deve definir um mé todo __call__(); o efeito é entã o o mesmo como se esse mé todo fosse chamado.

6.4 Expressão await

Suspende a execuçã o de corrotina em um objeto aguardável. Só pode ser usado dentro de uma função de corrotina.

await_expr ::= "await" primary

Adicionado na versã o 3.5.

6.5 O operador de potência

O operador de potê ncia vincula-se com mais força do que os operadores uná rios à sua esquerda; ele se vincula com
menos força do que os operadores uná rios à sua direita. A sintaxe é :

power ::= (await_expr | primary) ["**" u_expr]

Assim, em uma sequê ncia sem parê nteses de operadores de potê ncia e uná rios, os operadores sã o avaliados da direita
para a esquerda (isso nã o restringe a ordem de avaliaçã o dos operandos): -1**2 resulta em -1 .
O operador de potê ncia tem a mesma semâ ntica que a funçã o embutida pow(), quando chamado com dois argu-
mentos: ele produz seu argumento esquerdo elevado à potê ncia de seu argumento direito. Os argumentos numé ricos
sã o primeiro convertidos em um tipo comum e o resultado é desse tipo.
Para operandos int, o resultado tem o mesmo tipo que os operandos, a menos que o segundo argumento seja negativo;
nesse caso, todos os argumentos sã o convertidos em ponto flutuante e um resultado ponto flutuante é entregue. Por
exemplo, 10**2 retorna 100, mas 10**-2 retorna 0.01.
Elevar 0.0 a uma potê ncia negativa resulta em uma exceçã o ZeroDivisionError. Elevar um nú mero negativo a
uma potê ncia fracioná ria resulta em um nú mero complex. (Em versõ es anteriores, levantava ValueError.)
Esta operaçã o pode ser personalizada usando os mé todos especial __pow__() e __rpow__().

6.4. Expressão await 91

The Python Language Reference, Release 3.13.0

6.6 Operações aritméticas unárias e bit a bit

Todas as operaçõ es aritmé ticas uná rias e bit a bit tê m a mesma prioridade:

u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr

O operador uná rio - (menos) produz a negaçã o de seu argumento numé rico; a operaçã o pode ser substituída pelo
mé todo especial __neg__().
O operador uná rio + (mais) produz seu argumento numé rico inalterado; a operaçã o pode ser substituída pelo mé todo
especial __pos__().
O operador uná rio ~ (inverter) produz a inversã o bit a bit de seu argumento inteiro. A inversã o bit a bit de x é definida
como -(x+1). Aplica-se apenas a nú meros inteiros ou a objetos personalizados que substituem o mé todo especial
__invert__().

Em todos os trê s casos, se o argumento nã o tiver o tipo adequado, uma exceçã o TypeError é levantada.

6.7 Operações binárias aritméticas

As operaçõ es aritmé ticas biná rias possuem os níveis de prioridade convencionais. Observe que algumas dessas ope-
raçõ es també m se aplicam a determinados tipos nã o numé ricos. Alé m do operador potê ncia, existem apenas dois
níveis, um para operadores multiplicativos e outro para operadores aditivos:

m_expr ::= u_expr | m_expr "*" u_expr | m_expr "@" m_expr |

m_expr "//" u_expr | m_expr "/" u_expr |
m_expr "%" u_expr
a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr

O operador * (multiplicaçã o) produz o produto de seus argumentos. Os argumentos devem ser nú meros ou um argu-
mento deve ser um nú mero inteiro e o outro deve ser uma sequê ncia. No primeiro caso, os nú meros sã o convertidos
para um tipo comum e depois multiplicados. Neste ú ltimo caso, é realizada a repetiçã o da sequê ncia; um fator de
repetiçã o negativo produz uma sequê ncia vazia.
Esta operaçã o pode ser personalizada usando os mé todos especial __mul__() e __rmul__().
O operador @ (arroba) deve ser usado para multiplicaçã o de matrizes. Nenhum tipo embutido do Python implementa
este operador.
Esta operaçã o pode ser personalizada usando os mé todos especial __matmul__() e __rmatmul__().
Adicionado na versã o 3.5.
Os operadores / (divisã o) e // (divisã o pelo piso) produzem o quociente de seus argumentos. Os argumentos nu-
mé ricos sã o primeiro convertidos em um tipo comum. A divisã o de inteiros produz um ponto flutuante, enquanto
a divisã o pelo piso de inteiros resulta em um inteiro; o resultado é o da divisã o matemá tica com a funçã o ‘floor’
aplicada ao resultado. A divisã o por zero levanta a exceçã o ZeroDivisionError.
A operaçã o de divisã o pode ser personalizada usando os mé todos especiais __truediv__() e __rtruediv__().
A operaçã o de divisã o pelo piso pode ser personalizada usando os mé todos especiais __floordiv__() e
__rfloordiv__().

O operador % (mó dulo) produz o restante da divisã o do primeiro argumento pelo segundo. Os argumentos numé ricos
sã o primeiro convertidos em um tipo comum. Um argumento zero à direita levanta a exceçã o ZeroDivisionError.
Os argumentos podem ser nú meros de ponto flutuante, por exemplo, 3.14%0.7 é igual a 0.34 (já que 3.14 é igual
a 4*0.7 + 0.34.) O operador mó dulo sempre produz um resultado com o mesmo sinal do seu segundo operando
(ou zero); o valor absoluto do resultado é estritamente menor que o valor absoluto do segundo operando1 .
1 Embora abs(x%y) < abs(y) seja verdadeiro matematicamente, para nú meros flutuantes pode nã o ser verdadeiro numericamente devido

ao arredondamento. Por exemplo, e presumindo uma plataforma na qual um float Python seja um nú mero de precisã o dupla IEEE 754, para
que -1e-100 % 1e100 tenha o mesmo sinal que 1e100, o resultado calculado é -1e-100 + 1e100, que é numericamente exatamente igual a

92 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

Os operadores de divisã o pelo piso e mó dulo sã o conectados pela seguinte identidade: x == (x//y)*y + (x%y).
A divisã o pelo piso e o mó dulo també m estã o conectados com a funçã o embutida divmod(): divmod(x, y) ==
(x//y, x%y).2 .

Alé m de realizar a operaçã o de mó dulo em nú meros, o operador % també m é sobrecarregado por objetos string para
realizar a formataçã o de string no estilo antigo (també m conhecida como interpolaçã o). A sintaxe para formataçã o
de string é descrita na Referê ncia da Biblioteca Python, seçã o old-string-formatting.
A operaçã o módulo pode ser personalizada usando os mé todos especial __mod__() e __rmod__().
O operador de divisã o pelo piso, o operador de mó dulo e a funçã o divmod() nã o sã o definidos para nú meros
complexos. Em vez disso, converta para um nú mero de ponto flutuante usando a funçã o abs() se apropriado.
O operador + (adiçã o) produz a soma de seus argumentos. Os argumentos devem ser nú meros ou sequê ncias do
mesmo tipo. No primeiro caso, os nú meros sã o convertidos para um tipo comum e depois somados. Neste ú ltimo
caso, as sequê ncias sã o concatenadas.
Esta operaçã o pode ser personalizada usando os mé todos especial __add__() e __radd__().
O operador - (subtraçã o) produz a diferença de seus argumentos. Os argumentos numé ricos sã o primeiro convertidos
em um tipo comum.
Esta operaçã o pode ser personalizada usando os mé todos especial __sub__() e __rsub__().

6.8 Operações de deslocamento

As operaçõ es de deslocamento tê m menor prioridade que as operaçõ es aritmé ticas:

shift_expr ::= a_expr | shift_expr ("<<" | ">>") a_expr

Esses operadores aceitam nú meros inteiros como argumentos. Eles deslocam o primeiro argumento para a esquerda
ou para a direita pelo nú mero de bits fornecido pelo segundo argumento.
A operaçã o de deslocamento à esquerda pode ser personalizada usando os mé todos especiais __lshift__() e
__rlshift__(). A operaçã o de deslocamento à direita pode ser personalizada usando os mé todos especiais
__rshift__() e __rrshift__().

Um deslocamento para a direita por n bits é definido como divisã o pelo piso por pow(2,n). Um deslocamento à
esquerda por n bits é definido como multiplicaçã o com pow(2,n).

6.9 Operações binárias bit a bit

Cada uma das trê s operaçõ es bit a bit tem um nível de prioridade diferente:

and_expr ::= shift_expr | and_expr "&" shift_expr

xor_expr ::= and_expr | xor_expr "^" and_expr
or_expr ::= xor_expr | or_expr "|" xor_expr

O operador & produz o E (AND) bit a bit de seus argumentos, que devem ser inteiros ou um deles deve ser um objeto
personalizado substituindo os mé todos especiais __and__() ou __rand__().
O operador ^ produz o XOR bit a bit (OU exclusivo) de seus argumentos, que devem ser inteiros ou um deles deve
ser um objeto personalizado sobrescrevendo os mé todos especiais __xor__() ou __rxor__().
O operador | produz o OU (OR) bit a bit de seus argumentos, que devem ser inteiros ou um deles deve ser um objeto
personalizado sobrescrevendo os mé todos especiais __or__() ou __ror__().
1e100. A funçã o [Link]() retorna um resultado cujo sinal corresponde ao sinal do primeiro argumento e, portanto, retorna -1e-100 neste
caso. Qual abordagem é mais apropriada depende da aplicaçã o.
2 Se x estiver muito pró ximo de um mú ltiplo inteiro exato de y, é possível que x//y seja maior que (x-x%y)//y devido ao arredondamento.

Nesses casos, Python retorna o ú ltimo resultado, para preservar que divmod(x,y)[0] * y + x % y esteja muito pró ximo de x.

6.8. Operações de deslocamento 93

The Python Language Reference, Release 3.13.0

6.10 Comparações
Ao contrá rio de C, todas as operaçõ es de comparaçã o em Python tê m a mesma prioridade, que é menor do que
qualquer operaçã o aritmé tica, de deslocamento ou bit a bit. També m diferentemente de C, expressõ es como a < b
< c tê m a interpretaçã o que é convencional em matemá tica:

comparison ::= or_expr (comp_operator or_expr)*

comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!="
| "is" ["not"] | ["not"] "in"

Comparaçõ es produzem valores booleanos: True ou False. métodos de comparação rica personalizados podem
retornar valores nã o booleanos. Neste caso, o Python chamará bool() nesse valor em contextos booleanos.
As comparaçõ es podem ser encadeadas arbitrariamente, por exemplo, x < y <= z é equivalente a x < y and y
<= z, exceto que y é avaliado apenas uma vez (mas em ambos os casos z nã o é avaliado quando x < y é considerado
falso).
Formalmente, se a, b, c, …, y, z sã o expressõ es e op1, op2, …, opN sã o operadores de comparaçã o, entã o a op1
b op2 c ... y opN z é equivalente a a op1 b e b op2 c e ... y opN z, exceto que cada expressã o é
avaliada no má ximo uma vez.
Observe que a op1 b op2 c nã o implica qualquer tipo de comparaçã o entre a e c, de modo que, por exemplo, x
< y > z é perfeitamente vá lido (embora talvez nã o seja bonito).

6.10.1 Comparações de valor

Os operadores <, >, ==, >=, <= e != comparam os valores de dois objetos. Os objetos nã o precisam ser do mesmo
tipo.
O capítulo Objetos, valores e tipos afirma que os objetos possuem um valor (alé m do tipo e da identidade). O valor de
um objeto é uma noçã o bastante abstrata em Python: por exemplo, nã o existe um mé todo de acesso canô nico para
o valor de um objeto. Alé m disso, nã o há exigê ncia de que o valor de um objeto seja construído de uma maneira
específica, por exemplo. composto por todos os seus atributos de dados. Os operadores de comparaçã o implementam
uma noçã o específica de qual é o valor de um objeto. Pode-se pensar neles como definindo o valor de um objeto
indiretamente, por meio de sua implementaçã o de comparaçã o.
Como todos os tipos sã o subtipos (diretos ou indiretos) de object, eles herdam o comportamento de comparaçã o
padrã o de object. Os tipos podem personalizar seu comportamento de comparaçã o implementando métodos de
comparação rica como __lt__(), descrito em Personalização básica.
O comportamento padrã o para comparaçã o de igualdade (== e !=) é baseado na identidade dos objetos. Consequen-
temente, a comparaçã o da igualdade de instâ ncias com a mesma identidade resulta em igualdade, e a comparaçã o
da igualdade de instâ ncias com identidades diferentes resulta em desigualdade. Uma motivaçã o para este comporta-
mento padrã o é o desejo de que todos os objetos sejam reflexivos (ou seja, x is y implica x == y).
Uma comparaçã o de ordem padrã o (<, >, <= e >=) nã o é fornecida; uma tentativa levanta TypeError. Uma moti-
vaçã o para este comportamento padrã o é a falta de um invariante semelhante ao da igualdade.
O comportamento da comparaçã o de igualdade padrã o, de que instâ ncias com identidades diferentes sã o sempre
desiguais, pode contrastar com o que os tipos precisarã o ter uma definiçã o sensata de valor de objeto e igualdade
baseada em valor. Esses tipos precisarã o personalizar seu comportamento de comparaçã o e, de fato, vá rios tipos
embutidos fizeram isso.
A lista a seguir descreve o comportamento de comparaçã o dos tipos embutidos mais importantes.
• Nú meros de tipos numé ricos embutidos (typesnumeric) e dos tipos de biblioteca padrã o fractions.
Fraction e [Link] podem ser comparados dentro e entre seus tipos, com a restriçã o que os
nú meros complexos nã o oferecem suporte a comparaçã o de ordens. Dentro dos limites dos tipos envolvidos,
eles comparam matematicamente (algoritmicamente) corretos sem perda de precisã o.
Os valores nã o numé ricos float('NaN') e [Link]('NaN') sã o especiais. Qualquer compa-
raçã o ordenada de um nú mero com um valor que nã o é um nú mero é falsa. Uma implicaçã o contraintuitiva é

94 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

que os valores que nã o sã o numé ricos nã o sã o iguais a si mesmos. Por exemplo, se x = float('NaN'), 3
< x, x < 3 e x == x sã o todos falsos, enquanto x != x é verdadeiro. Esse comportamento é compatível
com IEEE 754.
• None e NotImplemented sã o singletons. PEP 8 aconselha que comparaçõ es para singletons devem sempre
ser feitas com is ou is not, nunca com os operadores de igualdade.
• Sequê ncias biná rias (instâ ncias de bytes ou bytearray) podem ser comparadas dentro e entre seus tipos.
Eles comparam lexicograficamente usando os valores numé ricos de seus elementos.
• Strings (instâ ncias de str) sã o comparadas lexicograficamente usando os pontos de có digo Unicode numé ricos
(o resultado da funçã o embutida ord()) de seus caracteres.3
Strings e sequê ncias biná rias nã o podem ser comparadas diretamente.
• Sequê ncias (instâ ncias de tuple, list ou range) podem ser comparadas apenas dentro de cada um de
seus tipos, com a restriçã o de que intervalos nã o oferecem suporte a comparaçã o de ordem. A comparaçã o
de igualdade entre esses tipos resulta em desigualdade, e a comparaçã o ordenada entre esses tipos levanta
TypeError.
As sequê ncias sã o comparadas lexicograficamente usando a comparaçã o de elementos correspondentes. Os
contê ineres embutidos normalmente presumem que objetos idê nticos sã o iguais a si mesmos. Isso permite
ignorar testes de igualdade para objetos idê nticos para melhorar o desempenho e manter seus invariantes
internos.
A comparaçã o lexicográ fica entre coleçõ es embutidas funciona da seguinte forma:
– Para que duas coleçõ es sejam comparadas iguais, elas devem ser do mesmo tipo, ter o mesmo com-
primento e cada par de elementos correspondentes deve ser comparado igual (por exemplo, [1,2] ==
(1,2) é false porque o tipo nã o é o mesmo).

– Coleçõ es que oferecem suporte a comparaçã o de ordem sã o ordenadas da mesma forma que seus primei-
ros elementos desiguais (por exemplo, [1,2,x] <= [1,2,y] tem o mesmo valor que x <= y). Se
um elemento correspondente nã o existir, a coleçã o mais curta é ordenada primeiro (por exemplo, [1,2]
< [1,2,3] é verdadeiro).

• Mapeamentos (instâ ncias de dict) comparam iguais se e somente se eles tiverem pares (chave, valor)
iguais. A comparaçã o de igualdade das chaves e valores reforça a reflexividade.
Comparaçõ es de ordem (<, >, <= e >=) levantam TypeError.
• Conjuntos (instâ ncias de set ou frozenset) podem ser comparados dentro e entre seus tipos.
Eles definem operadores de comparaçã o de ordem para significar testes de subconjunto e superconjunto. Essas
relaçõ es nã o definem ordenaçõ es totais (por exemplo, os dois conjuntos {1,2} e {2,3} nã o sã o iguais, nem
subconjuntos um do outro, nem superconjuntos um do outro). Consequentemente, conjuntos nã o sã o argu-
mentos apropriados para funçõ es que dependem de ordenaçã o total (por exemplo, min(), max() e sorted()
produzem resultados indefinidos dada uma lista de conjuntos como entradas) .
A comparaçã o de conjuntos reforça a reflexividade de seus elementos.
• A maioria dos outros tipos embutidos nã o possui mé todos de comparaçã o implementados, portanto, eles her-
dam o comportamento de comparaçã o padrã o.
As classes definidas pelo usuá rio que personalizam seu comportamento de comparaçã o devem seguir algumas regras
de consistê ncia, se possível:
3 O padrã o Unicode distingue entre pontos de código (por exemplo, U+0041) e caracteres abstratos (por exemplo, “LATIN CAPITAL LETTER

A”). Embora a maioria dos caracteres abstratos em Unicode sejam representados apenas por meio de um ponto de có digo, há vá rios caracteres
abstratos que també m podem ser representados por meio de uma sequê ncia de mais de um ponto de có digo. Por exemplo, o caractere abstrato
“LATIN CAPITAL LETTER C WITH CEDILLA” pode ser representado como um ú nico caractere pré-composto na posiçã o de có digo U+00C7,
ou como uma sequê ncia de um caractere base na posiçã o de có digo U+0043 (LATIN CAPITAL LETTER C), seguido por um caractere de
combinação na posiçã o de có digo U+0327 (COMBINING CEDILLA).
Os operadores de comparaçã o em strings sã o comparados no nível dos pontos de có digo Unicode. Isso pode ser contraintuitivo para os huma-
nos. Por exemplo, "\u00C7" == "\u0043\u0327" é False, mesmo que ambas as strings representem o mesmo caractere abstrato “LATIN
CAPITAL LETTER C WITH CEDILLA”.
Para comparar strings no nível de caracteres abstratos (ou seja, de uma forma intuitiva para humanos), use [Link]().

6.10. Comparações 95
The Python Language Reference, Release 3.13.0

• A comparaçã o da igualdade deve ser reflexiva. Em outras palavras, objetos idê nticos devem ser comparados
iguais:
x is y implica em x == y
• A comparaçã o deve ser simé trica. Em outras palavras, as seguintes expressõ es devem ter o mesmo resultado:
x == y e y == x

x != y e y != x

x < yey > x

x <= y e y >= x

• A comparaçã o deve ser transitiva. Os seguintes exemplos (nã o exaustivos) ilustram isso:
x > y and y > z implica em x > z

x < y and y <= z implica em x < z

• A comparaçã o inversa deve resultar na negaçã o booleana. Em outras palavras, as seguintes expressõ es devem
ter o mesmo resultado:
x == y e not x != y

x < y e not x >= y (pra classificaçã o total)

x > y e not x <= y (pra classificaçã o total)

As duas ú ltimas expressõ es aplicam-se a coleçõ es totalmente ordenadas (por exemplo, a sequê ncias, mas nã o
a conjuntos ou mapeamentos). Veja també m o decorador total_ordering().
• O resultado hash() deve ser consistente com a igualdade. Objetos iguais devem ter o mesmo valor de hash
ou ser marcados como nã o-hasheá veis.
Python nã o impõ e essas regras de consistê ncia. Na verdade, os valores nã o numé ricos sã o um exemplo de nã o
cumprimento dessas regras.

6.10.2 Operações de teste de pertinência

Os operadores in e not in testam se um operando é membro ou nã o de outro. x in s é avaliado como True
se x for membro de s, e False caso contrá rio. x not in s retorna a negaçã o de x in s. Todas as sequê ncias e
tipos de conjuntos embutidos oferecem suporte a isso, assim como o dicioná rio, para o qual in testa se o dicioná rio
tem uma determinada chave. Para tipos de contê iner como list, tuple, set, frozenset, dict ou [Link], a
expressã o x in y é equivalente a any(x is e or x == e for e in y).
Para os tipos string e bytes, x in y é True se e somente se x for uma substring de y. Um teste equivalente é
[Link](x) != -1. Strings vazias sã o sempre consideradas uma substring de qualquer outra string, entã o "" in
"abc" retornará True.

Para classes definidas pelo usuá rio que definem o mé todo __contains__(), x in y retorna True se y.
__contains__(x) retorna um valor verdadeiro, e False caso contrá rio.

Para classes definidas pelo usuá rio que nã o definem __contains__(), mas definem __iter__(), x in y é True
se algum valor z, para a qual a expressã o x is z or x == z é verdadeira, é produzida durante a iteraçã o sobre
y. Se uma exceçã o for levantada durante a iteraçã o, é como se in tivesse levantado essa exceçã o.

Por ú ltimo, o protocolo de iteraçã o de estilo antigo é tentado: se uma classe define __getitem__(), x in y é
True se, e somente se, houver um índice inteiro nã o negativo i tal que x is y[i] or x == y[i], e nenhum
índice inteiro inferior levanta a exceçã o IndexError. (Se qualquer outra exceçã o for levantada, é como se in
levantasse essa exceçã o).
O operador not in é definido para ter o valor verdade inverso de in.

96 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

6.10.3 Comparações de identidade

Os operadores is e is not testam a identidade de um objeto: x is y é verdadeiro se, e somente se, x e y sã o
o mesmo objeto. A identidade de um objeto é determinada usando a funçã o id(). x is not y produz o valor
verdade inverso.4

6.11 Operações booleanas

or_test ::= and_test | or_test "or" and_test

and_test ::= not_test | and_test "and" not_test
not_test ::= comparison | "not" not_test
No contexto de operaçõ es booleanas, e també m quando expressõ es sã o usadas por instruçõ es de fluxo de controle, os
seguintes valores sã o interpretados como falsos: False, None, zero numé rico de todos os tipos e strings e contê ineres
vazios (incluindo strings, tuplas, listas, dicioná rios, conjuntos e frozensets). Todos os outros valores sã o interpretados
como verdadeiros. Objetos definidos pelo usuá rio podem personalizar seu valor verdade fornecendo um mé todo
__bool__().
O operador not produz True se seu argumento for falso, False caso contrá rio.
A expressã o x and y primeiro avalia x; se x for falso, seu valor será retornado; caso contrá rio, y será avaliado e o
valor resultante será retornado.
A expressã o x or y primeiro avalia x; se x for verdadeiro, seu valor será retornado; caso contrá rio, y será avaliado
e o valor resultante será retornado.
Observe que nem and nem or restringem o valor e o tipo que retornam para False e True, mas sim retornam o
ú ltimo argumento avaliado. Isso à s vezes é ú til, por exemplo, se s é uma string que deve ser substituída por um valor
padrã o se estiver vazia, a expressã o s or 'foo' produz o valor desejado. Como not precisa criar um novo valor,
ele retorna um valor booleano independente do tipo de seu argumento (por exemplo, not 'foo' produz False em
vez de ''.)

6.12 Expressões de atribuição

assignment_expression ::= [identifier ":="] expression

Uma expressã o de atribuiçã o (à s vezes també m chamada de “expressã o nomeada” ou “morsa”) atribui um
expression a um identifier, ao mesmo tempo que retorna o valor de expression.
Um caso de uso comum é ao lidar com expressõ es regulares correspondentes:

if matching := [Link](data):
do_something(matching)

Ou, ao processar um fluxo de arquivos em partes:

while chunk := [Link](9000):

process(chunk)

As expressõ es de atribuiçã o devem ser colocadas entre parê nteses quando usadas como instruçõ es de expressã o e
quando usadas como subexpressõ es em expressõ es de fatiamento, condicionais, de lambda, de argumento nomeado e
de if de compreensã o e em instruçõ es assert, with e assignment. Em todos os outros lugares onde eles podem
ser usados, os parê nteses nã o sã o necessá rios, inclusive nas instruçõ es if e while.
Adicionado na versã o 3.8: Veja PEP 572 para mais detalhes sobre expressõ es de atribuiçã o.
4Devido à coleta de lixo automá tica, à s listas livres e à natureza dinâ mica dos descritores, você pode notar um comportamento aparente-
mente incomum em certos usos do operador is, como aqueles que envolvem comparaçõ es entre mé todos de instâ ncia ou constantes. Confira a
documentaçã o para obter mais informaçõ es.

6.11. Operações booleanas 97

The Python Language Reference, Release 3.13.0

6.13 Expressões condicionais

conditional_expression ::= or_test ["if" or_test "else" expression]

expression ::= conditional_expression | lambda_expr
Expressõ es condicionais (à s vezes chamadas de “operador terná rio”) tê m a prioridade mais baixa de todas as operaçõ es
Python.
A expressã o x if C else y primeiro avalia a condiçã o, C em vez de x. Se C for verdadeiro, x é avaliado e seu
valor é retornado; caso contrá rio, y será avaliado e seu valor será retornado.
Veja PEP 308 para mais detalhes sobre expressõ es condicionais.

6.14 Lambdas

lambda_expr ::= "lambda" [parameter_list] ":" expression

Expressõ es lambda (à s vezes chamadas de funçõ es lambda) sã o usadas para criar funçõ es anô nimas. A expressã o
lambda parameters: expression produz um objeto funçã o. O objeto sem nome se comporta como um objeto
de funçã o definido com:

def <lambda>(parâmetros):
return expressão

Veja a seçã o Definições de função para a sintaxe das listas de parâ metros. Observe que as funçõ es criadas com
expressõ es lambda nã o podem conter instruçõ es ou anotaçõ es.

6.15 Listas de expressões

starred_expression ::= ["*"] or_expr

flexible_expression ::= assignment_expression | starred_expression
flexible_expression_list ::= flexible_expression ("," flexible_expression)* [","]
starred_expression_list ::= starred_expression ("," starred_expression)* [","]
expression_list ::= expression ("," expression)* [","]
yield_list ::= expression_list | starred_expression "," [starred_expression_list
Exceto quando parte de uma sintaxe de criaçã o de lista ou conjunto, uma lista de expressõ es contendo pelo menos uma
vírgula produz uma tupla. O comprimento da tupla é o nú mero de expressõ es na lista. As expressõ es sã o avaliadas
da esquerda para a direita.
Um asterisco * denota desempacotamento de iterável. Seu operando deve ser um iterável. O iterá vel é expandido em
uma sequê ncia de itens, que sã o incluídos na nova tupla, lista ou conjunto, no local do desempacotamento.
Adicionado na versã o 3.5: Desempacotamento de iterá vel em listas de expressõ es, originalmente proposta pela PEP
448.
Adicionado na versã o 3.11: Qualquer item em uma lista de expressõ es pode ser estrelado. Veja a PEP 646.
Uma vírgula final é necessá ria apenas para criar uma tupla de um item, como 1,; é opcional em todos os outros
casos. Uma ú nica expressã o sem vírgula final nã o cria uma tupla, mas produz o valor dessa expressã o. (Para criar
uma tupla vazia, use um par vazio de parê nteses: ().)

6.16 Ordem de avaliação

Python avalia expressõ es da esquerda para a direita. Observe que ao avaliar uma tarefa, o lado direito é avaliado
antes do lado esquerdo.
Nas linhas a seguir, as expressõ es serã o avaliadas na ordem aritmé tica de seus sufixos:

98 Capítulo 6. Expressões
 The Python Language Reference, Release 3.13.0

expr1, expr2, expr3, expr4

(expr1, expr2, expr3, expr4)
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
expr1(expr2, expr3, *expr4, **expr5)
expr3, expr4 = expr1, expr2

6.17 Precedência de operadores

A tabela a seguir resume a precedê ncia de operadores no Python, da precedê ncia mais alta (mais vinculativa) à
precedê ncia mais baixa (menos vinculativa). Os operadores na mesma caixa tê m a mesma precedê ncia. A menos
que a sintaxe seja fornecida explicitamente, os operadores sã o biná rios. Os operadores na mesma caixa agrupam-se
da esquerda para a direita (exceto exponenciaçã o e expressõ es condicionais, que agrupam da direita para a esquerda).
Observe que comparaçõ es, testes de pertinê ncia e testes de identidade tê m todos a mesma precedê ncia e possuem
um recurso de encadeamento da esquerda para a direita, conforme descrito na seçã o Comparações.

Operador Descrição
(expressions...), Expressã o entre parê nteses ou de ligaçã o, sintaxe de criaçã o de
[expressões...], {chave: valor... lista, sintaxe de criaçã o de dicioná rio, sintaxe de criaçã o de con-
}, {expressões...} junto
x[índice], x[índice:índice], subscriçã o, fatiamento, chamada, referê ncia a atributo
x(argumentos...), [Link]
await x Expressã o await
** Exponenciaçã o5
+x, -x, ~x positivo, negativo, NEGAÇÃO (NOT) bit a bit
*, @, /, //, % Multiplicaçã o, multiplicaçã o de matrizes, divisã o, divisã o pelo
piso, resto6
+, - Adiçã o e subtraçã o
<<, >> Deslocamentos
& E (AND) bit a bit
^ OU EXCLUSIVO (XOR) bit a bit
| OU (OR) bit a bit
in, not in, is, is not, <, <=, >, >=, !=, Comparaçõ es, incluindo testes de pertinê ncia e testes de identi-
== dade
not x NEGAÇÃO (NOT) booleana
and E (AND) booleano
or OU (OR) booleano
if – else Expressã o condicional
lambda Expressã o lambda
:= Expressã o de atribuiçã o

5 O operador de potê ncia ** liga-se com menos força do que um operador aritmé tico ou uná rio bit a bit à sua direita, ou seja, 2**-1 é 0.5.
6 O operador % també m é usado para formataçã o de strings; a mesma precedê ncia se aplica.

6.17. Precedência de operadores 99

The Python Language Reference, Release 3.13.0

100 Capítulo 6. Expressões

 CAPÍTULO 7

Instruções simples

Uma instruçã o simples consiste uma ú nica linha ló gica. Vá rias instruçõ es simples podem ocorrer em uma ú nica linha
separada por ponto e vírgula. A sintaxe para instruçõ es simples é :

simple_stmt ::= expression_stmt

| assert_stmt
| assignment_stmt
| augmented_assignment_stmt
| annotated_assignment_stmt
| pass_stmt
| del_stmt
| return_stmt
| yield_stmt
| raise_stmt
| break_stmt
| continue_stmt
| import_stmt
| future_stmt
| global_stmt
| nonlocal_stmt
| type_stmt

7.1 Instruções de expressão

As instruçõ es de expressã o sã o usadas (principalmente interativamente) para calcular e escrever um valor, ou (ge-
ralmente) para chamar um procedimento (uma funçã o que nã o retorna nenhum resultado significativo; em Python,
os procedimentos retornam o valor None). Outros usos de instruçõ es de expressã o sã o permitidos e ocasionalmente
ú teis. A sintaxe para uma instruçã o de expressã o é :

expression_stmt ::= starred_expression

Uma instruçã o de expressã o avalia a lista de expressõ es (que pode ser uma ú nica expressã o).
No modo interativo, se o valor nã o for None, ele será convertido em uma string usando a funçã o embutida repr()
e a string resultante será gravada na saída padrã o em uma linha sozinha (exceto se o resultado é None, de modo que

101
The Python Language Reference, Release 3.13.0

as chamadas de procedimento nã o causam nenhuma saída.)

7.2 Instruções de atribuição

As instruçõ es de atribuiçã o sã o usadas para (re)vincular nomes a valores e modificar atributos ou itens de objetos
mutá veis:

assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression)

target_list ::= target ("," target)* [","]
target ::= identifier
| "(" [target_list] ")"
| "[" [target_list] "]"
| attributeref
| subscription
| slicing
| "*" target

(Veja a seçã o Primárias para as definiçõ es de sintaxe de attributeref, subscription e slicing.)

Uma instruçã o de atribuiçã o avalia a lista de expressõ es (lembre-se de que pode ser uma ú nica expressã o ou uma
lista separada por vírgulas, a ú ltima produzindo uma tupla) e atribui o ú nico objeto resultante a cada uma das listas
alvos, da esquerda para a direita.
A atribuiçã o é definida recursivamente dependendo da forma do alvo (lista). Quando um alvo faz parte de um objeto
mutá vel (uma referê ncia de atributo, assinatura ou divisã o), o objeto mutá vel deve, em ú ltima aná lise, executar
a atribuiçã o e decidir sobre sua validade e pode levantar uma exceçã o se a atribuiçã o for inaceitá vel. As regras
observadas pelos vá rios tipos e as exceçõ es levantadas sã o dadas com a definiçã o dos tipos de objetos (ver seçã o A
hierarquia de tipos padrão).
A atribuiçã o de um objeto a uma lista alvo, opcionalmente entre parê nteses ou colchetes, é definida recursivamente
da maneira a seguir.
• Se a lista alvo contiver um ú nico alvo sem vírgula à direita, opcionalmente entre parê nteses, o objeto será
atribuído a esse alvo.
• Senã o:
– Se a lista alvo contiver um alvo prefixado com um asterisco, chamado de alvo “com estrela” (starred): o
objeto deve ser um iterá vel com pelo menos tantos itens quantos os alvos na lista alvo, menos um. Os
primeiros itens do iterá vel sã o atribuídos, da esquerda para a direita, aos alvos antes do alvo com estrela.
Os itens finais do iterá vel sã o atribuídos aos alvos apó s o alvo com estrela. Uma lista dos itens restantes
no iterá vel é entã o atribuída ao alvo com estrela (a lista pode estar vazia).
– Senã o: o objeto deve ser um iterá vel com o mesmo nú mero de itens que existem alvos na lista alvos, e os
itens sã o atribuídos, da esquerda para a direita, aos alvos correspondentes.
A atribuiçã o de um objeto a um ú nico alvo é definida recursivamente da maneira a seguir.
• Se o alvo for um identificador (nome):
– Se o nome nã o ocorrer em uma instruçã o global ou nonlocal no bloco de có digo atual: o nome está
vinculado ao objeto no espaço de nomes local atual.
– Caso contrá rio: o nome é vinculado ao objeto no espaço de nomes global global ou no espaço de nomes
global externo determinado por nonlocal, respectivamente.
O nome é vinculado novamente se já estiver vinculado. Isso pode fazer com que a contagem de referê ncias
para o objeto anteriormente vinculado ao nome chegue a zero, fazendo com que o objeto seja desalocado e seu
destrutor (se houver) seja chamado.
• Se o alvo for uma referê ncia de atributo: a expressã o primá ria na referê ncia é avaliada. Deve produzir um
objeto com atributos atribuíveis; se este nã o for o caso, a exceçã o TypeError é levanta. Esse objeto é entã o

102 Capítulo 7. Instruções simples

 The Python Language Reference, Release 3.13.0

solicitado a atribuir o objeto atribuído ao atributo fornecido; se nã o puder executar a atribuiçã o, ele levanta
uma exceçã o (geralmente, mas nã o necessariamente AttributeError).
Nota: Se o objeto for uma instâ ncia de classe e a referê ncia de atributo ocorrer em ambos os lados do operador
de atribuiçã o, a expressã o do lado direito, a.x pode acessar um atributo de instâ ncia ou (se nã o existir nenhum
atributo de instâ ncia) uma classe atributo. O alvo do lado esquerdo a.x é sempre definido como um atributo
de instâ ncia, criando-o se necessá rio. Assim, as duas ocorrê ncias de a.x nã o necessariamente se referem ao
mesmo atributo: se a expressã o do lado direito se refere a um atributo de classe, o lado esquerdo cria um novo
atributo de instâ ncia como alvo da atribuiçã o:

class Cls:
x = 3 # variável de classe
inst = Cls()
inst.x = inst.x + 1 # escreve inst.x como 4 deixando Cls.x como 3

Esta descriçã o nã o se aplica necessariamente aos atributos do descritor, como propriedades criadas com
property().

• Se o alvo for uma assinatura: a expressã o primá ria na referê ncia é avaliada. Deve produzir um objeto de
sequê ncia mutá vel (como uma lista) ou um objeto de mapeamento (como um dicioná rio). Em seguida, a
expressã o subscrito é avaliada.
Se o primá rio for um objeto de sequê ncia mutá vel (como uma lista), o subscrito deverá produzir um inteiro.
Se for negativo, o comprimento da sequê ncia é adicionado a ela. O valor resultante deve ser um inteiro nã o
negativo menor que o comprimento da sequê ncia, e a sequê ncia é solicitada a atribuir o objeto atribuído ao seu
item com esse índice. Se o índice estiver fora do intervalo, a exceçã o IndexError será levantada (a atribuiçã o
a uma sequê ncia subscrita nã o pode adicionar novos itens a uma lista).
Se o primá rio for um objeto de mapeamento (como um dicioná rio), o subscrito deve ter um tipo compatível
com o tipo de chave do mapeamento, e o mapeamento é solicitado a criar um par chave/valore que mapeia o
subscrito para o objeto atribuído. Isso pode substituir um par de chave/valor existente pelo mesmo valor de
chave ou inserir um novo par de chave/valor (se nã o existir nenhuma chave com o mesmo valor).
Para objetos definidos pelo usuá rio, o mé todo __setitem__() é chamado com argumentos apropriados.
• Se o alvo for um fatiamento: a expressã o primá ria na referê ncia é avaliada. Deve produzir um objeto de
sequê ncia mutá vel (como uma lista). O objeto atribuído deve ser um objeto de sequê ncia do mesmo tipo. Em
seguida, as expressõ es de limite inferior e superior sã o avaliadas, na medida em que estiverem presentes; os
padrõ es sã o zero e o comprimento da sequê ncia. Os limites devem ser avaliados como inteiros. Se um dos
limites for negativo, o comprimento da sequê ncia será adicionado a ele. Os limites resultantes sã o cortados para
ficarem entre zero e o comprimento da sequê ncia, inclusive. Finalmente, o objeto de sequê ncia é solicitado a
substituir a fatia pelos itens da sequê ncia atribuída. O comprimento da fatia pode ser diferente do comprimento
da sequê ncia atribuída, alterando assim o comprimento da sequê ncia alvo, se a sequê ncia alvo permitir.
Detalhes da implementação do CPython: Na implementaçã o atual, a sintaxe dos alvos é considerada a mesma das
expressõ es e a sintaxe invá lida é rejeitada durante a fase de geraçã o do có digo, causando mensagens de erro menos
detalhadas.
Embora a definiçã o de atribuiçã o implique que as sobreposiçõ es entre o lado esquerdo e o lado direito sejam “simul-
tâ neas” (por exemplo, a, b = b, a troca duas variá veis), sobreposiçõ es dentro da coleçã o de variá veis atribuídas
ocorrem da esquerda para a direita, à s vezes resultando em confusã o. Por exemplo, o programa a seguir imprime
[0, 2]:

x = [0, 1]
i = 0
i, x[i] = 1, 2 # i é atualizado e, em seguida, x[i] é atualizado
print(x)

µ Ver também

7.2. Instruções de atribuição 103

The Python Language Reference, Release 3.13.0

PEP 3132 - Desempacotamento estendido de iterável

A especificaçã o para o recurso *target.

7.2.1 Instruções de atribuição aumentada

A atribuiçã o aumentada é a combinaçã o, em uma ú nica instruçã o, de uma operaçã o biná ria e uma instruçã o de
atribuiçã o:

augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)

augtarget ::= identifier | attributeref | subscription | slicing
augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
| ">>=" | "<<=" | "&=" | "^=" | "|="

(Veja a seçã o Primárias para as definiçõ es de sintaxe dos ú ltimos trê s símbolos.)
Uma atribuiçã o aumentada avalia o alvo (que, diferentemente das instruçõ es de atribuiçã o normais, nã o pode ser um
desempacotamento) e a lista de expressõ es, executa a operaçã o biná ria específica para o tipo de atribuiçã o nos dois
operandos e atribui o resultado ao alvo original. O alvo é avaliado apenas uma vez.
Uma instruçã o de atribuiçã o aumentada como x += 1 pode ser reescrita como x = x + 1 para obter um efeito
semelhante, mas nã o exatamente igual. Na versã o aumentada, x é avaliado apenas uma vez. Alé m disso, quando
possível, a operaçã o real é executada no local, o que significa que, em vez de criar um novo objeto e atribuí-lo ao
alvo, o objeto antigo é modificado.
Ao contrá rio das atribuiçõ es normais, as atribuiçõ es aumentadas avaliam o lado esquerdo antes de avaliar o lado
direito. Por exemplo, a[i] += f(x) primeiro procura a[i], entã o avalia f(x) e executa a adiçã o e, por ú ltimo,
escreve o resultado de volta para a[i].
Com exceçã o da atribuiçã o a tuplas e vá rios alvos em uma ú nica instruçã o, a atribuiçã o feita por instruçõ es de
atribuiçã o aumentada é tratada da mesma maneira que atribuiçõ es normais. Da mesma forma, com exceçã o do
possível comportamento in-place, a operaçã o biná ria executada por atribuiçã o aumentada é a mesma que as operaçõ es
biná rias normais.
Para alvos que sã o referê ncias de atributos, a mesma advertência sobre atributos de classe e instância se aplica a
atribuiçõ es regulares.

7.2.2 instruções de atribuição anotado

A atribuiçã o de anotação é a combinaçã o, em uma ú nica instruçã o, de uma anotaçã o de variá vel ou atributo e uma
instruçã o de atribuiçã o opcional:

annotated_assignment_stmt ::= augtarget ":" expression

["=" (starred_expression | yield_expression)]

A diferença para as Instruções de atribuição normal é que apenas um ú nico alvo é permitido.
O alvo da atribuiçã o é considerado “simples” se consistir em um ú nico nome que nã o esteja entre parê nteses. Para
alvos de atribuiçã o simples, se no escopo de classe ou mó dulo, as anotaçõ es sã o avaliadas e armazenadas em uma
classe especial ou atributo de mó dulo __annotations__ que é um mapeamento de dicioná rio de nomes de variá veis
(desconfigurados se privados) para anotaçõ es avaliadas. Este atributo é gravá vel e é criado automaticamente no início
da execuçã o do corpo da classe ou mó dulo, se as anotaçõ es forem encontradas estaticamente.
Se o alvo da atribuiçã o nã o for simples (um atributo, nó subscrito ou nome entre parê nteses), a anotaçã o será avaliada
se estiver no escopo da classe ou do mó dulo, mas nã o será armazenada.
Se um nome for anotado em um escopo de funçã o, esse nome será local para esse escopo. As anotaçõ es nunca sã o
avaliadas e armazenadas em escopos de funçã o.

104 Capítulo 7. Instruções simples

 The Python Language Reference, Release 3.13.0

Se o lado direito estiver presente, uma atribuiçã o anotada executa a atribuiçã o real antes de avaliar as anotaçõ es
(quando aplicá vel). Se o lado direito nã o estiver presente para um alvo de expressã o, entã o o interpretador avalia o
alvo, exceto para a ú ltima chamada __setitem__() ou __setattr__().

µ Ver também

PEP 526 - Sintaxe para Anotações de Variáveis

A proposta que adicionou sintaxe para anotar os tipos de variá veis (incluindo variá veis de classe e variá veis
de instâ ncia), em vez de expressá -las por meio de comentá rios.
PEP 484 - Dicas de tipo
A proposta que adicionou o mó dulo typing para fornecer uma sintaxe padrã o para anotaçõ es de tipo que
podem ser usadas em ferramentas de aná lise está tica e IDEs.

Alterado na versã o 3.8: Agora, as atribuiçõ es anotadas permitem as mesmas expressõ es no lado direito que as atri-
buiçõ es regulares. Anteriormente, algumas expressõ es (como expressõ es de tupla sem parê nteses) causavam um erro
de sintaxe.

7.3 A instrução assert

As instruçõ es assert sã o uma maneira conveniente de inserir asserçõ es de depuraçã o em um programa:

assert_stmt ::= "assert" expression ["," expression]

A forma simples, assert expression, é equivalente a

if __debug__:
if not expression: raise AssertionError

A forma estendida, assert expression1, expression2, é equivalente a

if __debug__:
if not expression1: raise AssertionError(expression2)

Essas equivalê ncias presumem que __debug__ e AssertionError referem-se à s variá veis embutidas com esses
nomes. Na implementaçã o atual, a variá vel embutida __debug__ é True em circunstâ ncias normais, False quando
a otimizaçã o é solicitada (opçã o de linha de comando -O). O gerador de có digo atual nã o emite có digo para uma
instruçã o assert quando a otimizaçã o é solicitada em tempo de compilaçã o. Observe que nã o é necessá rio incluir o
có digo-fonte da expressã o que falhou na mensagem de erro; ele será exibido como parte do stack trace (situaçã o da
pilha de execuçã o).
Atribuiçõ es a __debug__ sã o ilegais. O valor da variá vel embutida é determinado quando o interpretador é iniciado.

7.4 A instrução pass

pass_stmt ::= "pass"

pass é uma operaçã o nula — quando é executada, nada acontece. É ú til como um espaço reservado quando uma
instruçã o é necessá ria sintaticamente, mas nenhum có digo precisa ser executado, por exemplo:

def f(arg): pass # uma função que faz nada (ainda)

class C: pass # uma classe com nenhum método (ainda)

7.3. A instrução assert 105

The Python Language Reference, Release 3.13.0

7.5 A instrução del

del_stmt ::= "del" target_list

A exclusã o é definida recursivamente de maneira muito semelhante à maneira como a atribuiçã o é definida. Em vez
de explicar em detalhes, aqui estã o algumas dicas.
A exclusã o de uma lista alvo exclui recursivamente cada alvo, da esquerda para a direita.
A exclusã o de um nome remove a ligaçã o desse nome do espaço de nomes global local ou global, dependendo se
o nome ocorre em uma instruçã o global no mesmo bloco de có digo. Se o nome for desvinculado, uma exceçã o
NameError será levantada.

A exclusã o de referê ncias de atributos, assinaturas e fatias é passada para o objeto principal envolvido; a exclusã o de
um fatiamento é em geral equivalente à atribuiçã o de uma fatia vazia do tipo certo (mas mesmo isso é determinado
pelo objeto fatiado).
Alterado na versã o 3.2: Anteriormente, era ilegal excluir um nome do espaço de nomes local se ele ocorresse como
uma variá vel livre em um bloco aninhado.

7.6 A instrução return

return_stmt ::= "return" [expression_list]

return só pode ocorrer sintaticamente aninhado em uma definiçã o de funçã o, nã o em uma definiçã o de classe
aninhada.
Se uma lista de expressõ es estiver presente, ela será avaliada, caso contrá rio, None será substituído.
return deixa a chamada da funçã o atual com a lista de expressõ es (ou None) como valor de retorno.

Quando return passa o controle de uma instruçã o try com uma clá usula finally , essa clá usula finally é
executada antes de realmente sair da funçã o.
Em uma funçã o geradora, a instruçã o return indica que o gerador está pronto e fará com que StopIteration
seja gerado. O valor retornado (se houver) é usado como argumento para construir StopIteration e se torna o
atributo [Link].
Em uma funçã o de gerador assíncrono, uma instruçã o return vazia indica que o gerador assíncrono está pronto e
fará com que StopAsyncIteration seja gerado. Uma instruçã o return nã o vazia é um erro de sintaxe em uma
funçã o de gerador assíncrono.

7.7 A instrução yield

yield_stmt ::= yield_expression

Uma instruçã o yield é semanticamente equivalente a uma expressão yield. A instruçã o yield pode ser usada para
omitir os parê nteses que, de outra forma, seriam necessá rios na instruçã o de expressã o yield equivalente. Por exemplo,
as instruçõ es yield

yield <expr>
yield from <expr>

sã o equivalentes à s instruçõ es de expressã o yield

(yield <expr>)
(yield from <expr>)

106 Capítulo 7. Instruções simples

 The Python Language Reference, Release 3.13.0

Expressõ es e instruçõ es yield sã o usadas apenas ao definir uma funçã o geradora e sã o usadas apenas no corpo da
funçã o geradora. Usar yield em uma definiçã o de funçã o é suficiente para fazer com que essa definiçã o crie uma
funçã o geradora em vez de uma funçã o normal.
Para detalhes completos da semâ ntica yield, consulte a seçã o Expressões yield.

7.8 A instrução raise

raise_stmt ::= "raise" [expression ["from" expression]]

Se nenhuma expressã o estiver presente, raise reativa a exceçã o que está sendo tratada no momento, que també m
é conhecida como exceção ativa. Se nã o houver uma exceçã o ativa no momento, uma exceçã o RuntimeError é
levantada indicando que isso é um erro.
Caso contrá rio, raise avalia a primeira expressã o como o objeto de exceçã o. Deve ser uma subclasse ou uma
instâ ncia de BaseException. Se for uma classe, a instâ ncia de exceçã o será obtida quando necessá rio instanciando
a classe sem argumentos.
O tipo da exceçã o é a classe da instâ ncia de exceçã o, o valor é a pró pria instâ ncia.
Um objeto traceback (situaçã o da pilha de execuçã o) normalmente é criado automaticamente quando uma exceçã o
é levantada e anexada a ele como o atributo __traceback__. Você pode criar uma exceçã o e definir seu pró prio
traceback em uma etapa usando o mé todo de exceçã o with_traceback() (que retorna a mesma instâ ncia de
exceçã o, com seu traceback definido para seu argumento), assim:

raise Exception("ocorreu foo").with_traceback(tracebackobj)

A clá usula from é usada para encadeamento de exceçõ es: se fornecida, a segunda expressã o, expression, deve ser
outra classe ou instâ ncia de exceçã o. Se a segunda expressã o for uma instâ ncia de exceçã o, ela será anexada à
exceçã o levantada como o atributo __cause__ (que é gravá vel). Se a expressã o for uma classe de exceçã o, a classe
será instanciada e a instâ ncia de exceçã o resultante será anexada à exceçã o levantada como o atributo __cause__.
Se a exceçã o levantada nã o for tratada, ambas as exceçõ es serã o impressas:

>>> try:
... print(1 / 0)
... except Exception as exc:
... raise RuntimeError("Something bad happened") from exc
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
print(1 / 0)
~~^~~
ZeroDivisionError: division by zero

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

Traceback (most recent call last):

File "<stdin>", line 4, in <module>
raise RuntimeError("Something bad happened") from exc
RuntimeError: Something bad happened

Um mecanismo semelhante funciona implicitamente se uma nova exceçã o for levantada quando uma exceçã o já
estiver sendo tratada. Uma exceçã o pode ser tratada quando uma clá usula except ou finally , ou uma instruçã o
with, é usada. A exceçã o anterior é entã o anexada como o atributo __context__ da nova exceçã o:

>>> try:
... print(1 / 0)
... except:
... raise RuntimeError("Something bad happened")
(continua na pró xima pá gina)

7.8. A instrução raise 107

The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
print(1 / 0)
~~^~~
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):

File "<stdin>", line 4, in <module>
raise RuntimeError("Something bad happened")
RuntimeError: Something bad happened

O encadeamento de exceçã o pode ser explicitamente suprimido especificando None na clá usula from:

>>> try:
... print(1 / 0)
... except:
... raise RuntimeError("Something bad happened") from None
...
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
RuntimeError: Something bad happened

Informaçõ es adicionais sobre exceçõ es podem ser encontradas na seçã o Exceções, e informaçõ es sobre como lidar
com exceçõ es estã o na seçã o A instrução try.
Alterado na versã o 3.3: None agora é permitido como Y em raise X from Y.
Adicionado o atributo __suppress_context__ para suprimir a exibiçã o automá tica do contexto de exceçã o.
Alterado na versã o 3.11: Se o traceback da exceçã o ativa for modificado em uma clá usula except, uma instruçã o
raise subsequente levantará novamente a exceçã o com o traceback modificado. Anteriormente, a exceçã o era
levantada novamente com o traceback que tinha quando foi capturada.

7.9 A instrução break

break_stmt ::= "break"

break só pode ocorrer sintaticamente aninhado em um laço for ou while, mas nã o aninhado em uma funçã o ou
definiçã o de classe dentro desse laço.
Ele termina o laço de fechamento mais pró ximo, pulando a clá usula opcional else se o laço tiver uma.
Se um laço for é encerrado por break, o alvo de controle do laço manté m seu valor atual.
Quando break passa o controle de uma instruçã o try com uma clá usula finally , essa clá usula finally é exe-
cutada antes de realmente sair do laço.

7.10 A instrução continue

continue_stmt ::= "continue"

continue só pode ocorrer sintaticamente aninhado em um laço for ou while, mas nã o aninhado em uma funçã o
ou definiçã o de classe dentro desse laço. Ele continua com o pró ximo ciclo do laço de fechamento mais pró ximo.

108 Capítulo 7. Instruções simples

 The Python Language Reference, Release 3.13.0

Quando continue passa o controle de uma instruçã o try com uma clá usula finally , essa clá usula finally é
executada antes realmente iniciar o pró ximo ciclo do laço.

7.11 A instrução import

import_stmt ::= "import" module ["as" identifier] ("," module ["as" identifier])*
| "from" relative_module "import" identifier ["as" identifier]
("," identifier ["as" identifier])*
| "from" relative_module "import" "(" identifier ["as" identifier]
("," identifier ["as" identifier])* [","] ")"
| "from" relative_module "import" "*"
module ::= (identifier ".")* identifier
relative_module ::= "."* module | "."+
A instruçã o de importaçã o bá sica (sem clá usula from) é executada em duas etapas:
1. encontra um mó dulo, carregando e inicializando-o se necessá rio
2. define um nome ou nomes no espaço de nomes local para o escopo onde ocorre a instruçã o import.
Quando a instruçã o conté m vá rias clá usulas (separadas por vírgulas), as duas etapas sã o executadas separadamente
para cada clá usula, como se as clá usulas tivessem sido separadas em instruçõ es de importaçã o individuais.
Os detalhes da primeira etapa, encontrar e carregar mó dulos, estã o descritos com mais detalhes na seçã o sobre o
sistema de importação, que també m descreve os vá rios tipos de pacotes e mó dulos que podem ser importados, bem
como todos os os ganchos que podem ser usados para personalizar o sistema de importaçã o. Observe que falhas
nesta etapa podem indicar que o mó dulo nã o pô de ser localizado ou que ocorreu um erro durante a inicializaçã o do
mó dulo, o que inclui a execuçã o do có digo do mó dulo.
Se o mó dulo solicitado for recuperado com sucesso, ele será disponibilizado no espaço de nomes local de trê s ma-
neiras:
• Se o nome do mó dulo é seguido pela palavra reservada as, o nome a seguir é vinculado diretamente ao mó dulo
importado.
• Se nenhum outro nome for especificado e o mó dulo que está sendo importado for um mó dulo de nível superior,
o nome do mó dulo será vinculado ao espaço de nomes local como uma referê ncia ao mó dulo importado
• Se o mó dulo que está sendo importado não for um mó dulo de nível superior, o nome do pacote de nível
superior que conté m o mó dulo será vinculado ao espaço de nomes local como uma referê ncia ao pacote de
nível superior. O mó dulo importado deve ser acessado usando seu nome completo e nã o diretamente
O formulá rio from usa um processo um pouco mais complexo:
1. encontra o mó dulo especificado na clá usula from, carregando e inicializando-o se necessá rio;
2. para cada um dos identificadores especificados nas clá usulas import:
1. verifica se o mó dulo importado tem um atributo com esse nome
2. caso contrá rio, tenta importar um submó dulo com esse nome e verifica o mó dulo importado novamente
para esse atributo
3. se o atributo nã o for encontrado, a exceçã o ImportError é levantada.
4. caso contrá rio, uma referê ncia a esse valor é armazenada no espaço de nomes local, usando o nome na
clá usula as se estiver presente, caso contrá rio, usando o nome do atributo
Exemplos:

import foo # foo imported and bound locally

import [Link] # foo, [Link], and [Link] imported, foo bound␣
,→locally

import [Link] as fbb # foo, [Link], and [Link] imported, [Link]␣

(continua na pró xima pá gina)

7.11. A instrução import 109

The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

,→ bound as fbb
from [Link] import baz # foo, [Link], and [Link] imported, [Link]␣
,→bound as baz

from foo import attr # foo imported and [Link] bound as attr

Se a lista de identificadores for substituída por uma estrela ('*'), todos os nomes pú blicos definidos no mó dulo serã o
vinculados ao espaço de nomes local para o escopo onde ocorre a instruçã o import.
Os nomes públicos definidos por um mó dulo sã o determinados verificando o espaço de nomes do mó dulo para uma
variá vel chamada __all__; se definido, deve ser uma sequê ncia de strings que sã o nomes definidos ou importados
por esse mó dulo. Os nomes dados em __all__ sã o todos considerados pú blicos e devem existir. Se __all__ nã o
estiver definido, o conjunto de nomes pú blicos inclui todos os nomes encontrados no espaço de nomes do mó dulo que
nã o começam com um caractere sublinhado ('_'). __all__ deve conter toda a API pú blica. Destina-se a evitar
a exportaçã o acidental de itens que nã o fazem parte da API (como mó dulos de biblioteca que foram importados e
usados no mó dulo).
A forma curinga de importaçã o — from module import * — só é permitida no nível do mó dulo. Tentar usá -lo
em definiçõ es de classe ou funçã o irá levantar uma SyntaxError.
Ao especificar qual mó dulo importar, você nã o precisa especificar o nome absoluto do mó dulo. Quando um mó dulo
ou pacote está contido em outro pacote, é possível fazer uma importaçã o relativa dentro do mesmo pacote superior
sem precisar mencionar o nome do pacote. Usando pontos iniciais no mó dulo ou pacote especificado apó s from você
pode especificar quã o alto percorrer a hierarquia de pacotes atual sem especificar nomes exatos. Um ponto inicial
significa o pacote atual onde o mó dulo que faz a importaçã o existe. Dois pontos significam um nível de pacote acima.
Trê s pontos sã o dois níveis acima, etc. Entã o, se você executar from . import mod de um mó dulo no pacote
pkg entã o você acabará importando o [Link]. Se você executar from ..subpkg2 import mod de dentro de
pkg.subpkg1 você irá importar [Link]. A especificaçã o para importaçõ es relativas está contida na
seçã o Importações relativas ao pacote.
importlib.import_module() é fornecida para dar suporte a aplicaçõ es que determinam dinamicamente os mó -
dulos a serem carregados.
Levanta um evento de auditoria import com os argumentos module, filename, [Link], sys.meta_path,
sys.path_hooks.

7.11.1 Instruções future

Uma instrução future é uma diretiva para o compilador de que um determinado mó dulo deve ser compilado usando
sintaxe ou semâ ntica que estará disponível em uma versã o futura especificada do Python, onde o recurso se tornará
padrã o.
A instruçã o future destina-se a facilitar a migraçã o para versõ es futuras do Python que introduzem alteraçõ es incom-
patíveis na linguagem. Ele permite o uso dos novos recursos por mó dulo antes do lançamento em que o recurso se
torna padrã o.

future_stmt ::= "from" "__future__" "import" feature ["as" identifier]

("," feature ["as" identifier])*
| "from" "__future__" "import" "(" feature ["as" identifier]
("," feature ["as" identifier])* [","] ")"
feature ::= identifier

Uma instruçã o future deve aparecer perto do topo do mó dulo. As ú nicas linhas que podem aparecer antes de uma
instruçã o future sã o:
• o mó dulo docstring (se houver),
• omentá rios,
• linhas vazias e
• outras instruçõ es future.

110 Capítulo 7. Instruções simples

 The Python Language Reference, Release 3.13.0

O ú nico recurso que requer o uso da instruçã o future é annotations (veja PEP 563).
Todos os recursos histó ricos habilitados pela instruçã o future ainda sã o reconhecidos pelo Python 3. A lista inclui
absolute_import, division, generators, generator_stop, unicode_literals, print_function,
nested_scopes e with_statement. Eles sã o todos redundantes porque estã o sempre habilitados e mantidos
apenas para compatibilidade com versõ es anteriores.
Uma instruçã o future é reconhecida e tratada especialmente em tempo de compilaçã o: as alteraçõ es na semâ ntica das
construçõ es principais sã o frequentemente implementadas gerando có digo diferente. Pode até ser o caso de um novo
recurso introduzir uma nova sintaxe incompatível (como uma nova palavra reservada), caso em que o compilador
pode precisar analisar o mó dulo de maneira diferente. Tais decisõ es nã o podem ser adiadas até o tempo de execuçã o.
Para qualquer versã o, o compilador sabe quais nomes de recursos foram definidos e levanta um erro em tempo de
compilaçã o se uma instruçã o future contiver um recurso desconhecido.
A semâ ntica do tempo de execuçã o direto é a mesma de qualquer instruçã o de importaçã o: existe um mó dulo padrã o
__future__, descrito posteriormente, e será importado da maneira usual no momento em que a instruçã o future
for executada.
A semâ ntica interessante do tempo de execuçã o depende do recurso específico ativado pela instruçã o future.
Observe que nã o há nada de especial sobre a instruçã o:

import __future__ [as name]

Essa nã o é uma instruçã o future; é uma instruçã o de importaçã o comum sem nenhuma semâ ntica especial ou restri-
çõ es de sintaxe.
O có digo compilado por chamadas para as funçõ es embutidas exec() e compile() que ocorrem em um mó dulo M
contendo uma instruçã o future usará , por padrã o, a nova sintaxe ou semâ ntica associada com a instruçã o future. Isso
pode ser controlado por argumentos opcionais para compile() – veja a documentaçã o dessa funçã o para detalhes.
Uma instruçã o future tipada digitada em um prompt do interpretador interativo terá efeito no restante da sessã o do
interpretador. Se um interpretador for iniciado com a opçã o -i, for passado um nome de script para ser executado
e o script incluir uma instruçã o future, ela entrará em vigor na sessã o interativa iniciada apó s a execuçã o do script.

µ Ver também

PEP 236 - De volta ao __future__

A proposta original para o mecanismo do __future__.

7.12 A instrução global

global_stmt ::= "global" identifier ("," identifier)*

A instruçã o global é uma declaraçã o que vale para todo o bloco de có digo atual. Isso significa que os identificadores
listados devem ser interpretados como globais. Seria impossível atribuir a uma variá vel global sem global, embora
variá veis livres possam se referir a globais sem serem declaradas globais.
Nomes listados em uma instruçã o global nã o devem ser usados no mesmo bloco de có digo que precede textualmente
a instruçã o global.
Os nomes listados em uma instruçã o global nã o devem ser definidos como parâ metros formais, ou como alvos em
instruçõ es with ou clá usulas except, ou em uma lista alvo for, definiçã o de class, definiçã o de funçã o, instruçã o
import ou anotaçã o de variá vel.

Detalhes da implementação do CPython: A implementaçã o atual nã o impõ e algumas dessas restriçõ es, mas os
programas nã o devem abusar dessa liberdade, pois implementaçõ es future podem aplicá -las ou alterar silenciosa-
mente o significado do programa.
Nota do programador: global é uma diretiva para o analisador sintá tico. Aplica-se apenas ao có digo analisado
ao mesmo tempo que a instruçã o global. Em particular, uma instruçã o global contida em uma string ou objeto

7.12. A instrução global 111

The Python Language Reference, Release 3.13.0

có digo fornecido à funçã o embutida exec() nã o afeta o bloco de có digo contendo a chamada da funçã o e o có digo
contido em tal uma string nã o é afetada por instruçõ es global no có digo que conté m a chamada da funçã o. O
mesmo se aplica à s funçõ es eval() e compile().

7.13 A instrução nonlocal

nonlocal_stmt ::= "nonlocal" identifier ("," identifier)*

Quando a definiçã o de uma funçã o ou classe está aninhada (incluída) nas definiçõ es de outras funçõ es, seus escopos
nã o locais sã o os escopos locais das funçõ es envolventes. A instruçã o nonlocal faz com que os identificadores
listados se refiram a nomes previamente vinculados a escopos nã o locais. Ele permite que o có digo encapsulado
religue esses identificadores nã o locais. Se um nome estiver ligado a mais de um escopo nã o local, a ligaçã o mais
pró xima será usada. Se um nome nã o estiver vinculado a nenhum escopo nã o local, ou se nã o houver escopo nã o
local, uma exceçã o SyntaxError será levantada.
A instruçã o nã o local se aplica a todo o escopo de uma funçã o ou corpo da classe. Uma exceçã o SyntaxError é
levantada se uma variá vel for usada ou atribuída antes de sua declaraçã o nã o local no escopo.

µ Ver também

PEP 3104 - Acesso a nomes em escopos externos

A especificaçã o para a instruçã o nonlocal.

Nota do programador: nonlocal é uma diretiva para o analisador sintá tico e se aplica apenas ao có digo analisado
junto com ele. Veja a nota para a instruçã o global.

7.14 A instrução type

type_stmt ::= 'type' identifier [type_params] "=" expression

A instruçã o type declara um apelido de tipo, que é uma instâ ncia de [Link].
Por exemplo, a instruçã o a seguir cria um apelido de tipo:

type Point = tuple[float, float]

Este có digo é aproximadamente equivalente a:

annotation-def VALUE_OF_Point():
return tuple[float, float]
Point = [Link]("Point", VALUE_OF_Point())

annotation-def indica um escopo de anotação, que se comporta principalmente como uma funçã o, mas com
diversas pequenas diferenças.
O valor do apelido de tipo é avaliado no escopo de anotaçã o. Ele nã o é avaliado quando o apelido de tipo é criado, mas
somente quando o valor é acessado atravé s do atributo __value__ do apelido de tipo (veja Avaliação preguiçosa).
Isso permite que o apelido de tipo se refira a nomes que ainda nã o estã o definidos.
Apelidos de tipo podem se tornar gené ricos adicionando uma lista de parâmetros de tipo apó s o nome. Veja Generic
type aliases para mais.
type é uma palavra reservada contextual.

Adicionado na versã o 3.12.

112 Capítulo 7. Instruções simples

 The Python Language Reference, Release 3.13.0

µ Ver também

PEP 695 - Sintaxe de parâmetros de tipo

Introduziu a instruçã o type e sintaxe para classes e funçõ es gené ricas.

7.14. A instrução type 113

The Python Language Reference, Release 3.13.0

114 Capítulo 7. Instruções simples

 CAPÍTULO 8

Instruções compostas

Instruçõ es compostas conté m (grupos de) outras instruçõ es; Elas afetam ou controlam a execuçã o dessas outras
instruçõ es de alguma maneira. Em geral, instruçõ es compostas abrangem mú ltiplas linhas, no entanto em algumas
manifestaçõ es simples uma instruçã o composta inteira pode estar contida em uma linha.
As instruçõ es if , while e for implementam construçõ es tradicionais de controle do fluxo de execuçã o. try espe-
cifica tratadores de exceçã o e/ou có digo de limpeza para uma instruçã o ou grupo de instruçõ es, enquanto a palavra
reservada with permite a execuçã o de có digo de inicializaçã o e finalizaçã o em volta de um bloco de có digo. Defi-
niçõ es de funçã o e classe també m sã o sintaticamente instruçõ es compostas.
Uma instruçã o composta consiste em uma ou mais “clá usulas”. Uma clá usula consiste em um cabeçalho e um “con-
junto”. Os cabeçalhos das clá usulas de uma instruçã o composta específica estã o todos no mesmo nível de indentaçã o.
Cada cabeçalho de clá usula começa com uma palavra reservada de identificaçã o exclusiva e termina com dois pon-
tos. Um conjunto é um grupo de instruçõ es controladas por uma clá usula. Um conjunto pode ser uma ou mais
instruçõ es simples separadas por ponto e vírgula na mesma linha do cabeçalho, apó s os dois pontos do cabeçalho,
ou pode ser uma ou mais instruçõ es indentadas nas linhas subsequentes. Somente a ú ltima forma de conjunto pode
conter instruçõ es compostas aninhadas; o seguinte é ilegal, principalmente porque nã o ficaria claro a qual clá usula
if a seguinte clá usula else pertenceria:

if test1: if test2: print(x)

Observe també m que o ponto e vírgula é mais vinculado que os dois pontos neste contexto, de modo que no exemplo
a seguir, todas ou nenhuma das chamadas print() sã o executadas:

if x < y < z: print(x); print(y); print(z)

Resumindo:

compound_stmt ::= if_stmt

| while_stmt
| for_stmt
| try_stmt
| with_stmt
| match_stmt
| funcdef
| classdef
| async_with_stmt

115
The Python Language Reference, Release 3.13.0

| async_for_stmt
| async_funcdef
suite ::= stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT
statement ::= stmt_list NEWLINE | compound_stmt
stmt_list ::= simple_stmt (";" simple_stmt)* [";"]

Note que instruçõ es sempre terminam em uma NEWLINE possivelmente seguida por uma DEDENT. Note també m que
clá usulas opcionais de continuaçã o sempre começam com uma palavra reservada que nã o pode iniciar uma instruçã o,
desta forma nã o há ambiguidades (o problema do “else pendurado” é resolvido em Python obrigando que instruçõ es
if aninhadas tenham indentaçã o)

A formataçã o das regras de gramá tica nas pró ximas seçõ es põ e cada clá usula em uma linha separada para as tornar
mais claras.

8.1 A instrução if
A instruçã o if é usada para execuçã o condicional:

if_stmt ::= "if" assignment_expression ":" suite

("elif" assignment_expression ":" suite)*
["else" ":" suite]

Ele seleciona exatamente um dos conjuntos avaliando as expressõ es uma por uma até que uma seja considerada
verdadeira (veja a seçã o Operações booleanas para a definiçã o de verdadeiro e falso); entã o esse conjunto é executado
(e nenhuma outra parte da instruçã o if é executada ou avaliada). Se todas as expressõ es forem falsas, o conjunto da
clá usula else, se presente, é executado.

8.2 A instrução while

A instruçã o while é usada para execuçã o repetida desde que uma expressã o seja verdadeira:

while_stmt ::= "while" assignment_expression ":" suite

["else" ":" suite]

Isto testa repetidamente a expressã o e, se for verdadeira, executa o primeiro conjunto; se a expressã o for falsa (o que
pode ser a primeira vez que ela é testada) o conjunto da clá usula else, se presente, é executado e o laço termina.
Uma instruçã o break executada no primeiro conjunto termina o loop sem executar o conjunto da clá usula else.
Uma instruçã o continue executada no primeiro conjunto ignora o resto do conjunto e volta a testar a expressã o.

8.3 A instrução for

A instruçã o for é usada para iterar sobre os elementos de uma sequê ncia (como uma string, tupla ou lista) ou outro
objeto iterá vel:

for_stmt ::= "for" target_list "in" starred_list ":" suite

["else" ":" suite]

A expressã o starred_list é avaliada uma vez; deve produzir um objeto iterável. Um iterador é criado para esse
iterá vel. O primeiro item fornecido pelo iterador é entã o atribuído à lista de alvos usando as regras padrã o para
atribuiçõ es (veja Instruções de atribuição), e o conjunto é executado. Isso se repete para cada item fornecido pelo
iterador. Quando o iterador se esgota, o conjunto na clá usula else, se presente, é executado e o loop termina.

116 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

Uma instruçã o break executada no primeiro conjunto termina o loop sem executar o conjunto da clá usula else.
Uma instruçã o continue executada no primeiro conjunto pula o resto do conjunto e continua com o pró ximo item,
ou com a clá usula else se nã o houver pró ximo item.
O laço for faz atribuiçõ es à s variá veis na lista de destino. Isso substitui todas as atribuiçõ es anteriores a essas variá veis,
incluindo aquelas feitas no conjunto do laço for:

for i in range(10):
print(i)
i = 5 # this will not affect the for-loop
# because i will be overwritten with the next
# index in the range

Os nomes na lista de destinos nã o sã o excluídos quando o laço termina, mas se a sequê ncia estiver vazia, eles nã o
serã o atribuídos pelo laço. Dica: o tipo embutido range() representa sequê ncias aritmé ticas imutá veis de inteiros.
Por exemplo, iterar range(3) sucessivamente produz 0, 1 e depois 2.
Alterado na versã o 3.11: Elementos marcados com estrela agora sã o permitidos na lista de expressõ es.

8.4 A instrução try

A instruçã o try especifica manipuladores de exceçã o e/ou có digo de limpeza para um grupo de instruçõ es:

try_stmt ::= try1_stmt | try2_stmt | try3_stmt

try1_stmt ::= "try" ":" suite
("except" [expression ["as" identifier]] ":" suite)+
["else" ":" suite]
["finally" ":" suite]
try2_stmt ::= "try" ":" suite
("except" "*" expression ["as" identifier] ":" suite)+
["else" ":" suite]
["finally" ":" suite]
try3_stmt ::= "try" ":" suite
"finally" ":" suite

Informaçõ es adicionais sobre exceçõ es podem ser encontradas na seçã o Exceções, e informaçõ es sobre como usar a
instruçã o raise para gerar exceçõ es podem ser encontradas na seçã o A instrução raise.

8.4.1 Cláusula except

As clá usulas except especificam um ou mais manipuladores de exceçã o. Quando nenhuma exceçã o ocorre na
clá usula try , nenhum manipulador de exceçã o é executado. Quando uma exceçã o ocorre no conjunto try, uma
busca por um manipulador de exceçã o é iniciada. Essa busca inspeciona as clá usulas except por vez até que uma
seja encontrada que corresponda à exceçã o. Uma clá usula except sem expressã o, se presente, deve ser a ú ltima; ela
corresponde a qualquer exceçã o.
Para uma clá usula except com uma expressã o, a expressã o deve ser avaliada como um tipo de exceçã o ou uma
tupla de tipos de exceçã o. A exceçã o levantada corresponde a uma clá usula except cuja expressã o é avaliada como
a classe ou uma classe base não virtual do objeto exceçã o, ou como uma tupla que conté m tal classe.
Se nenhuma clá usula except corresponder à exceçã o, a busca por um manipulador de exceçã o continua no có digo
circundante e na pilha de invocaçã o.1
Se a avaliaçã o de uma expressã o no cabeçalho de uma clá usula except levantar uma exceçã o, a busca original por
um manipulador será cancelada e uma busca pela nova exceçã o será iniciada no có digo circundante e na pilha de
chamadas (ela é tratado como se toda a instruçã o try levantasse a exceçã o).
1 The exception is propagated to the invocation stack unless there is a finally clause which happens to raise another exception. That new

exception causes the old one to be lost.

8.4. A instrução try 117

The Python Language Reference, Release 3.13.0

Quando uma clá usula except correspondente é encontrada, a exceçã o é atribuída ao destino especificado apó s a
palavra reservada as nessa clá usula except, se presente, e o conjunto da clá usula except é executado. Todas
as clá usulas except devem ter um bloco executá vel. Quando o final deste bloco é atingido, a execuçã o continua
normalmente apó s toda a instruçã o try . (Isso significa que se existirem dois manipuladores aninhados para a mesma
exceçã o, e a exceçã o ocorrer na clá usula try do manipulador interno, o manipulador externo nã o tratará a exceçã o.)
Quando uma exceçã o foi atribuída usando as target, ela é limpa no final da clá usula except. É como se

except E as N:
foo

fosse traduzido para

except E as N:
try:
foo
finally:
del N

Isso significa que a exceçã o deve ser atribuída a um nome diferente para poder referenciá -la apó s a clá usula except.
As exceçõ es sã o limpas porque, com o traceback (situaçã o da pilha de execuçã o) anexado a elas, elas formam um
ciclo de referê ncia com o quadro de pilha, mantendo todos os locais nesse quadro vivos até que ocorra a pró xima
coleta de lixo.
Antes de um conjunto de clá usulas except ser executado, a exceçã o é armazenada no mó dulo sys, onde pode ser
acessada de dentro do corpo da clá usula except chamando [Link](). Ao sair de um manipulador de
exceçõ es, a exceçã o armazenada no mó dulo sys é redefinida para seu valor anterior:

>>> print([Link]())
None
>>> try:
... raise TypeError
... except:
... print(repr([Link]()))
... try:
... raise ValueError
... except:
... print(repr([Link]()))
... print(repr([Link]()))
...
TypeError()
ValueError()
TypeError()
>>> print([Link]())
None

8.4.2 Cláusula except*

As clá usulas except* sã o usadas para manipular ExceptionGroups. O tipo de exceçã o para correspondê ncia é
interpretado como no caso de except, mas no caso de grupos de exceçã o, podemos ter correspondê ncias parciais
quando o tipo corresponde a algumas das exceçõ es no grupo. Isso significa que vá rias clá usulas except* podem ser
executadas, cada uma manipulando parte do grupo de exceçõ es. Cada clá usula é executada no má ximo uma vez e
manipula um grupo de exceçõ es de todas as exceçõ es correspondentes. Cada exceçã o no grupo é manipulada por no
má ximo uma clá usula except*, a primeira que corresponde a ela.

>>> try:
... raise ExceptionGroup("eg",
... [ValueError(1), TypeError(2), OSError(3), OSError(4)])
... except* TypeError as e:
(continua na pró xima pá gina)

118 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

... print(f'caught {type(e)} with nested {[Link]}')
... except* OSError as e:
... print(f'caught {type(e)} with nested {[Link]}')
...
caught <class 'ExceptionGroup'> with nested (TypeError(2),)
caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))
+ Exception Group Traceback (most recent call last):
| File "<stdin>", line 2, in <module>
| ExceptionGroup: eg
+-+---------------- 1 ----------------
| ValueError: 1
+------------------------------------

Quaisquer exceçõ es restantes que nã o foram manipuladas por nenhuma clá usula except* sã o levantadas novamente
no final, junto com todas as exceçõ es que foram levantadas de dentro das clá usulas except*. Se esta lista contiver
mais de uma exceçã o para levantar novamente, elas serã o combinadas em um grupo de exceçõ es.
Se a exceçã o levantada nã o for um grupo de exceçõ es e seu tipo corresponder a uma das clá usulas except*, ela será
capturada e encapsulada por um grupo de exceçõ es com uma string de mensagem vazia.

>>> try:
... raise BlockingIOError
... except* BlockingIOError as e:
... print(repr(e))
...
ExceptionGroup('', (BlockingIOError()))

Uma clá usula except* deve ter uma expressã o correspondente; nã o pode ser except*:. Alé m disso, essa expressã o
nã o pode conter tipos de grupo de exceçã o, porque isso teria semâ ntica ambígua.
Nã o é possível misturar except e except* no mesmo try . break, continue e return nã o pode aparecer em
uma clá usula except*.

8.4.3 Cláusula else

A clá usula opcional else é executada se o fluxo de controle deixar o conjunto try , nenhuma exceçã o foi levantada
e nenhuma instruçã o return, continue ou break foi executada. Exceçõ es na clá usula else nã o sã o manipuladas
pelas clá usulas except precedentes.

8.4.4 Cláusula finally

Se finally estiver presente, especifica um manipulador de “limpeza”. A clá usula try é executada, incluindo quais-
quer clá usulas except e else. Se uma exceçã o ocorrer em qualquer uma das clá usulas e nã o for manipulada, a
exceçã o será salva temporariamente. A clá usula finally é executada. Se houver uma exceçã o salva, ela será le-
vantada novamente no final da clá usula finally. Se a clá usula finally levantar outra exceçã o, a exceçã o salva
será definida como o contexto da nova exceçã o. Se a clá usula finally executar uma instruçã o return, break ou
continue, a exceçã o salva será descartada:

>>> def f():

... try:
... 1/0
... finally:
... return 42
...
>>> f()
42

As informaçõ es de exceçã o nã o estã o disponíveis para o programa durante a execuçã o da clá usula finally.

8.4. A instrução try 119

The Python Language Reference, Release 3.13.0

Quando uma instruçã o return, break ou continue é executada no conjunto try de uma instruçã o
try…finally, a clá usula finally també m é executada “na saída”.

O valor de retorno de uma funçã o é determinado pela ú ltima instruçã o return executada. Como a clá usula finally
sempre é executada, uma instruçã o return executada na clá usula finally sempre será a ú ltima executada:

>>> def foo():

... try:
... return 'try'
... finally:
... return 'finally'
...
>>> foo()
'finally'

Alterado na versã o 3.8: Antes do Python 3.8, uma instruçã o continue era ilegal na clá usula finally devido a um
problema com a implementaçã o.

8.5 A instrução with

A instruçã o with é usada para envolver em um invó lucro a execuçã o de um bloco com mé todos definidos por um
gerenciador de contexto (veja a seçã o Gerenciadores de contexto da instrução with). Isso permite que padrõ es comuns
de uso de try …except…finally sejam encapsulados para reutilizaçã o conveniente.

with_stmt ::= "with" ( "(" with_stmt_contents ","? ")" | with_stmt_contents ) ":" sui
with_stmt_contents ::= with_item ("," with_item)*
with_item ::= expression ["as" target]

A execuçã o da instruçã o with com um “item” ocorre da seguinte maneira:

1. A expressã o de contexto (a expressã o fornecida em with_item) é avaliada para obter um gerenciador de
contexto.
2. O __enter__() do gerenciador de contexto é carregado para uso posterior.
3. O __exit__() do gerenciador de contexto é carregado para uso posterior.
4. O mé todo __enter__() do gerenciador de contexto é invocado.
5. Se um alvo foi incluído na instruçã o with, o valor de retorno de __enter__() é atribuído a ele.

® Nota

A instruçã o with garante que se o mé todo __enter__() retornar sem um erro, entã o __exit__()
sempre será chamado. Assim, se ocorrer um erro durante a atribuiçã o à lista de alvos, ele será tratado da
mesma forma que um erro ocorrendo dentro do conjunto seria. Veja a etapa 7 abaixo.

6. O conjunto é executado.
7. O mé todo __exit__() do gerenciador de contexto é invocado. Se uma exceçã o fez com que o conjunto fosse
encerrado, seu tipo, valor e traceback sã o passados como argumentos para __exit__(). Caso contrá rio, trê s
argumentos None sã o fornecidos.
Se o conjunto foi encerrado devido a uma exceçã o, e o valor de retorno do mé todo __exit__() foi falso, a
exceçã o é levantada novamente. Se o valor de retorno era verdadeiro, a exceçã o é suprimida, e a execuçã o
continua com a instruçã o apó s a instruçã o with.
Se o conjunto foi encerrado por qualquer motivo diferente de uma exceçã o, o valor de retorno de __exit__()
é ignorado e a execuçã o prossegue no local normal para o tipo de saída que foi realizada.
O seguinte có digo:

120 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

with EXPRESSION as TARGET:

SUITE

é semanticamente equivalente a:

manager = (EXPRESSION)
enter = type(manager).__enter__
exit = type(manager).__exit__
value = enter(manager)
hit_except = False

try:
TARGET = value
SUITE
except:
hit_except = True
if not exit(manager, *sys.exc_info()):
raise
finally:
if not hit_except:
exit(manager, None, None, None)

Com mais de um item, os gerenciadores de contexto sã o processados como se vá rias instruçõ es with estivessem
aninhadas:

with A() as a, B() as b:

SUITE

é semanticamente equivalente a:

with A() as a:
with B() as b:
SUITE

Você també m pode escrever gerenciadores de contexto multi-item em vá rias linhas se os itens estiverem entre pa-
rê nteses. Por exemplo:

with (
A() as a,
B() as b,
):
SUITE

Alterado na versã o 3.1: Suporte para mú ltiplas expressõ es de contexto.

Alterado na versã o 3.10: Suporte para usar parê nteses de agrupamento para dividir a instruçã o em vá rias linhas.

µ Ver também

PEP 343 - A instrução “with”

A especificaçã o, o histó rico e os exemplos para a instruçã o Python with.

8.6 A instrução match

Adicionado na versã o 3.10.
A instruçã o match é usada para correspondê ncia de padrõ es. Sintaxe:

8.6. A instrução match 121

The Python Language Reference, Release 3.13.0

match_stmt ::= 'match' subject_expr ":" NEWLINE INDENT case_block+ DEDENT

subject_expr ::= star_named_expression "," star_named_expressions?
| named_expression
case_block ::= 'case' patterns [guard] ":" block

® Nota

Esta seçã o usa aspas simples para denotar palavras reservadas contextuais.

A correspondê ncia de padrõ es aceita um padrã o como entrada (seguindo case) e um valor de sujeito (seguindo
match). O padrã o (que pode conter subpadrõ es) é correspondido ao valor de assunto. Os resultados sã o:

• Um sucesso ou falha de correspondê ncia (també m chamado de sucesso ou falha de padrã o).
• Possível vinculaçã o de valores correspondentes a um nome. Os pré -requisitos para isso sã o discutidos mais
adiante.
As palavras reservadas match e case sã o palavras reservadas contextuais.

µ Ver também

• PEP 634 – Structural Pattern Matching: Specification

• PEP 636 – Correspondê ncia de padrõ es estruturais: Tutorial

8.6.1 Visão Geral

Aqui está uma visã o geral do fluxo ló gico de uma instruçã o match:
1. A expressã o de sujeito subject_expr é avaliada e um valor de sujeito resultante é obtido. Se a expressã o de
sujeito contiver uma vírgula, uma tupla é construída usando as regras padrã o.
2. Cada padrã o em um case_block é tentado para corresponder ao valor de sujeito. As regras específicas
para sucesso ou falha sã o descritas abaixo. A tentativa de correspondê ncia també m pode vincular alguns ou
todos os nomes autô nomos dentro do padrã o. As regras precisas de vinculaçã o de padrã o variam por tipo de
padrã o e sã o especificadas abaixo. As vinculações de nome feitas durante uma correspondência de padrão
bem-sucedida sobrevivem ao bloco executado e podem ser usadas após a instrução match.

® Nota

Durante correspondê ncias de padrõ es com falha, alguns subpadrõ es podem ter sucesso. Nã o confie em
vinculaçõ es sendo feitas para uma correspondê ncia com falha. Por outro lado, nã o confie em variá veis
permanecendo inalteradas apó s uma correspondê ncia com falha. O comportamento exato depende da
implementaçã o e pode variar. Esta é uma decisã o intencional feita para permitir que diferentes implemen-
taçõ es adicionem otimizaçõ es.

3. Se o padrã o for bem-sucedido, o guard correspondente (se presente) é avaliado. Neste caso, todas as vincula-
çõ es de nome sã o garantidas como tendo acontecido.
• Se o guard for avaliado como verdadeiro ou estiver ausente, o block dentro de case_block será exe-
cutado.
• Caso contrá rio, o pró ximo case_block será tentado conforme descrito acima.
• Se nã o houver mais blocos de caso, a instruçã o match será concluída.

122 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

® Nota

Os usuá rios geralmente nunca devem confiar em um padrã o sendo avaliado. Dependendo da implementaçã o, o
interpretador pode armazenar valores em cache ou usar outras otimizaçõ es que pulam avaliaçõ es repetidas.

Um exemplo de instruçã o match:

>>> flag = False

>>> match (100, 200):
... case (100, 300): # Mismatch: 200 != 300
... print('Case 1')
... case (100, 200) if flag: # Successful match, but guard fails
... print('Case 2')
... case (100, y): # Matches and binds y to 200
... print(f'Case 3, y: {y}')
... case _: # Pattern not attempted
... print('Case 4, I match anything!')
...
Case 3, y: 200

Neste caso, if flag é um guard. Leia mais sobre isso na pró xima seçã o.

8.6.2 Guards

guard ::= "if" named_expression

Um guard (que faz parte do case) deve ter sucesso para que o có digo dentro do bloco case seja executado. Ele
assume a forma: if seguido por uma expressã o.
O fluxo ló gico de um bloco case com um guard é o seguinte:
1. Verifique se o padrã o no bloco case foi bem-sucedido. Se o padrã o falhou, o guard nã o é avaliado e o
pró ximo bloco case é verificado.
2. Se o padrã o for bem-sucedido, avalia o guard.
• Se a condiçã o guard for avaliada como verdadeira, o bloco de caso será selecionado.
• Se a condiçã o guard for avaliada como falsa, o bloco de caso nã o será selecionado.
• Se o guard levantar uma exceçã o durante a avaliaçã o, a exceçã o surgirá .
Guards podem ter efeitos colaterais, pois sã o expressõ es. A avaliaçã o de guards deve prosseguir do primeiro ao
ú ltimo bloco de caso, um de cada vez, pulando blocos de caso cujos padrõ es nã o sã o todos bem-sucedidos. (Isto é ,
a avaliaçã o de guardas deve acontecer em ordem.) A avaliaçã o de guards deve parar quando um bloco de caso for
selecionado.

8.6.3 Blocos irrefutáveis de case

Um bloco irrefutá vel de case é um bloco de case que corresponde a qualquer valor. Uma instruçã o match pode ter
no má ximo um bloco irrefutá vel de case, e ele deve ser o ú ltimo.
Um bloco de case é considerado irrefutá vel se nã o tiver guard e seu padrã o for irrefutá vel. Um padrã o é considerado
irrefutá vel se pudermos provar somente por sua sintaxe que ele sempre terá sucesso. Somente os seguintes padrõ es
sã o irrefutá veis:
• AS Patterns cujo lado esquerdo é irrefutá vel
• OR Patterns contendo pelo menos um padrã o irrefutá vel
• Capture Patterns
• Wildcard Patterns

8.6. A instrução match 123

The Python Language Reference, Release 3.13.0

• padrõ es irrefutá veis entre parê teses

8.6.4 Padrões

® Nota

Esta seçã o usa notaçõ es de gramá tica para alé m do padrã o de EBNF:
• a notaçã o [Link]+ é uma abreviaçã o para RULE (SEP RULE)*
• a notaçã o !RULE é uma abreviaçã o para uma asserçã o de negaçã o antecipada.

The top-level syntax for patterns is:

patterns ::= open_sequence_pattern | pattern

pattern ::= as_pattern | or_pattern
closed_pattern ::= | literal_pattern
| capture_pattern
| wildcard_pattern
| value_pattern
| group_pattern
| sequence_pattern
| mapping_pattern
| class_pattern

The descriptions below will include a description “in simple terms” of what a pattern does for illustration purposes
(credits to Raymond Hettinger for a document that inspired most of the descriptions). Note that these descriptions
are purely for illustration purposes and may not reflect the underlying implementation. Furthermore, they do not
cover all valid forms.

OR Patterns
An OR pattern is two or more patterns separated by vertical bars |. Syntax:

or_pattern ::= "|".closed_pattern+

Only the final subpattern may be irrefutable, and each subpattern must bind the same set of names to avoid ambiguity.
An OR pattern matches each of its subpatterns in turn to the subject value, until one succeeds. The OR pattern is
then considered successful. Otherwise, if none of the subpatterns succeed, the OR pattern fails.
In simple terms, P1 | P2 | ... will try to match P1, if it fails it will try to match P2, succeeding immediately if
any succeeds, failing otherwise.

AS Patterns
An AS pattern matches an OR pattern on the left of the as keyword against a subject. Syntax:

as_pattern ::= or_pattern "as" capture_pattern

If the OR pattern fails, the AS pattern fails. Otherwise, the AS pattern binds the subject to the name on the right of
the as keyword and succeeds. capture_pattern cannot be a _.
In simple terms P as NAME will match with P, and on success it will set NAME = <subject>.

124 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

Literal Patterns
A literal pattern corresponds to most literals in Python. Syntax:

literal_pattern ::= signed_number

| signed_number "+" NUMBER
| signed_number "-" NUMBER
| strings
| "None"
| "True"
| "False"
signed_number ::= ["-"] NUMBER

The rule strings and the token NUMBER are defined in the standard Python grammar. Triple-quoted strings are
supported. Raw strings and byte strings are supported. Literais de strings formatadas are not supported.
The forms signed_number '+' NUMBER and signed_number '-' NUMBER are for expressing complex num-
bers; they require a real number on the left and an imaginary number on the right. E.g. 3 + 4j.
In simple terms, LITERAL will succeed only if <subject> == LITERAL. For the singletons None, True and
False, the is operator is used.

Capture Patterns
A capture pattern binds the subject value to a name. Syntax:

capture_pattern ::= !'_' NAME

A single underscore _ is not a capture pattern (this is what !'_' expresses). It is instead treated as a
wildcard_pattern.

In a given pattern, a given name can only be bound once. E.g. case x, x: ... is invalid while case [x] | x:
... is allowed.

Capture patterns always succeed. The binding follows scoping rules established by the assignment expression operator
in PEP 572; the name becomes a local variable in the closest containing function scope unless there’s an applicable
global or nonlocal statement.

In simple terms NAME will always succeed and it will set NAME = <subject>.

Wildcard Patterns
A wildcard pattern always succeeds (matches anything) and binds no name. Syntax:

wildcard_pattern ::= '_'

_ is a soft keyword within any pattern, but only within patterns. It is an identifier, as usual, even within match subject
expressions, guards, and case blocks.
In simple terms, _ will always succeed.

Value Patterns
A value pattern represents a named value in Python. Syntax:

value_pattern ::= attr

attr ::= name_or_attr "." NAME
name_or_attr ::= attr | NAME

8.6. A instrução match 125

The Python Language Reference, Release 3.13.0

The dotted name in the pattern is looked up using standard Python name resolution rules. The pattern succeeds if the
value found compares equal to the subject value (using the == equality operator).
In simple terms NAME1.NAME2 will succeed only if <subject> == NAME1.NAME2

® Nota

If the same value occurs multiple times in the same match statement, the interpreter may cache the first value
found and reuse it rather than repeat the same lookup. This cache is strictly tied to a given execution of a given
match statement.

Group Patterns
A group pattern allows users to add parentheses around patterns to emphasize the intended grouping. Otherwise, it
has no additional syntax. Syntax:

group_pattern ::= "(" pattern ")"

In simple terms (P) has the same effect as P.

Sequence Patterns
A sequence pattern contains several subpatterns to be matched against sequence elements. The syntax is similar to
the unpacking of a list or tuple.

sequence_pattern ::= "[" [maybe_sequence_pattern] "]"

| "(" [open_sequence_pattern] ")"
open_sequence_pattern ::= maybe_star_pattern "," [maybe_sequence_pattern]
maybe_sequence_pattern ::= ",".maybe_star_pattern+ ","?
maybe_star_pattern ::= star_pattern | pattern
star_pattern ::= "*" (capture_pattern | wildcard_pattern)

There is no difference if parentheses or square brackets are used for sequence patterns (i.e. (...) vs [...] ).

® Nota

A single pattern enclosed in parentheses without a trailing comma (e.g. (3 | 4)) is a group pattern. While a
single pattern enclosed in square brackets (e.g. [3 | 4]) is still a sequence pattern.

At most one star subpattern may be in a sequence pattern. The star subpattern may occur in any position. If no
star subpattern is present, the sequence pattern is a fixed-length sequence pattern; otherwise it is a variable-length
sequence pattern.
The following is the logical flow for matching a sequence pattern against a subject value:
1. If the subject value is not a sequence2 , the sequence pattern fails.
2 In pattern matching, a sequence is defined as one of the following:
• a class that inherits from [Link]
• a Python class that has been registered as [Link]
• a builtin class that has its (CPython) Py_TPFLAGS_SEQUENCE bit set
• a class that inherits from any of the above
The following standard library classes are sequences:
• [Link]
• [Link]
• list
• memoryview
• range
• tuple

126 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

2. If the subject value is an instance of str, bytes or bytearray the sequence pattern fails.
3. The subsequent steps depend on whether the sequence pattern is fixed or variable-length.
If the sequence pattern is fixed-length:
1. If the length of the subject sequence is not equal to the number of subpatterns, the sequence pattern fails
2. Subpatterns in the sequence pattern are matched to their corresponding items in the subject sequence
from left to right. Matching stops as soon as a subpattern fails. If all subpatterns succeed in matching
their corresponding item, the sequence pattern succeeds.
Otherwise, if the sequence pattern is variable-length:
1. If the length of the subject sequence is less than the number of non-star subpatterns, the sequence pattern
fails.
2. The leading non-star subpatterns are matched to their corresponding items as for fixed-length sequences.
3. If the previous step succeeds, the star subpattern matches a list formed of the remaining subject items,
excluding the remaining items corresponding to non-star subpatterns following the star subpattern.
4. Remaining non-star subpatterns are matched to their corresponding subject items, as for a fixed-length
sequence.

® Nota

The length of the subject sequence is obtained via len() (i.e. via the __len__() protocol). This length
may be cached by the interpreter in a similar manner as value patterns.

In simple terms [P1, P2, P3, … , P<N>] matches only if all the following happens:
• check <subject> is a sequence
• len(subject) == <N>
• P1 matches <subject>[0] (note that this match can also bind names)
• P2 matches <subject>[1] (note that this match can also bind names)
• … and so on for the corresponding pattern/element.

Mapping Patterns
A mapping pattern contains one or more key-value patterns. The syntax is similar to the construction of a dictionary.
Syntax:

mapping_pattern ::= "{" [items_pattern] "}"

items_pattern ::= ",".key_value_pattern+ ","?
key_value_pattern ::= (literal_pattern | value_pattern) ":" pattern
| double_star_pattern
double_star_pattern ::= "**" capture_pattern

At most one double star pattern may be in a mapping pattern. The double star pattern must be the last subpattern in
the mapping pattern.
Duplicate keys in mapping patterns are disallowed. Duplicate literal keys will raise a SyntaxError. Two keys that
otherwise have the same value will raise a ValueError at runtime.

® Nota

Subject values of type str, bytes, and bytearray do not match sequence patterns.

8.6. A instrução match 127

The Python Language Reference, Release 3.13.0

The following is the logical flow for matching a mapping pattern against a subject value:
1. If the subject value is not a mapping3 ,the mapping pattern fails.
2. If every key given in the mapping pattern is present in the subject mapping, and the pattern for each key matches
the corresponding item of the subject mapping, the mapping pattern succeeds.
3. If duplicate keys are detected in the mapping pattern, the pattern is considered invalid. A SyntaxError is
raised for duplicate literal values; or a ValueError for named keys of the same value.

® Nota

Key-value pairs are matched using the two-argument form of the mapping subject’s get() method. Matched
key-value pairs must already be present in the mapping, and not created on-the-fly via __missing__() or
__getitem__().

In simple terms {KEY1: P1, KEY2: P2, ... } matches only if all the following happens:
• check <subject> is a mapping
• KEY1 in <subject>
• P1 matches <subject>[KEY1]
• … and so on for the corresponding KEY/pattern pair.

Class Patterns
A class pattern represents a class and its positional and keyword arguments (if any). Syntax:

class_pattern ::= name_or_attr "(" [pattern_arguments ","?] ")"

pattern_arguments ::= positional_patterns ["," keyword_patterns]
| keyword_patterns
positional_patterns ::= ",".pattern+
keyword_patterns ::= ",".keyword_pattern+
keyword_pattern ::= NAME "=" pattern

The same keyword should not be repeated in class patterns.

The following is the logical flow for matching a class pattern against a subject value:
1. If name_or_attr is not an instance of the builtin type , raise TypeError.
2. If the subject value is not an instance of name_or_attr (tested via isinstance()), the class pattern fails.
3. If no pattern arguments are present, the pattern succeeds. Otherwise, the subsequent steps depend on whether
keyword or positional argument patterns are present.
For a number of built-in types (specified below), a single positional subpattern is accepted which will match
the entire subject; for these types keyword patterns also work as for other types.
If only keyword patterns are present, they are processed as follows, one by one:
I. The keyword is looked up as an attribute on the subject.
• If this raises an exception other than AttributeError, the exception bubbles up.
• If this raises AttributeError, the class pattern has failed.
3 In pattern matching, a mapping is defined as one of the following:
• a class that inherits from [Link]
• a Python class that has been registered as [Link]
• a builtin class that has its (CPython) Py_TPFLAGS_MAPPING bit set
• a class that inherits from any of the above
The standard library classes dict and [Link] are mappings.

128 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

• Else, the subpattern associated with the keyword pattern is matched against the subject’s attribute value.
If this fails, the class pattern fails; if this succeeds, the match proceeds to the next keyword.
II. If all keyword patterns succeed, the class pattern succeeds.
If any positional patterns are present, they are converted to keyword patterns using the __match_args__
attribute on the class name_or_attr before matching:
I. The equivalent of getattr(cls, "__match_args__", ()) is called.
• If this raises an exception, the exception bubbles up.
• If the returned value is not a tuple, the conversion fails and TypeError is raised.
• If there are more positional patterns than len(cls.__match_args__), TypeError is rai-
sed.
• Otherwise, positional pattern i is converted to a keyword pattern using __match_args__[i]
as the keyword. __match_args__[i] must be a string; if not TypeError is raised.
• If there are duplicate keywords, TypeError is raised.

µ Ver também

Customizando argumentos posicionais na classe correspondência de padrão

II. Once all positional patterns have been converted to keyword patterns,
the match proceeds as if there were only keyword patterns.
For the following built-in types the handling of positional subpatterns is different:
• bool
• bytearray
• bytes
• dict
• float
• frozenset
• int
• list
• set
• str
• tuple
These classes accept a single positional argument, and the pattern there is matched against the whole object
rather than an attribute. For example int(0|1) matches the value 0, but not the value 0.0.
In simple terms CLS(P1, attr=P2) matches only if the following happens:
• isinstance(<subject>, CLS)
• convert P1 to a keyword pattern using CLS.__match_args__
• For each keyword argument attr=P2:
– hasattr(<subject>, "attr")
– P2 matches <subject>.attr
• … and so on for the corresponding keyword argument/pattern pair.

8.6. A instrução match 129

The Python Language Reference, Release 3.13.0

µ Ver também

• PEP 634 – Structural Pattern Matching: Specification

• PEP 636 – Correspondê ncia de padrõ es estruturais: Tutorial

8.7 Definições de função

A function definition defines a user-defined function object (see section A hierarquia de tipos padrão):

funcdef ::= [decorators] "def" funcname [type_params] "(" [parameter_list] "

["->" expression] ":" suite
decorators ::= decorator+
decorator ::= "@" assignment_expression NEWLINE
parameter_list ::= defparameter ("," defparameter)* "," "/" ["," [parameter_list_no
| parameter_list_no_posonly
parameter_list_no_posonly ::= defparameter ("," defparameter)* ["," [parameter_list_starargs]]
| parameter_list_starargs
parameter_list_starargs ::= "*" [star_parameter] ("," defparameter)* ["," ["**" parameter ["
| "**" parameter [","]
parameter ::= identifier [":" expression]
star_parameter ::= identifier [":" ["*"] expression]
defparameter ::= parameter ["=" expression]
funcname ::= identifier

A function definition is an executable statement. Its execution binds the function name in the current local namespace
to a function object (a wrapper around the executable code for the function). This function object contains a reference
to the current global namespace as the global namespace to be used when the function is called.
The function definition does not execute the function body; this gets executed only when the function is called.4
A function definition may be wrapped by one or more decorator expressions. Decorator expressions are evaluated
when the function is defined, in the scope that contains the function definition. The result must be a callable, which
is invoked with the function object as the only argument. The returned value is bound to the function name instead
of the function object. Multiple decorators are applied in nested fashion. For example, the following code

@f1(arg)
@f2
def func(): pass

is roughly equivalent to

def func(): pass

func = f1(arg)(f2(func))

except that the original function is not temporarily bound to the name func.
Alterado na versã o 3.9: Functions may be decorated with any valid assignment_expression. Previously, the
grammar was much more restrictive; see PEP 614 for details.
A list of type parameters may be given in square brackets between the function’s name and the opening parenthesis for
its parameter list. This indicates to static type checkers that the function is generic. At runtime, the type parameters
can be retrieved from the function’s __type_params__ attribute. See Generic functions for more.
Alterado na versã o 3.12: Type parameter lists are new in Python 3.12.
4 A string literal appearing as the first statement in the function body is transformed into the function’s __doc__ attribute and therefore the

function’s docstring.

130 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

When one or more parameters have the form parameter = expression, the function is said to have “default parameter
values.” For a parameter with a default value, the corresponding argument may be omitted from a call, in which case
the parameter’s default value is substituted. If a parameter has a default value, all following parameters up until the
“*” must also have a default value — this is a syntactic restriction that is not expressed by the grammar.
Default parameter values are evaluated from left to right when the function definition is executed. This means
that the expression is evaluated once, when the function is defined, and that the same “pre-computed” value is used
for each call. This is especially important to understand when a default parameter value is a mutable object, such as
a list or a dictionary: if the function modifies the object (e.g. by appending an item to a list), the default parameter
value is in effect modified. This is generally not what was intended. A way around this is to use None as the default,
and explicitly test for it in the body of the function, e.g.:

def whats_on_the_telly(penguin=None):
if penguin is None:
penguin = []
[Link]("property of the zoo")
return penguin

Function call semantics are described in more detail in section Chamadas. A function call always assigns values to
all parameters mentioned in the parameter list, either from positional arguments, from keyword arguments, or from
default values. If the form “*identifier” is present, it is initialized to a tuple receiving any excess positional
parameters, defaulting to the empty tuple. If the form “**identifier” is present, it is initialized to a new ordered
mapping receiving any excess keyword arguments, defaulting to a new empty mapping of the same type. Parame-
ters after “*” or “*identifier” are keyword-only parameters and may only be passed by keyword arguments.
Parameters before “/” are positional-only parameters and may only be passed by positional arguments.
Alterado na versã o 3.8: The / function parameter syntax may be used to indicate positional-only parameters. See
PEP 570 for details.
Parameters may have an annotation of the form “: expression” following the parameter name. Any parameter
may have an annotation, even those of the form *identifier or **identifier. (As a special case, parameters
of the form *identifier may have an annotation “: *expression”.) Functions may have “return” annotation
of the form “-> expression” after the parameter list. These annotations can be any valid Python expression.
The presence of annotations does not change the semantics of a function. The annotation values are available as
values of a dictionary keyed by the parameters’ names in the __annotations__ attribute of the function object. If
the annotations import from __future__ is used, annotations are preserved as strings at runtime which enables
postponed evaluation. Otherwise, they are evaluated when the function definition is executed. In this case annotations
may be evaluated in a different order than they appear in the source code.
Alterado na versã o 3.11: Parameters of the form “*identifier” may have an annotation “: *expression”. See
PEP 646.
It is also possible to create anonymous functions (functions not bound to a name), for immediate use in expressions.
This uses lambda expressions, described in section Lambdas. Note that the lambda expression is merely a shorthand
for a simplified function definition; a function defined in a “def ” statement can be passed around or assigned to
another name just like a function defined by a lambda expression. The “def” form is actually more powerful since it
allows the execution of multiple statements and annotations.
Programmer’s note: Functions are first-class objects. A “def” statement executed inside a function definition
defines a local function that can be returned or passed around. Free variables used in the nested function can access
the local variables of the function containing the def. See section Nomeação e ligação for details.

µ Ver também

PEP 3107 - Function Annotations

The original specification for function annotations.
PEP 484 - Dicas de tipo
Definition of a standard meaning for annotations: type hints.

8.7. Definições de função 131

The Python Language Reference, Release 3.13.0

PEP 526 - Sintaxe para Anotações de Variáveis

Ability to type hint variable declarations, including class variables and instance variables.
PEP 563 - Postponed Evaluation of Annotations
Support for forward references within annotations by preserving annotations in a string form at runtime
instead of eager evaluation.
PEP 318 - Decorators for Functions and Methods
Function and method decorators were introduced. Class decorators were introduced in PEP 3129.

8.8 Definições de classe

A class definition defines a class object (see section A hierarquia de tipos padrão):

classdef ::= [decorators] "class" classname [type_params] [inheritance] ":" suite

inheritance ::= "(" [argument_list] ")"
classname ::= identifier

A class definition is an executable statement. The inheritance list usually gives a list of base classes (see Metaclasses
for more advanced uses), so each item in the list should evaluate to a class object which allows subclassing. Classes
without an inheritance list inherit, by default, from the base class object; hence,

class Foo:
pass

é equivalente a

class Foo(object):
pass

The class’s suite is then executed in a new execution frame (see Nomeação e ligação), using a newly created local
namespace and the original global namespace. (Usually, the suite contains mostly function definitions.) When the
class’s suite finishes execution, its execution frame is discarded but its local namespace is saved.5 A class object is
then created using the inheritance list for the base classes and the saved local namespace for the attribute dictionary.
The class name is bound to this class object in the original local namespace.
The order in which attributes are defined in the class body is preserved in the new class’s __dict__. Note that this
is reliable only right after the class is created and only for classes that were defined using the definition syntax.
Class creation can be customized heavily using metaclasses.
Classes can also be decorated: just like when decorating functions,

@f1(arg)
@f2
class Foo: pass

is roughly equivalent to

class Foo: pass

Foo = f1(arg)(f2(Foo))

The evaluation rules for the decorator expressions are the same as for function decorators. The result is then bound
to the class name.
Alterado na versã o 3.9: Classes may be decorated with any valid assignment_expression. Previously, the
grammar was much more restrictive; see PEP 614 for details.
5 A string literal appearing as the first statement in the class body is transformed into the namespace’s __doc__ item and therefore the class’s

docstring.

132 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

A list of type parameters may be given in square brackets immediately after the class’s name. This indicates to
static type checkers that the class is generic. At runtime, the type parameters can be retrieved from the class’s
__type_params__ attribute. See Generic classes for more.

Alterado na versã o 3.12: Type parameter lists are new in Python 3.12.
Programmer’s note: Variables defined in the class definition are class attributes; they are shared by instances. Ins-
tance attributes can be set in a method with [Link] = value. Both class and instance attributes are accessible
through the notation “[Link]”, and an instance attribute hides a class attribute with the same name when ac-
cessed in this way. Class attributes can be used as defaults for instance attributes, but using mutable values there can
lead to unexpected results. Descriptors can be used to create instance variables with different implementation details.

µ Ver também

PEP 3115 - Metaclasses no Python 3000

The proposal that changed the declaration of metaclasses to the current syntax, and the semantics for how
classes with metaclasses are constructed.
PEP 3129 - Class Decorators
The proposal that added class decorators. Function and method decorators were introduced in PEP 318.

8.9 Corrotinas
Adicionado na versã o 3.5.

8.9.1 Definição de função de corrotina

async_funcdef ::= [decorators] "async" "def" funcname "(" [parameter_list] ")"

["->" expression] ":" suite
Execution of Python coroutines can be suspended and resumed at many points (see coroutine). await expressions,
async for and async with can only be used in the body of a coroutine function.
Functions defined with async def syntax are always coroutine functions, even if they do not contain await or
async keywords.

It is a SyntaxError to use a yield from expression inside the body of a coroutine function.
An example of a coroutine function:

async def func(param1, param2):

do_stuff()
await some_coroutine()

Alterado na versã o 3.7: await and async are now keywords; previously they were only treated as such inside the
body of a coroutine function.

8.9.2 The async for statement

async_for_stmt ::= "async" for_stmt

An asynchronous iterable provides an __aiter__ method that directly returns an asynchronous iterator, which can
call asynchronous code in its __anext__ method.
The async for statement allows convenient iteration over asynchronous iterables.
O seguinte có digo:

8.9. Corrotinas 133

The Python Language Reference, Release 3.13.0

async for TARGET in ITER:

SUITE
else:
SUITE2

Is semantically equivalent to:

iter = (ITER)
iter = type(iter).__aiter__(iter)
running = True

while running:
try:
TARGET = await type(iter).__anext__(iter)
except StopAsyncIteration:
running = False
else:
SUITE
else:
SUITE2

See also __aiter__() and __anext__() for details.

It is a SyntaxError to use an async for statement outside the body of a coroutine function.

8.9.3 The async with statement

async_with_stmt ::= "async" with_stmt

An asynchronous context manager is a context manager that is able to suspend execution in its enter and exit methods.
O seguinte có digo:

async with EXPRESSION as TARGET:

SUITE

é semanticamente equivalente a:

manager = (EXPRESSION)
aenter = type(manager).__aenter__
aexit = type(manager).__aexit__
value = await aenter(manager)
hit_except = False

try:
TARGET = value
SUITE
except:
hit_except = True
if not await aexit(manager, *sys.exc_info()):
raise
finally:
if not hit_except:
await aexit(manager, None, None, None)

See also __aenter__() and __aexit__() for details.

It is a SyntaxError to use an async with statement outside the body of a coroutine function.

134 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

µ Ver também

PEP 492 - Coroutines with async and await syntax

The proposal that made coroutines a proper standalone concept in Python, and added supporting syntax.

8.10 Type parameter lists

Adicionado na versã o 3.12.
Alterado na versã o 3.13: Support for default values was added (see PEP 696).

type_params ::= "[" type_param ("," type_param)* "]"

type_param ::= typevar | typevartuple | paramspec
typevar ::= identifier (":" expression)? ("=" expression)?
typevartuple ::= "*" identifier ("=" expression)?
paramspec ::= "**" identifier ("=" expression)?

Functions (including coroutines), classes and type aliases may contain a type parameter list:

def max[T](args: list[T]) -> T:

...

async def amax[T](args: list[T]) -> T:

...

class Bag[T]:
def __iter__(self) -> Iterator[T]:
...

def add(self, arg: T) -> None:

...

type ListOrSet[T] = list[T] | set[T]

Semantically, this indicates that the function, class, or type alias is generic over a type variable. This information is
primarily used by static type checkers, and at runtime, generic objects behave much like their non-generic counter-
parts.
Type parameters are declared in square brackets ([]) immediately after the name of the function, class, or type alias.
The type parameters are accessible within the scope of the generic object, but not elsewhere. Thus, after a declaration
def func[T](): pass, the name T is not available in the module scope. Below, the semantics of generic objects
are described with more precision. The scope of type parameters is modeled with a special function (technically, an
annotation scope) that wraps the creation of the generic object.
Generic functions, classes, and type aliases have a __type_params__ attribute listing their type parameters.
Type parameters come in three kinds:
• [Link], introduced by a plain name (e.g., T). Semantically, this represents a single type to a type
checker.
• [Link], introduced by a name prefixed with a single asterisk (e.g., *Ts). Semantically, this
stands for a tuple of any number of types.
• [Link], introduced by a name prefixed with two asterisks (e.g., **P). Semantically, this stands
for the parameters of a callable.
[Link] declarations can define bounds and constraints with a colon (:) followed by an expression. A
single expression after the colon indicates a bound (e.g. T: int). Semantically, this means that the typing.

8.10. Type parameter lists 135

The Python Language Reference, Release 3.13.0

TypeVar can only represent types that are a subtype of this bound. A parenthesized tuple of expressions after the
colon indicates a set of constraints (e.g. T: (str, bytes)). Each member of the tuple should be a type (again,
this is not enforced at runtime). Constrained type variables can only take on one of the types in the list of constraints.
For [Link] declared using the type parameter list syntax, the bound and constraints are not evaluated
when the generic object is created, but only when the value is explicitly accessed through the attributes __bound__
and __constraints__. To accomplish this, the bounds or constraints are evaluated in a separate annotation scope.
[Link] and [Link] cannot have bounds or constraints.

All three flavors of type parameters can also have a default value, which is used when the type parameter is not
explicitly provided. This is added by appending a single equals sign (=) followed by an expression. Like the bounds
and constraints of type variables, the default value is not evaluated when the object is created, but only when the type
parameter’s __default__ attribute is accessed. To this end, the default value is evaluated in a separate annotation
scope. If no default value is specified for a type parameter, the __default__ attribute is set to the special sentinel
object [Link].
The following example indicates the full set of allowed type parameter declarations:

def overly_generic[
SimpleTypeVar,
TypeVarWithDefault = int,
TypeVarWithBound: int,
TypeVarWithConstraints: (str, bytes),
*SimpleTypeVarTuple = (int, float),
**SimpleParamSpec = (str, bytearray),
](
a: SimpleTypeVar,
b: TypeVarWithDefault,
c: TypeVarWithBound,
d: Callable[SimpleParamSpec, TypeVarWithConstraints],
*e: SimpleTypeVarTuple,
): ...

8.10.1 Generic functions

Generic functions are declared as follows:

def func[T](arg: T): ...

This syntax is equivalent to:

annotation-def TYPE_PARAMS_OF_func():
T = [Link]("T")
def func(arg: T): ...
func.__type_params__ = (T,)
return func
func = TYPE_PARAMS_OF_func()

Here annotation-def indicates an annotation scope, which is not actually bound to any name at runtime. (One
other liberty is taken in the translation: the syntax does not go through attribute access on the typing module, but
creates an instance of [Link] directly.)
The annotations of generic functions are evaluated within the annotation scope used for declaring the type parameters,
but the function’s defaults and decorators are not.
The following example illustrates the scoping rules for these cases, as well as for additional flavors of type parameters:

@decorator
def func[T: int, *Ts, **P](*args: *Ts, arg: Callable[P, T] = some_default):
...

136 Capítulo 8. Instruções compostas

 The Python Language Reference, Release 3.13.0

Except for the lazy evaluation of the TypeVar bound, this is equivalent to:

DEFAULT_OF_arg = some_default

annotation-def TYPE_PARAMS_OF_func():

annotation-def BOUND_OF_T():
return int
# In reality, BOUND_OF_T() is evaluated only on demand.
T = [Link]("T", bound=BOUND_OF_T())

Ts = [Link]("Ts")
P = [Link]("P")

def func(*args: *Ts, arg: Callable[P, T] = DEFAULT_OF_arg):

...

func.__type_params__ = (T, Ts, P)

return func
func = decorator(TYPE_PARAMS_OF_func())

The capitalized names like DEFAULT_OF_arg are not actually bound at runtime.

8.10.2 Generic classes

Generic classes are declared as follows:

class Bag[T]: ...

This syntax is equivalent to:

annotation-def TYPE_PARAMS_OF_Bag():
T = [Link]("T")
class Bag([Link][T]):
__type_params__ = (T,)
...
return Bag
Bag = TYPE_PARAMS_OF_Bag()

Here again annotation-def (not a real keyword) indicates an annotation scope, and the name
TYPE_PARAMS_OF_Bag is not actually bound at runtime.

Generic classes implicitly inherit from [Link]. The base classes and keyword arguments of generic
classes are evaluated within the type scope for the type parameters, and decorators are evaluated outside that scope.
This is illustrated by this example:

@decorator
class Bag(Base[T], arg=T): ...

Isso equivale a:

annotation-def TYPE_PARAMS_OF_Bag():
T = [Link]("T")
class Bag(Base[T], [Link][T], arg=T):
__type_params__ = (T,)
...
return Bag
Bag = decorator(TYPE_PARAMS_OF_Bag())

8.10. Type parameter lists 137

The Python Language Reference, Release 3.13.0

8.10.3 Generic type aliases

The type statement can also be used to create a generic type alias:

type ListOrSet[T] = list[T] | set[T]

Except for the lazy evaluation of the value, this is equivalent to:

annotation-def TYPE_PARAMS_OF_ListOrSet():
T = [Link]("T")

annotation-def VALUE_OF_ListOrSet():
return list[T] | set[T]
# In reality, the value is lazily evaluated
return [Link]("ListOrSet", VALUE_OF_ListOrSet(), type_params=(T,
,→))

ListOrSet = TYPE_PARAMS_OF_ListOrSet()

Here, annotation-def (not a real keyword) indicates an annotation scope. The capitalized names like
TYPE_PARAMS_OF_ListOrSet are not actually bound at runtime.

138 Capítulo 8. Instruções compostas

 CAPÍTULO 9

Componentes de Alto Nível

O interpretador Python pode receber suas entradas de uma quantidade de fontes: de um script passado a ele como
entrada padrã o ou como um argumento do programa, digitado interativamente, de um arquivo fonte de um mó dulo,
etc. Este capítulo mostra a sintaxe usada nesses casos.

9.1 Programas Python completos

Ainda que uma especificaçã o de linguagem nã o precise prescrever como o interpretador da linguagem é invocado, é
ú til ter uma noçã o de um programa Python completo. Um programa Python completo é executado em um ambiente
minimamente inicializado: todos os mó dulos embutidos e padrõ es estã o disponíveis, mas nenhum foi inicializado,
exceto por sys (serviços de sistema diversos), builtins (funçõ es embutidas, exceçõ es e None) e __main__. O
ú ltimo é usado para fornecer o espaço de nomes global e local para execuçã o de um programa completo.
A sintaxe para um programa Python completo é esta para uma entrada de arquivo, descrita na pró xima seçã o.
O interpretador també m pode ser invocado no modo interativo; neste caso, ele nã o lê e executa um programa com-
pleto, mas lê e executa uma instruçã o (possivelmente composta) por vez. O ambiente inicial é idê ntico à quele de um
programa completo; cada instruçã o é executada no espaço de nomes de __main__.
Um programa completo pode ser passado ao interpretador de trê s formas: com a opçã o de linha de comando -c
string, como um arquivo passado como o primeiro argumento da linha de comando, ou como uma entrada padrã o.
Se o arquivo ou a entrada padrã o é um dispositivo tty, o interpretador entra em modo interativo; caso contrá rio, ele
executa o arquivo como um programa completo.

9.2 Entrada de arquivo

Toda entrada lida de arquivos nã o-interativos tê m a mesma forma:

file_input ::= (NEWLINE | statement)*

Essa sintaxe é usada nas seguintes situaçõ es:

• quando analisando um programa Python completo (a partir de um arquivo ou de uma string);
• quando analisando um mó dulo;
• quando analisando uma string passada à funçã o exec();

139
The Python Language Reference, Release 3.13.0

9.3 Entrada interativa

A entrada em modo interativo é analisada usando a seguinte gramá tica:

interactive_input ::= [stmt_list] NEWLINE | compound_stmt NEWLINE

Note que uma instruçã o composta (de alto-nível) deve ser seguida por uma linha em branco no modo interativo; isso
é necessá rio para ajudar o analisador sintá tico a detectar o fim da entrada.

9.4 Entrada de expressão

A funçã o eval() é usada para uma entrada de expressã o. Ela ignora espaços à esquerda. O argumento em string
para eval() deve ter a seguinte forma:

eval_input ::= expression_list NEWLINE*

140 Capítulo 9. Componentes de Alto Nível

 CAPÍTULO 10

Especificação Completa da Gramática

Esta é a gramá tica completa do Python, derivada diretamente da gramá tica usada para gerar o analisador sintá tico
de CPython (consulte Grammar/[Link]). A versã o aqui omite detalhes relacionados à geraçã o de có digo e
recuperaçã o de erros.
A notaçã o é uma mistura de EBNF e GASE (em inglê s, PEG). Em particular, & seguido por um símbolo, token
ou grupo entre parê nteses indica um “olhar a frente” positivo (ou seja, é necessá rio para corresponder, mas nã o
consumido), enquanto ! indica um “olhar a frente” negativo (ou seja, é necessá rio não combinar). Usamos o separador
| para significar a “escolha ordenada” do GASE (escrito como / nas gramá ticas GASE tradicionais). Veja PEP 617
para mais detalhes sobre a sintaxe da gramá tica.

# PEG grammar for Python

# ========================= START OF THE GRAMMAR =========================

# General grammatical elements and rules:

#
# * Strings with double quotes (") denote SOFT KEYWORDS
# * Strings with single quotes (') denote KEYWORDS
# * Upper case names (NAME) denote tokens in the Grammar/Tokens file
# * Rule names starting with "invalid_" are used for specialized syntax errors
# - These rules are NOT used in the first pass of the parser.
# - Only if the first pass fails to parse, a second pass including the invalid
# rules will be executed.
# - If the parser fails in the second phase with a generic syntax error, the
# location of the generic failure of the first pass will be used (this avoids
# reporting incorrect locations due to the invalid rules).
# - The order of the alternatives involving invalid rules matter
# (like any rule in PEG).
#
# Grammar Syntax (see PEP 617 for more information):
#
# rule_name: expression
# Optionally, a type can be included right after the rule name, which
# specifies the return type of the C or Python function corresponding to the
(continua na pró xima pá gina)

141
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

# rule:
# rule_name[return_type]: expression
# If the return type is omitted, then a void * is returned in C and an Any in
# Python.
# e1 e2
# Match e1, then match e2.
# e1 | e2
# Match e1 or e2.
# The first alternative can also appear on the line after the rule name for
# formatting purposes. In that case, a | must be used before the first
# alternative, like so:
# rule_name[return_type]:
# | first_alt
# | second_alt
# ( e )
# Match e (allows also to use other operators in the group like '(e)*')
# [ e ] or e?
# Optionally match e.
# e*
# Match zero or more occurrences of e.
# e+
# Match one or more occurrences of e.
# s.e+
# Match one or more occurrences of e, separated by s. The generated parse tree
# does not include the separator. This is otherwise identical to (e (s e)*).
# &e
# Succeed if e can be parsed, without consuming any input.
# !e
# Fail if e can be parsed, without consuming any input.
# ~
# Commit to the current alternative, even if it fails to parse.
# &&e
# Eager parse e. The parser will not backtrack and will immediately
# fail with SyntaxError if e cannot be parsed.
#

# STARTING RULES
# ==============

file: [statements] ENDMARKER

interactive: statement_newline
eval: expressions NEWLINE* ENDMARKER
func_type: '(' [type_expressions] ')' '->' expression NEWLINE* ENDMARKER

# GENERAL STATEMENTS
# ==================

statements: statement+

statement: compound_stmt | simple_stmts

statement_newline:
| compound_stmt NEWLINE
| simple_stmts
| NEWLINE
| ENDMARKER
(continua na pró xima pá gina)

142 Capítulo 10. Especificação Completa da Gramática

 The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

simple_stmts:
| simple_stmt !';' NEWLINE # Not needed, there for speedup
| ';'.simple_stmt+ [';'] NEWLINE

# NOTE: assignment MUST precede expression, else parsing a simple assignment

# will throw a SyntaxError.
simple_stmt:
| assignment
| type_alias
| star_expressions
| return_stmt
| import_stmt
| raise_stmt
| 'pass'
| del_stmt
| yield_stmt
| assert_stmt
| 'break'
| 'continue'
| global_stmt
| nonlocal_stmt

compound_stmt:
| function_def
| if_stmt
| class_def
| with_stmt
| for_stmt
| try_stmt
| while_stmt
| match_stmt

# SIMPLE STATEMENTS
# =================

# NOTE: annotated_rhs may start with 'yield'; yield_expr must start with 'yield'
assignment:
| NAME ':' expression ['=' annotated_rhs ]
| ('(' single_target ')'
| single_subscript_attribute_target) ':' expression ['=' annotated_rhs ]
| (star_targets '=' )+ (yield_expr | star_expressions) !'=' [TYPE_COMMENT]
| single_target augassign ~ (yield_expr | star_expressions)

annotated_rhs: yield_expr | star_expressions

augassign:
| '+='
| '-='
| '*='
| '@='
| '/='
| '%='
| '&='
| '|='
| '^='
(continua na pró xima pá gina)

143
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

| '<<='
| '>>='
| '**='
| '//='

return_stmt:
| 'return' [star_expressions]

raise_stmt:
| 'raise' expression ['from' expression ]
| 'raise'

global_stmt: 'global' ','.NAME+

nonlocal_stmt: 'nonlocal' ','.NAME+

del_stmt:
| 'del' del_targets &(';' | NEWLINE)

yield_stmt: yield_expr

assert_stmt: 'assert' expression [',' expression ]

import_stmt:
| import_name
| import_from

# Import statements
# -----------------

import_name: 'import' dotted_as_names

# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS
import_from:
| 'from' ('.' | '...')* dotted_name 'import' import_from_targets
| 'from' ('.' | '...')+ 'import' import_from_targets
import_from_targets:
| '(' import_from_as_names [','] ')'
| import_from_as_names !','
| '*'
import_from_as_names:
| ','.import_from_as_name+
import_from_as_name:
| NAME ['as' NAME ]
dotted_as_names:
| ','.dotted_as_name+
dotted_as_name:
| dotted_name ['as' NAME ]
dotted_name:
| dotted_name '.' NAME
| NAME

# COMPOUND STATEMENTS
# ===================

# Common elements
# ---------------
(continua na pró xima pá gina)

144 Capítulo 10. Especificação Completa da Gramática

 The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

block:
| NEWLINE INDENT statements DEDENT
| simple_stmts

decorators: ('@' named_expression NEWLINE )+

# Class definitions
# -----------------

class_def:
| decorators class_def_raw
| class_def_raw

class_def_raw:
| 'class' NAME [type_params] ['(' [arguments] ')' ] ':' block

# Function definitions
# --------------------

function_def:
| decorators function_def_raw
| function_def_raw

function_def_raw:
| 'def' NAME [type_params] '(' [params] ')' ['->' expression ] ':' [func_type_
,→comment] block

| 'async' 'def' NAME [type_params] '(' [params] ')' ['->' expression ] ':'␣
,→[func_type_comment] block

# Function parameters
# -------------------

params:
| parameters

parameters:
| slash_no_default param_no_default* param_with_default* [star_etc]
| slash_with_default param_with_default* [star_etc]
| param_no_default+ param_with_default* [star_etc]
| param_with_default+ [star_etc]
| star_etc

# Some duplication here because we can't write (',' | &')'),

# which is because we don't support empty alternatives (yet).

slash_no_default:
| param_no_default+ '/' ','
| param_no_default+ '/' &')'
slash_with_default:
| param_no_default* param_with_default+ '/' ','
| param_no_default* param_with_default+ '/' &')'

star_etc:
| '*' param_no_default param_maybe_default* [kwds]
| '*' param_no_default_star_annotation param_maybe_default* [kwds]
(continua na pró xima pá gina)

145
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

| '*' ',' param_maybe_default+ [kwds]
| kwds

kwds:
| '**' param_no_default

# One parameter. This *includes* a following comma and type comment.

#
# There are three styles:
# - No default
# - With default
# - Maybe with default
#
# There are two alternative forms of each, to deal with type comments:
# - Ends in a comma followed by an optional type comment
# - No comma, optional type comment, must be followed by close paren
# The latter form is for a final parameter without trailing comma.
#

param_no_default:
| param ',' TYPE_COMMENT?
| param TYPE_COMMENT? &')'
param_no_default_star_annotation:
| param_star_annotation ',' TYPE_COMMENT?
| param_star_annotation TYPE_COMMENT? &')'
param_with_default:
| param default ',' TYPE_COMMENT?
| param default TYPE_COMMENT? &')'
param_maybe_default:
| param default? ',' TYPE_COMMENT?
| param default? TYPE_COMMENT? &')'
param: NAME annotation?
param_star_annotation: NAME star_annotation
annotation: ':' expression
star_annotation: ':' star_expression
default: '=' expression | invalid_default

# If statement
# ------------

if_stmt:
| 'if' named_expression ':' block elif_stmt
| 'if' named_expression ':' block [else_block]
elif_stmt:
| 'elif' named_expression ':' block elif_stmt
| 'elif' named_expression ':' block [else_block]
else_block:
| 'else' ':' block

# While statement
# ---------------

while_stmt:
| 'while' named_expression ':' block [else_block]

# For statement
(continua na pró xima pá gina)

146 Capítulo 10. Especificação Completa da Gramática

 The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

# -------------

for_stmt:
| 'for' star_targets 'in' ~ star_expressions ':' [TYPE_COMMENT] block [else_
,→block]

| 'async' 'for' star_targets 'in' ~ star_expressions ':' [TYPE_COMMENT] block␣

,→[else_block]

# With statement
# --------------

with_stmt:
| 'with' '(' ','.with_item+ ','? ')' ':' [TYPE_COMMENT] block
| 'with' ','.with_item+ ':' [TYPE_COMMENT] block
| 'async' 'with' '(' ','.with_item+ ','? ')' ':' block
| 'async' 'with' ','.with_item+ ':' [TYPE_COMMENT] block

with_item:
| expression 'as' star_target &(',' | ')' | ':')
| expression

# Try statement
# -------------

try_stmt:
| 'try' ':' block finally_block
| 'try' ':' block except_block+ [else_block] [finally_block]
| 'try' ':' block except_star_block+ [else_block] [finally_block]

# Except statement
# ----------------

except_block:
| 'except' expression ['as' NAME ] ':' block
| 'except' ':' block
except_star_block:
| 'except' '*' expression ['as' NAME ] ':' block
finally_block:
| 'finally' ':' block

# Match statement
# ---------------

match_stmt:
| "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT

subject_expr:
| star_named_expression ',' star_named_expressions?
| named_expression

case_block:
| "case" patterns guard? ':' block

guard: 'if' named_expression

(continua na pró xima pá gina)

147
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

patterns:
| open_sequence_pattern
| pattern

pattern:
| as_pattern
| or_pattern

as_pattern:
| or_pattern 'as' pattern_capture_target

or_pattern:
| '|'.closed_pattern+

closed_pattern:
| literal_pattern
| capture_pattern
| wildcard_pattern
| value_pattern
| group_pattern
| sequence_pattern
| mapping_pattern
| class_pattern

# Literal patterns are used for equality and identity constraints

literal_pattern:
| signed_number !('+' | '-')
| complex_number
| strings
| 'None'
| 'True'
| 'False'

# Literal expressions are used to restrict permitted mapping pattern keys

literal_expr:
| signed_number !('+' | '-')
| complex_number
| strings
| 'None'
| 'True'
| 'False'

complex_number:
| signed_real_number '+' imaginary_number
| signed_real_number '-' imaginary_number

signed_number:
| NUMBER
| '-' NUMBER

signed_real_number:
| real_number
| '-' real_number

real_number:
| NUMBER
(continua na pró xima pá gina)

148 Capítulo 10. Especificação Completa da Gramática

 The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

imaginary_number:
| NUMBER

capture_pattern:
| pattern_capture_target

pattern_capture_target:
| !"_" NAME !('.' | '(' | '=')

wildcard_pattern:
| "_"

value_pattern:
| attr !('.' | '(' | '=')

attr:
| name_or_attr '.' NAME

name_or_attr:
| attr
| NAME

group_pattern:
| '(' pattern ')'

sequence_pattern:
| '[' maybe_sequence_pattern? ']'
| '(' open_sequence_pattern? ')'

open_sequence_pattern:
| maybe_star_pattern ',' maybe_sequence_pattern?

maybe_sequence_pattern:
| ','.maybe_star_pattern+ ','?

maybe_star_pattern:
| star_pattern
| pattern

star_pattern:
| '*' pattern_capture_target
| '*' wildcard_pattern

mapping_pattern:
| '{' '}'
| '{' double_star_pattern ','? '}'
| '{' items_pattern ',' double_star_pattern ','? '}'
| '{' items_pattern ','? '}'

items_pattern:
| ','.key_value_pattern+

key_value_pattern:
| (literal_expr | attr) ':' pattern

(continua na pró xima pá gina)

149
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

double_star_pattern:
| '**' pattern_capture_target

class_pattern:
| name_or_attr '(' ')'
| name_or_attr '(' positional_patterns ','? ')'
| name_or_attr '(' keyword_patterns ','? ')'
| name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'

positional_patterns:
| ','.pattern+

keyword_patterns:
| ','.keyword_pattern+

keyword_pattern:
| NAME '=' pattern

# Type statement
# ---------------

type_alias:
| "type" NAME [type_params] '=' expression

# Type parameter declaration

# --------------------------

type_params:
| invalid_type_params
| '[' type_param_seq ']'

type_param_seq: ','.type_param+ [',']

type_param:
| NAME [type_param_bound] [type_param_default]
| '*' NAME [type_param_starred_default]
| '**' NAME [type_param_default]

type_param_bound: ':' expression

type_param_default: '=' expression
type_param_starred_default: '=' star_expression

# EXPRESSIONS
# -----------

expressions:
| expression (',' expression )+ [',']
| expression ','
| expression

expression:
| disjunction 'if' disjunction 'else' expression
| disjunction
| lambdef

yield_expr:
(continua na pró xima pá gina)

150 Capítulo 10. Especificação Completa da Gramática

 The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

| 'yield' 'from' expression
| 'yield' [star_expressions]

star_expressions:
| star_expression (',' star_expression )+ [',']
| star_expression ','
| star_expression

star_expression:
| '*' bitwise_or
| expression

star_named_expressions: ','.star_named_expression+ [',']

star_named_expression:
| '*' bitwise_or
| named_expression

assignment_expression:
| NAME ':=' ~ expression

named_expression:
| assignment_expression
| expression !':='

disjunction:
| conjunction ('or' conjunction )+
| conjunction

conjunction:
| inversion ('and' inversion )+
| inversion

inversion:
| 'not' inversion
| comparison

# Comparison operators
# --------------------

comparison:
| bitwise_or compare_op_bitwise_or_pair+
| bitwise_or

compare_op_bitwise_or_pair:
| eq_bitwise_or
| noteq_bitwise_or
| lte_bitwise_or
| lt_bitwise_or
| gte_bitwise_or
| gt_bitwise_or
| notin_bitwise_or
| in_bitwise_or
| isnot_bitwise_or
| is_bitwise_or

(continua na pró xima pá gina)

151
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

eq_bitwise_or: '==' bitwise_or
noteq_bitwise_or:
| ('!=' ) bitwise_or
lte_bitwise_or: '<=' bitwise_or
lt_bitwise_or: '<' bitwise_or
gte_bitwise_or: '>=' bitwise_or
gt_bitwise_or: '>' bitwise_or
notin_bitwise_or: 'not' 'in' bitwise_or
in_bitwise_or: 'in' bitwise_or
isnot_bitwise_or: 'is' 'not' bitwise_or
is_bitwise_or: 'is' bitwise_or

# Bitwise operators
# -----------------

bitwise_or:
| bitwise_or '|' bitwise_xor
| bitwise_xor

bitwise_xor:
| bitwise_xor '^' bitwise_and
| bitwise_and

bitwise_and:
| bitwise_and '&' shift_expr
| shift_expr

shift_expr:
| shift_expr '<<' sum
| shift_expr '>>' sum
| sum

# Arithmetic operators
# --------------------

sum:
| sum '+' term
| sum '-' term
| term

term:
| term '*' factor
| term '/' factor
| term '//' factor
| term '%' factor
| term '@' factor
| factor

factor:
| '+' factor
| '-' factor
| '~' factor
| power

power:
| await_primary '**' factor
(continua na pró xima pá gina)

152 Capítulo 10. Especificação Completa da Gramática

 The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

| await_primary

# Primary elements
# ----------------

# Primary elements are things like "[Link]", "obj[something]",

,→"obj(something)", "obj" ...

await_primary:
| 'await' primary
| primary

primary:
| primary '.' NAME
| primary genexp
| primary '(' [arguments] ')'
| primary '[' slices ']'
| atom

slices:
| slice !','
| ','.(slice | starred_expression)+ [',']

slice:
| [expression] ':' [expression] [':' [expression] ]
| named_expression

atom:
| NAME
| 'True'
| 'False'
| 'None'
| strings
| NUMBER
| (tuple | group | genexp)
| (list | listcomp)
| (dict | set | dictcomp | setcomp)
| '...'

group:
| '(' (yield_expr | named_expression) ')'

# Lambda functions
# ----------------

lambdef:
| 'lambda' [lambda_params] ':' expression

lambda_params:
| lambda_parameters

# lambda_parameters etc. duplicates parameters but without annotations

# or type comments, and if there's no comma after a parameter, we expect
# a colon, not a close parenthesis. (For more, see parameters above.)
#
lambda_parameters:
(continua na pró xima pá gina)

153
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

| lambda_slash_no_default lambda_param_no_default* lambda_param_with_default*␣
,→[lambda_star_etc]

| lambda_slash_with_default lambda_param_with_default* [lambda_star_etc]

| lambda_param_no_default+ lambda_param_with_default* [lambda_star_etc]
| lambda_param_with_default+ [lambda_star_etc]
| lambda_star_etc

lambda_slash_no_default:
| lambda_param_no_default+ '/' ','
| lambda_param_no_default+ '/' &':'

lambda_slash_with_default:
| lambda_param_no_default* lambda_param_with_default+ '/' ','
| lambda_param_no_default* lambda_param_with_default+ '/' &':'

lambda_star_etc:
| '*' lambda_param_no_default lambda_param_maybe_default* [lambda_kwds]
| '*' ',' lambda_param_maybe_default+ [lambda_kwds]
| lambda_kwds

lambda_kwds:
| '**' lambda_param_no_default

lambda_param_no_default:
| lambda_param ','
| lambda_param &':'
lambda_param_with_default:
| lambda_param default ','
| lambda_param default &':'
lambda_param_maybe_default:
| lambda_param default? ','
| lambda_param default? &':'
lambda_param: NAME

# LITERALS
# ========

fstring_middle:
| fstring_replacement_field
| FSTRING_MIDDLE
fstring_replacement_field:
| '{' annotated_rhs '='? [fstring_conversion] [fstring_full_format_spec] '}'
fstring_conversion:
| "!" NAME
fstring_full_format_spec:
| ':' fstring_format_spec*
fstring_format_spec:
| FSTRING_MIDDLE
| fstring_replacement_field
fstring:
| FSTRING_START fstring_middle* FSTRING_END

string: STRING
strings: (fstring|string)+

list:
(continua na pró xima pá gina)

154 Capítulo 10. Especificação Completa da Gramática

 The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

| '[' [star_named_expressions] ']'

tuple:
| '(' [star_named_expression ',' [star_named_expressions] ] ')'

set: '{' star_named_expressions '}'

# Dicts
# -----

dict:
| '{' [double_starred_kvpairs] '}'

double_starred_kvpairs: ','.double_starred_kvpair+ [',']

double_starred_kvpair:
| '**' bitwise_or
| kvpair

kvpair: expression ':' expression

# Comprehensions & Generators

# ---------------------------

for_if_clauses:
| for_if_clause+

for_if_clause:
| 'async' 'for' star_targets 'in' ~ disjunction ('if' disjunction )*
| 'for' star_targets 'in' ~ disjunction ('if' disjunction )*

listcomp:
| '[' named_expression for_if_clauses ']'

setcomp:
| '{' named_expression for_if_clauses '}'

genexp:
| '(' ( assignment_expression | expression !':=') for_if_clauses ')'

dictcomp:
| '{' kvpair for_if_clauses '}'

# FUNCTION CALL ARGUMENTS

# =======================

arguments:
| args [','] &')'

args:
| ','.(starred_expression | ( assignment_expression | expression !':=') !'=')+␣
,→[',' kwargs ]

| kwargs

kwargs:
| ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
(continua na pró xima pá gina)

155
The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

| ','.kwarg_or_starred+
| ','.kwarg_or_double_starred+

starred_expression:
| '*' expression

kwarg_or_starred:
| NAME '=' expression
| starred_expression

kwarg_or_double_starred:
| NAME '=' expression
| '**' expression

# ASSIGNMENT TARGETS
# ==================

# Generic targets
# ---------------

# NOTE: star_targets may contain *bitwise_or, targets may not.

star_targets:
| star_target !','
| star_target (',' star_target )* [',']

star_targets_list_seq: ','.star_target+ [',']

star_targets_tuple_seq:
| star_target (',' star_target )+ [',']
| star_target ','

star_target:
| '*' (!'*' star_target)
| target_with_star_atom

target_with_star_atom:
| t_primary '.' NAME !t_lookahead
| t_primary '[' slices ']' !t_lookahead
| star_atom

star_atom:
| NAME
| '(' target_with_star_atom ')'
| '(' [star_targets_tuple_seq] ')'
| '[' [star_targets_list_seq] ']'

single_target:
| single_subscript_attribute_target
| NAME
| '(' single_target ')'

single_subscript_attribute_target:
| t_primary '.' NAME !t_lookahead
| t_primary '[' slices ']' !t_lookahead

t_primary:
(continua na pró xima pá gina)

156 Capítulo 10. Especificação Completa da Gramática

 The Python Language Reference, Release 3.13.0

(continuaçã o da pá gina anterior)

| t_primary '.' NAME &t_lookahead
| t_primary '[' slices ']' &t_lookahead
| t_primary genexp &t_lookahead
| t_primary '(' [arguments] ')' &t_lookahead
| atom &t_lookahead

t_lookahead: '(' | '[' | '.'

# Targets for del statements

# --------------------------

del_targets: ','.del_target+ [',']

del_target:
| t_primary '.' NAME !t_lookahead
| t_primary '[' slices ']' !t_lookahead
| del_t_atom

del_t_atom:
| NAME
| '(' del_target ')'
| '(' [del_targets] ')'
| '[' [del_targets] ']'

# TYPING ELEMENTS
# ---------------

# type_expressions allow */** but ignore them

type_expressions:
| ','.expression+ ',' '*' expression ',' '**' expression
| ','.expression+ ',' '*' expression
| ','.expression+ ',' '**' expression
| '*' expression ',' '**' expression
| '*' expression
| '**' expression
| ','.expression+

func_type_comment:
| NEWLINE TYPE_COMMENT &(NEWLINE INDENT) # Must be followed by indented block
| TYPE_COMMENT

# ========================= END OF THE GRAMMAR ===========================

# ========================= START OF INVALID RULES =======================

157
The Python Language Reference, Release 3.13.0

158 Capítulo 10. Especificação Completa da Gramática

 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 ou-
tras té cnicas, como hasattr(), seriam desajeitadas ou sutilmente erradas (por exemplo, com métodos mági-
cos). CBAs introduzem subclasses virtuais, classes que nã o herdam de uma classe mas ainda sã o reconhecidas
por isinstance() e issubclass(); veja a documentaçã o do mó dulo abc. Python vem com muitas CBAs
embutidas para estruturas de dados (no mó dulo [Link]), nú meros (no mó dulo numbers), fluxos
(no mó dulo io), localizadores e carregadores de importaçã o (no mó dulo [Link]). 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:

159
The Python Language Reference, 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 Chamadas 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 Identifica-
dores e palavras-chave, 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.

160 Apêndice A. Glossário

 The Python Language Reference, 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+'), [Link], [Link], e instâ ncias
de [Link] e [Link].
Veja també m arquivo texto para um objeto arquivo capaz de ler e gravar em objetos str.
referência emprestada
Na API C do Python, uma referê ncia emprestada é uma referê ncia a um objeto que nã o é dona da referê ncia.
Ela se torna um ponteiro solto se o objeto for destruído. Por exemplo, uma coleta de lixo pode remover a
ú ltima referência forte para o objeto e assim destruí-lo.
Chamar Py_INCREF() na referência emprestada é recomendado para convertê -lo, internamente, em uma
referência forte, exceto quando o objeto nã o pode ser destruído antes do ú ltimo uso da referê ncia emprestada.
A funçã o Py_NewRef() pode ser usada para criar uma nova referência forte.
objeto byte ou similar
Um objeto com suporte ao o bufferobjects e que pode exportar um buffer C contíguo. Isso inclui todos os
objetos bytes, bytearray e [Link], alé m de muitos objetos memoryview comuns. Objetos byte
ou similar podem ser usados para vá rias operaçõ es que funcionam com dados biná rios; isso inclui compactaçã o,
salvamento em um arquivo biná rio e envio por um soquete.
Algumas operaçõ es precisam que os dados biná rios sejam mutá veis. A documentaçã o geralmente se refere
a eles como “objetos byte ou similar para leitura e escrita”. Exemplos de objetos de buffer mutá vel incluem
bytearray e um memoryview de um bytearray. Outras operaçõ es exigem que os dados biná rios sejam
armazenados em objetos imutá veis (“objetos byte ou similar para somente leitura”); exemplos disso incluem
bytes e a memoryview de um objeto bytes.

bytecode
O có digo-fonte Python é compilado para bytecode, a representaçã o interna de um programa em Python no
interpretador CPython. O bytecode també m é mantido em cache em arquivos .pyc e .pyo, de forma que
executar um mesmo arquivo é mais rá pido na segunda vez (a recompilaçã o dos fontes para bytecode nã o é
necessá ria). Esta “linguagem intermediá ria” é adequada para execuçã o em uma máquina virtual, que executa
o có digo de má quina correspondente para cada bytecode. Tenha em mente que nã o se espera que bytecodes
sejam executados entre má quinas virtuais Python diferentes, nem que se mantenham está veis entre versõ es de
Python.
Uma lista de instruçõ es bytecode pode ser encontrada na documentaçã o para o mó dulo dis.
chamável
Um chamá vel é um objeto que pode ser chamado, possivelmente com um conjunto de argumentos (veja ar-
gumento), com a seguinte sintaxe:

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

161
The Python Language Reference, 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, [Link]., 3+1j. Para ter acesso aos equivalentes para nú meros complexos do mó dulo math,
utilize cmath. O uso de nú meros complexos é uma funcionalidade matemá tica bastante avançada. Se você
nã o sabe se irá precisar deles, é quase certo que você pode ignorá -los sem problemas.
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 [Link] específico e

acessadas por meio de objetos ContextVar. Veja també m variável de contexto.
• Um objeto [Link]. 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 [Link]. 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.

162 Apêndice A. Glossário

 The Python Language Reference, 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 [Link].
O termo “CPython” é usado quando necessá rio distinguir esta implementaçã o de outras como Jython ou
IronPython.
contexto atual
O contexto (objeto [Link]) 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: Implementando descritores 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 Sintaxe de criação de listas, conjuntos e dicionários.
visão de dicionário
Os objetos retornados por [Link](), [Link]() e [Link]() sã o chamados de visõ es de
dicioná rio. Eles fornecem uma visã o dinâ mica das entradas do dicioná rio, o que significa que quando o 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-

163
The Python Language Reference, Release 3.13.0

meira expressã o numa classe, funçã o ou mó dulo. Ainda que sejam ignoradas quando a suíte é executada, é
reconhecida pelo compilador que a coloca no atributo __doc__ da classe, funçã o ou mó dulo que a 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 [Link]() e [Link]() 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.

164 Apêndice A. Glossário

 The Python Language Reference, 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 Localizadores e carregadores 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 Definições
de função.
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 Definições de função.

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

165
The Python Language Reference, 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 [Link](), e a PEP
443.
tipo genérico
Um tipo que pode ser parametrizado; tipicamente uma classe contêiner tal como list ou dict. Usado para
dicas de tipo e anotações.
Para mais detalhes, veja tipo apelido gené rico, PEP 483, PEP 484, PEP 585, e o mó dulo typing.
GIL
Veja 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 Invalidação de bytecode em cache.
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

166 Apêndice A. Glossário

 The Python Language Reference, 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 [Link],
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 tut-interac.
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

167
The Python Language Reference, 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, [Link]() é usada para produzir uma chave de ordenaçã o que leva o locale
em consideraçã o para fins de ordenaçã o.
Uma porçã o de ferramentas no Python aceitam funçõ es chave para controlar como os elementos sã o orde-
nados ou agrupados. Algumas delas incluem min(), max(), sorted(), [Link](), [Link](),
[Link](), [Link]() e [Link]().
Há vá rias maneiras de se criar funçõ es chave. Por exemplo, o mé todo [Link]() pode servir como uma
funçã o chave para ordenaçõ es insensíveis à caixa. Alternativamente, uma funçã o chave ad-hoc pode ser cons-
truída a partir de uma expressã o lambda, como lambda r: (r[0], r[2]). Alé m disso, operator.
attrgetter(), [Link]() e [Link]() sã o trê s 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.

168 Apêndice A. Glossário

 The Python Language Reference, 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:
• Localizadores e carregadores
• [Link]
• 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.
[Link]() pode ser usado para obter a codificaçã o da localidade.
Veja també m tratador de erros e codificação do sistema de arquivos.
método mágico
Um sinô nimo informal para um método especial.
mapeamento
Um objeto contê iner que tem suporte a pesquisas de chave arbitrá ria e implementa os mé todos especificados nas
[Link] ou [Link] classes base abstratas. Exemplos
incluem dict, [Link], [Link] e [Link].
localizador de metacaminho
Um localizador retornado por uma busca de sys.meta_path. Localizadores de metacaminho sã o relaciona-
dos a, mas diferentes de, localizadores de entrada de caminho.
Veja [Link] 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 [Link].

169
The Python Language Reference, 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 [Link]() e
[Link](). 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 [Link] ou com
uma funçã o fá brica [Link](). As duas ú ltimas té cnicas també m adicionam alguns
mé todos extras, que podem nã o ser encontrados quando foi escrita manualmente, ou em tuplas nomeadas
embutidas.
espaço de nomes
O lugar em que uma variá vel é armazenada. Espaços de nomes sã o implementados como dicioná rios. 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 [Link]() sã o diferenciadas por seus espaços de nomes. Espaços de nomes
també m auxiliam na legibilidade e na manutenibilidade ao torar mais claro quais mó dulos implementam uma
funçã o. Escrever [Link]() ou [Link](), por exemplo, deixa claro que estas funçõ es sã o
implementadas pelos mó dulos random e itertools respectivamente.
pacote de espaço de nomes
Um pacote da PEP 420 que serve apenas como container para sub pacotes. Pacotes de espaços de nomes
podem nã o ter representaçã o física, e especificamente nã o sã o como um pacote regular porque eles nã o tem
um arquivo __init__.py.
Veja també m módulo.
escopo aninhado
A habilidade de referir-se a uma variá vel em uma definiçã o de fechamento. Por exemplo, uma funçã o definida
dentro de outra pode referenciar variá veis da funçã o externa. Perceba que escopos aninhados por padrã o
funcionam apenas por referê ncia e nã o por atribuiçã o. Variá veis locais podem ler e escrever no escopo mais
interno. De forma similar, variá veis globais podem ler e escrever para o espaço de nomes global. O nonlocal
permite escrita para escopos externos.
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.

170 Apêndice A. Glossário

 The Python Language Reference, 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
[Link], a seçã o Definições de função 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 [Link] 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.

171
The Python Language Reference, 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 [Link]. Um
objeto que suporta o protocolo [Link] pode ser convertido para um arquivo de caminho do sistema
str ou bytes, atravé s da chamada da funçã o [Link](); [Link]() e [Link]() podem
ser usadas para garantir um str ou bytes como resultado, respectivamente. Introduzido na PEP 519.
PEP
Proposta de melhoria do Python. Uma PEP é um documento de design que fornece informaçã o para a co-
munidade Python, ou descreve uma nova funcionalidade para o Python ou seus predecessores ou ambientes.
PEPs devem prover uma especificaçã o té cnica concisa e um racional para funcionalidades propostas.
PEPs tê m a intençã o de ser os mecanismos primá rios para propor novas funcionalidades significativas, para
coletar opiniõ es da comunidade sobre um problema, e para documentar as decisõ es de design que foram
adicionadas ao Python. O autor da PEP é responsá vel por construir um consenso dentro da comunidade e
documentar opiniõ es dissidentes.
Veja PEP 1.
porção
Um conjunto de arquivos em um ú nico diretó rio (possivelmente armazenado em um arquivo zip) que contri-
buem para um pacote de espaço de nomes, conforme definido em PEP 420.
argumento posicional
Veja argumento.
API provisória
Uma API provisó ria é uma API que foi deliberadamente excluída das bibliotecas padrõ es com compatibilidade
retroativa garantida. Enquanto mudanças maiores para tais interfaces nã o sã o esperadas, contanto que elas
sejam marcadas como provisó rias, mudanças retroativas incompatíveis (até e incluindo a remoçã o da interface)
podem ocorrer se consideradas necessá rias pelos desenvolvedores principais. Tais mudanças nã o serã o feitas
gratuitamente – elas irã o ocorrer apenas se sé rias falhas fundamentais forem descobertas, que foram esquecidas
anteriormente a inclusã o da API.
Mesmo para APIs provisó rias, mudanças retroativas incompatíveis sã o vistas como uma “soluçã o em ú ltimo
caso” - cada tentativa ainda será feita para encontrar uma resoluçã o retroativa compatível para quaisquer pro-
blemas encontrados.
Esse processo permite que a biblioteca padrã o continue a evoluir com o passar do tempo, sem se prender em
erros de design problemá ticos por períodos de tempo prolongados. Veja PEP 411 para mais detalhes.
pacote provisório
Veja API provisória.
Python 3000
Apelido para a linha de lançamento da versã o do Python 3.x (cunhada há muito tempo, quando o lançamento
da versã o 3 era algo em um futuro muito distante.) Esse termo possui a seguinte abreviaçã o: “Py3k”.
Pythônico
Uma ideia ou um pedaço de có digo que segue de perto 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:

172 Apêndice A. Glossário

 The Python Language Reference, 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'
>>> [Link].__qualname__
'[Link]'

Quando usado para se referir a mó dulos, o nome totalmente qualificado significa todo o caminho pontilhado
para o mó dulo, incluindo quaisquer pacotes pai, por exemplo: [Link]:

>>> import [Link]

>>> [Link].__name__
'[Link]'

contagem de referências
O nú mero de referê ncias a um objeto. Quando a contagem de referê ncias de um objeto cai para zero, ele é
desalocado. Alguns objetos sã o imortais e tê m contagens de referê ncias que nunca sã o modificadas e, portanto,
os objetos nunca sã o desalocados. A contagem de referê ncias geralmente nã o é visível para o có digo Python,
mas é um elemento-chave da implementaçã o do CPython. Os programadores podem chamar a funçã o 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 [Link] define uma interface mais rica que vai alé m
de apenas __getitem__() e __len__(), adicionando count(), index(), __contains__(), e
__reversed__(). Tipos que implementam essa interface podem ser explicitamente registrados usando
register(). Para mais documentaçã o sobre mé todos de sequê ncias em geral, veja Operaçõ es comuns de
sequê ncias.

173
The Python Language Reference, 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 Sintaxe de criação de listas, conjuntos e dicionários.
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 Nomes de métodos especiais.
instrução
Uma instruçã o é parte de uma suíte (um “bloco” de có digo). Uma instruçã o é ou uma expressão ou uma de
vá rias construçõ es com uma palavra reservada, tal como if , while ou for.
verificador de tipo estático
Uma ferramenta externa que lê o có digo Python e o analisa, procurando por problemas como tipos incorretos.
Consulte també m dicas de tipo e o mó dulo typing.
referência forte
Na API C do Python, uma referê ncia forte é uma referê ncia a um objeto que pertence ao có digo que conté m a
referê ncia. A referê ncia forte é obtida chamando Py_INCREF() quando a referê ncia é criada e liberada com
Py_DECREF() quando a referê ncia é excluída.

A funçã o Py_NewRef() pode ser usada para criar uma referê ncia forte para um objeto. Normalmente, a
funçã o Py_DECREF() deve ser chamada na referê ncia forte antes de sair do escopo da referê ncia forte, para
evitar o vazamento de uma referê ncia.
Veja també m referência emprestada.
codificador de texto
Uma string em Python é uma sequê ncia de pontos de có digo Unicode (no intervalo U+0000–U+10FFFF). Para
armazenar ou transferir uma string, ela precisa ser serializada como uma sequê ncia de bytes.
A serializaçã o de uma string em uma sequê ncia de bytes é conhecida como “codificaçã o” e a recriaçã o da string
a partir de uma sequê ncia de bytes é conhecida como “decodificaçã o”.
Há uma variedade de diferentes serializaçõ es de texto codecs, que sã o coletivamente chamadas de “codificaçõ es
de texto”.
arquivo texto
Um objeto arquivo apto a ler e escrever objetos str. Geralmente, um arquivo texto, na verdade, acessa um
fluxo de dados de bytes e captura o codificador de texto automaticamente. Exemplos de arquivos texto sã o:
arquivos abertos em modo texto ('r' or 'w'), [Link], [Link], e instâ ncias de [Link].
Veja també m arquivo binário para um objeto arquivo apto a ler e escrever objetos byte ou similar.
aspas triplas
Uma string que está definida com trê s ocorrê ncias de aspas duplas (”) ou apó strofos (‘). Enquanto elas nã o
fornecem nenhuma funcionalidade nã o disponível com strings de aspas simples, elas sã o ú teis para inú meras

174 Apêndice A. Glossário

 The Python Language Reference, 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 [Link]() para uso adicional.
anotação de variável
Uma anotação de uma variá vel ou um atributo de classe.
Ao fazer uma anotaçã o de uma variá vel ou um atributo de classe, a atribuiçã o é opcional:

class C:
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 instruções de atribuição anotado.

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.

175
The Python Language Reference, 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.

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

177
The Python Language Reference, Release 3.13.0

178 Apêndice B. Sobre esses documentos

 APÊNDICE C

História e Licença

C.1 História do software

O Python foi criado no início dos anos 1990 por Guido van Rossum na Stichting Mathematisch Centrum (CWI,
veja [Link] na Holanda como um sucessor de uma linguagem chamada ABC. Guido continua a ser o
principal autor de Python, embora inclua muitas contribuiçõ es de outros.
Em 1995, Guido continuou seu trabalho em Python na Corporaçã o para Iniciativas Nacionais de Pesquisa (CNRI,
veja [Link] em Reston, Virgínia, onde lançou vá rias versõ es do software.
Em maio de 2000, Guido e a equipe principal de desenvolvimento do Python mudaram-se para o [Link] para
formar a equipe BeOpen PythonLabs. Em outubro do mesmo ano, a equipe da PythonLabs mudou para a Digital
Creations (agora Zope Corporation; veja [Link] Em 2001, formou-se a Python Software Foundation
(PSF, veja [Link] uma organizaçã o sem fins lucrativos criada especificamente para possuir
propriedade intelectual relacionada a Python. A Zope Corporation é um membro patrocinador do PSF.
Todas as versõ es do Python sã o de có digo aberto (consulte [Link] para a definiçã o de có digo aberto).
Historicamente, a maioria, mas nã o todas, versõ es do Python també m sã o compatíveis com GPL; a tabela abaixo
resume os vá rios lançamentos.

Versão Derivada de Ano Proprietário Compatível com a GPL?

0.9.0 a 1.2 n/a 1991-1995 CWI sim
1.3 a 1.5.2 1.2 1995-1999 CNRI sim
1.6 1.5.2 2000 CNRI nã o
2.0 1.6 2000 [Link] nã o
1.6.1 1.6 2001 CNRI nã o
2.1 2.0+1.6.1 2001 PSF nã o
2.0.1 2.0+1.6.1 2001 PSF sim
2.1.1 2.1+2.0.1 2001 PSF sim
2.1.2 2.1.1 2002 PSF sim
2.1.3 2.1.2 2002 PSF sim
2.2 e acima 2.1.1 2001-agora PSF sim

® Nota

179
The Python Language Reference, 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

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

 The Python Language Reference, 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 [Link] PARA PYTHON 2.0

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

1. This LICENSE AGREEMENT is between [Link] ("BeOpen"), having an office at

160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization
("Licensee") accessing and otherwise using this software in source or binary
form and its associated documentation ("the Software").

2. Subject to the terms and conditions of this BeOpen Python License Agreement,
BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license
to reproduce, analyze, test, perform and/or display publicly, prepare derivative
works, distribute, and otherwise use the Software alone or in any derivative
version, provided, however, that the BeOpen Python License is retained in the
Software, alone or in any derivative version prepared by Licensee.

3. BeOpen is making the Software available to Licensee on an "AS IS" basis.

BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF
EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING,
MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF
ADVISED OF THE POSSIBILITY THEREOF.

5. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.

6. This License Agreement shall be governed by and interpreted in all respects

by the law of the State of California, excluding conflict of law provisions.
Nothing in this License Agreement shall be deemed to create any relationship of
agency, partnership, or joint venture between BeOpen and Licensee. This License
Agreement does not grant permission to use BeOpen trademarks or trade names in a
trademark sense to endorse or promote products or services of Licensee, or any
third party. As an exception, the "BeOpen Python" logos available at
[Link] may be used according to the permissions
granted on that web page.

7. By copying, installing or otherwise using the software, Licensee agrees to be

bound by the terms and conditions of this License Agreement.

C.2.3 CONTRATO DE LICENÇA DA CNRI PARA O PYTHON 1.6.1

1. This LICENSE AGREEMENT is between the Corporation for National Research
Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191
("CNRI"), and the Individual or Organization ("Licensee") accessing and
otherwise using Python 1.6.1 software in source or binary form and its
associated documentation.

(continua na pró xima pá gina)

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

The Python Language Reference, 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: [Link]

3. In the event Licensee prepares a derivative work that is based on or

incorporates Python 1.6.1 or any part thereof, and wants to make the derivative
work available to others as provided herein, then Licensee hereby agrees to
include in any such work a brief summary of the changes made to Python 1.6.1.

4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" basis. CNRI
MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,
BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE
THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

6. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.

7. This License Agreement shall be governed by the federal intellectual property

law of the United States, including without limitation the federal copyright
law, and, to the extent such U.S. federal law does not apply, by the law of the
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.

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

 The Python Language Reference, 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 [Link]
[Link]/~m-mat/MT/MT2002/[Link]. 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 183

The Python Language Reference, 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.

[Link]
email: m-mat @ [Link] (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, [Link]

Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the project nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
(continua na pró xima pá gina)

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

 The Python Language Reference, 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 [Link] e [Link] contê m o seguinte aviso:

Copyright 1996 by Sam Rushing

All Rights Reserved

Permission to use, copy, modify, and distribute this software and

its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of Sam
Rushing not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

C.3.4 Gerenciamento de cookies

O mó dulo [Link] conté m o seguinte aviso:

Copyright 2000 by Timothy O'Malley <timo@[Link]>

All Rights Reserved

Permission to use, copy, modify, and distribute this software

and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Timothy O'Malley not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.

Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
(continua na pró xima pá gina)

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

The Python Language Reference, 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
[Link]
[Link]

Copyright 2000, Mojam Media, Inc., all rights reserved.

Author: Skip Montanaro

Copyright 1999, Bioreason, Inc., all rights reserved.

Author: Andrew Dalke

Copyright 1995-1997, Automatrix, Inc., all rights reserved.

Author: Skip Montanaro

Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved.

Permission to use, copy, modify, and distribute this Python software and
its associated documentation for any purpose without fee is hereby
granted, provided that the above copyright notice appears in all copies,
and that both that copyright notice and this permission notice appear in
supporting documentation, and that the name of neither Automatrix,
Bioreason or Mojam Media be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.

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)

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

 The Python Language Reference, 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 [Link] conté m o seguinte aviso:
The XML-RPC client interface is

Copyright (c) 1999-2002 by Secret Labs AB

Copyright (c) 1999-2002 by Fredrik Lundh

By obtaining, using, and/or copying this software and/or its

associated documentation, you agree that you have read, understood,
and will comply with the following terms and conditions:

Permission to use, copy, modify, and distribute this software and

its associated documentation for any purpose and without fee is
hereby granted, provided that the above copyright notice appears in
all copies, and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Secret Labs AB or the author not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.

SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.

C.3.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 187

The Python Language Reference, 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@[Link]>

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
</MIT License>

Original location:
[Link]

(continua na pró xima pá gina)

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

 The Python Language Reference, 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 ([Link]

C.3.11 strtod e dtoa

O arquivo Python/dtoa.c, que fornece as funçõ es C dtoa e strtod para conversã o de duplas de C para e de strings,
é derivado do arquivo com o mesmo nome de David M. Gay, atualmente disponível em [Link]
web/20220517033456/[Link] O arquivo original, conforme recuperado em 16 de março
de 2009, conté m os seguintes avisos de direitos autorais e de licenciamento:

/****************************************************************
*
* The author of this software is David M. Gay.
*
* Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose without fee is hereby granted, provided that this entire notice
* is included in all copies of any software which is or includes a copy
* or modification of this software and in all copies of the supporting
* documentation for such software.
*
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
* OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
*
***************************************************************/

C.3.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
[Link]

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by

the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
(continua na pró xima pá gina)

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

The Python Language Reference, 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)

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

 The Python Language Reference, 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 191

The Python Language Reference, 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)

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

 The Python Language Reference, 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 193

The Python Language Reference, 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@[Link] madler@[Link]

C.3.16 cfuhash
A implementaçã o da tabela de hash usada pelo tracemalloc é baseada no projeto cfuhash:

Copyright (c) 2005 Don Owens

All rights reserved.

This code is released under the BSD license:

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.

* Neither the name of the author nor the names of its

contributors may be used to endorse or promote products derived
from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
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.

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

 The Python Language Reference, 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 [Link] e é distribuído sob a licença BSD de 3 clá usulas:

Copyright (c) 2013 W3C(R) (MIT, ERCIM, Keio, Beihang),

All Rights Reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

* Redistributions of works must retain the original copyright notice,

this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the original copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the W3C nor the names of its contributors may be
used to endorse or promote products derived from this work without
specific prior written permission.

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 195

The Python Language Reference, 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. [Link]

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be

included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

 The Python Language Reference, 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@[Link]>

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 197

The Python Language Reference, Release 3.13.0

198 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 [Link]. Todos os direitos reservados.
Copyright © 1995-2000 Corporation for National Research Initiatives. Todos os direitos reservados.
Copyright © 1991-1995 Stichting Mathematisch Centrum. Todos os direitos reservados.

Veja: História e Licença para informaçõ es completas de licença e permissõ es.

199
The Python Language Reference, Release 3.13.0

200 Apêndice D. Direitos autorais

 Índice

Não alfabético instrução import, 110

..., 159 na lista de alvo de atribuição, 102
reticências literais, 19 operador, 92
''' **
literal de string, 10 em chamadas de função, 90
' (aspas simples) em sintaxes de criação de dicionário,
literal de string, 10 82
! (exclamação) function definition, 131
em literal de string formatado, 12 operador, 91
- (menos) **=
operador binário, 93 atribuição aumentada, 104
operador unário, 92 *=
. (ponto) atribuição aumentada, 104
em literal númerico, 15 + (mais)
referência de atributo, 88 operador binário, 93
! patterns, 124 operador unário, 92
" (aspas duplas) +=
literal de string, 10 atribuição aumentada, 104
""" , (vírgula), 81
literal de string, 10 em sintaxes de criação de dicionário,
# (cerquilha) 82
comentário, 5 expressão, lista de, 82, 98, 105, 132
declaração de codificação de fatiamento, 89
código-fonte, 6 identificadores, lista de, 111, 112
% (porcentagem) instrução import, 109
operador, 92 lista de argumentos, 89
%= na lista de alvos, 102
atribuição aumentada, 104 parameter list, 130
& (e comercial) with statement, 120
operador, 93 / (barra)
&= function definition, 131
atribuição aumentada, 104 operador, 92
() (parênteses) //
chamada, 89 operador, 92
class definition, 132 //=
expressão geradora, 83 atribuição aumentada, 104
function definition, 130 /=
na lista de alvo de atribuição, 102 atribuição aumentada, 104
sintaxe de criação de tupla, 81 0b
* (asterisco) literal de inteiro, 15
em chamadas de função, 90 0o
em listas de expressões, 98 literal de inteiro, 15
function definition, 131 0x
literal de inteiro, 15

201
The Python Language Reference, Release 3.13.0

: (dois pontos) sequência de escape, 11

anotações de função, 131 \f
anotada, variável, 104 sequência de escape, 11
compound statement, 116, 117, 120, 121, 130, \N
132 sequência de escape, 11
em expressões de dicionário, 82 \n
em literal de string formatado, 12 sequência de escape, 11
expressão lambda, 98 \r
fatiamento, 89 sequência de escape, 11
:= (dois points igual), 97 \t
; (ponto e vírgula), 115 sequência de escape, 11
< (menor que) \U
operador, 94 sequência de escape, 11
<< \u
operador, 93 sequência de escape, 11
<<= \v
atribuição aumentada, 104 sequência de escape, 11
<= \x
operador, 94 sequência de escape, 11
!= ^ (circunflexo)
operador, 94 operador, 93
-= ^=
atribuição aumentada, 104 atribuição aumentada, 104
= (igual) _ (sublinhado)
atribuição, instrução de, 102 em literal númerico, 15
class definition, 46 _, identificadores, 9
em chamadas de função, 89 __, identificadores, 9
function definition, 130 __abs__() (método object), 54
para ajudar na depuração usando __add__() (método object), 52
literais de string, 12 __aenter__() (método object), 59
== __aexit__() (método object), 59
operador, 94 __aiter__() (método object), 59
-> __all__ (atributo opcional de módulo), 110
anotações de função, 131 __and__() (método object), 52
> (maior) __anext__() (método agen), 87
operador, 94 __anext__() (método object), 59
>= __annotations__ (atributo function), 23
operador, 94 __annotations__ (atributo module), 27
>> __annotations__ (atributo type), 29
operador, 93 __annotations__ (class attribute), 29
>>= __annotations__ (function attribute), 22
atribuição aumentada, 104 __annotations__ (module attribute), 25
>>>, 159 __await__() (método object), 57
@ (arroba) __bases__ (atributo type), 29
class definition, 132 __bases__ (class attribute), 29
function definition, 130 __bool__() (método object), 40
operador, 92 __bool__() (object method), 51
[] (colchetes) __buffer__() (método object), 56
expressão de lista, 82 __bytes__() (método object), 38
na lista de alvo de atribuição, 102 __cached__ (atributo module), 27
subscrição, 88 __cached__ (module attribute), 25
\ (contrabarra) __call__() (método object), 50
sequência de escape, 11 __call__() (método objeto), 91
\\ __cause__ (atributo de exceção), 107
sequência de escape, 11 __ceil__() (método object), 54
\a __class__ (atributo object), 30
sequência de escape, 11 __class__ (instance attribute), 30
\b __class__ (method cell), 47

202 Índice
 The Python Language Reference, Release 3.13.0

__class__ (module attribute), 42 __globals__ (atributo function), 22

__class_getitem__() (método de classe object), 49 __globals__ (function attribute), 22
__classcell__ (class namespace entry), 47 __gt__() (método object), 39
__closure__ (atributo de função), 22 __hash__() (método object), 40
__closure__ (atributo function), 22 __iadd__() (método object), 54
__code__ (atributo function), 23 __iand__() (método object), 54
__code__ (function attribute), 22 __ifloordiv__() (método object), 54
__complex__() (método object), 54 __ilshift__() (método object), 54
__contains__() (método object), 52 __imatmul__() (método object), 54
__context__ (atributo de exceção), 107 __imod__() (método object), 54
__debug__, 105 __imul__() (método object), 54
__defaults__ (atributo function), 23 __index__() (método object), 54
__defaults__ (function attribute), 22 __init__() (método object), 37
__del__() (método object), 37 __init_subclass__() (método de classe object), 45
__delattr__() (método object), 41 __instancecheck__() (método type), 48
__delete__() (método object), 43 __int__() (método object), 54
__delitem__() (método object), 52 __invert__() (método object), 54
__dict__ (atributo function), 23 __ior__() (método object), 54
__dict__ (atributo module), 28 __ipow__() (método object), 54
__dict__ (atributo object), 30 __irshift__() (método object), 54
__dict__ (atributo type), 29 __isub__() (método object), 54
__dict__ (class attribute), 29 __iter__() (método object), 52
__dict__ (function attribute), 22 __itruediv__() (método object), 54
__dict__ (instance attribute), 30 __ixor__() (método object), 54
__dict__ (module attribute), 28 __kwdefaults__ (atributo function), 23
__dir__ (module attribute), 42 __kwdefaults__ (function attribute), 22
__dir__() (método object), 41 __le__() (método object), 39
__divmod__() (método object), 52 __len__() (mapping object method), 41
__doc__ (atributo function), 23 __len__() (método object), 51
__doc__ (atributo method), 24 __length_hint__() (método object), 51
__doc__ (atributo module), 27 __loader__ (atributo module), 26
__doc__ (atributo type), 29 __loader__ (module attribute), 25
__doc__ (class attribute), 29 __lshift__() (método object), 52
__doc__ (function attribute), 22 __lt__() (método object), 39
__doc__ (method attribute), 23 __main__
__doc__ (module attribute), 25 módulo, 62, 139
__enter__() (método object), 55 __matmul__() (método object), 52
__eq__() (método object), 39 __missing__() (método object), 52
__exit__() (método object), 55 __mod__() (método object), 52
__file__ (atributo module), 27 __module__ (atributo function), 23
__file__ (module attribute), 25 __module__ (atributo method), 24
__firstlineno__ (atributo type), 29 __module__ (atributo type), 29
__firstlineno__ (class attribute), 29 __module__ (class attribute), 29
__float__() (método object), 54 __module__ (function attribute), 22
__floor__() (método object), 54 __module__ (method attribute), 23
__floordiv__() (método object), 52 __mro__ (atributo type), 29
__format__() (método object), 39 __mro_entries__() (método object), 46
__func__ (atributo method), 24 __mul__() (método object), 52
__func__ (method attribute), 23 __name__ (atributo function), 23
__future__, 165 __name__ (atributo method), 24
instrução future, 110 __name__ (atributo module), 26
__ge__() (método object), 39 __name__ (atributo type), 29
__get__() (método object), 42 __name__ (class attribute), 29
__getattr__ (module attribute), 42 __name__ (function attribute), 22
__getattr__() (método object), 41 __name__ (method attribute), 23
__getattribute__() (método object), 41 __name__ (module attribute), 25
__getitem__() (mapping object method), 36 __ne__() (método object), 39
__getitem__() (método object), 51 __neg__() (método object), 54

Índice 203
The Python Language Reference, Release 3.13.0

__new__() (método object), 37 expressão de dicionário, 82

__next__() (método generator), 84 | (barra vertical)
__objclass__ (atributo object), 43 operador, 93
__or__() (método object), 52 |=
__package__ (atributo module), 26 atribuição aumentada, 104
__package__ (module attribute), 25 ~ (til)
__path__ (atributo module), 27 operador, 92
__path__ (module attribute), 25
__pos__() (método object), 54 A
__pow__() (método object), 52 abs
__prepare__ (metaclass method), 47 função embutida, 54
__qualname__ (atributo function), 23 aclose() (método agen), 87
__qualname__ (atributo type), 29 adição, 93
__radd__() (método object), 53 agrupamento, 7
__rand__() (método object), 53 agrupamento de instruções, 7
__rdivmod__() (método object), 53 aguardável, 160
__release_buffer__() (método object), 56 alvo, 102
__repr__() (método object), 38 controle de laço, 108
__reversed__() (método object), 52 exclusão, 106
__rfloordiv__() (método object), 53 lista, 102, 116
__rlshift__() (método object), 53 lista atribuição, 102
__rmatmul__() (método object), 53 lista, exclusão, 106
__rmod__() (método object), 53 ambiente, 62
__rmul__() (método object), 53 ambiente virtual, 175
__ror__() (método object), 53 analisador sintático, 5
__round__() (método object), 54 análise léxica, 5
__rpow__() (método object), 53 and
__rrshift__() (método object), 53 bit a bit, 93
__rshift__() (método object), 52 operador, 97
__rsub__() (método object), 53 annotations
__rtruediv__() (método object), 53 função, 131
__rxor__() (método object), 53 anônima
__self__ (atributo method), 24 função, 98
__self__ (method attribute), 23 anotação, 159
__set__() (método object), 43 anotação de função, 165
__set_name__() (método object), 45 anotação de variável, 175
__setattr__() (método object), 41 anotada
__setitem__() (método object), 52 atribuição, 104
__slots__, 173 ao final
__spec__ (atributo module), 26 vírgula, 98
__spec__ (module attribute), 25 apelido de tipo, 175
__static_attributes__ (atributo type), 29 API provisória, 172
__static_attributes__ (class attribute), 29 argumento, 159
__str__() (método object), 38 função, 22
__sub__() (método object), 52 function definition, 130
__subclasscheck__() (método type), 48 semântica de chamadas, 89
__subclasses__() (método type), 30 argumento nomeado, 168
__traceback__ (atributo de exceção), 107 argumento posicional, 172
__truediv__() (método object), 52 aritmética
__trunc__() (método object), 54 conversão, 79
__type_params__ (atributo function), 23 operação, binário, 92
__type_params__ (atributo type), 29 operação, unária, 92
__type_params__ (class attribute), 29 arquivo binário, 161
__type_params__ (function attribute), 22 arquivo texto, 174
__xor__() (método object), 52 array
{} (chaves) módulo, 20
em literal de string formatado, 12 as
expressão de conjunto, 82 except clause, 117

204 Índice
 The Python Language Reference, Release 3.13.0

instrução import, 109 B

match statement, 121 b'
palavra reservada, 109, 117, 120, 121 literal de bytes, 10
with statement, 120 b"
AS pattern, OR pattern, capture pattern, literal de bytes, 10
wildcard pattern, 124 BDFL, 161
ASCII, 4, 10 binário
asend() (método agen), 87 aritmética operação, 92
aspas triplas, 174 bit a bit operação, 93
asserções bit a bit
depuração, 105 and, 93
assert operação, binário, 93
instrução, 105 operação, unária, 92
AssertionError or, 93
exceção, 105 xor, 93
async bloco, 61
palavra reservada, 133 código, 61
async def BNF, 4, 79
instrução, 133 Booleano
async for objeto, 19
em compreensões, 81 operação, 97
instrução, 133 break
async with instrução, 108, 116, 119
instrução, 134 builtins
athrow() (método agen), 87 módulo, 139
átomo, 79 byte, 20
atribuição bytearray, 21
alvo lista, 102 bytecode, 30, 161
anotada, 104 bytes, 20
atributo, 102 função embutida, 39
aumentada, 104
classe atributo, 28 C
expressão, 97
C, 11
fatiamento, 103
linguagem, 18, 19, 25, 94
instância de classe atributo, 30
caminho
instrução, 20, 102
ganchos, 70
subscrição, 103
caminho de importação, 167
atributo, 18, 160
caractere, 20, 88
atribuição, 102
caractere cerquilha, 5
atribuição, classe, 28
caractere contrabarra, 6
atribuição, instância de classe, 30
carregador, 69, 169
classe, 28
case
especial, 18
match, 121
exclusão, 106
palavra reservada, 121
generic especial, 18
case block, 123
instância de classe, 30
chamada, 89
referência, 88
definida por usuário função, 91
AttributeError
função, 22, 91
exceção, 88
função embutida, 91
aumentada
instância, 50, 91
atribuição, 104
instância de classe, 91
avaliação
método, 91
ordem, 98
método embutido, 91
await
objeto classe, 28, 91
em compreensões, 81
procedimento, 101
palavra reservada, 91, 133
chamável, 161
objeto, 22, 89
chave, 82

Índice 205
The Python Language Reference, Release 3.13.0

chr coleta de lixo, 17, 165

função embutida, 20 collections
classe, 161 módulo, 20
atributo, 28 comentário, 5
atributo atribuição, 28 comparação, 94
body, 47 comparações, 39
constructor, 37 encadeamento, 94
definição, 106, 132 compile
instância, 30 função embutida, 111
instrução, 132 complexo
nome, 132 função embutida, 54
objeto, 28, 91, 132 number, 20
classe base abstrata, 159 objeto, 20
classe estilo novo, 170 compound
clause, 115 instrução, 115
clear() (método frame), 35 compreensão de conjunto, 174
close() (método coroutine), 58 compreensão de dicionário, 163
close() (método generator), 85 compreensão de lista, 168
co_argcount (atributo codeobject), 32 compreensões, 81
co_argcount (atributo de objeto código), 31 dicionário, 82
co_cellvars (atributo codeobject), 32 lista, 82
co_cellvars (atributo de objeto código), 31 set, 82
co_code (atributo codeobject), 32 Condicional
co_code (atributo de objeto código), 31 expressão, 97
co_consts (atributo codeobject), 32 condicional
co_consts (atributo de objeto código), 31 expressão, 98
co_filename (atributo codeobject), 32 conjunto de caracteres do código-fonte, 6
co_filename (atributo de objeto código), 31 Consórcio Unicode, 10
co_firstlineno (atributo codeobject), 32 constante, 10
co_firstlineno (atributo de objeto código), 31 constructor
co_flags (atributo codeobject), 32 classe, 37
co_flags (atributo de objeto código), 31 contagem de referências, 173
co_freevars (atributo codeobject), 32 contêiner, 18, 28
co_freevars (atributo de objeto código), 31 contexto, 162
co_kwonlyargcount (atributo codeobject), 32 contexto atual, 163
co_kwonlyargcount (atributo de objeto código), 31 contíguo, 162
co_lines() (método codeobject), 33 contíguo C, 162
co_lnotab (atributo codeobject), 32 contíguo Fortran, 162
co_lnotab (atributo de objeto código), 31 continuação de linha, 6
co_name (atributo codeobject), 32 continue
co_name (atributo de objeto código), 31 instrução, 108, 116, 119
co_names (atributo codeobject), 32 controle de laço
co_names (atributo de objeto código), 31 alvo, 108
co_nlocals (atributo codeobject), 32 conversão
co_nlocals (atributo de objeto código), 31 aritmética, 79
co_positions() (método codeobject), 33 string, 39, 101
co_posonlyargcount (atributo codeobject), 32 corrotina, 57, 84, 162
co_posonlyargcount (atributo de objeto código), 31 função, 24
co_qualname (atributo codeobject), 32 CPython, 163
co_qualname (atributo de objeto código), 31
co_stacksize (atributo codeobject), 32 D
co_stacksize (atributo de objeto código), 31 dados, 17
co_varnames (atributo codeobject), 32 tipo, 18
co_varnames (atributo de objeto código), 31 tipo, imutável, 80
codificação da localidade, 169 dangling
codificador de texto, 174 else, 116
código [Link]
bloco, 61 módulo, 21

206 Índice
 The Python Language Reference, Release 3.13.0

[Link] método, 25
módulo, 21 encadeamento
declaração de codificação (arquivo fonte), 6 comparações, 94
decorador, 163 exceção, 107
def entrada, 140
instrução, 130 entrada de caminho, 171
default entrada padrão, 139
parâmetro value, 130 erros, 65
definição escopo, 61, 62
classe, 106, 132 escopo aninhado, 170
função, 106, 130 escopo otimizado, 170
definida por usuário escrita
função, 22 gravação;valores, 101
função chamada, 91 espaço, 7
método, 23 espaço de nomes, 61, 170
del global, 22
instrução, 37, 106 módulo, 25
delimitadores, 16 pacote, 68
depuração espaço em branco inicial, 7
asserções, 105 especial
descritor, 163 atributo, 18
desempacotamento atributo, generic, 18
dicionário, 82 método, 174
em chamadas de função, 90 especificação do módulo, 169
Iterável, 98 estrutura da linha, 5
desfiguração eval
nome, 80 função embutida, 111, 140
desligamento do interpretador, 167 exc_info (in module sys), 35
deslocamento exceção, 65, 107
operação, 93 AssertionError, 105
despacho único, 174 AttributeError, 88
destrutor, 37, 102 encadeamento, 107
desvinculação GeneratorExit, 85, 87
nome, 106 handler, 35
dica de tipo, 175 ImportError, 109
dicionário, 163 levantamento, 107
compreensões, 82 NameError, 80
objeto, 21, 28, 40, 82, 88, 103 StopAsyncIteration, 87
sintaxe de criação, 82 StopIteration, 84, 106
divisão, 92 TypeError, 92
divisão pelo piso, 165 ValueError, 93
divmod ZeroDivisionError, 92
função embutida, 53 except
docstring, 132, 163 palavra reservada, 117
except_star
E palavra reservada, 118
e exclusão
em literal númerico, 15 alvo, 106
EAFP, 164 alvo lista, 106
elif atributo, 106
palavra reservada, 116 exclusivo
Ellipsis or, 93
objeto, 19 exec
else função embutida, 111
dangling, 116 execução
expressão condicional, 98 quadro, 61, 132
palavra reservada, 108, 116, 117, 119 restrita, 64
embutido stack, 35

Índice 207
The Python Language Reference, Release 3.13.0

execução, modelo, 61 __str__() (object method), 38

expressão, 79, 164 from
atribuição, 97 instrução import, 61, 109
Condicional, 97 palavra reservada, 83, 109
condicional, 98 yield from expressão, 84
gerador, 83 frozenset
instrução, 101 objeto, 21
lambda, 98, 131 fstring, 12
lista, 98, 101 f-string, 12
yield, 83 função, 165
expressão de atribuição, 97 annotations, 131
expressão geradora, 166 anônima, 98
expressão nomeada, 97 argumento, 22
extension chamada, 22, 91
módulo, 18 chamada, definida por usuário, 91
definição, 106, 130
F definida por usuário, 22
f' gerador, 83, 106
literal de string formatado, 11 lambda, 98
f" nome, 130
literal de string formatado, 11 objeto, 22, 25, 91, 130
f-string, 164 função chave, 168
f_back (atributo frame), 34 função de corrotina, 163
f_back (frame attribute), 34 função de retorno, 161
f_builtins (atributo frame), 34 função definida por usuário
f_builtins (frame attribute), 34 objeto, 22, 91, 130
f_code (atributo frame), 34 função embutida
f_code (frame attribute), 34 abs, 54
f_globals (atributo frame), 34 bytes, 39
f_globals (frame attribute), 34 chamada, 91
f_lasti (atributo frame), 34 chr, 20
f_lasti (frame attribute), 34 compile, 111
f_lineno (atributo frame), 35 complexo, 54
f_lineno (frame attribute), 34 divmod, 53
f_locals (atributo frame), 34 eval, 111, 140
f_locals (frame attribute), 34 exec, 111
f_trace (atributo frame), 35 fatia, 36
f_trace (frame attribute), 34 hash, 40
f_trace_lines (atributo frame), 35 id, 17
f_trace_lines (frame attribute), 34 int, 54
f_trace_opcodes (atributo frame), 35 len, 20, 21, 51
f_trace_opcodes (frame attribute), 34 objeto, 25, 91
False, 19 open, 30
fatia, 89, 174 ord, 20
função embutida, 36 ponto flutuante, 54
objeto, 51 pow, 53
fatiamento, 20, 89 print, 39
atribuição, 103 range, 117
finalizer, 37 repr, 101
finally round, 55
palavra reservada, 106, 108, 117, 119 tipo, 17, 46
find_spec função genérica, 166
localizador, 70 future
for instrução, 110
em compreensões, 81
instrução, 108, 116 G
forma entre parênteses, 81 gancho de entrada de caminho, 171
format() (função embutida) ganchos

208 Índice
 The Python Language Reference, Release 3.13.0

caminho, 70 import
importação, 70 instrução, 109
meta, 70 importação, 167
ganchos de caminho, 70 ganchos, 70
ganchos de importação, 70 instrução, 25
GeneratorExit importador, 167
exceção, 85, 87 ImportError
generic exceção, 109
especial atributo, 18 imutável, 167
gerador, 165 dados tipo, 80
expressão, 83 objeto, 20, 80, 82
função, 24, 83, 106 in
iterador, 24, 106 operador, 96
objeto, 33, 83, 84 palavra reservada, 116
gerador assíncrono, 160 inclusive
função, 24 or, 93
iterador assíncrono, 24 indentação, 7
objeto, 86 index operation, 20
gerenciador de contexto, 55, 162 indices() (método slice), 36
gerenciador de contexto assíncrono, 160 inheritance, 132
GIL, 166 início (atributo de objeto fatia), 36
global instância
espaço de nomes, 22 chamada, 50, 91
instrução, 106, 111 classe, 30
nome vinculação; ligação, 111 objeto, 28, 30, 91
gramática, 4 instância de classe
gravação;valores atributo, 30
escrita, 101 atributo atribuição, 30
guard, 123 chamada, 91
objeto, 28, 30, 91
H instrução, 174
handler assert, 105
exceção, 35 async def, 133
hash async for, 133
função embutida, 40 async with, 134
hasheável, 82, 166 atribuição, 20, 102
hierarchy atribuição, anotada, 104
tipo, 18 aumentada, atribuição, 104
break, 108, 116, 119
I classe, 132
id compound, 115
função embutida, 17 continue, 108, 116, 119
identidade def, 130
teste, 96 del, 37, 106
identificador, 8, 80 expressão, 101
identity of an object, 17 for, 108, 116
IDLE, 167 future, 110
if global, 106, 111
em compreensões, 81 if, 116
expressão condicional, 98 import, 109
instrução, 116 importação, 25
palavra reservada, 121 laço, 108, 116
immutable object, 17 match, 121
immutable sequence nonlocal, 112
objeto, 20 pass, 105
immutable types raise, 107
subclassing, 37 return, 106, 119
imortal, 167 simples, 101

Índice 209
The Python Language Reference, Release 3.13.0

tipo, 112 vinculação, 102

try, 35, 117 linguagem
while, 108, 116 C, 18, 19, 25, 94
with, 55, 120 Java, 19
yield, 106 linha de comando, 139
int linha em branco, 6
função embutida, 54 linha física, 5, 6, 11
inteiro, 20 linha lógica, 5
objeto, 19 lista, 168
representation, 19 alvo, 102, 116
interativo, 167 atribuição, alvo, 102
internal type, 30 compreensões, 82
interpretado, 167 exclusão alvo, 106
interpretador, 139 expressão, 98, 101
inversão, 92 objeto, 21, 82, 88, 89, 103
invocation, 22 sintaxe de criação, 82
io vazia, 82
módulo, 30 literal, 10, 80
irrefutable case block, 123 literal de binário, 15
is literal de bytes, 10
operador, 96 literal de decimal, 15
is not literal de hexadecimal, 15
operador, 96 literal de inteiro, 15
item literal de número complexo, 15
sequência, 88 literal de número imaginário, 15
string, 88 literal de octal, 15
item selection, 20 literal de ponto flutuante, 15
iterador, 168 literal de string, 10
iterador assíncrono, 160 literal de string formatado, 12
iterador gerador, 166 literal de string interpolada, 12
iterador gerador assíncrono, 160 literal numérico, 15
Iterável livre
desempacotamento, 98 variável, 62
iterável, 167 localizador, 69, 165
iterável assíncrono, 160 find_spec, 70
localizador baseado no caminho, 74, 172
J localizador de entrada de caminho, 171
j localizador de metacaminho, 169
em literal númerico, 15
Java M
linguagem, 19 mágico
junção de linha, 5, 6 método, 169
mais, 92
L makefile() (socket method), 30
laço manipular uma exceção, 65
instrução, 108, 116 mapeamento, 169
lambda, 168 objeto, 21, 30, 88, 103
expressão, 98, 131 máquina virtual, 176
função, 98 maquinário de importação, 67
last_traceback (in module sys), 35 match
LBYL, 168 case, 121
len instrução, 121
função embutida, 20, 21, 51 menos, 92
levantamento meta
exceção, 107 ganchos, 70
levantar uma exceção, 65 metaclass hint, 46
léxicas, definições, 4 metaclasse, 46, 169
ligação;nome metaganchos, 70

210 Índice
 The Python Language Reference, Release 3.13.0

método, 169 operador, 97

chamada, 91 not in
definida por usuário, 23 operador, 96
embutido, 25 notação, 4
especial, 174 NotImplemented
mágico, 169 objeto, 18
objeto, 23, 25, 91 nova ligação;nome
método embutido nova vinculação, 102
chamada, 91 nova vinculação
objeto, 25, 91 nova ligação;nome, 102
método especial, 174 novas linhas universais, 175
método mágico, 169 null
modelo de terminação, 65 operação, 105
modo interativo, 139 number
módulo, 92, 169 complexo, 20
__main__, 62, 139 ponto flutuante, 19
array, 20 numérico
builtins, 139 objeto, 19, 30
collections, 20 número, 15
[Link], 21 número complexo, 162
[Link], 21
espaço de nomes, 25 O
extension, 18 object.__match_args__ (variável interna), 55
importação, 109 object.__slots__ (variável interna), 44
io, 30 objeto, 17, 170
objeto, 25, 88 Booleano, 19
sys, 118, 139 chamável, 22, 89
módulo de extensão, 164 classe, 28, 91, 132
módulo spec, 69 código, 30
MRO, 170 complexo, 20
mro() (método type), 29 dicionário, 21, 28, 40, 82, 88, 103
multiplicação, 92 Ellipsis, 19
multiplicação de matrizes, 92 fatia, 51
mutable object, 17 frozenset, 21
mutável, 170 função, 22, 25, 91, 130
objeto, 20, 102, 103 função definida por usuário, 22, 91, 130
função embutida, 25, 91
N gerador, 33, 83, 84
NameError gerador assíncrono, 86
exceção, 80 immutable sequence, 20
NameError (exceção embutida), 62 imutável, 20, 80, 82
negação, 92 instância, 28, 30, 91
nome, 8, 61, 80 instância de classe, 28, 30, 91
classe, 132 inteiro, 19
desfiguração, 80 lista, 21, 82, 88, 89, 103
desvinculação, 106 mapeamento, 21, 30, 88, 103
função, 130 método, 23, 25, 91
vinculação, 61, 130, 132 método embutido, 25, 91
vinculação; ligação, 109 módulo, 25, 88
vinculação; ligação, global, 111 mutável, 20, 102, 103
nome qualificado, 173 None, 18, 101
nomes NotImplemented, 18
privados, 80 numérico, 19, 30
None ponto flutuante, 19
objeto, 18, 101 quadro, 34
nonlocal sequência, 20, 30, 88, 89, 96, 103, 116
instrução, 112 sequência mutável, 20
not set, 21, 82

Índice 211
The Python Language Reference, Release 3.13.0

set type, 21 exclusivo, 93

string, 88, 89 inclusive, 93
traceback, 35, 107, 118 operador, 97
tupla, 20, 88, 89, 98 ord
user-defined method, 23 função embutida, 20
objeto arquivo, 164 ordem
objeto arquivo ou similar, 164 avaliação, 98
objeto byte ou similar, 161 ordem de resolução de métodos, 169
objeto caminho ou similar, 172 overloading
objeto classe operador, 36
chamada, 28, 91
objeto código, 30 P
open pacote, 68, 171
função embutida, 30 espaço de nomes, 68
operação porção, 68
binário aritmética, 92 regular, 68
binário bit a bit, 93 pacote de espaço de nomes, 170
Booleano, 97 pacote provisório, 172
deslocamento, 93 pacote regular, 173
null, 105 padrão
potência, 91 saída, 101
unária aritmética, 92 palavra reservada, 9
unária bit a bit, 92 as, 109, 117, 120, 121
operador async, 133
- (menos), 92, 93 await, 91, 133
% (porcentagem), 92 case, 121
& (e comercial), 93 elif, 116
* (asterisco), 92 else, 108, 116, 117, 119
**, 91 except, 117
+ (mais), 92, 93 except_star, 118
/ (barra), 92 finally, 106, 108, 117, 119
//, 92 from, 83, 109
< (menor que), 94 if, 121
<<, 93 in, 116
<=, 94 yield, 83
!=, 94 palavra reservada contextual, 9
==, 94 par chave/valor, 82
> (maior), 94 parâmetro, 171
>=, 94 function definition, 130
>>, 93 semântica de chamadas, 89
@ (arroba), 92 value, default, 130
^ (circunflexo), 93 pass
| (barra vertical), 93 instrução, 105
~ (til), 92 pattern matching, 121
and, 97 PEP, 172
in, 96 pertinência
is, 96 teste, 96
is not, 96 ponto flutuante
not, 97 função embutida, 54
not in, 96 number, 19
or, 97 objeto, 19
overloading, 36 popen() (in module os), 30
precedência, 99 porção, 172
ternário, 98 pacote, 68
operador morsa, 97 potência
operadores, 16 operação, 91
or pow
bit a bit, 93 função embutida, 53

212 Índice
 The Python Language Reference, Release 3.13.0

precedência PEP 688, 56

operador, 99 PEP 695, 63, 113
primário, 87 PEP 696, 63, 135
print PEP 703, 165, 166
função embutida, 39 PEP 3104, 112
print() (built-in function) PEP 3107, 131
__str__() (object method), 38 PEP 3115, 47, 133
privados PEP 3116, 175
nomes, 80 PEP 3119, 48
procedimento PEP 3120, 5
chamada, 101 PEP 3129, 132, 133
programa, 139 PEP 3131, 8
Propostas de Melhorias do Python PEP 3132, 104
PEP 1, 172 PEP 3135, 48
PEP 8, 95 PEP 3147, 27
PEP 236, 111 PEP 3155, 173
PEP 238, 165 protocolo de gerenciamento de contexto,
PEP 252, 43 162
PEP 255, 84 pyc baseado em hash, 166
PEP 278, 175 Python 3000, 172
PEP 302, 67, 78, 169 PYTHON_GIL, 166
PEP 308, 98 PYTHONHASHSEED, 40
PEP 318, 132, 133 Pythônico, 172
PEP 328, 78 PYTHONNODEBUGRANGES, 33
PEP 338, 78 PYTHONPATH, 75
PEP 342, 84
PEP 343, 55, 121, 162 Q
PEP 362, 160, 171 quadro
PEP 366, 26, 78 execução, 61, 132
PEP 380, 84 objeto, 34
PEP 411, 172
PEP 414, 11 R
PEP 420, 67, 69, 73, 78, 170, 172 r'
PEP 443, 166 literal de string bruta, 10
PEP 448, 82, 91, 98 r"
PEP 451, 78 literal de string bruta, 10
PEP 483, 166 raise
PEP 484, 48, 105, 131, 159, 165, 166, 175 instrução, 107
PEP 492, 58, 84, 135, 160, 162, 163 range
PEP 498, 14, 164 função embutida, 117
PEP 519, 172 reference counting, 17
PEP 525, 84, 160 referência
PEP 526, 105, 132, 159, 175 atributo, 88
PEP 530, 81 referência emprestada, 161
PEP 560, 46, 50 referência forte, 174
PEP 562, 42 regular
PEP 563, 111, 132 pacote, 68
PEP 570, 131 relativa
PEP 572, 83, 97, 125 import, 110
PEP 585, 166 REPL, 173
PEP 614, 130, 132 replace() (método codeobject), 34
PEP 617, 141 repr
PEP 626, 34 função embutida, 101
PEP 634, 56, 122, 130 repr() (built-in function)
PEP 636, 122, 130 __repr__() (object method), 38
PEP 646, 88, 98, 131 representation
PEP 649, 63 inteiro, 19
PEP 683, 167 restrita

Índice 213
The Python Language Reference, Release 3.13.0

execução, 64 string de documentação, 33

return string entre aspas triplas, 10
instrução, 106, 119 suavemente descontinuado, 174
round subclassing
função embutida, 55 immutable types, 37
subscrição, 20, 21, 88
S atribuição, 103
saída, 101 substração, 93
padrão, 101 suite, 115
send() (método coroutine), 58 sys
send() (método generator), 85 módulo, 118, 139
sequência, 173 sys.exc_info, 35
item, 88 [Link], 35
objeto, 20, 30, 88, 89, 96, 103, 116 sys.last_traceback, 35
sequência de escape, 11 sys.meta_path, 70
sequência de escape não reconhecida, 12 [Link], 69
sequência mutável [Link], 75
objeto, 20 sys.path_hooks, 75
set sys.path_importer_cache, 75
compreensões, 82 [Link], 30
objeto, 21, 82 [Link], 30
sintaxe de criação, 82 [Link], 30
set type SystemExit (exceção embutida), 65
objeto, 21
simples T
instrução, 101 tabulação, 7
singleton tb_frame (atributo traceback), 36
tupla, 20 tb_frame (traceback attribute), 35
sintaxe, 4 tb_lasti (atributo traceback), 36
sintaxe de criação tb_lasti (traceback attribute), 35
dicionário, 82 tb_lineno (atributo traceback), 36
lista, 82 tb_lineno (traceback attribute), 35
set, 82 tb_next (atributo traceback), 36
stack tb_next (traceback attribute), 36
execução, 35 ternário
trace, 35 operador, 98
Standard C, 11 teste
start (atributo de objeto fatia), 89 identidade, 96
stderr (in module sys), 30 pertinência, 96
stdin (in module sys), 30 threads livres, 165
stdio, 30 throw() (método coroutine), 58
stdout (in module sys), 30 throw() (método generator), 85
step (atributo de objeto fatia), 36, 89 tipagem pato, 164
stop (atributo de objeto fatia), 36, 89 tipo, 18, 175
StopAsyncIteration dados, 18
exceção, 87 função embutida, 17, 46
StopIteration hierarchy, 18
exceção, 84, 106 imutável dados, 80
string instrução, 112
__format__() (object method), 39 tipo genérico, 166
__str__() (object method), 38 token, 5
conversão, 39, 101 token DEDENT, 7, 116
immutable sequences, 20 token INDENT, 7
item, 88 token NEWLINE, 5, 116
literal formatado, 12 trace
literal interpolado, 12 stack, 35
objeto, 88, 89 traceback
string bruta, 10 objeto, 35, 107, 118

214 Índice
 The Python Language Reference, Release 3.13.0

tratador de erros e codificação do verificador de tipo estático, 174

sistema de arquivos, 164 vinculação
tratador de exceção, 65 ligação;nome, 102
tratamento de erros, 65 nome, 61, 130, 132
trava global do interpretador, 166 vinculação; ligação
True, 19 global nome, 111
try nome, 109
instrução, 35, 117 vírgula, 81
tupla ao final, 98
objeto, 20, 88, 89, 98 visão de dicionário, 163
singleton, 20
vazia, 81 W
vazio, 20 while
tupla nomeada, 170 instrução, 108, 116
type of an object, 17 Windows, 139
type parameters, 135 with
TypeError instrução, 55, 120
exceção, 92
types, internal, 30 X
xor
U bit a bit, 93
u'
literal de string, 10 Y
u" yield
literal de string, 10 exemplos, 85
unária expressão, 83
aritmética operação, 92 instrução, 106
bit a bit operação, 92 palavra reservada, 83
UnboundLocalError, 62
Unicode, 20 Z
UNIX, 139 Zen do Python, 176
unreachable object, 17 ZeroDivisionError
user-defined method exceção, 92
objeto, 23

V
valor, 82
value
default parâmetro, 130
value of an object, 17
ValueError
exceção, 93
variável
livre, 62
variável de ambiente
PYTHON_GIL, 166
PYTHONHASHSEED, 40
PYTHONNODEBUGRANGES, 33
PYTHONPATH, 75
variável de classe, 161
variável de clausura, 162
variável de contexto, 162
variável livre, 165
vazia
lista, 82
tupla, 81
vazio
tupla, 20

Índice 215