<div class="titlepage">
<div class='center'>
<p><b>Guido van Rossum</b></p>
<p>Python Software Foundation<br />
Email: <span class="email">docs@python.org</span> <strong>Python Brasil</strong><br />
<a class="url" href="http://pythonbrasil.com.br">http://pythonbrasil.com.br</a></p>
<p><i>Fred L. Drake, Jr., editor</i></p>
<p><strong>Release 2.4.2</strong><br />
<strong>23. Fevereiro 2008</strong></p>
<p>Tradução: Python Brasil</p>
</div>
</div>
<h1> Front Matter</h1>
<p>Copyright © 2001-2004 Python Software Foundation. All rights reserved.</p>
<p>Copyright © 2000 BeOpen.com. All rights reserved.</p>
<p>Copyright © 1995-2000 Corporation for National Research Initiatives. All rights reserved.</p>
<p>Copyright © 1991-1995 Stichting Mathematisch Centrum. All rights reserved.</p>
<p>Tradução: Pedro Werneck, Osvaldo Santana Neto, José Alexandre Nalon, Felipe Lessa, Pedro de
Medeiros, Rafael Almeida, Renata Palazzo, Rodrigo Senra e outros.</p>
<p>Revisão: Pedro Werneck, Osvaldo Santana Neto, Pedro de Medeiros.</p>
<p>Veja a parte final deste documento para informações mais completas sobre licenças e
permissões.</p>
<h3>Resumo:</h3>
<div class="ABSTRACT">
<p>Python é uma linguagem de programação poderosa e de fácil aprendizado. Ela possui estruturas
de dados de alto-nível eficientes, bem como adota uma abordagem simples e efetiva para a programação
orientada a objetos. Sua sintaxe elegante e tipagem dinâmica, em adição à sua natureza
interpretada, tornam Python ideal para scripting e para o desenvolvimento rápido de aplicações em
diversas áreas e na maioria das plataformas.</p>
<p>O interpretador de Python e sua extensa biblioteca padrão estão disponíveis na forma de
código fonte ou binário para a maioria das plataformas a partir do site, <a class="url" href=
"http://www.python.org/">http://www.python.org/</a>, e deve ser distribuídos livremente. No mesmo sítio
estão disponíveis distribuições e referências para diversos módulos, programas,
ferramentas e documentação adicional contribuídos por terceiros.</p>
<p>O interpretador de Python é facilmente extensível incorporando novas funções e tipos de
dados implementados em C ou C++ (ou qualquer outra linguagem acessível a partir de C). Python também se
adequa como linguagem de extensão para customizar aplicações.</p>
<p>Este tutorial introduz o leitor informalmente aos conceitos básicos e aspectos do sistema e linguagem
Python. É aconselhável ter um interpretador Python disponível para se poder ``por a mão na
massa'', porém todos os exemplos são auto-contidos, assim o tutorial também pode ser lido sem que
haja a necessidade de se estar on-line.</p>
<p>Para uma descrição dos módulos e objetos padrão, veja o documento <em class=
"citetitle"><a href="../lib/lib.html" title="Referência da Biblioteca Python">Referência da Biblioteca
Python</a></em>. O <em class="citetitle"><a href="../ref/ref.html" title="Manual de Referência Python">Manual
de Referência Python</a></em> oferece uma definição formal da linguagem. Para se escrever
extensões em C ou C++, leia <em class="citetitle"><a href="../ext/ext.html" title=
"Extendendo e Embutindo o Interpretador Python">Extendendo e Embutindo o Interpretador Python</a></em> e <em class=
"citetitle"><a href="../api/api.html" title="Manual de Referência da API Python/C">Manual de Referência
da API Python/C</a></em>. Existem também diversos livros abordando Python em maior profundidade.</p>
<p>Este tutorial não almeja ser abrangente ou abordar todos os aspectos, nem mesmo todos os mais frequentes.
Ao invés disso, ele introduz muitas das características dignas de nota em Python, e fornecerá a
você uma boa idéia sobre o estilo e o sabor da linguagem. Após a leitura, você deve ser capaz
de ler e escrever programas e módulos em Python, e estará pronto para aprender mais sobre os diversos
módulos de biblioteca descritos na <em class="citetitle"><a href="../lib/lib.html" title=
"Referência da Biblioteca Python">Referência da Biblioteca Python</a></em></p>
<p>A tradução original do tutorial da versão 2.1 foi patrocinada pela GPr Sistemas Ltda
(http://www.gpr.com.br).</p>
<p>A atualização do tutorial para esta versão foi realizada por voluntários do projeto
PythonDoc-Brasil. (http://www.pythonbrasil.com.br/moin.cgi/PythonDoc)</p>
</div>
<h1> 1. Abrindo o Apetite</h1>Se alguma vez você já escreveu um extenso script de shell, provavelmente se sentiu
assim: você adoraria adicionar mais uma característica, mas já está tão lento, e tão
grande, e tão complicado; ou a nova característica implica numa chamada de sistema ou função
só acessível a partir do C... Tipicamente o problema em questão não é sério o
suficiente para motivar a re-escrita do script em C; talvez o problema exija cadeias de caracteres de comprimento
variável ou tipos (como listas ordenadas de nomes de arquivos) que são fácilmente manipuláveis na
shell, porém demandam muito esforço de implementação em C, ou talvez você nem esteja
suficientemente familiarizado com C.
<p>Outra situação: suponha que você tenha que trabalhar com diversas bibiotecas em C, e o típico
ciclo escreve/compila/testa/re-compila seja muito lento. Você precisa desenvolver software de uma forma mais
ágil. Ou, suponha que você escreveu um programa que precise fazer uso de uma linguagem de extensão, e
você não quer projetar a linguagem, implementar e depurar um interpretador para ela, para só
então estabelecer o vínculo com sua aplicação original.</p>
<p>Nestes casos, Python possivelmente é exatamente do que você está precisando. Python é simples
de usar, sem deixar de ser uma linguagem de programação de verdade, oferecendo muito mais
estruturação e suporte para programas extensos do que shell scripts oferecem. Por outro lado, Python
também oferece melhor verificação de erros do que C, e por ser uma <em>linguagem de alto
nível</em>, ela possui tipos nativos de alto nível: dicionários e vetores (<em>arrays</em>)
flexíveis que lhe custariam dias para obter uma implementação eficiente em C. Devido ao suporte nativo
a tipos genéricos, Python é aplicável a um domínio de problemas muito mais vasto do que
<em>Awk</em> ou até mesmo <em>Perl</em>, ainda assim Python é tão fácil de usar quanto essas
linguagens sob diversos aspectos.</p>
<p>Python permite que você organize seu programa em módulos que podem ser reutilizados em outros programas
escritos em Python. A linguagem provê uma vasta coleção de módulos que podem ser utilizados como
base para sua aplicação -- ou como exemplos para estudo e aprofundamento. Alguns desses módulos
implementam manipulação de arquivos, chamadas do sistema, sockets, e até mesmo acesso a bibiotecas de
construção de interfaces gráficas, como Tk.</p>
<p>Python é uma linguagem interpretada, que pode fazer com que você economize um tempo considerável,
uma vez que não há necessidade de compilação e vinculação(<em>linking</em>) durante o
desenvolvimento. O interpretador pode ser usado interativamente, o que torna fácil experimentar diversas
características da linguagem, escrever programas ``descartáveis'', ou testar funções em um
desenvolvimento <em>bottom-up</em>. É também uma útil calculadora de mesa.</p>
<p>Python permite a escrita de programas compactos e legíveis. Programas escritos em Python são tipicamente
mais curtos do que seus equivalentes em C ou C++, por diversas razões:</p>
<ul>
<li>os tipos de alto-nível permitem que você expresse operações complexas em uma único
comando (<em>statement</em>);</li>
<li>a definição de bloco é feita por identação ao invés de marcadores de início
e fim de bloco;</li>
<li>não há necessidade de declaração de variáveis ou parâmetros formais;</li>
</ul>
<p>Python é extensível: se você sabe como programar em C, é fácil adicionar
funções ou módulos diretamente no interpretador, seja para desempenhar operações
críticas em máxima velocidade, ou para vincular programas Python a bibliotecas que só estejam
disponívies em formato binário (como uma bibloteca gráfica de terceiros). Uma vez que você tenha
sido fisgado, você pode vincular o interpretador Python a uma aplicação escrita em C e utilizá-la
como linguagem de comandos ou extensão para esta aplicação.</p>
<p>A propósito, a linguagem foi batizada a partir do famoso show da BBC ``Monty Python's Flying Circus'' e
não tem nada a ver com repulsivos répteis. Fazer referências à citações do show na
documentação não é só permitido, como também é encorajado!</p>
<p>Agora que você está entusiasmado com Python, vai desejar examiná-la com maior detalhe. Partindo do
princípio que a melhor maneira de aprender uma linguagem é usando-a, você está agora convidado a
fazê-lo com este tutorial.</p>
<p>No próximo capítulo, a mecânica de utilização do interpretador é explicada. Essa
informação, ainda que mundana, é essencial para a experimentação dos exemplos apresentados
mais tarde.</p>
<p>O resto do tutorial introduz diversos aspectos do sistema e linguagem Python por intermédio de exemplos.
Serão abordadas expressões simples, comandos, tipos, funções e módulos. Finalmente,
serão explicados alguns conceitos avançados como exceções e classes definidas pelo
usuário.</p>
<h1> 2. Utilizando o Interpretador Python</h1>
<h1> 2.1 Disparando o Interpretador</h1>
<p>O interpretador é freqüentemente instalado como <span class="file">/usr/local/bin/python</span> nas
máquinas em que é disponibilizado; adicionando <span class="file">/usr/local/bin</span> ao caminho de busca
(<em>search path</em>) da shell de seu <span class="Unix">Unix</span> torna-se possível iniciá-lo
digitando:</p>
<div class="verbatim">
<pre>
python
</pre>
</div>
<p>na shell. Considerando que a escolha do diretório de instalação é uma opção de
instalação, outras localizações são possíveis; verifique com seu guru local de Python
ou com o administrador do sistema. (Ex., <span class="file">/usr/local/python</span> é uma alternativa popular
para instalação.)</p>
<p>Em computadores com Windows, Python é instalado geralmente em <span class="file">C:\Python24</span>, apesar
de você poder mudar isso enquanto está executando o instalador. Para adicionar esse diretório ao
<em>path</em>, você pode digitar o seguinte comando no DOS:</p>
<div class="verbatim">
<pre>
set path=%path%;C:\python24
</pre>
</div>
<p>Digitando um caracter EOF() (<kbd>Control-D</kbd> on <span class="Unix">Unix</span>, <kbd>Control-Z</kbd> no
Windows) diretamente no prompt força o interpretador a sair com status de saída zero. Se isso não
funcionar, voce pode sair do interpretador através da digitação do seguinte: "<tt class="samp">import
sys; sys.exit()</tt>".</p>
<p>As características de edição de linha não são muito sofisticadas. Sobre <span class=
"Unix">Unix</span>, seja lá quem for que tenha instalado o interpretador talvez tenha habilitado o suporte
à biblioteca readline da GNU, que adiciona facilidades mais elaboradas de edição e histórico de
comandos. Teclar <kbd>Control-P</kbd> no primeiro prompt oferecido pelo Python é, provavelmente, a maneira mais
rápida de verificar se a edição de linha de comando ée suportada. Se houver um beep, você
possui edição de linha de comando; veja o Apêndice <a href="#interacting">A</a> para uma
introdução as teclas especiais. Se nada acontecer, ou se <code>P</code> aparecer na tela, a opção
de edição não está disponível; você apenas será capaz de usar o <em>backspace</em>
para remover caracteres da linha corrente.</p>
<p>O interpretador trabalha de forma semelhante a uma shell de <span class="Unix">Unix</span>: quando disparado com a
saída padrão conectadaa um console de terminal (tty device), ele lê e executa comandos
interativamente; quando disparado com um nome de arquivo como parâmetro ou com redirecionamento da entrada
padrão para um arquivo, o interpretador irá ler e executar o <em>script</em> contido em tal arquivo.</p>
<p>Uma segunda forma de disparar o interpretador é "<tt class="samp"><b class="program">python</b> <b class=
"programopt">-c</b> <var>command</var> [arg] ...</tt>", que executa o(s) comando(s) especificados na
posição command, analogamente à opção de shell <b class="programopt">-c</b>. Considerando
que comandos Python possuem freqüentemente espaços em branco (ou outros caracteres que sejam especiais para
a shell) é aconselhável que o comando especificado em <var>command</var> esteja dentro de aspas duplas.</p>
<p>Alguns módulos Python são também úteis como scripts. Estes podem ser chamados usando
"<tt class="samp"><b class="program">python</b> <b class="programopt">-m</b> <var>module</var> [arg] ...</tt>", que
executa o arquivo fonte para <var>module</var> como se você tivesse digitado seu caminho completo na linha de
comando.</p>
<p>Observe que há uma diferença entre "<tt class="samp">python file</tt>" e "<tt class="samp">python
<file</tt>". No último caso, chamadas do tipo <tt class="function">input()</tt> e <tt class=
"function">raw_input()</tt> serão satisfeitas a partir de <em>file</em>. Uma vez que file já foi
inteiramente lido antes de que o script Python entrasse em execução, o programa encontrará o fim de
arquivo (EOF) imediatamente. Já no primeiro caso, que é o mais frequente (provavelmente o que você
quer), a entrada de dados será fornecida pelo dispositivo vinculado à entrada padrão do
interpretador.</p>
<p>Quando um arquivo de script é utilizado, as vezes é útil ser capaz de executá-lo para logo em
seguida entrar em modo interativo. Este efeito pode ser obtido pela adição do parâmetro -<b class=
"programopt">i</b> antes do nome do script. (Observe que isto não irá funcionar se o script for lido a
partir da entrada padrão, pelas mesmas razões explicadas no parágrafo anterior.)</p>
<h2> 2.1.1 Passagem de Argumentos</h2>
<p>Quando são de conhecimento do interpretador, o nome do script e subseqüentes parâmetros da linha de
comando da shell são acessíveis ao próprio script através da variável <code>sys.argv</code>,
que é uma lista de strings. Essa lista tem sempre ao menos um elemento; quando nenhum script ou parâmetro
forem passados para o interpretador, <code>sys.argv[0]</code> será uma lista vazia. Quando o nome do script for
<code>'-'</code> (significando entrada padrão), o conteúdo de <code>sys.argv[0]</code> será
<code>'-'</code>. Quando for utilizado <b class="programopt">-c</b> <var>command</var>, <code>sys.argv[0]</code>
conterá <code>'-c'</code>. Quando for utilizado <b class="programopt">-m</b> <var>module</var>,
<code>sys.argv[0]</code> conterá o caminho completo do módulo localizado. Opções especificadas
após <b class="programopt">-c</b> <var>command</var> não serão consumidas pelo interpretador mas
armazenadas em <code>sys.argv</code>.</p>
<h2> 2.1.2 Modo Interativo</h2>
<p>Quando os comandos são lidos a partir do console (<em>tty</em>), diz-se que o interpretador está em
<em>modo interativo</em>. Nesse modo ele requisita por um próximo comando através do <em>prompt
primário</em>, tipicamente três sinais de maior-que ("<tt class=
"samp">><code>></code>> </tt>"); para linhas de continuação do comando corrente, o <em>prompt
secundário</em> default são três pontos ("<tt class="samp">... </tt>"). O interpretador imprime
uma mensagem de boas vindas, informando seu número de versão e uma nota legal de copyright antes de
oferecer o primeiro prompt:</p>
<div class="verbatim">
<pre>
python
Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06) [GCC 2.8.1] on sunos5
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>>
</pre>
</div>
<p>Linhas de continuação são necessárias em construções multi-linha. Como exemplo,
dê uma olhada nesse comando <tt class="keyword">if</tt>:</p>
<div class="verbatim">
<pre>
>>> o_mundo_eh_plano = 1
>>> if o_mundo_eh_plano:
... print "Cuidado para não cair fora dele!"
...
Cuidado para não cair fora dele!
</pre>
</div>
<h1> 2.2 O Interpretador e seu Ambiente</h1>
<h2> 2.2.1 Tratamento de Erros</h2>
<p>Quando ocorre um erro, o interpretador imprime uma mensagem de erro e a situação da pilha (daqui em
diante <em>stack trace</em>). No modo interativo, retorna-se ao prompt primário; quando a entrada vem de um
arquivo, o interpretador aborta sua execução com status de erro diferente de zero após imprimir o
<em>stack trace</em> (Exceções tratadas por um <tt class="keyword">except</tt> num bloco <tt class=
"keyword">try</tt> não são consideradas erros neste contexto). Alguns erros são incondicionalmente
fatais e causam a saída com status diferente de zero; isto se aplica a inconsistências internas e alguns
casos de exaustão de memória. Todas as mensagens de erro são escritas na saída de erros
padrão (<em>standard error</em>), enquanto a saída dos demais comandos é direcionada para a saída
padrão.</p>
<p>Teclando o caracter de interrupção (tipicamente Control-C ou DEL) no prompt primário ou
secundário cancela a entrada de dados corrente e retorna-se ao prompt primário. <a name="tex2html1" href=
"#foot143"><sup>2.1</sup></a> Provocando uma interrupção enquanto um comando está em
execução levanta a exceção <tt class="exception">KeyboardInterrupt</tt>, a qual pode ser tratada
em um bloco <tt class="keyword">try</tt>.</p>
<h2> 2.2.2 Scripts Executáveis em Python</h2>
<p>Em sistemas <span class="Unix">Unix</span>BSD, scripts Python podem ser transformados em executáveis, como
shell scripts, pela inclusão do cabeçalho</p>
<div class="verbatim">
<pre>
#! /usr/bin/env python
</pre>
</div>
<p>(Assumindo que o interpretador foi incluído do caminho de busca do usuário (<a class="envvar" id='l2h-1'
xml:id='l2h-1'>PATH</a>)) e que o script tenha a permissão de acesso habilitada para execução. O
"<tt class="samp">#!</tt>" deve estar no início do arquivo .Em algumas plataformas esta linha inicial deve ser
finalizada no estilo <span class="Unix">Unix</span>-style com ("<tt class="character">\n</tt>"), ao invés do
estlo Mac OS ("<tt class="character">\r</tt>") ou mesmo a terminação típica do Windows ("<tt class=
"character">\r\n</tt>"). Observe que o caracter "<tt class="character">#</tt>" designa comentários em
Python.</p>
<p>Para atribuir permissão de execução (plataforma Unix) ao seu script Python, utilize o comando
<b class="program">chmod</b>:</p>
<div class="verbatim">
<pre>
$ chmod +x meuscript.py
</pre>
</div>
<h2><a name="SECTION004230000000000000000">2.2.3 Codificação em Arquivos de Código-fonte</a></h2>
<p>É possível usar codificação diferente de ASCII() em arquivos de código Python. A melhor
maneira de fazê-lo é através de um comentário adicional logo após a linha
<code>#!</code>:</p>
<div class="verbatim">
<pre>
<tt>
# -*- coding: <var>encoding</var> -*-
</tt>
</pre>
</div>
<p>Com essa declaração, todos os caracteres no código-fonte serão tratados como
<var>encoding</var>, mas será possível escrever strings Unicode diretamente. A lista de
codificações possíveis pode ser encontrada na <em class="citetitle"><a href="../lib/lib.html" title=
"Referência da Biblioteca Python">Referência da Biblioteca Python</a></em>, na seção <a class=
"ulink" href="../lib/module-codecs.html"><tt class="module">codecs</tt></a>.</p>
<p>Por exemplo, para escrever strings unicode incluindo o símbolo monetário para o Euro, ISO-8859-15 pode
ser usado, com o símbolo tendo o valor 164. Este script exibirá o valor 8364 (Unicode correspondente ao
símbolo do Euro) e retornar:</p>
<div class="verbatim">
<pre>
<tt>
# -*- coding: iso-8859-15 -*-
currency = u"€"
print ord(currency)
</tt>
</pre>
</div>
<p>Se o seu editor é capaz de salvar arquivos <code>UTF-8</code> com um <em>byte order mark</em> (conhecido como
BOM), você pode usá-lo ao invés da declaração de codificação. O IDLE é capaz
de fazer isto se <code>Options/General/Default Source Encoding/UTF-8</code> estiver habilitado. Note que esta
assinatura não é reconhecida por versões antigas (Python 2.2 e anteriores), e pelo sistema operacional
para arquivos com a declaração <code>#!</code> (usada somente em sistemas <span class=
"Unix">Unix</span>).</p>
<p>Usando UTF-8 (seja através da assinatura ou de uma declaração de codificação), caracteres
da maioria das línguas do mundo podem ser usados simultaneamente em strings e comentários. Não é
possível usar caracteres não-ASCII em identificadores. Para exibir todos esses caracteres adequadamente,
seu editor deve reconhecer que o arquivo é UTF-8, e deve usar uma fonte que tenha todos os caracteres usados no
arquivo.</p>
<h2> 2.2.4 O Arquivo de Inicialização para Modo Interativo</h2>
<p>Quando você for utilizar Python interativamente, pode ser útil adicionar uma série de comandos a
serem executados por default antes de cada sessão de utilização do interpretador. Isto pode ser obtido
pela configuração da variável de ambiente <a class="envvar" id='l2h-2' xml:id=
'l2h-2'>PYTHONSTARTUP</a> para indicar o nome do arquivo script que contém o script de inicialização.
Essa característica assemelha-se aos arquivos <span class="file">.profile</span> de shells <span class=
"Unix">Unix</span>.</p>
<p>O arquivo só é processado em sessões interativas, nunca quando Python lê comandos de um script
especificado como parâmetro, nem tampouco quando <span class="file">/dev/tty</span> é especificado como a
fonte de leitura de comandos (caso contrário se comportaria como uma sessão interativa). O script de
inicialização é executado no mesmo contexto (doravante <em>namespace</em>) em que os comandos da
sessão interativa serão executados, sendo assim, os objetos definidos e módulos importados podem ser
utilizados sem qualificação durante a sessão interativa. É possível também redefinir os
prompts <code>sys.ps1</code> e <code>sys.ps2</code> através deste arquivo.</p>
<p>Se for necessário ler um script adicional de inicialização a partir do diretório corrente,
você pode programar isso a partir do script de inicialização global, por exemplo "<tt class="samp">if
os.path.isfile('.pythonrc.py'): execfile('.pythonrc.py')</tt>". Se você deseja utilizar o script de
inicialização em outro script, você deve fazê-lo explicitamente da seguinte forma:</p>
<div class="verbatim">
<pre>
import os
filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
execfile(filename)
</pre>
</div>
<h1> 3. Uma Introdução Informal a Python</h1>
<p>Nos exemplos seguintes, pode-se distinguir a entrada da saída pela presença ou ausência dos prompts
("<tt class="samp">><code>></code>> </tt>" and "<tt class="samp">... </tt>"): para repetir o
exemplo, você deve digitar tudo após o prompt, quando o mesmo aparece; linhas que não começarem
com o prompt são na verdade as saídas geradas pelo interpretador.</p>
<p>Observe que existe um segundo prompt indicando a linha de continuação de um comando com múltiplas
linhas, o qual pode ser encerrado pela digitação de um linha em branco.</p>
<p>Muitos dos exemplos neste manual, até mesmo aqueles digitados interativamente, incluem comentários.
Comentários em Python são delimitados pelo caracter "<tt class="character">#</tt>", e se extendem até
o final da linha. Um comentário pode aparecer no início da linha, depois de um espaço em branco ou
código, mas nunca dentro de uma string (literal). O delimitar de comentário dentro de uma string é
interpretado como o próprio caracter.</p>
<p>Alguns exemplos:</p>
<div class="verbatim">
<pre>
# primeiro comentário
SPAM = 1 # e esse é o segundo comentário
# ... e ainda um terceiro !
STRING = "# Este não é um comentário."
</pre>
</div>
<h1> 3.1 Utilizando Python Como Uma Calculadora</h1>
<p>Vamos tentar alguns comandos simples em Python. Inicie o interpretador e aguarde o prompt primário,
"<tt class="samp">><code>></code>> </tt>". (Não deve demorar muito.)</p>
<h2> 3.1.1 Números</h2>
<p>O interpretador atua como uma calculadora bem simples: você pode digitar uma expressão e o valor
resultando será apresentado após a avaliação da expressão. A sintaxe da expressão
é a usual: operadores <code>+</code>, <code>-</code>, <code>*</code> e <code>/</code> funcionam da mesma forma
que em outras linguagens tradicionais (por exemplo, Pascal ou C); parênteses podem ser usados para definir
agrupamentos. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> 2+2
4
>>> # Isso é um comentário
... 2+2
4
>>> 2+2 # e um comentário na mesma linha de um comando
4
>>> (50-5*6)/4
5
>>> # Divisão inteira retorna com aredondamento para base
... 7/3
2
>>> 7/-3
-3
</pre>
</div>
<p>O sinal de igual ("<tt class="character">=</tt>") é utilizado para atribuição de um valor a uma
variável. Nenhum resultado é exibido até o próximo <em>prompt</em> interativo:</p>
<div class="verbatim">
<pre>
>>> width = 20
>>> height = 5*9
>>> width * height
900
</pre>
</div>
<p>Um valor pode ser atribuído a diversas variáveis simultaneamente:</p>
<div class="verbatim">
<pre>
>>> x = y = z = 0 # Zero x, y e z
>>> x
0
>>> y
0
>>> z
0
</pre>
</div>
<p>Há total suporte para ponto-flutuante; operadores com operandos de diferentes tipos convertem o inteiro para
ponto-flutuante:</p>
<div class="verbatim">
<pre>
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5
</pre>
</div>
<p>Números complexos também são suportados; números imaginários são escritos com o
sufixo "<tt class="samp">j</tt>" ou "<tt class="samp">J</tt>". Números complexos com parte real não nula
são escritos como "<tt class="samp">(<var>real</var>+<var>imag</var>j)</tt>", ou podem ser criados pela chamada
de função "<tt class="samp">complex(<var>real</var>, <var>imag</var>)</tt>".</p>
<div class="verbatim">
<pre>
>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)
</pre>
</div>
<p>Números complexos são sempre representados por dois números ponto-flutuante, a parte real e a parte
imaginária. Para extrair as partes de um número <var>z</var>, utilize <code><var>z</var>.real</code> e
<code><var>z</var>.imag</code>.</p>
<div class="verbatim">
<pre>
>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5
</pre>
</div>
<p>As funções de conversão para ponto-flutuante e inteiro (<tt class="function">float()</tt>,
<tt class="function">int()</tt> e <tt class="function">long()</tt>) não funcionam para números complexos --
não existe maneira correta de converter um número complexo para um número real. Utilize
<code>abs(<var>z</var>)</code> para obter sua magnitude (como ponto-flutuante) ou <code>z.real</code> para obter sua
parte real.</p>
<div class="verbatim">
<pre>
>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)
5.0
</pre>
</div>
<p>No modo interativo, a última expressão a ser impressa é atribuída a variável
<code>_</code>. Isso significa que ao utilizar Python como uma calculadora, é muitas vezes mais fácil
prosseguir com os cálculos da seguinte forma:</p>
<div class="verbatim">
<pre>
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
</pre>
</div>
<p>Essa variável especial deve ser tratada somente para leitura pelo usuário. Nunca lhe atribua
explicitamente um valor - do contrário, estaria se criando uma outra variável (homônima) independente,
que mascararia o comportamento mágico da variável especial.</p>
<h2> 3.1.2 Strings</h2>
<p>Além de números, Python também pode manipular strings, que podem ser expressas de diversas formas.
Elas podem ser delimitadas pos aspas simples ou duplas:</p>
<div class="verbatim">
<pre>
>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
</pre>
</div>
<p>Strings que contém mais de uma linha podem ser construídas de diversas maneiras. Terminadores de linha
podem ser embutidos na string com barras invertidas, ex.:</p>
<div class="verbatim">
<pre>
oi = "Esta eh uma string longa contendo\n\
diversas linhas de texto assim como voce faria em C.\n\
Observe que os espaços em branco no inicio da linha são \
significativos."
print oi
</pre>
</div>
<p>Observe que terminadores de linha ainda precisam ser embutidos na string usando <code>\n</code>; a quebra de linha
após a última barra de escape seria ignorada. Este exemplo produziria o seguinte resultado:</p>
<div class="verbatim">
<pre>
Esta eh uma string longa contendo
diversas linhas de texto assim como voce faria em C.
Observe que os espaços em branco no inicio da linha são significativos.
</pre>
</div>
<p>No entanto, se a tornarmos uma string ``crua'' (<em>raw</em>), as sequências de <code>\n</code> não
são convertidas para quebras de linha. Tanto a barra invertida quanto a quebra de linha no código-fonte
são incluídos na string como dados. Portanto, o exemplo:</p>
<div class="verbatim">
<pre>
oi = r"Esta eh uma string longa contendo\n\
diversas linhas de texto assim como voce faria em C.\n\
Observe que os espaços em branco no inicio da linha são \
significativos."
print oi
</pre>
</div>
<p>teria como resultado:</p>
<div class="verbatim">
<pre>
Esta eh uma string longa contendo\n\
diversas linhas de texto assim como voce faria em C.\n\
Observe que os espaços em branco no inicio da linha são \
significativos
</pre>
</div>
<p>Ou, strings podem ser delimitadas por pares de aspas tríplices: <code>"</code> ou <code>'''</code>. Neste
caso não é necessário embutir terminadores de linha, pois o texto da string será tratado
verbatim.</p>
<div class="verbatim">
<pre>
print """
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
"""
</pre>
</div>
<p>produz a seguinte saída:</p>
<div class="verbatim">
<pre>
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
</pre>
</div>
<p>O interpretador imprime o resultado de operações sobre strings da mesma forma que as strings são
formatadas na digitação: dentro de aspas, e com caracteres especiais embutidos em <em>escape
sequences</em>, para mostar seu valor com precisão. A string será delimitada por aspas duplas se ela
contém um único caracter de aspas simples e nenhum de aspas duplas, caso contrário a string será
delimitada por aspas simples. ( O comando <tt class="keyword">print</tt>, descrito posteriormente, pode ser utilizado
para escrever strings sem aspas ou <em>escape sequences</em>.)</p>
<p>Strings podem ser concatenadas (coladas) com o operador <code>+</code>, e repetidas com <code>*</code>:</p>
<div class="verbatim">
<pre>
>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'
</pre>
</div>
<p>Duas strings literais justapostas são automaticamente concatenadas; a primeira linha do exemplo anterior
poderia ter sido escrita como "<tt class="samp">word = 'Help''A'</tt>"; isso funciona somente com strings literais,
não com expressões arbitrárias:</p>
<div class="verbatim">
<pre>
>>> 'str' 'ing' # <- This is ok
'string'
>>> str.strip('str') + 'ing' # <- This is ok
'string'
>>> str.strip('str') 'ing' # <- This is invalid
File "<stdin>", line 1
str.strip('str') 'ing'
^
SyntaxError: invalid syntax
</pre>
</div>
<p>Strings podem ser indexadas; como em C, o primeiro índice da string é o 0. Não existe um tipo
separado para caracteres; um caracter é simplesmente uma string unitária. Assim como na linguagem Icon,
substrings podem ser especificadas através da notação <em>slice</em> (N.d.T: fatiar): dois
índices separados por dois pontos.</p>
<div class="verbatim">
<pre>
>>> word[4]
'A'
>>> word[0:2]
'He'
>>> word[2:4]
'lp'
</pre>
</div>
<p>Índices de fatias <em>slice</em> seguem uma padronização útil; a omissão do primeiro
índice equivale a zero, a omissão do segundo índice equivale ao tamanho da string sendo fatiada.</p>
<div class="verbatim">
<pre>
>>> word[:2] # Os dois primeiros caracteres
'He'
>>> word[2:] # Tudo exceto os dois primeiros caracteres
'lpA'
</pre>
</div>
<p>Diferentemente de C, strings não podem ser alteradas em Python. Atribuir para uma posição
(índice) dentro de uma string resultará em erro:</p>
<div class="verbatim">
<pre>
>>> word[0] = 'x'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
>>> word[:1] = 'Splat'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object doesn't support slice assignment
</pre>
</div>
<p>Entretanto, criar uma nova string com o conteúdo combinado é fácil e eficiente:</p>
<div class="verbatim">
<pre>
>>> 'x' + word[1:]
'xelpA'
>>> 'Splat' + word[4]
'SplatA'
</pre>
</div>
<p>Aqui está um invariante interessante relacionado a operações de slice: <code>s[:i] + s[i:]</code>
equals <code>s</code>.</p>
<div class="verbatim">
<pre>
>>> word[:2] + word[2:]
'HelpA'
>>> word[:3] + word[3:]
'HelpA'
</pre>
</div>
<p>Índices de slice degenerados são tratados ``graciosamente'' (N.d.T: este termo indica robustez no
tratamento de erros): um índice muito maior que o comprimento é trocado pelo comprimento, um limitante
superior que seja menor que o limitante inferior produz uma string vazia como resultado.</p>
<div class="verbatim">
<pre>
>>> word[1:100]
'elpA'
>>> word[10:]
''
>>> word[2:1]
''
</pre>
</div>
<p>Índices podem ser números negativos, para iniciar a contagem a partir da direita ao invés da
esquerda. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> word[-1] # O útlimo caracter
'A'
>>> word[-2] # O penúltimo caracter
'p'
>>> word[-2:] # Os dois últimos caracteres
'pA'
>>> word[:-2] # Tudo exceto os dois últimos caracteres
'Hel'
</pre>
</div>
<p>Observe que -0 é o mesmo que 0, logo neste caso não se conta a partir da direita!</p>
<div class="verbatim">
<pre>
>>> word[-0] # ( -0 == 0)
'H'
</pre>
</div>
<p>Intervalos fora dos limites da string são truncados, mas não tente isso em indexações com um
único índice (que não seja um slice):</p>
<div class="verbatim">
<pre>
>>> word[-100:]
'HelpA'
>>> word[-10] # error
Traceback (most recent call last):
File "<stdin>", line 1
IndexError: string index out of range
</pre>
</div>
<p>A melhor maneira de lembrar como slices funcionam é pensar nos índices como ponteiros para os
espaços entre caracteres, onde a beirada esquerda do primeiro caracter é 0. Logo a beirada direita do
último caracter de uma string de comprimento <var>n</var> tem índice <var>n</var>, por exemplo:</p>
<div class="verbatim">
<pre>
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
</pre>
</div>
<p>A primeira fileira de números indica a posição dos índices 0..5 na string; a segunda fileira
indica a posição dos respectivos índices negativos. Um slice de <var>i</var> até <var>j</var>
consiste em todos os caracteres entre as beiradas <var>i</var> e <var>j</var>, respectivamente.</p>
<p>Para índices positivos, o comprimento do slice é a diferença entre os índices, se ambos
estão dentro dos limites da string, ex, o comprimento de <code>word[1:3]</code> é 2.</p>
<p>A função interna (N.d.T: interna == <em>built-in</em>) <tt class="function">len()</tt> devolve o
comprimento de uma string:</p>
<div class="verbatim">
<pre>
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
</pre>
</div>
<div class="seealso">
<p class="heading">See Also:</p>
<dl compact="compact" class="seetitle">
<dt><em class="citetitle"><a href="../lib/typesseq.html">Sequências</a></em></dt>
<dd>Strings, e strings Unicode, descritas na próxima seção, são exemplos de
<em>sequências</em> e suportam as operações comuns associadas com esses objetos.</dd>
</dl>
<dl compact="compact" class="seetitle">
<dt><em class="citetitle"><a href="../lib/string-methods.html">Métodos de Strings</a></em></dt>
<dd>Tanto strings comuns quanto Unicode suportam um grande número de métodos para busca e
transformação.</dd>
</dl>
<dl compact="compact" class="seetitle">
<dt><em class="citetitle"><a href="../lib/typesseq-strings.html">Operações de Formatação de
Strings</a></em></dt>
<dd>As operações de formatação em que strings 8-bits e Unicode são o operando à
esquerda do operador <code>%</code> são descritas em mais detalhes aqui.</dd>
</dl>
</div>
<h2> 3.1.3 Strings Unicode</h2>
<p>A partir de Python 2.0 um novo tipo foi introduzido: o objeto Unicode. Ele pode ser usado para armazenar e
manipular dados Unicode (veja <a class="url" href="http://www.unicode.org/">http://www.unicode.org/</a>) e se integra
bem aos demais objetos strings pré-existentes, de forma a realizar auto-conversões quando
necessário.</p>
<p>Unicode tem a vantagem de prover um único número ordinal para cada caracter usado em textos modernos ou
antigos. Previamente, havia somente 256 números ordinais. Logo, mapeamentos entre conjuntos de caracteres e os
256 números ordinais precisavam ser indexados por códigos de página. Isso levou a uma enorme
confusão especialmente no âmbito da internacionalização (tipicamente escrito como "<tt class=
"samp">i18n</tt>" - "<tt class="character">i</tt>" + 18 caracteres + "<tt class="character">n</tt>") de software.
Unicode resolve esses problemas ao definir um único código de página para todos os conjuntos de
caracteres.</p>
<p>Criar strings Unicode em Python é tão simples quanto criar strings normais:</p>
<div class="verbatim">
<pre>
>>> u'Hello World !'
u'Hello World !'
</pre>
</div>
<p>O pequeno "<tt class="character">u</tt>" antes das aspas indica a criação de uma string Unicode . Se
você desejar incluir caracteres especiais na string, você pode fazê-lo através da
codificação Python <em>Unicode-Escape</em>.</p>
<div class="verbatim">
<pre>
>>> u'Hello\u0020World !'
u'Hello World !'
</pre>
</div>
<p>O código de escape <code>\u0020</code> indica a inserção do caracter Unicode com valor ordinal
0x0020 (o espaço em branco) na posição determinada.</p>
<p>Os outros caracteres são interpretados através de seus respectivos valores ordinais diretamente para os
valores ordinais em Unicode. Se você possui strings literais na codificação padrão Latin-1 que
é utilizada na maioria do oeste europeu, você achará conveniente que os 256 caracteres inferiores do
Unicode coincidem com os 256 caracteres inferiores do Latin-1.</p>
<p>Para experts, existe ainda um modo cru (N.d.T: sem processamento de caracteres escape) da mesma forma que existe
para strings normais. Basta prefixar a string com 'ur' para utilizar a codificação Python
<em>Raw-Unicode-Escape</em>. Só será aplicado a conversão <code>\ uXXXX</code> se houver um
número ímpar de barras invertidas antes do escape 'u'.</p>
<div class="verbatim">
<pre>
>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'
</pre>
</div>
<p>O modo cru (N.d.T: <em>raw</em>) é muito útil para evitar excesso de barras invertidas, por exemplo, em
expressões regulares.</p>
<p>Além dessas codificações padrão, Python oferece um outro conjunto de maneiras de se criar
strings Unicode sobre uma codificação padrão.</p>
<p>A função interna <tt class="function">unicode()</tt><a id='l2h-3' xml:id='l2h-3'></a> provê acesso
a todos os Unicode codecs registrados (COders and DECoders).</p>
<p>Alguns dos mais conhecidos codecs são : <em>Latin-1</em>, <em>ASCII</em>, <em>UTF-8</em>, and
<em>UTF-16</em>. Os dois últimos são codificações de tamanho variável para armazenar cada
caracter Unicode em um ou mais bytes. A codificação default é ASCII, que trata normalmente caracteres
no intervalo de 0 a 127 mas rejeita qualquer outro com um erro. Quando uma string Unicode é impressa, escrita em
arquivo ou convertida por <tt class="function">str()</tt>, a codificação padrão é utilizada.</p>
<div class="verbatim">
<pre>
>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"äöü"
u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last):
File "<stdin>", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position
0-2: ordinal not in range(128)
</pre>
</div>
<p>Para se converter uma string Unicode em uma string 8-bits usando uma codificação específica, basta
invocar o método <tt class="function">encode()</tt> de objetos Unicode passando como parâmetro o nome da
codificação destino. É preferível utilizar nomes de codificação em letras
minúsculas.</p>
<div class="verbatim">
<pre>
>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'
</pre>
</div>
<p>Também pode ser utilizada a função <tt class="function">unicode()</tt> para efetuar a
converção de um string em outra codificação. Neste caso, o primeiro parâmetro é a
string a ser convertida e o segundo o nome da codificação almejada. O valor de retorno da função
é a string na nova codificação.</p>
<div class="verbatim">
<pre>
>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'
</pre>
</div>
<h2> 3.1.4 Listas</h2>
<p>Python possui diversas estruturas de dados nativas, utilizadas para agrupar outros valores. A mais versátil
delas é a lista (<em>list</em>), que pode ser escrita como uma lista de valores separados por vírgula e
entre colchetes. Mais importante, os valores contidos na lista não precisam ser do mesmo tipo.</p>
<div class="verbatim">
<pre>
>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]
</pre>
</div>
<p>Da mesma forma que índices de string, índices de lista começam do 0, listas também podem ser
concatenadas e sofrer o operador de <em>slice</em>.</p>
<div class="verbatim">
<pre>
>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boo!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']
</pre>
</div>
<p>Diferentemente de strings, que são imutáveis, é possível mudar elementos individuais da
lista:</p>
<div class="verbatim">
<pre>
>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]
</pre>
</div>
<p>Atribuição à fatias (<em>slices</em>) é possível, e isso pode até alterar o tamanho
da lista:</p>
<div class="verbatim">
<pre>
>>> # Replace some items:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Remove some:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Insert some:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> a[:0] = a # Insert (a copy of) itself at the beginning
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]
</pre>
</div>
<p>A função interna <tt class="function">len()</tt> também se aplica a lista:</p>
<div class="verbatim">
<pre>
>>> len(a)
8
</pre>
</div>
<p>É possível aninhar listas (criar listas contendo outras listas), por exemplo:</p>
<div class="verbatim">
<pre>
>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra') # See section 5.1
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']
</pre>
</div>
<p>Observe que no último exemplo, <code>p[1]</code> e <code>q</code> na verdade se referem ao mesmo objeto! Mais
tarde retornaremos a semântica do objeto.</p>
<h1> 3.2 Primeiros Passos em Direção à Programação</h1>
<p>Naturalmente, nós podemos utilizar Python para tarefas mais complicadas do que somar dois números. A
título de exemplificação, nós podemos escrever o início da sequência de
<em>Fibonacci</em> assim:</p>
<div class="verbatim">
<pre>
>>> # Serie de Fibonacci :
... # A soma de dois elementos define o proximo
... a, b = 0, 1
>>> while b < 10:
... print b
... a, b = b, a+b
...
1
1
2
3
5
8
</pre>
</div>
<p>Este exemplo introduz diversas características ainda não mencionadas.</p>
<ul>
<li>A primeira linha contém uma atribuição múltipla: as variáveis <code>a</code> e
<code>b</code> simultaneamente recebem os novos valores 0 e 1. Na última linha há outro exemplo de
atribuição múltipla demonstrando que expressões do lado direito são sempre avaliadas
primeiro, antes da atribuição. As expressões do lado direito são avaliadas da esquerda para a
direita.</li>
<li>O laço <tt class="keyword">while</tt> executa enquanto a condição (aqui:<code>b < 10</code>)
permanecer verdadeira. Em Python, como em C, qualquer valor inteiro não nulo é considerado verdadeiro
(valor <em>true</em>), zero tem valor <em>false</em>. A condição pode ser ainda uma lista ou string, na
verdade qualquer sequência; qualquer coisa com comprimento não nulo tem valor <em>true</em> e
sequências vazias tem valor <em>false</em>. O teste utilizado no exemplo é uma simples
comparação. Os operadores padrão para comparação são os mesmos de C:
<code><</code> (menor que), <code>></code> (maior que), <code>==</code> (igual), <code><=</code> (menor ou
igual), <code>>=</code> (maior ou igual) and <code>!=</code> (diferente).</li>
<li>O corpo do laço é identado: identação em Python é a maneira de agrupar comandos.
Python (ainda!) não possui facilidades automáticas de edição de linha. Na prática
você irá preparar scripts Python complexos em um editor de texto; a maioria dos editores de texto possui
facilidades de identação automática. Quando comandos compostos forem alimentados ao interpretador
interativamente, devem ser encerrados por uma linha em branco (já que o <em>parser</em> não tem como
adivinhar qual é a última linha do comando). Observe que toda linha de um mesmo bloco de comandos deve
possuir a mesma identação.</li>
<li>O comando <tt class="keyword">print</tt> escreve o valor da expressão dada. Ele difere de apenas escrever
a expressão no interpretador (como foi feito no exemplo da calculadora) ao aceitar múltiplas
expressões e strings. Strings são impressas sem aspas, um espaço é inserido entre itens de
forma a formatar o resultado assim:
<div class="verbatim">
<pre>
>>> i = 256*256
>>> print 'The value of i is', i
The value of i is 65536
</pre>
</div>
<p>Uma vírgula ao final evita a quebra de linha:</p>
<div class="verbatim">
<pre>
>>> a, b = 0, 1
>>> while b < 1000:
... print b,
... a, b = b, a+b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
</pre>
</div>
<p>Note que o interpretador insere uma quebra de linha antes de imprimir o próximo prompt se a última
linha não foi completada.</p>
</li>
</ul>
<h1> 4. Mais Ferramentas de Controle de Fluxo</h1>
<p>Além do <tt class="keyword">while</tt> recém apresentado, Python possui as estruturas usuais de controle
de fluxo conhecidas em outras linguagens, com algumas variações:</p>
<h1> 4.1 Construção <tt class="keyword">if</tt></h1>
<p>Provavelmente uma das mais conhecidas construções é o <tt class="keyword">if</tt>. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> x = int(raw_input("Por favor entre com um numero inteiro: "))
>>> if x < 0:
... x = 0
... print 'Negativo mudou para zero'
... elif x == 0:
... print 'Zero'
... elif x == 1:
... print 'Um'
... else:
... print 'Mais'
...
</pre>
</div>
<p>Pode haver zero ou mais seções <tt class="keyword">elif</tt>. A seção <tt class=
"keyword">else</tt> é opcional. A palavra-chave `<tt class="keyword">elif</tt>' é uma abreviação
para `else if', e é útil para evitar identação excessiva. Uma sequência <tt class=
"keyword">if</tt> ... <tt class="keyword">elif</tt> ... <tt class="keyword">elif</tt> ... substitui as
construções <tt class="keyword">switch</tt> e <tt class="keyword">case</tt> encontradas em outras
linguagens.</p>
<h1> 4.2 Construção <tt class="keyword">for</tt></h1>
<p>A construção <tt class="keyword">for</tt><a id='l2h-4' xml:id='l2h-4'></a> em Python difere um pouco do
que se está acostumado em C ou Pascal. Ao invés de se iterar sobre progressões aritiméticas (como
em Pascal), ou fornecer ao usuário a habilidade de definir tanto o passo da iteração quanto a
condição de parada (como em C), o <tt class="keyword">for</tt><a id='l2h-5' xml:id='l2h-5'></a> de Python
itera sobre os itens de uma sequência (uma lista ou uma string), na ordem em que aparecem na sequência. Por
exemplo :</p>
<div class="verbatim">
<pre>
>>> # Medindo algumas strings:
... a = ['gato', 'janela', 'defenestrar']
>>> for x in a:
... print x, len(x)
...
gato 4
janela 6
defenestrar 11
</pre>
</div>
<p>Não é seguro modificar a sequência sobre a qual se baseia o laço de iteração (isto
só pode acontecer se a sequência for mutável, isto é, uma lista). Se você precisar modificar
a lista sobre a qual se está iterando, por exemplo, para duplicar itens selecionados, você deve iterar
sobre uma cópia da lista ao invés da própria. A notação de <em>slice</em> é bastante
conveniente para isso:</p>
<div class="verbatim">
<pre>
>>> for x in a[:]: # faz uma cópia da lista inteira
... if len(x) > 6: a.insert(0, x)
...
>>> a
['defenestrar', 'gato', 'janela', 'defenestrar']
</pre>
</div>
<h1> 4.3 A Função <tt class="function">range()</tt></h1>
<p>Se você precisar iterar sobre sequências numéricas, a função interna <tt class=
"function">range()</tt> é a resposta. Ela gera listas contendo progressões aritiméticas, por
exemplo:</p>
<div class="verbatim">
<pre>
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</pre>
</div>
<p>O ponto de parada fornecido nunca é gerado na lista; <code>range(10)</code> gera uma lista com 10 valores,
exatamente os índices válidos para uma sequência de comprimento 10. É possível iniciar o
intervalo em outro número, ou alterar a razão da progresão (inclusive com passo negativo):</p>
<div class="verbatim">
<pre>
>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]
</pre>
</div>
<p>Para iterar sobre os índices de uma sequência, combine <tt class="function">range()</tt> e <tt class=
"function">len()</tt> da seguinte forma:</p>
<div class="verbatim">
<pre>
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
... print i, a[i]
...
0 Mary
1 had
2 a
3 little
4 lamb
</pre>
</div>
<h1> 4.4 Cláusulas <tt class="keyword">break</tt>, <tt class="keyword">continue</tt> e <tt class="keyword">else</tt>
em Laços</h1>
<p>O <tt class="keyword">break</tt>, como no C, quebra o laço mais interno de um <tt class="keyword">for</tt> ou
<tt class="keyword">while</tt>.</p>
<p>O <tt class="keyword">continue</tt>, também emprestado do C, continua o próximo passo do laço mais
interno.</p>
<p>Laços podem ter uma cláusula <code>else</code>, que é executada sempre que o laço se encerra
por exaustão da lista (no caso do <tt class="keyword">for</tt>) ou quando a condição se torna falsa
(no caso do <tt class="keyword">while</tt>), mas nunca quando o laço é encerrado por um <tt class=
"keyword">break</tt>. Isto é exemplificado no próximo exemplo que procura números primos:</p>
<div class="verbatim">
<pre>
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
... print n, 'equals', x, '*', n/x
... break
... else:
... # loop fell through without finding a factor
... print n, 'is a prime number'
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
</pre>
</div>
<h1> 4.5 Construção <tt class="keyword">pass</tt></h1>
<p>A construção <tt class="keyword">pass</tt> não faz nada. Ela pode ser usada quando a sintaxe exige
um comando mas a semântica do programa não requer nenhuma ação. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> while True:
... pass # Busy-wait para interrupção de teclado
...
</pre>
</div>
<h1> 4.6 Definindo Funções</h1>
<p>Nós podemos criar uma função que escreve a série de Fibonacci até um limite
arbitrário:</p>
<div class="verbatim">
<pre>
>>> def fib(n): # escreve a serie de Fibonacci ate n
... """Print a Fibonacci series up to n"""
... a, b = 0, 1
... while b < n:
... print b,
... a, b = b, a+b
...
>>> # Agora invoca a funçao que acabamos de definir
... fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
</pre>
</div>
<p>A palavra-reservada <tt class="keyword">def</tt> serve para definir uma função. Ela deve ser seguida do
nome da função, da lista formal de parâmetros entre parênteses e dois pontos.</p>
<p>O corpo da função deve começar na linha seguinte e deve ser identado. Opcionalmente, a primeira
linha do corpo da função pode ser uma string literal, cujo propósito é documentar a
função. Se presente, essa string chama-se <i class="dfn">docstring</i>. <a id='l2h-6' xml:id=
'l2h-6'></a></p>
<p>Existem ferramentas que utilizam docstrings para produzir automaticamente documentação impressa,
on-line, ou ainda permitir que o usuário navegue interativamente pelo código. É uma boa prárica
incluir sempre docstrings em suas funções, portanto, tente fazer disto um hábito.</p>
<p>A execução da função gera uma nova tabela de símbolos utilizada para as variáveis
locais da função, mais precisamente, toda atribuição a variável dentro da função
armazena o valor na tabela de símbolos local. Referências a variáveis são buscadas primeiramente
na tabela local, então na tabela de símbolos global e finalmente na tabela de símbolos interna
(<em>built-in</em>). Portanto, não se pode atribuir diretamente um valor a uma variável global dentro de
uma função (a menos que se utilize a declaração <tt class="keyword">global</tt> antes), ainda que
variáveis globais possam ser referenciadas livremente.</p>
<p>Os parâmetros reais (argumentos) de uma chamada de função são introduzidos na tabela de
símbolos local da função chamada, portanto, argumentos são passados por valor (onde valor é
sempre uma referência para objeto, não o valor do objeto)<a name="tex2html2" href=
"#foot1805"><sup>4.1</sup></a> Quando uma função chama outra, uma nova tabela de símbolos é
criada para tal chamada.</p>
<p>Uma definição de função introduz o nome da função na tabela de símbolos
corrente. O valor do nome da função possui um tipo que é reconhecido pelo interpretador como uma
função definida pelo usuário. Esse valor pode ser atribuído para outros nomes que também
podem ser usados como funções. Esse mecanismo serve para renomear funções:</p>
<div class="verbatim">
<pre>
>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
1 1 2 3 5 8 13 21 34 55 89
</pre>
</div>
<p>Você pode afirmar que <code>fib</code> não é uma função, mas um procedimento. Em Python,
assim como em C, procedimentos são apenas funções que não retornam valores. Na verdade, falando
tecnicamente, procedimentos retornam um valor, ainda que meio chato. Esse valor é chamado <code>None</code>
(é um nome interno). A escrita do valor None é supressa pelo interpretador se ele estiver sozinho.
Você pode verificar isso se quiser.</p>
<div class="verbatim">
<pre>
>>> print fib(0)
None
</pre>
</div>
<p>É muito simples escrever uma função que retorna a lista da série de Fibonacci, ao invés
de imprimi-la:</p>
<div class="verbatim">
<pre>
>>> def fib2(n):
... """Retorna a lista contendo a serie de Fibonacci ate n"""
... result = []
... a, b = 0, 1
... while b < n:
... result.append(b) # veja abaixo
... a, b = b, a+b
... return result
...
>>> f100 = fib2(100) # invoca
>>> f100 # escreve resultado
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
</pre>
</div>
<p>Este exemplo, como sempre, demonstra algumas características novas:</p>
<ul>
<li>A palavra-chave <tt class="keyword">return</tt> termina a função retornando um valor. Se <tt class=
"keyword">return</tt> não for seguido de nada, então retorna o valor <code>None</code>. Se a
função chegar ao fim sem o uso explícito do <tt class="keyword">return</tt>, então também
será retornado o valor <code>None</code>.</li>
<li>O trecho <code>result.append(b)</code> chama um método do objeto lista <code>result</code>. Um método
é uma função que pertence a um objeto e é chamada através de <code>obj.methodname</code>,
onde <code>obj</code> é um objeto qualquer, e <code>methodname</code> é o nome de um método que foi
definido pelo tipo do objeto. Tipos diferentes definem métodos diferentes. Sobretudo, métodos de
diferentes tipos podem ser homônimos sem ambiguidade (é possível definir seus próprios tipos de
objetos e métodos, utilizando <em>classes</em>, como será discutido mais tarde neste tutorial).
<p>O método <tt class="method">append()</tt> mostrado no exemplo, é definido para todos objetos do tipo
lista. Este método permite a adição de novos elementos à lista. Neste exemplo, ele é
equivalente a "<tt class="samp">result = result + [b]</tt>", só que <tt class="method">append()</tt> ainda
é mais eficiente.</p>
</li>
</ul>
<h1> 4.7 Mais sobre Definição de Funções</h1>
<p>Ainda é possível definir funções com um número variável de argumentos. Existem
três formas que podem ser combinadas.</p>
<h2> 4.7.1 Parâmetros com Valores Default</h2>
<p>A mais útil das três é especificar um valor default para um ou mais argumentos. Isso cria uma
função que pode ser invocada com um número menor de argumentos do que quando foi definida.</p>
<div class="verbatim">
<pre>
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while 1:
ok = raw_input(prompt)
if ok in ('y', 'ye', 'yes'): return True
if ok in ('n', 'no', 'nop', 'nope'): return False
retries = retries - 1
if retries < 0: raise IOError, 'refusenik user'
print complaint
</pre>
</div>
<p>Essa função pode ser chamada de duas formas: <code>ask_ok('Do you really want to quit?')</code> ou como
<code>ask_ok('OK to overwrite the file?', 2)</code>.</p>
<p>Este exemplo também introduz a keyword <tt class="keyword">in</tt>, que verifica se uma sequência
contém ou não um determinado valor.</p>
<p>Os valores default são avaliados durante a definição da função, e no escopo em que a
função foi definida:</p>
<div class="verbatim">
<pre>
i = 5
def f(arg = i):
print arg
i = 6
f()
</pre>
</div>
<p>irá imprimir <code>5</code>.</p>
<p><strong>Aviso importante:</strong> Valores default são avaliados apenas uma vez. Isso faz diferença
quando o valor default é um objeto mutável como uma lista ou dicionário. Por exemplo, a
função a seguir acumula os argumentos passados em chamadas subsequentes:</p>
<div class="verbatim">
<pre>
def f(a, L=[]):
L.append(a)
return L
print f(1)
print f(2)
print f(3)
</pre>
</div>
<p>Isso irá imprimir:</p>
<div class="verbatim">
<pre>
[1]
[1, 2]
[1, 2, 3]
</pre>
</div>
<p>Se você não quiser que o valor default seja compartilhado entre chamadas subsequentes, pode reescrever a
função assim:</p>
<div class="verbatim">
<pre>
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
</pre>
</div>
<h2> 4.7.2 Parâmetros na Forma Chave-Valor</h2>
<p>Funções também podem ser chamadas passando argumentos no formato chave-valor como "<tt class=
"samp"><var>keyword</var> = <var>value</var></tt>". Por exemplo:</p>
<div class="verbatim">
<pre>
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
print "-- This parrot wouldn't", action,
print "if you put", voltage, "volts through it."
print "-- Lovely plumage, the", type
print "-- It's", state, "!"
</pre>
</div>
<p>poderia ser chamada em qualquer uma das seguintes maneiras:</p>
<div class="verbatim">
<pre>
parrot(1000)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('a thousand', state = 'pushing up the daisies')
parrot('a million', 'bereft of life', 'jump')
</pre>
</div>
<p>porém, existem maneiras inválidas:</p>
<div class="verbatim">
<pre>
parrot() # parâmetro exigido faltando
parrot(voltage=5.0, 'dead') # parâmetro não-chave-valor depois de parâmetro chave-valor
parrot(110, voltage=220) # valor duplicado para mesmo parâmetro
parrot(actor='John Cleese') # parâmetro desconhecido
</pre>
</div>
<p>Em geral, uma lista de argumentos tem que apresentar todos argumentos posicionais antes de qualquer um dos seus
argumentos chave-valor, onde as chaves têm que ser escolhidas a partir dos nomes formais dos argumentos.
Não é importante se um dado argumento já possuia valor default ou não. Nenhum argumento deve
receber um valor mais do que uma única vez. Nomes de parâmetros formais correspondendo a argumentos
posicionais não podem ser usados na forma chave-valor em uma mesma chamada. O próximo exemplo ilustra essa
limitação.</p>
<div class="verbatim">
<pre>
>>> def function(a):
... pass
...
>>> function(0, a=0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: function() got multiple values for keyword argument 'a'
</pre>
</div>
<p>Quando o último parâmetro formal for <code>**<var>name</var></code>, ele armazenará todos os
parâmetros efetivamente passados para a função, exceto aqueles que não correspondiam a
parâmetros formais. Isto pode ser combinado com o parâmetro formal <code>*<var>name</var></code> (descrito
na próxima sub-seção) que recebe a lista contendo todos argumentos posicionais que não
correspondiam a parâmetros formais. O importante é que (<code>*<var>name</var></code> deve ser declarado
antes de <code>**<var>name</var></code>.) Siga o exemplo:</p>
<div class="verbatim">
<pre>
def cheeseshop(kind, *arguments, **keywords):
print "-- Do you have any", kind, '?'
print "-- I'm sorry, we're all out of", kind
for arg in arguments: print arg
print '-'*40
keys = keywords.keys()
keys.sort()
for kw in keys: print kw, ':', keywords[kw]
</pre>
</div>
<p>Poderia ser chamado assim:</p>
<div class="verbatim">
<pre>
cheeseshop('Limburger', "It's very runny, sir.",
"It's really very, VERY runny, sir.",
client='John Cleese',
shopkeeper='Michael Palin',
sketch='Cheese Shop Sketch')
</pre>
</div>
<p>e, naturalmente, produziria:</p>
<div class="verbatim">
<pre>
-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch
</pre>
</div>
<p>Note que o método <tt class="method">sort()</tt> da lista de chaves em <em>keywords</em> é chamado antes
de exibir o conteúdo do dicionário; se isso não fosse feito, eles seriam exibidos em ordem
arbitrária.</p>
<h2> 4.7.3 Listas Arbitrárias de Argumentos</h2>
<p>Finalmente, a opção menos frequentemente usada é chamar a função com um número
arbitrário de argumentos. Esses argumentos serão encapsulados em uma sequência (tupla). Antes do
número variável de argumentos, zero ou mais argumentos normais podem estar presentes.</p>
<div class="verbatim">
<pre>
def fprintf(file, format, *args):
file.write(format % args)
</pre>
</div>
<h2> 4.7.4 Desempacotando Listas de Argumentos</h2>
<p>A situação inversa ocorre quando os argumentos já estão numa lista ou tupla mas é
necessário que elas sejam desempacotadas para uma chamada de função que requer argumentos separados.
Por exemplo, a função <tt class="function">range()</tt> espera argumentos separados, <var>start</var> e
<var>stop</var>. Se eles não estiverem disponíveis separadamente, escreva a chamada de função com
o operador <code>*</code> para retirá-los da lista ou tupla:</p>
<div class="verbatim">
<pre>
>>> range(3, 6) # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> range(*args) # call with arguments unpacked from a list
[3, 4, 5]
</pre>
</div>
<h2> 4.7.5 Funções Lambda</h2>
<p>Dada a demanda do público, algumas características encontradas em linguagens de programação
funcionais (como Lisp) foram adicionadas a Python. Com a palavra-chave <tt class="keyword">lambda</tt>,
funções curtas e anônimas podem ser criadas.</p>
<p>Aqui está uma função que devolve a soma de seus dois argumentos: "<tt class="samp">lambda a, b:
a+b</tt>". Funções Lambda podem ser utilizadas em qualquer lugar que exigiria uma função
tradicional. Sintaticamente, funções Lambda estão restritas a uma única expressão.
Semanticamente, ela são apenas açúcar sintático para a definição de funções
normais. Assim como definições de funções aninhadas, funções lambda não podem
referenciar variáveis de um escopo mais externo:</p>
<div class="verbatim">
<pre>
>>> def make_incrementor(n):
... return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43
</pre>
</div>
<h2> 4.7.6 Strings de Documentação</h2>
<p>Há uma convenção sobre o conteúdo e formato de strings de documentação. <a id=
'l2h-7' xml:id='l2h-7'></a></p>
<p>A primeira linha deve ser sempre curta, representando um consiso sumário do propósito do objeto. Por
brevidade, não deve explicitamente se referir ao nome ou tipo do objeto, uma vez que estas informações
estão disponívies por outros meios (exceto se o nome da função for o próprio verbo que
descreve a finalidade da função). Essa linha deve começar com letra maiúscula e terminar com
ponto.</p>
<p>Se existem múltiplas linhas na string de documentação, a segunda linha deve estar em branco,
visulamente separando o sumário do resto da descrição. As linhas seguintes devem conter um ou mais
parágrafos descrevendo as convenções de chamada ao objeto, seus efeitos colaterais, etc.</p>
<p>O parser do Python não toca na identação de comentários multi-linha. Portanto, ferramentas que
processem strings de documentação precisam lidar com isso (se desejado). Existe uma convenção
para isso. A primeira linha não nula após a linha de sumário determina a identação para o
resto da string de documentação. A partir daí, espaços em branco podem ser removidos de todas as
linhas da string.</p>
<p>Aqui está um exemplo de uma docstring multi-linha:</p>
<div class="verbatim">
<pre>
>>> def my_function():
... """Do nothing, but document it.
...
... No, really, it doesn't do anything.
... """
... pass
...
>>> print my_function.__doc__
Do nothing, but document it.
No, really, it doesn't do anything.
</pre>
</div>
<h1> 5. Estruturas de Dados</h1>
<p>Este capítulo descreve alguns pontos já abordados, porém com mais detalhes, e ainda adiciona outros
pontos inéditos.</p>
<h1> 5.1 Mais sobre Listas</h1>
<p>O tipo <em>list</em> possui mais métodos. Aqui estão todos os métodos disponívies em um objeto
lista.</p>
<dl>
<dd>
<table cellpadding="0" cellspacing="0">
<tr valign="baseline">
<td><nobr><b><tt id='l2h-8' xml:id='l2h-8' class="method">append</tt></b>(</nobr></td>
<td><var>x</var>)</td>
</tr>
</table>
</dd>
<dd>Adiciona um item ao fim da lista; equivalente a <code>a[len(a):] = [<var>x</var>]</code>.</dd>
</dl>
<dl>
<dd>
<table cellpadding="0" cellspacing="0">
<tr valign="baseline">
<td><nobr><b><tt id='l2h-9' xml:id='l2h-9' class="method">extend</tt></b>(</nobr></td>
<td><var>L</var>)</td>
</tr>
</table>
</dd>
<dd>Extende a lista adicionando no fim todos os elementos da lista passada como parâmetro; equivalente a
<code>a[len(a):] = <var>L</var></code>.</dd>
</dl>
<dl>
<dd>
<table cellpadding="0" cellspacing="0">
<tr valign="baseline">
<td><nobr><b><tt id='l2h-10' xml:id='l2h-10' class="method">insert</tt></b>(</nobr></td>
<td><var>i, x</var>)</td>
</tr>
</table>
</dd>
<dd>Insere um item em uma posição especificada. O primeiro argumento é o índice do elemento
anterior ao que está para ser inserido, assim <code>a.insert(0, <var>x</var>)</code> insere no início da
lista, e <code>a.insert(len(a), <var>x</var>)</code> é equivalente a <code>a.append(<var>x</var>)</code>.</dd>
</dl>
<dl>
<dd>
<table cellpadding="0" cellspacing="0">
<tr valign="baseline">
<td><nobr><b><tt id='l2h-11' xml:id='l2h-11' class="method">remove</tt></b>(</nobr></td>
<td><var>x</var>)</td>
</tr>
</table>
</dd>
<dd>Remove o primeiro item da lista cujo valor é <var>x</var>. É gerado um erro se este valor não
existir.</dd>
</dl>
<dl>
<dd>
<table cellpadding="0" cellspacing="0">
<tr valign="baseline">
<td><nobr><b><tt id='l2h-12' xml:id='l2h-12' class="method">pop</tt></b>(</nobr></td>
<td><big>[</big><var>i</var><big>]</big>)</td>
</tr>
</table>
</dd>
<dd>Remove o item na posição dada e o retorna. Se nenhum item for especificado, <code>a.pop()</code>
remove e retorna o último item na lista. (Os colchetes ao redor de <var>i</var> indicam que o parâmetro
é opcional, não que você deva digitá-los naquela posição. Você verá essa
notação com frequência na <em class="citetitle"><a href="../lib/lib.html" title=
"Referência da Biblioteca Python">Referência da Biblioteca Python</a></em>.)</dd>
</dl>
<dl>
<dd>
<table cellpadding="0" cellspacing="0">
<tr valign="baseline">
<td><nobr><b><tt id='l2h-13' xml:id='l2h-13' class="method">index</tt></b>(</nobr></td>
<td><var>x</var>)</td>
</tr>
</table>
</dd>
<dd>Retorna o índice do primeiro item cujo valor é igual ao argumento fornecido em <var>x</var>, gerando
erro se este valor não existe</dd>
</dl>
<dl>
<dd>
<table cellpadding="0" cellspacing="0">
<tr valign="baseline">
<td><nobr><b><tt id='l2h-14' xml:id='l2h-14' class="method">count</tt></b>(</nobr></td>
<td><var>x</var>)</td>
</tr>
</table>
</dd>
<dd>Retorna o número de vezes que o valor <var>x</var> aparece na lista.</dd>
</dl>
<dl>
<dd>
<table cellpadding="0" cellspacing="0">
<tr valign="baseline">
<td><nobr><b><tt id='l2h-15' xml:id='l2h-15' class="method">sort</tt></b>(</nobr></td>
<td>)</td>
</tr>
</table>
</dd>
<dd>Ordena os itens da lista sem gerar uma nova lista.</dd>
</dl>
<dl>
<dd>
<table cellpadding="0" cellspacing="0">
<tr valign="baseline">
<td><nobr><b><tt id='l2h-16' xml:id='l2h-16' class="method">reverse</tt></b>(</nobr></td>
<td>)</td>
</tr>
</table>
</dd>
<dd>Inverte a ordem dos elementos na lista sem gerar uma nova lista.</dd>
</dl>
<p>Um exemplo que utiliza a maioria dos métodos:</p>
<div class="verbatim">
<pre>
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print a.count(333), a.count(66.25), a.count('x')
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
</pre>
</div>
<h2> 5.1.1 Usando Listas como Pilhas</h2>
<p>Os métodos de lista tornam muito fácil utilizar listas como pilhas, onde o item adicionado por
último é o primeiro a ser recuperado (política ``último a entrar, primeiro a sair''). Para
adicionar um item ao topo da pilha, use <tt class="method">append()</tt>. Para recuperar um item do topo da pilha use
<tt class="method">pop()</tt> sem nenhum índice. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
</pre>
</div>
<h2> 5.1.2 Usando Listas como Filas</h2>
<p>Você pode também utilizar uma lista como uma fila, onde o primeiro item adicionado é o primeiro a
ser recuperado (política ``primeiro a entrar, primeiro a sair''). Para adicionar um elemento ao fim da fila
utiliza <tt class="method">append()</tt>. Para recuperar um elemento do início da fila use <tt class=
"method">pop()</tt> com <code>0</code> no índice. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> queue = ["Eric", "John", "Michael"]
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.pop(0)
'Eric'
>>> queue.pop(0)
'John'
>>> queue
['Michael', 'Terry', 'Graham']
</pre>
</div>
<h2> 5.1.3 Ferramentas para Programação Funcional</h2>
<p>Existem três funções internas que são muito úteis sobre listas: <tt class=
"function">filter()</tt>, <tt class="function">map()</tt>, e <tt class="function">reduce()</tt>.</p>
<p>"<tt class="samp">filter(<var>function</var>, <var>sequence</var>)</tt>" retorna uma sequência consistindo
dos itens pertencentes a sequência para os quais <code><var>function</var>(<var>item</var>)</code> é
verdadeiro. If se a sequência for <tt class="class">string</tt> ou <tt class="class">tuple</tt>, o resultado
será sempre do mesmo tipo; caso contrário, será sempre uma lista. Por exemplo, para computar
números primos:</p>
<div class="verbatim">
<pre>
>>> def f(x): return x % 2 != 0 and x % 3 != 0
...
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]
</pre>
</div>
<p>"<tt class="samp">map(<var>function</var>, <var>sequence</var>)</tt>" aplica
<code><var>function</var>(<var>item</var>)</code> para cada item da sequência e retorna a lista de valores
retornados a cada aplicação. Por exemplo, para computar quadrados:</p>
<div class="verbatim">
<pre>
>>> def cube(x): return x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
</pre>
</div>
<p>Mais de uma sequência pode ser passada; a função a ser aplicada deve possuir tantos parâmetros
formais quantas sequências forem alimentadas para "<tt class="samp">map</tt>", e é chamada com o item
correspondente de cada sequência (ou <code>None</code> caso se uma sequência for menor que a outra). Se
<code>None</code> for passado no lugar da função, então será aplicada uma função que
apenas devolve os argumentos recebidos.</p>
<div class="verbatim">
<pre>
>>> seq = range(8)
>>> def square(x, y): return x+y
...
>>> map(add, seq, seq)
[0, 2, 4, 6, 8, 10, 12, 14]
</pre>
</div>
<p>"<tt class="samp">reduce(<var>function</var>, <var>sequence</var>)</tt>" retorna um único valor
construído a partir da sucessiva aplicação da função binária <var>function</var> a
todos os elementos da lista fornecida, dois de cada vez. Por exemplo, para computar a soma dos 10 primeiros
números inteiros:</p>
<div class="verbatim">
<pre>
>>> def add(x,y): return x+y
...
>>> reduce(add, range(1, 11))
55
</pre>
</div>
<p>Se apenas houver um único elemento na sequência fornecida como parâmetro, então seu valor
será retornado. Se a sequência for vazia uma exceção será levantada.</p>
<p>Um terceiro argumento pode ser passado para indicar o valor inicial. Neste caso, redução de
sequências vazias retornará o valor inicial. Se a sequência não for vazia, a redução se
iniciará a partir do valor inicial.</p>
<div class="verbatim">
<pre>
>>> def sum(seq):
... def add(x,y): return x+y
... return reduce(add, seq, 0)
...
>>> sum(range(1, 11))
55
>>> sum([])
0
</pre>
</div>
<p>Não use este exemplo de função para somar: como somar números é uma necessidade comum,
fornecemos uma função <code>sum(<var>sequence</var>)</code> que funciona exatamente como essa. <span class=
"versionnote">New in version 2.3.</span></p>
<h2><a name="SECTION007140000000000000000">5.1.4 Abrangência de Lista (<em>List Comprehensions</em>)</a></h2>
<p>Abrangência de listas (ou <em>list comprehensions</em>) permitem a criação de listas de forma
concisa sem apelar para o uso de <tt class="function">map()</tt>, <tt class="function">filter()</tt> e/ou <tt class=
"keyword">lambda</tt>. A definição resultante tende a ser mais clara do que o uso das construções
funcionais citadas anteriormente. Cada abrangência de lista consiste numa expressão seguida da
cláusula <tt class="keyword">for</tt>, e então zero ou mais cláusulas <tt class="keyword">for</tt> ou
<tt class="keyword">if</tt>. O resultado será uma lista proveniente da avaliação da expressão no
contexto das cláusulas <tt class="keyword">for</tt> e <tt class="keyword">if</tt> subsequentes. Se a
expressão gerar uma tupla, a mesma deve ser inserida entre parênteses.</p>
<div class="verbatim">
<pre>
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
>>> [[x,x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> [x, x**2 for x in vec] # erro - parenteses requerido para tuplas
File "<stdin>", line 1 in ?
[x, x**2 for x in vec]
^
SyntaxError: invalid syntax
>>> [(x, x**2) for x in vec]
[(2, 4), (4, 16), (6, 36)]
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
</pre>
</div>
<p>Abrangência de listas é muito mais flexível do que <tt class="function">map()</tt> e pode ser
aplicada a expressões complexas e funções aninhadas:</p>
<h1> 5.2 O comando <tt class="keyword">del</tt></h1>
<p>Existe uma maneira de remover um item de uma lista a partir de seu índice, ao invés de seu valor: o
comando <tt class="keyword">del</tt>. Ele difere do método <tt class="method">pop</tt>, que retorna o item
removido. Ele também pode ser utilizado para remover fatias (<em>slices</em>) da lista. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
</pre>
</div>
<p><tt class="keyword">del</tt> também pode ser utilizado para apagar variáveis:</p>
<div class="verbatim">
<pre>
>>> del a
</pre>
</div>
<p>Referenciar a variável <code>a</code> posteriormente a sua remoção constitui erro (pelo menos
até que seja feita uma nova atribuição para ela). Nós encontraremos outros usos para o comando
<tt class="keyword">del</tt> mais tarde.</p>
<h1> 5.3 Tuplas e Sequências</h1>
<p>Nós vimos que listas e strings possuem muitas propriedades em comum como indexação e
operações de <em>slicing</em>. Elas são dois dos exemplos possíveis de <a class="ulink" href=
"../lib/typesseq.html"><em>sequências</em></a>. Como Python é uma linguagem em evolução, outros
tipos de sequências podem ser adicionados. Existe ainda um outro tipo de sequência já presente na
linguagem: a tupla (<em>tuple</em>).</p>
<p>Uma tupla consiste em uma sequência imutável de valores separados por vírgulas.</p>
<div class="verbatim">
<pre>
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuplas podem ser aninhadas:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
</pre>
</div>
<p>Como você pode ver no trecho acima, tuplas são sempre envolvidas por parênteses. Na
criação, tuplas podem ser envolvidas ou não por parênteses, desde que o contexto não exija
os parênteses (como no caso da tupla pertencer a uma expressão maior).</p>
<p>Tuplas podem ser usadas de diversas formas: pares ordenados, registros de empregados em uma base de dados, etc.
Tuplas, assim como strings, são imutáveis. Não é possível atribuir valores a itens
individuais de uma tupla (você pode simular o mesmo efeito através de operações de fatiamento e
concatenação). Também é possível criar tuplas contendo objetos mutáveis, como
listas.</p>
<p>Um problema especial é a criação de tuplas contendo 0 ou 1 itens: a sintaxe tem certos truques para
acomodar estes casos. Tuplas vazias são construídas por uma par de parênteses vazios. E uma tupla
unitária é construída por um único valor e uma vírgula entre parênteses (sem a
vírgula a tupla não será gerada!). Feio, mas efetivo:</p>
<div class="verbatim">
<pre>
>>> empty = ()
>>> singleton = 'hello', # <-- observe a vírgula extra
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)
</pre>
</div>
<p>O comando <code>t = 12345, 54321, 'hello!'</code> é um exemplo de empacotamento em tupla (<em>tuple
packing</em>): os valores <code>12345</code>, <code>54321</code> e <code>'hello!'</code> são empacotados juntos
em uma tupla. A operação inversa também é possível:</p>
<div class="verbatim">
<pre>
>>> x, y, z = t
</pre>
</div>
<p>Isto é chamado de desempacotamento de sequência (<em>sequence unpacking</em>), e requer que a lista de
variáveis do lado esquerdo corresponda ao comprimento da sequência à direita. Sendo assim, a
atribuição múltipla é um caso de empacotamento e desempacotamento de tupla.</p>
<p>Existe ainda uma certa assimetria aqui: empacotamento de múltiplos valores sempre cria tuplas, mas o
desempacotamento funciona para qualquer sequência.</p>
<h1> 5.4 Sets</h1>
<p>Python também inclui um tipo de dados para conjuntos (<em>sets</em>). Um conjunto é uma
coleção desordenada de dados, sem elementos duplicados. Usos comuns para isso incluem
verificações da existência de objetos em outros sequências e eliminação de items
duplicados. Conjuntos também suportam operações matemáticas como união,
interseção, diferença e diferença simétrica.</p>
<p>Uma pequena demonstração:</p>
<div class="verbatim">
<pre>
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruits = set(basket) # create a set without duplicates
>>> fruits
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruits # fast membership testing
True
>>> 'crabgrass' in fruits
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b # letters in a but not in b
set(['r', 'd', 'b'])
>>> a | b # letters in either a or b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b # letters in both a and b
set(['a', 'c'])
>>> a ^ b # letters in a or b but not both
set(['r', 'd', 'b', 'm', 'z', 'l'])
</pre>
</div>
<h1> 5.5 Dicionários</h1>
<p>Outra estrutura de dados interna de Python, e muito útil, é o <a class="ulink" href=
"../lib/typesmapping.html"><em>dicionário</em></a>. Dicionários são também chamados de
``memória associativa'', ou ``vetor associativo'' . Diferentemente de sequências que são indexadas por
inteiros, dicionários são indexados por chaves (<em>keys</em>), que podem ser de qualquer tipo
imutável (como strings e inteiros). Tuplas também podem ser chaves se contiverem apenas strings, inteiros
ou outras tuplas. Se a tupla contiver, direta ou indiretamente, qualquer valor mutável não poderá ser
chave. Listas não podem ser usadas como chaves porque são mutáveis.</p>
<p>O melhor modelo mental de um dicionário é um conjunto não ordenado de pares chave-valor, onde as
chaves são únicas em uma dada instância do dicionário.</p>
<p>Dicionários são delimitados por : <code>{}</code>. Uma lista de pares <em>chave:valor</em> separada por
vírgulas dentro desse delimitadores define a constituição inicial do dicionário. Dessa forma
também será impresso o conteúdo de um dicionário em uma seção de
depuração.</p>
<p>As principais operações em um dicionário são armazenar e recuperar valores a partir de chaves.
Também é possível remover um par <em>chave:valor</em> com o comando <code>del</code>. Se você
armazenar um valor utilizando uma chave já presente, o antigo valor será substituído pelo novo. Se
tentar recuperar um valor dada uma chave inexistente será gerado um erro.</p>
<p>O método <tt class="method">keys()</tt> do dicionário retorna a lista de todas as chaves presentes no
dicionário, em ordem arbitrária (se desejar ordená-las basta aplicar o método <tt class=
"method">sort()</tt> na lista devolvida). Para verificar a existência de uma chave, utilize o método
<tt class="method">has_key()</tt> do dicionário ou a keyword <tt class="keyword">in</tt>.</p>
<p>A seguir, um exemplo de uso do dicionário:</p>
<div class="verbatim">
<pre>
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> tel.has_key('guido')
True
>>> 'guido' in tel
True
</pre>
</div>
<p>A construtora <tt class="function">dict()</tt> produz dicionários diretamente a partir de uma lista de
chaves-valores, armazenadas como tuplas. Quando os pares formam um padrão, <em>list comprehensions</em> podem
especificar a lista de chaves-valores de forma mais compacta.</p>
<div class="verbatim">
<pre>
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
>>> dict([(x, x**2) for x in (2, 4, 6)]) # use a list comprehension
{2: 4, 4: 16, 6: 36}
</pre>
</div>
<p>Mais adiante no tutorial aprenderemos sobre Geradores, que são ainda mais adequados para fornecer os pares
chave-valor para <tt class="function">dict()</tt>.</p>
<p>Quando chaves são apenas strings, é mais fácil especificar os pares usando argumentos
chave-valor:</p>
<div class="verbatim">
<pre>
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
</pre>
</div>
<h1> 5.6 Técnicas de Laço</h1>
<p>Ao percorrer um dicionário com um laço, a chave e o valor correspondente podem ser obtidos
simultaneamente com o método <tt class="method">iteritems()</tt>.</p>
<div class="verbatim">
<pre>
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.iteritems():
... print k, v
...
gallahad the pure
robin the brave
</pre>
</div>
<p>Ao percorrer uma sequência qualquer, o índice da posição atual e o valor correspondente podem
ser obtidos simultaneamente usando a função <tt class="function">enumerate()</tt>.</p>
<div class="verbatim">
<pre>
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print i, v
...
0 tic
1 tac
2 toe
</pre>
</div>
<p>Para percorrer duas ou mais sequências simultaneamente com o laço, os items podem ser agrupados com a
função <tt class="function">zip()</tt>.</p>
<div class="verbatim">
<pre>
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print 'What is your %s? It is %s.' % (q, a)
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
</pre>
</div>
<p>Para percorrer uma sequência em ordem reversa, chame a função <tt class="function">reversed()</tt>
com a sequência na ordem original.</p>
<div class="verbatim">
<pre>
>>> for i in reversed(xrange(1,10,2)):
... print i
...
9
7
5
3
1
</pre>
</div>
<p>Para percorrer uma sequência de maneira ordenada, use a função <tt class="function">sorted()</tt>,
que retorna uma lista ordenada com os items, mantendo o original inalterado.</p>
<div class="verbatim">
<pre>
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print f
...
apple
banana
orange
pear
</pre>
</div>
<h1> 5.7 Mais sobre Condições</h1>
<p>As condições de controle utilizadas no <code>while</code> e <code>if</code> podem conter quaisquer
operadores, não apenas comparações.</p>
<p>Os operadores de comparação <code>in</code> e <code>not in</code> verificam se um valor ocorre (ou
não ocorre) em uma dada sequência. Os operadores <code>is</code> e <code>is not</code> comparam se dois
objetos são na verdade o mesmo objetos; o que só é significativo no contexto de objetos mutáveis,
como listas. Todos operadores de comparação possuem a mesma precedência, que é menor do que a
prioridade dos operadores numéricos.</p>
<p>Comparações podem ser encadeadas: Por exemplo <code>a < b == c</code> testa se <code>a</code> é
menor que <code>b</code> e ainda por cima se <code>b</code> é igual a <code>c</code>.</p>
<p>Comparações podem ser combinadas através de operadores booleanos <code>and</code> e
<code>or</code>, e negados através de <code>not</code>. Estes possuem menor prioridade que os demais operadores
de comparação. Entre eles, <code>not</code> é o de maior prioridade e <code>or</code> o de menor.
Dessa forma, a condição <code>A and not B or C</code> é equivalente a <code>(A and (not B)) or
C</code>. Naturalmente, parênteses podem ser usados para expressar o agrupamento desejado.</p>
<p>Os operadores booleanos <code>and</code> and <code>or</code> são também operadores <em>atalhos</em> :
seus argumentos são avaliados da esquerda para a direita, e a avaliação pára quando o resultado
se torna conhecido. Por exemplo, se <code>A</code> e <code>C</code> são verdadeiros mas <code>B</code> é
falso, então <code>A and B and C</code> não retorna a expressão <code>C</code>. Em geral, quando usado
sobre valores genéricos e não como booleanos, o valor de retorno de um operador atalho é o último
valor avaliado na expressão.</p>
<p>É possível atribuir o resultado de uma comparação ou outra expressão booleana para uma
variável. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
</pre>
</div>
<p>Observe que em Python, diferentemente de C, atribuição não pode ocorrer dentro de uma
expressão. Programadores C podem resmungar, mas isso evita toda uma classe de problemas frequentemente
encontrados em programas C: digitar <code>=</code> numa expressão quando a intenção era
<code>==</code>.</p>
<h1> 5.8 Comparando Sequências e Outros Tipos</h1>
<p>Objetos sequência podem ser comparados com outros objetos sequência, desde que o tipo das
sequências seja o mesmo. A comparação utiliza a ordem <em>léxicografica</em> : primeiramente os
dois primeiros itens são comparados, e se diferirem isto determinará o resultado da comparação,
caso contrário os próximos dois itens serão comparados, e assim por diante até que se tenha
exaurido alguma das sequências. Se em uma comparação de itens, os mesmos forem também
sequências (aninhadas), então é disparada recursivamente outra comparação
léxicografica. Se todos os itens da sequência forem iguais, então as sequências são ditas
iguais. Se uma das sequências é uma subsequência da outra, então a subsequência é a
menor (operador <). A comparação lexicográfica utiliza ASCII para definir a ordenação.
Alguns exemplos de comparações entre sequências do mesmo tipo:</p>
<div class="verbatim">
<pre>
(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
</pre>
</div>
<p>Observe que é permitido comparar objetos de diferentes tipos. O resultado é determinístico,
porém, arbitrário: os tipos são ordenados pelos seus nomes. Então, uma lista é sempre menor
do que uma string, uma string é sempre menor do que uma tupla, etc. <a name="tex2html3" href=
"#foot755"><sup>5.1</sup></a>Tipos numéricos mistos são comparados de acordo com seus valores
numéricos, logo 0 é igual a 0.0, etc.</p>
<h1> 6. Módulos</h1>
<p>Se você sair do interpretador Python e entrar novamente, todas as definições de funções e
variáveis serão perdidas. Logo, se você desejar escrever um programa que dure é melhor preparar o
código em um editor de textos. Quando estiver pronto, dispare o interpretador sobre o arquivo-fonte gerado. Isto
se chama gerar um <em>script</em>.</p>
<p>A medida que seus programas crescem, pode ser desejável dividi-los em vários arquivos para facilitar a
manutenção. Talvez você até queira reutilizar uma função sem copiar sua
definição a cada novo programa.</p>
<p>Para permitir isto, Python possui uma maneira de depositar definições em um arquivo e posteriormente
reutilizá-las em um script ou seção interativa do interpretador. Esse arquivo é denominado
módulo. Definições de um módulo podem ser importadas por outros módulos ou no módulo
principal.</p>
<p>Um módulo é um arquivo contendo definições e comandos Python. O nome do arquivo recebe o
sufixo <span class="file">.py</span>. Dentro de um módulo, seu nome (uma string) está disponível na
variável global <code>__name__</code>. Por exemplo, use seu editor de textos favorito para criar um arquivo
chamado <span class="file">fibo.py</span> no diretório corrente com o seguinte conteúdo:</p>
<div class="verbatim">
<pre>
# Módulo Sequências de Fibonacci
def fib(n): # write Fibonacci series up to n
a, b = 0, 1
while b < n:
print b,
a, b = b, a+b
def fib2(n): # return Fibonacci series up to n
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a+b
return result
</pre>
</div>
<p>Agora inicie o interpretador e importe o módulo da seguinte forma:</p>
<div class="verbatim">
<pre>
>>> import fibo
</pre>
</div>
<p>Isso não incorpora as funções definidas em <code>fibo</code> diretamente na tabela de símbolos
corrente, apenas coloca o nome do módulo lá. Através do nome do módulo você pode acessar as
funções:</p>
<div class="verbatim">
<pre>
>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
</pre>
</div>
<p>Se você pretende utilizar uma função frequentemente, é possível atribuir a ela um nome
local:</p>
<div class="verbatim">
<pre>
>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
</pre>
</div>
<h1> 6.1 Mais sobre Módulos</h1>
<p>Um módulo pode conter tanto comandos como definições. Os comandos servem ao propósito de
inicializar o módulo, sendo executados apenas na primeira vez em que o mesmo é importado.<a name=
"tex2html4" href="#foot771"><sup>6.1</sup></a></p>
<p>Cada módulo possui sua própria tabela de símbolos, que é usada como tabela de símbolos
global por todas as funções definidas no próprio módulo. Portanto, o autor do módulo pode
utilizar variáveis globais no módulo sem se preocupar com colisão de nomes acidental com as
variáveis globais de usuário.</p>
<p>Por outro lado, se você sabe o que está fazendo, é possível o acesso as variáveis globais
do módulo através da mesma notação. O que permite o acesso às funções do
módulo: <code>modname.itemname</code>.</p>
<p>Módulos podem ser importados por outros módulos. É costume, porém não obrigatório,
colocar todos os comandos de importação (<tt class="keyword">import</tt>) no início do módulo (ou
script, se preferir).</p>
<p>Existe uma variante do comando <tt class="keyword">import</tt> statement que importa nomes de um dado módulo
diretamente para a tabela do módulo importador. Os nomes do módulo importado são adicionados a tabela
de símbolos global do módulo importador. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
</pre>
</div>
<p>Isso não introduz o nome do módulo importado na tabela de símbolos local, mas sim o nome da
função diretamente.</p>
<p>Existe ainda uma variante que permite importar diretamente todos os nomes definidos em um dado módulo.</p>
<div class="verbatim">
<pre>
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
</pre>
</div>
<p>Isso importa todos os nomes exceto aqueles iniciados por um sublinhado (<code>_</code>).</p>
<h2> 6.1.1 O Caminho de Busca dos Módulos</h2>
<p><a id='l2h-17' xml:id='l2h-17'></a> Quando um módulo denominado <tt class="module">spam</tt> é
importado, o interpretador busca por um arquivo chamado <span class="file">spam.py</span> no diretório corrente,
depois na lista de diretórios especificados pela variável de ambiente <a class="envvar" id='l2h-18' xml:id=
'l2h-18'>PYTHONPATH</a>. Esta última possui a mesma sintaxe da variável de ambiente <a class="envvar" id=
'l2h-19' xml:id='l2h-19'>PATH</a>, isto é, uma lista de caminhos. Quando <a class="envvar" id='l2h-20' xml:id=
'l2h-20'>PYTHONPATH</a> não existir, ou o arquivo não for achado nesta lista, a busca continua num caminho
que depende da instalação. No caso do <span class="Unix">Unix</span> esse caminho é quase sempre
<span class="file">.:/usr/local/lib/python</span>.</p>
<p>De fato, módulos são buscados pela lista de caminhos especificados na variável
<code>sys.path</code> inicializada com os caminhos citados acima, o que permite aos programas Python manipularem o
processo de busca de módulos se desejado.</p>
<p>Note que devido ao fato do diretório contendo o script executado estar no caminho de busca, é importante
que o script não tenha o mesmo nome que um módulo da biblioteca padrão, ou Python vai tentar carregar
o script como tal quando aquele módulo for importado. Na maior parte das vezes essa não é a
intenção e resultará em um erro. Veja a seção <a href=
"#standardModules">6.2</a>,``Módulos Padrão,'' para mais detalhes.</p>
<h2><a name="SECTION008120000000000000000">6.1.2 Arquivos Python ``Compilados''</a></h2>
<p>Um fator que agiliza a carga de programas curtos que utilizam muitos módulos padrão é a
existência de um arquivo com extensão <span class="file">.pyc</span> no mesmo diretório do fonte
<span class="file">.py</span>. O arquivo <span class="file">.pyc</span> contém uma versão
``byte-compilada'' do fonte <span class="file">.py</span>. A data de modificação de <span class=
"file">.py</span> é armazenada dentro do <span class="file">.pyc</span>, e verificada automaticamente antes da
utilização do último. Se não conferir, o arquivo <span class="file">.pyc</span> existente é
re-compilado a partir do <span class="file">.py</span> mais atual.</p>
<p>Normalmente, não é preciso fazer nada para gerar o arquivo <span class="file">.pyc</span>. Sempre que um
módulo <span class="file">.py</span> é compilado com sucesso, é feita uma tentativa de se escrever sua
versão compilada para o <span class="file">.pyc</span>. Não há geração de erro se essa
tentativa falha. Se por qualquer razão o arquivo compilado não é inteiramente escrito em disco, o
<span class="file">.pyc</span> resultante será reconhecido como inválido e, portanto, ignorado. O
conteúdo do <span class="file">.pyc</span> é independente de plataforma, assim um diretório de
módulos Python pode ser compartilhado por diferentes arquiteturas.</p>
<p>Algumas dicas dos experts:</p>
<ul>
<li>Quando o interpretador Python é invocado com a diretiva <b class="programopt">-O</b>, código
otimizado é gerado e armazenado em arquivos <span class="file">.pyo</span>. O otimizador corrente não faz
muita coisa, ele apenas remove construções <tt class="keyword">assert</tt> e instruções
<code>SET_LINENO</code>. Quando o <b class="programopt">-O</b> é utilizado, <em>todo</em> bytecode é
otimizado. Arquivos <code>.pyc</code> são ignorados e arquivos <code>.py</code> são compilados em
bytecode otimizado.</li>
<li>Passando dois flags <b class="programopt">-O</b> ao interpretador (<b class="programopt">-OO</b>) irá
forçar o compilador de bytecode a efetuar otimizações arriscadas que poderiam em casos raros
acarretar o mal funcionamento de programas. Presentemente, apenas strings <code>__doc__</code> são removidas
do bytecode, proporcionando arquivos <span class="file">.pyo</span> mais compactos. Uma vez que alguns programas
podem supor a existência das docstrings, é melhor você só se utilizar disto se tiver
segurança de que não acarretará nenhum efeito colateral negativo.</li>
<li>Um programa não executa mais rápido quando é lido de um arquivo <span class="file">.pyc</span>
ou de um <span class="file">.pyo</span> em comparação a quando é lido de um <span class=
"file">.py</span>. A única diferença é que nos dois primeiros casos o tempo de carga do programa
é menor.</li>
<li>Quando um script é executado diretamente a partir de seu nome da linha de comando, não são
geradas as formas compiladas deste script em arquivos <span class="file">.pyo</span> ou <span class=
"file">.pyc</span>. Portanto, o tempo de carga de um script pode ser melhorado se transportarmos a maioria de seu
código para um módulo e utilizarmos outro script apenas para o disparo. É possível disparar o
interpretador diretamente sobre arquivos compilados.</li>
<li>Na presença das formas compiladas (<span class="file">.pyc</span> e<span class="file">.pyo</span>) de um
script, não há necessidade da presença da forma textual(<span class="file">.py</span>). Isto é
útil na hora de se distribuir bibliotecas Python dificultando práticas de engenharia reversa.</li>
<li>O módulo <a class="ulink" href="../lib/module-compileall.html"><tt class="module">compileall</tt></a>
<a id='l2h-21' xml:id='l2h-21'></a> pode criar arquivos <span class="file">.pyc</span> (ou <span class=
"file">.pyo</span> quando é usado <b class="programopt">-O</b>) para todos os módulos em um dado
diretório.</li>
</ul>
<h1> 6.2 Módulos Padrão</h1>
<p>Python possui um biblioteca padrão de módulos, descrita em um documento em separado, a <em class=
"citetitle"><a href="../lib/lib.html" title="Python Library Reference">Python Library Reference</a></em> (doravante
``Library Reference''). Alguns módulos estão embutidos no interpretador; estes possibilitam acesso a
operações que não são parte do núcleo da linguagem, seja por eficiência ou para
permitir o acesso a chamadas de sistema. O conjunto presente destes módulos é configurável, por
exemplo, o módulo <tt class="module">amoeba</tt> só está disponível em sistemas que suportam as
primitivas do Amoeba. Existe um módulo que requer especial atenção: <a class="ulink" href=
"../lib/module-sys.html"><tt class="module">sys</tt></a><a id='l2h-22' xml:id='l2h-22'></a>, que é embutido em
qualquer interpretador Python. As variáveis <code>sys.ps1</code> e <code>sys.ps2</code> definem as strings
utilizadas como prompt primário e secundário:</p>
<div class="verbatim">
<pre>
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print 'Yuck!'
Yuck!
C>
</pre>
</div>
<p>Essas variáveis só estão definidas se o interpretador está em modo interativo.</p>
<p>A variável <code>sys.path</code> contém uma lista de strings que determina os caminhos de busca de
módulos conhecidos pelo interpretador. Ela é inicializada para um caminho default determinado pela
variável de ambiente <a class="envvar" id='l2h-23' xml:id='l2h-23'>PYTHONPATH</a> ou por um valor default
interno se a variável não estiver definida. Você pode modificá-la utilizando as
operações típicas de lista, por exemplo:</p>
<div class="verbatim">
<pre>
>>> import sys
>>> sys.path.append('/ufs/guido/lib/python')
</pre>
</div>
<h1> 6.3 A Função <tt class="function">dir()</tt></h1>
<p>A função interna <tt class="function">dir()</tt> é utilizada para se descobrir que nomes são
definidos por um módulo. Ela retorna uma lista ordenada de strings:</p>
<div class="verbatim">
<pre>
>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__',
'__stdin__', '__stdout__', '_getframe', 'api_version', 'argv',
'builtin_module_names', 'byteorder', 'callstats', 'copyright',
'displayhook', 'exc_clear', 'exc_info', 'exc_type', 'excepthook',
'exec_prefix', 'executable', 'exit', 'getdefaultencoding', 'getdlopenflags',
'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode',
'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache',
'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdlopenflags',
'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',
'version', 'version_info', 'warnoptions']
</pre>
</div>
<p>Sem nenhum argumento, <tt class="function">dir()</tt> lista os nomes atualmente definidos:</p>
<div class="verbatim">
<pre>
>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir()
['__builtins__', '__doc__', '__file__', '__name__', 'a', 'fib', 'fibo', 'sys']
</pre>
</div>
<p>Observe que ela lista nomes dos mais diversos tipos: variáveis, módulos, funções, etc.</p>
<p><tt class="function">dir()</tt> não lista nomes de funções ou variáveis internas. Se você
desejar conhecê-los, eles estão definidos no módulo padrão <tt class=
"module">__builtin__</tt><a id='l2h-24' xml:id='l2h-24'></a>:</p>
<div class="verbatim">
<pre>
>>> import __builtin__
>>> dir(__builtin__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning',
'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
'FloatingPointError', 'FutureWarning', 'IOError', 'ImportError',
'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
'NotImplementedError', 'OSError', 'OverflowError', 'OverflowWarning',
'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',
'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError',
'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True',
'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',
'UserWarning', 'ValueError', 'Warning', 'WindowsError',
'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__',
'__name__', 'abs', 'apply', 'basestring', 'bool', 'buffer',
'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile',
'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float',
'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter',
'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'min',
'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range',
'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set',
'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
</pre>
</div>
<h1> 6.4 Pacotes</h1>
<p>Pacotes são uma maneira de estruturar espaços de nomes para módulos utilizando a sintaxe de
``separação por ponto''. Como exemplo, o módulo <tt class="module">A.B</tt> designa um sub-módulo
chamado "<tt class="samp">B</tt>" num pacote denominado "<tt class="samp">A</tt>". O uso de pacotes permite aos
autores de grupos de módulos (como NumPy ou PIL) não terem que se preocupar com colisão entre os nomes
de seus módulos e os nomes de módulos de outros autores.</p>
<p>Suponha que você deseje projetar uma coleção de módulos (um ``pacote'') para o gerenciamento
uniforme de arquivos de som. Existem muitos formatos diferentes (normalmente identificados pela extensão do nome
de arquivo, por exemplo. <span class="file">.wav</span>, <span class="file">.aiff</span>, <span class=
"file">.au</span>), de forma que você pode precisar criar e manter uma crescente coleção de
módulos de conversão entre formatos. Ainda podem existir muitas operações diferentes
passíveis de aplicação sobre os arquivos de som (mixagem, eco, equalização, efeito stereo
artificial). Logo, possivelmente você também estará escrevendo uma interminável coleção
de módulos para aplicar estas operações.</p>
<p>Aqui está uma possível estrutura para o seu pacote (expressa em termos de um sistema hierárquico de
arquivos):</p>
<div class="verbatim">
<pre>
Sound/ Top-level package
__init__.py Initialize the sound package
Formats/ Subpackage for file format conversions
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
Effects/ Subpackage for sound effects
__init__.py
echo.py
surround.py
reverse.py
...
Filters/ Subpackage for filters
__init__.py
equalizer.py
vocoder.py
karaoke.py
...
</pre>
</div>
<p>Ao importar esse pacote, Python busca pelo subdiretório com mesmo nome nos diretórios listados em
<code>sys.path</code>.</p>
<p>Os arquivos <span class="file">__init__.py</span> são necessários para que Python trate os
diretórios como um conjunto de módulos. Isso foi feito para evitar diretórios com nomes comuns, como
"<tt class="samp">string</tt>", de inadvertidamente esconder módulos válidos que ocorram a posteriori no
caminho de busca. No caso mais simples, <span class="file">__init__.py</span> pode ser um arquivo vazio. Porém,
ele pode conter código de inicialização para o pacote ou gerar a variável <code>__all__</code>,
que será descrita depois.</p>
<p>Usuários do pacote podem importar módulos individuais, por exemplo:</p>
<div class="verbatim">
<pre>
import Sound.Effects.echo
</pre>
</div>
<p>Assim se carrega um sub-módulo <tt class="module">Sound.Effects.echo</tt>. Ele deve ser referenciado com seu
nome completo, como em:</p>
<div class="verbatim">
<pre>
Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4)
</pre>
</div>
<p>Uma alternativa para a importação é:</p>
<div class="verbatim">
<pre>
from Sound.Effects import echo
</pre>
</div>
<p>Assim se carrega o módulo sem necessidade de prefixação na hora do uso. Logo, pode ser utilizado
como se segue:</p>
<div class="verbatim">
<pre>
echo.echofilter(input, output, delay=0.7, atten=4)
</pre>
</div>
<p>Também é possível importar diretamente uma única variável ou função, como
em:</p>
<div class="verbatim">
<pre>
from Sound.Effects.echo import echofilter
</pre>
</div>
<p>Novamente, há carga do sub-módulo <tt class="module">echo</tt>, mas a função <tt class=
"function">echofilter()</tt> está acessível diretamente sem prefixação:</p>
<div class="verbatim">
<pre>
echofilter(input, output, delay=0.7, atten=4)
</pre>
</div>
<p>Observe que ao utilizar <code>from <var>package</var> import <var>item</var></code>, o item pode ser um
sub-pacote, sub-módulo, classe, função ou variável. O comando <code>import</code> primeiro testa
se o item está definido no pacote, senão assume que é um módulo e tenta carregá-lo. Se
falhar em encontrar o módulo uma exceção <tt class="exception">ImportError</tt> é levantada.</p>
<p>Em oposição, na construção <code>import <var>item.subitem.subsubitem</var></code>, cada item,
com exceção do último, deve ser um pacote. O último pode ser também um pacote ou
módulo, mas nunca uma entidade contida em um módulo.</p>
<h2> 6.4.1 Importando * de Um Pacote</h2>
<p><a id='l2h-25' xml:id='l2h-25'></a> Agora, o que acontece quando um usuário escreve <code>from Sound.Effects
import *</code> ? Idealmente, poderia se esperar que todos sub-módulos presentes no pacote fossem importados.
Infelizmente, essa operação não funciona muito bem nas plataformas Mac ou Windows, onde não
existe distinção entre maiúsculas ou minúsculas nos sistema de arquivos. Nestas plataformas
não há como saber como importar o arquivo <span class="file">ECHO.PY</span>, deveria ser com o nome
<tt class="module">echo</tt>, <tt class="module">Echo</tt> ou <tt class="module">ECHO</tt> (por exemplo, o Windows 95
tem o irritante hábito de colocar a primeira letra em maiúscula). A restrição de nomes de arquivo
em DOS com o formato 8+3 adiciona um outro problema na hora de se utilizar arquivos com nomes longos.</p>
<p>A única solução é o autor do pacote fornecer um índice explícito do pacote. O
comando de importação utiliza a seguinte convenção: se o arquivo <span class=
"file">__init__.py</span> do pacote define a lista chamada <code>__all__</code>, então esta lista indica os
nomes dos módulos a serem importados quando o comando <code>from <var>package</var> import *</code> é
encontrado.</p>
<p>Fica a cargo do autor do pacote manter esta lista atualizada, inclusive fica a seu critério excluir
inteiramente o suporte a importação direta de todo o pacote através do <code>from <var>package</var>
import *</code>. Por exemplo, o arquivo <span class="file">Sounds/Effects/__init__.py</span> poderia conter
apenas:</p>
<div class="verbatim">
<pre>
__all__ = ["echo", "surround", "reverse"]
</pre>
</div>
<p>Isso significaria que <code>from Sound.Effects import *</code> iria importar apenas os três sub-módulos
especificados no pacote <tt class="module">Sound</tt>.</p>
<p>Se <code>__all__</code> não estiver definido, o comando <code>from Sound.Effects import *</code> não
importará todos os sub-módulos do pacote <tt class="module">Sound.Effects</tt> no espaço de nomes
corrente. Há apenas garantia que o pacote <tt class="module">Sound.Effects</tt> foi importado (possivelmente
executando qualquer código de inicialização em <span class="file">__init__.py</span>) juntamente com
os nomes definidos no pacote. Isso inclui todo nome definido em <span class="file">__init__.py</span> bem como em
qualquer sub-módulo importado a partir deste. Considere o código abaixo:</p>
<div class="verbatim">
<pre>
import Sound.Effects.echo
import Sound.Effects.surround
from Sound.Effects import *
</pre>
</div>
<p>Neste exemplo, os módulos <em>echo</em> e <em>surround</em> são importados no espaço de nomes
corrente, pois estão definidos no pacote <tt class="module">Sound.Effects</tt>. O que também funciona
quando <code>__all__</code> estiver definida.</p>
<p>Em geral, a prática de importar <code>*</code> de um dado módulo é desaconselhada, principalmente
por prejudicar a legibilidade do código. Contudo, é recomendada em sessões interativas para evitar
excesso de digitação.</p>
<p>Lembre-se que não há nada de errado em utilizar <code>from Package import specific_submodule</code>! De
fato, essa é a notação recomendada a menos que o módulo efetuando a importação precise
utilizar sub-módulos homônimos em diferentes pacotes.</p>
<h2><a name="SECTION008420000000000000000">6.4.2 Referências em Um Mesmo Pacote</a></h2>
<p>Os sub-módulos frequentemente precisam referenciar uns aos outros. Por exemplo, o módulo <tt class=
"module">surround</tt> talvez precise utilizar o módulo <tt class="module">echo</tt>. De fato, tais
referências são tão comuns que o comando <tt class="keyword">import</tt> primeiro busca módulos
dentro do pacote antes de utilizar o caminho de busca padrão. Portanto, o módulo <tt class=
"module">surround</tt> pode usar simplesmente <code>import echo</code> ou <code>from echo import echofilter</code>.
Se o módulo importado não for encontrado no pacote corrente (o pacote do qual o módulo corrente é
sub-módulo), então o comando <tt class="keyword">import</tt> procura por um módulo de mesmo nome no
escopo global.</p>
<p>Quando pacotes são estruturados em sub-pacotes (como no exemplo <tt class="module">Sound</tt>), não
existe atalho para referenciar sub-módulos de pacotes irmãos - o nome completo do pacote deve ser
utilizado. Por exemplo, se o módulo <tt class="module">Sound.Filters.vocoder</tt> precisa utilizar o módulo
<tt class="module">echo</tt> no pacote <tt class="module">Sound.Effects</tt>, é preciso importá-lo como
<code>from Sound.Effects import echo</code>.</p>
<h2><a name="SECTION008430000000000000000">6.4.3 Packages in Multiple Directories</a></h2>
<p>Pacotes suportam mais um atributo especiai, <tt class="member">__path__</tt>. Este é inicializado como uma
lista contendo o nome do diretório com o arquivo <span class="file">__init__.py</span> do pacote, antes do
código naquele arquivo ser executado. Esta variável pode ser modificada; isso afeta a busca futura de
módulos e subpacotes contidos no pacote.</p>
<p>Apesar de não ser muito usado, pode ser usado para extender o conjunto de módulos usado num pacote.</p>
<h1> 7. Entrada e Saída</h1>
<p>Existem diversas maneiras de se apresentar a saída de um programa. Dados podem ser impressos em forma
imediatamente legível, ou escritos em um arquivo para uso futuro. Este capítulo vai discutir algumas das
possibilidades.</p>
<h1> 7.1 Refinando a Formatação de Saída</h1>
<p>Até agora nós encontramos duas maneiras de escrever valores: através de <em>expressões</em> e
pelo comando <tt class="keyword">print</tt> (uma terceira maneira é utilizar o método <tt class=
"method">write()</tt> de objetos de arquivo; a saída padrão pode ser referenciada como
<code>sys.stdout</code>). Veja o documento <em>Library Reference</em> para mais informações sobre este
tópico.</p>
<p>Frequentemente você desejará mais controle sobre a formatação de saída do que
simplesmente imprimindo valores separados por espaços. Existem duas formas. A primeira é você mesmo
manipular a string através de recortes (<em>slicing</em>) e concatenação. O módulo padrão
<tt class="module">string</tt><a id='l2h-26' xml:id='l2h-26'></a> contém algumas rotinas úteis a esta
finalidade. A segunda maneira é utilizar o operador <code>%</code>.</p>
<p>O operador <code>%</code> interpreta seu argumento à esquerda como uma string de formatação de um
<tt class="cfunction">sprintf()</tt> aplicada ao argumento à direita do operador. O resultado é uma string
formatada.</p>
<p>Permanece a questão: como converter valores para strings? Por sorte, Python possui maneiras de converter
qualquer valor para uma string: basta submetê-lo a função <tt class="function">repr()</tt> ou
<tt class="function">str()</tt>. Aspas reversas (<code>``</code>) são equivalentes a <tt class=
"function">repr()</tt>, mas não são mais usadas com frequência e provavelmente serão retiradas de
futuras versões da linguagem.</p>
<div class="verbatim">
<pre>
>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(0.1)
'0.1'
>>> repr(0.1)
'0.10000000000000001'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print s
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print hellos
'hello, world\n'
>>> # The argument to repr() may be any Python object:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
>>> # reverse quotes are convenient in interactive sessions:
... `x, y, ('spam', 'eggs')`
"(32.5, 40000, ('spam', 'eggs'))"
</pre>
</div>
<p>A seguir, duas maneiras de se escrever uma tabela de quadrados e cubos:</p>
<div class="verbatim">
<pre>
>>> for x in range(1, 11):
... print repr(x).rjust(2), repr(x*x).rjust(3),
... # Observe a vírgula final na linha anterior
... print repr(x*x*x).rjust(4)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> for x in range(1,11):
... print '%2d %3d %4d' % (x, x*x, x*x*x)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
</pre>
</div>
<p>Note que os espaços adicionados entre as colunas se devem a forma de funcionamento do comando <tt class=
"keyword">print</tt> : ele sempre adiciona espaço entre seus argumentos.</p>
<p>Este exemplo demonstra o método <tt class="method">rjust()</tt> de strings, que justifica uma string à
direita gerando espaços adicionais à esquerda. Existem métodos análogas <tt class=
"method">ljust()</tt> e <tt class="method">center()</tt>. Esses métodos apenas retornam a string formatada. Se a
entrada extrapolar o comprimento exigido a string original é devolvida sem modificação. A razão
para isso é não apresentar um valor potencialmente corrompido por truncamento (se for desejado truncar o
valor pode-se utilizar operações de recorte como em "<tt class="samp">x.ljust(n)[0:n]</tt>").</p>
<p>Existe ainda o método <tt class="method">zfill()</tt> que preenche uma string numérica com zeros à
esquerda. Ele entende sinais positivos e negativos.</p>
<div class="verbatim">
<pre>
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
</pre>
</div>
<p>Um exemplo de uso do operador <code>%</code>:</p>
<div class="verbatim">
<pre>
>>> import math
>>> print 'The value of PI is approximately %5.3f.' % math.pi
The value of PI is approximately 3.142.
</pre>
</div>
<p>Se há mais do que um formato, então o argumento à direita deve ser uma tupla com os valores de
formatação. Exemplo:</p>
<div class="verbatim">
<pre>
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
... print '%-10s ==> %10d' % (name, phone)
...
Jack ==> 4098
Dcab ==> 7678
Sjoerd ==> 4127
</pre>
</div>
<p>A maioria dos formatos funciona da mesma maneira que em C, e exigem que você passe o tipo apropriado.
Entretanto, em caso de erro ocorre uma exceção e não uma falha do sistema operacional. O formato
<code>%s</code> é mais relaxado: se o argumento correspondente não for um objeto string, então ele
é convertido para string pela função interna <tt class="function">str()</tt>.</p>
<p>Há suporte para o modificador <code>*</code> determinar o comprimento ou precisão num argumento inteiro
em separado. Os formatadores (em C) <code>%n</code> e <code>%p</code> também são suportados.</p>
<p>Se você possuir uma string de formatação muito longa, seria bom referenciar as variáveis de
formatação <em>por nome</em>, ao invés de <em>por posição</em>. Isso pode ser obtido
passando um dicionário como argumento à direita e prefixando campos na string de formatação com
<code>%(name)format</code>. Veja o exermplo:</p>
<div class="verbatim">
<pre>
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d' % table
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
</pre>
</div>
<p>Isso é particularmente útil em combinação com a nova função interna <tt class=
"function">vars()</tt>, que retorna um dicionário contendo todas as variáveis locais.</p>
<h1> 7.2 Leitura e Escrita de Arquivos</h1>
<p>A função <tt class="function">open()</tt><a id='l2h-27' xml:id='l2h-27'></a> retorna um objeto de
arquivo<a id='l2h-28' xml:id='l2h-28'></a>, e é frequentemente usada com dois argumentos: "<tt class=
"samp">open(<var>filename</var>, <var>mode</var>)</tt>".</p>
<div class="verbatim">
<pre>
>>> f=open('/tmp/workfile', 'w')
>>> print f
<open file '/tmp/workfile', mode 'w' at 80a0960>
</pre>
</div>
<p>O primeiro argumento é uma string contendo o nome do arquivo. O segundo argumento é outra string
contendo alguns caracteres que descrevem o modo como o arquivo será usado. O parâmetro <var>mode</var> pode
assumir valor <code>'r'</code> quando o arquivo será só de leitura, <code>'w'</code> quando for só de
escrita (se o arquivo já existir seu conteúdo prévio será apagado), e <code>'a'</code> para abrir
o arquivo para adição; qualquer escrita será adicionada ao final do arquivo. A opção
<code>'r+'</code> abre o arquivo tanto para leitura como para escrita. O parâmetro <var>mode</var> é
opcional, em caso de omissão será assumido <code>'r'</code>.</p>
<p>No Windows e no Macintosh, <code>'b'</code> adicionado a string de modo indica que o arquivo será aberto no
formato binário. Sendo assim, existem os modos compostos : <code>'rb'</code>, <code>'wb'</code>, e
<code>'r+b'</code>. O Windows faz distinção entre arquivos texto e binários: os caracteres
terminadores de linha em arquivos texto são levemente alterados em leituras e escritas. Essa mudança
por-trás-do-pano é útil em arquivos texto ASCII, mas irá corromper um arquivo binário como
no caso de arquivos <span class="file">JPEG</span> ou <span class="file">EXE</span>. Seja muito cuidadoso em usar o
modo binário ao manipular tais arquivos.</p>
<h2> 7.2.1 Métodos de Objetos de Arquivos</h2>
<p>A título de simplificação, o resto dos exemplos nesta seção irá assumir que o objeto
de arquivo chamado <code>f</code> já foi criado.</p>
<p>Para ler o conteúdo de um arquivo chame <code>f.read(<var>size</var>)</code>, que lê um punhado de dados
retornando-os como string. O argumento numérico <var>size</var> é opcional. Quando <var>size</var> for
omitido ou negativo, todo o conteúdo do arquivo será lido e retornado. É problema seu se o
conteúdo do arquivo é o dobro da memória disponível na máquina. Caso contrário, no
máximo <var>size</var> bytes serão lidos e retornados. Se o fim do arquivo for atingido,
<code>f.read()</code> irá retornar uma string vazia (<code>''</code>).</p>
<div class="verbatim">
<pre>
>>> f.read()
'Esse é todo o conteúdo do arquivo.\n'
>>> f.read()
''
</pre>
</div>
<p><code>f.readline()</code> lê uma única linha do arquivo. O caracter de retorno de linha
(<code>\n</code>) é deixado ao final da string, só sendo omitido na última linha do arquivo se ele
já não estiver presente lá. Isso elimina a ambiguidade no valor de retorno. Se
<code>f.readline()</code> retornar uma string vazia, então o arquivo acabou. Linhas em branco são
representadas por <code>'\n'</code>: uma string contendo unicamente o terminador de linha.</p>
<div class="verbatim">
<pre>
>>> f.readline()
'Essa é a primeira linha do arquivo.\n'
>>> f.readline()
'Segunda linha do arquivo\n'
>>> f.readline()
''
</pre>
</div>
<p><code>f.readlines()</code> retorna uma lista contendo todas as linhas do arquivo. Se for fornecido o
parâmetro opcional <var>sizehint</var>, será lida a quantidade especificada de bytes e mais o suficiente
para completar uma linha. Frequentemente, esta operação é utilizada para ler arquivos muito grandes
sem ter que ler todo o arquivo para a memória de uma só vez. Apenas linhas completas serão
retornadas.</p>
<div class="verbatim">
<pre>
>>> f.readlines()
['Essa é a primeira linha do arquivo.\n', 'Segunda linha do arquivo\n']
</pre>
</div>
<p>Uma maneira alternativa de ler linhas do arquivo é usando um laço diretamente com o objeto arquivo.
É mais eficiente, rápido e resulta em código mais simples:</p>
<div class="verbatim">
<pre>
>>> for line in f:
print line,
Esta é a primeira linha do arquivo.
Segunda linha do arquivo.
</pre>
</div>
<p>Essa alternativa é bem mais simples, mas não oferece tanto controle. Como as duas alternativas são
um pouco diferentes internamente, no gerenciamento de <em>buffers</em>, elas não devem ser misturadas.</p>
<p><code>f.write(<var>string</var>)</code> escreve o conteúdo da <var>string</var> para o arquivo, retornando
<code>None</code>.</p>
<div class="verbatim">
<pre>
>>> f.write('Isso é um teste.\n')
</pre>
</div>
<p>Ao escrever algo que não seja uma string, é necessário convertê-lo antes:</p>
<div class="verbatim">
<pre>
>>> value = ('a resposta', 42)
>>> s = str(value)
>>> f.write(s)
</pre>
</div>
<p><code>f.tell()</code> retorna um inteiro que indica a posição corrente de leitura ou escrita no arquivo,
medida em bytes desde o início do arquivo. Para mudar a posição utilize "<tt class=
"samp">f.seek(<var>offset</var>, <var>from_what</var>)</tt>". A nova posição é computada pela soma do
<var>offset</var> a um ponto de referência, que por sua vez é definido pelo argumento <var>from_what</var>.
O argumento <var>from_what</var> pode assumir o valor 0 para indicar o início do arquivo, 1 para indicar a
posição corrente e 2 para indicar o fim do arquivo. Este parâmetro pode ser omitido, quando é
assumido o valor default 0.</p>
<div class="verbatim">
<pre>
>>> f = open('/tmp/workfile', 'r+')
>>> f.write('0123456789abcdef')
>>> f.seek(5) # Vai para o sexto byte
>>> f.read(1)
'5'
>>> f.seek(-3, 2) # Vai para o terceiro byte antes do fim
>>> f.read(1)
'd'
</pre>
</div>
<p>Quando acabar de utilizar o arquivo, chame <code>f.close()</code> para fechá-lo e liberar recursos. Qualquer
tentativa de acesso ao arquivo depois dele ter sido fechado implicará em falha.</p>
<div class="verbatim">
<pre>
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file
</pre>
</div>
<p>Objetos de arquivo podem ter métodos adicionais, tais como <tt class="method">isatty()</tt> e <tt class=
"method">truncate()</tt> que são usados com menos frequência, consulte a <em>Library Reference</em> para
obter maiores informações.</p>
<h2> 7.2.2 O Módulo <tt class="module">pickle</tt></h2><a id='l2h-29' xml:id='l2h-29'></a>
<p>Strings podem ser facilmente escritas e lidas de um arquivo. Números exigem um pouco mais de esforço,
uma vez que o método <tt class="method">read()</tt> só trabalha com strings. Portanto, pode ser utilizada a
função <tt class="function">int()</tt>, que recebe uma string <code>'123'</code> e a converte para o
respectivo valor inteiro. Entretanto, quando estruturas de dados mais complexas (listas, dicionários,
instâncias de classe,etc) estão envolvidas, o processo se torna mais complicado.</p>
<p>Para que não seja necessário que usuários estejam constantemente escrevendo e depurando código
que torna estruturas de dados persistentes, Python oferece o módulo padrão <a class="ulink" href=
"../lib/module-pickle.html"><tt class="module">pickle</tt></a>. Este módulo permite que praticamente qualquer
objeto Python (até mesmo código!) seja convertido para uma representação string. Este processo
é denominado <i class="dfn">pickling</i>. E <i class="dfn">unpickling</i> é o processo reverso de
reconstruir o objeto a partir de sua representação string. Enquanto estiver representado como uma string, o
objeto pode ser armazenado em arquivo, transferido pela rede, etc.</p>
<p>Se você possui um objeto qualquer <code>x</code>, e um objeto arquivo <code>f</code> que foi aberto para
escrita, a maneira mais simples de utilizar este módulo é:</p>
<div class="verbatim">
<pre>
pickle.dump(x, f)
</pre>
</div>
<p>Para desfazer, se <code>f</code> for agora um objeto de arquivo pronto para leitura:</p>
<div class="verbatim">
<pre>
x = pickle.load(f)
</pre>
</div>
<p>Existem outras variações desse processo úteis quando se precisa aplicar sobre muitos objetos ou o
destino da representação string não é um arquivo. Consulte a documentação para
<a class="ulink" href="../lib/module-pickle.html"><tt class="module">pickle</tt></a> na <em class=
"citetitle"><a href="../lib/" title="Referência da Biblioteca Python">Referência da Biblioteca
Python</a></em> para obter informações detalhadas.</p>
<p>Utilizar o módulo <a class="ulink" href="../lib/module-pickle.html"><tt class="module">pickle</tt></a> é
a forma padrão de tornar objetos Python persistentes, permitindo a reutilização dos mesmos entre
diferentes programas, ou pelo mesmo programa em diferentes sessões de utilização. A
representação string dos dados é tecnicamente chamada <i class="dfn">objeto persistente</i>, como
já foi visto. Justamente porque o módulo <a class="ulink" href="../lib/module-pickle.html"><tt class=
"module">pickle</tt></a> é amplamente utilizado, vários autores que escrevem extensões para Python
tomam o cuidado de garantir que novos tipos de dados sejam compatíveis com esse processo.</p>
<h1> 8. Erros e Exceções</h1>
<p>Até agora mensagens de erro foram apenas mencionadas, mas se você testou os exemplos, talvez tenha
esbarrado em algumas. Existem pelo menos dois tipos distintos de erros: <em>erros de sintaxe</em> e
<em>exceções</em>.</p>
<h1> 8.1 Erros de Sintaxe</h1>
<p>Erros de sintaxe, também conhecidos como erros de parse, são provavelmente os mais frequentes entre
aqueles que ainda estão aprendendo Python:</p>
<div class="verbatim">
<pre>
>>> while True print 'Hello world'
File "<stdin>", line 1, in ?
while True print 'Hello world'
^
SyntaxError: invalid syntax
</pre>
</div>
<p>O parser repete a linha inválida e apresenta uma pequena `flecha' apontando para o ponto da linha em que o
erro foi encontrado. O erro é detectado pelo token que precede a flecha. No exemplo, o erro foi detectado na
palavra-reservada <tt class="keyword">print</tt>, uma vez que o dois-pontos ("<tt class="character">:</tt>")
está faltando. Nome de arquivo e número de linha são impressos para que você possa rastrear o
erro no texto do script.</p>
<h1> 8.2 Exceções</h1>
<p>Mesmo que um comando ou expressão estejam sintaticamente corretos, talvez ocorra um erro na hora de sua
execução. Erros detectados durante a execução são chamados <em>exceções</em> e
não são necessariamente fatais. Logo veremos como tratá-las em programas Python. A maioria das
exceções não são tratadas e acabam resultando em mensagens de erro:</p>
<div class="verbatim">
<pre>
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: cannot concatenate 'str' and 'int' objects
</pre>
</div>
<p>A última linha da mensagem de erro indica o que aconteceu. Exceções surgem com diferentes tipos, e
o tipo é impresso como parte da mensagem . Os tipos no exemplo são: <tt class=
"exception">ZeroDivisionError</tt>, <tt class="exception">NameError</tt> e <tt class="exception">TypeError</tt>. A
string impressa como sendo o tipo da exceção é o nome interno da exceção que ocorreu. Isso
é verdade para todas exceções pré-definidas em Python, mas não é necessariamente
verdade para exceções definidas pelo usuário.</p>
<p>O resto da linha é um detalhamento que depende do tipo da exceção ocorrida e sua causa.</p>
<p>A parte anterior da mensagem de erro apresenta o contexto onde ocorreu a exceção. Essa
informação é denominada <em>stack traceback</em> (N.d.T: rastreamento da pilha para trás). Em
geral, contém uma lista de linhas do código fonte, sem apresentar, no entanto, valores lidos da entrada
padrão.</p>
<p>O documento <em class="citetitle"><a href="../lib/module-exceptions.html" title=
"Referência da Biblioteca Python">Referência da Biblioteca Python</a></em> lista as exceções
pré-definidas e seus significados.</p>
<h1> 8.3 Tratamento de Exceções</h1>
<p>É possível escrever programas que tratam exceções específicas. Observe o exemplo
seguinte, que pede dados ao usuário até que um inteiro válido seja fornecido, ainda permitindo que o
programa seja interrompido (utilizando <kbd>Control-C</kbd> ou seja lá o que for que o sistema operacional
suporte). Note que uma interrupção gerada pelo usuário será sinalizada pela exceção
<tt class="exception">KeyboardInterrupt</tt>.</p>
<div class="verbatim">
<pre>
>>> while True:
... try:
... x = int(raw_input("Entre com um número: "))
... break
... except ValueError:
... print "Opa! Esse número não é válido. Tente de novo..."
...
</pre>
</div>
<p>A construção <tt class="keyword">try</tt> funciona da seguinte maneira:</p>
<ul>
<li>Primeiramente, a cláusula <em>try</em> (o conjunto de comandos entre as palavras-reservadas <tt class=
"keyword">try</tt> e <tt class="keyword">except</tt> ) é executado.</li>
<li>Se não for gerada exceção, a cláusula <em>except</em> é ignorada e termina a
execução da construção <tt class="keyword">try</tt>.</li>
<li>Se uma execução ocorre durante a execução da cláusula <tt class="keyword">try</tt>, os
comandos remanescentes na cláusula são ignorados. Se o tipo da exceção ocorrida tiver sido
previsto junto àlguma palavra-reservada <tt class="keyword">except</tt>, então essa cláusula
será executada. Ao fim da cláusula também termina a execução do <tt class=
"keyword">try</tt> como um todo.</li>
<li>Se a exceção ocorrida não foi prevista em nenhum tratador <tt class="keyword">except</tt> da
construção <tt class="keyword">try</tt> em que ocorreu, então ela é entregue a uma
construção <tt class="keyword">try</tt> mais externa. Se não existir nenhum tratador previsto para
tal exceção (chamada <em>unhandled exception</em>), a execução encerra com uma mensagem de
erro.</li>
</ul>
<p>A construção <tt class="keyword">try</tt> pode ter mais de uma cláusula <tt class=
"keyword">except</tt> para especificar múltiplos tratadores para diferentes exceções. No máximo
um único tratador será ativado. Tratadores só são sensíveis as exceções levantadas
no interior da cláusula <tt class="keyword">try</tt>, e não que tenha ocorrido no inteiror de outro
tratador num mesmo <tt class="keyword">try</tt>. Um tratador pode ser sensível a múltiplas
exceções, desde que as especifique em uma tupla:</p>
<div class="verbatim">
<pre>
... except (RuntimeError, TypeError, NameError): ... pass
</pre>
</div>
<p>A última cláusula <tt class="keyword">except</tt> pode omitir o nome da exceção, servindo como
uma máscara genérica. Utilize esse recurso com extrema cautela, uma vez que isso pode esconder errors do
programador e do usuário. Também pode ser utilizado para imprimir uma mensagem de erro, ou re-levantar
(<em>re-raise</em>) a exceção de forma que um ``chamador'' também possa tratá-la.</p>
<div class="verbatim">
<pre>
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except IOError, (errno, strerror):
print "I/O error(%s): %s" % (errno, strerror)
except ValueError:
print "Could not convert data to an integer."
except:
print "Unexpected error:", sys.exc_info()[0]
raise
</pre>
</div>
<p>A construção <tt class="keyword">try</tt> ... <tt class="keyword">except</tt> possui uma cláusula
<em>else</em> opcional, que quando presente, deve ser colocada depois de todas as outras cláusulas. É
útil para um código que precisa ser executado se nenhuma exceção foi levantada. Por exemplo:</p>
<div class="verbatim">
<pre>
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print 'cannot open', arg
else:
print arg, 'has', len(f.readlines()), 'lines'
f.close()
</pre>
</div>
<p>Este recurso é melhor do que simplesmente adicionar o código do <tt class="keyword">else</tt> ao corpo
da cláusula <tt class="keyword">try</tt>, pois mantém as exceções levantadas no <tt class=
"keyword">else</tt> num escopo diferente de tratamento das exceções levantadas na cláusula <tt class=
"keyword">try</tt>.</p>
<p>Quando uma exceção ocorre, ela pode estar associada a um valor chamado <em>argumento</em> da
exceção. A presença e o tipo do argumento dependem do tipo da exceção.</p>
<p>A cláusula except pode especificar uma variável depois do nome (ou da tupla de nomas) exceção.
A variável é ligada à instância dela com os argumentos armazenados em <code>instance.args</code>.
Por conveniência, a instância define os métodos <tt class="method">__getitem__</tt> e <tt class=
"method">__str__</tt> para que os argumentos possam ser acessados sem necessidada de recorrer a
<code>.args</code>.</p>
<div class="verbatim">
<pre>
>>> try:
... raise Exception('spam', 'eggs')
... except Exception, inst:
... print type(inst) # the exception instance
... print inst.args # arguments stored in .args
... print inst # __str__ allows args to printed directly
... x, y = inst # __getitem__ allows args to be unpacked directly
... print 'x =', x
... print 'y =', y
...
<type 'instance'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs
</pre>
</div>
<p>Se uma exceção possui argumento, ele é impresso ao final do detalhamento de expressões
não tratadas (<em>unhandled exceptions</em>).</p>
<p>Além disso, tratadores de exceção são capazes de capturar exceções que tenham sido
levantadas no interior de funções invocadas na cláusula <tt class="keyword">try</tt>. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> def this_fails():
... x = 1/0
...
>>> try:
... this_fails()
... except ZeroDivisionError, detail:
... print 'Handling run-time error:', detail
...
Handling run-time error: integer division or modulo by zero
</pre>
</div>
<h1> 8.4 Levantando Exceções</h1>
<p>A palavra-reservada <tt class="keyword">raise</tt> permite ao programador forçar a ocorrência de um
determinado tipo de exceção. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> raise NameError, 'HiThere'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: HiThere
</pre>
</div>
<p>O primeiro argumento de <tt class="keyword">raise</tt> é o nome da exceção a ser levantada. O
segundo argumento, opcional, é o argumento da exceção. O código acima pode ser escrito como
<code>raise NameError('HiThere)</code>. Qualquer forma funciona bem, mas parece haver uma preferência crescente
pela última.</p>
<p>Caso você precise determinar se uma exceção foi levantada ou não, mas não quer manipular
o erro, uma forma simples de <tt class="keyword">raise</tt> permite que você levante-a novamente.</p>
<div class="verbatim">
<pre>
>>> try:
... raise NameError, 'HiThere'
... except NameError:
... print 'An exception flew by!'
... raise
...
An exception flew by!
Traceback (most recent call last):
File "<stdin>", line 2, in ?
NameError: HiThere
</pre>
</div>
<h1> 8.5 Exceções Definidas pelo Usuário</h1>
<p>Programas podem definir novos tipos de exceções, através da criação de uma nova classe.
Devem ser subclasses da classe <tt class="exception">Exception</tt>, direta ou indiretamente. Por exemplo:</p>
<div class="verbatim">
<pre>
>>> class MyError(Exception):
... def __init__(self, value):
... self.value = value
... def __str__(self):
... return repr(self.value)
...
>>> try:
... raise MyError(2*2)
... except MyError, e:
... print 'My exception occurred, value:', e.value
...
My exception occurred, value: 4
>>> raise MyError, 'oops!'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'
</pre>
</div>
<p>Neste exemplo, o método <tt class="method">__init__</tt> de <tt class="class">Exception</tt> foi redefinido.
O novo comportamento simplesmente cria o atributo <var>value</var>. Isto substitui o comportamento padrão de
criar o atributo <var>args</var>.</p>
<p>Classes para exceções podem ser definidas para fazer qualquer coisa que qualquer outra classe faz, mas
em geral são bem simples, freqüentemente oferecendo apenas alguns atributos que fornecem
informações sobre o erro que ocorreu. Ao criar um módulo que pode gerar diversos erros, uma
prática comum é criar uma classe base para as exceções definidas por aquele módulo, e as
classes específicas para cada condição de erro como subclasses dela:</p>
<div class="verbatim">
<pre>
class Error(Exception):
"""Base class for exceptions in this module."""
pass
class InputError(Error):
"""Exception raised for errors in the input.
Attributes:
expression -- input expression in which the error occurred
message -- explanation of the error
"""
def __init__(self, expression, message):
self.expression = expression
self.message = message
class TransitionError(Error):
"""Raised when an operation attempts a state transition that's not
allowed.
Attributes:
previous -- state at beginning of transition
next -- attempted new state
message -- explanation of why the specific transition is not allowed
"""
def __init__(self, previous, next, message):
self.previous = previous
self.next = next
self.message = message
</pre>
</div>
<p>Muitas exceções são definidas com nomes que terminam em ``Error,'' , de forma semelhante ao estilo
usado com as exceções padrão da linguagem.</p>
<p>Muitos módulos padrão se utilizam disto para reportar erros que ocorrem no interior das
funções que definem. Mais informações sobre esse mecanismo serão descritas no capítulo
<a href="#classes">9</a>, ``Classes.''</p>
<h1> 8.6 Definindo Ações de Limpeza</h1>
<p>A construção <tt class="keyword">try</tt> possui outra cláusula opcional, cuja finalidade é
permitir a implementação de ações de limpeza, que sempre devem ser executadas independentemente
da ocorrência de exceções. Como no exemplo:</p>
<div class="verbatim">
<pre>
>>> try:
... raise KeyboardInterrupt
... finally:
... print 'Goodbye, world!'
...
Goodbye, world!
Traceback (most recent call last):
File "<stdin>", line 2, ?
KeyboardInterrupt
</pre>
</div>
<p>A cláusula <em>finally</em> é executada sempre, ocorrendo ou não uma exceção. Quando
ocorre a exceção, é como se a exceção fosse sempre levantada após a execução
do código na cláusula <em>finally</em>. Mesmo que haja um <tt class="keyword">break</tt> ou <tt class=
"keyword">return</tt> dentro do <tt class="keyword">try</tt>, ainda assim o <tt class="keyword">finally</tt>
será executado.</p>
<p>O código na cláusula <em>finally</em> é útil para liberar recursos externos (como arquivos e
conexões de rede), não importando se o uso deles foi bem sucedido.</p>
<p>A construção <tt class="keyword">try</tt> pode ser seguida da cláusula <tt class=
"keyword">finally</tt> ou de um conjunto de cláusulas <tt class="keyword">except</tt>, mas nunca ambas (não
ficaria muito claro qual deve ser executada primeiro).</p>
<h1> 9. Classes</h1>
<p>O mecanismo de classes em Python foi adicionado à linguagem de forma a minimizar a sobrecarga sintática
e semântica. É uma mistura de mecanismos equivalentes encontrados em C++ e Modula-3. Assim como é
válido para módulos, classes em Python não impõe barreiras entre o usuário e a
definição. Contudo, dependem da ``cordialidade'' do usuário para não quebrar a
definição. Todavia, as características mais importantes de classes foram asseguradas: o mecanismo de
herança permite múltiplas classes base, uma classe derivada pode sobrescrever quaisquer métodos de uma
classe ancestral, e um método pode invocar outro método homônimo de uma classe ancestral. E mais,
objetos podem armazenar uma quantidade arbitrária de dados privados.</p>
<p>Na terminologia de C++, todos os membros de uma classe (incluindo dados) são <em>public</em>, e todos as
funções membro são <em>virtual</em>. Não existem construtores ou destrutores especiais.</p>
<p>Como em Modula-3, não existem atalhos para referenciar membros do objeto de dentro dos seus métodos. Um
método (função de classe) é declarado com um primeiro argumento explícito representando o
objeto (instância da classe) , que é fornecido implicitamente pela invocação.</p>
<p>Como em Smalltalk (e em Java), classes são objetos. Mas em Python, todos os tipos de dados são objetos.
Isso fornece uma semântica para importação e renomeamento. Ao contrário de C++ ou Modula-3, tipos
pré-definidos podem ser utilizados como classes base para extensões de usuário por herança. Como
em C++, mas diferentemente de Modula-3, a maioria dos operadores (aritiméticos, indexação,etc) podem
ser redefinidos para instâncias de classe.</p>
<h1> 9.1 Uma Palavra Sobre Terminologia</h1>
<p>Na falta de uma terminologia de classes universalmente aceita, eu irei ocasionalmente fazer uso de termos comuns a
Smalltalk ou C++(eu usaria termos de Modula-3 já que sua semântica é muito próxima a de Python,
mas tenho a impressão de que poucos usuários já ouviram falar dessa linguagem).</p>
<p>Objetos tem individualidade, e podem estar vinculados a múltiplos nomes (em diferentes escopos). Essa
facilidade é chamada <em>aliasing</em> em outras linguagens. À primeira vista não é muito
apreciada, e pode ser seguramente ignorada ao lidar com tipos imutáveis (números, strings, tuplas).
Entretanto, <em>aliasing</em> tem um efeito intencional sobre a semântica de código em Python envolvendo
objetos mutáveis como listas, dicionários, e a maioria das entidades externas a um programa como arquivos,
janelas, etc. Alias (N.d.T: sinônimos) funcionam de certa forma como ponteiros, em benefício do
programamdor. Por exemplo, passagem de objetos como parâmetro é barato, pois só o ponteiro é
passado na implementação. E se uma função modifica um objeto passado como argumento, o chamador
vai ver a mudança - o que elimina a necessidade de um duplo mecanismo de passagem de parâmetros como em
Pascal.</p>
<h1> 9.2 Escopos e Espaços de Nomes em Python</h1>
<p>Antes de introduzir classes, é preciso falar das regras de escopo em Python. Definições de classe
empregam alguns truques com espaços de nomes. Portanto, é preciso entender bem de escopos e espaços de
nomes antes. Esse conhecimento é muito útil para o programador avançado em Python.</p>
<p>Iniciando com algumas definições.</p>
<p>Um espaço de nomes é um mapeamento entre nomes e objetos. Presentemente, são implementados como
dicionários, isso não é perceptível (a não ser pelo desempenho) e pode mudar no futuro.
Exemplos de espaços de nomes são: o conjunto de nomes pré-definidos (funções como <tt class=
"function">abs()</tt> e exceções), nomes globais em módulos e nomes locais em uma função. De
uma certa forma, os atributos de um objeto também formam um espaço de nomes. O que há de importante
para saber é que não existe nenhuma relação entre nomes em espaços distintos. Por exemplo,
dois módulos podem definir uma função de nome ``maximize'' sem confusão - usuários dos
módulos devem prefixar a função com o nome do módulo para evitar colisão.</p>
<p>A propósito, eu utilizo a palavra <em>atributo</em> para qualquer nome depois de um ponto. Na expressão
<code>z.real</code>, por exemplo, <code>real</code> é um atributo do objeto <code>z</code>. Estritamente
falando, referências para nomes em módulos são atributos: na expressão
<code>modname.funcname</code>, <code>modname</code> é um objeto módulo e <code>funcname</code> é seu
atributo. Neste caso, existe um mapeamento direto entre os os atributos de um módulo e os nomes globais
definidos no módulo: eles compartilham o mesmo espaço de nomes. <a name="tex2html5" href=
"#foot1881"><sup>9.1</sup></a></p>
<p>Atributos podem ser somente de leitura ou não. Atributos de módulo são passíveis de
atribuição, você pode escrever "<tt class="samp">modname.the_answer = 42</tt>", e remoção
pelo comando <tt class="keyword">del</tt> ("<tt class="samp">del modname.the_answer</tt>").</p>
<p>Espaços de nomes são criados em momentos diferentes e possuem diferentes longevidades. O espaço de
nomes que contém os nomes pré-definidos é criado quando o interpretador inicializa e nunca é
removido. O espaço de nomes global é criado quando uma definição de módulo é lida, e
normalmente duram até a saída do interpretador.</p>
<p>Os comandos executados pela invocação do interpertador, ou pela leitura de um script, ou interativamente
são parte do módulo chamado <tt class="module">__main__</tt>, e portanto possuem seu próprio
espaço de nomes (os nomes pré-definidos possuem seu próprio espaço de nomes no módulo
chamado <tt class="module">__builtin__</tt>).</p>
<p>O espaço de nomes local para uma função é criado quando a função é chamada, e
removido quando a função retorna ou levanta uma exceção que não é tratada na
própria função. Naturalmente, chamadas recursivas de uma função possuem seus próprios
espaços de nomes.</p>
<p>Um escopo é uma região textual de um programa Python onde um espaço de nomes é diretamente
acessível. Onde ``diretamente acessível'' significa que uma referência sem qualificador especial
permite o acesso ao nome.</p>
<p>Ainda que escopos sejam determinados estaticamente, eles são usados dinamicamente. A qualquer momento durante
a execução, existem no mínimo três escopos diretamente acessíveis: o escopo interno (que
é procurado primeiro) contendo nomes locais, o escopo intermediário (com os nomes globais do módulo) e
o escopo externo (procurado por último) contendo os nomes pré-definidos.</p>
<p>Se um nome é declarado como global, então todas as referências e atribuições de valores
vão diretamente para o escopo intermediário que contém os nomes do módulo. Caso contrário,
todas as variáveis encontradas fora do escopo interno são apenas para leitura (a tentativa de atribuir
valores a essas variáveis irá simplesmente criar uma variável local, no escopo interno, não
alterando nada na variável de nome idêntico fora dele).</p>
<p>Normalmente, o escopo local referencia os nomes locais da função corrente. Fora de funções, o
escopo local referencia os nomes do escopo global (espaço de nomes do módulo). Definições de
classes adicionam um espaço de nomes ao escopo local.</p>
<p>É importante perceber que escopos são determinados textualmente. O escopo global de uma função
definida em um módulo é o espaço de nomes deste módulo, sem importar de onde ou de que alias
(N.d.T. sinônimo) a função é invocada. Por outro lado, a efetiva busca de nomes é
dinâmica, ocorrendo durante a execução. A evolução da linguagem está caminhando para
uma resolução de nomes estática, em tempo de compilação, que não dependa de
resolução dinâmica de nomes. (de fato, variáveis locais já são resolvidas
estaticamente.)</p>
<p>Um detalhe especial é que atribuições são sempre vinculadas ao escopo interno.
Atribuições não copiam dados, simplesmente vinculam objetos a nomes. O mesmo é verdade para
remoções. O comando "<tt class="samp">del x</tt>" remove o vínculo de <code>x</code> do espaço de
nomes referenciado pelo escopo local. De fato, todas operações que introduzem novos nomes usam o escopo
local. Em particular, comandos <tt class="keyword">import</tt> e definições de função vinculam o
módulo ou a função ao escopo local (a palavra-reservada <tt class="keyword">global</tt> pode ser usada
para indicar que certas variáveis residem no escopo global ao invés do local).</p>
<h1> 9.3 Primeiro Contato com Classes</h1>
<p>Classes introduzem novidades sintáticas, três novos tipos de objetos, e também semântica
nova.</p>
<h2> 9.3.1 Sintaxe de Definição de Classe</h2>
<p>A forma mais simples de definir uma classe é:</p>
<div class="verbatim">
<pre>
class NomeDaClasse:
<comando-1>
.
.
.
<comando-N>
</pre>
</div>
<p>Definições de classes, como definições de funções (comandos <tt class=
"keyword">def</tt>) devem ser executados antes que tenham qualquer efeito. Você pode colocar uma
definição de classe após um teste condicional <tt class="keyword">if</tt> ou dentro de uma
função.</p>
<p>Na prática, os comandos dentro de uma classe serão definições de funções, mas
existem outros comandos que são permitidos. Definições de função dentro da classe possuem um
lista peculiar de argumentos determinada pela convenção de chamada a métodos.</p>
<p>Quando se fornece uma definição de classe, um novo espaço de nomes é criado. Todas
atribuições de variáveis são vinculadas a este escopo local. Em particular, definições
de função também são armazenadas neste escopo.</p>
<p>Quando termina o processamento de uma definição de classe (normalmente, sem erros), um objeto de classe
é criado. Este objeto encapsula o conteúdo do espaço de nomes criado pela definição da
classe. O escopo local ativo antes da definição da classe é restaurado, e o objeto classe é
vinculado a este escopo com o nome dado a classe.</p>
<h2> 9.3.2 Objetos de Classe</h2>
<p>Objetos de Classe suportam dois tipos de operações: referências a atributos e
instanciação.</p>
<p><em>Referências a atributos</em> de classe utilizam a sintaxe padrão utilizada para quaisquer
referências a atributos em Python: <code>obj.name</code>. Atributos válidos são todos os nomes
presentes no espaço de nomes da classe quando o objeto classe foi criado. Portanto, se a definição da
classe era:</p>
<div class="verbatim">
<pre>
class MyClass:
"Um exemplo simples de classe"
i = 12345
def f(self):
return 'hello world'
</pre>
</div>
<p>então <code>MyClass.i</code> e <code>MyClass.f</code> são referências a atributos válidos,
retornando um inteiro e um objeto função, respectivamente. Atributos de classe podem receber
atribuições, logo você pode mudar o valor de <code>MyClass.i</code> por atribuição.
<tt class="member">__doc__</tt> é também um atributo válido, que retorna a docstring pertencente a
classe: <code>"Um exemplo simples de classe"</code>.</p>
<p><em>Instanciação de Classe</em> também utiliza uma notação de função. Apenas
finja que o objeto classe não possui parâmetros e retorna uma nova instância da classe. Por
exemplo:</p>
<div class="verbatim">
<pre>
x = MyClass()
</pre>
</div>
<p>cria uma nova <em>instância</em> da classe e atribui o objeto resultante a variável local
<code>x</code>.</p>
<p>A operação de instanciação (``calling'' um objeto de classe) cria um objeto vazio. Muitas
classes preferem criar um novo objeto em um estado inicial pré-determinado. Para tanto, existe um método
especial que pode ser definido pela classe, <tt class="method">__init__()</tt>, veja:</p>
<div class="verbatim">
<pre>
def __init__(self):
self.data = []
</pre>
</div>
<p>Quando uma classe define um método <tt class="method">__init__()</tt>, o processo de
instânciação automáticamente invoca <tt class="method">__init__()</tt> sobre a recém-criada
instância de classe. Neste exemplo, uma nova intância já inicializada pode ser obtida por:</p>
<div class="verbatim">
<pre>
x = MyClass()
</pre>
</div>
<p>Naturalmente, o método <tt class="method">__init__()</tt> pode ter argumentos para aumentar sua
flexibilidade. Neste caso, os argumentos passados para a instanciação de classe serão delegados para o
método <tt class="method">__init__()</tt>. Como ilustrado em:</p>
<div class="verbatim">
<pre>
>>> class Complex:
... def __init__(self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)
</pre>
</div>
<h2> 9.3.3 Instâncias</h2>
<p>Agora, o que podemos fazer com instâncias ? As únicas operações reconhecidas por
instâncias são referências a atributos. Existem dois tipos de nomes de atributos válidos:
atributos de dados e métodos.</p>
<p><em>Atributos-de-dados</em>, que correspondem a ``variáveis de instância'' em Smalltalk, e a ``membros''
em C++. Atributos-de-dados não não precisam ser declarados. Assim como variáveis locais, eles passam a
existir na primeira vez em que é feita uma atribuição. Por exemplo, se <code>x</code> é uma
instância de <tt class="class">MyClass</tt> criada acima, o próximo trecho de código irá imprimir
o valor <code>16</code>, sem deixar rastro (por causa do <tt class="keyword">del</tt>):</p>
<div class="verbatim">
<pre>
x.counter = 1
while x.counter < 10:
x.counter = x.counter * 2
print x.counter
del x.counter
</pre>
</div>
<p>O outro tipo de referências a atributos são <em>métodos</em>. Um método é uma
função que ``pertence a'' uma instância (em Python, o termo método não é aplicado
exclusivamente a instâncias de classes definidas pelo usuário: outros tipos de objetos também podem
ter métodos; por exemplo, objetos listas possuem os métodos: append, insert, remove, sort, etc).</p>
<p>Nomes de métodos válidos de uma instância dependem de sua classe. Por definição, todos
atributos de uma classe que são funções equivalem a um método presente nas instâncias. No
nosso exemplo, <code>x.f</code> é uma referência de método válida já que
<code>MyClass.f</code> é uma função, enquanto <code>x.i</code> não é, já que
<code>MyClass.i</code> não é função. Entretanto, <code>x.f</code> não é o mesmo que
<code>MyClass.f</code> -- o primeiro é um método de objeto <a id='l2h-30' xml:id='l2h-30'></a>, o segundo
é um objeto função.</p>
<h2> 9.3.4 Métodos de Objeto</h2>
<p>Normalmente, um método é chamado imediatamente:</p>
<div class="verbatim">
<pre>
x.f()
</pre>
</div>
<p>No exemplo com <tt class="class">MyClass</tt> o resultado será a string <code>'hello world'</code>. No
entanto, não é obrigatótio chamar o método imediatamente: como <code>x.f</code> é
também um objeto (tipo método), ele pode ser armazenado e invocado a posteriori. Por exemplo:</p>
<div class="verbatim">
<pre>
xf = x.f
while True:
print xf()
</pre>
</div>
<p>continuará imprimindo "<tt class="samp">hello world</tt>" até o final dos tempos.</p>
<p>O que ocorre precisamente quando um método é chamado ? Você deve ter notado que
<code>x.f()</code> foi chamado sem nenhum parâmetro, porém a definição da função
<tt class="method">f</tt> especificava um argumento. O que aconteceu com o argumento ? Certamente Python
levantaria uma exceção se o argumento estivesse faltando...</p>
<p>Talvez você já tenha advinhado a resposta: o que há de especial em métodos é que o objeto
(a qual o método pertence) é passado como o primeiro argumento da função. No nosso exemplo, a
chamada <code>x.f()</code> é exatamente equivalente a <code>MyClass.f(x)</code>. Em geral, chamar um método
com uma lista de <var>n</var> argumentos é equivalente a chamar a função na classe correspondente
passando a instância como o primeiro argumento antes dos demais argumentos.</p>
<p>Se você ainda não entendeu como métodos funcionam, talvez uma olhadela na implementação
sirva para clarear as coisas. Quando um atributo de instância é referenciado e não é um atributo
de dado, a sua classe é procurada. Se o nome indica um atributo de classe válido que seja um objeto
função, um objeto método é criado pela composição da instância alvo e do objeto
função. Quando o método é chamado com uma lista de argumentos, ele é desempacotado, uma nova
lista de argumentos é criada a partir da instância original e da lista original de argumentos do
método. Finalmente, a função é chamada com a nova lista de argumentos.</p>
<h1> 9.4 Observações Aleatórias</h1>
<p>Atributos de dados sobrescrevem atributos métodos homônimos. Para evitar conflitos de nome acidentais,
que podem gerar bugs de difícil rastreio em programas extensos, é sábio utilizar algum tipo de
convenção que minimize a chance de conflitos. Algumas idéias incluem colocar nomes de métodos com
inicial maiúscula, prefixar atributos de dados com uma string única (quem sabe ``_''), ou simplesmente
utilizar substantivos para atributos e verbos para métodos.</p>
<p>Atributos de dados podem ser referenciados por métodos da própria instância, bem como por qualquer
outro usuário do objeto. Em outras palavras, classes não servem para implementar tipos puramente abstratos
de dados. De fato, nada em Python torna possível assegurar o encapsulamento de dados. Tudo é
convenção. Por outro lado, a implementação Python, escrita em C, pode esconder completamente
detalhes de um objeto ou regular seu acesso se necessário. Isto pode ser utilizado por extensões a Python
escritas em C.</p>
<p>Clientes devem utilizar atributos de dados com cuidado, pois podem bagunçar invariantes mantidos pelos
métodos ao esbarrar nos seus atributos. Portanto, clientes podem adicionar à vontade atributos de dados
para uma instância sem afetar a validade dos métodos, desde que seja evitado o conflito de nomes.
Novamente, uma convenção de nomenclatura poupa muita dor de cabeça.</p>
<p>Não existe atalho para referenciar atributos de dados (ou métodos) de dentro de um método. Isso na
verdade aumenta a legibilidade dos métodos: não há como confundir uma variável local com uma
instância global ao dar uma olhadela em um método desconhecido.</p>
<p>Frequentemente, o primeiro argumento de qualquer método é chamado <code>self</code>. Isso não
é nada mais do que uma convenção, <code>self</code> não possui nenhum significado especial em
Python (observe que ao seguir a convenção seu código se torna legível por uma grande comunidade
de desenvolvedores Python e potencialmente poderá se beneficiar de ferramentas feitas por outrém que se
baseie na convenção).</p>
<p>Qualquer função que é também atributo de classe, define um método nas instâncias
desta classe. Não é necessário que a definição da função esteja textualmente
embutida na definição da classe. Atribuir um objeto função a uma variável local da classe
é válido. Por exemplo:</p>
<div class="verbatim">
<pre>
# Função definida fora da classe
def f1(self, x, y):
return min(x, x+y)
class C:
f = f1
def g(self):
return 'hello world'
h = g
</pre>
</div>
<p>Agora <code>f</code>, <code>g</code> e <code>h</code> são todos atributos da classe <tt class="class">C</tt>
que referenciam funções, e consequentemente são todos métodos de instâncias da classe
<tt class="class">C</tt>, onde <code>h</code> é equivalente a <code>g</code>. No entanto, essa prática pode
confundir o leitor do programa.</p>
<p>Métodos podem chamar outros métodos utilizando o argumento <code>self</code> :</p>
<div class="verbatim">
<pre>
class Bag:
def __init__(self):
self.data = []
def add(self, x):
self.data.append(x)
def addtwice(self, x):
self.add(x)
self.add(x)
</pre>
</div>
<p>Métodos podem referenciar nomes globais da mesma forma que funções ordinárias. O escopo global
associado a um método é o módulo contendo sua definição de classe (a classe propriamente
dita nunca é usada como escopo global!). Ainda que seja raro encontrar a necessidade de utilizar dados globais
em um método, há diversos usos legítimos do escopo global. Por exemplo, funções e
módulos importados no escopo global podem ser usados por métodos, bem como as funções e classes
definidas no próprio escopo global. Provavelmente, a classe contendo o método em questão também
foi definida neste escopo global. Na próxima seção veremos um conjunto de razões pelas quais um
método desejaria referenciar sua própria classe.</p>
<h1> 9.5 Herança</h1>
<p>Obviamente, uma característica de linguagem não seria digna do nome ``classe'' se não suportasse
herança. A sintaxe para uma classe derivada se parece com:</p>
<div class="verbatim">
<pre>
class DerivedClassName(BaseClassName):
<statement-1>
.
.
.
<statement-N>
</pre>
</div>
<p>O nome <tt class="class">BaseClassName</tt> deve estar definido em um escopo contendo a definição da
classe derivada. No lugar do nome da classe base, também são aceitas outras expressões. Isso é
muito útil, por exemplo, quando a classe base é definida em outro módulo:</p>
<div class="verbatim">
<pre>
class DerivedClassName(modname.BaseClassName):
</pre>
</div>
<p>Execução de uma definição de classe derivada procede da mesma forma que a de uma classe base.
Quando o objeto classe é construído, a classe base é lembrada. Isso é utilizado para resolver
referências a atributos. Se um atributo requisitado não for encontrado na classe, ele é procurado na
classe base. Essa regra é aplicada recursivamente se a classe base por sua vez for derivada de outra.</p>
<p>Não existe nada de especial sobre instanciação de classes derivadas.
<code>DerivedClassName()</code> cria uma nova instância da classe. Referências a métodos são
resolvidas da seguinte forma: o atributo correspondente é procurado através da cadeia de
derivação, e referências a métodos são válidas desde que produzam um objeto do tipo
função.</p>
<p>Classes derivadas podem sobrescrever métodos das suas classes base. Uma vez que métodos não possuem
privilégios especiais quando invocam outros métodos no mesmo objeto, um método na classe base que
invocava um outro método da mesma classe base, pode efetivamente acabar invocando um método sobreposto por
uma classe derivada. Para programadores C++ isso significa que todos os métodos em Python são efetivamente
<tt class="keyword">virtual</tt>.</p>
<p>Um método que sobrescreva outro em uma classe derivada pode desejar na verdade estender, ao invés de
substituir, o método sobrescrito de mesmo nome na classe base. A maneira mais simples de implementar esse
comportamento é chamar diretamente a classe base "<tt class="samp">BaseClassName.methodname(self,
arguments)</tt>". O que pode ser útil para os usuários da classe também. Note que isso só
funciona se a classe base for definida ou importada diretamente no escopo global.</p>
<h2> 9.5.1 Herança Múltipla</h2>
<p>Python também suporta uma forma limitada de herança múltipla. Uma definição de classe que
herda de várias classes base é:</p>
<div class="verbatim">
<pre>
class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>
</pre>
</div>
<p>A única regra que precisa ser explicada é a semântica de resolução para as
referências a atributos de classe. É feita uma busca em profundidade da esquerda para a direita. Logo, se
um atributo não é encontrado em <tt class="class">DerivedClassName</tt>, ele é procurado em <tt class=
"class">Base1</tt>, e recursivamente nas classes bases de <tt class="class">Base1</tt>, e apenas se não for
encontrado lá a busca prosseguirá em <tt class="class">Base2</tt>, e assim sucessivamente.</p>
<p>Para algumas pessoas a busca em largura - procurar antes em <tt class="class">Base2</tt> e <tt class=
"class">Base3</tt> do que nos ancestrais de <tt class="class">Base1</tt> -- parece mais natural. Entretanto, seria
preciso conhecer toda a hierarquia de <tt class="class">Base1</tt> para evitar um conflito com um atributo de
<tt class="class">Base2</tt>. Enquanto a busca em profundidade não diferencia o acesso a atributos diretos ou
herdados de <tt class="class">Base1</tt>.</p>
<p>É sabido que o uso indiscriminado de herança múltipla é o pesadelo da manutenção,
sobretudo pela confiança de Python na adoção de uma convenção de nomenclatura para evitar
conflitos. Um problema bem conhecido com herança múltipla é quando há uma classe derivada de
outras que por sua vez possuem um ancestral em comum. Ainda que seja perfeitamente claro o que acontecerá (a
instância possuirá uma única cópia dos atributos de dados do ancestral comum), não está
claro se a semântica é útil.</p>
<h1> 9.6 Variáveis Privadas</h1>
<p>Existe um suporte limitado a identificadores privados em classes. Qualquer identificador no formato
<code>__spam</code> (no mínimo dois caracteres `_' no prefixo e no máximo u m como sufixo) é
substituído por <code>_classname__spam</code>, onde <code>classname</code> é o nome da classe corrente.
Essa construção independe da posição sintática do identificador, e pode ser usada para
tornar privadas: instâncias, variáveis de classe e métodos. Pode haver truncamento se o nome combinado
extrapolar 255 caracteres. Fora de classes, ou quando o nome da classe só tem `_', não se aplica esta
construção.</p>
<p>Este procedimento visa oferecer a classes uma maneira fácil de definir variáveis de instância e
métodos ``privados'', sem ter que se preocupar com outras variáveis de instância definidas em classes
derivadas ou definidas fora da classe. Apesar da regra de nomenclatura ter sido projetada para evitar ``acidentes'',
ainda é possível o acesso e a manipulação de entidades privadas. O que é útil em
determinadas circunstâncias, como no caso de depuradores, talvez a única razão pela qual essa
característica ainda não tenha sido suprimida (detalhe: derivar uma classe com o mesmo nome da classe base
torna possível o uso de seus membros privados! Isso pode ser corrigido em versões futuras).</p>
<p>Observe que código passado para <code>exec</code>, <code>eval()</code> ou <code>evalfile()</code> não
considera o nome da classe que o invocou como sendo a classe corrente. O modificador <code>global</code> funciona de
maneira semelhante, quando se está restrito ao código que foi byte-compilado em conjunto. A mesma
restrição se aplica aos comandos <code>getattr()</code>, <code>setattr()</code> e <code>delattr()</code>, e
a manipulação direta do dicionário <code>__dict__</code>.</p>
<h1> 9.7 Particularidades</h1>
<p>Às vezes, é útil ter um tipo semelhante ao ``record'' de Pascal ou ao ``struct'' de C. Uma
definição de classe vazia atende esse propósito:</p>
<div class="verbatim">
<pre>
class Employee:
pass
john = Employee() # Cria um registro vazio de Empregado
# Preenche os campos do registro
john.name = 'John Doe'
john.dept = 'computer lab'
john.salary = 1000
</pre>
</div>
<p>Um trecho de código Python que espera um tipo abstrato de dado em particular, pode receber ao invés do
tipo abstrato uma classe (que emula os métodos que aquele tipo suporta). Por exemplo, se você tem uma
função que formata dados em um objeto arquivo, você pode definir uma classe com os métodos
<tt class="method">read()</tt> e <tt class="method">readline()</tt> que utiliza um buffer ao invés do arquivo
propriamente dito.</p>
<p>Métodos de instância são objetos, e podem possuir atributos também: <code>m.im_self</code>
é o objeto ao qual o método está ligado, e <code>m.im_func</code> é o objeto função
correspondente ao método.</p>
<h2> 9.7.1 Exceções Também São Classes</h2>
<p>Exceções definidas pelo usuário são identificadas por classes. Através deste mecanismo
é possível criar hierarquias extensíveis de exceções.</p>
<p>Existem duas novas semânticas válidas para o comando <tt class="keyword">raise</tt>:</p>
<div class="verbatim">
<pre>
raise Class, instance
raise instance
</pre>
</div>
<p>Na primeira forma, <code>instance</code> deve ser uma instância de <tt class="class">Class</tt> ou de uma
classe derivada dela. A segunda forma é um atalho para:</p>
<div class="verbatim">
<pre>
raise instance.__class__, instance
</pre>
</div>
<p>Uma classe em uma cláusula de exceção é compatível com a exceção se é a
mesma classe prevista na cláusula ou ancestral dela (não o contrário, se na cláusula estiver uma
classe derivada não haverá casamento com exceções base levantadas). No exemplo a seguir será
impresso B, C, D nessa ordem:</p>
<div class="verbatim">
<pre>
class B:
pass
class C(B):
pass
class D(C):
pass
for c in [B, C, D]:
try:
raise c()
except D:
print "D"
except C:
print "C"
except B:
print "B"
</pre>
</div>
<p>Se a ordem das cláusulas fosse invertida (B no início), seria impresso B, B, B - sempre a primeira
cláusula válida é ativada.</p>
<p>Quando uma mensagem de erro é impressa para uma exceção não tratada, o nome da classe da
exceção é impresso, e depois a instância da exceção é convertida para string pela
função <tt class="function">str()</tt> e é também impressa (após um espaço e uma
vírgula).</p>
<h1> 9.8 Iteradores</h1>
<p>Você já deve ter notado que pode usar laços com a maioria das contêineres usando um comando
<tt class="keyword">for</tt>:</p>
<div class="verbatim">
<pre>
for element in [1, 2, 3]:
print element
for element in (1, 2, 3):
print element
for key in {'one':1, 'two':2}:
print key
for char in "123":
print char
for line in open("myfile.txt"):
print line
</pre>
</div>
<p>Este estilo de acesso é limpo, conciso e muito conveniente. O uso de iteradores promove uma
unificação ao longo de toda a linguagem. Por trás dos bastidores, o comando <tt class=
"keyword">for</tt> chama <tt class="function">iter()</tt> no contêiner. Essa função retorna um
iterador que define o método <tt class="method">next()</tt>, que acessa os elementos da sequência um por
vez. Quando acabam os elementos, <tt class="method">nex()</tt> levanta a exceção <tt class=
"exception">StopIteration</tt>, indicando que o laço <tt class="keyword">for</tt> deve encerrar. Este exemplo
mostra como tudo funciona:</p>
<div class="verbatim">
<pre>
>>> s = 'abc'
>>> it = iter(s)
>>> it
<iterator object at 0x00A1DB50>
>>> it.next()
'a'
>>> it.next()
'b'
>>> it.next()
'c'
>>> it.next()
Traceback (most recent call last):
File "<stdin>", line 1, in ?
it.next()
StopIteration
</pre>
</div>
<p>Vendo o mecanismo por trás do protocolo usado pelos iteradores, torna-se fácil adicionar esse
comportamento às suas classes. Defina uma método <tt class="method">__iter__()</tt> que retorna um objeto
com um método <tt class="method">next()</tt>. Se a classe definir <tt class="method">next()</tt>, então
<tt class="method">__iter__()</tt> pode simplesmente retornar <code>self</code>:</p>
<div class="verbatim">
<pre>
class Reverse:
"Iterator for looping over a sequence backwards"
def __init__(self, data):
self.data = data
self.index = len(data)
def __iter__(self):
return self
def next(self):
if self.index == 0:
raise StopIteration
self.index = self.index - 1
return self.data[self.index]
>>> for char in Reverse('spam'):
... print char
...
m
a
p
s
</pre>
</div>
<h1> 9.9 Geradores</h1>
<p>Geradores são uma maneira fácil e poderosa de criar iteradores. Eles são escritos como uma
função normal, mas usam o comando <tt class="keyword">yield()</tt> quando desejam retornar dados. Cada vez
que <tt class="method">next()</tt> é chamado, o gerador continua a partir de onde parou (sempre mantendo na
memória os valores e o último comando executado). Um exemplo mostra como geradores podem ser muito
fáceis de criar:</p>
<div class="verbatim">
<pre>
def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]
>>> for char in reverse('golf'):
... print char
...
f
l
o
g
</pre>
</div>
<p>Qualquer coisa feita com geradores também pode ser feita com iteradores baseados numa classe, como descrito
na seção anterior. O que torna geradores tão compactos é que os métodos <tt class=
"method">__iter__()</tt> e <tt class="method">next()</tt> são criados automaticamente.</p>
<p>Outro ponto chave é que as variáveis locais e o estado da execucação são memorizados
automaticamente entre as chamadas. Isto torna a função mais fácil de escrever e muito mais clara do
que uma abordagem usando variáveis como <code>self.index</code> and <code>self.data</code>.</p>
<p>Além disso, quando geradores terminam, eles levantam <tt class="exception">StopIteration</tt>
automaticamente. Combinados, todos estes aspectos tornam a criação de iteradores tão fácil quanto
a de uma função normal.</p>
<h1> 9.10 Expressões Geradoras</h1>
<p>Alguns geradores simples podem ser escritos sucintamente como expressões usando uma sintaxe similar a de
abrangência de listas, mas com parênteses ao invés de colchetes. Essas expressões são
destinadas a situações em que o gerador é usado imediatamente por uma função.
Expressões geradoras tendem a ser mais compactas, porém menos versáteis do que uma definição
completa de um gerador, e tendem a ser muito mais amigáveis no consumo de memória do que uma
abrangência de lista equivalente.</p>
<p>Exemplos:</p>
<div class="verbatim">
<pre>
>>> sum(i*i for i in range(10)) # sum of squares
285
>>> xvec = [10, 20, 30]
>>> yvec = [7, 5, 3]
>>> sum(x*y for x,y in zip(xvec, yvec)) # dot product
260
>>> from math import pi, sin
>>> sine_table = dict((x, sin(x*pi/180)) for x in range(0, 91))
>>> unique_words = set(word for line in page for word in line.split())
>>> valedictorian = max((student.gpa, student.name) for student in graduates)
>>> data = 'golf'
>>> list(data[i] for i in range(len(data)-1,-1,-1))
['f', 'l', 'o', 'g']
</pre>
</div>
<h1> 10. Um Breve Passeio Pela Biblioteca Padrão</h1>
<h1> 10.1 Interface Com o Sistema Operacional</h1>
<p>O módulo <a class="ulink" href="../lib/module-os.html"><tt class="module">os</tt></a> fornece dúzias de
fúnções para interagir com o sistema operacional:</p>
<div class="verbatim">
<pre>
>>> import os
>>> os.system('time 0:02')
0
>>> os.getcwd() # Retorna o diretório de trabalho atual
'C:\\Python24'
>>> os.chdir('/server/accesslogs')
</pre>
</div>
<p>Tome cuidado para usar a forma "<tt class="samp">import os</tt>" ao invés de "<tt class="samp">from os import
*</tt>". Isto evitará que <tt class="function">os.open()</tt> oculte a função <tt class=
"function">open()</tt> que opera de forma muito diferente.</p>
<p><a id='l2h-31' xml:id='l2h-31'></a>As funções internas <tt class="function">dir()</tt> e <tt class=
"function">help()</tt> são úteis como um sistema de ajuda interativa pra lidar com módulos grandes
como <tt class="module">os</tt>:</p>
<div class="verbatim">
<pre>
>>> import os
>>> dir(os)
<returns a list of all module functions>
>>> help(os)
<returns an extensive manual page created from the module's docstrings>
</pre>
</div>
<p>Para tarefas de gerenciamento diário de arquivos e diretórios, o módulo <a class="ulink" href=
"../lib/module-shutil.html"><tt class="module">shutil</tt></a> fornece uma interface de alto nível bem que
é mais simples de usar:</p>
<div class="verbatim">
<pre>
>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
>>> shutil.move('/build/executables', 'installdir')
</pre>
</div>
<h1> 10.2 Caracteres Coringa</h1>
<p>O módulo <a class="ulink" href="../lib/module-glob.html"><tt class="module">glob</tt></a> fornece uma
função para criar listas de arquivos a partir de buscas em diretórios usando caracteres coringa:</p>
<div class="verbatim">
<pre>
>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']
</pre>
</div>
<h1> 10.3 Argumentos da Linha de Comando</h1>
<p>Scripts geralmente precisam processar argumentos passados na linha de comando. Esses argumentos são
armazenados como uma lista no atributo <var>argv</var> do módulo <a class="ulink" href=
"../lib/module-sys.html"><tt class="module">sys</tt></a>. Por exemplo, teríamos a seguinte saída executando
"<tt class="samp">python demo.py um dois tres</tt>" na linha de comando:</p>
<div class="verbatim">
<pre>
>>> import sys
>>> print sys.argv
['demo.py', 'um', 'dois', 'tres']
</pre>
</div>
<p>O módulo <a class="ulink" href="../lib/module-getopt.html"><tt class="module">getopt</tt></a> processa os
argumentos passados em <var>sys.argv</var> usando as convenções da função <span class=
"Unix">Unix</span> <tt class="function">getopt()</tt>. Outros recursos de processamento mais poderosos e
flexíveis estão disponíveis no módulo <a class="ulink" href=
"../lib/module-optparse.html"><tt class="module">optparse</tt></a>.</p>
<h1> 10.4 Redirecionamento de Erros e Encerramento do Programa</h1>
<p>O módulo <a class="ulink" href="../lib/module-sys.html"><tt class="module">sys</tt></a> também possui
atributos para <var>stdin</var>, <var>stdout</var>, e <var>stderr</var> (entrada e saída de dados padrão,
saída de erros, respectivamente). O último é usado para emitir avisos e mensagens de erro
visíveis mesmo quando <var>stdout</var> foi redirecionado:</p>
<div class="verbatim">
<pre>
>>> sys.stderr.write('Warning, log file not found starting a new one\n')
Warning, log file not found starting a new one
</pre>
</div>
<p>A forma mais direta de encerrar um script é usando "<tt class="samp">sys.exit()</tt>".</p>
<h1> 10.5 Reconhecimento de Padrões em Strings</h1>
<p>O módulo <a class="ulink" href="../lib/module-re.html"><tt class="module">re</tt></a> fornece ferramentas
para lidar processamento de strings através de expressões regulares. Para reconhecimento de padrões
complexos e manipulações elaboradas, expressões regulares oferecem uma solução sucinta e
eficiente:</p>
<div class="verbatim">
<pre>
>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'
</pre>
</div>
<p>Quando as exigências são simples, métodos de strings são preferíveis por serem mais
fáceis de ler e depurar:</p>
<div class="verbatim">
<pre>
>>> 'tea for too'.replace('too', 'two')
'tea for two'
</pre>
</div>
<h1> 10.6 Matemática</h1>
<p>O módulo <a class="ulink" href="../lib/module-math.html"><tt class="module">math</tt></a> oferece acesso
às funções da biblioteca C para matemática e ponto flutuante:</p>
<div class="verbatim">
<pre>
>>> import math
>>> math.cos(math.pi / 4.0)
0.70710678118654757
>>> math.log(1024, 2)
10.0
</pre>
</div>
<p>O módulo <a class="ulink" href="../lib/module-random.html"><tt class="module">random</tt></a> fornece
ferramentas para gerar seleções aleatórias:</p>
<div class="verbatim">
<pre>
>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'
>>> random.sample(xrange(100), 10) # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random() # random float
0.17970987693706186
>>> random.randrange(6) # random integer chosen from range(6)
4
</pre>
</div>
<h1> 10.7 Acesso à Internet</h1>
<p>Há diversos módulos para acesso e processamento de protocolos da internet. Dois dos mais simples
são <a class="ulink" href="../lib/module-urllib2.html"><tt class="module">urllib2</tt></a> para efetuar
<em>download</em> de dados a partir de urls e <a class="ulink" href="../lib/module-smtplib.html"><tt class=
"module">smtplib</tt></a> para enviar mensagens de correio eletrônico:</p>
<div class="verbatim">
<pre>
>>> import urllib2
>>> for line in urllib2.urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
... if 'EST' in line: # look for Eastern Standard Time
... print line
<BR>Nov. 25, 09:43:32 PM EST
>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
"""To: jcaesar@example.org
From: soothsayer@example.org
Beware the Ides of March.
""")
>>> server.quit()
</pre>
</div>
<h1> 10.8 Data e Hora</h1>
<p>O módulo <a class="ulink" href="../lib/module-datetime.html"><tt class="module">datetime</tt></a> fornece
classes para manipulação de datas e horas nas mais variadas formas. Apesar da disponibilidade de
aritmética com data e hora, o foco da implementação é na extração eficiente dos membros
para formatação e manipulação. O módulo também oferece objetos que levam os fusos
horários em consideração.</p>
<div class="verbatim">
<pre>
# dates are easily constructed and formatted
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'
# dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368
</pre>
</div>
<h1> 10.9 Compressão de Dados</h1>
<p>Formatos comuns de arquivamento e compressão de dados estão disponíveis diretamente através de
alguns módulos, entre eles: <a class="ulink" href="../lib/module-zlib.html"><tt class="module">zlib</tt></a>,
<a class="ulink" href="../lib/module-gzip.html"><tt class="module">gzip</tt></a>, <a class="ulink" href=
"../lib/module-bz2.html"><tt class="module">bz2</tt></a>, <a class="ulink" href=
"../lib/module-zipfile.html"><tt class="module">zipfile</tt></a> e <a class="ulink" href=
"../lib/module-tarfile.html"><tt class="module">tarfile</tt></a>.</p>
<div class="verbatim">
<pre>
>>> import zlib
>>> s = 'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979
</pre>
</div>
<h1> 10.10 Medição de Desempenho</h1>
<p>Alguns usuários de Python desenvolvem um interesse profundo pelo desempenho relativo de diferentes abordagens
para o mesmo problema. Python oferece uma ferramenta de medição que esclarecem essas dúvidas
rapidamente.</p>
<p>Por exemplo, pode ser tentador usar empacotamento e desempacotamento de tuplas ao invés da abordagem
tradicional de permutar os argumentos. O módulo <a class="ulink" href="../lib/module-timeit.html"><tt class=
"module">timeit</tt></a> rapidamente mostra uma modesta vantagem de desempenho:</p>
<div class="verbatim">
<pre>
>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791
</pre>
</div>
<p>Em contraste com o alto nível de granularidade oferecido pelo módulo <tt class="module">timeit</tt>, os
módulos <a class="ulink" href="../lib/module-profile.html"><tt class="module">profile</tt></a> e <tt class=
"module">pstats</tt> disponibilizam ferramentas para identificar os trechos mais críticas em grandes blocos de
código.</p>
<h1> 10.11 Controle de Qualidade</h1>
<p>Uma das abordagens usadas no desenvolvimento de software de alta qualidade é escrever testes para cada
função à medida que é desenvolvida e executar esses testes frequentemente durante o processo de
desenvolvimento.</p>
<p>O módulo <a class="ulink" href="../lib/module-doctest.html"><tt class="module">doctest</tt></a> oferece uma
ferramenta para realizar um trabalho de varredura e validação de testes escritos nas strings de
documentação (<em>docstrings</em>) de um programa. A construção dos testes é tão
simples quanto copiar uma chamada típica juntamente dos seus resultados e colá-los na docstring. Isto
aprimora a documentação, fornecendo ao usuário um exemplo real, e permite que o módulo doctest
verifique que o código continua fiel à documentação.</p>
<div class="verbatim">
<pre>
def average(values):
"""Computes the arithmetic mean of a list of numbers.
>>> print average([20, 30, 70])
40.0
"""
return sum(values, 0.0) / len(values)
import doctest
doctest.testmod() # automatically validate the embedded tests
</pre>
</div>
<p>O módulo <a class="ulink" href="../lib/module-unittest.html"><tt class="module">unittest</tt></a> não
é tão simples de usar quanto o módulo <tt class="module">doctest</tt>, mas permite que um conjunto
muito maior de testes seja mantido em um arquivo separado:</p>
<div class="verbatim">
<pre>
import unittest
class TestStatisticalFunctions(unittest.TestCase):
def test_average(self):
self.assertEqual(average([20, 30, 70]), 40.0)
self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
self.assertRaises(ZeroDivisionError, average, [])
self.assertRaises(TypeError, average, 20, 30, 70)
unittest.main() # Calling from the command line invokes all tests
</pre>
</div>
<h1> 10.12 Baterias Incluídas</h1>
<p>Python tem uma filosofia de ``baterias incluídas''. Isto fica mais evidente através da
sofisticação e robustez dos seus maiores pacotes. Por exemplo:</p>
<ul>
<li>Os módulos <a class="ulink" href="../lib/module-xmlrpclib.html"><tt class="module">xmlrpclib</tt></a> e
<a class="ulink" href="../lib/module-SimpleXMLRPCServer.html"><tt class="module">SimpleXMLRPCServer</tt></a> tornam
a implementação de chamadas remotas (<em>remote procedure calls</em>) uma tarefa quase trivial. Apesar
dos nomes dos módulos, nenhum conhecimento ou manipulação de XML é necessário.</li>
<li>O pacote <a class="ulink" href="../lib/module-email.html"><tt class="module">email</tt></a> é uma
biblioteca para gerenciamento de mensagens de correio eletrônico, incluindo MIME e outros baseados no RFC
2822. Diferentemente dos módulos <tt class="module">smtplib</tt> e <tt class="module">poplib</tt> que apenas
enviam e recebem mensagens, o pacote email tem um conjunto completo de ferramentas para construir ou decodificar
estruturas complexas de mensagens (incluindo anexos) e para implementação de protocolos de
codificação e cabeçalhos.</li>
<li>Os pacotes <a class="ulink" href="../lib/module-xml.dom.html"><tt class="module">xml.dom</tt></a> e <a class=
"ulink" href="../lib/module-xml.sax.html"><tt class="module">xml.sax</tt></a> oferecem uma implementação
robusta deste popular formato de troca de dados. De maneira semelhante, o módulo <a class="ulink" href=
"../lib/module-csv.html"><tt class="module">csv</tt></a> permite ler e escrever diretamente num formato comum de
bancos de dados. Juntos, estes módulos e pacotes simplificam muito a troca de dados entre aplicações
em Python e outras ferramentas.</li>
<li>Internacionalização é disponível através de diversos módulos, como <a class=
"ulink" href="../lib/module-gettext.html"><tt class="module">gettext</tt></a>, <a class="ulink" href=
"../lib/module-locale.html"><tt class="module">locale</tt></a>, e o pacote <a class="ulink" href=
"../lib/module-codecs.html"><tt class="module">codecs</tt></a>.</li>
</ul>
<h1> 11. Um Breve Passeio Pela Biblioteca Padrão - Parte II</h1>
<p>Este segundo passeio cobre alguns módulos mais avançados que cobrem algumas necessidades de
programação profissional. Estes módulos raramente aparecem em scripts pequenos.</p>
<h1> 11.1 Formatando Saída</h1>
<p>O módulo <a class="ulink" href="../lib/module-repr.html"><tt class="module">repr</tt></a> oferece uma
versão da função <tt class="function">repr()</tt> customizada para abreviar a exibição
contêineres grandes ou aninhados muito profundamente:</p>
<div class="verbatim">
<pre>
>>> import repr
>>> repr.repr(set('supercalifragilisticexpialidocious'))
"set(['a', 'c', 'd', 'e', 'f', 'g', ...])"
</pre>
</div>
<p>O módulo <a class="ulink" href="../lib/module-pprint.html"><tt class="module">pprint</tt></a> oferece
controle mais sofisticada na exibição de tanto objetos internos quanto aqueles definidos pelo usuário
de uma maneira legível através do interpretador. Quando o resultado é maior do que uma linha, o
``pretty printer'' acrescenta quebras de linha e indentação para revelar as estruturas de dados de maneira
mais clara:</p>
<div class="verbatim">
<pre>
>>> import pprint
>>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',
... 'yellow'], 'blue']]]
...
>>> pprint.pprint(t, width=30)
[[[['black', 'cyan'],
'white',
['green', 'red']],
[['magenta', 'yellow'],
'blue']]]
</pre>
</div>
<p>O módulo <a class="ulink" href="../lib/module-textwrap.html"><tt class="module">textwrap</tt></a> formata
parágrafos de texto de forma que caibam em uma dada largura de tela:</p>
<div class="verbatim">
<pre>
>>> import textwrap
>>> doc = """The wrap() method is just like fill() except that it returns
... a list of strings instead of one big string with newlines to separate
... the wrapped lines."""
...
>>> print textwrap.fill(doc, width=40)
The wrap() method is just like fill()
except that it returns a list of strings
instead of one big string with newlines
to separate the wrapped lines.
</pre>
</div>
<p>O módulo <a class="ulink" href="../lib/module-locale.html"><tt class="module">locale</tt></a> acessa um banco
de dados de formatos de dados específicos à determinada cultura. O atributo <em>grouping</em> da
função <em>format</em>, oferece uma forma simples de formatar números com separadores:</p>
<div class="verbatim">
<pre>
>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')
'English_United States.1252'
>>> conv = locale.localeconv() # get a mapping of conventions
>>> x = 1234567.8
>>> locale.format("%d", x, grouping=True)
'1,234,567'
>>> locale.format("%s%.*f", (conv['currency_symbol'],
... conv['frac_digits'], x), grouping=True)
'\$1,234,567.80'
</pre>
</div>
<h1> 11.2 Templating</h1>
<p>The <a class="ulink" href="../lib/module-string.html"><tt class="module">string</tt></a> module includes a
versatile <tt class="class">Template</tt> class with a simplified syntax suitable for editing by end-users. This
allows users to customize their applications without having to alter the application.</p>
<p>The format uses placeholder names formed by "<tt class="samp">$</tt>" with valid Python identifiers (alphanumeric
characters and underscores). Surrounding the placeholder with braces allows it to be followed by more alphanumeric
letters with no intervening spaces. Writing "<tt class="samp">$$</tt>" creates a single escaped "<tt class=
"samp">$</tt>":</p>
<div class="verbatim">
<pre>
>>> from string import Template
>>> t = Template('\${village}folk send \$\$10 to \$cause.')
>>> t.substitute(village='Nottingham', cause='the ditch fund')
'Nottinghamfolk send \$10 to the ditch fund.'
</pre>
</div>
<p>The <tt class="method">substitute</tt> method raises a <tt class="exception">KeyError</tt> when a placeholder is
not supplied in a dictionary or a keyword argument. For mail-merge style applications, user supplied data may be
incomplete and the <tt class="method">safe_substitute</tt> method may be more appropriate -- it will leave
placeholders unchanged if data is missing:</p>
<div class="verbatim">
<pre>
>>> t = Template('Return the \$item to \$owner.')
>>> d = dict(item='unladen swallow')
>>> t.substitute(d)
Traceback (most recent call last):
. . .
KeyError: 'owner'
>>> t.safe_substitute(d)
'Return the unladen swallow to \$owner.\$'
</pre>
</div>
<p>Template subclasses can specify a custom delimiter. For example, a batch renaming utility for a photo browser may
elect to use percent signs for placeholders such as the current date, image sequence number, or file format:</p>
<div class="verbatim">
<pre>
>>> import time, os.path
>>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
>>> class BatchRename(Template):
... delimiter = '%'
>>> fmt = raw_input('Enter rename style (%d-date %n-seqnum %f-format): ')
Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f
>>> t = BatchRename(fmt)
>>> date = time.strftime('%d%b%y')
>>> for i, filename in enumerate(photofiles):
... base, ext = os.path.splitext(filename)
... newname = t.substitute(d=date, n=i, f=ext)
... print '%s --> %s' % (filename, newname)
img_1074.jpg --> Ashley_0.jpg
img_1076.jpg --> Ashley_1.jpg
img_1077.jpg --> Ashley_2.jpg
</pre>
</div>
<p>Another application for templating is separating program logic from the details of multiple output formats. This
makes it possible to substitute custom templates for XML files, plain text reports, and HTML web reports.</p>
<h1> 11.3 Working with Binary Data Record Layouts</h1>
<p>The <a class="ulink" href="../lib/module-struct.html"><tt class="module">struct</tt></a> module provides
<tt class="function">pack()</tt> and <tt class="function">unpack()</tt> functions for working with variable length
binary record formats. The following example shows how to loop through header information in a ZIP file (with pack
codes <code>"H"</code> and <code>"L"</code> representing two and four byte unsigned numbers respectively):</p>
<div class="verbatim">
<pre>
import struct
data = open('myfile.zip', 'rb').read()
start = 0
for i in range(3): # show the first 3 file headers
start += 14
fields = struct.unpack('LLLHH', data[start:start+16])
crc32, comp_size, uncomp_size, filenamesize, extra_size = fields
start += 16
filename = data[start:start+filenamesize]
start += filenamesize
extra = data[start:start+extra_size]
print filename, hex(crc32), comp_size, uncomp_size
start += extra_size + comp_size # skip to the next header
</pre>
</div>
<h1> 11.4 Multi-threading</h1>
<p>Threading is a technique for decoupling tasks which are not sequentially dependent. Threads can be used to improve
the responsiveness of applications that accept user input while other tasks run in the background. A related use case
is running I/O in parallel with computations in another thread.</p>
<p>The following code shows how the high level <a class="ulink" href="../lib/module-threading.html"><tt class=
"module">threading</tt></a> module can run tasks in background while the main program continues to run:</p>
<div class="verbatim">
<pre>
import threading, zipfile
class AsyncZip(threading.Thread):
def __init__(self, infile, outfile):
threading.Thread.__init__(self)
self.infile = infile
self.outfile = outfile
def run(self):
f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
f.write(self.infile)
f.close()
print 'Finished background zip of: ', self.infile
background = AsyncZip('mydata.txt', 'myarchive.zip')
background.start()
print 'The main program continues to run in foreground.'
background.join() # Wait for the background task to finish
print 'Main program waited until background was done.'
</pre>
</div>
<p>The principal challenge of multi-threaded applications is coordinating threads that share data or other resources.
To that end, the threading module provides a number of synchronization primitives including locks, events, condition
variables, and semaphores.</p>
<p>While those tools are powerful, minor design errors can result in problems that are difficult to reproduce. So,
the preferred approach to task coordination is to concentrate all access to a resource in a single thread and then
use the <a class="ulink" href="../lib/module-Queue.html"><tt class="module">Queue</tt></a> module to feed that thread
with requests from other threads. Applications using <tt class="class">Queue</tt> objects for inter-thread
communication and coordination are easier to design, more readable, and more reliable.</p>
<h1> 11.5 Logging</h1>
<p>The <a class="ulink" href="../lib/module-logging.html"><tt class="module">logging</tt></a> module offers a full
featured and flexible logging system. At its simplest, log messages are sent to a file or to
<code>sys.stderr</code>:</p>
<div class="verbatim">
<pre>
import logging
logging.debug('Debugging information')
logging.info('Informational message')
logging.warning('Warning:config file %s not found', 'server.conf')
logging.error('Error occurred')
logging.critical('Critical error -- shutting down')
</pre>
</div>
<p>This produces the following output:</p>
<div class="verbatim">
<pre>
WARNING:root:Warning:config file server.conf not found
ERROR:root:Error occurred
CRITICAL:root:Critical error -- shutting down
</pre>
</div>
<p>By default, informational and debugging messages are suppressed and the output is sent to standard error. Other
output options include routing messages through email, datagrams, sockets, or to an HTTP Server. New filters can
select different routing based on message priority: <tt class="constant">DEBUG</tt>, <tt class="constant">INFO</tt>,
<tt class="constant">WARNING</tt>, <tt class="constant">ERROR</tt>, and <tt class="constant">CRITICAL</tt>.</p>
<p>The logging system can be configured directly from Python or can be loaded from a user editable configuration file
for customized logging without altering the application.</p>
<h1> 11.6 Referências Fracas</h1>
<p>Python realiza gerenciamento automático de memória (contagem de referências para a maoria dos
objetos e <em>coleta de lixo</em> para eliminar ciclos). A memória é liberada logo depois da última
referência ser eliminada.</p>
<p>Essa abordagem funciona bem para a maioria das aplicações, mas ocasionalmente surge a necessidade de
rastrear objetos apenas enquanto estão sendo usados por algum outro. Infelizmente, rastreá-los através
de uma referência torna-os permanentes. O módulo <a class="ulink" href=
"../lib/module-weakref.html"><tt class="module">weakref</tt></a> oferece ferramentas para rastrear objetos sem criar
uma referência. Quando o objeto não é mais necessário, ele é automaticamente removido de uma
tabela de referências fracas e uma chamada (<em>callback</em>) é disparada. Aplicações
típicas incluem o armazenamento de objetos que são muito dispendiosos para criar:</p>
<div class="verbatim">
<pre>
>>> import weakref, gc
>>> class A:
... def __init__(self, value):
... self.value = value
... def __repr__(self):
... return str(self.value)
...
>>> a = A(10) # create a reference
>>> d = weakref.WeakValueDictionary()
>>> d['primary'] = a # does not create a reference
>>> d['primary'] # fetch the object if it is still alive
10
>>> del a # remove the one reference
>>> gc.collect() # run garbage collection right away
0
>>> d['primary'] # entry was automatically removed
Traceback (most recent call last):
File "<pyshell#108>", line 1, in -toplevel-
d['primary'] # entry was automatically removed
File "C:/PY24/lib/weakref.py", line 46, in __getitem__
o = self.data[key]()
KeyError: 'primary'
</pre>
</div>
<h1> 11.7 Trabalhando com Listas</h1>
<p>Muitas das necessidades envolvendo estruturas de dados podem ser alcançadas com listas. No entanto, as vezes
surge a necessidade de uma implementação alternativa, com diversos sacrifícios em nome de melhor
desempenho.</p>
<p>O módulo <a class="ulink" href="../lib/module-array.html"><tt class="module">array</tt></a> oferece um objeto
<tt class="class">array()</tt>, semelhante a uma lista, mas que armazena apenas dados homogêneos e de maneira
mais compacta. O exemplo a seguir mostra um vetor de números armazenados como números binários de dois
bytes sem sinal (typecode <code>"H"</code>) ao invés do usual 16 bytes por item nas listas normais de objetos
int:</p>
<div class="verbatim">
<pre>
>>> from array import array
>>> a = array('H', [4000, 10, 700, 22222])
>>> sum(a)
26932
>>> a[1:3]
array('H', [10, 700])
</pre>
</div>
<p>O módulo <a class="ulink" href="../lib/module-collections.html"><tt class="module">collections</tt></a>
oferece um objeto <tt class="class">deque()</tt> que comporta-se como uma lista com operações de
anexação (<em>append()</em>) e remoção (<em>pop()</em>) pelo lado esquerdo mais rápidos, mas
com buscas mais lentas no centro. Estes objetos são adequados para implementação de filas e buscas em
amplitudade em árvores de dados (<em>breadth first tree searches</em>):</p>
<div class="verbatim">
<pre>
>>> from collections import deque
>>> d = deque(["task1", "task2", "task3"])
>>> d.append("task4")
>>> print "Handling", d.popleft()
Handling task1
unsearched = deque([starting_node])
def breadth_first_search(unsearched):
node = unsearched.popleft()
for m in gen_moves(node):
if is_goal(m):
return m
unsearched.append(m)
</pre>
</div>
<p>Além de implementações alternativas de listas, a biblioteca também oeferece outras ferramentas
como o módulo <a class="ulink" href="../lib/module-bisect.html"><tt class="module">bisect</tt></a> com
funções para manipulações de listas ordenadas:</p>
<div class="verbatim">
<pre>
>>> import bisect
>>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
>>> bisect.insort(scores, (300, 'ruby'))
>>> scores
[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]
</pre>
</div>
<p>O módulo <a class="ulink" href="../lib/module-heapq.html"><tt class="module">heapq</tt></a> oferece
funções para implementação de heaps baseadas em listas normais. O valor mais baixo é sempre
mantido na posição zero. Isso é útil para aplicações que acessam repetidamente o menor
elemento, mas não querem reordenar a lista toda a cada acesso:</p>
<div class="verbatim">
<pre>
>>> from heapq import heapify, heappop, heappush
>>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
>>> heapify(data) # rearrange the list into heap order
>>> heappush(data, -5) # add a new entry
>>> [heappop(data) for i in range(3)] # fetch the three smallest entries
[-5, 0, 1]
</pre>
</div>
<h1> 11.8 Decimal Floating Point Arithmetic</h1>
<p>The <a class="ulink" href="../lib/module-decimal.html"><tt class="module">decimal</tt></a> module offers a
<tt class="class">Decimal</tt> datatype for decimal floating point arithmetic. Compared to the built-in <tt class=
"class">float</tt> implementation of binary floating point, the new class is especially helpful for financial
applications and other uses which require exact decimal representation, control over precision, control over rounding
to meet legal or regulatory requirements, tracking of significant decimal places, or for applications where the user
expects the results to match calculations done by hand.</p>
<p>For example, calculating a 5% tax on a 70 cent phone charge gives different results in decimal floating point and
binary floating point. The difference becomes significant if the results are rounded to the nearest cent:</p>
<div class="verbatim">
<pre>
>>> from decimal import *
>>> Decimal('0.70') * Decimal('1.05')
Decimal("0.7350")
>>> .70 * 1.05
0.73499999999999999
</pre>
</div>
<p>The <tt class="class">Decimal</tt> result keeps a trailing zero, automatically inferring four place significance
from multiplicands with two place significance. Decimal reproduces mathematics as done by hand and avoids issues that
can arise when binary floating point cannot exactly represent decimal quantities.</p>
<p>Exact representation enables the <tt class="class">Decimal</tt> class to perform modulo calculations and equality
tests that are unsuitable for binary floating point:</p>
<div class="verbatim">
<pre>
>>> Decimal('1.00') % Decimal('.10')
Decimal("0.00")
>>> 1.00 % 0.10
0.09999999999999995
>>> sum([Decimal('0.1')]*10) == Decimal('1.0')
True
>>> sum([0.1]*10) == 1.0
False
</pre>
</div>
<p>The <tt class="module">decimal</tt> module provides arithmetic with as much precision as needed:</p>
<div class="verbatim">
<pre>
>>> getcontext().prec = 36
>>> Decimal(1) / Decimal(7)
Decimal("0.142857142857142857142857142857142857")
</pre>
</div>
<h1> 12. E agora?</h1>
<p>Espera-se que a leitura deste manual tenha aguçado seu interesse em utilizar Python. Agora onde você
deve ir para aprender mais ?</p>
<p>This tutorial is part of Python's documentation set. Some other documents in the set are:</p>
<ul>
<li>
<em class="citetitle"><a href="../lib/lib.html" title="Python Library Reference">Python Library
Reference</a></em>:
<p>You should browse through this manual, which gives complete (though terse) reference material about types,
functions, and the modules in the standard library. The standard Python distribution includes a <em>lot</em> of
additional code. There are modules to read <span class="Unix">Unix</span> mailboxes, retrieve documents via HTTP,
generate random numbers, parse command-line options, write CGI programs, compress data, and many other tasks.
Skimming through the Library Reference will give you an idea of what's available.</p>
</li>
<li><em class="citetitle"><a href="../inst/inst.html" title="Installing Python Modules">Installing Python
Modules</a></em> explains how to install external modules written by other Python users.</li>
<li><em class="citetitle"><a href="../ref/ref.html" title="Language Reference">Language Reference</a></em>: A
detailed explanation of Python's syntax and semantics. It's heavy reading, but is useful as a</li>
</ul>
<p>More Python resources:</p>
<ul>
<li><a class="url" href="http://www.python.org">http://www.python.org</a>: The major Python Web site. It contains
code, documentation, and pointers to Python-related pages around the Web. This Web site is mirrored in various
places around the world, such as Europe, Japan, and Australia; a mirror may be faster than the main site, depending
on your geographical location.</li>
<li><a class="url" href="http://docs.python.org">http://docs.python.org</a>: Fast access to Python's
documentation.</li>
<li><a class="url" href="http://cheeseshop.python.org">http://cheeseshop.python.org</a>: The Python Package Index,
nicknamed the Cheese Shop, is an index of user-created Python modules that are available for download. Once you
begin releasing code, you can register it here so that others can find it.</li>
<li><a class="url" href=
"http://aspn.activestate.com/ASPN/Python/Cookbook/">http://aspn.activestate.com/ASPN/Python/Cookbook/</a>: The
Python Cookbook is a sizable collection of code examples, larger modules, and useful scripts. Particularly notable
contributions are collected in a book also titled <em class="citetitle">Python Cookbook</em> (O'Reilly &
Associates, ISBN 0-596-00797-3.)</li>
</ul>
<p>Para questões relacionadas a Python e notificação de problemas, você pode enviar uma mensagem
para o newsgroup <a class="newsgroup" href="news:comp.lang.python">comp.lang.python</a>, ou para a lista de e-mail
<span class="email">python-list@python.org</span>. Ambos estão vinculados e tanto faz mandar através de um
ou através de outro que o resultado é o mesmo. Existem em média 120 mensagens por dia (com picos de
várias centenas), perguntando e respondendo questões, sugerindo novas funcionalidades, e anunciando novos
módulos. Antes de submeter, esteja certo que o que você procura não consta na Frequently Asked
Questions (também conhecida por FAQ), em <a class="url" href=
"http://www.python.org/doc/FAQ.html">http://www.python.org/doc/FAQ.html</a>, ou procure no diretório
<span class="file">Misc/</span> da distribuição (código fonte). Os arquivos da lista de discussão
estão disponíveis em <a class="url" href=
"http://www.python.org/pipermail/">http://www.python.org/pipermail/</a>. A FAQ responde muitas das questões
reincidentes na lista, talvez lá esteja a solução para o seu problema.</p>
<h1> A. Edição de Entrada Interativa e Substituição por Histórico</h1>
<p>Algumas versões do interpretador Python suportam facilidades de edição e substituição
semelhantes as encontradas na Korn shell ou na GNU Bash shell. Isso é implementado através da biblioteca
<em>GNU Readline</em>, que suporta edição no estilo Emacs ou vi. Essa biblioteca possui sua própria
documentação, que não será duplicada aqui. Porém os fundamentos são fáceis de
serem explicados. As facilidades aqui descritas estão disponívies nas versões <span class=
"Unix">Unix</span> e Cygwin do interpretador.</p>
<p>Este capítulo não documenta as facilidades de edição do pacote PythonWin de Mark Hammond, ou
do ambiente IDLE baseado em Tk e distribuído junto com Python.</p>
<h1> A.1 Edição de Linha</h1>
<p>Se for suportado, edição de linha está ativa sempre que o interpretador imprimir um dos prompts
(primário ou secundário). A linha corrente pode ser editada usando comandos típicos do Emacs. Os mais
imoportantes são: <kbd>C-A</kbd> (Control-A) move o cursor para o início da linha, <kbd>C-E</kbd> para o
fim, <kbd>C-B</kbd> move uma posição para à esquerda, <kbd>C-F</kbd> para a direita. Backspace apaga o
caracter à esquerda, <kbd>C-D</kbd> apaga o da direita. <kbd>C-K</kbd> apaga do cursor até o resto da linha
à direita, <kbd>C-Y</kbd> cola a linha apagada. <kbd>C-underscore</kbd> é o undo e tem efeito
cumulativo.</p>
<h1> A.2 Substituição de Histórico</h1>
<p>Funciona da seguinte maneira: todas linhas não vazias são armazenadas em um buffer (histórico).
<kbd>C-P</kbd> volta uma posição no histórico, <kbd>C-N</kbd> avança uma posição.
Pressionando <kbd>Return</kbd> a linha corrente é alimentada para o interpretador. <kbd>C-R</kbd> inicia uma
busca para trás no histórico, e <kbd>C-S</kbd> um busca para frente.</p>
<h1> A.3 Vinculação de Teclas</h1>
<p>A vinculação de teclas e outros parâmetros da biblioteca Readline podem ser personalizados por
configurações colocadas no arquivo <span class="file">~/.inputrc</span>. Vinculação de teclas tem
o formato:</p>
<div class="verbatim">
<pre>
key-name: function-name
</pre>
</div>
<p>ou</p>
<div class="verbatim">
<pre>
"string": function-name
</pre>
</div>
<p>e opções podem ser especificadas com:</p>
<div class="verbatim">
<pre>
set option-name value
</pre>
</div>
<p>Por exemplo:</p>
<div class="verbatim">
<pre>
# Qume prefere editar estilo vi:
set editing-mode vi
# Edição em uma única linha:
set horizontal-scroll-mode On
# Redefinição de algumas teclas:
Meta-h: backward-kill-word
"\C-u": universal-argument
"\C-x\C-r": re-read-init-file
</pre>
</div>
<p>Observe que a vinculação default para <kbd>Tab</kbd> em Python é inserir um caracter <kbd>Tab</kbd>
ao invés de completar o nome de um arquivo (default no Readline). Isto pode ser reconfigurado de volta
através:</p>
<div class="verbatim">
<pre>
Tab: complete
</pre>
</div>
<p>no <span class="file">~/.inputrc</span>. Todavia, isto torna mais difícil digitar comandos identados em
linhas de continuação se você estiver acostumado a usar <kbd>Tab</kbd> para isso.</p>
<p>Preenchimento automático de nomes de variáveis e módulos estão opcionalmente disponívies.
Para habilitá-los no modo interativo, adicione o seguinte ao seu arquivo de inicialização: <a name=
"tex2html6" href="#foot1971"><sup>A.1</sup></a><a id='l2h-33' xml:id='l2h-33'></a></p>
<div class="verbatim">
<pre>
import rlcompleter, readline
readline.parse_and_bind('tab: complete')
</pre>
</div>
<p>Isso vincula a tecla <kbd>Tab</kbd> para o preenchimento automático de nomes de função. Assim,
teclar <kbd>Tab</kbd> duas vezes dispara o preenchimento. Um determinado nome é procurado entre as
variáveis locais e módulos disponíveis. Para expressões terminadas em ponto, como em
<code>string.a</code>, a expressão será avaliada até o último "<tt class="character">.</tt>"
quando serão sugeridos possíveis extensões. Isso pode até implicar na execução de
código definido por aplicação quando um objeto que define o método <tt class=
"method">__getattr__()</tt> for parte da expressão.</p>
<p>Um arquivo de inicialização mais eficiente seria algo como esse exemplo. Note que ele deleta os nomes
que cria quando não são mais necessários; isso é feito porque o arquivo de
inicialização é executado no mesmo ambiente do que os comandos interativos, e remover os nomes evita
criar efeitos colaterais nos ambiente usado interativamente. Você pode achar conveniente manter alguns dos
módulos importados, como <a class="ulink" href="../lib/module-os.html"><tt class="module">os</tt></a>, que acaba
sendo necessário na maior parte das sessões com o interpretador.</p>
<div class="verbatim">
<pre>
# Add auto-completion and a stored history file of commands to your Python
# interactive interpreter. Requires Python 2.0+, readline. Autocomplete is
# bound to the Esc key by default (you can change it - see readline docs).
#
# Store the file in ~/.pystartup, and set an environment variable to point
# to it: "export PYTHONSTARTUP=/max/home/itamar/.pystartup" in bash.
#
# Note that PYTHONSTARTUP does *not* expand "~", so you have to put in the
# full path to your home directory.
import atexit
import os
import readline
import rlcompleter
historyPath = os.path.expanduser("~/.pyhistory")
def save_history(historyPath=historyPath):
import readline
readline.write_history_file(historyPath)
if os.path.exists(historyPath):
readline.read_history_file(historyPath)
atexit.register(save_history)
del os, atexit, readline, rlcompleter, save_history, historyPath
</pre>
</div>
<h1> A.4 Comentário</h1>
<p>Essa facilidade representa um enorme passo em comparação com versões anteriores do interpretador.
Todavia, ainda há características desejáveis deixadas de fora. Seria interessante se a
indentação apropriada fosse sugerida em linhas de continuação, pois o parser sabe se um token de
identação é necessário. O mecanismo de preenchimento poderia utilizar a tabela de símbolos
do interpretador. Também seria útil um comando para verificar (ou até mesmo sugerir) o balanceamento
de parênteses, aspas, etc.</p>
<h1> B. Floating Point Arithmetic: Issues and Limitations</h1>
<p>Floating-point numbers are represented in computer hardware as base 2 (binary) fractions. For example, the decimal
fraction</p>
<div class="verbatim">
<pre>
0.125
</pre>
</div>
<p>has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction</p>
<div class="verbatim">
<pre>
0.001
</pre>
</div>
<p>has value 0/2 + 0/4 + 1/8. These two fractions have identical values, the only real difference being that the
first is written in base 10 fractional notation, and the second in base 2.</p>
<p>Unfortunately, most decimal fractions cannot be represented exactly as binary fractions. A consequence is that, in
general, the decimal floating-point numbers you enter are only approximated by the binary floating-point numbers
actually stored in the machine.</p>
<p>The problem is easier to understand at first in base 10. Consider the fraction 1/3. You can approximate that as a
base 10 fraction:</p>
<div class="verbatim">
<pre>
0.3
</pre>
</div>
<p>or, better,</p>
<div class="verbatim">
<pre>
0.33
</pre>
</div>
<p>or, better,</p>
<div class="verbatim">
<pre>
0.333
</pre>
</div>
<p>and so on. No matter how many digits you're willing to write down, the result will never be exactly 1/3, but will
be an increasingly better approximation of 1/3.</p>
<p>In the same way, no matter how many base 2 digits you're willing to use, the decimal value 0.1 cannot be
represented exactly as a base 2 fraction. In base 2, 1/10 is the infinitely repeating fraction</p>
<div class="verbatim">
<pre>
0.0001100110011001100110011001100110011001100110011...
</pre>
</div>
<p>Stop at any finite number of bits, and you get an approximation. This is why you see things like:</p>
<div class="verbatim">
<pre>
>>> 0.1
0.10000000000000001
</pre>
</div>
<p>On most machines today, that is what you'll see if you enter 0.1 at a Python prompt. You may not, though, because
the number of bits used by the hardware to store floating-point values can vary across machines, and Python only
prints a decimal approximation to the true decimal value of the binary approximation stored by the machine. On most
machines, if Python were to print the true decimal value of the binary approximation stored for 0.1, it would have to
display</p>
<div class="verbatim">
<pre>
>>> 0.1
0.1000000000000000055511151231257827021181583404541015625
</pre>
</div>
<p>instead! The Python prompt uses the builtin <tt class="function">repr()</tt> function to obtain a string version
of everything it displays. For floats, <code>repr(<var>float</var>)</code> rounds the true decimal value to 17
significant digits, giving</p>
<div class="verbatim">
<pre>
0.10000000000000001
</pre>
</div>
<p><code>repr(<var>float</var>)</code> produces 17 significant digits because it turns out that's enough (on most
machines) so that <code>eval(repr(<var>x</var>)) == <var>x</var></code> exactly for all finite floats <var>x</var>,
but rounding to 16 digits is not enough to make that true.</p>
<p>Note that this is in the very nature of binary floating-point: this is not a bug in Python, it is not a bug in
your code either. You'll see the same kind of thing in all languages that support your hardware's floating-point
arithmetic (although some languages may not <em>display</em> the difference by default, or in all output modes).</p>
<p>Python's builtin <tt class="function">str()</tt> function produces only 12 significant digits, and you may wish to
use that instead. It's unusual for <code>eval(str(<var>x</var>))</code> to reproduce <var>x</var>, but the output may
be more pleasant to look at:</p>
<div class="verbatim">
<pre>
>>> print str(0.1)
0.1
</pre>
</div>
<p>It's important to realize that this is, in a real sense, an illusion: the value in the machine is not exactly
1/10, you're simply rounding the <em>display</em> of the true machine value.</p>
<p>Other surprises follow from this one. For example, after seeing</p>
<div class="verbatim">
<pre>
>>> 0.1
0.10000000000000001
</pre>
</div>
<p>you may be tempted to use the <tt class="function">round()</tt> function to chop it back to the single digit you
expect. But that makes no difference:</p>
<div class="verbatim">
<pre>
>>> round(0.1, 1)
0.10000000000000001
</pre>
</div>
<p>The problem is that the binary floating-point value stored for "0.1" was already the best possible binary
approximation to 1/10, so trying to round it again can't make it better: it was already as good as it gets.</p>
<p>Another consequence is that since 0.1 is not exactly 1/10, summing ten values of 0.1 may not yield exactly 1.0,
either:</p>
<div class="verbatim">
<pre>
>>> sum = 0.0
>>> for i in range(10):
... sum += 0.1
...
>>> sum
0.99999999999999989
</pre>
</div>
<p>Binary floating-point arithmetic holds many surprises like this. The problem with "0.1" is explained in precise
detail below, in the "Representation Error" section. See <em class="citetitle"><a href=
"http://www.lahey.com/float.htm" title="The Perils of Floating Point">The Perils of Floating Point</a></em> for a
more complete account of other common surprises.</p>
<p>As that says near the end, ``there are no easy answers.'' Still, don't be unduly wary of floating-point! The
errors in Python float operations are inherited from the floating-point hardware, and on most machines are on the
order of no more than 1 part in 2**53 per operation. That's more than adequate for most tasks, but you do need to
keep in mind that it's not decimal arithmetic, and that every float operation can suffer a new rounding error.</p>
<p>While pathological cases do exist, for most casual use of floating-point arithmetic you'll see the result you
expect in the end if you simply round the display of your final results to the number of decimal digits you expect.
<tt class="function">str()</tt> usually suffices, and for finer control see the discussion of Python's <code>%</code>
format operator: the <code>%g</code>, <code>%f</code> and <code>%e</code> format codes supply flexible and easy ways
to round float results for display.</p>
<h1> B.1 Representation Error</h1>
<p>This section explains the ``0.1'' example in detail, and shows how you can perform an exact analysis of cases like
this yourself. Basic familiarity with binary floating-point representation is assumed.</p>
<p><i class="dfn">Representation error</i> refers to the fact that some (most, actually) decimal fractions cannot be
represented exactly as binary (base 2) fractions. This is the chief reason why Python (or Perl, C, C++, Java,
Fortran, and many others) often won't display the exact decimal number you expect:</p>
<div class="verbatim">
<pre>
>>> 0.1
0.10000000000000001
</pre>
</div>
<p>Why is that? 1/10 is not exactly representable as a binary fraction. Almost all machines today (November 2000) use
IEEE-754 floating point arithmetic, and almost all platforms map Python floats to IEEE-754 "double precision". 754
doubles contain 53 bits of precision, so on input the computer strives to convert 0.1 to the closest fraction it can
of the form <var>J</var>/2**<var>N</var> where <var>J</var> is an integer containing exactly 53 bits. Rewriting</p>
<div class="verbatim">
<pre>
1 / 10 ~= J / (2**N)
</pre>
</div>
<p>as</p>
<div class="verbatim">
<pre>
J ~= 2**N / 10
</pre>
</div>
<p>and recalling that <var>J</var> has exactly 53 bits (is <code>>= 2**52</code> but <code>< 2**53</code>), the
best value for <var>N</var> is 56:</p>
<div class="verbatim">
<pre>
>>> 2**52
4503599627370496L
>>> 2**53
9007199254740992L
>>> 2**56/10
7205759403792793L
</pre>
</div>
<p>That is, 56 is the only value for <var>N</var> that leaves <var>J</var> with exactly 53 bits. The best possible
value for <var>J</var> is then that quotient rounded:</p>
<div class="verbatim">
<pre>
>>> q, r = divmod(2**56, 10)
>>> r
6L
</pre>
</div>
<p>Since the remainder is more than half of 10, the best approximation is obtained by rounding up:</p>
<div class="verbatim">
<pre>
>>> q+1
7205759403792794L
</pre>
</div>
<p>Therefore the best possible approximation to 1/10 in 754 double precision is that over 2**56, or</p>
<div class="verbatim">
<pre>
7205759403792794 / 72057594037927936
</pre>
</div>
<p>Note that since we rounded up, this is actually a little bit larger than 1/10; if we had not rounded up, the
quotient would have been a little bit smaller than 1/10. But in no case can it be <em>exactly</em> 1/10!</p>
<p>So the computer never ``sees'' 1/10: what it sees is the exact fraction given above, the best 754 double
approximation it can get:</p>
<div class="verbatim">
<pre>
>>> .1 * 2**56
7205759403792794.0
</pre>
</div>
<p>If we multiply that fraction by 10**30, we can see the (truncated) value of its 30 most significant decimal
digits:</p>
<div class="verbatim">
<pre>
>>> 7205759403792794 * 10**30 / 2**56
100000000000000005551115123125L
</pre>
</div>
<p>meaning that the exact number stored in the computer is approximately equal to the decimal value
0.100000000000000005551115123125. Rounding that to 17 significant digits gives the 0.10000000000000001 that Python
displays (well, will display on any 754-conforming platform that does best-possible input and output conversions in
its C library -- yours may not!).</p>
<h1><a name="SECTION0017000000000000000000">C. History and License</a></h1>
<h1><a name="SECTION0017100000000000000000">C.1 History of the software</a></h1>
<p>Python was created in the early 1990s by Guido van Rossum at Stichting Mathematisch Centrum (CWI, see <a class=
"url" href="http://www.cwi.nl/">http://www.cwi.nl/</a>) in the Netherlands as a successor of a language called ABC.
Guido remains Python's principal author, although it includes many contributions from others.</p>
<p>In 1995, Guido continued his work on Python at the Corporation for National Research Initiatives (CNRI, see
<a class="url" href="http://www.cnri.reston.va.us/">http://www.cnri.reston.va.us/</a>) in Reston, Virginia where he
released several versions of the software.</p>
<p>In May 2000, Guido and the Python core development team moved to BeOpen.com to form the BeOpen PythonLabs team. In
October of the same year, the PythonLabs team moved to Digital Creations (now Zope Corporation; see <a class="url"
href="http://www.zope.com/">http://www.zope.com/</a>). In 2001, the Python Software Foundation (PSF, see <a class=
"url" href="http://www.python.org/psf/">http://www.python.org/psf/</a>) was formed, a non-profit organization created
specifically to own Python-related Intellectual Property. Zope Corporation is a sponsoring member of the PSF.</p>
<p>All Python releases are Open Source (see <a class="url" href=
"http://www.opensource.org/">http://www.opensource.org/</a> for the Open Source Definition). Historically, most, but
not all, Python releases have also been GPL-compatible; the table below summarizes the various releases.</p>
<div class="center">
<table class="realtable">
<thead>
<tr>
<th class="center">Release</th>
<th class="center">Derived from</th>
<th class="center">Year</th>
<th class="center">Owner</th>
<th class="center">GPL compatible?</th>
</tr>
</thead>
<tbody>
<tr>
<td class="center" valign="baseline">0.9.0 thru 1.2</td>
<td class="center">n/a</td>
<td class="center">1991-1995</td>
<td class="center">CWI</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">1.3 thru 1.5.2</td>
<td class="center">1.2</td>
<td class="center">1995-1999</td>
<td class="center">CNRI</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">1.6</td>
<td class="center">1.5.2</td>
<td class="center">2000</td>
<td class="center">CNRI</td>
<td class="center">no</td>
</tr>
<tr>
<td class="center" valign="baseline">2.0</td>
<td class="center">1.6</td>
<td class="center">2000</td>
<td class="center">BeOpen.com</td>
<td class="center">no</td>
</tr>
<tr>
<td class="center" valign="baseline">1.6.1</td>
<td class="center">1.6</td>
<td class="center">2001</td>
<td class="center">CNRI</td>
<td class="center">no</td>
</tr>
<tr>
<td class="center" valign="baseline">2.1</td>
<td class="center">2.0+1.6.1</td>
<td class="center">2001</td>
<td class="center">PSF</td>
<td class="center">no</td>
</tr>
<tr>
<td class="center" valign="baseline">2.0.1</td>
<td class="center">2.0+1.6.1</td>
<td class="center">2001</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.1.1</td>
<td class="center">2.1+2.0.1</td>
<td class="center">2001</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.2</td>
<td class="center">2.1.1</td>
<td class="center">2001</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.1.2</td>
<td class="center">2.1.1</td>
<td class="center">2002</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.1.3</td>
<td class="center">2.1.2</td>
<td class="center">2002</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.2.1</td>
<td class="center">2.2</td>
<td class="center">2002</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.2.2</td>
<td class="center">2.2.1</td>
<td class="center">2002</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.2.3</td>
<td class="center">2.2.2</td>
<td class="center">2002-2003</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.3</td>
<td class="center">2.2.2</td>
<td class="center">2002-2003</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.3.1</td>
<td class="center">2.3</td>
<td class="center">2002-2003</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.3.2</td>
<td class="center">2.3.1</td>
<td class="center">2003</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.3.3</td>
<td class="center">2.3.2</td>
<td class="center">2003</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.3.4</td>
<td class="center">2.3.3</td>
<td class="center">2004</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.3.5</td>
<td class="center">2.3.4</td>
<td class="center">2005</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.4</td>
<td class="center">2.3</td>
<td class="center">2004</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
<tr>
<td class="center" valign="baseline">2.4.1</td>
<td class="center">2.4</td>
<td class="center">2005</td>
<td class="center">PSF</td>
<td class="center">yes</td>
</tr>
</tbody>
</table>
</div>
<p><span class="note"><b class="label">Note:</b> GPL-compatible doesn't mean that we're distributing Python under the
GPL. All Python licenses, unlike the GPL, let you distribute a modified version without making your changes open
source. The GPL-compatible licenses make it possible to combine Python with other software that is released under the
GPL; the others don't.</span></p>
<p>Thanks to the many outside volunteers who have worked under Guido's direction to make these releases possible.</p>
<h1><a name="SECTION0017200000000000000000">C.2 Terms and conditions for accessing or otherwise using Python</a></h1>
<div class="centerline" id="par10628" align="center">
<strong>PSF LICENSE AGREEMENT FOR PYTHON 2.4.2</strong>
</div>
<ol>
<li>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.</li>
<li>Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
works, distribute, and otherwise use Python 2.4.2 alone or in any derivative version, provided, however, that PSF's
License Agreement and PSF's notice of copyright, i.e., ``Copyright © 2001-2004 Python Software Foundation; All
Rights Reserved'' are retained in Python 2.4.2 alone or in any derivative version prepared by Licensee.</li>
<li>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.</li>
<li>PSF is making Python 2.4.2 available to Licensee on an ``AS IS'' basis. PSF MAKES NO REPRESENTATIONS OR
WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY
REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.4.2
WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.</li>
<li>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 MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.4.2, OR ANY
DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.</li>
<li>This License Agreement will automatically terminate upon a material breach of its terms and conditions.</li>
<li>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.</li>
<li>By copying, installing or otherwise using Python 2.4.2, Licensee agrees to be bound by the terms and conditions
of this License Agreement.</li>
</ol>
<div class="centerline" id="par10629" align="center">
<strong>BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0</strong>
</div>
<div class="centerline" id="par10630" align="center">
<strong>BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1</strong>
</div>
<ol>
<li>This LICENSE AGREEMENT is between BeOpen.com (``BeOpen''), having an office at 160 Saratoga Avenue, Santa
Clara, CA 95051, and the Individual or Organization (``Licensee'') accessing and otherwise using this software in
source or binary form and its associated documentation (``the Software'').</li>
<li>Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants Licensee a
non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly,
prepare derivative works, distribute, and otherwise use the Software alone or in any derivative version, provided,
however, that the BeOpen Python License is retained in the Software, alone or in any derivative version prepared by
Licensee.</li>
<li>BeOpen is making the Software available to Licensee on an ``AS IS'' basis. BEOPEN MAKES NO REPRESENTATIONS OR
WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY
REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE
WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.</li>
<li>BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR
CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE
THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.</li>
<li>This License Agreement will automatically terminate upon a material breach of its terms and conditions.</li>
<li>This License Agreement shall be governed by and interpreted in all respects by the law of the State of
California, excluding conflict of law provisions. Nothing in this License Agreement shall be deemed to create any
relationship of agency, partnership, or joint venture between BeOpen and Licensee. This License Agreement does not
grant permission to use BeOpen trademarks or trade names in a trademark sense to endorse or promote products or
services of Licensee, or any third party. As an exception, the ``BeOpen Python'' logos available at
http://www.pythonlabs.com/logos.html may be used according to the permissions granted on that web page.</li>
<li>By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and conditions
of this License Agreement.</li>
</ol>
<div class="centerline" id="par10631" align="center">
<strong>CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1</strong>
</div>
<ol>
<li>This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an office at 1895
Preston White Drive, Reston, VA 20191 (``CNRI''), and the Individual or Organization (``Licensee'') accessing and
otherwise using Python 1.6.1 software in source or binary form and its associated documentation.</li>
<li>Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a nonexclusive,
royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
works, distribute, and otherwise use Python 1.6.1 alone or in any derivative version, provided, however, that
CNRI's License Agreement and CNRI's notice of copyright, i.e., ``Copyright © 1995-2001 Corporation for
National Research Initiatives; All Rights Reserved'' are retained in Python 1.6.1 alone or in any derivative
version prepared by Licensee. Alternately, in lieu of CNRI's License Agreement, Licensee may substitute the
following text (omitting the quotes): ``Python 1.6.1 is made available subject to the terms and conditions in
CNRI's License Agreement. This Agreement together with Python 1.6.1 may be located on the Internet using the
following unique, persistent identifier (known as a handle): 1895.22/1013. This Agreement may also be obtained from
a proxy server on the Internet using the following URL: <a class="url" href=
"http://hdl.handle.net/1895.22/1013">http://hdl.handle.net/1895.22/1013</a>.''</li>
<li>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.</li>
<li>CNRI is making Python 1.6.1 available to Licensee on an ``AS IS'' basis. CNRI MAKES NO REPRESENTATIONS OR
WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY
REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1
WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.</li>
<li>CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR
CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY
DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.</li>
<li>This License Agreement will automatically terminate upon a material breach of its terms and conditions.</li>
<li>This License Agreement shall be governed by the federal intellectual property law of the United States,
including without limitation the federal copyright law, and, to the extent such U.S. federal law does not apply, by
the law of the Commonwealth of Virginia, excluding Virginia's conflict of law provisions. Notwithstanding the
foregoing, with regard to derivative works based on Python 1.6.1 that incorporate non-separable material that was
previously distributed under the GNU General Public License (GPL), the law of the Commonwealth of Virginia shall
govern this License Agreement only as to issues arising under or with respect to Paragraphs 4, 5, and 7 of this
License Agreement. Nothing in this License Agreement shall be deemed to create any relationship of agency,
partnership, or joint venture between CNRI and Licensee. This License Agreement does not grant permission to use
CNRI trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any
third party.</li>
<li>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.</li>
</ol>
<div class="centerline" id="par10632" align="center">
ACCEPT
</div>
<div class="centerline" id="par10633" align="center">
<strong>CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2</strong>
</div>
<p>Copyright © 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands. All rights reserved.</p>
<p>Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without
fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting documentation, and that the name of Stichting Mathematisch
Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software without specific,
written prior permission.</p>
<p>STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
OR PERFORMANCE OF THIS SOFTWARE.</p>
<h1><a name="SECTION0017300000000000000000">C.3 Licenses and Acknowledgements for Incorporated Software</a></h1>
<p>This section is an incomplete, but growing list of licenses and acknowledgements for third-party software
incorporated in the Python distribution.</p>
<h2><a name="SECTION0017310000000000000000">C.3.1 Mersenne Twister</a></h2>
<p>The <tt class="module">_random</tt> module includes code based on a download from <a class="url" href=
"http://www.math.keio.ac.jp/~matumoto/MT2002/emt19937ar.html">http://www.math.keio.ac.jp/~matumoto/MT2002/emt19937ar.html</a>.
The following are the verbatim comments from the original code:</p>
<div class="verbatim">
<pre>
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
</pre>
</div>
<h2><a name="SECTION0017320000000000000000">C.3.2 Sockets</a></h2>
<p>The <tt class="module">socket</tt> module uses the functions, <tt class="function">getaddrinfo</tt>, and
<tt class="function">getnameinfo</tt>, which are coded in separate source files from the WIDE Project, <a class="url"
href="http://www.wide.ad.jp/about/index.html">http://www.wide.ad.jp/about/index.html</a>.</p>
<div class="verbatim">
<pre>
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.
</pre>
</div>
<h2><a name="SECTION0017330000000000000000">C.3.3 Floating point exception control</a></h2>
<p>The source for the <tt class="module">fpectl</tt> module includes the following notice:</p>
<div class="verbatim">
<pre>
---------------------------------------------------------------------
/ 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. /
---------------------------------------------------------------------
</pre>
</div>
<h2><a name="SECTION0017340000000000000000">C.3.4 MD5 message digest algorithm</a></h2>
<p>The source code for the <tt class="module">md5</tt> module contains the following notice:</p>
<div class="verbatim">
<pre>
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.
</pre>
</div>
<h2><a name="SECTION0017350000000000000000">C.3.5 Asynchronous socket services</a></h2>
<p>The <tt class="module">asynchat</tt> and <tt class="module">asyncore</tt> modules contain the following
notice:</p>
<div class="verbatim">
<pre>
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.
</pre>
</div>
<h2><a name="SECTION0017360000000000000000">C.3.6 Cookie management</a></h2>
<p>The <tt class="module">Cookie</tt> module contains the following notice:</p>
<div class="verbatim">
<pre>
Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>
All Rights Reserved
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Timothy O'Malley not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.
Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
</pre>
</div>
<h2><a name="SECTION0017370000000000000000">C.3.7 Profiling</a></h2>
<p>The <tt class="module">profile</tt> and <tt class="module">pstats</tt> modules contain the following notice:</p>
<div class="verbatim">
<pre>
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.
</pre>
</div>
<h2><a name="SECTION0017380000000000000000">C.3.8 Execution tracing</a></h2>
<p>The <tt class="module">trace</tt> module contains the following notice:</p>
<div class="verbatim">
<pre>
portions copyright 2001, Autonomous Zones Industries, Inc., all rights...
err... reserved and offered to the public under the terms of the
Python 2.2 license.
Author: Zooko O'Whielacronx
http://zooko.com/
mailto:zooko@zooko.com
Copyright 2000, Mojam Media, Inc., all rights reserved.
Author: Skip Montanaro
Copyright 1999, Bioreason, Inc., all rights reserved.
Author: Andrew Dalke
Copyright 1995-1997, Automatrix, Inc., all rights reserved.
Author: Skip Montanaro
Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved.
Permission to use, copy, modify, and distribute this Python software and
its associated documentation for any purpose without fee is hereby
granted, provided that the above copyright notice appears in all copies,
and that both that copyright notice and this permission notice appear in
supporting documentation, and that the name of neither Automatrix,
Bioreason or Mojam Media be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.
</pre>
</div>
<h2><a name="SECTION0017390000000000000000">C.3.9 UUencode and UUdecode functions</a></h2>
<p>The <tt class="module">uu</tt> module contains the following notice:</p>
<div class="verbatim">
<pre>
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
</pre>
</div>
<h2><a name="SECTION00173100000000000000000">C.3.10 XML Remote Procedure Calls</a></h2>
<p>The <tt class="module">xmlrpclib</tt> module contains the following notice:</p>
<div class="verbatim">
<pre>
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.
</pre>
</div>
<h1> D. Glossary</h1>
<dl>
<dd><a id='l2h-34' xml:id='l2h-34'></a></dd>
<dt><strong><code>></code>></strong>></dt>
<dd>
The typical Python prompt of the interactive shell. Often seen for code examples that can be tried right away in
the interpreter.
<p><a id='l2h-35' xml:id='l2h-35'></a></p>
</dd>
<dt><strong><code>.</code>.</strong>.</dt>
<dd>
The typical Python prompt of the interactive shell when entering code for an indented code block.
<p><a id='l2h-36' xml:id='l2h-36'></a></p>
</dd>
<dt><strong>BDFL</strong></dt>
<dd>
Benevolent Dictator For Life, a.k.a. <a class="ulink" href="http://www.python.org/~guido/">Guido van Rossum</a>,
Python's creator.
<p><a id='l2h-37' xml:id='l2h-37'></a></p>
</dd>
<dt><strong>byte code</strong></dt>
<dd>
The internal representation of a Python program in the interpreter. The byte code is also cached in
<code>.pyc</code> and <code>.pyo</code> files so that executing the same file is faster the second time
(recompilation from source to byte code can be avoided). This ``intermediate language'' is said to run on a
``virtual machine'' that calls the subroutines corresponding to each bytecode.
<p><a id='l2h-38' xml:id='l2h-38'></a></p>
</dd>
<dt><strong>classic class</strong></dt>
<dd>
Any class which does not inherit from <tt class="class">object</tt>. See <em>new-style class</em>.
<p><a id='l2h-39' xml:id='l2h-39'></a></p>
</dd>
<dt><strong>coercion</strong></dt>
<dd>
The implicit conversion of an instance of one type to another during an operation which involves two arguments of
the same type. For example, <code>int(3.15)</code> converts the floating point number to the integer
<code>3</code>, but in <code>3+4.5</code>, each argument is of a different type (one int, one float), and both
must be converted to the same type before they can be added or it will raise a <code>TypeError</code>. Coercion
between two operands can be performed with the <code>coerce</code> builtin function; thus, <code>3+4.5</code> is
equivalent to calling <code>operator.add(*coerce(3, 4.5))</code> and results in <code>operator.add(3.0,
4.5)</code>. Without coercion, all arguments of even compatible types would have to be normalized to the same
value by the programmer, e.g., <code>float(3)+4.5</code> rather than just <code>3+4.5</code>.
<p><a id='l2h-40' xml:id='l2h-40'></a></p>
</dd>
<dt><strong>complex number</strong></dt>
<dd>
An extension of the familiar real number system in which all numbers are expressed as a sum of a real part and an
imaginary part. Imaginary numbers are real multiples of the imaginary unit (the square root of <code>-1</code>),
often written <code>i</code> in mathematics or <code>j</code> in engineering. Python has builtin support for
complex numbers, which are written with this latter notation; the imaginary part is written with a <code>j</code>
suffix, e.g., <code>3+1j</code>. To get access to complex equivalents of the <tt class="module">math</tt> module,
use <tt class="module">cmath</tt>. Use of complex numbers is a fairly advanced mathematical feature. If you're
not aware of a need for them, it's almost certain you can safely ignore them.
<p><a id='l2h-41' xml:id='l2h-41'></a></p>
</dd>
<dt><strong>descriptor</strong></dt>
<dd>
Any <em>new-style</em> object that defines the methods <tt class="method">__get__()</tt>, <tt class=
"method">__set__()</tt>, or <tt class="method">__delete__()</tt>. When a class attribute is a descriptor, its
special binding behavior is triggered upon attribute lookup. Normally, writing <var>a.b</var> looks up the object
<var>b</var> in the class dictionary for <var>a</var>, but if <var>b</var> is a descriptor, the defined method
gets called. Understanding descriptors is a key to a deep understanding of Python because they are the basis for
many features including functions, methods, properties, class methods, static methods, and reference to super
classes.
<p><a id='l2h-42' xml:id='l2h-42'></a></p>
</dd>
<dt><strong>dictionary</strong></dt>
<dd>
An associative array, where arbitrary keys are mapped to values. The use of <tt class="class">dict</tt> much
resembles that for <tt class="class">list</tt>, but the keys can be any object with a <tt class=
"method">__hash__()</tt> function, not just integers starting from zero. Called a hash in Perl.
<p><a id='l2h-43' xml:id='l2h-43'></a></p>
</dd>
<dt><strong>duck-typing</strong></dt>
<dd>
Pythonic programming style that determines an object's type by inspection of its method or attribute signature
rather than by explicit relationship to some type object ("If it looks like a duck and quacks like a duck, it
must be a duck.") By emphasizing interfaces rather than specific types, well-designed code improves its
flexibility by allowing polymorphic substitution. Duck-typing avoids tests using <tt class="function">type()</tt>
or <tt class="function">isinstance()</tt>. Instead, it typically employs <tt class="function">hasattr()</tt>
tests or <em>EAFP</em> programming.
<p><a id='l2h-44' xml:id='l2h-44'></a></p>
</dd>
<dt><strong>EAFP</strong></dt>
<dd>
Easier to ask for forgiveness than permission. This common Python coding style assumes the existence of valid
keys or attributes and catches exceptions if the assumption proves false. This clean and fast style is
characterized by the presence of many <tt class="keyword">try</tt> and <tt class="keyword">except</tt>
statements. The technique contrasts with the <em>LBYL</em> style that is common in many other languages such as
C.
<p><a id='l2h-45' xml:id='l2h-45'></a></p>
</dd>
<dt><strong>__future__</strong></dt>
<dd>
A pseudo module which programmers can use to enable new language features which are not compatible with the
current interpreter. For example, the expression <code>11/4</code> currently evaluates to <code>2</code>. If the
module in which it is executed had enabled <em>true division</em> by executing:
<div class="verbatim">
<pre>
from __future__ import division
</pre>
</div>
<p>the expression <code>11/4</code> would evaluate to <code>2.75</code>. By importing the <a class="ulink" href=
"../lib/module-future.html"><tt class="module">__future__</tt></a> module and evaluating its variables, you can
see when a new feature was first added to the language and when it will become the default:</p>
<div class="verbatim">
<pre>
>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
</pre>
</div>
<p><a id='l2h-46' xml:id='l2h-46'></a></p>
</dd>
<dt><strong>generator</strong></dt>
<dd>
A function that returns an iterator. It looks like a normal function except that values are returned to the
caller using a <tt class="keyword">yield</tt> statement instead of a <tt class="keyword">return</tt> statement.
Generator functions often contain one or more <tt class="keyword">for</tt> or <tt class="keyword">while</tt>
loops that <tt class="keyword">yield</tt> elements back to the caller. The function execution is stopped at the
<tt class="keyword">yield</tt> keyword (returning the result) and is resumed there when the next element is
requested by calling the <tt class="method">next()</tt> method of the returned iterator.
<p><a id='l2h-47' xml:id='l2h-47'></a></p>
</dd>
<dt><strong>generator expression</strong></dt>
<dd>
An expression that returns a generator. It looks like a normal expression followed by a <tt class=
"keyword">for</tt> expression defining a loop variable, range, and an optional <tt class="keyword">if</tt>
expression. The combined expression generates values for an enclosing function:
<div class="verbatim">
<pre>
>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81
285
</pre>
</div>
<p><a id='l2h-48' xml:id='l2h-48'></a></p>
</dd>
<dt><strong>GIL</strong></dt>
<dd>
See <em>global interpreter lock</em>.
<p><a id='l2h-49' xml:id='l2h-49'></a></p>
</dd>
<dt><strong>global interpreter lock</strong></dt>
<dd>
The lock used by Python threads to assure that only one thread can be run at a time. This simplifies Python by
assuring that no two processes can access the same memory at the same time. Locking the entire interpreter makes
it easier for the interpreter to be multi-threaded, at the expense of some parallelism on multi-processor
machines. Efforts have been made in the past to create a ``free-threaded'' interpreter (one which locks shared
data at a much finer granularity), but performance suffered in the common single-processor case.
<p><a id='l2h-50' xml:id='l2h-50'></a></p>
</dd>
<dt><strong>IDLE</strong></dt>
<dd>
An Integrated Development Environment for Python. IDLE is a basic editor and interpreter environment that ships
with the standard distribution of Python. Good for beginners, it also serves as clear example code for those
wanting to implement a moderately sophisticated, multi-platform GUI application.
<p><a id='l2h-51' xml:id='l2h-51'></a></p>
</dd>
<dt><strong>immutable</strong></dt>
<dd>
An object with fixed value. Immutable objects are numbers, strings or tuples (and more). Such an object cannot be
altered. A new object has to be created if a different value has to be stored. They play an important role in
places where a constant hash value is needed, for example as a key in a dictionary.
<p><a id='l2h-52' xml:id='l2h-52'></a></p>
</dd>
<dt><strong>integer division</strong></dt>
<dd>
Mathematical division discarding any remainder. For example, the expression <code>11/4</code> currently evaluates
to <code>2</code> in contrast to the <code>2.75</code> returned by float division. Also called <em>floor
division</em>. When dividing two integers the outcome will always be another integer (having the floor function
applied to it). However, if one of the operands is another numeric type (such as a <tt class="class">float</tt>),
the result will be coerced (see <em>coercion</em>) to a common type. For example, an integer divided by a float
will result in a float value, possibly with a decimal fraction. Integer division can be forced by using the
<code>//</code> operator instead of the <code>/</code> operator. See also <em>__future__</em>.
<p><a id='l2h-53' xml:id='l2h-53'></a></p>
</dd>
<dt><strong>interactive</strong></dt>
<dd>
Python has an interactive interpreter which means that you can try out things and immediately see their results.
Just launch <code>python</code> with no arguments (possibly by selecting it from your computer's main menu). It
is a very powerful way to test out new ideas or inspect modules and packages (remember <code>help(x)</code>).
<p><a id='l2h-54' xml:id='l2h-54'></a></p>
</dd>
<dt><strong>interpreted</strong></dt>
<dd>
Python is an interpreted language, as opposed to a compiled one. This means that the source files can be run
directly without first creating an executable which is then run. Interpreted languages typically have a shorter
development/debug cycle than compiled ones, though their programs generally also run more slowly. See also
<em>interactive</em>.
<p><a id='l2h-55' xml:id='l2h-55'></a></p>
</dd>
<dt><strong>iterable</strong></dt>
<dd>
A container object capable of returning its members one at a time. Examples of iterables include all sequence
types (such as <tt class="class">list</tt>, <tt class="class">str</tt>, and <tt class="class">tuple</tt>) and
some non-sequence types like <tt class="class">dict</tt> and <tt class="class">file</tt> and objects of any
classes you define with an <tt class="method">__iter__()</tt> or <tt class="method">__getitem__()</tt> method.
Iterables can be used in a <tt class="keyword">for</tt> loop and in many other places where a sequence is needed
(<tt class="function">zip()</tt>, <tt class="function">map()</tt>, ...). When an iterable object is passed as an
argument to the builtin function <tt class="function">iter()</tt>, it returns an iterator for the object. This
iterator is good for one pass over the set of values. When using iterables, it is usually not necessary to call
<tt class="function">iter()</tt> or deal with iterator objects yourself. The <code>for</code> statement does that
automatically for you, creating a temporary unnamed variable to hold the iterator for the duration of the loop.
See also <em>iterator</em>, <em>sequence</em>, and <em>generator</em>.
<p><a id='l2h-56' xml:id='l2h-56'></a></p>
</dd>
<dt><strong>iterator</strong></dt>
<dd>
An object representing a stream of data. Repeated calls to the iterator's <tt class="method">next()</tt> method
return successive items in the stream. When no more data is available a <tt class="exception">StopIteration</tt>
exception is raised instead. At this point, the iterator object is exhausted and any further calls to its
<tt class="method">next()</tt> method just raise <tt class="exception">StopIteration</tt> again. Iterators are
required to have an <tt class="method">__iter__()</tt> method that returns the iterator object itself so every
iterator is also iterable and may be used in most places where other iterables are accepted. One notable
exception is code that attempts multiple iteration passes. A container object (such as a <tt class=
"class">list</tt>) produces a fresh new iterator each time you pass it to the <tt class="function">iter()</tt>
function or use it in a <tt class="keyword">for</tt> loop. Attempting this with an iterator will just return the
same exhausted iterator object used in the previous iteration pass, making it appear like an empty container.
<p><a id='l2h-57' xml:id='l2h-57'></a></p>
</dd>
<dt><strong>LBYL</strong></dt>
<dd>
Look before you leap. This coding style explicitly tests for pre-conditions before making calls or lookups. This
style contrasts with the <em>EAFP</em> approach and is characterized by the presence of many <tt class=
"keyword">if</tt> statements.
<p><a id='l2h-58' xml:id='l2h-58'></a></p>
</dd>
<dt><strong>list comprehension</strong></dt>
<dd>
A compact way to process all or a subset of elements in a sequence and return a list with the results.
<code>result = ["0x%02x% x for x in range(256) if x % 2 == 0]</code> generates a list of strings containing hex
numbers (0x..) that are even and in the range from 0 to 255. The <tt class="keyword">if</tt> clause is optional.
If omitted, all elements in <code>range(256)</code> are processed.
<p><a id='l2h-59' xml:id='l2h-59'></a></p>
</dd>
<dt><strong>mapping</strong></dt>
<dd>
A container object (such as <tt class="class">dict</tt>) that supports arbitrary key lookups using the special
method <tt class="method">__getitem__()</tt>.
<p><a id='l2h-60' xml:id='l2h-60'></a></p>
</dd>
<dt><strong>metaclass</strong></dt>
<dd>
The class of a class. Class definitions create a class name, a class dictionary, and a list of base classes. The
metaclass is responsible for taking those three arguments and creating the class. Most object oriented
programming languages provide a default implementation. What makes Python special is that it is possible to
create custom metaclasses. Most users never need this tool, but when the need arises, metaclasses can provide
powerful, elegant solutions. They have been used for logging attribute access, adding thread-safety, tracking
object creation, implementing singletons, and many other tasks.
<p><a id='l2h-61' xml:id='l2h-61'></a></p>
</dd>
<dt><strong>mutable</strong></dt>
<dd>
Mutable objects can change their value but keep their <tt class="function">id()</tt>. See also
<em>immutable</em>.
<p><a id='l2h-62' xml:id='l2h-62'></a></p>
</dd>
<dt><strong>namespace</strong></dt>
<dd>
The place where a variable is stored. Namespaces are implemented as dictionaries. There are the local, global and
builtin namespaces as well as nested namespaces in objects (in methods). Namespaces support modularity by
preventing naming conflicts. For instance, the functions <tt class="function">__builtin__.open()</tt> and
<tt class="function">os.open()</tt> are distinguished by their namespaces. Namespaces also aid readability and
maintainability by making it clear which module implements a function. For instance, writing <tt class=
"function">random.seed()</tt> or <tt class="function">itertools.izip()</tt> makes it clear that those functions
are implemented by the <a class="ulink" href="../lib/module-random.html"><tt class="module">random</tt></a> and
<a class="ulink" href="../lib/module-itertools.html"><tt class="module">itertools</tt></a> modules respectively.
<p><a id='l2h-63' xml:id='l2h-63'></a></p>
</dd>
<dt><strong>nested scope</strong></dt>
<dd>
The ability to refer to a variable in an enclosing definition. For instance, a function defined inside another
function can refer to variables in the outer function. Note that nested scopes work only for reference and not
for assignment which will always write to the innermost scope. In contrast, local variables both read and write
in the innermost scope. Likewise, global variables read and write to the global namespace.
<p><a id='l2h-64' xml:id='l2h-64'></a></p>
</dd>
<dt><strong>new-style class</strong></dt>
<dd>
Any class that inherits from <tt class="class">object</tt>. This includes all built-in types like <tt class=
"class">list</tt> and <tt class="class">dict</tt>. Only new-style classes can use Python's newer, versatile
features like <tt class="method">__slots__</tt>, descriptors, properties, <tt class=
"method">__getattribute__()</tt>, class methods, and static methods.
<p><a id='l2h-65' xml:id='l2h-65'></a></p>
</dd>
<dt><strong>Python3000</strong></dt>
<dd>
A mythical python release, not required to be backward compatible, with telepathic interface.
<p><a id='l2h-66' xml:id='l2h-66'></a></p>
</dd>
<dt><strong>__slots__</strong></dt>
<dd>
A declaration inside a <em>new-style class</em> that saves memory by pre-declaring space for instance attributes
and eliminating instance dictionaries. Though popular, the technique is somewhat tricky to get right and is best
reserved for rare cases where there are large numbers of instances in a memory-critical application.
<p><a id='l2h-67' xml:id='l2h-67'></a></p>
</dd>
<dt><strong>sequence</strong></dt>
<dd>
An <em>iterable</em> which supports efficient element access using integer indices via the <tt class=
"method">__getitem__()</tt> and <tt class="method">__len__()</tt> special methods. Some built-in sequence types
are <tt class="class">list</tt>, <tt class="class">str</tt>, <tt class="class">tuple</tt>, and <tt class=
"class">unicode</tt>. Note that <tt class="class">dict</tt> also supports <tt class="method">__getitem__()</tt>
and <tt class="method">__len__()</tt>, but is considered a mapping rather than a sequence because the lookups use
arbitrary <em>immutable</em> keys rather than integers.
<p><a id='l2h-68' xml:id='l2h-68'></a></p>
</dd>
<dt><strong>Zen of Python</strong></dt>
<dd>Listing of Python design principles and philosophies that are helpful in understanding and using the language.
The listing can be found by typing ``<code>import this</code>'' at the interactive prompt.</dd>
</dl>
<p><br /></p>
<h4>Notas</h4>
<dl>
<dt><a name="foot143">... primário.</a><a href="tut.html#tex2html1"><sup>2.1</sup></a></dt>
<dd>Um problema com o pacote Readline da GNU evita isso</dd>
<dt><a name="foot1805">... objeto)</a><a href="tut.html#tex2html2"><sup>4.1</sup></a></dt>
<dd>De fato, passagem por referência para objeto seria uma melhor descrição, pois quando um objeto
mutável for passado, o <em>chamador</em> irá perceber as alterações feitas pelo
<em>chamado</em> (como a inserção de itens em uma lista).</dd>
<dt><a name="foot755">... etc.</a><a href="tut.html#tex2html3"><sup>5.1</sup></a></dt>
<dd>As regras para comparação de objetos de tipos diferentes não são confiáveis; elas
podem variar em futuras versões da linguagem.</dd>
<dt><a name="foot771">... importado.</a><a href="tut.html#tex2html4"><sup>6.1</sup></a></dt>
<dd>Na verdade, definições de funções são também ``comandos'' que são
``executados''. A execução desses comandos é colocar o nome da função na tabela de
símbolos global do módulo.</dd>
<dt><a name="foot1881">... nomes.</a><a href="tut.html#tex2html5"><sup>9.1</sup></a></dt>
<dd>Exceto por uma coisa. Objetos Módulo possuem um atributo de leitura escondido chamado <tt class=
"member">__dict__</tt> que retorna o dicionário utilizado para implementar o espaço de nomes do
módulo. O nome <tt class="member">__dict__</tt> é um atributo, porém não é um nome global.
Obviamente, utilizar isto violaria a abstração de espaço de nomes, portanto seu uso deve ser
restrito. Um exemplo válido é o caso de depuradores <em>post-mortem</em>.</dd>
<dt><a name="foot1971">... inicialização:</a><a href="tut.html#tex2html6"><sup>A.1</sup></a></dt>
<dd>Python executará o conteúdo do arquivo identificado pela variável de ambiente <a class="envvar"
id='l2h-32' xml:id='l2h-32'>PYTHONSTARTUP</a> quando se dispara o interpretador interativamente.</dd>
</dl>
Logado como (Entrar)
