Python

Manual de Refer encia Python
Release 2.4.2
Guido van Rossum
Fred L. Drake, Jr., editor
Traduc ao: Python Brasil
23 de novembro de 2005
Python Software Foundation
Email: docs@python.org Python Brasil
http://pythonbrasil.com.br
Copyright c 2001-2004 Python Software Foundation. All rights reserved.
Copyright c 2000 BeOpen.com. All rights reserved.
Copyright c 1995-2000 Corporation for National Research Initiatives. All rights reserved.
Copyright c 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
Traduc ao: Pedro Werneck, Osvaldo Santana Neto, Jos e Alexandre Nalon, Felipe Lessa, Pedro de Medeiros, Rafael
Almeida, Renata Palazzo, Rodrigo Senra e outros.
Revis ao: Pedro Werneck, Osvaldo Santana Neto, Pedro de Medeiros.
Veja a parte nal deste documento para informac oes mais completas sobre licencas e permiss oes.
Resumo
Python e uma linguagem de alto nvel, orientada a objetos, de programac ao de alto nvel e de sem antica din amica.
Sua construc ao baseada em estruturas de dados de alto nvel, combinada com sua tipagem e ligac oes din amicas
tornam-a muito atraente tanto para o desenvolvimento r apido de aplicac oes quanto para criac ao de scripts ou
como linguagem para interligar componentes j a existentes. Python e simples, possui uma sintaxe f acil de aprender
que d a enfase ` a legibilidade, reduzindo o custo de manutenc ao do c odigo. Python suporta m odulos e pacotes, os
quais encorajam a modularizac ao e o reaproveitamento de c odigo. O interpretador Python e a extensa biblioteca
padr ao est ao disponveis na forma de c odigo fonte, e bin arios para as principais plataformas, e pode ser distribudo
livremente.
Este manual de refer encia descreve a sintaxe e a sem antica principal da linguagem.

E um resumo, mas tenta
ser exato e completo. A sem antica de objetos de tipo interno (built-in) e das func oes e m odulos s ao descritas na
Refer encia da Biblioteca Python. Para uma introduc ao informal ` a linguagem, veja o Tutorial Python. Para pro-
gramadores C ou C++ existem outros dois manuais adicionais: Extendendo e Embutindo o Interpretador Python
fornece um retrato de alto nvel sobre como escrever m odulos de extens ao para Python, e o Manual de Refer encia
da API Python/C que descreve em detalhes as interfaces disponveis para programadores C/C++.
SUM
ARIO
1 Introduc ao 1
1.1 Alternate Implementations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Notac ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 An alise l exica 3
2.1 Estrutura das linhas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Outros smbolos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Identicadores e keywords . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Literais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.5 Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.6 Delimitadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3 Modelo de Dados 13
3.1 Objetos, valores e tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2 A hierarquia padr ao de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3 Nomes de m etodos especiais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4 Modelo de execuc ao 33
4.1 Nomeando e ligando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.2 Excec oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5 Express oes 37
5.1 Convers oes Aritm eticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2

Atomos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3 Prim arias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.4 O operador de pot encia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.5 Unary arithmetic operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.6 Operac oes aritm eticas bin arias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.7 Operac oes de deslocamento (shifting) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.8 Operac oes bit-a-bit bin arias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.9 Binary bit-wise operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.10 Comparac oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.11 Operac oes Booleanas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.12 Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.13 Listas de express oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.14 Ordem de interpretac ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.15 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
6 Instruc oes simples 49
6.1 Express oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.2 Assertivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.3 Atribuic oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.4 O comando pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.5 O comando del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
i
6.6 O comando print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.7 O comando return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.8 O comando yield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.9 O comando raise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.10 O comando break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.11 O comando continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.12 O comando import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.13 O comando global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.14 O comando exec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7 Instruc oes compostas 59
7.1 O comando if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.2 O comando while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.3 O comando for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.4 O comando try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7.5 Denic ao de func oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
7.6 Denic ao de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8 Componentes de alto-nvel 65
8.1 Programas Python completos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
8.2 Arquivo como entrada de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
8.3 Entrada de dados interativa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
8.4 Express oes como entrada de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
A Hist orico e Licencas 67
A.1 History of the software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
A.2 Terms and conditions for accessing or otherwise using Python . . . . . . . . . . . . . . . . . . . 68
A.3 Licenses and Acknowledgements for Incorporated Software . . . . . . . . . . . . . . . . . . . . 70
Indice Remissivo 79
ii
CAP
ITULO
ONE
Introduc ao
Este manual de refer encia descreve a linguagem de programac ao Python. Ele n ao tem a intenc ao de servir como
um tutorial.
Tentarei ser o mais preciso possvel, no entanto escolhi o uso do Portugu es no lugar de uma especicac ao formal
para tudo, exceto para sintaxe e analise l exica. Isso deixar a o documento mais compreensvel para a maioria dos
leitores, mas deixar a brechas para ambig uidades. Consequentemente, se voc e veio de Marte e tentar reimplemen-
tar a linguagem apenas com esse documento, provavelmente implementar a uma linguagem um pouco diferente.
Por outro lado, se voc e est a usando Python e quer saber com precis ao as regras sobre uma area da linguagem
em particular, provavelmente voc e conseguir a encontr a-las aqui. Se deseja ver uma denic ao mais formal da
linguagem, talvez voc e possa se voluntariar para a tarefa ou inventar uma m aquina de clonagem :-).
E perigoso colocar muitos detalhes de implementac ao num documento de refer encia de uma linguagem a
implementac ao pode mudar, e outras implementac oes da mesma linguagempodemfuncionar de maneira diferente.
Por outro lado, como existe apenas uma implementac ao de Python usada em grande escala (apesar de j a existirem
implementac oes alternativas), e importante mencionar suas peculiaridades, especialmente onde a implementac ao
imp oe limitac oes adicionais. Portanto, voc e encontrar a algumas pequenas notas de implementac ao espalhadas
pelo texto.
Todas as implementac oes de Python vem com um certo n umero de m odulos internos (built-in) e m odulos padr ao.
Esses m odulos n ao ser ao documentados aqui, mas sim no documento Refer encia da Biblioteca Python. Alguns
poucos m odulos ser ao mencionados quando eles interagirem com a denic ao da linguagem de modo signicativo.
1.1 Alternate Implementations
Though there is one Python implementation which is by far the most popular, there are some alternate implemen-
tations which are of particular interest to different audiences.
Known implementations include:
CPython This is the original and most-maintained implementation of Python, written in C. New language features
generally appear here rst.
Jython Python implemented in Java. This implementation can be used as a scripting language for Java applications,
or can be used to create applications using the Java class libraries. It is also often used to create tests for
Java libraries. More information can be found at the Jython website.
Python for .NET This implementation actually uses the CPython implementation, but is a managed .NET application and
makes .NET libraries available. This was created by Brian Lloyd. For more information, see the Python for
.NET home page.
IronPython An alternate Python for .NET. Unlike Python.NET, this is a complete Python implementation that generates
IL, and compiles Python code directly to .NET assemblies. It was created by Jim Hugunin, the original
creator of Jython. For more information, see the IronPython website.
PyPy An implementation of Python written in Python; even the bytecode interpreter is written in Python. This
is executed using CPython as the underlying interpreter. One of the goals of the project is to encourage
1
experimentation with the language itself by making it easier to modify the interpreter (since it is written in
Python). Additional information is available on the PyPy projects home page.
Each of these implementations varies in some way from the language as documented in this manual, or intro-
duces specic information beyond whats covered in the standard Python documentation. Please refer to the
implementation-specic documentation to determine what else you need to know about the specic implementa-
tion youre using.
1.2 Notac ao
As descric oes do analisador l exico e de sintaxe usam uma notac ao gramatical BNF modicada. Elas usam o
seguinte estilo de denic ao:
nome: lc_letra (lc_letra | "_")*
lc_letra: "a"..."z"
A primeira linha diz que um nome e um lc_letra seguido de uma sequencia com zero ou mais lc_letra
e sublinhados. Um lc_letra por sua vez e qualquer caracter entre a e z. (Esta regra e na verdade seguida
para nomes denidos nas denic oes l exicas e gramaticais neste documento.)
Cada regra comeca com um nome (o qual e o nome denido pela regra) e um sinal ::=. Uma barra vertical (|) e
usada para separar alternativas; este e o menor operador de conex ao nesta notac ao. Um asterisco (*) signica zero
ou mais repetic oes do item precedente; assim como, um sinal de adic ao (+) representa uma ou mais repetic oes, e
um elemento dentro de colchetes ([ ]) signica zero ou uma ocorr encia (em outras palavras, o elemento interno
e opcional). Os operadores * e + conectam da forma mais forte possvel; parenteses s ao usados para agrupamento.
Strings literais s ao denidas entre aspas-duplas. Espacos em branco s ao usados com a intenc ao de separar tokens
(elemento l exico). Regras s ao geralmente denidas em apenas uma linha; regras com muitas alternativas podem
ser formatadas com cada linha iniciando com uma barra vertical.
Nas denic oes l exicas (como no exemplo acima), duas outras convenc oes s ao usadas: dois caracteres literais
separados por tr es pontos signicam a escolha de qualquer caracter na faixa especicada (inclusive) dos caracteres
ASCII. Um elemento entre os sinais de menor e maior (<...>) fornece uma descric ao informal do smbolo
denido; ex., pode ser usado para descrever o conceito de caracter de controle se necess ario.
Mesmo a notac ao utilizada sendo quase sempre a mesma, existe uma grande diferenca entre o signicado das
denic oes l exica e sint atica: uma denic ao l exica opera em caracteres individuais de uma fonte de entrada,
enquanto a denic ao da sintaxe opera sobre um uxo de tokens gerados por um analisador l exico. Todos os
usos de BNF no pr oximo captulo (An alise L exica) s ao denic oes l exicas; usos nos captulos subseq uentes s ao
denic oes sint aticas.
2 Captulo 1. Introduc ao
CAP
ITULO
TWO
An alise l exica
Um programa em Python e lido por um parser. A entrada de dados do parser e uma sequ encia de tokens, gerados
pelo analisador l exico. Este captulo descreve como essa an alise divide o conte udo de um arquivo em tokens.
Python usa o conjunto de caracteres de 7 bits ASCII para o texto de um programa. New in version 2.3: Uma
declarac ao de p agina de c odigo pode ser usada para indicar que as strings literais e os coment arios usam um
c odigo diferente de ASCII.. Por quest oes de compatibilidade com vers oes anteriores, o interpretador Python vai
avisar apenas se encontrar caracteres de 8 bits; pode-se corrigir o problema declarando explicitamente a p agina de
c odigo usada ou usando sequ encias de escape, se aqueles bytes forem dados bin arios ao inv es de caracteres.
O conjunto de caracteres usado durante a execuc ao depende dos dispositivos de entrada e sada conectados ao
programa, mas geralmente e um subgrupo de ASCII.
Nota de compatibilidade futura: Pode ser tentador assumir que o conjunto de caracteres usado para caracteres
de 8 bits e o ISO Latin-1 (um subgrupo do ASCIIque cobre a maioria dos idiomas ocidentais que utilizam o
alfabeto latino), mas e possvel que no futuro os editores de texto que usem Unicode se tornem mais populares.
Normalmente, esses editores utilizam o UTF-8, que e tamb em um subgrupo de ASCII, mas que usa de forma
diferente os caracteres com c odigo de 128 a 255. Apesar de ainda n ao haver nenhum consenso nesse assunto, n ao
e recomend avel assumir que qualquer um dos dois ser a o dominante, ainda que a implementac ao atual favoreca o
Latin-1. Isto se aplica tanto aos caracteres usados no c odigo-fonte quanto aos utilizados durante a execuc ao.
2.1 Estrutura das linhas
Um programa em Python e dividido em um conjunto de linhas l ogicas.
2.1.1 Linhas l ogicas
O m de uma linha l ogica e representado pelo smbolo (token) NEWLINE. Comandos (statements) n ao podem
ultrapassar os limites da linha l ogica exceto quando uma nova linha e permitida pela sintaxe (por exemplo, entre
comandos em um comando composto). Uma linha l ogica e construda de uma ou mais linhas fsicas, seguindo as
regras implcitas ou explcitas de uni ao de linhas.
2.1.2 Linhas fsicas
A physical line is a sequence of characters terminated by an end-of-line sequence. In source les, any of the
standard platform line termination sequences can be used - the UNIXform using ASCII LF (linefeed), the Windows
form using the ASCII sequence CR LF (return followed by linefeed), or the Macintosh form using the ASCII CR
(return) character. All of these forms can be used equally, regardless of platform.
When embedding Python, source code strings should be passed to Python APIs using the standard C conventions
for newline characters (the \n character, representing ASCII LF, is the line terminator).
3
2.1.3 Coment arios
Coment arios iniciam com uma tralha (#) que n ao seja parte de uma string literal e terminam no m da linha fsica.
Um coment ario signica o m da linha l ogica a menos que as regras implcitas de uni ao de linhas sejam usadas.
Coment arios s ao ignorados pela sintaxe; eles n ao s ao tokens.
2.1.4 Declarac oes de p agina de c odigo
Se um coment ario na primeira ou segunda linha de um arquivo de c odigo Python coincidir com a express ao regular
denida por

coding[=:]\s*([-\w.]+), este coment ario e processado como uma declarac ao de c odigo de
caracteres: o primeiro grupo da express ao e o nome da p agina de c odigo. As formas recomendadas s ao
# -*- coding: <nome-do-codigo> -*-
Que tamb em e reconhecido pelo GNU Emacs, e:
# vim:fileencoding=<nome-do-codigo>
Que e reconhecido pelo VIM. Al em disso, se os primeiros bytes do arquivo s ao (\xef\xbb\xbf), o c odigo
usado e UTF-8 (isso e reconhecido pelo bloco de notas, do Microsoft Windows, entre outros editores)
Se uma p agina de c odigo for declarada, o nome tem de ser reconhecido pelo interpretador. A p agina de c odigo
e usada para toda e qualquer an alise l exica, em especial para encontrar o m de uma string, e para interpretar o
conte udo de strings literais. Strings literais s ao convertidas para Unicode antes de serem analisadas, e s ao ent ao
convertidas de volta para o c odigo original antes do interpretador comecar a execuc ao. A declarac ao de p agina de
c odigo tem de aparecer sozinha na linha.
2.1.5 Uni ao Explcita de linhas
Duas ou mais linhas fsicas podem ser unidas em linhas l ogicas usando barras invertidas (\) da seguinte forma:
quando uma linha fsica termina em uma barra invertida que n ao e parte de uma string literal ou um coment ario,
ela e unida com a linha seguinte, formando uma unica linha l ogica, sem a barra e o caracter de nova linha a seguir.
Por exemplo:
if 1900 < ano < 2100 and 1 <= mes <= 12 \
and 1 <= dia <= 31 and 0 <= hora < 24 \
and 0 <= minuto < 60 and 0 <= segundo < 60: # Parece ser uma data valida
return 1
Uma linha terminando em barra invertida n ao pode conter coment arios. Barras invertidas n ao continuam co-
ment arios. Eles n ao continuam quaisquer elementos, exceto strings literais (ou seja, elementos outros que strings
n ao podem ser divididos em v arias linhas usando barras invertidas). Uma barra invertida e ilegal em qualquer
outro lugar que n ao seja uma string literal.
2.1.6 Uni ao Implcita de linhas
Express oes em par enteses, colchetes ou chaves, podem ser divididas em mais de uma linha, sem usar a barra
invertida. Exemplo:
4 Captulo 2. An alise l exica
nomes_de_meses = [Januari, Februari, Maart, # Estes sao os nomes
April, Mei, Juni, # holandeses para os
Juli, Augustus, September, # meses do ano
Oktober, November, December]
Linhas continuadas explicitamente podem conter coment arios. A indentac ao da linha de continuac ao n ao e im-
portante. Linhas em branco s ao permitidas. N ao h a qualquer caracter de NEWLINE entre linhas continuadas
implicitamente. Elas tamb em podem ocorrer em strings com tr es aspas (abaixo); neste caso, n ao podem conter
coment arios.
2.1.7 Linhas em Branco
Uma linha l ogica que contenha apenas espacos, tabulac oes, par agrafos e possivelmente um coment ario, e ignorada
(ou seja, n ao e gerado uma NEWLINE). Durante o uso do interpretador interativo, o manuseio de linhas em
branco pode diferir dependendo da implementac ao do interpretador. Na implementac ao padr ao, uma linha l ogica
completamente em branco (isto e, que n ao tenha nem mesmo espacos ou coment arios) nalizam um comando
multi-linhas.
2.1.8 Indentac ao
Espacos em branco (ou tabulac oes) no incio de uma linha l ogica e usado para computar o nvel de indentac ao da
linha, que por sua vez e usado para determinar o agrupamento de comandos.
Primeiro, tabulac oes s ao substitudas (da esquerda pra direita) por um n umero de espacos que pode variar de um
a oito, de forma que o total de caracteres seja sempre um m ultiplo de oito (a mesma regra usada por sistemas
UNIX). O n umero total de espacos precedendo o primeiro caracter v alido determina o nvel de indentac ao da
linha. A indentac ao n ao pode ser dividida em v arias linhas fsicas usando barras invertidas; os espacos em branco
at e a primeira barra invertida determinam o nvel de indentac ao.
nota: n ao e muito aconselh avel misturar espacos e tabulac oes usados como indentac ao em um unico arquivo de
c odigo fonte. Tamb em deve-se notar que diferentes plataformas podem limitar explicitamente o nvel m aximo de
indentac ao.
Um caracter formfeed pode estar presente no comeco da linha; ele ser a ignorado para o c alculo de indentac ao
descrito acima. Quando ocorrem em qualquer outro ponto dos espacos precedendo a linha, t em efeito indenido
(por exemplo, podem zerar a contagem de espacos).
O nvel de indentac ao de linhas consecutivas e usado para gerar tokens INDENT e DEDENT, usando uma pilha,
da seguinte forma:
Antes de ler a primeira linha do arquivo, um zero e inserido na pilha; ele jamais sair a dela. Os n umeros inseridos
sempre aumentar ao, progressivamente, da base para o topo. No incio de cada linha l ogica, o nvel de indentac ao
da linha e comparado com o do topo da pilha. Se for igual, nada acontece; se for maior, e inserido na pilha, e
um token INDENT e gerado. Se for menor, ele obrigatoriamente tem de ser um dos n umeros da pilha; todos os
n umeros que s ao maiores que ele s ao removidos e para cada um deles, um token DEDENT e gerado. No nal do
arquivo, um token DEDENT e gerado para cada n umero maior que zero restante na pilha.
Segue um trecho de c odigo que apesar de confuso, est a indentado corretamente:
2.1. Estrutura das linhas 5
def perm(l):
# Computa a lista de todas as permutacoes de 1
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:
r.append(l[i:i+1] + x)
return r
O exemplo a seguir mostra diversos erros de indentac ao:
def perm(l): # erro: primeira linha indentada
for i in range(len(l)): # erro: sem indentacao
s = l[:i] + l[i+1:]
p = perm(l[:i] + l[i+1:]) # erro: indentacao inesperada
for x in p:
r.append(l[i:i+1] + x)
return r # error: indentacao inconsistente
(Na verdade, os tr es primeiros erros s ao detectados pelo parser; apenas o ultimo erro e encontrado durante a an alise
l exica a indentac ao de return r n ao coincide com o nvel que foi removido da pilha.)
2.1.9 Espaco em branco entre elementos
Os caracteres espaco, tabulac ao e formfeed podem ser usados para separar smbolos, exceto quando no comeco de
uma linha l ogica ou em strings literais. Espacos s ao necess arios entre dois smbolos somente se a sua concatenac ao
levar a interpret a-los como um smbolo diferente (por exemplo, ab e um smbolo, mas a b s ao dois).
2.2 Outros smbolos
Al em de NEWLINE, INDENT e DEDENT, as seguintes categorias de tokens existem: identicadores, keywords,
literais, operadores, e delimitadores. Espacos (quando n ao forem terminac oes de linhas, discutidos mais adiante)
n ao s ao tokens, mas servem para delimit a-los. Quando existir ambiguidade, um token compreende a mais longa
string que forma um smbolo legal, lido da esquerda pra direita.
2.3 Identicadores e keywords
Identicadores (tamb em chamados de nomes) s ao descritos pela seguinte denic ao l exica:
identifier ::= (letter|"_") (letter | digit | "_")*
letter ::= lowercase | uppercase
lowercase ::= "a"..."z"
uppercase ::= "A"..."Z"
digit ::= "0"..."9"
Identicadores n ao tem limite de comprimento, mas o uso de mai usculas e min usculas tem import ancia.
2.3.1 Keywords
Os seguintes identicadores s ao palavras reservadas, ou keywords da linguagem, e n ao podem ser usadas como
identicadores comuns. Eles devem ser escritos exatamente como est ao aqui:
and del for is raise
assert elif from lambda return
break else global not try
class except if or while
continue exec import pass yield
def finally in print
Note que apesar do identicador as poder ser usado como parte da sintaxe da instruc ao import, no momento
ele n ao e um keyword.
Em uma futura vers ao da linguagem, e possvel que os identicadores as e None tornar-se- ao keywords.
2.3.2 Classes reservadas de identicadores
Algumas classes de identicadores (exceto keywords), t em signicados especiais. Estas classes s ao identicadas
pelo padr ao da disposic ao do caracter underscore antes e depois do identicador:
_* N ao e importado por from module import *. O identicador especial _ e usado no interpretador
interativo para armazenar o resultado da ultima express ao resolvida: ele e armazenado no m odulo __-
builtin__. Quando n ao o interpretador n ao estiver em modo interativo, _ n ao tem qualquer signicado
especial e n ao e denido. Veja section 6.12, O comando import.
Note: O nome _ e ` as vezes usado para internacionalizac ao; procure a documentac ao para o m odulo
gettext module para mais informac ao sobre esta convenc ao.
__*__ Nomes denidos pelo sistema. Estes nomes s ao denidos pelo interpretador e sua implementac ao (in-
cluindo a biblioteca padr ao); Assume-se que as aplicac oes n ao denam nomes adicionais usando esta
convenc ao. O conjunto de nomes desta classe denidos pela linguagem pode ser estendido em vers oes
futuras. Veja section 3.3, Nomes de m etodos especiais.
__* Nomes privados da classe. Nomes nesta categoria, quando usados dentro do contexto de uma denic ao de
classe, s ao re-escritos para usar uma vers ao modicada, para evitar conitos entre atributos privados entre
a classe base e suas classes derivadas. Veja section 5.2.1, Identicadores (Nomes).
2.4 Literais
Literais s ao notac oes para valores constantes de alguns tipos built-in.
2.4.1 Strings literais
Strings literais s ao descritas pelas seguintes denic oes l exicas:
stringliteral ::= [stringprefix](shortstring | longstring)
stringprefix ::= "r "u "ur "R "U "UR "Ur "uR"
shortstring ::= ""shortstringitem* " " shortstringitem* "
longstring ::= ""longstringitem* ""
| " longstringitem* "
shortstringitem ::= shortstringchar | escapeseq
longstringitem ::= longstringchar | escapeseq
shortstringchar ::= <any character except "\"or newline or the quote>
longstringchar ::= <any character except "\
escapeseq ::= "\any ASCII character>
2.4. Literais 7
Uma restric ao sint atica n ao indicada por essas denic oes e que espacos n ao s ao permitidos entre o
stringprefix e o resto da string literal.
Strings literais podem ser inseridas entre aspas simples () ou aspas duplas ("). Elas podem tamb em ser inseridas
em groupos de tr es aspas duplas ou simples. Uma barra-invertida (\) pode ser usada para escapar caracteres que de
outra forma teriam algum signicado especial, como newline, a pr opria barra-invertida ou aspas. Strings literais
podem opcionalmente ter como prexo a letra r ou R; tais strings s ao chamadas raw strings e usam regras
diferentes para a interpretac ao de sequ encias de escape. Uma string prexada pelo character u or U torna-
se uma string Unicod, que utiliza o conjunto de caracteres Unicode, denido pela norma ISO 10646. Algumas
sequ encias adicionais, descritas adiante, est ao disponveis em strings Unicode. Estes dois caracteres prexando
strings podem ser utilizados simultaneamente; neste caso, u deve vir antes de r.
Em strings com tr es aspas, newlines ou aspas s ao permitidas (e mantidas), exceto por tr es aspas seguidas, que
terminam a string.
Amenos que a string tenha o prexo r ou R, sequ encias de escape s ao interpretadas segundo regras semelhantes
aquelas usadas em C. As sequ encias reconhecidas s ao:
Escape Sequence Meaning Notes
\newline Ignored
\\ Backslash (\)
\ Single quote ()
\" Double quote (")
\a ASCII Bell (BEL)
\b ASCII Backspace (BS)
\f ASCII Formfeed (FF)
\n ASCII Linefeed (LF)
\N{name} Character named name in the Unicode database (Unicode only)
\r ASCII Carriage Return (CR)
\t ASCII Horizontal Tab (TAB)
\uxxxx Character with 16-bit hex value xxxx (Unicode only) (1)
\Uxxxxxxxx Character with 32-bit hex value xxxxxxxx (Unicode only) (2)
\v ASCII Vertical Tab (VT)
\ooo Character with octal value ooo (3,5)
\xhh Character with hex value hh (4,5)
Notas:
(1) Individual code units which form parts of a surrogate pair can be encoded using this escape sequence.
(2) Any Unicode character can be encoded this way, but characters outside the Basic Multilingual Plane (BMP)
will be encoded using a surrogate pair if Python is compiled to use 16-bit code units (the default). Individual
code units which form parts of a surrogate pair can be encoded using this escape sequence.
(3) As in Standard C, up to three octal digits are accepted.
(4) Unlike in Standard C, at most two hex digits are accepted.
(5) In a string literal, hexadecimal and octal escapes denote the byte with the given value; it is not necessary
that the byte encodes a character in the source character set. In a Unicode literal, these escapes denote a
Unicode character with the given value.
Ao contr ario de C , todas as sequ encias de escape n ao reconhecidas s ao deixadas na string inalteradas, ou seja,
a barra invertida e deixada na string. (Este comportamente e util na depurac ao do c odigo: se uma sequ encia de
escape foi digitada errada, a sada resultante e facilmente reconhecida.) Tamb em e importante notar que sequ encias
marcadas como (Apenas Unicode) na tabela acima, caem na categora de sequ encias n ao reconhecidas para
strings que n ao sejam Unicode.
Quando o prexo r ou R est a presente, o caracter seguinte ` a barra invertida e includo na string sem alterac oes,
e todas as barras s ao deixadas na string. Por exemplo, r"\n" c e uma string literal v alida que consiste de dois
caracteres: uma barra invertida e um n min usculo. Aspas simples podem ser escapadas com a barra invertida,
mas ela continua na string; por exemplo, r"\ e uma string literal v alida consistindo de dois caracteres: uma barra
invertida e aspas duplas; r"\" n ao e uma string v alida (mesmo uma string crua n ao pode terminar num n umero
impar de barras invertidas). A string n ao pode terminar com uma barra invertida (j a que ela ir a escapar as aspas
logo em seguida).
Quando o prexo r ou R e usado com o prexo u ou U prex, ent ao a sequ encia \uXXXX e processada
enquanto todas as outras barras invertidas s ao deixadas na string. Por exemplo, a string literal ur"\u0062\n"
consiste de tr es caracteres Unicode, LATIN SMALL LETTER B, REVERSE SOLIDUS e LATIN SMALL
LETTER N. Barras invertidas podem ser escapadas com uma outra barra; no entanto, ambas cam na string.
Como resultado sequ encias de escape\uXXXX s o s ao reconhecidas quando h a um n umero mpar de barras inver-
tidas.
2.4.2 Concatenac ao de strings literais
M ultiplas strings literais adjacentes (delimitadas por espacos, possivelmente usando convenc oes diferentes para as
aspas) s ao permitidas, e seu signicado e o mesmo da sua concatenac ao. Desta forma, "hello"world
e equivalente a "helloworld". Esse recurso pode ser usado para reduzir o n umero de barras-invertidas
necess arias, para repartir strings longas atrav es de v arias linhas, ou mesmo para adicionar coment arios a partes de
uma string, por exemplo:
re.compile("[A-Za-z_]" # letra ou underscore
"[A-Za-z0-9_]*" # letra, dgito ou underscore
)
Note que este recurso e denido no nvel sint atico, mas implementado no momento da compilac ao. O operador
+ deve ser usado para concatenar strings em tempo de execuc ao. Note ainda que concatenac ao literal pode usar
diferentes tipos de aspas para cada componente (at e misturar strings cruas e strings com tr es aspas).
2.4.3 Literais num ericos
H a quatro tipos de literais num ericos: inteiros, longos, n umeros de ponto utuante e n umeros imagin arios. N ao
h a literais complexos (eles podem ser formados adicionando um n umero real e um n umero imagin ario).
Note que literais num ericos n ao incluem um sinal; um trecho como -1 e na verdade uma express ao composta do
operador - e do n umero 1.
2.4.4 Inteiros e longos
Literais inteiros e longos s ao descritos pelas seguintes denic oes l exicas:
longinteger ::= integer ("l "L")
integer ::= decimalinteger | octinteger | hexinteger
decimalinteger ::= nonzerodigit digit* | "0"
octinteger ::= "0"octdigit+
hexinteger ::= "0"("x "X") hexdigit+
nonzerodigit ::= "1"..."9"
octdigit ::= "0"..."7"
hexdigit ::= digit | "a"..."f "A"..."F"
Apesar de tanto o caracter l e L serem permitidos como suxo para longos, e recomendado usar sempre o L,
j a que a letra l se parece muito com o dgito 1.
Inteiros decimais que est ao acima do maior inteiro represent avel (2147483647 quando usamos 32-bits) s ao aceitos
como se fossem longos.
1
There is no limit for long integer literals apart from what can be stored in available
memory.
1
In versions of Python prior to 2.4, octal and hexadecimal literals in the range just above the largest representable plain integer but below
the largest unsigned 32-bit number (on a machine using 32-bit arithmetic), 4294967296, were taken as the negative plain integer obtained by
subtracting 4294967296 from their unsigned value.
2.4. Literais 9
Octais e hexadecimais se comportam de maneira semelhante, mas quando ultrapassam a maior representac ao
possvel, mas est ao abaixo do maior n umero de 32-bits possvel, 4294967296, eles aparecem como o inteiro
negativo obtido da subtrac ao de 4294967296 do seu valor original. N ao h a limite para longos, exceto, e claro, o
quanto pode ser armazenado na mem oria.
Alguns exemplos de inteiros (primeira linha) e longos (segunda e terceira linhas):
7 2147483647 0177
3L 79228162514264337593543950336L 0377L 0x100000000L
79228162514264337593543950336 0xdeadbeef
2.4.5 Literais de ponto-utuante
N umeros de ponto-utuante s ao descritos pelas seguintes denic oes l exicas:
floatnumber ::= pointfloat | exponentfloat
pointfloat ::= [intpart] fraction | intpart "."
exponentfloat ::= (intpart | pointfloat) exponent
intpart ::= digit+
fraction ::= "."digit+
exponent ::= ("e "E") ["+ -"] digit+
Note que as partes de um n umero de ponto utuante podem parecer como inteiros octais, mas s ao interpretadas
usando base 10. Por exemplo, 077e010 e legal, e denota o mesmo n umero que 77e10. O intervalo permitido
de n umeros de ponto utuante depende da implementac ao. Alguns exemplos:
3.14 10. .001 1e100 3.14e-10 0e0
Note que literais num ericos n ao incluem um sinal; um trecho como -1 e na verdade uma express ao composta do
operador - e do n umero 1.
2.4.6 Literais imagin arios
N umeros imagin arios s ao descritos pelas seguintes denic oes l exicas:
imagnumber ::= (floatnumber | intpart) ("j "J")
Um literal imagin ario retorna um n umero complexo com a parte real de 0.0. N umeros complexos s ao represen-
tados como um par de n umeros de ponto utuante e t em as mesmas restric oes. Para criar um n umero complexo
com a parte real diferente de zero, adicione um n umero de ponto utuante a ele, por exemplo (3+4j). Alguns
exemplos:
3.14j 10.j 10j .001j 1e100j 3.14e-10j
2.5 Operadores
Os seguintes smbolos s ao operadores:
+ - * ** / // %
<< >> & |
< > <= >= == != <>
Os operadores de comparac ao <> e != s ao formas alternativas do mesmo operador. != e a forma preferida; <>
est a obsoleto.
2.6 Delimitadores
Os seguintes smbolos funcionam como delimitadores:
( ) [ ] { } @
, : . = ;
+= -= *= /= //= %=
&= |= = >>= <<= **=
O ponto pode ocorrer ainda em n umeros de ponto-utuante e literais imagin arios. Uma sequ encia de tr es pontos
tem o signicado especial de uma elipse no fatiamento de sequ encias. Os operadores da segunda metada da lista,
servem como delimitadores, mas tamb em executam uma operac ao.
Os seguintes caracteresASCII t em signicado especial quando partes de outros smbolos ou s ao de alguma forma
signicantes para a an alise l exica:
" # \
Os seguintes caracteres ASCII n ao s ao usados em Python. Sua ocorr encia fora de strings ou coment arios e um erro
incondicional:
$ ?
2.6. Delimitadores 11
12
CAP
ITULO
THREE
Modelo de Dados
3.1 Objetos, valores e tipos
Objetos s ao a abstrac ao para dados em Python. Todos os dados em um programa Python s ao representados por
objetos ou por relac oes entre objetos. (Em um certo sentido, e em concord ancia com o modelo de programas
armazenados em computadores de Von Neumann, o c odigo tamb em e representado por objetos.)
Todo objeto possui uma identidade, um tipo e um valor. A identidade de um objeto nunca muda ap os sua criac ao;
voc e pode imagin a-la como sendo o endereco de mem oria de um objeto. O operador is compara a identidade
de dois objetos; a func ao id() retorna um n umero inteiro que representa a identidade de um objeto (atualmente
implementada como sendo o seu endereco). Otipo de umobjeto tamb em e inalter avel.
1
Otipo do objeto determina
as operac oes que o objeto suporta (ex., ele tem um comprimento?) e os possveis valores para objetos deste tipo.
A func ao type() retorna o tipo do objeto (que tamb em e um objeto). O valor de alguns objetos pode mudar.
Objetos que podem mudar seu valor s ao denominados mut aveis; objetos que n ao podem mudar seu valor ap os
teremsido criados s ao chamados de imut aveis. (Ovalor de umobjeto cont einer imut avel que possui uma refer encia
para um objeto mut avel pode alterar quando o valor do ultimo e alterado; por em, o conte udo do primeiro ainda e
considerado imut avel porque a colec ao de objetos deste conte udo n ao pode ser modicada. Logo, imutabilidade
n ao e estritamente o mesmo que ter um valor inalter avel, e algo mais sutil.) A mutabilidade de um objeto e
determinada pelo seu tipo; por exemplo, n umeros, strings e tuplas s ao imut aveis, enquanto dicion arios e listas s ao
mut aveis.
Objetos nunca s ao explicitamente destrudos; entretanto, quando eles se tornam inacessveis podem ser coletados
pelo sistema de coleta de lixo (garbage-collect). Uma implementac ao pode adiar coletas de lixo ou omit-las
completamente contanto que respeite a regra de que nenhum objeto ainda acessvel ser a coletado, depende
apenas da qualidade da implementac ao a forma exata com que a coleta e realizada. (Nota de implementac ao:
a implementac ao atual usa um esquema de contagem de refer encias com uma detecc ao de refer encias cclicas
(opcional) que coleta a maioria dos objetos assim que eles se tornam inacessveis, mas n ao garante a coleta de lixo
de objetos com refer encias circulares. Veja a Refer encia da Biblioteca Python para informac oes sobre o controle
de coleta de lixo de objetos com refer encias circulares.)
Observe que o uso de recursos de rastreamento ou de depurac ao pode manter objetos vivos onde normalmente
seriam coletados. Note tamb em que a captura de uma excec ao com os comandos try...except pode manter
os objetos ativos.
Alguns objetos cont em refer encias para recursos externos como um arquivo aberto ou janela.

E de se imaginar
que estes recursos s ao liberados quando um objeto e coletado, mas como n ao h a garantias de que a coleta aconteca,
alguns objetos fornecem uma maneira de liberar os recursos externos, normalmente um m etodo close().

E
extremamente recomendado que programas fechem explicitamente esses objetos. O comando try...finally
fornecem uma maneira conveniente para se fazer isso.
Alguns objetos possuem refer encias para outros objetos; eles s ao chamados cont eineres. Exemplos de cont eineres
s ao tuplas, listas e dicion arios. As refer encias s ao parte do valor de um cont einer. Na maioria dos casos, quando
n os falamos sobre o valor de um cont einer, n os estamos falando dos valores, n ao das identidades dos objetos
1
Desde Python 2.2, foi iniciada uma unicac ao gradual de tipos e classes, portanto, uma ou outra armac ao feita neste manual pode n ao
estar 100% precisa e completa: por exemplo, agora e possvel em alguns casos mudar o tipo de um objeto, sob certas condic oes controladas.
At e que este manual passe por uma revis ao extensiva ele n ao deve ser considerado como autoridade denitiva com excec ao das considerac oes
acerca das classes tradicionais, que ainda s ao o padr ao, por motivos de compatibilidade, em Python 2.2 e 2.3
13
contidos; entretanto, quando n os falamos sobre a mutabilidade de um cont einer, estamos tratando apenas das
identidades dos objetos imediatamente contidos. Ent ao, se um cont einer imut avel (como uma tupla) cont em uma
refer encia para um objeto mut avel, seu valor muda se o objeto mut avel for alterado.
Os tipos afetam quase todos os aspectos do comportamento de um objeto. A import ancia da identidade e afetada
do mesmo jeito: para tipos imut aveis, operac oes que calculam novos valores podem retornar uma refer encia para
um objeto existente com o mesmo tipo e valor, enquanto para objetos mut aveis isto n ao e permitido. Ex., depois
de a = 1; b = 1, a e b podem ou n ao se referirem ao mesmo objeto com o valor um, dependendo da
implementac ao, mas c = []; d = [], c e d tem que garantir que se referem a duas listas diferentes, unicas,
rec em-criadas e vazias. (Note que c = d = [] atribuem o mesmo objeto tanto para c quanto para d.)
3.2 A hierarquia padr ao de tipos
Abaixo est a uma lista de tipos que s ao internas ao interpretador Python. M odulos de extens ao (escritos em C, Java,
ou outras linguagens, dependendo da implementac ao) podem denir tipos adicionais. Vers oes futuras do Python
podem adicionar tipos nesta hierarquia (ex., n umeros racionais, arrays com armazenamento eciente de inteiros,
etc.).
Algumas das descric oes de tipos abaixo cont em um par agrafo listando atributos especiais. S ao atributos que
fornecem acesso ` a implementac ao e cuja intenc ao n ao e de uso geral. Suas denic oes podem mudar no futuro.
None Este tipo tem um valor unico. Existe um unico objeto com este valor. Este objeto e acessado atrav es do
nome interno None. Ele e usado com o signicado de aus encia de valor em v arias situac oes, ex., ele e
retornado por func oes que n ao retornam nada explicitamente. Seu valor l ogico e falso.
NotImplemented Este tipo tem um valor unico. Existe um unico objeto com este valor. Este objeto e acessado
atrav es do nome interno NotImplemented. M etodos num ericos e m etodos completos de comparac ao
podem retornar este valor se eles n ao implementam a operac ao para os operandos fornecidos. (O interpre-
tador tentar a ent ao uma operac ao reetida, ou alguma chamada alternativa, dependendo do operador.) Seu
valor l ogico e verdadeiro.
Ellipsis Este tipo tem um valor unico. Existe um unico objeto com este valor. Este objeto e acessado atrav es do
nome interno Ellipsis. Ele e usado para indicar a presenca da sintaxe ... em uma fatia. Seu valor
l ogico e verdadeiro.
N umeros S ao criados por n umeros literais e retornados como resultado por operadores aritm eticos e func oes
aritm eticas internas. Objetos num ericos s ao imut aveis; uma vez criados seus valores nunca mudam.
N umeros em Python s ao fortemente relacionados com n umeros matem aticos, mas sujeitos ` as limitac oes
da representac ao num erica em computadores.
Python faz distinc ao entre inteiros, n umeros de ponto utuante, e n umeros complexos:
Inteiros Representam elementos do conjunto matem atico dos n umeros inteiros (positivos e negativos).
Existem tr es tipos de inteiros:
Inteiros Planos Representam n umeros na faixa de -2147483648 at e 2147483647. (A faixa pode ser
maior em m aquinas com um tamanho de palavra maior, mas n ao menor.) Quando o resultado
de uma operac ao ca fora dessa faixa, o resultado e retornado normalmente como um inteiro
longo (em alguns casos, a excec ao OverflowError e levantada no lugar). Para prop osito de
deslocamento (bin ario) e operac oes comm ascaras, assume-se que eles usemnotac ao bin aria de 32
bits ou mais e n umeros negativos s ao representados usando complemento de dois, e n ao escondem
nenhum bit do usu ario (ex., todos os 4294967296 padr oes de bits diferentes correspondem a um
valor diferente).
Inteiros Longos Representam n umeros numa faixa ilimitada, sujeita apenas ` a mem oria (virtual). Para
prop osito de deslocamento (bin ario) e operac oes com m ascaras, assume-se que usem notac ao
bin aria e n umeros negativos s ao representados com uma variac ao do complemento de dois que d a
a ilus ao de uma string innita com o bit de sinal extendendo para a esquerda.
Booleanos Representam os valores l ogicos False (Falso) e True (Verdadeiro). Os dois objetos que
representam os valores False e True s ao os unicos objetos Booleanos. O tipo Booleano e um
subtipo dos inteiros planos, e valores Booleanos se parecemcomos valores 0 e 1, respectivamente,
14 Captulo 3. Modelo de Dados
em quase todos os contextos, a excec ao e quando s ao convertidos para uma string, as strings
"False" ou "True" s ao retornadas, respectivamente.
As regras para representac ao de inteiros foram feitas com a intenc ao de facilitar a interpretac ao de
operac oes com m ascara e deslocamento envolvendo inteiros negativos, e com o mnimo de problemas
quando eles trocam entre os domnios dos inteiros planos e dos inteiros longos. Qualquer operac ao
exceto o deslocamento ` a esquerda, se mantiver o resultado no mesmo domnio dos inteiros planos sem
causar sobrecarga, ir a manter o resultado no mesmo domnio dos inteiros longos ou ao usar operadores
mistos.
N umeros de ponto utuante Eles representam os n umeros de ponto utuante de precis ao dupla no nvel
da m aquina. Vai depender da arquitetura da m aquina (e da implementac ao de C ou Java) para a denir
qual e a faixa aceita e a manipulac ao de sobrecargas. Python n ao suporta n umeros de ponto utuante
de precis ao simples; a economia de processamento e de uso de mem oria que geralmente s ao a raz ao
para usar este tipo de t ecnica s ao mnimas perto do trabalho de usar objetos em Python, ent ao n ao h a
raz ao para complicar a linguagem com dois tipos de n umeros de ponto utuante.
N umeros complexos Representam os n umeros complexos com um par de n umeros de ponto utuante de
precis ao dupla no nvel da m aquina. As mesmas caractersticas se aplicam como no caso dos n umeros
de ponto utuante. As partes reais e imagin arias de um n umero complexo z podem ser obtidas atrav es
dos atributos somente de leitura z.real e z.imag. z.real e z.imag.
Seq u encias Representam conjuntos nitos ordenados indexados por um n umero n ao-negativo. A func ao interna
len() retorna o n umero de tens da seq u encia. Quando o tamanho de uma seq u encia e n, o conjunto de
ndices cont em os n umeros 0, 1, . . . , n-1. O tem i de uma seq u encia a e retornado por a[i].
Seq u encias tamb em suportam fatiamento (slicing): a[i:j] retorna todos os tens com ndice k onde i <=k
< j. Quando usado como uma express ao, uma fatia e uma seq u encia do mesmo tipo. Isto implica que o
conjunto de ndices e renumerado para que comece em 0.
Algumas seq u encias tamb em suportam fatiamento estendido com um terceiro par ametro de passo:
a[i:j:k] retorna todos os tens de a com ndice x onde x = i + n*k, n >= 0 e i <= x < j.
Seq u encias s ao divididas de acordo com sua mutabilidade:
Seq u encias imut aveis Um objeto do tipo seq u encia imut avel n ao pode ser alterado ap os sua criac ao. (Se o
objeto cont em refer encias para outros objetos, estes objetos podem ser mut aveis e podem ser alterados;
todavia, a colec ao de objetos diretamente referenciadas por um objeto imut avel n ao pode alterar.)
Os seguintes tipos s ao seq u encias imut aveis:
Strings Os items de uma string s ao caracteres. N ao h a um tipo ` a parte para caracteres; eles s ao
representados por uma string de um unico item. Caracteres representam (pelo menos) um byte.
As func oes internas chr() e ord() convertem entre caracteres e n umeros inteiros positivos
representando os valores. Bytes com os valores de 0 a 127 geralmente representam o valor ASCII
correspondente, mas a sua interpretac ao correta depende do programa. O tipo string e ainda usado
para representar matrizes de dados, por exemplo, para guardar dados lidos de um arquivo.
(Em sistemas cujo conjunto de caracteres nativo n ao e ASCII, strings podem usar EBCDIC em sua
representac ao interna, contanto que as func oes chr() e ord() implementem um mapeamento
entre EBCDIC, e comparac oes de strings preservem a ordem ASCII. Ou ser a que talvez algu em
pode prop or uma regra melhor?)
Unicode Os items de um objeto Unicode s ao unidades de c odigo Unicode. S ao representadas por
um objeto Unicode de um item e podem conter valores de 16 ou 32 bits, representando um car-
acter ordinal Unicode (o valor m aximo e dado por sys.maxunicode e depende de como o
interpretador Python foi congurado no momento da compilac ao). Pares surrogate podem estar
presentes no objeto Unicode, e ser ao reportados como dois items separados. As func oes internas
unichr() e ord() convertem entre unidades de c odigo e inteiros positivos, representando os
ordinais Unicode, como denidos no Unicode Standard 3.0. Convers ao de e para outros c odigos
s ao possveis atrav es do m etodo Unicode encode e a func ao interna unicode().
Tuples Os items de uma tupla s ao quaisquer objetos Python. Tuplas de dois ou mais items s ao
formadas por uma lista de express oes, separadas por vrgula. Uma tupla de um item (single-
ton) pode ser formada adicionando uma vrgula a uma express ao (uma express ao sozinha en-
tre par enteses n ao cria uma tupla, j a que par enteses podem ser usados para criar grupos de ex-
press oes). Uma tupla vazia pode ser criada por um par de par enteses.
3.2. A hierarquia padr ao de tipos 15
Sequ encias mut aveis Sequ encias mut aveis podem ser alteradas depois de criadas. As notac oes de
subscric ao e fatiamento podem ser usadas como o alvo de atribuic oes ou do comando (del).
Atualmente h a apenas uma sequ encia mut avel intrnseca ` a linguagem:
Listas Os items de uma lista s ao quaisquer objetos Python. Listas s ao criadas colocando uma lista de
express oes separadas por vrgulas entre dois colchetes. (Note que n ao h a nenhuma regra especial
necess aria para criar listas de comprimento 0 ou 1.)
O m odulo array fornece um exemplo adicional de uma sequ encia mut avel.
Mapeamentos Mapeamentos representam conjuntos nitos de objetos, indexados por ndices arbitr arios. A
notac ao a[k] seleciona o item indexado por [k] do mapeamento a; isto pode ser usado em express oes
e como o alvo de atribuic oes ou do comando del. A func ao interna len() retorna o n umero de items num
mapeamento.
Atualmente h a apenas um unico mapeamento intrnseco ` a linguagem:
Dicion arios Dicion arios () representam conjuntos nitos de objetos, indexados por ndices praticamente
arbitr arios. O unico tipo de objeto inaceit avel como chave s ao listas ou dicion arios ou outros ob-
jetos mut aveis que s ao comparados pelo valor e n ao pela identidade. A raz ao para isso e que uma
implementac ao eciente de dicion arios requer que o valor do hash da chave permaneca constante.
Tipos num ericos usados para chaves obedecem as regras normais de comparac ao: se na comparac ao
dois n umeros s ao considerados iguais (por exemplo, 1 e 1.0) ent ao qualquer um deles pode ser usado
para indexar o mesmo valor em um dicion ario.
Dicion arios s ao mut aveis; eles podem ser criados pela notac ao {...} (veja a sec ao 5.2.6,
Visualizac ao de dicion arios).
Os m odulos dbm,gdbm, bsddb fornecem exemplos adicionais de mapeamentos.
Tipos execut aveis Estes s ao os tipos aos quais a operac ao de chamada de func ao (veja section ??, Chamadas)
pode ser aplicada:
Func oes Um objeto func ao e criado por uma denic ao de func ao (veja a section 7.5, Denic oes de
func ao). Ele deve ser chamado com uma lista de argumentos contendo o mesmo n umero que itens
que na denic ao formal da lista de par ametros do objeto.
Special attributes:
Attribute Meaning
func_doc The functions documentation string, or None if unavailable Writable
__doc__ Another way of spelling func_doc Writable
func_name The functions name Writable
__name__ Another way of spelling func_name Writable
__module__ The name of the module the function was dened in, or None if unavailable. Writable
func_defaults A tuple containing default argument values for those arguments that have defaults, or None if no arguments have a default value Writable
func_code The code object representing the compiled function body. Writable
func_globals A reference to the dictionary that holds the functions global variables the global namespace of the module in which the function was dened. Read-only
func_dict The namespace supporting arbitrary function attributes. Writable
func_closure None or a tuple of cells that contain bindings for the functions free variables. Read-only
Most of the attributes labelled Writable check the type of the assigned value.
Changed in version 2.4: func_name is now writable.
Function objects also support getting and setting arbitrary attributes, which can be used, for example, to
attach metadata to functions. Regular attribute dot-notation is used to get and set such attributes. Note
that the current implementation only supports function attributes on user-dened functions. Function
attributes on built-in functions may be supported in the future.
Additional information about a functions denition can be retrieved from its code object; see the
description of internal types below.
M etodos Um objeto m etodo combina uma classe, uma inst ancia dessa classe (ou None) e qualquer objeto
execut avel (normalmente uma func ao denida pelo usu ario).
Atributos especiais (somente leitura): im_self e a inst ancia da classe, im_func e o objeto func ao;
im_class e a classe de im_self para m etodos ligados ou a classe que pediu a execuc ao do m etodo
para m etodos desligados; __doc__ e a documentac ao do m etodo (o mesmo que im_func.__-
doc__); __name__ e o nome do m etodo (o mesmo que im_func.__name__); __module__ e
o nome do m odulo em que o m etodo foi denido, ou None se indisponvel. Changed in version 2.2:
im_self e usado para referir ` a classe que deniu o m etodo.
M etodos tamb em suportam o acesso (mas n ao a denic ao) de atributos arbitr arios do objeto func ao
subjacente.
M etodo, ou o objeto que refere a um m etodo, podem ser criados quando acessando um atributo de uma
classe (talvez atr as de uma inst ancia dessa classe), se esse atributo for um objeto func ao, um objeto
m etodo denido pelo usu ario ou um m etodo da classe.
Quando o atributo e um objeto m etodo, um objeto novo s o ser a criado se a classe da qual ele est a
sendo consultado for ou a classe original armazenada no objeto, ou uma classe derivada dela; em
outros casos, o objeto original e utilizado.
Quando um objeto m etodo e criado consultando um objeto func ao de uma classe, o seu atribto im_-
self e None e o diz-se que ele e um m etodo desligado. Quando e criado atrav es de uma consulta a
um objeto func ao de uma classe atrav es de uma de suas inst ancias, seu atributo im_self e a inst ancia
e diz-se que e um m etodo ligado. Em qualquer um dos casos, o atributo im_class e a classe de
onde a consulta ocorre e o atributo im_func e o objeto func ao original.
Quando um objeto m etodo e criado consultando outro objeto m etodo de uma classe ou inst ancia, o
comportamente e id entico ao de um objeto func ao, exceto que o atributo im_func da nova inst ancia
n ao e o objeto original e sim o seu atributo im_func.
Quando um objeto m etodo e criado consultando um m etodo da classe, de uma classe ou inst ancia, seu
atributo im_self e a pr opria classe (o mesmo que o atributo im_class), e seu atributo im_func
e o objeto func ao sob o m etodo da classe.
Quando um objeto m etodo desligado e chamado, a func ao subjacente (im_func) e chamada. O
primeiro argumento deve ser uma inst ancia da classe apropriada im class) ou de uma classe derivada.
Quando um objeto m etodo ligado e chamado, a func ao subjacente e chamada (im_func) inserindo a
inst ancia da classe (im_self) na frente da lista de argumentos. Por exemplo, quando C e uma classe
que cont em uma denic ao de uma func ao f(), e x e uma inst ancia da classe C, chamar x.f(1) e
equivalente a C.f(x, 1).
Quando um objeto m etodo e derivado de um objeto m etodo da classe, a inst ancia armazenada em
im_self ser a na verdade a pr opria classe, de modo que chamar tanto x.f(1) ou C.f(1) e equiv-
alente a f(C,1) onde f e a func ao subjacente.
Note que a transformac ao de um objeto func ao para um m etodo (ligado ou desligado) acontece cada
vez que o atributo e recuperado da classe ou da inst ancia. Em alguns casos, uma boa otimizac ao e
atribuir o atributo a uma vari avel local e chamar aquela vari avel. Note ainda que esta transformac ao
ocorre apenas para func oes denidas pelo usu ario; outros objetos execut aveis (e tamb em n ao-
execut aveis) s ao recuperados sem transformac ao.

E importante notar que func oes denidas pelo
usu ario que s ao atributos de uma inst ancia de uma classe n ao s ao convertidas para m etodos ligados;
isso ocorre apenas quando a func ao e um atributo de uma classe.
Func oes geradoras Uma func ao ou m etodo que usa o comando yield (veja a sec ao 6.8, O comando
yield ) e chamado de func ao geradora generator function. Ao ser chamado, uma func ao desse
tipo sempre retorna um objeto iterador, que pode ser usado para executar o corpo da func ao; ao
chamar o m etodo next() do iterador, a func ao ser a executada at e retornar um valor atrav es do
comando yield. Quando a func ao executa o comando return, ou chega no m, uma excec ao
StopIteration e levantada e o iterador ter a alcancado o m do conjunto de valores a ser retor-
nado.
Func oes internas (built-in) Uma func ao interna e um wrapper em torno de uma func ao em C. Exemplos
de func oes internas s ao len() e math.sn() (math e um m odulo interno padr ao). O n umero e tipo
dos argumentos s ao determinados pela func ao em C. Atributos somente-leitura especiais: __doc_-
_ e a string de documentac ao da func ao, ou None, caso esteja indisponvel; __name__ e o nome
da func ao; __self__ tem o valor None (mas veja o pr oximo item); __module__ e o nome do
m odulo em que a func ao foi denida, ou None se indisponvel.
M etodos internos (built-in) Estes s ao realmente quase a mesma coisa de uma func ao interna, exceto que
cont em um objeto passado para a func ao em C como um argumento extra implcito. Um exemplo de
m etodo interno e alist.append(), assumindo que alist e uma lista. Neste caso, o atributo especial
somente-leitura __self__ aponta para o objeto list.
Tipos Tipos, ou classes new-style s ao execut aveis. Esses objetos normalmente funcionam como f abricas de
novas inst ancias, mas existem variac oes possveis de tipos que sobrescrevem o m etodo __new__().
Os argumentos da chamada s ao passados para o m etodo __new__() e, normalmente, passados em
seguida para o m etodo __init__() para a inicializac ao da inst ancia.
Classes tradicionais Estas classes s ao descritas adiante. Quando um objeto class e chamado, uma nova
inst ancia dessa classe (tamb em descritas adiante) e criada e retornada. Isso implica em uma chamada
do m etodo __init__(), se ele existir, com quaisquer argumentos passados na chamada. Se n ao
houver um m etodo __init__(), a classe deve ser chamada sem argumentos.
Inst ancias Inst ancias s ao descritas logo adiante. Inst ancias s ao execut aveis somente quando a classe tem
um m etodo __call__; x(argumentos) e um atalho para x.__call__(argumentos).
M odulos M odulos s ao importados atrav es do comando import (veja section 6.12, O comando import).
Um objeto m odulo tem um namespace implementado atrav es de um dicion ario ( e esse o dicion ario refer-
enciado pelo atributo func globals de func oes denidas no m odulo). Refer encias a atributos s ao traduzidas
em procuras a esse dicion ario, por exemplo: m.x equivale ` a m.__dict__["x"]. Um objeto m odulo n ao
contem o objeto c odigo usado para sua inicializac ao (j a que n ao e mais necess ario depois dela).
Atribuic oes atualizam o dicion ario do namespace do m odulo, por exemplo., m.x = 1 equivale a m._-
_dict__["x"] = 1.
Atributos especiais somente para leitura: __dict__ e o namespace do m odulo, representado por um
dicion ario.
Atributos pr e-denidos: __name__ e o nome do m odulo; __doc__ e a string de documentac ao do
m odulo, ou None se indisponvel; __file__ e o caminho do arquivo do qual o m odulo foi carregado,
se ele foi carregado de um arquivo. O atributo __file__ n ao est a presente para m odulos em C que
s ao ligados estaticamente ao interpretador; para m odulos de extens oes carregados dinamicamente de uma
biblioteca compartilhada, e o caminho do arquivo da biblioteca.
Classes Classes s ao objetos criados por denic oes de classe (veja section7.6, Denic oes de classe). Uma classe
tem um namespace implementado atrav es de um objeto dicion ario. Refer encias a atributos da classe s ao
traduzidas em procuras a este dicion ario, por exemplo: C.x e equivalente ` a C.__dict__["x"].
Quando o nome do atributo n ao e encontrado, a busca continua nas classes base. A busca e realizada da
esquerda para a direita, na ordem de ocorr encia na lista de classes base.
Quando uma refer encia de um atributo da classe (digamos, uma classe C) ir a retornar uma func ao ou um
m etodo desligado cuja classe associada e C ou uma de suas classes base, ele e transformado em um m etodo
desligado cujo atributo im_class e C. Quando ele for retornar um m etodo est atico, ele e transformado em
um objeto embrulhado pelo objeto original. Veja section 3.3.2 para outros exemplos de como atributos
recuperados de uma classe podem diferir daqueles contidos em seu __dict__.
Atribuic oes aos atributos de uma classe alteram sempre o seu pr oprio dicion ario, nunca o de uma classe
base.
Um objeto classe pode ser executado (veja acima) para criar e retornar uma inst ancia da classe (veja logo
abaixo).
Atributos especiais: __name__ e o nome da classe; __module__ e o nome do m odulo no qual a classe
foi denida; __dict__ e o dicion ario contendo o namespace da classe; __bases__ e uma tupla (talvez
vazia, ou contendo um unico elemento) contendo as classes base, na ordem de sua ocorr encia na denic ao
da classe; __doc__ e a string de documentac ao da classe ou None quando indenida;
Inst ancias de classes Uma inst ancia e criada executando um objeto classe (veja acima). Elas t em um namespace
implementado como um dicion ario que e o primeiro lugar em que s ao procuradas refer encias a atributos.
Quando um atributo n ao e encontrado l a, e a classe da inst ancia tem um atributo com aquele nome, a busca
continua entre os atributos da classe. Se for encontrado um atributo na classe que seja um objeto func ao
ou um m etodo cuja classe associada seja a seja a classe da inst ancia que iniciou a busca ouuma de suas
classes base, este m etodo ou func ao e ent ao transformado em um objeto m etodo ligado, cujos atributos
im_class e im_self s ao respectivamente C e a pr opria inst ancia. M etodos est aticos e m etodos de
classe s ao tamb em tranformados, como se tivessem sido recuperados da mesma classe C; veja logo acima
em Classes. Consulte section ?? para uma outra forma na qual atributos de uma classe recuperados atrav es
de uma inst ancia podem diferir do objeto que esteja realmente armazenado no __dict__ da classe. Se
nenhum atributo da classe for encontrado e ela tem um m etodo __getattr__(), ent ao ele e executado
para satisfazer a procura.
Ao atribuir ou apagar atributos, o dicion ario da inst ancia e atualizado, nunca o da classe. Se a classe tem
um m etodo __setattr__() ou __delattr__(), ele e chamado ao inv es de atualizar o dicion ario
diretamente.
Inst ancias podem ngir ser n umeros, sequ encias ou mapeamentos se elas tiverem algums m etodos com
certos nomes especiais. Veja a sec ao 3.3, Special method names.
Atributos especiais: __dict__ e o dicion ario de atributos; __class__ e a classe da inst ancia.
Arquivos Um objeto le representa um arquivo aberto. Estes objetos s ao criados pela func ao interna open() e
tamb em por os.popen(), os.fdopen(), e os m etodos makefile() de objetos socket. Os objetos
sys.stdin, sys.stdout e sys.stderr s ao inicializados para arquivos, correspondendo ` a entrada
e sada de dados padr ao do interpretador, e da sada de erros. Veja em Python Library Reference para a
documentac ao completa desses objetos.
Tipos internos Alguns tipos usados internamente pelo interpretador s ao acessveis ao usu ario. Suas denic oes
podem mudar em futuras vers oes, mas s ao mencionadas aqui para manter um registro mais completo.
C odigo Objeto C odigos objetos [code objects] cont em os bytes compilados do c odigo execut avel de
Python, ou bytecodes. A diferenca entre um c odigo objeto para uma func ao objeto e que a func ao
objeto cont em uma refer encia explcita para o seu contexto global (o m odulo em que ela foi denida),
enquanto que um c odigo objeto n ao cont em qualquer contexto; al em disso, os valores padr ao dos
argumentos s ao armazenados no objeto func ao, n ao no objeto c odigo (porque estes representam val-
ores calculados durante a execuc ao). Ao contr ario de objetos func ao, c odigo e imut avel e n ao cont em
quaisquer refer encias (diretas ou indiretas) para objetos mut aveis.
Atributos especiais somente para leitura: co_name cont em o nome da func ao; co_argcount e o
n umero de argumentos posicionais (incluindo argumentos com valores padr ao); co nlocals e o n umero
de vari aveis locais usadas pela func ao (incluindo argumentos); co_varnames e uma tupla contendo
os nomes das vari aveis locais (comecando pelos nomes dos argumentos); co_cellvars e uma tupla
contendo os nomes de vari aveis locais que s ao referenciadas por func oes aninhadas; co_freevars
e uma tupla contendo os nomes de vari aveis livres; co_code e uma string representando a sequ encia
de instruc oes em bytecode; co_consts e uma tupla contendo os literais usados pelo bytecode; co_-
names e uma tupla contendo os nomes usados pelo bytecode; co_filename e o nome do arquivo
de onde o bytecode foi compilado; co_firstlineno e o n umero da primeira linha da func ao;
co_lnotab e uma string contendo o mapeamento dos deslocamentos dos bytecodes para n umeros
de linhas (para maiores detalhes procurar o c odigo fonte do interpratador); co_stacksize e o
tamanho exigido da pilha (incluindo as vari aveis locais); co_flags e uma codicac ao inteira de
ags para o interpretador.
Os seguintes bits de ag s ao denidos como co_flags: o bit 0x04 e denido se a func ao usa a
sintaxe *arguments para aceitar um n umero arbitr ario de posic oesc o bit 0x08 e denido se a
func ao usa a sintaxe **keywords para aceitar argumentos chaves-valores; o bit 0x20 e denido
se a func ao e um gerador.
Futuras declarac oes de caractersticas (from __future__ import division) tamb em
usam bits nas co_flags para indicar se um c odigo-objeto foi compilado com uma caracterstica
particular habilitada: o bit 0x2000 e denido se a func ao foi compilada com divis oes futuras habili-
tadas; os bits 0x10 e 0x1000 foram utilizados em vers oes anteriores de Python.
Outros bits em co_flags s ao reservados para uso interno.
Se um c odigo-objeto representa uma func ao, o primeiro item em co_consts e a string de
documentac ao da func ao, ou None se n ao estiver denida.
Objetos quadro [frame ] Objetos quadro representam execuc ao de quadros. Eles podem ocorrer em obje-
tos [traceback] (veja abaixo).
Atributos especiais somente de leitura: f_back e anterior ao [stack frame] (pr oximo ao chamador),
ou None se estiver abaixo na [stack frame]; f_code e o c odigo objeto que est a sendo executado
neste quadro; f_locals e o diret orio utilizado para pesquisa de vari aveis locais; f_globals e
utilizado para vari aveis globais; f_builtins e uma ag indicando se a func ao est a executando em
modo de execuc ao restrita; f_lasti d a a instruc ao precisa (isto e um ndice para dentro da string de
[bytecode] do c odigo objeto.
Atributos especiais de escrita: f_trace, se n ao for None, e uma func ao chamada no incio de
cada linha do c odigo fonte (isto e usado pelo depurador); f_exc_type, f_exc_value, f_exc_-
traceback representa a ultima excec ao levantada no quadro pai deste, se ao menos uma outra
excec ao qualquer j a foi levantada no quadro atual (em todos os outros casos eles cont em None); f_-
lineno e o n umero atual de linhas do quadro escrever para este de dentro de uma trace salta para
as linhas dadas (somente para quadros acima). Um depurador pode implementar um comando Jump
(como Set Next Statment) por escrever para f lineno.
Objetos traceback Objetos traceback representam um rastro na pilha de excec ao. Um objeto traceback e
criado quando uma excec ao ocorre. Quando a busca por um operador de excec ao desenrola a pilha
de execuc ao, em cada nvel um objeto traceback e inserido na frente do atual traceback. Quando
um operador de excec ao entra, o rastro na pilha e colocado ` a disposic ao do programa. (Consulte
section 7.4, O comando try.)
Ele est a acessvel como sys.exc_traceback, e tamb em como o terceiro item do retorno da tupla
por sys.exc_info(). Recentemente e preferido a interface, desde que ele funcione corretamente
quando o programa est a utilizando m ultiplas threads.
Quando o programa n ao cont em operador adequado, o rastro da pilha e escrito (bem formatado) para
uma mensagem de erro padr ao; se o interpretador est a interativo, ele e tamb em colocado ` a disposic ao
para o usu ario como
sys.last_traceback.
Atributos especiais somente de leitura: tb_next e o pr oximo nvel no rastro da pilha (pr oximo
do quadro onde a excec ao ocorreu), ou None se n ao existir pr oximo nvel; tb_frame aponta para
o quadro de execuc ao do nvel atual; tb_lineno d a o n umero da linha onde a excec ao ocorreu;
tb_lasti indica a exata instruc ao. O n umero da linha e a ultima instruc ao no traceback pode ser
diferente do n umero do seu quadro objeto se a cl ausula a excec ao ocorreu no comando try sem que
ocorra cl ausula de excec ao ou com uma cl ausula de nalizac ao.
Objetos fatias Objetos fatias s ao usados para representar fatias quando a extended slice syntax e usado.
Esta e uma fatia usando duas colunas, ou m ultiplas fatias ou elipses separadas por vrgulas, por ex-
emplo, a[i:j:step], a[i:j,k:l], ou a[..., i:j]. Eles tamb em s ao criados pela func ao
embutida slice().
Atributos especiais somente de leitura: start e o limite mais baixo; stop e o limite mais alto; step
e o valor do passo; cada atributo e None se omitido. Estes atributos podem ter qualquer tipo.
Objetos fatias suportam um m etodo:
indices(self, length)
Este m etodo pega um simples argumento inteiro length e computa informac ao sobre as fatias
extendidas que o objeto fatia descreveria se aplicada para uma seq u encia de itens length. Ele
retorna uma tupla de tr es inteiros; respectivamente estes s ao os ndices start e stop e step ou
transp oem o comprimento da fatia. Perdas ou fora de limites de ndices s ao manipulados de uma
maneira consistente com fatias regulares. Novidades na vers ao New in version 2.3.
Objetos de m etodos est aticos Objetos de m etodos est aticos fornecem uma maneira de derrotar a
transformac ao da func ao dos objetos para m etodos de objetos descritos acima. Um objeto de m etodo
est atico e um empacotador em torno de qualquer outro objeto, normalmente um m etodo de objeto
denido pelo usu ario. Quando um objeto de m etodo est atico e retirado de uma classe ou uma inst ancia
de classe, o valor realmente retornado do objeto e o objeto empacotado, que n ao e objeto de qualquer
outra transformac ao. Objetos de m etodos est aticos n ao s ao chamados por si pr oprios, embora os
objetos sejam normalmente embrulhados. Objetos de m etodos est aticos s ao criados pelo construtor
staticmethod() embutido.
Objetos de m etodos de classe Um objeto de m etodo de classe, como um objeto de m etodo est atico, e um
empacotador em torno de outro objeto que altera a maneira em que este objeto e retirado das classes e
inst ancias de classes. O comportamento dos objetos dos m etodos das classes acima tal como retirada
e descrita abaixo, em M etodos denidos pelo usu ario. Objetos de m etodos de classes s ao criados
pelo construtor embutido classmethod().
3.3 Nomes de m etodos especiais
Uma classe pode implementar certas operac oes que s ao chamadas por sintaxe especial (tais como operac oes ar-
itm eticas ou acesso a posic oes e fatiamento em cont einers) pela denic ao de m etodos com nomes especiais.
Esta e a maneira de Python para sobrecarga de operador, permitindo ` as classes que denam o seu pr oprio com-
portamento em relac ao aos operadores da linguagem. Por exemplo, se uma classe dene um m etodo chamado
__getitem__(), e x e uma inst ancia desta classe, ent ao x[i] e equivalente ao x.__getitem__(i). Ex-
ceto onde mencionado, tentar executar uma operac ao lanca uma excec ao quando nenhum m etodo apropriado e
denido.
Quando a implementac ao de uma classe emula qualquer tipo embutido, e importante que a emulac ao somente seja
implementada para o grau em que ela faz sentido para o objeto que esteja sendo modelado. Por exemplo, algumas
seq u encias podem funcionar bem com a retirada de elementos individuais, mas extrair uma fatia pode n ao fazer
sentido. (Um exemplo disto e a interface NodeList no Documento de Modelo de Objetos da W3C).
3.3.1 Personalizac ao b asica
__new__(cls[, ... ])
Called to create a new instance of class cls. __new__() is a static method (special-cased so you need
not declare it as such) that takes the class of which an instance was requested as its rst argument. The
remaining arguments are those passed to the object constructor expression (the call to the class). The return
value of __new__() should be the new object instance (usually an instance of cls).
Typical implementations create a new instance of the class by invoking the superclasss __new__()
method using super(currentclass, cls).__new__(cls[, ...]) with appropriate arguments and
then modifying the newly-created instance as necessary before returning it.
If __new__() returns an instance of cls, then the new instances __init__() method will be invoked
like __init__(self [, ...]), where self is the new instance and the remaining arguments are the
same as were passed to __new__().
If __new__() does not return an instance of cls, then the new instances __init__() method will not
be invoked.
__new__() is intended mainly to allow subclasses of immutable types (like int, str, or tuple) to customize
instance creation.
__init__(self [, ... ])
Chamado quando a inst ancia e criada. Os argumentos s ao aqueles passados para a express ao que chama o
construtor da classe. Se uma classe base possui um m etodo __init__(), o m etodo __init__() da
classe derivada, se existir, deve explicitamente cham a-lo para garantir uma correta inicializac ao da parte da
inst ancia que est a na classe base; por exemplo: BaseClass.__init__(self , [args...]). Como
uma caracterstica especial dos construtores, estes n ao devem retornar nenhum valor; isto ir a fazer com que
uma TypeError seja lancada em tempo de execuc ao.
__del__(self )
Chamado quando uma inst ancia est a para ser destruda. Tamb em conhecido como destrutor. Se uma classe
base possui um m etodo __del__(), o m etodo __del__() da classe derivada, se existir, deve explici-
tamente cham a-lo para garantir uma correta delec ao da parte da inst ancia que est a na classe base. Note
que e possvel (mas n ao recomendado!) que o m etodo __del__() adie a destruic ao da inst ancia criando
uma nova refer encia para ela. O m etodo pode ser chamado em outro momento quando esta nova refer encia
e deletada. N ao e garantido que m etodos __del__() sejam chamados para objetos que ainda existam
quando o interpretador naliza.
Note: del x n ao chama diretamente x.__del__() a express ao decrementa a contagem de re-
fer encias para x em um, e __del__() somente ser a chamado quando o contador de refer encias de xs
chegar a zero. Algumas situac oes comuns para evitar que o contador de refer encias de um objeto chegue
a zero incluem: refer encias circulares entre objetos (ex., uma lista duplamente encadeada ou uma estru-
tura de dados em arvore com ponteiros pai e lho); uma refer encia para o objeto na pilha de uma func ao
que captura uma excess ao (o traceback armazenado em sys.exc_traceback mant em a pilha viva);
ou uma refer encia para o objeto em uma pilha que lancou uma excess ao n ao capturada no modo interativo
(o traceback armazenado em mant em a pilha viva). A primeira situac ao s o pode ser remediada atrav es da
3.3. Nomes de m etodos especiais 21
quebra explcita dos crculos; as duas ultimas situac oes podem ser resolvidas armezenando-se None em
sys.exc_traceback ou sys.last_traceback. Refer encias circulares que forem lixo s ao detec-
tadas quando a opc ao de detector de ciclos estiver habilitada (o padr ao), mas apenas podem ser limpas se
n ao existir nenhum m etodo __del__() em nvel do Python envolvido. Veja a documentac ao do m odulo
gc para obter mais informac oes sobre como m etodos __del__() s ao tratados pelo detector de ciclos,
particularmente na descric ao do valor garbage.
Devido a circunst ancias prec arias sob as quais os m etodos __del__() s ao invocados, excess oes que ocor-
rerem durante sua execuc ao s ao ignoradas, e ao inv es um (warning) (aviso) e impresso em sys.stderr.
Al em disso, quando __del__() e invocado em resposta a um m odulo sendo deletado (ex. quando a
execuc ao do programa termina), outros objetos globais referenciados pelo m etodo __del__() j a podem
ter sido deletados. Por essa raz ao, m etodos __del__() devem fazer mnimo necess ario para manter in-
variantes externas. A partir da vers ao 1.5, Python garante que objetos globais cujo nome comeca com um
simples underscore (_) s ao deletados de seus m odulos antes que outros objetos globais forem deletados;
se n ao existir mais nenhuma refer encia para tais objetos globais, ajuda a garantir que m odulos importados
ainda estejam disponveis no momento que o m etodo __del__() for chamado.
__repr__(self )
Chamado pela func ao interna repr() e por convers oes em string (aspas reversas) para computar a
representac ao ocial em string de um objeto. Se for possvel, deve ser uma express ao Python v alida
que pode ser usada para recriar um objeto com o mesmo valor (dado um ambiente apropriado). Se isso n ao
for possvel, uma string na forma <...alguma descricao util...> deve ser retornada. O valor retornado deve
ser um objeto string. Se uma classe dene __repr__() mas n ao __str__(), ent ao __repr__() e
tamb em usado quando uma representac ao informal em string de uma inst ancia da classe for requerida.
Isto e tipicamente usado para depurac ao, ent ao e importante que a representac ao seja ricamente informativa
e n ao ambgua.
__str__(self )
Chamado pela func ao interna str() e pela express ao print para computar a representac ao informal
em string de um objeto. Se difere de __repr__() no que esta n ao precisa ser uma express ao Python
v alida: ao inv es, uma representac ao mais conveniente e concisa deve ser usada. O valor de retorno deve ser
um objeto string.
__lt__(self, other)
__le__(self, other)
__eq__(self, other)
__ne__(self, other)
__gt__(self, other)
__ge__(self, other)
New in version 2.1. Estes s ao amplamente chamados de m etodo para comparac ao rica, e s ao chamados
pelos operadores de comparac ao em prefer encia ao m etodo __cmp__() abaixo. A correspond encia entre
os smbolos de operadores e os nomes dos m etodos s ao as seguintes: x<y chama x.__lt__(y), x<=y
chama x.__le__(y), x==y chama x.__eq__(y), x!=y e x<>y chamam x.__ne__(y), x>y chama
x.__gt__(y), e x>=y chama x.__ge__(y). Estes m etodos podem retornar qualquer valor, mas se o
operador de comparac ao e usado em um contexto Booleano, o valor de retorno deve ser interpret avel como
um valor Booleano, se n ao TypeError ser a lancada. Por convenc ao, False para falso e True para true.
N ao h a nenhum relacionamento implcito entre os operadores de comparac ao. A validade de x==y n ao
implica que x!=y e falso. Similarmente, quando se dene __eq__(), __ne__ tamb em deve ser denido,
de modo que os operadores se comportem como esperado.
N ao existe nenhuma vers ao especicamente reexiva (argumento de troca) desses m etodos (para serem
usadas quando o argumento da esquerda n ao suporta a operac ao, mas o da direita suporta); ao inv es, __-
lt__() e __gt__() s ao reexivos um do outro, __le__() e __ge__() s ao reexivos um do outro,
e __eq__() e __ne__() s ao suas pr oprias reex oes.
Argumentos em comparac oes ricas nunca sofrem coerc ao. Um m etodo de comparac ao rica deve retornar
NotImplemented se n ao suportar a operac ao para um dado par de argumentos.
__cmp__(self, other)
Chamado por operadores de comparac ao se comparac oes ricas (veja acima) n ao estiverem denidas. Deve
retornar um valor negativo se self < other, zero se self == other, um inteiro positivo se self
< other. Se nenhuma das operac oes __cmp__(), __eq__() ou __ne__() estiverem denidas,
inst ancias da classe s ao comparadas pela identidade do objeto (endereco). Veja tamb em a descric ao de
__hash__() para algumas importantes notas sobre a criac ao de objetos que suportam operac oes person-
alizadas e s ao us aveis como chaves de dicion arios. (Nota: a restric ao onde excess oes n ao s ao propagadas
por __cmp__() foram removidas desde Python 1.5.)
__rcmp__(self, other)
Changed in version 2.1: N ao mais suportado.
__hash__(self )
Chamado em operac oes com o objeto chave usado em dicion ario , e pela func ao interna hash(). Deve
retornar um inteiro de 32 bits us avel como um valor hash em operac oes com dicion arios. A unica pro-
priedade requerida e que objetos que possuem igualdade de comparac ao devem ter o mesmo valor hash; e
recomendado que de algum modo sejam colocados juntos (ex., usando ou exclusivo), os valores hash para
componentes que tamb em s ao objetos compar aveis. Se uma classe n ao dene um m etodo __cmp__()
n ao deve denir uma operac ao __hash__() tamb em; se ele dene __cmp__() ou __eq__() mas n ao
__hash__(), suas inst ancias n ao ser ao us aveis como chaves de dicion arios. Se uma classe dene objetos
mut aveis e implementa o m etodo __cmp__() ou __eq__(), ela n ao deve implementar __hash__(),
uma vez que a implementac ao de dicion ario requer que o valor hash seja imut avel (se o valor hash do objeto
mudar, estar a em um uso errado do hash).
__nonzero__(self )
Chamado para implementar o valor de teste de verdade, e a operac ao interna bool(); deve retornar False
ou True, ou seus valores inteiros 0 or 1. Quando este m etodo n ao est a denido, __len__() e chamado,
se estiver denido (veja abaixo). Se uma classe n ao dene __len__() nem __nonzero__(), todas as
suas inst ancias s ao consideradas verdadeiras.
__unicode__(self )
Chamado para implementar a func ao interna unicode(); deve retornar um objeto Unicode. Quando
este m etodo n ao est a denido, convers oes em string ser ao tentadas, e o resultado da convers ao em string e
convertido em Unicode usando a codicac ao padr ao do sistema.
3.3.2 Personalizando o acesso a atributos
Os m etodos seguintes podem ser denidos para customizar o modo de acesso a atributos (uso de, atribuic ao para,
ou delec ao de x.name) em inst ancias de classes.
__getattr__(self, name)
Chamado quando a busca por um atributo n ao o encontra nos lugares usuais (i.e., n ao e um atributo da
inst ancia nem foi encontrado na arvore da classe em self). name e o nome do atributo. Este m etodo deve
retornar o valor do atributo (computado) ou lancar uma excess ao AttributeError.
Note que se o atributo e encontrado atrav es do mecanismo normal, __getattr__() n ao e chamado.
(Essa e uma intencional assimetria entre __getattr__() e __setattr__().) Isso e feito em am-
bos por quest oes de eci encia e porque de outro modo __setattr__() n ao teria como acessar outros
atributos da inst ancia. Note que pelo menos para vari aveis de inst ancia, voc e pode falsicar totalmente o
controle n ao inserindo quaisquer valores no dicion ario de atributos da inst ancia (mas ao inv es inser-los em
outro objeto). Veja o m etodo __getattribute__() abaixo para um modo de atualmente obter controle
total em classes new-style.
__setattr__(self, name, value)
Chamado quando ocorre uma atribuic ao a algum atributo. Este m etodo e chamado ao inv es do mecanismo
normal (i.e. armazenar o valor no dicion ario da inst ancia). name e o nome do atributo, value e o valor a ser
atribudo a ele.
Se __setattr__() pretende atribuir um valor a um atributo de uma inst ancia, ele n ao deve simplesmente
executar self.name = value isso causaria uma chamada recursiva a si mesmo. Ao inv es, deve
inserir o valor no dicion ario de atributos da inst ancia, ex., self.__dict__[name] = value. Para
classes new-style, ao inv es de acessar o dicion ario da inst ancia, deve chamar o m etodo da classe base com
o mesmo nome, por exemplo, object.__setattr__(self, name, value).
__delattr__(self, name)
Similar a __setattr__(), mas para a delec ao de um atributo ao inv es de atribuic ao. Este s o deve ser
implementado se del obj.name e signicativo para o objeto.
Mais sobre acesso a atributos para classes new-style
Os m etodos seguintes s o se aplicam para classes new-style.
__getattribute__(self, name)
Chamado incondicionalmente para implementar acesso a atributos para inst ancias da classe. Se a classe
tamb em dene __getattr__, ele n ao ser a chamado a menos que __getattribute__ chame-o ex-
plicitamente ou levante uma excec ao AttributeError. Este m etodo deve retornar o valor (computado)
do atributo ou lancar um excess ao AttributeError. Para evitar recurs ao innita neste m etodo, sua
implementac ao deve sempre chamar o m etodo da classe base com o mesmo nome para acessar quaisquer
atributos se necess ario, por exemplo, object.__getattribute__(self, name).
Implementando Descritores
Os m etodos seguintes apenas se aplicam quando a inst ancia da classe contendo o m etodo (a chamada classe
descriptor (descritora)) aparece no dicion ario de outra classe new-style, conhecida como classe propriet aria. Nos
exemplos abaixo, o atributo refere-se ao atributo cujo nome e a chave da propriedade na classe propriet aria
__dict__. Descritores s o podem ser implementados ocmo classes new-style.
__get__(self, instance, owner)
Chamado para ler o atributo da classe propriet aria (acesso ao atributo da classe) ou de uma inst ancia dessa
classe (acesso ao atributo da inst ancia). owner e sempre a classe propriet aria, enquanto instance e a inst ancia
atrav es da qual o atributo est a sendo acessado, ou None quando o atributo e acessado atrav es de owner. Este
m etodo deve retornar o valor (computado) do atributo ou lancar uma excess ao AttributeError.
__set__(self, instance, value)
Chamado para atribuir um novo valor value ao atributo em uma inst ancia instance da classe propriet aria.
__delete__(self, instance)
Chamado para deletar o atributo em uma inst ancia instance da classe propriet aria.
Invocando Descritores
Em geral, um descritor e um atributo de um objeto com comportamento de ligac ao, no qual o acesso a atributos
foi sobrescrito por m etodos no protocolo de descritor: __get__(), __set__(), e __delete__(). Se
qualquer destes m etodos est ao denidos para um objeto, ele e chamado de descritor.
O comportamento padr ao para acessar atributos e ler, atribuir, ou deletar o atributo do dicion ario de um ob-
jeto. Para uma inst ancia, a.x possui uma corrente de localizac ao comecando com a.__dict__[x], de-
pois type(a).__dict__[x], e continuando atrav es das classes base de type(a), excluindo-se as meta-
classes.
Entretanto, se o valor procurado e um objeto que dene um dos m etodos descritores, ent ao Python pode sobrescr-
ever o comportamento padr ao e invocar ao inv es o m etodo descritor. Onde isto ir a ocorrer na corrente de preced-
ncia depende de onde os m etodos descritores est ao denidos e como eles s ao chamados. Note que descritores s ao
apenas invocados para objetos ou classes new-style (aquelas que extendem object() ou type()).
O ponto de partida da invocac ao de um descritor e uma ligac ao, a.x. Como os argumentos s ao montados depende
de a:
Chamada Direta A maneira mais simples e menos comum de chamada e quando o c odigo do usu ario diretamente invoca um
m etodo descritor: x.__get__(a).
Ligac ao de Inst ancia Se ligada a uma inst ancia de um objeto new-style, a.x e transformado na chamada: type(a).__dict_-
_[x].__get__(a, type(a)).
Ligac ao de Classe Se ligada a uma classe new-style, A.x e transformada na chamada: A.__dict__[x].__get__-
(None, A).
Super Ligac ao Se a e uma inst ancia de super, ent ao a ligac ao super(B, obj).m() busca obj.__class__._-
_mro__ para a classe base A imediatamente precedendo B e ent ao invoca o descritor com a chamada:
A.__dict__[m].__get__(obj, A).
Para ligac oes de inst ancia, a preced encia de invocac ao de descritor depende de quais m etodos descritores est ao
denidos. Descritores de dados denem tanto __get__() quanto __set__(). Descritores que n ao repre-
sentam dados (non-data) possuem apenas o m etodo __get__(). Descritores de dados sempre sobrescrevem
uma redenic ao em um dicion ario de inst ancia. Em constraste, descritores que n ao representam dados podem ser
sobrescritos pelas inst ancias.
M etodos Python (incluindo staticmethod() e classmethod()) s ao implementados como descritores non-
data. Deste modo, inst ancias podem redenir e sobrescrever m etodos. Isto permite a inst ancias individuais
adiquirirem comportamentos que as diferem de outras inst ancias da mesma classe.
A func ao property() e implementadas como um descritor de dados. Deste modo, inst ancias n ao podem
sobrescrever o comportamento de uma propriedade.
slots
Por padr ao, inst ancias de ambas as classes antigas e new-style possuem um dicion ario para armazenamento de
atributos. Isto disperdica espaco para objetos contendo muito poucas vari aveis de inst ancia. O consumo de espaco
pode se tornar prejudicial ao se criar um grande n umero de inst ancias.
O padr ao pode ser sobrescrito pela denic ao de slots em classes new-style. A declarac ao de slots toma uma
sequ encia de vari aveis de inst ancia e reserva apenas espaco suciente em cada inst ancia para guardar um valor
para cada vari avel. Espaco e economizado porque dict n ao e criado para cada inst ancia.
__slots__
A esta vari avel de classe pode ser atribuda uma string, um inter avel, ou uma sequ encia de strings com
nomes vari aveis usados pelas inst ancias. Se denido em uma classe new-style, slots reserva espaco para
as vari aveis declaradas e previne a autom atica criac ao de dict e weakref para cada inst ancia. New in
version 2.2.
Notas ao usar slots
Se uma vari avel dict , inst ancias n ao podem atribuir novas vari aveis n ao listadas na denic ao de slots .
Tentativas de atribuir ` a uma vari avel cujo nome n ao tenha sido listado lancam AttributeError. Se a
atribuic ao din amica de novas vari aveis e desejada, ent ao adicione __dict__ para a sequ encia de string
na declarac ao de slots . Changed in version 2.3: Antigamente, adicionando __dict__ ` a declarac ao
de slots n ao habilitaria a atribuic ao de novos atributos n ao especicamente listados na sequ encia de
nomes de vari aveis de inst ancia.
Sem uma vari avel weakref para cada inst ancia, classes que denem slots n ao suportam refer encias
fracas para suas inst ancias. Se o suporte a refer encia fraca e necess ario, ent ao adicione __weakref__
` a sequ encia de string na declarac ao de slots . Changed in version 2.3: Antigamentem, adicionando
__weakref__ ` a declarac ao de slots n ao habilitaria o suporte para refer encias fracas.
slots e implementado em nvel de classe pela criac ao de descritores (3.3.2) para cada nome de vari avel.
Como resultado, atributos de classe n ao podem ser usados para atribuir valores padr ao para vari aveis de
inst ancia denidos por slots ; de outro modo, o atributo da classe sobrescreveria a atribuic ao do descritor.
Se uma classe dene um slot tamb em denido na classe base, a vari avel de inst ancia denida pelo slot
da classe base e inacessvel (exceto retornando seu descritor diretamente da classe base). Isto rende um
comportamento indenido do programa. No futuro, uma vericac ao deve ser adicionada para prevenir isso.
A ac ao da declarac ao de slots e limitada ` a classe onde ele est a denido. Como resultado, subclasses
ter ao um dict a menos que elas tamb em denam slots .
slots n ao funcionam para classes derivadas de tipos internos de tamanho vari avel como long, str
and tuple.
Qualquer iter avel n ao string pode ser atribudo ` a slots . Mapas tamb em podem ser usados; entretando,
no futuro, comportamento especial pode ser adicionado aos valores correspondentes a cada chave.
3.3.3 Personalizando a criac ao de classes
Por padr ao, classes new-style s ao construdas usando type(). Uma denic ao de classe e lida dentro de um
namespace separado e o valor do nome da classe e anexado ao resultado de type(name, bases, dict).
Quando a denic ao de uma classe e lida, se metaclass est a denida ent ao a classe execut avel (callable)
atribuda a eke ser a chamada ao inv es de type(). Isto permite que classes e func oes sejamescritas para monitorar
ou alterar o processo de criac ao da classe:
Modicando o dicion ario da classe previamente ` a criac ao da classe.
Retornando uma inst ancia de outra classe essencialmente realizando a regra de uma uma func ao f abrica.
__metaclass__
Esta vari avel pode ser qualquer classe execut avel (callable) que aceite os argumentos name, bases, e
dict. Na criac ao da classe, o execut avel e usado ao inv es do interno type(). New in version 2.2.
A metaclasse apropriadas e determinada pelas seguintes regras de preced encia:
Se dict[__metaclass__] existe, e usado.
Caso contr ario, se existe pelo menos uma classe base, sua metaclasse e usada (procura-se por um atributo
class primeiro e se n ao encontrado, usa seu tipo).
Caso contr ario, se uma vari avel global chamada metaclass existe, pe usada.
Caso contr ario, o estilo antigo, com metaclasse cl assica (types.ClassType) e usado.
O uso potencial de metaclasses n ao possui limites. Algumas id eias que tem sido exploradas incluem log-
ging, vericac ao de interface, delegac ao autom atica, criac ao de propriedades autom atica, proxies, frameworks,
e locking/sincronizac ao de recursos autom atico.
3.3.4 Emulando objetos execut aveis (callable)
__call__(self [, args... ])
Chamado quando a inst ancia e executada como uma func ao; se este m etodo est a denido, x(arg1,
arg2, ...) e um atalho para x.__call__(arg1, arg2, ...).
3.3.5 Emulando tipos cont einer
Os m etodos seguintes podem ser denidos para implementar objetos cont einer. Cont eineres em geral s ao
sequ encias (como listas e tuplas) ou mapas (como dicion arios), mas podem representar outros cont einers do
mesmo modo. O primeiro conjunto de m etodos e usado tanto para emular uma sequ encia quando para emular um
mapa; a diferenca e que para uma sequ encia, as chaves permitidas devem ser inteiros k, para 0 <= k < N onde
N e o tamanho da sequ encia, ou objetos fatia, que denem uma faixa de itens. (Para compatibilidade com vers oes
anteriores, o m etodo __getslice__() (veja abaixo) tamb em de ser denido para lidar com fatias simples, mas
n ao extendidas. Tamb em e recomendado que mapas provenham os m etodos keys(), values(), items(),
has_key(), get(), clear(), setdefault(), iterkeys(), itervalues(), iteritems(),
pop(), popitem(), copy(), e update() se comportando de modo similar aos dicion arios padr ao de
Python. O m odulo UserDict prov e uma classe DictMixin para ajudar na criac ao daqueles m etodos de um
conjunto base de __getitem__(), __setitem__(), __delitem__(), e keys(). Sequ encias mut aveis
devem prover m etodos append(), count(), index(), extend(), insert(), pop(), remove(),
reverse() e sort(), como os objetos lista padr oes de Python. Finalmente, tipos sequ encia devem imple-
mentar adic ao (no sentido de concatenac ao) e multiplicac ao (no sentido de repetic ao) pela denic ao dos m etodos
__add__(), __radd__(), __iadd__(), __mul__(), __rmul__() e __imul__() descritos abaixo;
eles n ao devem denir __coerce__() ou outros operadores num ericos.

E recomendado que ambos os mapas e
sequ encias implementem o m etodo __contains__() para permitir o uso eciente do operador in; para ma-
pas, in deve ser equivalente a has_key(); para sequ encias, deve buscar atrav es dos valores. Adicionalmente
e recomendado que ambos mapas e sequ encias implementem o m etodo __iter__() para permitir interac ao
eciente atrav es do cont einer; para mapas, __iter__() deve ser o mesmo que iterkeys(); para sequ encias,
deve iterar sobre seus valores.
__len__(self )
Chamado para implementar a func ao interna len(). Al em disso, um objeto que n ao tenha denido um
m etodo __nonzero__() e cujo m etodo __len__() retorne zero ser a considerado falso emumcontexto
Booleano.
__getitem__(self, key)
Chamado para implementar a avaliac ao de self [key]. Para tipos sequ encia, as chaves aceitas devem ser
inteiros e objetos fatia. Note que a interpretac ao especial de ndices negativos (se a classe deseja emu-
lar um tipo sequ encia) deve ser feita no m etodo __getitem__(). Se key e de um tipo inapropriado,
TypeError deve ser lancado; se for um valor fora do conjunto de ndices da sequ encia (depois de qual-
quer interpretac ao especial de valores negativos), IndexError deve ser lancado. Para mapeamentos, se
a chave (key) estiver faltando (n ao estiver no conteiner), KeyError deve ser levantada. Note: for loops
esperam que IndexError seja lancado para ndices ilegais para permitir uma detecc ao adequada do nal
da sequ encia.
__setitem__(self, key, value)
Chamado para implememyar atribuic ao para self [key]. Se aplicam os mesmos coment arios que __-
getitem__(). Este m etodo somente deve ser implementado para mapas se os objetos nos valores para as
chaves dadas suportam alterac oes, ou se novas chaves podem ser adicionadas, ou para sequ encias se elemen-
tos podem ser substitudos. As mesmas excess oes do m etodo devem ser lancadas para valores impr oprios
de key.
__delitem__(self, key)
Chamado para implementar delec ao de self [key]. Se aplicam os mesmos coment arios que __getitem_-
_(). Este m etodo somente deve ser implementado para mapas se os objetos suportam remoc ao de chaves,
ou para sequ encias se elementos podem ser removidos dela. As mesmas excess oes do m etodo devem ser
lancadas para valores impr oprios de key. __getitem__() method.
__iter__(self )
Este m etodo e chamado quando um iterador e requerido para o cont einer. Este m etodo deve retornar um
novo objeto iterador que possa iterar sobre todos os objetos do cont einer. Para mapas, deve iterar sobre as
chaves do cont einer, e tamb em deve estar disponvel como no m etodo iterkeys().
Objetos iteradores tamb em precisam implementar este m etodo; neste caso e requerido que eles retornem a si
pr oprios. Para mais informac oes sobre objetos iteradores, veja Iterator Types em Refer encia da Biblioteca
Python.
Os operadores de teste de exist encia de um membro (in and not in) s ao normalmente implementados como
uma iterac ao atrav es da sequ encia. Entretanto, objetos cont einer podem suprir o seguinte m etodo especial como
uma implementac ao mais eciente, que tamb em n ao requer que o objeto seja uma sequ encia.
__contains__(self, item)
Chamado para implementar operadores de teste de exist encia de um membro. Deve retornar verdadeiro se
item est a em self , falso caso contr ario. Para objetos mapa, deve considerar as chaves do mapas ao inv es dos
valores ou dos pares chave-tem.
3.3.6 M etodos adicionais para emulac ao de tipos sequ encia
Os seguintes m etodos opcionais podem ser denidos para incrementar a emulac ao de objetos sequ encia. M etodos
de sequ encias imut aveis devem no m aximo denir __getslice__(); sequ encias mut aveis podem denir todos
os tr es m etodos.
__getslice__(self, i, j)
Deprecated since release 2.0. Suporte de objetos fatia como par ametros para o m etodo __getitem__().
Chamado para implemenyar a avaliac ao de self [i:j]. O objeto retornado deve ser do mesmo tipo de
self . Note que omitindo i ou j na express ao fatia os valores ser ao substitudos por zero ou sys.maxint,
respectivamente. Se ndices negativos s ao usados na fatia, o tamanho da sequ encia e adicionado ` aquele
ndice. Se a inst ancia n ao implementa o m etodo __len__(), AttributeError e lencada. Nenhuma
garantia e feita de que ndces ajustados deste modo n ao continuem negativos.

Indices maiores do que o
tamanho da sequ encia n ao s ao modicados. Se __getslice__() n ao for encontrado, um objeto fatia e
criado, e passado para __getitem__().
__setslice__(self, i, j, sequence)
Chamado para implementar atribuic ao a self [i:j]. Se aplicam os mesmos coment arios de i e j em __-
getslice__(). Este m etodo est a obsoleto. Se __setslice__() n ao for encontrado, ou para fatia
extendida na forma self [i:j:k], um objeto fatia e criado, e passado para __setitem__(), ao inv es de
chamar __setslice__().
__delslice__(self, i, j)
Chamado para implementar a delec ao de self [i:j]. Se aplicam os mesmos coment arios de i e j em __-
getslice__(). Este m etodo est a obsoleto. Se __delslice__() n ao for encontrado, ou para fatia
extendida na forma self [i:j:k], um objeto fatia e criado, e passado para __delitem__(), ao inv es de
chamar __delslice__().
Note que estes m etodos apenas s ao invocados quando uma unica fatia com uma unica vrgula e usada, e o m etodo
de fatiamento est a disponvel. Para operac oes de fatiamento involvendo notac ao de fatiamento extendida, ou na
aus encia de m etodos de fatiamento, __getitem__(), __setitem__() ou __delitem__() e chamado
com um objeto fatia como argumento.
O seguinte exemplo demonstra como fazer com que seu programa ou m odulo seja compatvel com vers oes antigas
de Python (assumindo que os m etodos __getitem__(), __setitem__() and __delitem__() suportem
objetos fatia como argumentos):
class MyClass:
...
def __getitem__(self, index):
...
def __setitem__(self, index, value):
...
def __delitem__(self, index):
...
if sys.version_info < (2, 0):
# They wont be defined if version is at least 2.0 final
def __getslice__(self, i, j):
return self[max(0, i):max(0, j):]
def __setslice__(self, i, j, seq):
self[max(0, i):max(0, j):] = seq
def __delslice__(self, i, j):
del self[max(0, i):max(0, j):]
...
Note as chamadas a max(); elas s ao necess arias para tratar ndices negativos antes que os m etodos __*slice_-
_() sejam chamados. Quando ndices negativos s ao usados, os m etodos __*item__() os recebem como s ao
fornecidos, mas os m etodos __*slice__() recebem uma forma preparada dos valores dos ndices. Para
cada valor de ndice negativo, o tamanho da sequ encia e adicionado ao ndice antes de chamar o m etodo (o
que ainda pode resultar em um ndice negativo); este e o tratamento habitual de ndices negativos pelas tipos
sequ encia internos, e espera-se que os m etodos __*item__() procedam deste modo. Entretanto, uma vez que
eles j a devem ter feito isto, ndices negativos n ao podem ser passados; eles devem ser forcados para os limites
da sequ encia antes de serem passados ao m etodos __*item__(). Chamando max(0, i) covenientemente
retorna o valor apropriado.
3.3.7 Emulando tipos num ericos
Os m etodos seguintes podem ser denidos para emular objetos num ericos. M etodos correspondentes a operac oes
que n ao s ao suportadas pelo tipo particular de n umero implementado (ex., operac oes bit a bit para n umeros n ao
inteiros) devem ser deixadas indenidas.
__add__(self, other)
__sub__(self, other)
__mul__(self, other)
__floordiv__(self, other)
__mod__(self, other)
__divmod__(self, other)
__pow__(self, other[, modulo])
__lshift__(self, other)
__rshift__(self, other)
__and__(self, other)
__xor__(self, other)
__or__(self, other)
Estes m etodos s ao chamados para implementar as operac oes aritm eticas bin arias (+, -, *, //, %,
divmod(), pow(), **, <<, >>, &, , |). Por exemplo, para avaliar a express ao x+y, onde x e uma
inst ancia da classe que possui um m etodo __add__(), x.__add__(y). O m etodo __divmod__()
deve ser equivalente ao uso de __floordiv__() e __mod__(); ele n ao deve ser relacionado com
__truediv__() (descrito abaixo). Note que __pow__() deve ser denido para aceitar um terceiro
argumento opcional se pretende-se suportar aa vers ao tern aria de pow().
__div__(self, other)
__truediv__(self, other)
O operador de divis ao (/) e implementado por estes m etodos. O m etodo __truediv__() e usado quando
__future__.division est a ativado, caso contr ario, __div__() e usado. Se somente um destes dois
m etodos est a denido, o objeto n ao ir a suportar divis ao no contexto alternativo; TypeError ser a lancada
ao inv es.
__radd__(self, other)
__rsub__(self, other)
__rmul__(self, other)
__rdiv__(self, other)
__rtruediv__(self, other)
__rfloordiv__(self, other)
__rmod__(self, other)
__rdivmod__(self, other)
__rpow__(self, other)
__rlshift__(self, other)
__rrshift__(self, other)
__rand__(self, other)
__rxor__(self, other)
__ror__(self, other)
Estes m etodos s ao chamados para implmentar as operac oes aritm eticas bin arias (+, -, *, /, %, divmod(),
pow(), **, <<, >>, &, , |) com os operadores reetidos (trocados). Estas func oes apenas s ao chamadas
se o operador da esquerda n ao suporta a operac ao correspondente. Por exemplo, para avaliar a express ao
x-y, onde y e uma inst ancia da classe que tem um m etodo __rsub__(), y.__rsub__(x) e chamado.
Note que a func ao tern aria pow() n ao tentar a chamar __rpow__() (as regras de coerc ao se tornariam
muito complicadas).
__iadd__(self, other)
__isub__(self, other)
__imul__(self, other)
__idiv__(self, other)
__itruediv__(self, other)
__ifloordiv__(self, other)
__imod__(self, other)
__ipow__(self, other[, modulo])
__ilshift__(self, other)
__irshift__(self, other)
__iand__(self, other)
__ixor__(self, other)
__ior__(self, other)
Estes m etodos s ao chamados para implementar as operac oes aritm eticas de aumento (+=, -=, *=, /=,
%=, **=, <<=, >>=, &=, =, |=). Estes m etodos devem tentar realizar a operac ao de modo (in-place)
(modicando self ) e retornar o resultado (o que poderia ser, mas n ao necessariamente, self ). Se um m etodo
especco n ao est a denido, a operac ao de aumento cai nos m etodos normais. Por exemplo, para avaliar a
express ao x+=y, onde x e uma inst ancia da classe que possui um m etodo __iadd__(), x.__iadd__(y)
e chamado. Se x e uma inst ancia de uma classe que n ao dene um m etodo __iadd__(), x.__add__(y)
e y.__radd__(x) s ao considerados, como na avaliac ao de x+y.
__neg__(self )
__pos__(self )
__abs__(self )
__invert__(self )
Chamado para implementar as operac oes aritm eticas un arias (-, +, abs() and ).
__complex__(self )
__int__(self )
__long__(self )
__float__(self )
Chamado para implementar as func oes internas complex(), int(), long(), and float(). Deve
retornar um valor do tipo apropriado.
__oct__(self )
__hex__(self )
Chamado para implementar as func oes internas oct() e hex(). Deve retornar um valor em string.
__coerce__(self, other)
Chamado para implementar o modo misto de n umeros aritm eticos. Deve retornar uma tupla de dois ele-
mentos contendo self e other convertidos a um tipo num erico comum, ou None se a convers ao e impossvel.
Quando o tipo comum seria do tipo de other, e insuciente retornar None, uma vez que o interpretador
tamb em ir a perguntar ao outro objeto para tentar a coerc ao. (mas ` as vezes, se a implementac ao do outro
tipo n ao pode ser e util fazer a convers ao para o outro tipo aqui). Retornar o valor NotImplemented e
equivalente a retornar None.
3.3.8 Regras de coerc ao
Esta sec ao costumava documentar as regras de coerc ao.
`
A medida que a linguagem evoluiu, estas regras
se tornaram difceis de documentar com precis ao; descrever aquilo que uma determinada vers ao de uma
implementac ao em particular faz e indesej avel. Ao inv es disso, aqui segue um guia informal de algumas regras.
Em Python 3.0, coerc ao n ao ser a mais suportada.
Se o operando esquerdo de um operador % e uma string ou um objeto Unicode, nenhuma coerc ao ocorre.
Ao inv es disso, e executada a operac ao de formatac ao da string.
N ao e mais recomend avel denir um operador de coerc ao. Operac oes em tipos que n ao denem coerc ao
passam os argumentos originais para a operac ao.
Classes new-style (aquelas derivadas de object) nunca invocam o m etodo __coerce__() em resposta
a um operador bin ario; o unico momento em que __coerce__() e chamado e quando a func ao interna
coerce() e usada.
Para a maioria das aplicac oes, um operador que retorna NotImplemented e tratado da mesma forma que
um que realmente n ao esteja implementado.
Logo abaixo, os m etodos __op__() e __rop__() s ao usados para simbolizar os nomes gen ericos de
m etodos correspondentes a um operador; o m etodo __iop__() e usado para o operador correspondente
que realiza a operac ao no lugar (in-place), sem criar um novo objeto. Por exemplo, para o operador +,
__add__() e __radd__() s ao usados para as vari aveis esquerda e direita do operador bin ario, e __-
iadd__() para a variante que realiza a operac ao no lugar (in-place).
Para objetos x e y, primeiro tentamosx.__op__(y) . Se este n ao estiver implementado ou retornar
NotImplemented, tenta-se y.__rop__(x). Se este tamb em n ao estiver implementado ou retornar
NotImplemented, uma excec ao TypeError e levantada. H a uma excec ao para isso no pr oximo item:
Se o operando esquerdo e uma inst ancia de um tipo interno ou de uma classe new-style, e o operando
direito e uma inst ancia de uma subclasse apropriada, daquele tipo ou classe, o m etodo __rop__() do
operando ` a direita e tentado antes do m etodo __op__() do operando ` a esquerda. Isto e feito para que
uma subclasse possa redenir completamente os operadores bin arios. De outra forma, o m etodo op do
operando esquerdo sempre aceitaria o outro operando: quando uma inst ancia de uma determinada classe e
esperada, uma inst ancia de uma subclasse dela e sempre aceit avel.
Quando qualquer um dos operandos dene uma regra de coerc ao, esta regra e chamada antes do m etodo
__op__() ou __rop__() ser chamado, mas n ao antes disso. Se a coerc ao retorna um objeto de um tipo
diferente do operando cuja coerc ao foi invocada, parte do processo e refeita usando o objeto novo.
Quando um operador in-place (como +=) e usado, se o operando da esquerda implementa __iop__(),
ele e invocado sem nenhuma coerc ao. Quando a operac ao cai em__op__() e/ou __rop__(), se aplicam
as regras normais de coerc ao.
Em x+y, se x e uma sequ encia que implementa concatenac ao, x e y s ao ent ao concatenadas.
Em x*y, se um operador for uma sequ encia que implementa repetic oes, e a outra for um inteiro (int ou
long), e invocada a repetic ao da sequ encia.
Comparac oes ricas (implementadas pelos m etodos __eq__() dentre outros) nunca usam coerc ao.
Comparac oes de tr es vias (implementadas por __cmp__()) usam coerc ao sob as mesmas condic oes que
os outros operadores bin arios usam.
Na implementac ao atual, os tipos num ericos internos int, long e float n ao usam coerc ao; o tipo
complex por outro lado usa. A diferenca pode se tornar aparente quando extendemos estes tipos. Todo
o tempo, o tipo complex pode ser corrigido para evitar a coerc ao. Todos estes tipos implementam um
m etodo __coerce__(), para uso da func ao interna coerce().
32
CAP
ITULO
FOUR
Modelo de execuc ao
4.1 Nomeando e ligando
Nomes s ao refer encias a objetos e s ao introduzidos por operac oes de ligac ao.Cada ocorr encia de um nome no texto
de um programa se refere ` a ligac ao estabelecida a ele no bloco de func ao mais interno que o cont em.
Um bloco e uma parte do c odigo de um programa que e executada como uma unidade. S ao blocos: um m odulo, o
corpo de uma func ao, a denic ao de uma classe. Cada comando digitado no interpretador interativo e um bloco.
Assim como um arquivo de script (um arquivo passado como a entrada padr ao ao interpretador ou especicado na
primeira linha na linha de comando do interpretador) e um comando de script (um comando especicado na linha
de comando do interpretador usando a opc ao -c ). Um arquivo lido pela func ao built-in execfile() tamb em
e um bloco de c odigo. Um argumento do tipo string passado para a func ao built-in eval() e para o comando
exec e um bloco de c odigo, a mesma coisa uma express ao lida e executada pela func ao built-in input().
Um bloco de c odigo e executado em um quadro de execuc ao. Um quadro cont em informac oes administrativas
(usadas na depurac ao) e determina como e onde a execuc ao continuar a ap os o t ermino da execuc ao do bloco de
c odigo.
O escopo dene a visibilidade de um nome em um bloco. Se uma vari avel local e denida em um bloco, seu
escopo o inclui. Se a denic ao ocorre dentro de uma func ao o escopo se estende a qualquer bloco contido nessa, a
n ao ser que o bloco contido faca uma nova ligac ao ao nome. O escopo de nomes denidos em um bloco de classe
e limitado a esse, ele n ao se estende aos m etodos.
Quando um nome e usado em um bloco de c odigo e utilizada a denic ao do escopo mais pr oximo que encapsula
o nome. O conjunto de todos escopos visiveis a um bloco de c odigo e o ambiente do bloco.
Se um nome e ligado em um bloco ele e uma vari avel local, caso o nome seja ligado em nivel modular ele e uma
vari avel global (as vari aveis ligadas em nivel modular s ao tanto locais quanto locais.) Se uma vari avel for usada
em um bloco de c odigo em que n ao foi denida essa e uma vari avel livre.
Quando um nome n ao e encontrado, uma excec ao NameError e levantada. Se um nome se referir a uma vari avel
local que n ao foi ligada, uma excec ao UnboundLocalError e levantada. UnboundLocalError e uma
subclasse de NameError.
Os seguintes ligam nomes: par ametros de uma func ao, comandos import, denic oes de classes e func oes (esses
ligam o nome da classe ou func ao no bloco que est a sendo denido) e alvos que s ao identicadores se estiverem
acontecendo em uma denic ao, no cabecalho de um loop for, ou na segunda posic ao do cabecalho do comando
except. O comando import escrito desta maneira: from ...import * liga todos os nomes denidos
no m odulo importado, exceto aqueles que comecam com travess ao. Essa forma do comando s o pode ser utilizada
em nvel modular.
Seguindo essa id eia, o alvo do comando del tamb em pode ser considerado uma ligac ao (apesar da terminologia
mais correta ser desligar o nome).

E ilegal desligar um nome que e referenciado pelo escopo externo: o compilador
ir a reportar uma excec ao SyntaxError.
Designac oes ou comandos import devem ocorrer dentro do bloco denido por uma classe ou func ao ou em nivel
modular (o mais alto nivel de um c odigo).
Se uma operac ao de ligac ao de nome ocorre em qualquer ponto de um bloco, todo uso desse nome e tratado como
uma refer encia ao bloco atual.. Isso pode levar a erros quando um nome e usado em um bloco antes de ser ligado.
33
Python n ao possui declarac oes de vari aveis e permite que a ligac ao de um nome ocorra em qualquer lugar de
um bloco de c odigo. As vari aveis locais de um pedaco de c odigo podem ser determinadas apenas olhando as
operac oes de ligac ao que ocorreram no bloco.
No caso do comando global, todos os usos do nome especicado no comando se referem ` a ligac ao feita para aquele
nome no namespace de mais alto nvel. Nomes s ao adicionados a esse namespace ap os a procura por nomes no
namespace global (namespace do modulo contendo o bloco de c odigo) e o namespace builtin (namespace do
m odulo __builtin__). O global e buscado primeiro e, se o nome n ao for encontrado nele, o namespace builtin
e buscado. O comando global deve preceder qualquer uso do nome desejado.
O namespace built-in (embutido) associado com a execuc ao de um bloco de c odigo pode ser visualizado usando
o nome __builtins__ em seu namespace global. Esse nome deve ser um dicion ario ou um m odulo (no caso
anterior o dicion ario do m odulo foi usado). Normalmente o namespace __builtins__ e um dicion ario do
m odulo embutido __builtin__ (nota: sem s). Se n ao for, o modo de execuc ao restrita esta sendo usado.
O namespace de um m odulo e criado automaticamente da primeira vez que um m odulo e importado. O m odulo
principal de um script e sempre chamado de __main__.
A denic ao de uma classe e um comando execut avel que usa e dene nomes seguindo as regras usuais de formac ao
de um nome. O namespace da denic ao de uma classe torna-se o dicion ario de atributo dessa. Nomes denidos
no escopo da classe n ao s ao visiveis para os m etodos.
4.1.1 Interac ao com aspectos din amicos
Existem v arios casos em que comandos Python, quando usados em conjunto com escopos aninhados que possuem
vari aveis livres s ao ilegais.
Se houver refer encias de uma vari avel em um escopo superior, e ilegal deletar o nome. Caso isso aconteca um
erro ocorrer a durante a compilac ao.
Se uma forma mais radical do import import * e usada em uma func ao e caso ela contenha ou seja um
bloco aninhado com vari aveis livres o compilador vai levantar uma excec ao SyntaxError.
Se o comando exec for usado em uma func ao contendo vari aveis livres ou um bloco aninhado com esse tipo de
vari avel, o compilador levantar a uma excec ao SyntaxError, a n ao ser que o namespace local seja explicita-
mente especicado no exec. (Em outras palavras, exec obj seria ilegal, mas exec obj in ns seria
legal.)
As func oes eval(), execfile() e input() e o comando exec n ao tem acesso a todos nomes resolvidos
no ambiente. Os nomes podem ser resolvidos no namespace global e local do requisitor. As vari aveis locais
n ao s ao resolvidas no namespace mais pr oximo, mas no namespace global.
1
O comando exec e as func oes
eval() e execfile() possuem argumentos opcionais para substituir o namespace global e local. Se apenas
um namespace for especicado ele e usado como global e local.
4.2 Excec oes
Excec oes s ao meios de quebrar o uxo normal de um c odigo para lidar com erros ou outras condic oes excep-
cionais. Uma excec ao e levantada assim que um erro e detectado, ela pode ser manipulada pelo c odigo que a
cerca ou pelo c odigo que invocou direta ou indiretamente o bloco onde o erro aconteceu.
O interpretador Python levanta uma excec ao quando detecta um erro durante o tempo de execuc ao (como uma
divis ao por zero). Um programa Python pode levantar uma excec ao explicitamente com o comando raise.
Manipuladores de excec ao s ao especicados com o comando try ... except. O comando try ... finally
especica um codigo de limpeza que n ao lida com a excec ao, mas que e sempre executado, ocorrendo ou n ao uma
excec ao.
Python usa o modelo de nalizac ao na manipulac ao de erros: um manipulador de excec oes pode descobrir o
que houve de errado e continuar a execuc ao em um nvel mais externo, mas ele n ao pode consertar a causa do
erro ou tentar novamente a operac ao que causou erro (a n ao ser que o pedaco de c odigo que causou o erro seja
re-executado desde o comeco).
1
Essa limitac ao acontece porque o c odigo que e executado por essas operac oes n ao esta disponvel no momento que o modulo e compilado.
34 Captulo 4. Modelo de execuc ao
Quando uma excec ao n ao e tratada, o interpretador encerra a execuc ao do programa ou retorna para seu loop
interativo principal. Em qualquer caso ele imprime na tela o o rastro da pilha de chamada, a n ao ser quando a
excec ao e SystemExit.
Excec oes s ao identicadas por inst ancias de classes. A selec ao de uma cl ausula except e baseada na identidade do
objeto: a cl ausula except deve se referenciar ` a mesma classe ou uma classe base da excec ao que foi levantada. A
inst ancia pode ser recebida pelo manipulador e pode carregar informac ao adicional sobre a condic ao excepcional
que ocorreu.
Excec oes tamb em podem ser identicadas por strings, caso em que a cl ausula except e selecionada pela iden-
tidade do objeto. Um valor arbitr ario pode ser passado junto com a string identicadora, que e passada para o
manipulador.
Deprecated since release 2.5. Strings n ao devem ser usadas como excec oes em c odigo novo. Elas n ao fun-
cionar ao em uma futura vers ao de Python. C odigo antigo deve ser reescrito para usar classes.
Mensagens para excec oes n ao fazem parte da API do Python. Seu conte udo pode mudar de uma vers ao para outra
sem qualquer aviso e n ao e con avel para c odigo que poder a ser executado em diversas vers oes do interpretador
Veja tamb em a descric ao do comando try em section 7.4 e do comando raise em section 6.9.
4.2. Excec oes 35
36
CAP
ITULO
FIVE
Express oes
Este captulo explica o signicado dos elementos das express oes em Python.
Nota de Sintaxe: Neste e nos captulos seguintes, a notac ao BNF estendida ser a usada para descrever a sintaxe,
n ao a an alise l exica. Quando (uma forma alternativa de) uma regra de sintaxe tem a forma
name ::= othername
e n ao e dada nenhuma sem antica, a sem antica da forma name e a mesma de othername.
5.1 Convers oes Aritm eticas
Quando uma descric ao de um operador aritm etico abaixo usa a frase os argumentos num ericos s ao convertidos
para um tipo comum, os argumentos s ao convertidos usando as regras de convers ao listadas no nal do captulo
3. Se ambos os argumentos forem de tipos num ericos padr ao, as seguintes convers oes s ao aplicadas:
Se um dos argumentos e um n umero complexo, o outro e convertido para complexo;
caso contr ario, se um dos argumentos e um n umero de ponto utuante, o outro e convertido para ponto
utuante;
caso contr ario, se um dos argumentos e um inteiro longo, o outro e convertido para inteiro longo;
caso contr ario, ambos devem se inteiros simples e nenhuma convers ao e necess aria.
Algumas regras adicionais se aplicam a certos operadores (por exemplo, um argumento do tipo string ` a esquerda
do operador %). Extens oes podem denir suas pr oprias regras de convers ao.
5.2

Atomos
Atomos (atoms) s ao os elementos mais b asicos das express oes. Os atomos mais simples s ao identicadores
(identiers) ou literais (literals). Express oes delimitadas por aspas invertidas, par enteses, colchetes ou chaves
(enclosures) tamb em s ao categorizadas sintaticamente como atomos. A sintaxe dos atomos e:
atom ::= identifier | literal | enclosure
enclosure ::= parenth_form | list_display
| generator_expression | dict_display
| string_conversion
5.2.1 Identicadores (Nomes)
Um identicador na forma de um atomo e um nome. Veja section 4.1 para documentac ao sobre nomeac ao e
ligac ao.
37
Quando o nome e ligado a um objeto, a interpretac ao do atomo retorna este objeto. Quando um nome n ao e ligado,
a tentativa de avali a-lo levanta uma excec ao NameError.
Modicac ao de nomes privados Quando um identicador que ocorre textualmente na denic ao de uma classe
comeca com dois ou mais caracteres sublinhados (underscore) e n ao termina com dois ou mais sublinhados, este e
considerado um nome privado desta classe. Nomes privados s ao transformados para uma forma mais longa antes
que seu c odigo seja gerado. A transformac ao insere o nome da classe antes do nome, com os sublinhados iniciais
removidos, e um unico sublinhado e inserido antes no nome da classe. Por exemplo, o identicador __spam,
ocorrendo em um classe chamada Ham, ser a transformado em_Ham__spam. Essa transformac ao e independente
do contexto sint atico no qual o identicador e usado. Se o nome transformado e extremamente longo (maior do
que 255 caracteres), pode ocorrer o truncamento denido pela implementac ao. Se o nome da classe e composto
somente por sublinhados, n ao e feita nenhuma transformac ao.
5.2.2 Literais
Python suporta strings literais e v arios literais num ericos.
literal ::= stringliteral | integer | longinteger
| floatnumber | imagnumber
A interpretac ao de um literal retorna um objeto do tipo fornecido (string, inteiro, inteiro longo, n umero de ponto
utuante, n umero complexo) com o valor fornecido. Este valor pode ser aproximado no caso de literais de ponto
utuante e imagin arios (complexos). Veja section 2.4 para mais detalhes.
Todos os literais correspondem a tipos de dados imut aveis e, portanto, a identidade do objeto e menos importante
do que o seu valor. M ultiplas interpretac oes de literais com o mesmo valor (tanto a mesma ocorr encia no corpo
do programa quanto uma ocorr encia diferente) podem resultar no mesmo objeto ou em um objeto diferente com o
mesmo valor.
5.2.3 Estruturas entre par enteses
Um estrutura entre par enteses (parenth form) e uma lista opcional de express oes contida entre par enteses:
parenth_form ::= "("[expression_list] ")"
Uma lista de express oes entre par enteses retorna o que quer que a lista de express oes retorne: se a lista cont em
pelo menos uma vrgula, esta retorna uma tupla; caso contr ario, retorna a unica express ao que comp oe a lista de
express oes.
Um par de par enteses vazio retorna uma tupla vazia. Uma vez que as tuplas s ao imut aveis, as regras para literais
se aplicam (isto e, duas ocorr encias de uma tupla vazia podem ou n ao retornar o mesmo objeto).
Note que as tuplas n ao s ao formadas pelos par enteses, mas pelo uso do operador vrgula. A excec ao e a tupla
vazia, para a qual os par enteses s ao obrigat orios permitir a presenca de um nada sem par enteses nas express oes
causaria ambig uidades e permitiria que erros comuns de digitac ao passassem despercebidos.
5.2.4 Representac oes de lista
Uma representac ao de lista (list display) e uma s erie possivelmente vazia de express oes contidas entre
colchetes:
test ::= and_test ( "or"and_test )* | lambda_form
testlist ::= test ( ","test )* [ ","]
list_display ::= "["[listmaker] "]"
listmaker ::= expression ( list_for | ( ","expression )* [","] )
list_iter ::= list_for | list_if
list_for ::= "for"expression_list "in"testlist [list_iter]
list_if ::= "if"test [list_iter]
Uma representac ao de lista retorna um novo objeto lista. Seu conte udo e especicado fornecendo ou uma lista de
express oes ou pela compreens ao de uma lista. Quando uma lista separada por vrgulas e fornecida, seus elementos
38 Captulo 5. Express oes
s ao interpretados da esquerda para a direita e colocados no objeto lista nessa ordem. Quando a compreens ao de
uma lista e fornecida, esta consiste de uma express ao seguida por pelo menos uma cl ausula for e zero ou mais
cl ausulas for ou if. Nesse caso, os elementos da nova lista s ao aqueles que seriamproduzidos considerando cada
uma das cl ausulas for ou if como um bloco, aninhando da esquerda para a direita e interpretando a express ao
para produzir um elemento da lista a cada vez que o bloco mais interno e alcancado.
5.2.5 Generator expressions
A generator expression is a compact generator notation in parentheses:
generator_expression ::= "("test genexpr_for ")"
genexpr_for ::= "for"expression_list "in"test [genexpr_iter]
genexpr_iter ::= genexpr_for | genexpr_if
genexpr_if ::= "if"test [genexpr_iter]
A generator expression yields a new generator object. It consists of a single expression followed by at least one
for clause and zero or more for or if clauses. The iterating values of the new generator are those that would
be produced by considering each of the for or if clauses a block, nesting from left to right, and evaluating the
expression to yield a value that is reached the innermost block for each iteration.
Variables used in the generator expression are evaluated lazily when the next() method is called for generator
object (in the same fashion as normal generators). However, the leftmost for clause is immediately evaluated
so that error produced by it can be seen before any other possible error in the code that handles the generator
expression. Subsequent for clauses cannot be evaluated immediately since they may depend on the previous
for loop. For example: (x*y for x in range(10) for y in bar(x)).
The parentheses can be omitted on calls with only one argument. See section ?? for the detail.
5.2.6 Representac oes de dicion ario
Uma representac ao de dicion ario (dictionary display) e uma s erie possivelmente vazia de pares chave/valor
(key/datum) contidos entre chaves:
dict_display ::= "{"[key_datum_list] "}"
key_datum_list ::= key_datum (","key_datum)* [","]
key_datum ::= expression ":"expression
Uma representac ao de dicion ario retorno um novo objeto dicion ario.
Os pares chave/valor s ao interpretados da esquerda para a direita para denir as entradas do dicion ario: cada
objeto chave e usado como uma chave dentro do dicion ario para armazenar os valores correspondentes.
As restric oes dos tipos de valores das chaves s ao listadas anteriormente nessa sec ao 3.2. (Resumindo, o tipo da
chave deve ser index avel, o que exclui todos os tipos de objetos mut aveis.) Conitos entre chaves duplicadas n ao
s ao detectados; prevalecem os ultimos valores (textualmente os mais ` a direita na representac ao) armazenados para
um dado valor de chave.
5.2.7 Convers oes para string
Uma convers ao para string (string conversion) e uma lista de express oes contidas entre aspas reversas:
string_conversion ::= ""expression_list ""
Em uma convers ao para string a lista de express oes contida e interpretada e o objeto resultante e convertido em
uma string de acordo com regras especcas para cada tipo.
Se o objeto e uma string, um n umero, None, ou ent ao uma tupla, lista ou dicion ario contendo apenas objetos de
um desses tipos, a string resultante e uma express ao Python v alida que pode ser passada para a func ao interna
eval() para gerar uma express ao com o mesmo valor (ou uma aproximac ao, caso estejam envolvidos n umeros
de ponto utuante).
5.2.

Atomos 39
(Particularmente, a convers ao de uma string adiciona aspas sobre ela e converte caracteres estranhos para
seq uencias de escape que podem ser impressas sem problemas.)
Objetos recursivos (por exemplo, listas ou dicion arios que cont em uma refer encia a si pr oprios, direta ou indi-
retamente) usam ... para indicar uma refer encia recursiva, e o resultado n ao pode ser passado para a func ao
eval() para obter um valor igual (em vez disso, e levantada uma excec ao SyntaxError).
A func ao interna repr() realiza exatamente a mesma convers ao nos seus argumentos que a colocac ao entre
par enteses e entre aspas invertidas fazem. A func ao interna str() realiza uma convers ao similar, mas mais
amig avel.
5.3 Prim arias
Prim arias (primaries) representam as operac oes mais fortemente ligadas da linguagem. Sua sintaxe e:
primary ::= atom | attributeref | subscription | slicing | call
5.3.1 Refer encias a atributos
Uma refer encia a um atributo (attribute reference) e uma prim aria seguida por um ponto e um nome:
attributeref ::= primary "."identifier
A interpretac ao de uma prim aria deve retornar um objeto cujo tipo suporte refer encias a atributos, por exemplo,
um m odulo, uma lista ou uma inst ancia.

E feita ent ao uma requisic ao a este objeto para retornar o atributo cujo
nome e o identicador. Se este atributo n ao estiver disponvel, e levantada uma excec ao AttributeError.
Caso contr ario, o tipo e o valor do objeto retornado s ao determinados pelo objeto. M ultiplas chamadas a uma
mesma refer encia a um atributo podem retornar objetos diferentes.
5.3.2 Subscric oes
Uma subscric ao (subscription) seleciona um item de uma seq u encia (string, tupla ou lista) ou de um mapeamento
(dicion ario):
subscription ::= primary "["expression_list "]"
A interpretac ao da prim aria deve retornar um objeto do tipo seq u encia ou mapeamento.
Se a prim aria for um mapeamento, a interpretac ao da lista de express oes deve retornar um objeto cujo valor e uma
das chaves do mapeamento, e a subscric ao seleciona o valor do mapeamento que corresponde ` aquela chave. (A
lista de express oes e uma tupla, a n ao ser que contenha exatamente um item).
Se a prim aria for uma seq u encia, a interpretac ao da express ao (ou lista de express oes) deve retornar um inteiro
simples. Se este valor for negativo, o tamanho da seq u encia e adicionado ao mesmo (para que, por exemplo,
x[-1] selecione o ultimo item de x). O valor resultante deve ser um inteiro n ao negativo menor do que o n umero
de itens da seq u encia, e a subscric ao seleciona o item cujo ndice e esse valor (contando a partir do zero).
Os itens de uma string s ao caracteres. Um caractere n ao e um tipo de dado separado, mas uma string com
exatamente um caractere.
5.3.3 Fatiamentos
O fatiamento (slicing) seleciona uma faixa de itens de uma seq u encia (como por exemplo uma string, uma tupla
ou uma lista). Fatiamentos podem ser usados como express oes ou como alvos em comandos de atribuic ao ou
delec ao. A sintaxe do fatiamento e:
slicing ::= simple_slicing | extended_slicing
simple_slicing ::= primary "["short_slice "]"
extended_slicing ::= primary "["slice_list "]"
slice_list ::= slice_item (","slice_item)* [","]
slice_item ::= expression | proper_slice | ellipsis
proper_slice ::= short_slice | long_slice
short_slice ::= [lower_bound] ":"[upper_bound]
long_slice ::= short_slice ":"[stride]
lower_bound ::= expression
upper_bound ::= expression
stride ::= expression
ellipsis ::= "..."
H a uma ambig uidade na sintaxe formal aqui: qualquer coisa que tem a forma de uma lista de express oes tamb em
tem a forma de uma lista de fatias, ent ao qualquer subscric ao pode ser interpretada como um fatiamento. Em vez
de complicar mais a sintaxe, esta ambig uidade e removida atrav es da denic ao de que, nesse caso, a interpretac ao
como subscric ao tem prioridade sobre a interpretac ao como fatiamento (isso se aplica se a lista de fatias n ao
cont em fatias v alidas e nem elipses). Similarmente, quando a lista de fatias tem exatamente uma fatia curta (short
slice), sem vrgula no nal, a interpretac ao como fatiamento simples tem prioridade sobre a interpretac ao como
fatiamento estendido.
A sem antica do fatiamento simples e a seguinte: a interpretac ao da prim aria deve retornar uma seq u encia. A
interpretac ao dos limites inferior (lower bound) e superior (upper bound), se estes estiverem presentes, deve
retornar inteiros simples; os valores padr ao s ao zero e sys.maxint, respectivamente. Se qualquer um dos
limites for negativo, e adicionado a este o tamanho da seq u encia. O fatiamento ent ao seleciona todos os itens
com ndice k tais que i <= k < j, onde i e j s ao os limites inferior e superior especicados. Essa selec ao pode
retornar uma seq u encia vazia. Se i e j est ao fora da faixa de ndices v alidos, isso n ao causa um erro (tais itens n ao
existem, portanto n ao s ao selecionados).
A sem antica do fatiamento estendido e a seguinte: a prim aria deve ser um mapeamento, o qual e indexado com
uma chave que e construda a partir da lista de fatias: se a lista de fatias cont em pelo menos uma vrgula, a chave e
uma tupla contendo a convers ao dos itens dessa lista; caso contr ario, a chave e a convers ao do unico item da lista
de fatias. A convers ao de um item da lista de fatias que e uma express ao e a pr opria express ao. A convers ao de
uma elipse da lista de fatias e o objeto pr e-denido Ellipsis. A convers ao de uma fatia corretamente formulada
e um objeto do tipo fatia (ver section 3.2), cujos atributos start, stop e stride s ao os valores das express oes
dadas como limite inferior, limite superior e passo, respectivamente, substituindo None pelas express oes que
faltam.
5.3.4 Chamadas
Uma chamada (call) chama um objeto execut avel (por exemplo, uma func ao) com uma s erie possivelmente
vazia de argumentos:
call ::= primary "("[argument_list [","]] ")"
argument_list ::= positional_arguments [","keyword_arguments]
[",*"expression]
[",**"expression]
| keyword_arguments [",*"expression]
[",**"expression]
| "*"expression [",**"expression]
| "**"expression
positional_arguments ::= expression (","expression)*
keyword_arguments ::= keyword_item (","keyword_item)*
keyword_item ::= identifier "="expression
Pode haver uma vrgula depois dos argumentos e keywords, mas isso n ao afeta a sem antica.
A interpretac ao da prim aria deve retornar um objeto execut avel (func oes denidas pelo usu ario, func oes internas,
m etodos de objetos internos, objetos do tipo classe, m etodos de inst ancias de classes e em alguns casos as pr oprias
inst ancias de classes s ao execut aveis; extens oes podem denir tipos de objetos execut aveis adicionais). Todas as
express oes do argumento s ao interpretadas antes que a chamada seja feita. Veja section 7.5 para saber sobre a
5.3. Prim arias 41
sintaxe de listas de par ametros formais.
Se h a argumentos nomeados, estes primeiro s ao convertidos para argumentos posicionais, como segue. Primeiro,
e criada uma lista de posic oes em branco para os par ametros formais. Se h a N argumentos posicionais, estes
s ao colocados nas N primeiras posic oes. A seguir, para cada argumento nomeado, o identicador e usado para
determinar a posic ao correspondente (se o identicador e igual ao nome do primeiro par ametro formal, e usada
a primeira posic ao, e assim por diante). Se a posic ao j a est a preenchida, e levantada uma excec ao TypeError.
Caso contr ario, o valor do argumento e colocado na posic ao, preenchendo-a (mesmo que a express ao seja None,
a posic ao e preenchida). Quando todos os argumentos tiverem sido processados, as posic oes que ainda est ao
em branco s ao preenchidas com o valor padr ao correspondente na denic ao da func ao. (Os valores padr ao s ao
calculados, uma unica vez, quando a func ao e denida; portanto, um objeto mut avel, como uma lista ou um
dicion ario, usado como valor padr ao ser a compartilhado por todas as chamadas que n ao especicam um valor de
argumento para a posic ao correspondente; isso deveria geralmente ser evitado.) Se h a posic oes em branco para as
quais n ao e especicado nenhum valor padr ao, e levantada uma excec ao TypeError. Caso contr ario, a lista de
posic oes preenchidas e usada com argumento para a chamada.
Se h a mais argumentos posicionais do que posic oes para os par ametros formais, e levantada uma excec ao
TypeError, a n ao ser que haja um par ametro usando a sintaxe *identificador; nesse caso, o par ametro
formal recebe uma tupla contendo os argumentos posicionais excedentes (uma uma tupla vazia se n ao houver
nenhum argumento posicional excedente).
Se algum argumento nomeado n ao corresponde a nenhum par ametro formal, e levantada uma excec ao
TypeError, a n ao ser que esteja presente um par ametro formal com a sintaxe **identificador; nesse
caso, esse par ametro formal recebe um dicion ario contendo os argumentos nomeados excedentes (usando os
nomes como chaves e os valores do argumento como valores correspondentes a essas chaves), ou um (novo)
dicion ario vazio, se n ao houverem argumentos nomeados excedentes.
Se a sintaxe *expressao aparece na chamada da func ao, o resultado da interpretac ao de expressao
deve ser uma seq u encia. Os elementos dessa seq u encia s ao tratados com se fossem argumentos posicionais adi-
cionais; se h a argumentos posicionais x,...,xN, e o resultado da interpretac ao de expressao e uma seq u encia
y1,...,yM, isso e equivalente a uma chamada com M+N argumentos posicionais x1,...,xN,y1,...,yM.
Uma conseq u encia disso e que, embora a sintaxe *expressao apareca depois de quaisquer argumentos
nomeados, esta e processada antes dos argumentos nomeados (e do argumento **express ao, se houver algum
veja abaixo). Ent ao:
>>> 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 ?
TypeError: f() got multiple values for keyword argument a
>>> f(1, *(2,))
1 2
E incomum o uso de argumentos nomeados e da sintaxe *expressao na mesma chamada, ent ao, na pr atica,
n ao acontece essa confus ao.
Se a sintaxe **expressao aparece na chamada ` a func ao, a interpretac ao de expressao deve resultar
em (uma subclasse de) um dicion ario, cujo conte udo e tratado como argumentos nomeados adicionais. No caso
de um mesmo nome aparecer tanto na expressao quanto como um argumento nomeado explicitamente, e
levantada uma excec ao TypeError.
Os par ametros formais que usam a sintaxe *identificador ou **identificador n ao podem ser usa-
dos como argumentos posicionais nem como nomes de argumentos nomeados. Os par ametros formais que usam
a sintaxe (sublista) n ao podem ser usados como nomes de argumentos nomeados; a lista mais externa cor-
responde a uma unica posic ao n ao nomeada, e o valor do argumento e atribudo ` a sublista usando as regras usuais
de atribuic ao para tuplas, ap os o processamento de todos os outros par ametros.
Uma chamada sempre retorna algum valor, possivelmente None, a n ao ser que cause uma excec ao. Como esse
valor e computado depende do tipo do objeto chamado.
Se este for
uma func ao denida pelo usu ario: O bloco de c odigo da func ao e executado, sendo-lhe passada a lista de argu-
mentos. A primeira coisa que o bloco de c odigo far a ser a ligar os par ametros formais aos argumentos; isso
e descrito na sec ao 7.5. Quando o bloco de c odigo executa um comando return, e especicado o valor de
retorno da chamada ` a func ao
uma func ao ou m etodo interno: O resultado ca a cargo do interpretador; ver Python Library Reference para
descric oes das func oes e m etodos internos.
um objeto do tipo classe:

E retornada uma nova inst ancia dessa classe.
um m etodo de uma inst ancia de classe: A func ao denida pelo usu ario correspondente e chamada, com uma
lista de argumentos que e maior do que a lista de argumentos da chamada: a inst ancia passa a ser o primeiro
argumento.
uma inst ancia de classe: A classe deve denir um m etodo __call__(); o efeito ent ao e o mesmo que se esse
m etodo fosse chamado.
5.4 O operador de pot encia
O operador de pot encia power se liga mais fortemente do que os operadores un arios ` a sua esquerda e se liga menos
fortemente do que que os operadores un arios ` a sua direita. Sua sintaxe e:
power ::= primary ["**"u_expr]
Assim, em uma seq uencia sem par enteses de operadores un arios e operadores de pot encia, os operadores s ao
interpretados da direita para a esquerda (isso n ao restringe a ordem de avaliac ao dos operandos).
O operador de pot encia tem a mesma sem antica da func ao interna pow(), quando chamada com dois argumen-
tos: retorna o argumento da esquerda elevado ao argumento da direita. Os argumentos num ericos s ao primeiro
convertidos para um tipo comum. O tipo resultante e o tipo dos argumentos convertidos.
Com diferentes tipos de operandos misturados, se aplicam as regras de convers ao para operadores aritm eticos
bin arios. Para argumentos do tipo inteiro e inteiro longo, o resultado e do mesmo tipo dos operandos (ap os a
convers ao), a menos que o segundo argumento seja negativo; nesse caso, todos os argumentos s ao convertidos
para n umeros de ponto utuante, e e retornado como resultado um n umero ponto utuante. Por exemplo, 10**2
retorna 100, mas 10**-2 retorna 0.01. (Esta func ao foi adicionada no Python 2.2. No Python 2.1 e anteriores,
se ambos os argumentos fossem inteiros e o segundo argumento fosse negativo, era levantada uma excec ao).
Elevar 0.0 a um a pot encia negativa resulta em uma excec ao ZeroDivisionError. Elevar um valor negativo
a uma pot encia fracion aria resulta em uma excec ao ValueError.
5.5 Unary arithmetic operations
Todas as operac oes aritm eticas (e operac oes bit-a-bit) un arias t em a mesma prioridade:
u_expr ::= power | -"u_expr | "+"u_expr | ""u_expr
O operador un ario - (menos) retorna a negac ao do seu argumento num erico.
O operador un ario + (mais) retorna o seu argumento num erico inalterado.
O operador un ario (invers ao) retorna a invers ao bit-a-bit do seu argumento inteiro longo ou simples. A invers ao
bit-a-bit de x e denida como -(x+1). Se aplica somente a n umeros integrais.
Em todos os tr es casos, se o argumento n ao e do tipo adequado, uma excec ao TypeError e levantada.
5.4. O operador de pot encia 43
5.6 Operac oes aritm eticas bin arias
As operac oes aritm eticas bin arias t em os nveis de prioridade convencionais. Note que algumas dessas operac oes
tamb em se aplicam a certos tipos n ao-num ericos. Fora o operador de pot encia, h a apenas dois nveis, um para
operadores multiplicativos e um para operadores aditivos:
m_expr ::= u_expr | m_expr "*"u_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 * (multiplicac ao) retorna o produto dos seus argumentos. Os argumentos devem ser ambos n umeros,
ou um argumento deve ser um inteiro (simples ou longo) e o outro deve ser uma seq u encia. No primeiro caso, os
n umeros s ao convertidos para um mesmo tipo e ent ao multiplicados. No segundo caso, e executada a repetic ao da
seq u encia; um fator de repetic ao negativo retorna uma seq u encia vazia.
Os operadores / (divis ao) e // (divis ao inteira) retornam o quociente dos seus argumentos. Os argumentos
num ericos s ao primeiro convertidos para um mesmo tipo. A divis ao de inteiros simples ou longos retorna um
inteiro do mesmo tipo; o resultado e o resultado da divis ao matem atica com a func ao oor aplicada ao resultado.
A divis ao por zero levanta uma excec ao ZeroDivisionError exception.
O operador % (modulo) retorna o resto da divis ao do primeiro argumento pelo segundo. Os argumentos
num ericos s ao primeiro convertidos para um mesmo tipo. Um argumento direito igual a zero levanta a excec ao
ZeroDivisionError. Os argumentos podem ser n umeros de ponto utuante, por exemplo, 3.14%0.7 e
igual a 0.34 (j a que 0.34 e igual a 4*0.7 + 0.34.) O operador m odulo sempre retorna um resultado com o
mesmo sinal do segundo operando (ou zero); o valor absoluto do resultado e estritamente menor do que o valor
absoluto do segundo operando
1
.
Os operadores divis ao inteira e m odulo s ao conectados pela seguinte identidade: x == (x/y)*y + (x%y). A
divis ao inteira e o m odulo tamb em s ao conectadas pela func ao inteira divmod(x,y) == (x/y, x%y). Estas
identidades n ao valem para n umeros de ponto utuante; identidades similares valem de forma aproximada quando
x/y e substitudo por floor(x/y) ou floor(x/y) - 1
2
. Deprecated since release 2.3. O operador de
divis ao inteira (oor) e a func ao divmod() n ao s ao mais denidas para n umeros complexos. Em vez disso,
converta para um n umero de ponto utuante usando a func ao abs(), se for o caso.
O operador + (adic ao) retorna a soma dos seus argumentos. Os argumentos devem ser ou ambos n umeros ou
ambos seq u encias do mesmo tipo. No primeiro caso, os n umeros s ao convertidos para um mesmo tipo e ent ao
adicionados. No segundo, as seq u encias s ao concatenadas.
O operador - (subtrac ao) retorna a diferenca entre os seus argumentos. Os argumentos num ericos s ao primeiro
convertidos para um mesmo tipo.
5.7 Operac oes de deslocamento (shifting)
As operac oes de deslocamento t em prioridade mais baixa do que as operac oes aritm eticas:
shift_expr ::= a_expr | shift_expr ( < >") a_expr
Estes operadores aceitam como argumentos inteiros simples ou longos. Os argumentos s ao convertidos para um
mesmo tipo. Eles deslocam o primeiro argumento para a esquerda ou para a direita em um n umero de bits dado
pelo segundo argumento.
Um deslocamento ` a direita em n bits e denido como um divis ao por pow(2,n). Um deslocamento ` a esquerda
em n bits e denido como uma multiplicac ao por pow(2,n); para inteiros simples n ao h a vericac ao de overow
de forma que nesse caso a operac ao descarta bits e troca o sinal se o resultado n ao for menor do que pow(2,31),
1
Apesar da express ao abs(x%y) < abs(y) ser matematicamente verdadeira, para n umeros de ponto utuante a mesma pode n ao ser
numericamente verdadeira devido ao arredondamento. Por exemplo, assumindo uma plataforma na qual o n umero de ponto utuante do
Python seja um n umero de precis ao dupla no padr ao IEEE 754, de modo que -1e-100 %1e100 tenha o mesmo sinal que 1e100. A func ao
fmod() do m odulo math retorna um resultado cujo sinal e igual ao do primeiro argumento em vez do segundo, e portanto retorna -1e100
nesse caso. A abordagem mais adequada depende da aplicac ao.
2
Se x e muito pr oximo de um inteiro exato m ultiplo de y, e possvel que floor(x/y) seja maior do que (x-x%y)/y devido ao
arredondamento. Em casos desse tipo, Python retorna o ultimo resultado, para manter a garantia de que
codedivmod(x,y)[0] * y + x % y seja muito pr oximo de x.
em valor absoluto. Deslocamentos negativos causam uma excec ao ValueError.
5.8 Operac oes bit-a-bit bin arias
5.9 Binary bit-wise operations
Cada uma das tr es operac oes bit-a-bit tem um nvel diferente de prioridade:
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 & retorna o AND bit-a-bit entre seus argumentos, que devem ser inteiros simples ou longos. Os
argumentos s ao convertidos para um mesmo tipo.
O operador retorna o XOR (OU exclusivo) bit-a-bit entre seus argumentos, que devem ser inteiros simples ou
longos. Os argumentos s ao convertidos para um mesmo tipo.
O operador | retorna o OR (inclusivo) bit-a-bit entre seus argumentos, que devem ser inteiros simples ou longos.
Os argumentos s ao convertidos para um mesmo tipo.
5.10 Comparac oes
Diferentemente do que em C, todas as operac oes de comparac oes em Python t em a mesma prioridade, que e menor
do que a de qualquer operac ao aritm etica, de deslocamento ou bit-a-bit. Tamb em diferentemente do que em C,
express oes como a < b < c t em a mesma interpretac ao que e convencional na matem atica:
comparison ::= or_expr ( comp_operator or_expr )*
comp_operator ::= "== = = > "!="
| "is"["not"] | ["not"] "in"
Comparac oes retornam valores booleanos: True (verdadeiro) ou False (falso).
Comparac oes podem ser encadeadas arbitrariamente, por exemplo, x < y <= z e equivalente a x < y and
y <= z, exceto que y e interpretado apenas uma vez (mas em ambos os casos z n ao e interpretado quando o
resultado de x < y resulta em falso).
Formalmente, se a, b, c, . . . , y, z s ao express oes e opa, opb, . . . , opy s ao operadores de comparac ao, ent ao a opa
b opb c . . . y opy z e equivalente a a opa b and b opb c and . . . y opy z, exceto que cada express ao e interpretada
pelo menos uma vez.
Note que a opa b opb c n ao implica nenhum tipo de comparac ao entre a e c, de modo que, por exemplo, x < y
> z e perfeitamente legal (embora talvez n ao seja muito bonito).
As formas <> e != s ao equivalentes; para manter a consist encia com o C, prefere-se !=; a seguir, onde e men-
cionado !=, <> tamb em e aceito. A forma <> e considerada obsolescente.
Os operadores <, >, ==, >=, <= e != comparam os valores de dois objetos. Os objetos n ao precisam ser do mesmo
tipo. Se ambos forem n umeros, s ao convertidos para o mesmo tipo. Caso contr ario, objetos de tipos diferentes
sempre s ao comparados como desiguais, e s ao ordenados consistente mas arbitrariamente.
(Essa denic ao pouco usual de comparac ao foi usada para simplicar a denic ao de operac oes como a ordenac ao
e os operadores in e not in. Futuramente, as regras de commparac oes para objetos de tipos diferentes ser ao
possivelmente modicadas.)
A comparac ao de objetos do mesmo tipo depende do tipo:
N umeros s ao comparados aritmeticamente.
Strings s ao comparadas lexicogracamente, usando os equivalentes num ericos da func ao interna ord()
dos seus caracteres. Strings unicode e de 8 bits s ao totalmente interoper aveis nesse comportamento.
5.8. Operac oes bit-a-bit bin arias 45
Tuplas e listas s ao comparadas lexicogracamente usando a comparac ao de elementos correspondentes.
Isso signica que para serem comparadas como iguais, cada elemento deve ser comparado como igual e as
duas seq u encias devem ser do mesmo tipo e ter o mesmo n umero de elementos.
Se n ao forem iguais, as seq u encias s ao ordenadas da mesma maneira que os seus primeiros elementos
diferentes. Por exemplo, cmp([1,2,x], [1,2,y]) retorna o mesmo que cmp(x,y). Se o elemento
correspondente n ao existe, a menor seq u encia ca em primeiro na ordenac ao (por exemplo, [1,2] <
[1,2,3]).
Mapeamentos (dicion arios) s ao comparados como iguais se e somente se suas listas (chave, valor) ordenadas
forem comparadas como iguais.
3
Outros resultados que n ao a igualdade s ao resolvidos consistentemente,
mas n ao s ao denidos de outro modo.
4
A maioria dos demais tipos e comparada como desigual a n ao ser que sejam o mesmo objeto; a escolha
se um objeto e considerado maior ou menor do que o outro e feita arbitrariamente, mas consistentemente
dentro de uma mesma execuc ao de um programa.
Os operadores in e not in testam a pertin encia a um conjunto. x in s e interpretado como verdadeiro se x e
um membro do conjunto s, e como falso caso contr ario. x not in s retorna a negac ao de x in s. O teste de
pertin encia a um conjunto tem sido tradicionalmente ligado a seq u encias; um objeto e membro de um conjunto
se este conjunto e uma seq u encia e cont em um elemento que e igual a este objeto. Entretanto, e possvel que um
objeto suporte testes de pertin encia mesmo que n ao seja uma seq u encia. Particularmente, dicion arios suportam
testes de pertin encia como um modo mais elegante da forma key in dict; outros tipos de mapeamentos podem
manter esta adequac ao.
Para os tipos tupla e lista, x in y e verdadeiro se e somente se existe umndice i tal que x == y[i] e verdadeiro.
Para os tipos Unicode e string, x in y e verdadeiro se e somente se x e uma substring de y. Um teste equivalente e
y.find(x) != -1. Note que x e y n ao precisam ser do mesmo tipo; consequentemente, uab in abc
retornar a True. Strings vazias s ao sempre consideradas substrings de qualquer outra string, logo in "abc"
retornar a True.
Changed in version 2.3: Anteriormente, era exigido que x fosse uma string de tamanho 1.
Para classes denidas pelo usu ario que denem o m etodo __contains__(), x in y e verdadeiro se e somente
se y.__contains__(x) e verdadeiro.
Para classes denidas pelo usu ario que n ao denem o m etodo __contains__() e que denem o m etodo _-
_getitem__(), x in y e verdadeiro se e somente se existe um ndice inteiro n ao-negativo i tal que x ==
y[i], e todos os ndices inteiros menores n ao causam a excec ao IndexError. (Se qualquer outra excec ao for
levantada, e como se essa excec ao tivesse sido causada pelo operador in).
O operador not in e denido como o valor verdade inverso de in.
Os operadores is e is not testam a identidade de um objeto: x is y e verdadeiro se e somente se x e y s ao o
mesmo objeto. x is not y retorna o valor verdade inverso.
5.11 Operac oes Booleanas
As operac oes Booleanas t em a prioridade mais baixa dentre todas as operac oes da linguagem Python:
expression ::= or_test | lambda_form
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 das operac oes Booleanas, e tamb em quando as express oes s ao usadas em comandos de controle de
uxo, os seguintes valores s ao interpretados como falsos: False, None, o zero num erico de todos os tipos,
3
A implementac ao computa isso ecientemente, sem construc ao de listas nem ordenac ao.
4
Vers oes anteriores do Python usavam comparac oes lexicogr acas dos listas (chave, valor) ordenadas, mas isso era muito custoso para o
caso comum da comparac ao por igualdade. Uma vers ao ainda mais antiga do Python comparava dicion arios somente por identidade, mas isso
causava surpresas, porque as pessoas esperavam poder testar se um dicion ario era vazio comparando-o com {}.
seq u encias vazias (strings, tuplas, listas, dicion arios, sets e frozensets). Todos os outros valores s ao interpretados
como verdadeiros.
O operador not retorna True se o seu argumento e falso, False caso contr ario.
Na express ao x and y, primeiro e interpretado x; se x e falso, seu valor e retornado; caso contr ario, y e interpre-
tado e o valor resultante e retornado.
Na express ao x or y, primeiro e interpretado x; se x e verdadeiro, seu valor e retornado; caso contr ario, y e
interpretado e o valor resultante e retornado
(Note que nem and nem or restringem o valor e o tipo que retornam a False e True, mas em vez disso
retornam o ultimo arugumento interpretado. Algumas vezes isso e util, por exemplo, se s e uma string que deve
ser substituda por um valor padr ao caso seja vazia, a express ao s or foo retorna o valor desejado. Porque o
not precisa inventar uma valor de qualquer forma, ele n ao se preocupa em retornar um valor que seja do mesmo
tipo que o seu argumento, ent ao por exemplo not foo retorna False, e n ao .)
5.12 Lambdas
lambda_form ::= "lambda"[parameter_list]: expression
Construc oes lambda (express oes lambda) t em a mesma posic ao sint atica do que express oes. Elas s ao uma forma
r apida de criar func oes an onimas; a express ao lambda arguments: expression retorna um objeto do tipo
func ao. Os objeto n ao nomeado se comporta como uma func ao denida com
def name(arguments):
return expression
Veja a section 7.5 para informac ao sobre a sintaxe das listasa de par ametros. Note que func oes criadas com
construc oes lambda n ao podem conter comandos.
5.13 Listas de express oes
expression_list ::= expression ( ","expression )* [","]
Uma lista de express oes contendo pelo menos uma vrgula retorna uma tupla. O tamanho da tupla e o n umero de
express oes contidas na lista. As express oes s ao interpretadas da esquerda para a direita.
A vgula no nal e obrigat oria somente para a criac ao de uma tupla de um unico elemento (tamb em chamada de
singleton); em todos os demais casos e opcional. Uma unica express ao sem vrgula no nal n ao cria uma tupla,
mas em vez disso retorna o valor da express ao. (Para criar uma tupla vazia, use um par de par enteses vazio: ().)
5.14 Ordem de interpretac ao
O interpretador Python interpreta as express oes da esquerda para a direita. Note que durante a interpretac ao de
uma atribuic ao o lado direito e interpretado antes do lado esquerdo.
Nas linhas seguintes, as express oes ser ao interpretadas na ordem aritm etica dos seus suxos:
expr1, expr2, expr3, expr4
(expr1, expr2, expr3, expr4)
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
func(expr1, expr2, *expr3, **expr4)
expr3, expr4 = expr1, expr2
5.12. Lambdas 47
5.15 Summary
A tabela a seguir resume as preced encias de operadores em Python, da menor preced encia (ligac ao mais fraca)
` a maior preced encia (ligac ao mais forte). Os operadores na mesma caixa t em a mesma preced encia. A menos
que a sintaxe seja dada explicitamente, os operadores s ao bin arios. Os operadores na mesma caixa s ao agrupados
da esquerda para a direita (exceto as comparac oes, incluindo os testes, os quaos tem a mesma preced encia e s ao
encadeados da esquerda para a direita veja a sec ao 5.10 e exponenciac ao, que se agrupam da direita para a
esquerda).
Operador Descric ao
lambda Express ao lambda
or OR Booleano
and AND Booleano
not x NOT Booleano
in, not in Testes de pertin encia
is, is not Testes de identidade
<, <=, >, >=, <>, !=, == Comparac oes
| OR bit-a-bit
XOR bit-a-bit
& AND bit-abit
<<, >> Deslocamentos
+, - Adic ao e subtrac ao
*, /, % Multiplicac ao, divis ao, resto
+x, -x Positivo, negativo
x NOT bit-a-bit
** Exponenciac ao
x.atributo Refer encia a atributos
x[indice] Subscric ao
x[indice:indice] Fatiamento
f (argumentos...) Chamada de func ao
(expressoes...) Ligac ao ou representac ao de tupla
[expressoes...] Representac ao de lista
{chave:dado...} Representac ao de dicion ario
expressoes... Convers ao para string
CAP
ITULO
SIX
Instruc oes simples
Instruc oes simples s ao compreendidas em uma unica linha l ogica. V arias instruc oes simples podem ocorrer em
uma unica linha, separadas por ponto-e-vrgula. A sintaxe para essas instruc oes e:
simple_stmt ::= expression_stmt
| assert_stmt
| assignment_stmt
| augmented_assignment_stmt
| pass_stmt
| del_stmt
| print_stmt
| return_stmt
| yield_stmt
| raise_stmt
| break_stmt
| continue_stmt
| import_stmt
| global_stmt
| exec_stmt
6.1 Express oes
Express oes s ao usadas para computar e escrever um valor ou para chamar um procedimento (uma func ao que
n ao retorna qualquer resultado signicativo; em Python, procedimentos retornam o valor None). Existem outras
formas permitidas e ocasionalmente uteis de se usar express oes. A sintaxe para uma express ao e denida por:
expression_stmt ::= expression_list
Uma express ao interpreta a lista de express oes passada (que pode ser uma unica express ao) e devolve o resultado.
No modo interativo, se o valor n ao for None, ele e convertido para uma string usando a func ao repr() e a string
resultante e escrita em uma linha na sada de dados padr ao (veja section 6.6). (Express oes que retornem None
n ao s ao escritas, de modo que esse procedimento n ao gera nenhuma sada.)
6.2 Assertivas
Assertivas s ao uma maneira conveniente de inserir vericac oes para a depurac ao de um programa:
assert_stmt ::= "assert"expression [","expression]
A forma simples, assert expression, e equivalente a:
49
if __debug__:
if not expression: raise AssertionError
A forma estendida, assert expression1, expression2, equivale a:
if __debug__:
if not expression1: raise AssertionError, expression2
Essas equival encias assumem que __debug__ e AssertionError referem ` as vari aveis built-in com esses nomes.
Na implementac ao atual, a vari avel __debug__ e True sob circunst ancias normais e False quando otimizac ao
e usada. O interpretador n ao gera nenhum c odigo para uma assertiva quando e usado otimizac ao durante a
compilac ao. Note que e desnecess ario incluir o c odigo fonte da express ao que falho na mensagem de erro; ele
ser a mostrado no traceback do erro.
Atribuic oes ` a __debug__ s ao ilegais. O valor dessa vari avel e determinado quando o interpretador inicia.
6.3 Atribuic oes
Atribuic oes s ao usadas para (re)ligar nomes ` a valores e para modicar atributos ou items de objetos mut aveis:
assignment_stmt ::= (target_list "=")+ expression_list
target_list ::= target (","target)* [","]
target ::= identifier
| "("target_list ")"
| "["target_list "]"
| attributeref
| subscription
| slicing
(Veja a sec ao 5.3 para a denic ao da sintaxe dos tr es ultimos smbolos.)
Uma atribuic ao resolve a lista de express oes passada (lembre-se que pode ser uma unica express ao ou uma lista
de express oes separadas por vrgulas, nesse caso retornando uma tupla) e atribui o objeto resultanta a cada uma
das vari aveis da lista de alvos, da esquerda para a direita.
A atribuic ao e denida recursivamente, dependendo do formato dos alvos. Quando um alvo e parte de um objeto
mut avel (uma refer encia de um atributo, subscric ao ou slicing) esse objeto que deve realizar a atribuic ao e decidir
sobre sua validade, podendo levantar uma excec ao se a atribuic ao for inaceit avel. As regras observadas pelo objeto
e as excec oes levantadas dependem da denic ao do pr oprio objeto (veja a sec ao 3.2).
A atribuic ao de um objeto a uma lista de alvos e denida recursivamente da seguinte forma:
Se a lista e um unico alvo: o objeto e atribuido a esse alvo.
Se a lista e uma sequ encia de alvos, separados por vrgulas: o objeto deve ser uma sequ encia com o n umero
de items igual ao n umero de alvos. Os objetos s ao atribudos, da esquerda para a direita aos alvos corre-
spondentes. (esta restric ao cou mais leve a partir de Python 1.5; em vers oes anteriores o objeto tinha de ser
uma tupla. Como strings s ao sequ encias legais, uma atribuic ao como a, b = "xy" e legal e a string
tiver o mesmo comprimento.)
A atribuic ao de um objeto a um unico alvo e denida da seguinte forma:
Se o alvo e um identicador (vari avel, nome):
Se o nome n ao ocorre em um comando global no bloco de c odigo atual: o nome e ligado ao objeto
no escopo atual.
Em outros casos, o nome e simplesmente ligado ao objeto no escopo atual.
50 Captulo 6. Instruc oes simples
O nome j a existente tem seu valor reatribudo. Isso pode causar a contagem de refer encias do objeto previ-
amente ligado chegar a zero, provocando sua desalocac ao da mesm oria e a chamada da destrutora (se tiver
uma).
Se o alvo e uma lista de alvos entre par enteses ou colchetes: o objeto deve ser uma sequ encia com o mesmo
n umero de items, que s ao atribudos aos alvos correspondentes.
Se o alvo e uma refer encia de um atributo: a primeira express ao e resolvida. Ela deve retornar um objeto
com atributos livres; se n ao for o caso, a excec ao TypeError e levantada. Pede-se ent ao que aquele
objeto atribua o objeto ao atributo em quest ao; se ele n ao puder realizar a atribuic ao, e levantada uma
excec ao (geralmente, mas n ao necessariamente AttributeError).
Se o alvo e uma subscric ao: a primeira express ao e resolvida, devendo retornar ou uma sequ encia mut avel
(uma lista, por exemplo) ou um mapeamento (um dicion ario). Em seguida, a subscric ao e resolvida e os
valores atribudos.
Se a express ao e uma sequ encia mut avel (como uma lista), a subscric ao deve retornar um n umero inteiro.
Se for negativo, o valor do comprimento da sequ encia e adicionado a ele. O valor resultante deve ser um
inteiro n ao negativo menor que o comprimento da sequ encia. Em seguida e requisitado que a sequ encia
atribua o objeto ao item daquele ndice. Se o item est a fora do comprimento da sequ encia, IndexError e
levantada (atribuic ao a uma sequ encia n ao pode adicionar novos items, apenas substituir items existentes).
Se a express ao for um mapeamento (um dicion ario), a subscric ao deve ser de um tipo compatvel com as
chaves, e ent ao pede-se que o objeto crie um par chave/dados que mapeia a subscric ao ao objeto atribudo.
Isto pode tanto substituir um par existente (com uma chave igual) ou inserir um novo (se a chave j a n ao
existir).
Se o alvo for um fatiamento (slicing): a express ao e resolvida e deve retornar uma sequ encia mut avel
(como uma lista. O objeto atribudo deve ser uma sequ encia do mesmo tipo. Em seguida, caso existam, as
express oes dando os limites superior e inferior (que devem ser inteiros, em geral pequenos) s ao resolvidas;
os valores padr ao s ao zero e o comprimento da seq encia. Se qualquer um dos limites for negativo, o
comprimento da sequ encia e adicionado a ele. Os valores resultantes s ao ent ao ajustados para car entre zero
e o comprimento da sequ encia, inclusive. Finalmente, o objeto e usado para substituir a fatia (slice) com
os items da sequ encia atribuda. O comprimento da fatia pode ser diferente do comprimento da sequ encia
atribuda, mudando o comprimento da sequ encia alvo, se ela permitir.
(Na implementac ao atual, assume-se que a sintaxe para alvos e id entica ` a usada para express oes, e uma sintaxe
inv alida e rejeitada na fase de gerac ao do c odigo, com mensagens de erro menos detalhadas.)
AVISO: Apesar da denic ao de atribuic ao implicar que repassar vari aveis entre o lado esquerdo e o lado direito
da express ao e uma operac ao segura (exemplo: a, b = b, a troca duas vari aveis), o mesmo dentro de uma
colec ao de vari aveis sendo atribudas n ao e seguro! Por exemplo, o seguinte programa escreve [0, 2]:
x = [0, 1]
i = 0
i, x[i] = 1, 2
print x
6.3.1 Atribuic oes incrementais
Uma atribuic ao incremental e a combinac ao, em um unico comando, de uma operac ao bin aria e uma atribuic ao:
augmented_assignment_stmt ::= target augop expression_list
augop ::= "+= -= "*= "/= "%= "**="
| >= <= "&= "= ="
(Veja a sec ao 5.3 para denic oes da sintaxe dos tr es ultimos smbolos.)
Uma atribuic ao incremental resolve o alvo (que, ao contr ario de outras operac oes de atribuic ao, n ao pode ser uma
sequ encia) e a lista de express oes, realizando a operac ao especca em relac ao ao tipo dos operandos, e por m
atribui o resultado ao alvo original. O alvo e resolvido apenas uma vez.
6.3. Atribuic oes 51
Uma express ao x += 1 pode ser escrita como x = x + 1 para obter um efeito semelhante, mas n ao id entico.
Na vers ao incremental, x e resolvido apenas uma vez. Al em disso, quando for possvel, a operac ao e realizada
in-place. Ao inv es de criar um novo objeto e atribudo ao alvo, o objeto antigo e modicado.
Com a excec ao de atribuic oes a tuplas e m ultiplos alvos no mesmo comando, a atribuic ao incremental e realizada
da mesma maneira que uma atribuic ao normal. De forma similar, com a excec ao do comportamento in-place
citado acima, a operac ao bin aria realizada pela atribuic ao e a mesma de uma operac ao normal.
Para alvos que s ao refer encias de atributos, o valor inicial e obtido com o m etodo getattr() e o resultado
e atribudo com o m etodo setattr(). Note que os dois m etodos n ao referem necessariamente a mesma
vari avel. Quando getattr() refer a uma vari avel da classe, setattr() ainda atribui o valor a uma vari avel
da inst ancia. Por exemplo:
class A:
x = 3 # variavel da classe
a = A()
a.x += 1 # atribui 4 `a a.x, deixando 3 em A.x
6.4 O comando pass
pass_stmt ::= "pass"
pass e uma operac ao nula quando e executado, nada acontece.

E util para tornar v alido um espaco vazio,
quando um comando e requerido sintaticamente, mas nenhum c odigo precisa ser executado, por exemplo:
def f(arg): pass # uma funcao que nao faz nada(ainda)
class C: pass # uma classe sem metodos (ainda)
6.5 O comando del
del_stmt ::= "del"target_list
A delec ao e recursivamente denida de forma bem similar ` as atribuic oes. Ao inv es de pass a-la em todos os
detalhes, aqui est ao algumas dicas.
Deletar uma lista alvo recursivamente deleta cada elemento, da esquerda pra direita.
Deletar um nome remove a sua ligac ao do espaco tanto local quanto global, caso o nome ocorra num comando
global no mesmo bloco de c odigo. Se o nome n ao est a ligado a nada, uma excec ao NameError ser a levantada.
E ilegal deletar um nome do espaco local se ele ocorre como uma vari avel livre em um bloco aninhado.
Delec oes de refer encias de atributos, subscric oes e slicings s ao passadas para o objeto prim ario envolvido na
operac ao; delec ao de um slicing e em geral equivalente a atribuic ao um slice vazio do tipo correto (determinado
pelo tipo do objeto).
6.6 O comando print
print_stmt ::= "print"( [expression (","expression)* [","]]
| >"expression [(","expression)+ [","]] )
print interpreta cada express ao passada e escreve o objeto resultante na sada de dados padr ao (veja adiante).
Se um objeto n ao e uma string, ele e primeiro convertido, usando as regras de convers ao. A string (resultante ou
original) e ent ao escrita. Um espaco e escrito antes de cada objeto, a menos que para o sistema de sada de dados
o cursor esteja posicionado no comeco da linha. Este e o caso (1) quando nenhum caracter foi ainda escrito na
sada de dados padr ao, (2) quando o ultimo caracter escrito na sada foi \n, ou (3) quando a ultima operac ao
de escrita na sada de dados n ao foi com o comando print. (Por esta raz ao, em alguns outros casos, pode ser
interessante escrever uma string vazia na sada de dados.) Note: Objetos que se comportam como arquivos mas
n ao s ao os objetos arquivo embutidos na linguagem, frequentemente n ao emulam corretamente este aspecto dos
arquivos, ent ao e melhor n ao conar nesse comportamente.
Um caracter \n e escrito no m, a menos que o comando print termine com uma vrgula. Esta e a unica ac ao
se o comando contem apenas a keyword print.
A sada de dados padr ao e denida como o objeto arquivo nomeado stdout no m odulo sys. Se o objeto n ao
existir, ou se ele n ao tiver um m etodo write(), ent ao uma excec ao RuntimeError e levantada.
print tem ainda uma forma estendida, denida pela segunda parte da sintaxe descrita acima. Esta forma e
algumas vezes referida como print chevron.. Nesta forma, a primeira express ao depois de >> deve resolver
em em um objeto arquivo ou que se comporte como arquivo, tendo um m etodo write(), como descrito acima.
Com esta forma estendida, as express oes subsequentes s ao impressas neste objeto arquivo. Se a primeira express ao
e resolvida como None, ent ao sys.stdout e usado como o arquivo de sada.
6.7 O comando return
return_stmt ::= "return"[expression_list]
return pode ocorrer apenas aninhado em uma denic ao de func ao, nunca em uma denic ao de classe.
Se a lista de express oes est a presente, ela e interpretada, caso contr ario None e o valor.
return deixa a chamada de func ao atual com a lista de express oes (ou None) como valor de retorno.
Quando return sai do controle de uma instruc ao try com uma cl ausula finally, essa cl ausula e executada
antes de deixar a func ao.
Em um gerador, n ao e permitido incluir uma lista de express oes (expression_list) no comando return.
Nesse contexto, um return indica que o gerador nalizou e ir a levantar a excec ao StopIteration.
6.8 O comando yield
yield_stmt ::= "yield"expression_list
O comando yield e usado apenas quando denindo um gerador, e e usado apenas no corpo da func ao que dene
o gerador. Usar o comando yield em uma denic ao de func ao e o suciente para que aquela denic ao crie um
gerador ao inv es de uma func ao normal.
Quando uma func ao que dene um gerador e chamado, ela retorna um iterador, ou o nome mais comumente usado,
um gerador. O corpo da func ao e executado chamando-se o m etodo next() do gerador repetidamente, at e que
uma excec ao seja levantada.
Quando um comando yield e executado, o estado do gerador e congelado e o valor da expression_list
e retornado para o invocador do m etodo next(). Por congelado n os queremos dizer que o estado local e
armazenado, incluindo as ligac oes atuais a vari aveis locais, o ponteiro de instruc ao e a pilha de resoluc ao interna:
e guardada toda informac ao necess aria para que na pr oxima vez que o m etodo next() for chamado, a func ao
possa proceder exatamente como se o comando yield fosse apenas outra chamada externa normal.
O comando yield n ao e permitido na cl ausula try de um comando try ... finally. O problema e que n ao h a
qualquer garantia de que o gerador ir a continuar a execuc ao, portanto, nenhuma garantia de que o bloco finally
ser a executado.
Note: Em Python 2.2, o comando yield s o e permitido quando geradores foram habilitados. Eles est ao habili-
tados por padr ao em Python 2.3. O seguinte comando pode ser usado para habilit a-los em Python 2.2:
6.7. O comando return 53
from __future__ import generators
See Also:
PEP 0255, Simple Generators
The proposal for adding generators and the yield statement to Python.
6.9 O comando raise
raise_stmt ::= "raise"[expression [","expression [","expression]]]
Se nenhuma express ao estiver presente, raise levanta novamente a ultima excec ao ativa no escopo atual. Se
nenhuma excec ao esteve ativa, uma excec ao Queue.Empty e levantada indicando esse erro.
Em outros casos, raise resolve as express oes para obter tr es objetos, usando None como o valor das express oes
omitidas. Os primeiros dois objetos s ao usados para determinar o tipo e valor da excec ao.
Se o primeiro objeto e uma inst ancia, o tipo da excec ao e a sua classe, a pr opria inst ancia e o valor e o segundo
objeto deve ser None.
Se o primeiro objeto e uma classe, ela se torna o tipo da excec ao. O segundo objeto e usado para determinar o
valor da excec ao: se ele for uma inst ancia da classe, ela se torna o valor. Se for uma tupla, ela e usada como a
lista de argumentos para a construtora da classe; se for None, uma lista de argumentos vazia e usada, e qualquer
outro objeto e tratado como um unico argumento para a construtora. A inst ancia ent ao criada pela chamada ` a
construtura e usada como valor da excec ao.
Se um terceiro objeto estiver presente e n ao for None, ele deve ser um objeto traceback (veja a sec ao 3.2), e e
usado ao inv es do local atual como o lugar em que a excec ao ocorreu. Se o terceiro objeto estiver presente e
n ao for o objeto traceback ou None, uma excec ao TypeError e levantada. A forma com tr es express oes de
raise e util para levantar novamente uma excec ao de forma transparente em uma cl ausula except, mas raise com
nenhuma express ao e preferida caso a excec ao a ser levantada foi a ultima excec ao ativa no escopo atual.
Informac ao adicional sobre excec oes pode ser encontrada em section 4.2, e informac ao sobre manipulac ao de
excec oes se encontra em section 7.4.
6.10 O comando break
break_stmt ::= "break"
break pode ocorrer aninhado em um loop for ou while, mas nunca em uma denic ao de func ao ou classe
dentro desse loop.
Ele termina o loop mais pr oximo, pulando a cl ausula opcional else, caso o loop tenha uma.
Se um loop for e terminado por break, as vari aveis alvo do loop mant em seu valor atual.
Quando break remove o controle de um comando try com uma cl ausula finally, essa cl ausula e executada
antes de deixar o loop.
6.11 O comando continue
continue_stmt ::= "continue"
continue pode ocorrer aninhado em um loop for ou while, mas n ao em uma denic ao de func ao ou classe
dentro desse loop.
1
Ele continua com o pr oximo ciclo do loop mais pr oximo.
1
Ele pode ocorrer dentro de uma cl ausula except ou else. A restric ao sobre o try e por pura preguica durante a implementac ao do
comando e com o tempo ser a removida.
6.12 O comando import
import_stmt ::= "import"module ["as"name] ( ","module ["as"name] )*
| "from"module "import"identifier ["as"name]
( ","identifier ["as"name] )*
| "from"module "import("identifier ["as"name]
( ","identifier ["as"name] )* [","] ")"
| "from"module "import*"
module ::= (identifier ".")* identifier
O comando import e executado em dois passos: (1) encontre o m odulo e inicialize-o se necess ario; (2) dena um
nome ou nomes no espaco local (do escopo onde o comando import ocorre). A primeira forma (sem from)
repete esses passos para cada identicador na lista. A forma com from executa o passo (1) uma vez e depois o
passo (2) repetidamente.
Neste contexto, inicializar um m odulo built-int ou uma extens ao, signica chamar uma func ao de inicializac ao
que o m odulo deve fornecer para este prop osito (na implementac ao de refer encia, o nome da func ao e obtido pre-
xando a string init ao nome do m odulo); inicializar um m odulo com c odigo puramente em Python signica
simplesmente executar o c odigo do corpo desse m odulo.
O sistema mantem uma tabela de m odulos que foram ou est ao sendo inicializados, indexada pelo nome do m odulo.
Essa tabela e acessvel como sys.modules. Quando um nome de um m odulo e encontrado nesta tabela, sig-
nica que o passo (1) foi concludo. Se n ao, uma busca por uma denic ao do m odulo e iniciada. Quando en-
contrado, e ent ao carregado. Detalhes no processo de buscar e carregar um m odulo dependem da implementac ao
e plataforma. Geralmente envolve buscar por um m odulo built-int com o nome dade e ent ao procur a-lo em uma
lista de locais dada por sys.path.
Se um m odulo built-in e encontrado, seu c odigo de inicializac ao e executado e o passo (1) e nalizado. Se
nenhum arquivo coincidente for encontrado, a excec ao ImportError e levantada. Se um erro de sintaxe ocorre,
a excec ao SyntaxError e levantada. Sen ao, um m odulo vazio com o nome dado e criado e inserido na tabela, e
ent ao o c odigo do e executado dentro desse m odulo vazio. Excec oes durante esta execuc ao encerram o passo (1).
Quando passo (1) termina sem levantar uma excec ao, o passo (2) pode comecar.
A primeira forma do comando import atribui o nome do m odulo no espaco local ao objeto correspondente, e
ent ao passa para o pr oximo identicador, se houver. Se o nome do m odulo e seguido da keyword as, o nome
seguinte e usado como o nome local para o m odulo.
A forma usando from n ao atribui o m odulo ao seu nome; ao inv es disso, passa-se por toda a lista de identi-
cadores, procurando cada um no m odulo encontrado no passo (1), e ent ao liga-se o nome no espaco local ao
objeto encontrado. Como ocorre com a primeira forma de import, um nome local alternativa pode ser es-
pecicado usando-se as nome. Se um nome n ao for encontrado, ImportError e levantada. Se a lista de
identicadores for substituda por um asterisco (*), ent ao todos os nomes p ublicos denidos no m odulos s ao
ligados no espaco local do comando import.
Os nomes p ublicos denidos por um m odulo s ao determinados por uma vari avel no m odulo chamada __all__;
se denida, ela deve ser uma sequ encia de strings que s ao os nomes denidos ou import aveis desse m odulo. Os
nomes em__all__ s ao todos considerados p ublicos e existentes. Se __all__ n ao e denida, ent ao o conjunto
de nomes p ublicos inclui todos os nomes encontrados no m odulo que n ao comecam com um _. __all__ deve
conter toda a API p ublica desse m odulo. A intenc ao e evitar exportar acidentalmente itens que n ao s ao parte da
API (como outros m odulos da biblioteca que foram importados e usados apenas dentro do m odulo).
A forma usando from com * pode ocorrer apenas no escopo do m odulo. Se for usada dentro de uma
func ao, e a func ao contem ou est a contida em um bloco com outras vari aveis, o compilador levanta a excec ao
SyntaxError.
Hierarquia dos nomes em um m odulo:
quando os nomes em um m odulo cont em um ou mais pontos, a busca pelo caminho do m odulo e feita de forma
diferente. A sequ encia de identicadores at e o ultimo ponto e usada para encontrar um pacote; o ultimo identi-
cado e ent ao procurado dentro do pacote. Um pacote e geralmente um subdiret orio de um diret orio emsys.path
com um arquivo init .
[XXX Cant be bothered to spell this out right now; see the URL http://www.python.org/doc/essays/packages.html
6.12. O comando import 55
for more details, also about how the module search works from inside a package.]
A func ao __import__() e fornecida para suportar aplicac oes que determinam dinamicamente que m odulos
precisam ser carregados; veja Func oes Built-in na Refer encia da Biblioteca Python para mais informac oesl.
6.12.1 Comandos futuros
Um comando futuro orienta o compilador de que um determinado m odulo deve ser compilado usando a sintaxe
ou a sem antica que estar a disponvel numa vers ao futura da linguagem. A intenc ao e facilitar a migrac ao para
vers oes futuras que introduzem mudancas que criam incompatibilidades na linguage. Ele permite o uso de novas
func oes em determinados m odulos, antes que a func ao se torne o padr ao.
future_statement ::= "from__future__import"feature ["as"name] (","feature ["as"name])*
| "from__future__import("feature ["as"name] (","feature ["as"name])* [","] ")"
feature ::= identifier
name ::= identifier
Um comando futuro deve aparecer logo no topo do m odulo. As unicas linhas permitidas antes dele s ao:
a docstring do m odulo (se houver),
coment arios,
linhas em branco,
outros comandos futuros.
As func oes reconhecidas em Python 2.3 s ao generators (geradores), division (divis ao de inteiros) e
nested_scopes (escopos aninhados). generators e nested_scopes s ao redundantes em Python
2.3 porque est ao sempre ativos.
Um comando futuro e reconhecido e tratado durante a compilac ao: mudancas na sem antica do n uclero da lin-
guagem s ao frequentemente implementadas gerando um c odigo diferente.

E at e possvel que uma nova func ao
introduza novas incompatibilidades na linguagem (como uma nova palavra reservada), caso em que o compilador
precisa interpretar o c odigo do m odulo de forma diferente. Estas decis oes n ao podem ser deixadas de lado at e o
momento da execuc ao.
Para qualquer vers ao, o compilador sabe exatamente que func oes foramdenidas e levanta umerro se umcomando
futuro cont em algo desconhecido.
A sem antica usada no momento da execuc ao e a mesma de qualquer comando import: h a um m odulo padr ao
chamado __future__, descrito adiante, e ele ser a importado da maneira usual no momento em que o comando
e executado.
Note que n ao h a nada de especial no comando:
import __future__ [como um nome]
Esse n ao e um comando futuro; e um comando import ordin ario, sem nenhuma sem antica especial ou restric ao na
sintaxe.
C odigo compilado pelo comando exec ou chamadas ` as func oes compile() e execfile() que ocorram em
um m odulo M contendo um comando futuro ir ao, por denic ao, usar a nova sintaxe ou sem antica associada com o
comando. Isso pode, a partir de Python 2.2, ser controlado com argumentos opcionais ` a func ao compile()
veja a documentac ao dessa func ao na biblioteca padr ao para mais detalhes.
Um comando futuro digitado no prompt do interpretador interativo ir a ter efeito pelo resto da sess ao. Se o inter-
pretador e iniciado com a oc ao -i e se for passado para execuc ao um script que contenha um comando futuro, ele
estar a em efeito na sess ao apenas depois que o script for executado.
6.13 O comando global
global_stmt ::= "global"identifier (","identifier)*
O comando global e uma declarac ao que vale para todo o bloco de c odigo atual. Signica que todos os identi-
cadores listados s ao interpretados como globais.

E impossvel atribuir um valor ` a uma vari avel global sem usar
o comando global, apesar de ser possvel se referir ` a globais sem ter sido declaradas como tal.
Nomes listados em um comando global n ao devem ser usados no mesmo bloco de texto antes do comando.
Nomes listados no comando n ao devem ser denidos como par ametros formais ou como vari avel alvo de um loop
for, denic

Oes de classes, denic oes de func oes ou no comando import.
(A implementac ao atual n ao imp oe restric oes formais ` as duas ultimas restric oes citadas, mas os programas n ao
devem abusar dessa liberdade, j a que futuras implementac oes podem alterar esse comportamento.
Nota: o comando global e uma diretiva para o parser. Ele se aplica apenas ao c odigo processado no mesmo
momento que o comando. Por exemplo, quando usado em um comando exec, ele n ao afeta o bloco que c odigo
que cont em esse exec, e o c odigo contido nele n ao e afetado por um comando global contido no bloco que
cont em o exec. O mesmo se aplica ` as func oes eval(), execfile() e compile().
6.14 O comando exec
exec_stmt ::= "exec"expression ["in"expression [","expression]]
Este comando permite a execuc ao din amica de c odigo Python. A primeira express ao deve resolver em uma string,
um objeto arquivo aberto ou um objeto c odigo. Se for uma string, ela e processada como se fosse um conjunto de
instruc oes, que s ao ent ao executadas (a menos que ocorra um erro de sintaxe). Se for um arquivo, ele e processado
at e EOF e executado. Se for um objeto c odigo, ele e simplesmente executado. Em todos os casos, espera-se que o
c odigo a ser executado seja v alido, como origin ario de um arquivo (veja a sec ao 8.2, File input). Esteja ciente
de que os comandos return e yield n ao podem ser usados fora de denic ao de func oes, mesmo no contexto
do c odigo passado para o comando exec.
Em todos os casos, se as partes opcionais forem omitidas, o c odigo e executado no escopo atual. Se apenas a
primeira express ao depois de in e especicada, deve ser um dicion ario, usado tanto para as vari aveis globais
quanto para as locais. Se duas express oes s ao passadas, s ao usadas para as vari aveis globais e locais, respectiva-
mente. Se passada, locals pode ser qualquer mapeamento. Changed in version 2.4: anteriormente, era requerido
que locals fosse um dicion ario.
Como efeito colateral, uma implementac ao pode inserir chaves adicionais nos dicion arios al em daquelas corre-
spondentes as vari aveis criadas pelo c odigo executado. Por exemplo, a implementac ao atual pode inserer uma
refer encia ao dicion ario do m odulo built-in builtin na chave __builtins__ (!).
Dica:
resoluc ao din amica de express oes e possvel atrav es da func ao eval(). As func oes globals() e locals()
retornam os dicion arios globais e locais, respectivamente, o que pode ser util para uso com o comando exec.
6.13. O comando global 57
58
CAP
ITULO
SEVEN
Instruc oes compostas
Instruc oes compostas comt em(grupos de) outras instruc oes; elas afetamou controlamde alguma forma a execuc ao
destas outras instruc oes. Em geral, instruc oes compostas se propagam por v arias linhas, apesar de que quando
usadas de formas simples, ela pode estar contida em uma s o linha.
As instruc oes if, while e for implementam as tradicionais estruturas de controle de uxo. try especica os
manipladores de excec oes e/ou c odigo de limpeza para um grupo de instruc oes. Denic oes de func oes e de classes
tamb em s ao consideradas sintaticamente como instruc oes compostas.
Instruc oes compostas consistem de uma ou mais cl ausulas. Uma cl ausula consiste de um cabecalho e de um
corpo(suite, no original). Os cabecalhos das diversas cl ausulas de uma instruc ao composta est ao sempre no
mesmo nvel de indentac ao. Cada cabecalho comeca com uma keyword identicador e termina com um sinal de
dois-pontos. O corpo e um grupo de instruc oes controlado por uma cl ausula. Ele pode ter um ou mais instruc oes
separadas por um sinal de ponto-e-vrgula na mesma linha do cabecalho, logo ap os o sinal de dois pontos do
cabecalho, ou pode ter uma ou mais instruc oes indentadas nas linhas seguintes. Apenas a ultima forma pode
conter intruc oes compostas aninhadas; o seguinte exemplo e ilegal, principalmente por n ao deixar claro a qual if
um possvel else seguinte pertenceria:
if test1: if test2: print x
Note ainda que o ponto-e-vrgula estabelece uma ligac ao mais forte que o sinal de dois-pontos neste contexto,
ent ao, no exemplo seguinte, s ao executados ou todas ou nenhuma das instruc oes print presentes:
if x < y < z: print x; print y; print z
Sum ario:
compound_stmt ::= if_stmt
| while_stmt
| for_stmt
| try_stmt
| funcdef
| classdef
suite ::= stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT
statement ::= stmt_list NEWLINE | compound_stmt
stmt_list ::= simple_stmt (";"simple_stmt)* [";"]
Note que instruc oes sempre terminam com o smbolo NEWLINE possivelmente seguido de um DEDENT. Note
ainda que cl ausulas de continuac ao opcionais sempre comecam com uma keyword que n ao pode iniciar uma
instruc ao, para que n ao hajam ambiguidades. (o problema de a qual if pertence o else e resolvido em Python
requerendo que todos os if aninhados estejam indentados.
Para deixar mais claro, a formatac ao das regras gramaticais adiante posiciona cada cl ausula emuma linha separada.
59
7.1 O comando if
O comando if e usado para execuc ao condicional:
if_stmt ::= "if"expression ":"suite
( "elif"expression ":"suite )*
["else:"suite]
Ele seleciona exatamente um dos corpos existentes, resolvendo as express oes, at e que uma delas seja verdadeira
(veja a sec ao 5.11 para as denic oes de verdadeiro e falso); ent ao, aquele corpo e executado (e nenhuma outra
parte do comando if e executada ou resolvida). Se todas as express oes s ao falsas, o corpo da cl ausula else, se
existente, e executado.
7.2 O comando while
O comando while e usado para execuc ao contnua, enquanto uma express ao for verdadeira:
while_stmt ::= "while"expression ":"suite
["else:"suite]
O comando repetidamente testa a express ao e, se for verdadeira, executa o primeiro corpo; se a express ao for falsa
(o que pode ocorrer na primeira vez que e testada) o corpo da cl ausula else, se presente, e executado, e o loop
termina.
O comando break executado no primeiro corpo naliza o loop sem executar o corpo da cl ausula else. O
comando continue executado no primeiro corpo pula o resto dele e volta a testar a validade da express ao.
7.3 O comando for
O comando for e usado para iterar pelos elementos de uma sequ encia (como uma string, tupla ou lista) ou
qualquer outro objeto iter avel:
for_stmt ::= "for"target_list "in"expression_list ":"suite
["else:"suite]
A lista de express oes e resolvida uma vez; ela deve retornar um objeto iter avel. Um iterador e criado e o corpo e
ent ao executado uma vez para cada item, em ordem ascendente. Cada item e ent ao passado para a lista de alvos
(target list) usando as regras normais de denic ao, e ent ao o corpo e executado. Quando os itens acabam (o que
ocorre imediatamente se a sequ encia estiver vazia), o corpo da cl ausula else, se presente, e executado, e o loop
termina.
O comando break executado no primeiro corpo naliza o loop sem executar o corpo da cl ausula else. O
comando continue executado no primeiro corpo pula para o pr oximo item da sequ encia, ou para a cl ausula
else se n ao houver um pr oximo item.
O corpo pode designar objetos para as vari aveis na lista de alvos; isso n ao afeta o pr oximo item designado a elas.
A lista de alvos n ao e apagada quando o loop e nalizado, mas se a sequ encia estiver vazia, naturalmente as
vari aveis da lista n ao ter ao recebido objeto algum pelo loop. Dica: a func ao built-in range() retorna uma
sequ encia de inteiros adequada para realizar uma sequ encia de execuc oes atrav es de um ndice qualquer, de forma
similar ao for encontrado em C ou Pascal.
Warning: H a um problema sutil quando a sequ encia est a sendo modicada pelo loop (o que pode ocorrer com
sequ encias mut aveis, como listas). Um contador interno e usado para manter um controle de qual e o pr oximo
item, e e incrementado a cada iterac ao. Quando este contador chega ao valor do comprimento da sequ encia, o
loop termina. Isso signica que se o corpo deleta o item atual(ou um item anterior) da sequ encia, o loop vai pular
o pr oximo item (j a que ele toma o ndice do item atual, que j a foi manipulado). De forma semelhante, se o corpo
insere um item na sequ encia antes do item atual, ele ser a manipulado novamente na pr oxima passagem do loop.
Isso pode levar a bugs s erios que podem ser evitados fazendo uma c opia tempor aria da sequ encia. Por exemplo:
60 Captulo 7. Instruc oes compostas
for x in a[:]:
if x < 0: a.remove(x)
7.4 O comando try
O comando try especica manipuladores de excec oes e/ou c odigo de limpeza para um grupo de instruc oes:
try_stmt ::= try_exc_stmt | try_fin_stmt
try_exc_stmt ::= "try:"suite
("except"[expression [","target]] ":"suite)+
["else:"suite]
try_fin_stmt ::= "try:"suite "finally:"suite
A duas formas de usar o comando try: try...except e try...finally. Estas formas n ao podem ser mistu-
radas (mas podem ser aninhadas uma na outra).
A forma try...except especica um ou mais manipuladores de excec oes (as cl ausulas except). Quando
nenhuma exec ao ocorre na cl ausula try, nenhum manipulador e executado. Quando uma excec ao ocorre, uma
procura por um manipulador inicia. Essa procura inspeciona cada uma das cl ausulas except at e que e encontrada
uma que coincida com a excec ao. Uma cl ausula excetp sem uma excec ao, se existente, deve ser a ultima; ela
coincide com qualquer excec ao. Para uma cl ausula except com uma express ao, essa express ao e resolvida, e se o
objeto resultante for compatvel com a excec ao, ela e marcada como coincidente. Um objeto e coincidente com a
excec ao se ele e a classe ou uma classe base da excec ao, ou, no caso (desaconselh avel) de strings como excec oes,
e a pr opria string que foi levantada (note que a identidade do objeto tem de coincidir, isto e, tem de ser o mesmo
objeto, n ao apenas uma string com o mesmo valor).
Se nenhuma cl ausula coincide com a excec ao, a busca continua no c odigo em volta e na pilha de invocac ao.
Se a resoluc ao de uma express ao no cabecalho de uma cl ausula except levanta uma excec ao, a busca original
e cancelada, e uma nova busca e iniciada para a nova excec ao no c odigo em volta da express ao e na pilha de
chamada (o c odigo e tratado como se todo o comando try levantou a excec ao).
Quando uma cl ausula except coincidente e encontrada, a excec ao e atribudo ao alvo especicado naquela cl ausula,
se presente, e ent ao a cl ausula e executada. Todas as cl ausulas except t emde conter umbloco de c odigo execut avel.
Quando chega ao m desse bloco, a execuc ao continua normalmente ap os todo o comando try. (isso signica que
se existirem dois manipuladores aninhados para a mesma excec ao, e a excec ao ocorre no try do manipulador
interno, o manipulador externo n ao ir a manipular a excec ao.)
Antes que o corpo de uma cl ausula except seja executado, detalhes sobre a excec ao s ao designados ` a tr es vari aveis
no m odulo sys module: sys.exc_type recebe o objeto identicador da excec ao; sys.exc_value recebe
os par ametros; e sys.exc_traceback recebe um objeto traceback (veja a sec ao 3.2), identicando o ponto
no programa em que a excec ao ocorreu. Estes detalhes tamb em est ao disponveis atrav es da func ao sys.exc_-
info() que retorna uma tupla (exc type, exc value, exc traceback). O uso dessa func ao e prefervel as
vari aveis correspondentes, j a que estas s ao inseguras em um programa que use threads. A partir de Python 1.5,
as vari aveis t em seus valores originais restaurados (antes da chamada) quando retornando de uma func aoque
manipulou a excec ao.
A cl ausula opcional else e executada se e quando o controle passa do m da cl ausula try. .
1
Excec oes na
cl ausula else n ao s ao manipuladas pelas cl ausulas except precedentes.
A forma try...finally especica um manipulador de limpeza. A cl ausula try e executada. Quando nen-
huma excec ao ocorre, a cl ausula finally e executada. Quando uma excec ao ocorre na cl ausula try, a excec ao
e temporariamente salva, a cl ausula finally e executada a ent ao a excec ao salva e re-levantada. Se a cl ausula
finally levanta outra excec ao ou executa uma instruc ao continue ou break, a excec ao salva e perdida.
Uma instruc ao continue na cl ausula finally e ilegal. (A raz ao e um problema com a implementac ao atual
essa restric ao pode ser removida no futuro). A informac ao sobre a excec ao n ao est a disponvel para o programa
durante a execuc ao da cl ausula finally.
1
Atualmente, o controle passa do m, exceto no caso de uma excec ao ou na execuc ao dos comandos return, continue ou break.
7.4. O comando try 61
Quando uma instruc ao return, break ou continue e executada no corpo do comando try...finally, a
cl ausula finally tamb em e executada durante a sada. Uma instruc ao continue na cl ausula finally e
ilegal. (A raz ao e um problema com a implementac ao atual essa restric ao pode ser removida no futuro).
Mais informac oes sobre excec oes podem ser encontradas na sec ao 4.2, e informac oes sobre o uso do comando
raise para gerar excec oes podem ser encontradas na sec ao 6.9.
7.5 Denic ao de func oes
Uma denic ao de func ao cria um objeto function, de acordo com a denic ao do usu ario (veja a sec ao 3.2):
funcdef ::= [decorators] "def"funcname "("[parameter_list] "):"suite
decorators ::= decorator+
decorator ::= "@"dotted_name ["("[argument_list [","]] ")"] NEWLINE
dotted_name ::= identifier ("."identifier)*
parameter_list ::= (defparameter ",")*
( "*"identifier [, "**"identifier]
| "**"identifier
| defparameter [","] )
defparameter ::= parameter ["="expression]
sublist ::= parameter (","parameter)* [","]
parameter ::= identifier | "("sublist ")"
funcname ::= identifier
Uma denic ao de func ao e uma instruc ao execut avel. Sua execuc ao liga o nome da func ao no contexto atual a um
objeto func ao (um inv olucro do c odigo execut avel para a func ao). Este objeto cont em uma refer encia ao espaco
global atual como o contexto a ser usado quando a func ao e chamada.
A denic ao n ao executa o corpo da func ao; este e executado apenas quando a func ao e chamada.
A function denition may be wrapped by one or more decorator expressions. Decorator expressions are evaluated
when the function is dened, in the scope that contains the function denition. 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 equivalent to:
def func(): pass
func = f1(arg)(f2(func))
Quando um ou mais par ametros t em a forma par ametro = express ao, diz-se que a func ao t em par ametros com
valores padr ao. Para um par ametro com valor padr ao, o argumento correspondente pode ser omitido de uma
chamada, caso em que o valor padr ao do par ametro e substitudo. Se um par ametro tem um valor padr ao, todos
os par ametros seguintes tamb em t em de ter esta e uma restric ao sint atica que n ao est a expressa na gram atica.
Valores padr ao de par ametros s ao resolvidos quando a denic ao da func ao e executada. Isso signica que a
express ao s o e resolvida uma vez, quando a denic ao da func ao e resolvida, e que o mesmo valor pr e-computado
e usado para todas as chamadas.

E importante entender isso, principalmente quando o valor padr ao e um objeto
mut avel, como uma lista ou dicion ario: se a func ao modica o objeto (por exemplo, adicionando um item a uma
lista) o valor padr ao est a denitivamente modicado. Geralmente, n ao e essa a intenc ao. Uma forma de contornar
isso e usar None como padr ao, e testar por ele no corpo da func ao. Por exemplo:
62 Captulo 7. Instruc oes compostas
def whats_on_the_telly(penguin=None):
if penguin is None:
penguin = []
penguin.append("property of the zoo")
return penguin
A sem antica da chamada de func oes e descrita em mais detalhes na sec ao ??. Uma chamada de func ao sempre
designa valores a todos os par ametros mencionados na lista de par ametros, seja de argumentos posicionais, de
palavras-chave ou de valores padr ao. Se a forma *identifier est a presente, essa vari avel e inicializada com
uma tupla contendo quaisquer argumentos posicionais em excesso. Se a forma **identifier e usada, a
var avel e inicializada com um dicion ario contendo quaisquer argumentos com palavras-chave usados em excesso.
Os valores padr ao s ao uma tupla e um dicion ario vazios, respectivamente.
E tamb em possvel criar func oes an onimas (func oes que n ao s ao ligadas a um nome), para uso imediato em
express oes. Elas usam o a instruc ao lambda, descrita na sec ao 5.12. Note que lambda e meramente um atalho para
uma denic ao simplicada de func ao; uma func ao denida com o comando def pode ser repassada ou ter o
nome redenido, assim como uma func ao denida por lambda. O comando def e mais poderoso pois permite
a execuc ao de m ultiplos comandos dentro do corpo da func ao.
Nota: Func oes s ao objetos de primeira classe. Um comando def executado dentro de uma denic ao de func ao,
cria uma func ao local que pode ser retornada ou passada adiante. Vari aveis livres usadas na func ao aninhada
podem acessar vari aveis locais da func ao contendo o comando. Veja a sec ao 4.1 para detalhes.
7.6 Denic ao de classes
Uma denic ao de classe cria um objeto class (veja a sec ao 3.2):
classdef ::= "class"classname [inheritance] ":"suite
inheritance ::= "("[expression_list] ")"
classname ::= identifier
Uma denic ao de classe e uma instruc ao execut avel. Ela primeiro resolve a lista de hierarquia, se presente.
Cada item na lista deve resolver em um objeto class ou type que possa ser subclasse. O corpo da classe e ent ao
executado num novo quador de execuc ao (ver sec ao 4.1), usando um novo espaco local e o espaco global original.
(normalmente, o corpo cont em apenas denic oes de func oes.) Quando o corpo da classe termina a execuc ao, seu
quadro de execuc ao e descartado, mas o espaco local e salvo. Um objeto class e ent ao criado, usando a lista de
hierarquia para as classes base e o espaco local salvo como o dicion ario de atributos. O nome da classe e ligado a
esse objeto class no espaco local original.
Nota: vari aveis denidas na denic ao de classe s ao vari aveis da classe; elas s ao compartilhadas por todas as
inst ancias. Para denir vari aveis da inst ancia, elas devem ter um valor designado no m etodo __init__()
ou em qualquer outro m etodo. Ambas as vari aveis da classe ou da inst ancia s ao acessveis atrav es da notac ao
self.name, e uma vari avel da inst ancia oculta uma vari avel da classe de mesmo nome quando acessada dessa
forma. Vari aveis de classe com valores imut aveis podem ser usadas como valores padr ao para as vari aveis das
inst ancias. For new-style classes, descriptors can be used to create instance variables with different implementation
details.
7.6. Denic ao de classes 63
64
CAP
ITULO
EIGHT
Componentes de alto-nvel
O interpretador Python pode receber sua entrada de uma s erie de fontes: de um script passado como entrada de
dados padr ao ou como argumento, digitado interativamente, de um m odulo, etc. Este captulo cobre a sintaxe
usada nestes casos.
8.1 Programas Python completos
Quando a uma especicac ao de uma linguagem n ao precisar prescrever como o interpretador deve ser invocado,
e util ter uma noc ao de um programa completo na linguagem. Um programa completo em Python e executado
em um ambiente minimamente inicializado: todos os m odulos da bilioteca padr ao ou built-in est ao disponveis,
mas nenhum foi inicializado, exceto pelos m odulos sys (v arios servicos do sistema), __builtin__ (func oes,
excec oes e None) e __main__. O otimo e usado para prover o ambiente local e global para a execuc ao do
programa.
A sintaxe de um programa completo (quando a entrada de dados e um arquivo) descrita na pr oxima sec ao.
O interpretador tamb em pode ser invocado em modo interativo; neste caso, ele n ao l e executa um programa
completo, e sim um comando de cada vez. O ambiente inicial e id entico ao de um programa; cada comando e
executado no ambiente do m odulo __main__.
Em UNIX, um programa completo pode ser passado para o interpretador em tr es formas: com a opc ao -c string na
linha de comando, como um arquivo passado como primeiro argumento, ou pela entrada de dados padr ao. Se o
arquivo ou entrada de dados e um terminal, o interpretador entra em modo interativo; caso contr ario, ele executa
o arquivo como um programa completo.
8.2 Arquivo como entrada de dados
Todo c odigo lido de um arquivo em modo n ao interativo tem a mesma forma:
file_input ::= (NEWLINE | statement)*
Essa sintaxe e usada nas seguintes situac oes:
quando estiver parseando um programa completo (de um arquivo ou de uma string);
quando estiver parseando um m odulo;
quando estiver parseando uma string passada para o comando exec;
8.3 Entrada de dados interativa
A entrada de dados em modo interativo e lida usando a seguinte gram atica:
interactive_input ::= [stmt_list] NEWLINE | compound_stmt NEWLINE
65
Note que uma instruc ao composta deve ser seguida de uma linha em branco quando em modo interativo; isso e
necess ario para que o parser possa detectar o m da entrada.
8.4 Express oes como entrada de dados
H a duas formas de usar express oes como entrada de dados. Ambas ignoram os espacos no comeco da linha.
A string usada como argumento para a func ao eval() deve ter a seguinte forma.
eval_input ::= expression_list NEWLINE*
A linha lida pela func ao input() deve ter a seguinte forma:
input_input ::= expression_list NEWLINE
Nota: para ler linhas cruas sem interpret a-las, voc e pode usar a func ao raw_input() ou o m etodo
readline() em arquivos.
66 Captulo 8. Componentes de alto-nvel
AP
ENDICE
A
Hist orico e Licencas
A.1 History of the software
Python was created in the early 1990s by Guido van Rossum at Stichting Mathematisch Centrum (CWI, see
http://www.cwi.nl/) in the Netherlands as a successor of a language called ABC. Guido remains Pythons principal
author, although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for National Research Initiatives (CNRI, see
http://www.cnri.reston.va.us/) in Reston, Virginia where he released several versions of the software.
In May 2000, Guido and the Python core development team moved to BeOpen.com to form the BeOpen Python-
Labs team. In October of the same year, the PythonLabs team moved to Digital Creations (now Zope Corporation;
see http://www.zope.com/). In 2001, the Python Software Foundation (PSF, see http://www.python.org/psf/) was
formed, a non-prot organization created specically to own Python-related Intellectual Property. Zope Corpora-
tion is a sponsoring member of the PSF.
All Python releases are Open Source (see http://www.opensource.org/ for the Open Source Denition). Histori-
cally, most, but not all, Python releases have also been GPL-compatible; the table below summarizes the various
releases.
Release Derived from Year Owner GPL compatible?
0.9.0 thru 1.2 n/a 1991-1995 CWI yes
1.3 thru 1.5.2 1.2 1995-1999 CNRI yes
1.6 1.5.2 2000 CNRI no
2.0 1.6 2000 BeOpen.com no
1.6.1 1.6 2001 CNRI no
2.1 2.0+1.6.1 2001 PSF no
2.0.1 2.0+1.6.1 2001 PSF yes
2.1.1 2.1+2.0.1 2001 PSF yes
2.2 2.1.1 2001 PSF yes
2.1.2 2.1.1 2002 PSF yes
2.1.3 2.1.2 2002 PSF yes
2.2.1 2.2 2002 PSF yes
2.2.2 2.2.1 2002 PSF yes
2.2.3 2.2.2 2002-2003 PSF yes
2.3 2.2.2 2002-2003 PSF yes
2.3.1 2.3 2002-2003 PSF yes
2.3.2 2.3.1 2003 PSF yes
2.3.3 2.3.2 2003 PSF yes
2.3.4 2.3.3 2004 PSF yes
2.3.5 2.3.4 2005 PSF yes
2.4 2.3 2004 PSF yes
2.4.1 2.4 2005 PSF yes
Note: GPL-compatible doesnt mean that were distributing Python under the GPL. All Python licenses, unlike
the GPL, let you distribute a modied version without making your changes open source. The GPL-compatible
67
licenses make it possible to combine Python with other software that is released under the GPL; the others dont.
Thanks to the many outside volunteers who have worked under Guidos direction to make these releases possible.
A.2 Terms and conditions for accessing or otherwise using Python
PSF LICENSE AGREEMENT FOR PYTHON 2.4.2
1. This LICENSE AGREEMENT is between the Python Software Foundation (PSF), and the Individual or
Organization (Licensee) accessing and otherwise using Python 2.4.2 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 deriva-
tive works, distribute, and otherwise use Python 2.4.2 alone or in any derivative version, provided, however,
that PSFs License Agreement and PSFs notice of copyright, i.e., Copyright c 2001-2004 Python Soft-
ware Foundation; All Rights Reserved are retained in Python 2.4.2 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 2.4.2 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 2.4.2.
4. PSF is making Python 2.4.2 available to Licensee on an AS IS basis. PSF MAKES NO REPRESEN-
TATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMI-
TATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MER-
CHANTABILITYORFITNESS FORANYPARTICULARPURPOSE ORTHAT THE USE OF PYTHON
2.4.2 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.4.2 FOR ANY
INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFY-
ING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.4.2, OR ANY DERIVATIVE THEREOF,
EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or
joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF
trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or
any third party.
8. By copying, installing or otherwise using Python 2.4.2, Licensee agrees to be bound by the terms and
conditions of this License Agreement.
BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
1. This LICENSE AGREEMENT is between BeOpen.com (BeOpen), having an ofce 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 Li-
censee 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 REP-
RESENTATIONS 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.
68 Ap endice A. Hist orico e Licencas
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,
6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of
California, excluding conict of law provisions. Nothing in this License Agreement shall be deemed to
create any relationship of agency, partnership, or joint venture between BeOpen and Licensee. This License
Agreement does not grant permission to use BeOpen trademarks or trade names in a trademark sense to
endorse or promote products or services of Licensee, or any third party. As an exception, the BeOpen
Python logos available at http://www.pythonlabs.com/logos.html may be used according to the permissions
granted on that web page.
7. By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and
conditions of this License Agreement.
CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an
ofce at 1895 Preston White Drive, Reston, VA 20191 (CNRI), and the Individual or Organization (Li-
censee) accessing and otherwise using Python 1.6.1 software in source or binary form and its associated
documentation.
2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a nonexclu-
sive, 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 CNRIs License Agreement and CNRIs notice of copyright, i.e., Copyright c 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 CNRIs License Agreement,
Licensee may substitute the following text (omitting the quotes): Python 1.6.1 is made available sub-
ject to the terms and conditions in CNRIs License Agreement. This Agreement together with Python
1.6.1 may be located on the Internet using the following unique, persistent identier (known as a handle):
1895.22/1013. This Agreement may also be obtained from a proxy server on the Internet using the following
URL: http://hdl.handle.net/1895.22/1013.
3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6.1 or any part
thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby
agrees to include in any such work a brief summary of the changes made to Python 1.6.1.
4. CNRI is making Python 1.6.1 available to Licensee on an AS IS basis. CNRI MAKES NO REPRESEN-
TATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMI-
TATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MER-
CHANTABILITYORFITNESS FORANYPARTICULARPURPOSE ORTHAT THE USE OF PYTHON
1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
5. CNRI SHALL NOT BE LIABLE TOLICENSEE ORANYOTHERUSERS OF PYTHON1.6.1 FORANY
INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFY-
ING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE THEREOF,
7. This License Agreement shall be governed by the federal intellectual property law of the United States, in-
cluding 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 Virginias conict of law provisions. Notwithstand-
ing 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 Com-
monwealth 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
A.2. Terms and conditions for accessing or otherwise using Python 69
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.
ACCEPT
CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
Copyright c 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 specic,
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 TOR-
TIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
A.3 Licenses and Acknowledgements for Incorporated Software
This section is an incomplete, but growing list of licenses and acknowledgements for third-party software incor-
porated in the Python distribution.
A.3.1 Mersenne Twister
The _random module includes code based on a download from http://www.math.keio.ac.jp/ matu-
moto/MT2002/emt19937ar.html. The following are the verbatim comments from the original code:
A C-program for MT19937, with initialization improved 2002/1/26.
Coded by Takuji Nishimura and Makoto Matsumoto.
Before using, initialize the state by using init_genrand(seed)
or init_by_array(init_key, key_length).
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Any feedback is very welcome.
http://www.math.keio.ac.jp/matumoto/emt.html
email: matumoto@math.keio.ac.jp
A.3.2 Sockets
The socket module uses the functions, getaddrinfo, and getnameinfo, which are coded in separate
source les from the WIDE Project, http://www.wide.ad.jp/about/index.html.
A.3. Licenses and Acknowledgements for Incorporated Software 71
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
GAI_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 GAI_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 GAI_ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN GAI_ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
A.3.3 Floating point exception control
The source for the fpectl module includes the following notice:
---------------------------------------------------------------------
/ Copyright (c) 1996. \
| The Regents of the University of California. |
| All rights reserved. |
| |
| Permission to use, copy, modify, and distribute this software for |
| any purpose without fee is hereby granted, provided that this en- |
| tire 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 work was produced at the University of California, Lawrence |
| Livermore National Laboratory under contract no. W-7405-ENG-48 |
| between the U.S. Department of Energy and The Regents of the |
| University of California for the operation of UC LLNL. |
| |
| DISCLAIMER |
| |
| This software was prepared as an account of work sponsored by an |
| agency of the United States Government. Neither the United States |
| Government nor the University of California nor any of their em- |
| ployees, makes any warranty, express or implied, or assumes any |
| liability or responsibility for the accuracy, completeness, or |
| usefulness of any information, apparatus, product, or process |
| disclosed, or represents that its use would not infringe |
| privately-owned rights. Reference herein to any specific commer- |
| cial products, process, or service by trade name, trademark, |
| manufacturer, or otherwise, does not necessarily constitute or |
| imply its endorsement, recommendation, or favoring by the United |
| States Government or the University of California. The views and |
| opinions of authors expressed herein do not necessarily state or |
| reflect those of the United States Government or the University |
| of California, and shall not be used for advertising or product |
\ endorsement purposes. /
---------------------------------------------------------------------
A.3.4 MD5 message digest algorithm
The source code for the md5 module contains the following notice:
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
A.3.5 Asynchronous socket services
The asynchat and asyncore modules contain the following notice:
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.
A.3.6 Cookie management
The Cookie module contains the following notice:
Copyright 2000 by Timothy OMalley <timo@alum.mit.edu>
All Rights Reserved
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Timothy OMalley not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.
Timothy OMalley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS, IN NO EVENT SHALL Timothy OMalley 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.
A.3.7 Proling
The profile and pstats modules contain the following notice:
Copyright 1994, by InfoSeek Corporation, all rights reserved.
Written by James Roskind
Permission to use, copy, modify, and distribute this Python software
and its associated documentation for any purpose (subject to the
restriction in the following sentence) 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 InfoSeek not be used in
advertising or publicity pertaining to distribution of the software
without specific, written prior permission. This permission is
explicitly restricted to the copying and modification of the software
to remain in Python, compiled Python, or other languages (such as C)
wherein the modified or derived code is exclusively imported into a
Python module.
INFOSEEK CORPORATION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL INFOSEEK CORPORATION 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.
A.3.8 Execution tracing
The trace module contains the following notice:
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 OWhielacronx
http://zooko.com/
mailto:zooko@zooko.com
Copyright 2000, Mojam Media, Inc., all rights reserved.
Author: Skip Montanaro
Copyright 1999, Bioreason, Inc., all rights reserved.
Author: Andrew Dalke
Copyright 1995-1997, Automatrix, Inc., all rights reserved.
Author: Skip Montanaro
Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved.
Permission to use, copy, modify, and distribute this Python software and
its associated documentation for any purpose without fee is hereby
granted, provided that the above copyright notice appears in all copies,
and that both that copyright notice and this permission notice appear in
supporting documentation, and that the name of neither Automatrix,
Bioreason or Mojam Media be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.
A.3.9 UUencode and UUdecode functions
The uu module contains the following notice:
Copyright 1994 by Lance Ellinghouse
Cathedral City, California Republic, United States of America.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Lance Ellinghouse
not be used in advertising or publicity pertaining to distribution
of the software without specific, written prior permission.
LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Modified by Jack Jansen, CWI, July 1995:
- Use binascii module to do the actual line-by-line conversion
between ascii and binary. This results in a 1000-fold speedup. The C
version is still 5 times faster, though.
- Arguments more compliant with python standard
A.3.10 XML Remote Procedure Calls
The xmlrpclib module contains the following notice:
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.
78
INDICE REMISSIVO
Symbols
atomo, 37
__abs__() (numeric object method), 30
__add__()
numeric object method, 29
sequence object method, 27
__all__ (optional module attribute), 55
__and__() (numeric object method), 29
__bases__ (class attribute), 18
__builtin__ (built-in module), 57, 65
__builtins__, 57
__call__()
object method, 43
object method, 26
__class__ (instance attribute), 19
__cmp__()
object method, 23
object method, 22
__coerce__()
__complex__() (numeric object method), 30
__contains__()
container object method, 27
mapping object method, 27
__debug__, 50
__del__() (object method), 21
__delattr__() (object method), 23
__delete__() (object method), 24
__delitem__() (container object method), 27
__delslice__() (sequence object method), 28
__dict__
class attribute, 18
function attribute, 16
instance attribute, 19, 23
module attribute, 18
__div__() (numeric object method), 29
__divmod__() (numeric object method), 29
__doc__
class attribute, 18
method attribute, 17
__eq__() (object method), 22
__file__ (module attribute), 18
__float__() (numeric object method), 30
__floordiv__() (numeric object method), 29
__ge__() (object method), 22
__get__() (object method), 24
__getattr__() (object method), 23
__getattribute__() (object method), 24
__getitem__()
__getslice__() (sequence object method), 27
__gt__() (object method), 22
__hash__() (object method), 23
__hex__() (numeric object method), 30
__iadd__()
__iand__() (numeric object method), 29
__idiv__() (numeric object method), 29
__ifloordiv__() (numeric object method), 29
__ilshift__() (numeric object method), 29
__imod__() (numeric object method), 29
__import__() (built-in function), 56
__imul__()
__init__()
object method, 18
object method, 21
__init__.py, 55
__int__() (numeric object method), 30
__invert__() (numeric object method), 30
__ior__() (numeric object method), 29
__ipow__() (numeric object method), 29
__irshift__() (numeric object method), 29
__isub__() (numeric object method), 29
__iter__()
__itruediv__() (numeric object method), 29
__ixor__() (numeric object method), 29
__le__() (object method), 22
__len__()
79
__long__() (numeric object method), 30
__lshift__() (numeric object method), 29
__lt__() (object method), 22
__main__ (built-in module), 34, 65
__metaclass__ (data in ), 26
__mod__() (numeric object method), 29
__module__
class attribute, 18
__mul__()
__name__
class attribute, 18
__ne__() (object method), 22
__neg__() (numeric object method), 30
__new__() (object method), 21
__nonzero__()
object method, 27
object method, 23
__oct__() (numeric object method), 30
__or__() (numeric object method), 29
__pos__() (numeric object method), 30
__pow__() (numeric object method), 29
__radd__()
__rand__() (numeric object method), 29
__rcmp__() (object method), 23
__rdiv__() (numeric object method), 29
__rdivmod__() (numeric object method), 29
__repr__() (object method), 22
__rfloordiv__() (numeric object method), 29
__rlshift__() (numeric object method), 29
__rmod__() (numeric object method), 29
__rmul__()
__ror__() (numeric object method), 29
__rpow__() (numeric object method), 29
__rrshift__() (numeric object method), 29
__rshift__() (numeric object method), 29
__rsub__() (numeric object method), 29
__rtruediv__() (numeric object method), 29
__rxor__() (numeric object method), 29
__set__() (object method), 24
__setattr__()
object method, 23
object method, 23
__setitem__() (container object method), 27
__setslice__() (sequence object method), 28
__slots__ (data in ), 25
__str__() (object method), 22
__sub__() (numeric object method), 29
__truediv__() (numeric object method), 29
__unicode__() (object method), 23
__xor__() (numeric object method), 29
A
abs() (built-in function), 30
addition, 44
an alise l exica, 3
and
bit-wise, 45
and
operator, 47
anonymous
function, 47
append() (sequence object method), 27
argument
function, 16
arithmetic
operation, binary, 44
operation, unary, 43
aritm etica
convers ao, 37
array (standard module), 16
ASCII, 2, 7, 8, 11, 15
aspas
invertidas, 39
assert
statement, 49
AssertionError
exception, 50
assertions
debugging, 49
assignment
attribute, 50, 51
augmented, 51
class attribute, 18
class instance attribute, 19
slicing, 51
statement, 16, 50
subscription, 51
target list, 50
atributo, 14
especial, 14
gen erico especial, 14
refer encia, 40
attribute
assignment, 50, 51
assignment, class, 18
assignment, class instance, 19
class, 18
class instance, 19
deletion, 52
AttributeError
exception, 40
augmented
assignment, 51
80

Indice Remissivo
B
back-quotes, 22, 39
backward
quotes, 22, 39
barra invertida, 4
binary
arithmetic operation, 44
bit-wise operation, 45
binding
global name, 57
name, 33, 50, 55, 62, 63
bit-wise
and, 45
operation, binary, 45
operation, unary, 43
or, 45
xor, 45
blank line, 5
block, 33
code, 33
BNF, 2, 37
Boolean
operation, 46
Booleano
object, 15
break
statement, 54, 6062
bsddb (standard module), 16
built-in
method, 18
module, 55
built-in function
call, 43
object, 17, 43
built-in method
call, 43
object, 18, 43
byte, 15
bytecode, 19
C
C, 8
language, 17, 45
linguagem, 14, 15
call
built-in function, 43
built-in method, 43
class instance, 43
class object, 18, 43
function, 16, 43
instance, 26, 43
method, 43
procedure, 49
user-dened function, 43
callable
object, 16, 41
calls, 41
caractere, 40
chaining
comparisons, 45
character, 15
character set, 15
chave, 39
chr() (built-in function), 15
class
attribute, 18
attribute assignment, 18
constructor, 21
denition, 53, 63
instance, 19
name, 63
object, 18, 43, 63
class
statement, 63
class instance
attribute, 19
attribute assignment, 19
call, 43
object, 18, 19, 43
class object
call, 18, 43
clause, 59
clear() (mapping object method), 27
cmp() (built-in function), 23
co_argcount (code object attribute), 19
co_cellvars (code object attribute), 19
co_code (code object attribute), 19
co_consts (code object attribute), 19
co_filename (code object attribute), 19
co_firstlineno (code object attribute), 19
co_flags (code object attribute), 19
co_freevars (code object attribute), 19
co_lnotab (code object attribute), 19
co_name (code object attribute), 19
co_names (code object attribute), 19
co_nlocals (code object attribute), 19
co_stacksize (code object attribute), 19
co_varnames (code object attribute), 19
code
block, 33
object, 19
code block, 55
coleta de lixo, 13
comma
trailing, 47, 53
command line, 65
comment, 4
comparison, 45
string, 15
comparisons, 23
chaining, 45
compile() (built-in function), 57
complex
literal, 9
complex() (built-in function), 30
complexos
Indice Remissivo 81
numeros, 15
object, 15
compound
statement, 59
compreens oes
lista, 38
constant, 7
constructor
class, 21
cont einer, 14
contagem de refer encia, 13
container, 18
continuac ao de linhas, 4
continue
statement, 54, 6062
convers ao
aritm etica, 37
string, 39
conversion
string, 22, 49
copy() (mapping object method), 27
count() (sequence object method), 27
D
dado
tipo, 14
tipo, imut avel, 38
dados, 13
dangling
else, 59
dbm (standard module), 16
debugging
assertions, 49
decimal literal, 9
DEDENT token, 5, 59
def
statement, 62
default
parameter value, 62
denic oes l exicas, 2
denition
class, 53, 63
function, 53, 62
del
statement, 16, 21, 52
delete, 16
deletion
attribute, 52
target, 52
target list, 52
delimiters, 11
destructor, 21, 51
dicion ario
object, 39, 40
dictionary
display, 39
object, 16, 18, 23, 51
display
dictionary, 39
division, 44
divmod() (built-in function), 29
documentation string, 19
E
EBCDIC, 15
elif
keyword, 60
Ellipsis
object, 14
else
dangling, 59
else
keyword, 54, 60, 61
empty
tuple, 15
encodings, 4
environment, 33
error handling, 34
errors, 34
escape sequence, 8
especial
atributo, 14
atributo, gen erico, 14
estendido
fatiamento, 41
estrutura entre par enteses, 38
eval() (built-in function), 57, 66
evaluation
order, 47
exc_info (in module sys), 20
exc_traceback (in module sys), 20, 61
exc_type (in module sys), 61
exc_value (in module sys), 61
except
keyword, 61
exception, 34, 54
AssertionError, 50
AttributeError, 40
handler, 20
ImportError, 55
NameError, 38
raising, 54
RuntimeError, 53
StopIteration, 53
SyntaxError, 55
TypeError, 43
ValueError, 45
ZeroDivisionError, 44
exception handler, 34
exclusive
or, 45
exec
statement, 57
execfile() (built-in function), 57
execution
frame, 33, 63
82

Indice Remissivo
restricted, 34
stack, 20
execution model, 33
express ao, 37
expression
generator, 39
lambda, 47
list, 47, 49, 50
statement, 49
extend() (sequence object method), 27
extended print statement, 53
extens ao
m odulo, 14
extension
lename, 55
F
f_back (frame attribute), 20
f_builtins (frame attribute), 20
f_code (frame attribute), 20
f_exc_traceback (frame attribute), 20
f_exc_type (frame attribute), 20
f_exc_value (frame attribute), 20
f_globals (frame attribute), 20
f_lasti (frame attribute), 20
f_lineno (frame attribute), 20
f_locals (frame attribute), 20
f_restricted (frame attribute), 20
f_trace (frame attribute), 20
False, 15
fatia, 40
fatiamento, 15, 40
estendido, 41
fatiamento estendido, 15
le
object, 66
lename
extension, 55
finally
keyword, 53, 54, 61
float() (built-in function), 30
oating point literal, 9
for
statement, 54, 60
form
lambda, 47, 63
frame
execution, 33, 63
object, 19
free
variable, 33, 52
from
keyword, 55
statement, 33, 55
func_closure (function attribute), 16
func_code (function attribute), 16
func_defaults (function attribute), 16
func_dict (function attribute), 16
func_doc (function attribute), 16
func_globals (function attribute), 16
function
anonymous, 47
argument, 16
call, 16, 43
call, user-dened, 43
denition, 53, 62
generator, 53
name, 62
object, 16, 17, 43, 62
user-dened, 16
future
statement, 56
G
gdbm (standard module), 16
gen erico
especial atributo, 14
generator
expression, 39
function, 17, 53
iterator, 17, 53
object, 19, 39
generator expression
object, 39
get() (mapping object method), 27
global
name binding, 57
namespace, 16
global
globals() (built-in function), 57
gram atica, 2
grouping, 5
H
handle an exception, 34
handler
exception, 20
has_key() (mapping object method), 27
hash() (built-in function), 23
hash character, 4
hex() (built-in function), 30
hexadecimal literal, 9
hierarchical
module names, 55
hierarquia
tipo, 14
I
id() (built-in function), 13
identidade de um objeto, 13
identier, 6, 37
identity
test, 46
if
statement, 60
Indice Remissivo 83
im_class (method attribute), 17
im_func (method attribute), 17
im_self (method attribute), 17
imaginary literal, 9
import
statement, 18, 55
ImportError
exception, 55
imut avel
dado tipo, 38
object, 15
objeto, 38, 39
in
keyword, 60
operator, 46
inclusive
or, 45
INDENT token, 5
indentation, 5
index() (sequence object method), 27
indices() (slice method), 20
inheritance, 63
initialization
module, 55
input, 66
raw, 66
input() (built-in function), 66
insert() (sequence object method), 27
instance
call, 26, 43
class, 19
object, 18, 19, 43
int() (built-in function), 30
integer, 15
integer literal, 9
inteiro
object, 14
representac ao, 15
inteiro longo
object, 14
inteiro plano
object, 14
interactive mode, 65
internal type, 19
interpreter, 65
inversion, 43
invertidas
aspas, 39
invocation, 16
is
operator, 46
is not
operator, 46
item
seq u encia, 40
string, 40
items() (mapping object method), 27
iteritems() (mapping object method), 27
iterkeys() (mapping object method), 27
itervalues() (mapping object method), 27
J
Java
linguagem, 15
K
keys() (mapping object method), 27
keyword, 7
elif, 60
else, 54, 60, 61
except, 61
finally, 53, 54, 61
from, 55
in, 60
L
lambda
expression, 47
form, 47, 63
language
C, 17, 45
Pascal, 60
last_traceback (in module sys), 20
leading whitespace, 5
len() (built-in function), 15, 16, 27
line structure, 3
linguagem
C, 14, 15
Java, 15
linha fsica, 3, 4
linha l ogica, 3
list
assignment, target, 50
deletion target, 52
expression, 47, 49, 50
object, 16, 51
target, 50, 60
lista
compreens oes, 38
object, 39, 40
representac ao, 38
vazia, 39
literal, 7, 38
locals() (built-in function), 57
long() (built-in function), 30
long integer literal, 9
loop
over mutable sequence, 60
statement, 54, 60
loop control
target, 54
M
m odulo
extens ao, 14
object, 40
84

Indice Remissivo
makefile() (socket method), 19
mapeamento
object, 40
mapping
object, 16, 19, 51
membership
test, 46
method
built-in, 18
call, 43
object, 16, 18, 43
user-dened, 16
minus, 43
modicac ao
nome, 38
module
built-in, 55
importing, 55
initialization, 55
name, 55
names, hierarchical, 55
namespace, 18
object, 18
search path, 55
user-dened, 55
modules (in module sys), 55
modulo, 44
multiplication, 44
mutable
object, 16, 50, 51
mutable sequence
loop over, 60
object, 16
N
name, 6, 33, 37
binding, 33, 50, 55, 62, 63
binding, global, 57
class, 63
function, 62
module, 55
rebinding, 50
unbinding, 52
NameError
exception, 38
NameError (built-in exception), 33
names
hierarchical module, 55
namespace, 33
global, 16
module, 18
negation, 43
newline
suppression, 53
NEWLINE token, 59
nome
modicac ao, 38
nomes
privados, 38
None
object, 49
None, 14
not
operator, 47
not in
operator, 46
notac ao, 2
NotImplemented, 14
null
operation, 52
num erico
object, 14
number, 9
numeric
object, 19
numeric literal, 9
numero
ponto utuante, 15
numeros
complexos, 15
O
object
Booleano, 15
built-in function, 17, 43
built-in method, 18, 43
callable, 16, 41
class, 18, 43, 63
class instance, 18, 19, 43
code, 19
complexos, 15
dicion ario, 39, 40
dictionary, 16, 18, 23, 51
Ellipsis, 14
le, 66
frame, 19
function, 16, 17, 43, 62
generator, 19, 39
generator expression, 39
imut avel, 15
instance, 18, 19, 43
inteiro, 14
inteiro longo, 14
inteiro plano, 14
list, 16, 51
lista, 39, 40
m odulo, 40
mapeamento, 40
mapping, 16, 19, 51
method, 16, 18, 43
module, 18
mutable, 16, 50, 51
mutable sequence, 16
None, 49
num erico, 14
numeric, 19
Indice Remissivo 85
ponto utuante, 15
recursivo, 40
seq u encia, 15, 40
seq u encia imut avel, 15
sequence, 19, 46, 51, 60
slice, 27
string, 15, 40
traceback, 20, 54, 61
tupla, 40
tuple, 15, 47
unicode, 15
user-dened function, 16, 43, 62
user-dened method, 16
objeto, 13
imut avel, 38, 39
objeto imut avel, 13
objeto mut avel, 13
objetos inacessveis, 13
oct() (built-in function), 30
octal literal, 9
open() (built-in function), 19
operac ao de ndice, 15
operation
binary arithmetic, 44
binary bit-wise, 45
Boolean, 46
null, 52
shifting, 44
unary arithmetic, 43
unary bit-wise, 43
operator
and, 47
in, 46
is, 46
is not, 46
not, 47
not in, 46
or, 47
overloading, 21
precedence, 48
operators, 10
or
bit-wise, 45
exclusive, 45
inclusive, 45
or
operator, 47
ord() (built-in function), 15
order
evaluation, 47
output, 49, 53
standard, 49, 53
OverflowError (excec ao interna), 14
overloading
operator, 21
P
packages, 55
par chave/valor, 39
parameter
value, default, 62
parser, 3
Pascal
language, 60
pass
statement, 52
path
module search, 55
physical line, 8
plain integer literal, 9
plus, 43
ponto utuante
numero, 15
object, 15
pop()
popen() (in module os), 19
popitem() (mapping object method), 27
pow() (built-in function), 29
precedence
operator, 48
prim aria, 40
print
statement, 22, 52
privados
nomes, 38
procedure
call, 49
program, 65
Python Enhancement Proposals
PEP 0255, 54
Q
quotes
backward, 22, 39
reverse, 22
R
raise
statement, 54
raise an exception, 34
raising
exception, 54
range() (built-in function), 60
raw input, 66
raw string, 8
raw_input() (built-in function), 66
readline() (le method), 66
rebinding
name, 50
recursivo
object, 40
refer encia
atributo, 40
remove() (sequence object method), 27
86

Indice Remissivo
repr() (built-in function), 22, 40, 49
representac ao
inteiro, 15
lista, 38
tupla, 38
reserved word, 7
restricted
execution, 34
retorna tem, 15
return
reverse
quotes, 22
reverse() (sequence object method), 27
RuntimeError
exception, 53
S
scope, 33
search
path, module, 55
seq u encia
item, 40
object, 15, 40
seq u encia imut avel
object, 15
sequence
object, 19, 46, 51, 60
setdefault() (mapping object method), 27
shifting
operation, 44
simple
statement, 49
singleton
tuple, 15
sintaxe, 2, 37
slice
object, 27
slice() (built-in function), 20
slicing, 16
assignment, 51
sort() (sequence object method), 27
source character set, 4
space, 5
stack
execution, 20
trace, 20
standard
output, 49, 53
Standard C, 8
standard input, 65
start (slice object attribute), 20, 41
statement
assert, 49
assignment, 16, 50
assignment, augmented, 51
break, 54, 6062
class, 63
compound, 59
continue, 54, 6062
def, 62
del, 16, 21, 52
exec, 57
expression, 49
for, 54, 60
from, 33, 55
future, 56
global, 50, 52, 57
if, 60
import, 18, 55
loop, 54, 60
pass, 52
print, 22, 52
raise, 54
return, 53, 61, 62
simple, 49
try, 20, 61
while, 54, 60
yield, 53
statement grouping, 5
stderr (in module sys), 19
stdin (in module sys), 19
stdout (in module sys), 19, 53
step (slice object attribute), 20, 41
stop (slice object attribute), 20, 41
StopIteration
exception, 53
str() (built-in function), 22, 40
string
comparison, 15
convers ao, 39
conversion, 22, 49
item, 40
object, 15, 40
Unicode, 8
string literal, 7
subscric ao, 15, 40
subscription, 16
assignment, 51
subtraction, 44
suite, 59
suppression
newline, 53
SyntaxError
exception, 55
sys (built-in module), 53, 55, 61, 65
sys.exc_info, 20
sys.exc_traceback, 20
sys.last_traceback, 20
sys.modules, 55
sys.stderr, 19
sys.stdin, 19
sys.stdout, 19
SystemExit (built-in exception), 35
Indice Remissivo 87
T
tab, 5
target, 50
deletion, 52
list, 50, 60
list assignment, 50
list, deletion, 52
loop control, 54
tb_frame (traceback attribute), 20
tb_lasti (traceback attribute), 20
tb_lineno (traceback attribute), 20
tb_next (traceback attribute), 20
termination model, 34
test
identity, 46
membership, 46
tipo, 14
dado, 14
hierarquia, 14
imut avel dado, 38
tipo de um objeto, 13
token, 3
token NEWLINE, 3
trace
stack, 20
traceback
object, 20, 54, 61
trailing
comma, 47, 53
triple-quoted string, 8
True, 15
try
statement, 20, 61
tupla
object, 40
representac ao, 38
vazia, 38
tuple
empty, 15
object, 15, 47
singleton, 15
type() (built-in function), 13
TypeError
exception, 43
types, internal, 19
U
unary
arithmetic operation, 43
bit-wise operation, 43
unbinding
name, 52
UnboundLocalError, 33
uni ao de linhas, 3, 4
unichr() (built-in function), 15
Unicode, 15
unicode
object, 15
unicode() (built-in function), 15, 23
Unicode Consortium, 8
UNIX, 65
unrecognized escape sequence, 8
update() (mapping object method), 27
user-dened
function, 16
function call, 43
method, 16
module, 55
user-dened function
object, 16, 43, 62
user-dened method
object, 16
V
vrgula, 38
valor, 39
valor de um objeto, 13
value
default parameter, 62
ValueError
exception, 45
values
writing, 49, 53
values() (mapping object method), 27
variable
free, 33, 52
vazia
lista, 39
tupla, 38
W
while
statement, 54, 60
whitespace, 5
writing
values, 49, 53
X
xor
bit-wise, 45
Y
yield
statement, 53
Z
ZeroDivisionError
exception, 44
88

Indice Remissivo

Python

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Python

Enviado por

Direitos autorais:

Formatos disponíveis

Manual de Refer encia Python

Você também pode gostar