Python 21

Tutorial de Python
Release 2.1
Guido van Rossum Fred L. Drake, Jr., editor Rodrigo D. A. Senra, tradutor
3 de setembro de 2004
PythonLabs E-mail: python-docs@python.org E-mail Tradutor: rodsenra@gpr.com.br
Copyright c 2001, 2002, 2003 Python Software Foundation. All rights reserved. Copyright c 2000 BeOpen.com. All rights reserved. Copyright c 1995-2000 Corporation for National Research Initiatives. All rights reserved. Copyright c 1991-1995 Stichting Mathematisch Centrum. All rights reserved. See the end of this document for complete license and permissions information.

Resumo Python e uma linguagem de programacao poderosa e de f cil aprendizado. Ela possui estruturas de dados de alto-nvel a ecientes, bem como adota uma abordagem simples e efetiva para a programacao orientada a objetos. Sua sintaxe elegante e tipagem din mica, em adicao a sua natureza interpretada, tornam Python ideal para scripting e para o a desenvolvimento r pido de aplicacoes em diversas areas e na maioria das plataformas. a O interpretador de Python e sua extensa biblioteca padr o est o disponveis na forma de c digo fonte ou bin rio para a a a o a maioria das plataformas a partir do stio, http://www.python.org, e podem ser distribudos livremente. No mesmo stio est o disponveis distribuicoes e refer ncias para diversos m dulos, programas, ferramentas e documentacao adicional a e o contribudos por terceiros. O interpretador de Python e f cilmente extensvel incorporando novas funcoes e tipos de dados implementados em C a ou C++ (ou qualquer outra linguagem acessvel a partir de C). Python tamb m se adequa como linguagem de extens o e a para customizar aplicacoes. Este tutorial introduz o leitor informalmente aos conceitos b sicos e aspectos do sistema e linguagem Python. E a aconselh vel ter um interpretador Python disponvel para se poder por a m o na massa, por m todos os exemplos a a e s o auto-contidos, assim o tutorial tamb m pode ser lido sem que haja a necessidade de se estar on-line. a e Para uma descricao dos m dulos e objetos padr o, veja o documento Python Library Reference. O Python Reference o a Manual oferece uma denicao formal da linguagem. Para se escrever extens es em C ou C ++, leia Extending and o Embedding the Python Interpreter. Existem tamb m diversos livros abordando Python em profundidade. e Este tutorial n o almeja ser abrangente ou abordar todos os aspectos, nem mesmo todos os mais frequentes. Ao inv s a e disso, ele introduz muitas das caractersticas dignas de nota em Python, e fornecer a voc uma boa id ia sobre o estilo a e e 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 o e o a pronto par aprender mais sobre os diversos m dulos de biblioteca descritos em Python Library Reference. o A traducao deste tutorial foi patrocinada pela GPr Sistemas Ltda, e vers es deste documento em formato eletr nico o o est o disponvies no site da empresa (http://www.gpr.com.br). a
SUMARIO
1 Abrindo o Apetite 1.1 Para Onde Ir a Partir Daqui . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Utilizando o Interpretador Python 2.1 Disparando o Interpretador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 O Interpretador e seu Ambiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Uma Introducao Informal a Python 3.1 Utilizando Python Como Uma Calculadora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Primeiros Passos em Direcao a Programacao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ` 4 Mais Ferramentas de Controle de Fluxo 4.1 Construcao if . . . . . . . . . . . . . . . . . . . 4.2 Construcao for . . . . . . . . . . . . . . . . . . 4.3 A Funcao range() . . . . . . . . . . . . . . . . 4.4 Cl usulas break, continue e else em Lacos a 4.5 Construcao pass . . . . . . . . . . . . . . . . . 4.6 Denindo Funcoes . . . . . . . . . . . . . . . . . 4.7 Mais sobre Denicao de Funcoes . . . . . . . . . 5 Estruturas de Dados 5.1 Mais sobre Listas . . . . . . . . . . . 5.2 O comando del . . . . . . . . . . . . 5.3 Tuplas e Sequ ncias . . . . . . . . . . e 5.4 Dicion rios . . . . . . . . . . . . . . a 5.5 Mais sobre Condicoes . . . . . . . . . 5.6 Comparando Sequ ncias e Outros Tipos e 6 M dulos o 6.1 Mais sobre M dulos o 6.2 M dulos Padr o . . o a 6.3 A Funcao dir() . 6.4 Pacotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 2 3 3 4 7 7 15 17 17 17 18 18 19 19 21 25 25 28 29 30 30 31 33 34 35 36 37 41 41 43 47 47
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . .
7 Entrada e Sada 7.1 Renando a Formatacao de Sada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Leitura e Escrita de Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Erros e Excecoes 8.1 Erros de Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 8.3 8.4 8.5 8.6
Excecoes . . . . . . . . . . . . . Tratamento de Excecoes . . . . . Levantando Excecoes . . . . . . Excecoes Denidas pelo Usu rio a Denindo Acoes de Limpeza . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
47 48 50 50 50 53 53 54 55 57 58 60 60 63
9 Classes 9.1 Uma Palavra Sobre Terminologia . . . . 9.2 Escopos e Espacos de Nomes em Python 9.3 Primeiro Contato com Classes . . . . . . 9.4 Observacoes Aleat rias . . . . . . . . . o 9.5 Heranca . . . . . . . . . . . . . . . . . 9.6 Vari veis Privadas . . . . . . . . . . . . a 9.7 Particularidades . . . . . . . . . . . . . 10 E agora?
A Edicao de Entrada Interativa e Substituicao por Hist rico o A.1 Edicao de Linha . . . . . . . . . . . . . . . . . . . . . A.2 Substituicao de Hist rico . . . . . . . . . . . . . . . . o A.3 Vinculacao de Teclas . . . . . . . . . . . . . . . . . . A.4 Coment rio . . . . . . . . . . . . . . . . . . . . . . . a
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
65 65 65 65 66
ii
CAP ITULO
ONE
Abrindo o Apetite
Se alguma vez voc j escreveu um extenso script de shell, provavelmente se sentiu assim: voc adoraria adicionar e a e mais uma caracterstica, mas j est t o lento, e t o grande, e t o complicado; ou a nova caracterstica implica numa a a a a a chamada de sistema ou funcao s acessvel a partir do C . . . Tipicamente o problema em quest o n o e s rio o suciente o a a e para motivar a re-escrita do script em C; talvez o problema exija cadeias de caracteres de comprimento vari vel ou a tipos (como listas ordenadas de nomes de arquivos) que s o f cilmente manipul veis na shell, por m demandam muito a a a e esforco de implementacao em C, ou talvez voc nem esteja sucientemente familiarizado com C. e Outra situacao: suponha que voc tenha que trabalhar com diversas bibiotecas em C, e o tpico ciclo e escreve/compila/testa/re-compila seja muito lento. Voc precisa desenvolver software de uma forma mais agil. Ou, sue ponha que voc escreveu um programa que precise fazer uso de uma linguagem de extens o, e voc n o quer projetar e a e a a linguagem, implementar e depurar um interpretador para ela, para s ent o estabelecer o vnculo com sua aplicacao o a original. Nestes casos, Python possivelmente e exatamente do que voc est precisando. Python e simples de usar, sem deixar e a de ser uma linguagem de programacao de verdade, oferecendo muito mais estruturacao e suporte para programas extensos do que shell scripts oferecem. Por outro lado, Python tamb m oferece melhor vericacao de erros do que C, e e por ser uma linguagem de alto nvel, ela possui tipos nativos de alto nvel: dicion rios e vetores (arrays) exveis que a lhe custariam dias para obter uma implementacao eciente em C. Devido ao suporte nativo a tipos gen ricos, Python e e aplic vel a um domnio de problemas muito mais vasto do que Awk ou at mesmo Perl, ainda assim Python e t o f cil a e a a de usar quanto essas linguagens sob diversos aspectos. Python permite que voc organize seu programa em m dulos que podem ser reutilizados em outros programas escritos e o Python. A linguagem prov uma vasta colecao de m dulos que podem ser utilizados como base para sua aplicacao e o ou como exemplos para estudo e aprofundamento. H tamb m m dulos nativos que implementam manipulacao de a e o arquivos, chamadas do sistema, sockets, e at mesmo acesso a bibiotecas de construcao de interfaces gr cas, como e a Tk. Python e uma linguagem interpretada, que pode fazer com que voc economize um tempo consider vel, uma vez que e a n o h necessidade de compilacao e vinculacao(linking) durante o desenvolvimento. O interpretador pode ser usado ina a terativamente, o que torna f cil experimentar diversas caractersticas da linguagem, escrever programas descart veis, a a ou testar funcoes em um desenvolvimento bottom-up. E tamb m uma util calculadora de mesa. e Python permite a escrita de programas compactos e legveis. Programas escritos em Python s o tipicamente mais a curtos do que seus equivalentes em C ou C++, por diversas raz es: o os tipos de alto-nvel permitem que voc expresse operacoes complexas em uma unico comando (statement); e

a denicao de bloco e feita por identacao ao inv s de marcadores de incio e m de bloco; e n o h necessidade de declaracao de vari veis ou par metros formais; a a a a
Python e extensvel: se voc sabe como programar em C, e f cil adicionar funcoes ou m dulos diretamente no in e a o terpretador, seja para desempenhar operacoes crticas em m xima velocidade, ou para vincular programas Python a a bibliotecas que s estejam disponvies em formato bin rio (como uma bibloteca gr ca de terceiros). Uma vez que o a a 1
voc tenha sido sgado, voc pode vincular o interpretador Python a uma aplicacao escrita em C e utiliz -la como e e a linguagem de comandos ou extens o para esta aplicacao. a A prop sito, a linguagem foi batizada a partir do famoso show da BBC Monty Pythons Flying Circus e n o tem o a nada a ver com repulsivos r pteis. Fazer refer ncias a citacoes do show na documentacao n o e s permitido, como e e ` a o tamb m e encorajado! e
1.1
Para Onde Ir a Partir Daqui
Agora que voc est entusiasmado com Python, vai desejar examin -la com maior detalhe. Partindo do princpio que e a a a melhor maneira de aprender uma linguagem e us -la, voc est convidado agora a faz -lo. a e a e No pr ximo captulo, a mec nica de utilizacao do interpretador e explicada. Essa informacao, ainda que mundana, e o a essencial para a experimentacao dos exemplos apresentados mais tarde. O resto do tutorial introduz diversos aspectos do sistema e linguagem Python por interm dio de exemplos. Ser o e a abordadas express es simples, comandos, tipos, funcoes e m dulos. Finalmente, ser o explicados alguns conceitos o o a avancados como excecoes e classes denidas pelo usu rio. a
Captulo 1. Abrindo o Apetite
CAP ITULO
TWO
Utilizando o Interpretador Python

2.1 Disparando o Interpretador
O interpretador e frequentemente instalado como /usr/local/bin/python nas m quinas em que e disponibilizado; adi a cionando /usr/local/bin ao caminho de busca (search path) da shell de seu U NIX torna-se possvel inici -lo digitando a :
python
na shell. Considerando que a escolha do diret rio de instalacao e uma opcao de instalacao, outras localizacoes s o o a possveis; verique com seu guru local de Python ou com o administrador do sistema. (Ex., /usr/local/python e outra alternativa popular para instalacao.) Digitando um caracter EOF() (Control-D on U NIX, Control-Zno DOS ou Windows) diretamente no prompt forca o interpretador a sair com status de sada zero. Se isso n o funcionar, voc pode sair do interpretador atrav s da a e e digitacao do seguinte: import sys; sys.exit(). As caractersticas de edicao de linha n o s o muito sosticadas. Sobre U NIX, seja l quem for que tenha instalado o a a a interpretador talvez tenha habilitado o suporte a biblioteca readline da GNU, que adiciona facilidades mais elaboradas de edicao e hist rico de comandos. Teclar Control-P no primeiro prompt oferecido pelo Python e, provavelmente, a o maneira mais r pida de vericar se a edicao de linha de comando e suportada. Se houver um beep, voc possui edicao a e de linha de comando; veja o Ap ndice A para uma introducao as teclas especiais. Se nada acontecer, ou se P aparecer e na tela, a opcao de edicao n o est disponvel; voc apenas ser capaz de usar o backspace para remover caracteres da a a e a linha corrente. O interpretador trabalha de forma semelhante a uma shell de U NIX: quando disparado com a sada padr o conectada a a um console de terminal (tty device), ele l e executa comandos interativamente; quando disparado com um nome e de arquivo como par metro ou com redirecionamento da entrada padr o para um arquivo, o interpretador ir ler e a a a executar o script contido em tal arquivo. Uma terceira forma de disparar o interpretador e python -c command [arg] ..., que executa o(s) comando(s) especicados na posicao command, analogamente a opcao de shell -c. Considerando que comandos Python pos suem frequentemente espacos em branco (ou outros caracteres que sejam especiais para a shell) e aconselh vel que o a comando especicado em command esteja dentro de aspas duplas. Observe que h uma diferenca entre python file e python <file. No utlimo caso, chamadas do tipo a input() e raw input() ser o satisfeitas a partir de le. Uma vez que le j foi inteiramente lido antes de que a a o script Python entrasse em execucao, o programa encontrar o m de arquivo (EOF) imediatamente. J no primeiro a a caso, que e o mais frequente (provavelmente o que voc quer), a entrada de dados ser fornecida pelo dispositivo e a vinculado a entrada padr o do interpretador. a Quando um arquivo de script e utilizado, as vezes e util ser capaz de execut -lo para logo em seguida entrar em modo ` a interativo. Este efeito pode ser obtido pela adicao do par metro -i antes do nome do script. (Observe que isto n o ir a a a
funcionar se o script for lido a partir da entrada padr o, pelas mesmas raz es explicadas no par grafo anterior). a o a
2.1.1
Passagem de Argumentos
O nome do script e subsequentes par metros da linha de comando da shell s o acessveis ao pr prio script atrav s da a a o e vari vel sys.argv, que e uma lista de strings. Essa lista tem sempre ao menos um elemento; quando nenhum script a ou par metro forem passados para o interpretador, sys.argv[0] ser uma lista vazia. Quando o nome do script a a for - (signicando entrada padr o), o conte do de sys.argv[0] ser -. Quando for utilizado -c command, a u a sys.argv[0] conter -c. Opcoes especicadas ap s -c command n o ser o consumidas pelo interpretador mas a o a a armazenadas em sys.argv.
2.1.2
Modo Interativo
Quando os comandos s o lidos a partir do console (tty), diz-se que o interpretador est em modo interativo. Nesse a a modo ele requisita por um pr ximo comando atrav s do prompt prim ario, tipicamente tr s sinais de maior-que o e e (>>> ); para linhas de continuacao do comando corrente, o prompt secund ario default s o tr s pontos (... ). O a e interpretador imprime uma mensagem de boas vindas, informando seu n mero de vers o e uma nota legal de copyright u a antes de oferecer o primeiro prompt, ex.:
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 >>>
Linhas de continuacao s o necess rias em construcoes multi-linha. Como exemplo, d uma olhada nesse comando a a e if:
>>> o_mundo_eh_plano = 1 >>> if o_mundo_eh_plano: ... print "Cuidado para no cair fora dele!" a ... Cuidado para no cair fora dele! a
2.2
2.2.1
O Interpretador e seu Ambiente

Tratamento de Erros
Quando ocorre um erro, o interpretador imprime uma mensagem de erro e a situacao da pilha (daqui em diante stack trace). No modo interativo, retorna-se ao prompt prim rio; quando a entrada vem de um arquivo, o interpretador aborta a sua execucao com status de erro diferente de zero ap s imprimir o stack trace (Excecoes tratadas por um except num o bloco try n o s o consideradas erros neste contexto). Alguns erros s o incondicionalmente fatais e causam a sada a a a com status diferente de zero; isto se aplica a inconsist ncias internas e alguns casos de exaust o de mem ria. Todas e a o as mensagens de erro s o escritas na sada de erros padr o (standard error), enquanto a sada dos demais comandos e a a direcionada para a sada padr o. a Teclando o caracter de interrupcao (tipicamente Control-C ou DEL) no prompt prim rio ou secund rio cancela a a a entrada de dados corrente e retorna-se ao prompt prim rio. 1 Provocando uma interrupcao enquanto um comando est a a em execucao levanta a excecao KeyboardInterrupt, a qual pode ser tratada em um bloco try.
1 Um
problema com o pacote Readline da GNU evita isso
Captulo 2. Utilizando o Interpretador Python
2.2.2
Scripts Executaveis em Python
Em sistemas U NIXBSD, scripts Python podem ser transformados em execut veis, como shell scripts, pela inclus o do a a cabecalho
#! /usr/bin/env python
(Assumindo que o interpretador foi includo do caminho de busca do usu rio (PATH)) e que o script tenha a permiss o a a de acesso habilitada para execucao. O #! deve estar no incio do arquivo . Observe que o caracter # designa coment rios em Python. a
2.2.3
O Arquivo de Inicializacao para Modo Interativo
Quando voc for utilizar Python interativamente, pode ser util adicionar uma s rie de comandos a serem executados e e por default antes de cada sess o de utilizacao do interpretador. Isto pode ser obtido pela conguracao da vari vel a a de ambiente PYTHONSTARTUP para indicar o nome do arquivo script que cont m o script de inicializacao. Essa e caracterstica assemelha-se aos arquivos .prole de shells U NIX. O arquivo s e processado em sess es interativas, nunca quando Python l comandos de um script especicado como o o e par metro, nem tampouco quando /dev/tty e especicado como a fonte de leitura de comandos (caso contr rio se a a comportaria como uma sess o interativa). O script de inicializacao e executado no mesmo contexto (doravante naa mespace) em que os comandos da sess o interativa ser o executados, sendo assim, os objetos denidos e m dulos a a o importados podem ser utilizados sem qualicacao durante a sess o interativa. E possvel tamb m redenir os prompts a e sys.ps1 e sys.ps2 atrav s deste arquivo. e Se for necess rio ler um script adicional de inicializacao a partir do diret rio corrente, voc pode prograa o e mar isso a partir do script de inicializacao global, ex.: if os.path.isfile(.pythonrc.py): execfile(.pythonrc.py). Se voc deseja utilizar o script de inicializacao em outro script, voc deve e e faz -lo explicitamente da seguinte forma: e
import os filename = os.environ.get(PYTHONSTARTUP) if filename and os.path.isfile(filename): execfile(filename)
2.2. O Interpretador e seu Ambiente
CAP ITULO
THREE
Uma Introducao Informal a Python

Nos exemplos seguintes, pode-se distinguir a entrada da sada pela presenca ou aus ncia dos prompts (>>> and e ... ): para repetir o exemplo, voc deve digitar tudo ap s o prompt, quando o mesmo aparece; linhas que n o e o a comecarem com o prompt s o na verdade as sadas geradas pelo interpretador. a Observe que existe um segundo prompt indicando a linha de continuacao de um comando com m ltiplas linhas, o qual u pode ser encerrado pela digitacao de um linha em branco. Muitos dos exemplos neste manual, at mesmo aqueles digitados interativamente, incluem coment rios. Coment rios e a a em Python s o delimitados pelo caracter #, e se extendem at o nal da linha. Um coment rio pode aparecer no a e a incio da linha, depois de um espaco em branco ou c digo, mas nunca dentro de uma string (literal). O delimitar de o coment rio dentro de uma string e interpretado como o pr prio caracter. a o Alguns exemplos:
# primeiro comentrio a SPAM = 1
a e # e esse o segundo comentrio # ... e ainda um terceiro ! a a e STRING = "# Este no um comentrio."
3.1
Utilizando Python Como Uma Calculadora
Vamos tentar alguns comandos simples em Python. Inicie o interpretador e aguarde o prompt prim rio, >>> . (N o a a deve demorar muito.)
3.1.1
Numeros
O interpretador atua como uma calculadora bem simples: voc pode digitar uma express o e o valor resultando ser e a a apresentado ap s a avaliacao da express o. A sintaxe da express o e a usual: operadores +, -, * e / funcionam da o a a mesma forma que em outras linguagens tradicionais (por exemplo, Pascal ou C); par nteses podem ser usados para e denir agrupamentos. Por exemplo:
>>> 4 >>> ... 4 >>> 4 >>> 2+2 # Isso um comentrio e a 2+2 2+2 # e um comentrio na mesma linha de um comando a
(50-5*6)/4
5 >>> # Diviso inteira retorna com aredondamento para base a ... 7/3 2 >>> 7/-3 -3
Como em C, o sinal de igual (=) e utilizado para atribuicao de um valor a uma vari vel. O valor da atribuicao n o e a a escrito:
>>> width = 20 >>> height = 5*9 >>> width * height 900
Um valor pode ser atribudo a diversas vari veis simultaneamente: a
>>> >>> 0 >>> 0 >>> 0
x = y = z = 0 x y z
# Zero x, y e z
H total suporte para ponto-utuante; operadores com operandos de diferentes tipos convertem o inteiro para pontoa utuante:
>>> 4 * 2.5 / 3.3 3.0303030303 >>> 7.0 / 2 3.5
N meros complexos tamb m s o suportados; n meros imagin rios s o escritos com o suxo j ou J. N meros u e a u a a u complexos com parte real n o nula s o escritos como (real+imagj), ou podem ser criados pela chamada de funcao a a complex(real, imag).
>>> 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)
N meros complexos s o sempre representados por dois n meros ponto-utuante, a parte real e a parte imagin ria. u a u a Para extrair as partes de um n mero z, utilize z.real e z.imag. u
>>> a=1.5+0.5j >>> a.real 1.5 >>> a.imag 0.5
Captulo 3. Uma Introducao Informal a Python
As funcoes de convers o para ponto-utuante e inteiro (float(), int() e long()) n o funcionam para n meros a a u complexos n o existe maneira correta de converter um n mero complexo para um n mero real. Utilize abs(z) a u u para obter sua magnitude (como ponto-utuante) ou z.real para obter sua parte real.
>>> a=1.5+0.5j >>> float(a) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: cant convert complex to float; use e.g. abs(z) >>> a.real 1.5 >>> abs(a) 1.58113883008
No modo interativo, a ultima express o a ser impressa e atribuda a vari vel . Isso signica que ao utilizar Python a a como uma calculadora, e muitas vezes mais f cil prosseguir com os c lculos da seguinte forma: a a
>>> tax = 17.5 / 100 >>> price = 3.50 >>> price * tax 0.61249999999999993 >>> price + _ 4.1124999999999998 >>> round(_, 2) 4.1100000000000003
Essa vari vel especial deve ser tratada somente para leitura pelo usu rio. Nunca lhe atribua explicitamente um valor a a do contr rio, estaria se criando uma outra vari vel (hom nima) independente, que mascararia o comportamento a a o m gico da vari vel especial. a a
3.1.2
Strings
Al m de n meros, Python tamb m pode manipular strings, que podem ser expressas de diversas formas. Elas podem e u e ser delimitadas pos aspas simples ou duplas:
>>> spam eggs spam eggs >>> doesn\t "doesnt" >>> "doesnt" "doesnt" >>> "Yes," he said. "Yes," he said. >>> "\"Yes,\" he said." "Yes," he said. >>> "Isn\t," she said. "Isn\t," she said.
Strings que cont m mais de uma linha podem ser construdas de diversas maneiras. Terminadores de linha podem ser e embutidos na string com barras invertidas, ex.:
oi = "Esta eh uma string longa contendo\n\ diversas linhas de texto assim como voce faria em C.\n\ Observe que os espacos em branco no inicio da linha so \ a significativos.\n" print oi
que produziria o seguinte resultado: 3.1. Utilizando Python Como Uma Calculadora 9
Esta eh uma string longa contendo diversas linhas de texto assim como voce faria em C. Observe que os espacos em branco no inicio da linha so significativos. a
Ou, strings podem ser delimitadas por pares de aspas trplices: " ou . Neste caso n o e necess rio embutir a a terminadores de linha, pois o texto da string ser tratado verbatim. a
print """ Usage: thingy [OPTIONS] -h -H hostname """
Display this usage message Hostname to connect to
produz a seguinte sada:

Usage: thingy [OPTIONS] -h -H hostname
Display this usage message Hostname to connect to
O interpretador imprime o resultado de operacoes sobre strings da mesma forma que as strings s o formatadas na a digitacao: dentro de aspas, e com caracteres especiais embutidos em escape sequences, para mostar seu valor com precis o. A string ser delimitada por aspas duplas se ela cont m um unico caracter de aspas simples e nenhum de a a e aspas duplas, caso contr rio a string ser delimitada por aspas simples. ( O comando print, descrito posteriormente, a a pode ser utilizado para escrever strings sem aspas ou escape sequences.) Strings podem ser concatenadas (coladas) com o operador +, e repetidas com *:
>>> word = Help + A >>> word HelpA >>> < + word*5 + > <HelpAHelpAHelpAHelpAHelpA>
Duas strings literais justapostas s o automaticamente concatenadas; a primeira linha do exemplo anterior poderia a ter sido escrita como word = HelpA; isso funciona somente com strings literais, n o com express es ara o bitr rias: a
>>> import string >>> str ing string >>> string.strip(str) + ing string >>> string.strip(str) ing File "<stdin>", line 1 string.strip(str) ing SyntaxError: invalid syntax
# # #
<<<-
This is ok This is ok This is invalid
Strings podem ser indexadas; como em C, o primeiro ndice da string e o 0. N o existe um tipo separado para a caracteres; um caracter e simplesmente uma string unit ria. Assim como na linguagem Icon, substrings podem ser a especicadas atrav s da notacao slice (N.d.T: fatiar): dois ndices separados por dois pontos. e
>>> word[4] A >>> word[0:2] He >>> word[2:4]
10
lp
Diferentemente de C, strings n o podem ser alteradas em Python. Atribuir para uma posicao (ndice) dentro de uma a string resultar em erro: a
>>> word[0] = x Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object doesnt support item assignment >>> word[:1] = Splat Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object doesnt support slice assignment
Entretanto, criar uma nova string com o conte do combinado e f cil e eciente: u a
>>> x + word[1:] xelpA >>> Splat + word[4] SplatA
Indices de slice possuem valores default uteis; o primeiro ndice se omitido possui valor default 0, o segundo possui valor default igual ao tamanho da string.
>>> word[:2] He >>> word[2:] lpA # Os dois primeiros caracteres # Todos menos os dois primeiros caracteres
Aqui est um invariante interessante relacionado a operacoes de slice: s[:i] + s[i:] equals s. a
>>> word[:2] + word[2:] HelpA >>> word[:3] + word[3:] HelpA
Indices de slice degenerados s o tratados graciosamente (N.d.T: este termo indica robustez no tratamento de erros): a um ndice muito maior que o comprimento e trocado pelo comprimento, um limitante superior que seja menor que o limitante inferior produz uma string vazia como resultado.
>>> word[1:100] elpA >>> word[10:] >>> word[2:1]
Indices podem ser n meros negativos, para iniciar a contagem a partir da direita ao inv s da esquerda. Por exemplo: u e
>>> word[-1] A >>> word[-2] p >>> word[-2:] pA >>> word[:-2] Hel # O tlimo caracter u # O penltimo caracter u # Os dois ltimos caracteres u # Todos menos os dois ltimos caracteres u
Observe que -0 e o mesmo que 0, logo neste caso n o se conta a partir da direita! a 3.1. Utilizando Python Como Uma Calculadora 11
>>> word[-0] H
# ( -0 ==
0)
Intervalos fora dos limites da string s o truncados, mas n o tente isso em indexacoes com um unico ndice (que n o a a a seja um slice):
>>> word[-100:] HelpA >>> word[-10] # error Traceback (most recent call last): File "<stdin>", line 1 IndexError: string index out of range
A melhor maneira de lembrar como slices funcionam e pensar nos ndices como ponteiros para os espacos entre caracteres, onde a beirada esquerda do primeiro caracter e 0. Logo a beirada direita do ultimo caracter de uma string de comprimento n tem ndice n, por exemplo:
+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1
A primeira leira de n meros indica a posicao dos ndices 0..5 na string; a segunda leira indica a posicao dos u respectivos ndices negativos. Um slice de i at j consiste em todos os caracteres entre as beiradas i e j, respectivamente. e Para ndices positivos, o comprimento do slice e a diferenca entre os ndices, se ambos est o dentro dos limites da a string, ex, o comprimento de word[1:3] e 2. A funcao interna (N.d.T: interna == built-in) len() devolve o comprimento de uma string:
>>> s = supercalifragilisticexpialidocious >>> len(s) 34
3.1.3
Strings Unicode
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 http://www.unicode.org) e se integra bem aos demais objetos strings pr -existentes de forma a e realizar auto-convers es quando necess rio. o a Unicode tem a vantagem de prover um unico n mero ordinal para cada caracter usado em textos modernos ou anti u gos. Previamente, havia somente 256 n meros ordinais. Logo, mapeamentos entre conjuntos de caracteres e os 256 u n meros ordinais precisavam ser indexados por c digos de p gina. Isso levou a uma enorme confus o especialmente u o a a no ambito da internacionalizacao (tipicamente escrito como i18n i + 18 caracteres + n) de software. Unicode resolve esses problemas ao denir um unico c digo de p gina para todos os conjuntos de caracteres. o a Criar strings Unicode em Python e t o simples quanto criar strings normais: a
>>> uHello World ! uHello World !
O pequeno u antes das aspas indica a criacao de uma string Unicode . Se voc desejar incluir caracteres especiais na e string, voc pode faz -lo atrav s da codicacao Python Unicode-Escape. e e e
>>> uHello\u0020World !
12
uHello World !
O c digo de escape \u0020 indica a insercao do caracter Unicode com valor ordinal 0x0020 (o espaco em branco) o na posicao determinada. Os outros caracteres s o interpretados atrav s de seus respectivos valores ordinais diretamente para os valores ordinais a e em Unicode. Se voc possui strings literais na codicacao padr o Latin-1 que e utilizada na maioria do oeste europeu, e a voc achar conveniente que os 256 caracteres inferiores do Unicode coincidem com os 256 caracteres inferiores do e a Latin-1. Para experts, existe ainda um modo cru (N.d.T: sem processamento de caracteres escape) da mesma forma que existe para strings normais. Basta prexar a string com ur para utilizar a codicacao Python Raw-Unicode-Escape. S ser o a aplicado a convers o \uXXXX se houver um n mero mpar de barras invertidas antes do escape u. a u
>>> urHello\u0020World ! uHello World ! >>> urHello\\u0020World ! uHello\\\\u0020World !
O modo cru (N.d.T: raw) e muito util para evitar excesso de barras invertidas em express es regulares. o Al m dessas codicacoes padr o, Python oferece um outro conjunto de maneiras de se criar strings Unicode sobre e a uma codicacao padr o. a A funcao interna unicode() prov acesso a todos os Unicode codecs registrados (COders and DECoders). e Alguns dos mais conhecidos codecs s o : Latin-1, ASCII, UTF-8, and UTF-16. Os dois ultimos s o codicacoes de a a tamanho vari vel para armazenar cada caracter Unicode em um ou mais bytes. A codicacao default e ASCII, que a trata normalmente caracteres no intervalo de 0 a 127 mas rejeita qualquer outro com um erro. Quando uma string Unicode e impressa, escrita em arquivo ou convertida por str(), a codicacao padr o e utilizada. a
>>> u"abc" uabc >>> str(u"abc") abc >>> u"" aou u\xe4\xf6\xfc >>> str(u"") aou Traceback (most recent call last): File "<stdin>", line 1, in ? UnicodeError: ASCII encoding error: ordinal not in range(128)
Para se converter uma string Unicode em uma string 8-bits usando uma codicacao especca, basta invocar o m todo e encode() de objetos Unicode passando como par metro o nome da codicacao destino. E prefervel utilizar nomes a de codicacao em letras min sculas. u
aou >>> u"".encode(utf-8) \xc3\xa4\xc3\xb6\xc3\xbc
Tamb m pode ser utilizada a funcao unicode() para efetuar a convercao de um string em outra codicacao. Neste e caso, o primeiro par metro e a string a ser convertida e o segundo o nome da codicacao almejada. O valor de retorno a da funcao e a string na nova codicacao.
>>> unicode(\xc3\xa4\xc3\xb6\xc3\xbc, utf-8) u\xe4\xf6\xfc
3.1. Utilizando Python Como Uma Calculadora
13
3.1.4
Listas
Python possui diversas estruturas de dados nativas, utilizadas para agrupar outros valores. A mais vers til delas e a a lista (list), que pode ser escrita como uma lista de valores separados por vrgula e entre colchetes. Mais importante, os valores contidos na lista n o precisam ser do mesmo tipo. a
>>> a = [spam, eggs, 100, 1234] >>> a [spam, eggs, 100, 1234]
Da mesma forma que ndices de string, ndices de lista comecam do 0, listas tamb m podem ser concatenadas e sofrer e o operador de slice.
>>> 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] + [Boe!] [spam, eggs, 100, spam, eggs, 100, spam, eggs, 100, Boe!]
Diferentemente de strings, que s o imut veis, e possvel mudar elementos individuais da lista: a a
>>> a [spam, eggs, 100, 1234] >>> a[2] = a[2] + 23 >>> a [spam, eggs, 123, 1234]
Atribuicao a fatias (slices) e possvel, e isso pode at alterar o tamanho da lista: ` e
>>> # 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]
A funcao interna len() tamb m se aplica a lista: e
>>> len(a)
14
E possvel aninhar listas (criar listas contendo outras listas), por exemplo:
>>> >>> >>> 3 >>> [2, >>> 2 >>> >>> [1, >>> [2, q = [2, 3] p = [1, q, 4] len(p) p[1] 3] p[1][0] p[1].append(xtra) p [2, 3, xtra], 4] q 3, xtra] # See section 5.1
Observe que no ultimo exemplo, p[1] e q na verdade se referem ao mesmo objeto! Mais tarde retornaremos a sem ntica do objeto. a
3.2
Primeiros Passos em Direcao a Programacao `
Naturalmente, n s podemos utilizar Python para tarefas mais complicadas do que somar dois n meros. A ttulo de o u exemplicacao, n s podemos escrever o incio da sequ ncia de Fibonacci assim: o e
>>> ... ... >>> ... ... ... 1 1 2 3 5 8 # 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
Este exemplo introduz diversas caractersticas ainda n o mencionadas. a A primeira linha cont m uma atribuicao m ltipla: as vari veis a e b simultaneamente recebem os novos valores e u a 0 e 1. Na ultima linha h outro exemplo de atribuicao m ltipla demonstrando que express es do lado direito s o a u o a sempre avaliadas primeiro, antes da atribuicao. As express es do lado direito s o avaliadas da esquerda para a o a direita.

O laco while executa enquanto a condicao (aqui:b < 10) permanecer verdadeira. Em Python, como em C, qualquer valor inteiro n o nulo e considerado verdadeiro (valor true), zero tem valor false. A condicao pode a ser ainda uma lista ou string, na verdade qualquer sequ ncia; qualquer coisa com comprimento n o nulo tem e a valor true e sequ ncias vazias tem valor false. O teste utilizado no exemplo e uma simples comparacao. Os e operadores padr o para comparacao s o os mesmos de C: < (menor que), > (maior que), == (igual), <= (menor a a ou igual), >= (maior ou igual) and != (diferente). O corpo do laco e identado: identacao em Python e a maneira de agrupar comandos. Python (ainda!) n o a possui facilidades autom ticas de edicao de linha. Na pr tica voc ir preparar scripts Python complexos em um a a e a 15
3.2. Primeiros Passos em Direcao a Programacao `
editor de texto; a maioria dos editores de texto possui facilidades de identacao autom tica. Quando comandos a compostos forem alimentados ao interpretador interativamente, devem ser encerrados por uma linha em branco (j que o parser n o tem como adivinhar qual e a ultima linha do comando). Observe que toda linha de um a a mesmo bloco de comandos deve possuir a mesma identacao. O comando print escreve o valor da express o dada. Ele difere de apenas escrever a express o no interpretador a a (como foi feito no exemplo da calculadora) ao aceitar m ltiplas express es e strings. Strings s o impressas sem u o a aspas, um espaco e inserido entre itens de forma a formatar o resultado assim:
>>> i = 256*256 >>> print The value of i is, i The value of i is 65536
Uma vrgula ao nal evita a quebra de linha:

>>> 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
Note que o interpretador insere uma quebra de linha antes de imprimir o pr ximo prompt se a ultima linha n o o a foi completada.
16
CAP ITULO
FOUR
Mais Ferramentas de Controle de Fluxo

Al m do while rec m apresentado, Python possui as estruturas usuais de controle de uxo conhecidas em outras e e linguagens, com algumas variacoes:
4.1
Construcao if
Provavelmente uma das mais conhecidas construcoes e o if. Por exemplo:

>>> >>> ... ... ... ... ... ... ... ... ... x = int(raw_input("Por favor entre com um numero: ")) if x < 0: x = 0 print Negativo mudou para zero elif x == 0: print Zero elif x == 1: print Um else: print Mais
Pode haver zero ou mais secoes elif. A secao else e opcional. A palavra-chave elif e uma abreviacao para else if, e e util para evitar identacao excessiva. Uma sequ ncia if . . . elif . . . elif . . . substitui as construcoes e switch e case encontradas em outras linguagens.
4.2
Construcao for
A construcao for em Python difere um pouco do que se est acostumado em C ou Pascal. Ao inv s de se iterar sobre a e progress es aritim ticas (como em Pascal), ou fornecer ao usu rio a habilidade de denir tanto o passo da iteracao o e a quanto a condicao de parada (como em C), o for de Python itera sobre os itens de uma sequ ncia (ex.: uma lista ou e uma string), na ordem em que aparecem na sequ ncia. Por exemplo : e
>>> # Medindo algumas strings: ... a = [gato, janela, defenestrar] >>> for x in a: ... print x, len(x) ... gato 4 janela 6 defenestrar 11
17
N o e seguro modicar a sequ ncia sobre a qual se baseia o laco de iteracao (isto s pode acontecer se a sequ ncia for a e o e mut vel, isto e, uma lista). Se voc precisar modicar a lista sobre a qual se est iterando, por exemplo, para duplicar a e a itens selecionados, voc deve iterar sobre uma c pia da lista ao inv s da pr pria. A notacao slice e particularmente e o e o conveniente para isso:
>>> for x in a[:]: # faz uma cpia da lista inteira o ... if len(x) > 6: a.insert(0, x) ... >>> a [defenestrar, gato, janela, defenestrar]
4.3
A Funcao range()
Se voc precisar iterar sobre sequ ncias num ricas, a funcao interna range() e a resposta. Ela gera listas contendo e e e progress es aritim ticas, ex.: o e
>>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
O ponto de parada fornecido nunca e gerado na lista; range(10) gera uma lista com 10 valores, exatamente os ndices v lidos para uma sequ ncia de comprimento 10. E possvel iniciar o intervalo em outro n mero, ou alterar a a e u raz o da progres o (inclusive com passo negativo): a a
>>> range(5, 10) [5, 6, 7, 8, 9] >>> range(0, 10, 3) [0, 3, 6, 9] >>> range(-10, -100, -30) [-10, -40, -70]
Para iterar sobre os ndices de uma sequ ncia, combine range() e len() da seguinte forma: e
>>> 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
4.4
Clausulas break, continue e else em Lacos
O break , como no C, quebra o laco mais interno de um for ou while. O continue , tamb m emprestado do C, continua o pr ximo passo do laco mais interno. e o Lacos podem ter uma cl usula else, que e executada sempre que o laco se encerra por exaust o da lista (no caso do a a for) ou quando a condicao se torna falsa (no caso do while), mas nunca quando o laco e encerrado por um break. Isto e exemplicado no pr ximo exemplo que procura n meros primos: o u
18
Captulo 4. Mais Ferramentas de Controle de Fluxo
>>> for n in range(2, 10): ... for x in range(2, n): ... if n % x == 0: ... print n, equals, x, *, n/x ... break ... else: ... 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
4.5
Construcao pass
A construcao pass n o faz nada. Ela pode ser usada quando a sintaxe exige um comando mas a sem ntica do a a programa n o requer nenhuma acao. Por exemplo: a
>>> while 1: ... pass # Busy-wait para interrupco de teclado a ...
4.6
Denindo Funcoes
N s podemos criar uma funcao que escreve a s rie de Fibonacci at um limite arbitr rio: o e e a
>>> ... ... ... ... ... ... >>> ... 1 1 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 funcao que acabamos de definir fib(2000) 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
A palavra-reservada def serve para denir uma funcao. Ela deve ser seguida do nome da funcao, da lista formal de par metros entre par nteses e dois pontos. a e O corpo da funcao deve comecar na linha seguinte e deve ser identado. Opcionalmente, a primeira linha do corpo da funcao pode ser uma string literal, cujo prop sito e documentar a funcao. Se presente, essa string chama-se docstring. o Existem ferramentas que utilizam docstrings para produzir automaticamente documentacao impressa, on-line, ou ainda permitir que o usu rio navegue interativamente pelo c digo. E uma boa pr rica incluir sempre docstrings em suas a o a funcoes, portanto, tente fazer disto um h bito. a A execucao da funcao gera uma nova tabela de smbolos utilizada para as vari veis locais da funcao, mais preci a samente, toda atribuicao a vari vel dentro da funcao armazena o valor na tabela de smbolos local. Refer ncias a a e vari veis s o buscadas primeiramente na tabela local, ent o na tabela de smbolos global e nalmente na tabela de a a a 4.5. Construcao pass 19
smbolos interna (built-in). Portanto, n o se pode atribuir diretamente um valor a uma vari vel global dentro de uma a a funcao (a menos que se utilize a declaracao global antes), ainda que vari veis globais possam ser referenciadas a livremente. Os par metros reais (argumentos) de uma chamada de funcao s o introduzidos na tabela de smbolos local da funcao a a chamada, portanto, argumentos s o passados por valor (onde valor e sempre uma refer ncia para objeto, n o o valor a e a do objeto)1 Quando uma funcao chama outra, uma nova tabela de smbolos e criada para tal chamada. Uma denicao de funcao introduz o nome da funcao na tabela de smbolos corrente. O valor do nome da funcao possui um tipo que e reconhecido pelo interpretador como uma funcao denida pelo usu rio. Esse valor pode ser atribudo a para outros nomes que tamb m podem ser usados como funcoes. Esse mecanismo serve para renomear funcoes: e
>>> fib <function object at 10042ed0> >>> f = fib >>> f(100) 1 1 2 3 5 8 13 21 34 55 89
Voc pode armar que fib n o e uma funcao, mas um procedimento. Em Python, assim como em C, procedimentos e a s o apenas funcoes que n o retornam valores. Na verdade, falando tecnicamente, procedimentos retornam um valor, a a ainda que meio chato. Esse valor e chamado None ( um nome interno). A escrita do valor None e supressa pelo e interpretador se ele estiver sozinho. Voc pode vericar isso se quiser. e
>>> print fib(0) None
E muito simples escrever uma funcao que retorna a lista da s rie de Fibonacci, ao inv s de imprimi-la: e e
>>> ... ... ... ... ... ... ... ... >>> >>> [1,
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, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Este exemplo, como sempre, demonstra algumas caractersticas novas: A palavra-chave return termina a funcao retornando um valor. Se return n o for seguido de nada, ent o a a retorna o valor None. Se a funcao chegar ao m sem o uso explcito do return, ent o tamb m ser retornado a e a o valor None.
O trecho result.append(b) chama um m todo do objeto lista result. Um m todo e uma funcao e e que pertence a um objeto e e chamada atrav s de obj.methodname, onde obj e um objeto qualquer, e e methodname e o nome de um m todo que foi denido pelo tipo do objeto. Tipos diferentes denem m todos e e diferentes. Sobretudo, m todos de diferentes tipos podem ser hom nimos sem ambiguidade ( possvel denir e o e seus pr prios tipos de objetos e m todos, utilizando classes, como ser discutido mais tarde neste tutorial). o e a
1 De fato, passagem por refer ncia para objeto seria uma melhor descric ao, pois quando um objeto mut vel for passado, o chamador ir perceber e a a as alterac oes feitas pelo chamado (ex: insercao de itens em uma lista).
20
O m todo append() mostrado no exemplo e denido para todos objetos do tipo lista. Este m todo permite a e e adicao de novos elementos a lista. Neste exemplo, ele e equivalente a result = result + [b], s que ` o append() ainda e mais eciente.
4.7
Mais sobre Denicao de Funcoes
Ainda e possvel denir funcoes com um n mero vari vel de argumentos. Existem tr s formas que podem ser combi u a e nadas.
4.7.1
Parametros com Valores Default
A mais util das tr s e especicar um valor default para um ou mais argumentos. Isso cria uma funcao que pode ser e invocada com um n mero menor de argumentos do que quando foi denida, ex: u
def ask_ok(prompt, retries=4, complaint=Yes or no, please!): while 1: ok = raw_input(prompt) if ok in (y, ye, yes): return 1 if ok in (n, no, nop, nope): return 0 retries = retries - 1 if retries < 0: raise IOError, refusenik user print complaint
Essa funcao pode ser chamada de duas formas: ask ok(Do you really want to quit?) ou como ask ok(OK to overwrite the file?, 2). Os valores default s o avaliados durante a denicao da funcao, e no escopo em que a funcao foi denida: a
i = 5 def f(arg = i): print arg i = 6 f()
ir imprimir 5. a Aviso importante: Valores default s o avaliados apenas uma vez. Isso faz diferenca quando o valor default e um a objeto mut vel como uma lista ou dicion rio. Por exemplo, a funcao a seguir acumula os argumentos passados em a a chamadas subsequentes:
def f(a, l = []): l.append(a) return l print f(1) print f(2) print f(3)
Isso ir imprimir: a
[1] [1, 2] [1, 2, 3]
Se voc n o quiser que o valor default seja compartilhado entre chamadas subsequentes, pode reescrever a funcao e a assim:
def f(a, l = None):
4.7. Mais sobre Denicao de Funcoes
21
if l is None: l = [] l.append(a) return l
4.7.2
Parametros na Forma Chave-Valor
Funcoes tamb m podem ser chamadas passando argumentos no formato chave-valor como keyword = value. Por e exemplo:
def parrot(voltage, state=a stiff, action=voom, type=Norwegian Blue): print "-- This parrot wouldnt", action, print "if you put", voltage, "Volts through it." print "-- Lovely plumage, the", type print "-- Its", state, "!"
poderia ser chamada em qualquer uma das seguintes maneiras:
parrot(1000) parrot(action = VOOOOOM, voltage = 1000000) parrot(a thousand, state = pushing up the daisies) parrot(a million, bereft of life, jump)
por m, existem maneiras inv lidas: e a
parrot() parrot(voltage=5.0, dead) parrot(110, voltage=220) parrot(actor=John Cleese)
# # # #
parmetro exigido faltando a a a a parmetro no-chave-valor depois de parmetro chave-valor a valor duplicado para mesmo parmetro parmetro desconhecido a
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 e e a importante se um dado argumento j possuia valor default ou n o. Nenhum argumento deve receber um valor mais do a a que uma unica vez. Nomes de par metros formais correspondendo a argumentos posicionais n o podem ser usados na a a forma chave-valor em uma mesma chamada. O pr ximo exemplo ilustra essa limitacao. o
>>> def function(a): ... pass ... >>> function(0, a=0) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: keyword parameter redefined
Quando o ultimo par metro formal for **name, ele armazenar todos os par metros efetivamente passados para a a a a funcao e que n o correspondiam a par metros formais. Isto pode ser combinado com o par metro formal *name a a a (descrito na pr xima sub-secao) que recebe a lista contendo todos argumentos posicionais que n o correspondiam a o a par metros formais. O importante e que (*name deve ser declarado antes de **name.) Siga o exemplo: a
def cheeseshop(kind, *arguments, **keywords): print "-- Do you have any", kind, ? print "-- Im sorry, were all out of", kind for arg in arguments: print arg print -*40
22
for kw in keywords.keys(): print kw, :, keywords[kw]
Poderia ser chamado assim:

cheeseshop(Limburger, "Its very runny, sir.", "Its really very, VERY runny, sir.", client=John Cleese, shopkeeper=Michael Palin, sketch=Cheese Shop Sketch)
e naturalmente produziria:
-- Do you have any Limburger ? -- Im sorry, were all out of Limburger Its very runny, sir. Its really very, VERY runny, sir. ---------------------------------------client : John Cleese shopkeeper : Michael Palin sketch : Cheese Shop Sketch
4.7.3
Listas Arbitrarias de Argumentos
Finalmente, a opcao menos frequentemente usada e chamar a funcao com um n mero arbitr rio de argumentos. Esses u a argumentos ser o encapsulados em uma sequ ncia (tupla). Antes do n mero vari vel de argumentos, zero ou mais a e u a argumentos normais podem estar presentes.
def fprintf(file, format, *args): file.write(format % args)
4.7.4
Funcoes Lambda
Dada a demanda do p blico, algumas caractersticas encontradas em linguagens de programacao funcionais (como u Lisp) foram adicionadas a Python. Com a palavra-chave lambda, funcoes curtas e an nimas podem ser criadas. o Aqui est uma funcao que devolve a soma de seus dois argumentos: lambda a, b: a+b. Funcoes Lambda a podem ser utilizadas em qualquer lugar que exigiria uma funcao tradicional. Sintaticamente, funcoes Lambda est o a restritas a uma unica express o. Semanticamente, ela s o apenas acucar sint tico para a denicao de funcoes normais. a a a Assim como denicoes de funcoes aninhadas, funcoes lambda n o podem referenciar vari veis de um escopo mais a a externo, o que pode ser contornado pelo parcimonioso uso de argumentos com valores default, ex:
>>> ... ... >>> >>> 42 >>> 43 >>>
def make_incrementor(n): return lambda x, incr=n: x+incr f = make_incrementor(42) f(0) f(1)
4.7.5
Strings de Documentacao
H uma convencao sobre o conte do e formato de strings de documentacao. a u
4.7. Mais sobre Denicao de Funcoes
23
A primeira linha deve ser sempre curta, representando um consiso sum rio do prop sito do objeto. Por brevidade, n o a o a deve explicitamente se referir ao nome ou tipo do objeto, uma vez que estas informacoes est o disponvies por outros a meios (exceto se o nome da funcao for o pr prio verbo que descreve a nalidade da funcao). Essa linha deve comecar o com letra mai scula e terminar com ponto. u Se existem m ltiplas linhas na string de documentacao, a segunda linha deve estar em branco, visulamente separando u o sum rio do resto da descricao. As linhas seguintes devem conter um ou mais par grafos descrevendo as convencoes a a de chamada ao objeto, seus efeitos colaterais, etc. O parser do Python n o toca na identacao de coment rios multi-linha. Portanto, ferramentas que processem strings de a a documentacao precisam lidar com isso (se desejado). Existe uma convencao para isso. A primeira linha n o nula ap s a o a linha de sum rio determina a identacao para o resto da string de documentacao. A partir da, espacos em branco a podem ser removidos de todas as linhas da string. Aqui est um exemplo de uma docstring multi-linha: a
>>> def my_function(): ... """Do nothing, but document it. ... ... No, really, it doesnt do anything. ... """ ... pass ... >>> print my_function.__doc__ Do nothing, but document it. No, really, it doesnt do anything.
24
CAP ITULO
FIVE
Estruturas de Dados
Este captulo descreve alguns pontos j abordados, por m com mais detalhes, e ainda adiciona outros pontos in ditos. a e e
5.1
Mais sobre Listas
O tipo list possui mais m todos. Aqui est o todos os m todos disponvies em um objeto lista. e a e append(x) Adiciona um item ao m da lista; equivalente a a[len(a):] = [x].
extend(L) Extende a lista adicionando no m todos os elementos da lista passada como par metro; equivalente a a a[len(a):] = L. insert(i, x) Insere um item em uma posicao especicada. O primeiro argumento e o ndice do elemento anterior ao que est para ser inserido, assim a.insert(0, x) insere no incio da lista, e a.insert(len(a), x) a e equivalente a a.append(x). remove(x) Remove o primeiro item da lista cujo valor e x. E gerado um erro se este valor n o existir. a pop([i ]) Remove o item na posicao dada e o retorna . Se nenhum item for especicado, a.pop() remove e retorna o ultimo item na lista. index(x) Retorna o ndice do primeiro item cujo valor e igual ao argumento fornecido em x, gerando erro se este valor n o existe. a count(x) Retorna o n mero de vezes que o valor x aparece na lista. u sort() Ordena os itens da lista sem gerar uma nova lista. reverse() Inverte a ordem dos elementos na lista sem gerar uma nova lista. Um exemplo que utiliza a maioria dos m todos: e
>>> a = [66.6, 333, 333, 1, 1234.5] >>> print a.count(333), a.count(66.6), a.count(x) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.6, 333, -1, 333, 1, 1234.5, 333] >>> a.index(333) 1 >>> a.remove(333)
25
>>> a [66.6, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.6] >>> a.sort() >>> a [-1, 1, 66.6, 333, 333, 1234.5]
5.1.1
Usando Listas como Pilhas
Os m todos de lista tornam muito f cil utilizar listas como pilhas, onde o item adicionado por ultimo e o primeiro a e a ser recuperado (poltica ltimo a entrar, primeiro a sair). Para adicionar um item ao topo da pilha, use append(). u Para recuperar um item do topo da pilha use pop() sem nenhum ndice. Por exemplo:
>>> >>> >>> >>> [3, >>> 7 >>> [3, >>> 6 >>> 5 >>> [3,
stack = [3, 4, 5] stack.append(6) stack.append(7) stack 4, 5, 6, 7] stack.pop() stack 4, 5, 6] stack.pop() stack.pop() stack 4]
5.1.2
Usando Listas como Filas
Voc pode tamb m utilizar uma lista como uma la, onde o primeiro item adicionado e o primeiro a ser recuperado e e (poltica primeiro a entrar, primeiro a sair). Para adicionar um elemento ao m da la utiliza append(). Para recuperar um elemento do incio da la use pop() com 0 no ndice. Por exemplo:
>>> 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]
5.1.3
Ferramentas para Programacao Funcional
Existem tr s funcoes internas que s o muito uteis sobre listas: filter(), map(), e reduce(). e a filter(function, sequence) retorna uma sequ ncia (do mesmo tipo se possvel) consistindo dos itens pertencene tes a sequ ncia para os quais function(item) e verdadeiro. Por exemplo, para computar n meros primos: e u 26 Captulo 5. Estruturas de Dados
>>> def f(x): return x % 2 != 0 and x % 3 != 0 ... >>> filter(f, range(2, 25)) [5, 7, 11, 13, 17, 19, 23]
map(function, sequence) aplica function(item) para cada item da sequ ncia e retorna a lista de valores retornados e a cada aplicacao. Por exemplo, para computar quadrados:
>>> def cube(x): return x*x*x ... >>> map(cube, range(1, 11)) [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
Mais de uma sequ ncia pode ser passada; a funcao a ser aplicada deve possuir tantos par metros formais quantas e a sequ ncias forem alimentadas para map. Se None for passado no lugar da funcao, ent o ser aplicada uma funcao e a a que apenas devolve os argumentos recebidos. Dessa forma, map(None, list1, list2) e uma forma conveniente de concatenar listas em uma unica. Por exemplo:
>>> seq = range(8) >>> def square(x): return x*x ... >>> map(None, seq, map(square, seq)) [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]
reduce(func, sequence) retorna um unico valor construdo a partir da sucessiva aplicacao da funcao bin ria func a a todos os elementos da lista fornecida, dois de cada vez. Por exemplo, para computar a soma dos 10 primeiros n meros inteiros: u
>>> def add(x,y): return x+y ... >>> reduce(add, range(1, 11)) 55
Se apenas houver um unico elemento na sequ ncia fornecida como par metro, ent o seu valor ser retornado. Se a e a a a sequ ncia for vazia uma excecao ser levantada. e a Um terceiro argumento pode ser passado para indicar o valor inicial. Neste caso, reducao de sequ ncias vazias retor e nar o valor inicial. Se a sequ ncia n o for vazia, a reducao se iniciar a partir do valor inicial. a e a a
>>> def sum(seq): ... def add(x,y): return x+y ... return reduce(add, seq, 0) ... >>> sum(range(1, 11)) 55 >>> sum([]) 0
5.1.4
Abrangencia de Lista (List Comprehensions)
Abrang ncia de listas (ou list comprehensions) permitem a criacao de listas de forma concisa sem apelar para o uso e de map(), filter() e/ou lambda. A denicao resultante tende a ser mais clara do que o uso das construcoes funcionais citadas anteriormente.
5.1. Mais sobre Listas
27
Cada abrang ncia de lista consiste numa express o seguida da cl usula for, e ent o zero ou mais cl usulas for ou if. e a a a a O resultado ser uma lista proveniente da avaliacao da express o no contexto das cl usulas for e if subsequentes. a a a Se a express o gerar uma tupla, a mesma deve ser inserida entre par nteses. a e
>>> 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] [[2, 4], [4, 16], [6, 36]] >>> [x, x**2 for x in vec] # erro - parenteses requerido para tuplas File "<stdin>", line 1 [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]
5.2
O comando del
Existe uma maneira de remover um item de uma lista a partir de seu ndice, ao inv s de seu valor: o comando del. e Ele tamb m pode ser utilizado para remover fatias (slices) da lista. Por exemplo: e
>>> a [-1, 1, 66.6, 333, 333, 1234.5] >>> del a[0] >>> a [1, 66.6, 333, 333, 1234.5] >>> del a[2:4] >>> a [1, 66.6, 1234.5]
del tamb m pode ser utilizado para apagar vari veis: e a
>>> del a
Referenciar a vari vel a posteriormente a sua remocao constitui erro (pelo menos at que seja feita uma nova atribuicao a e para ela). N s encontraremos outros usos para o comando del mais tarde. o
28
Captulo 5. Estruturas de Dados
5.3
Tuplas e Sequencias
N s vimos que listas e strings possuem muitas propriedades em comum como indexacao e operacoes de slicing. o Elas s o dois dos exemplos possveis de sequ ncias. Como Python e uma linguagem em evolucao, outros tipos de a e sequ ncias podem ser adicionados. Existe ainda um outro tipo de sequ ncia j presente na linguagem: a tupla (tuple). e e a Uma tupla consiste em uma sequ ncia imut vel de valores separados por vrgulas. e a
>>> 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))
Como voc pode ver no trecho acima, tuplas s o sempre envolvidas por par nteses. Na criacao, tuplas podem ser e a e envolvidas ou n o por par nteses, desde que o contexto n o exija os par nteses (como no caso da tupla pertencer a a e a e uma express o maior). a Tuplas podem ter os mais diversos usos: pares ordenados, registros de empregados em uma base de dados, etc. Tuplas, assim como strings, s o imut veis. N o e possvel atribuir valores a itens individuais de uma tupla (voc pode simular a a a e o mesmo efeito atrav s de operacoes de fatiamento e concatenacao). Tamb m e possvel criar tuplas contendo objetos e e mut veis, como listas. a Um problema especial e a criacao de tuplas contendo 0 ou 1 itens: a sintaxe tem certos truques para acomodar estes casos. Tuplas vazias s o construdas por uma par de par nteses vazios. E uma tupla unit ria e construda por um unico a e a valor e uma vrgula entre par nteses (sem a vrgula a tupla n o ser gerada!). Feio, mas efetivo: e a a
>>> empty = () >>> singleton = hello, >>> len(empty) 0 >>> len(singleton) 1 >>> singleton (hello,)
# <-- observe a vrgula extra
O comando t = 12345, 54321, hello! e um exemplo de empacotamento em tupla (tuple packing): os valores 12345, 54321 e hello! s o empacotados juntos em uma tupla. A operacao inversa tamb m e possvel: a e
>>> x, y, z = t
Isto e chamado de desempacotamento de sequ ncia (sequence unpacking), e requer que a lista de vari veis do lado e a esquerdo corresponda ao comprimento da sequ ncia a direita. Sendo assim, a atribuicao m ltipla e um caso de empae ` u cotamento e desempacotamento de tupla. Existe ainda uma certa assimetria aqui: empacotamento de m ltiplos valores sempre cria tuplas, mas o desempacotau mento funciona para qualquer sequ ncia. e
5.3. Tuplas e Sequencias
29
5.4
Dicionarios
Outra estrutura de dados interna de Python, e muito util, e o dicion rio. Dicion rios s o tamb m chamados de a a a e mem ria associativa, ou vetor associativo . Diferentemente de sequ ncias que s o indexadas por inteiros, dio e a cion rios s o indexados por chaves (keys), que podem ser de qualquer tipo imut vel (como strings e inteiros). Tuplas a a a tamb m podem ser chaves se contiverem apenas strings, inteiros ou outras tuplas. Se a tupla contiver, direta ou ine diretamente, qualquer valor mut vel n o poder ser chave. Listas n o podem ser usadas como chaves porque s o a a a a a mut veis. a O melhor modelo mental de um dicion rio e um conjunto n o ordenado de pares chave-valor, onde as chaves s o a a a unicas em uma dada inst ncia do dicion rio. a a Dicion rios s o delimitados por : {}. Uma lista de pares chave:valor separada por vrgulas dentro desse delimitadores a a dene a constituicao inicial do dicion rio. Dessa forma tamb m ser impresso o conte do de um dicion rio em uma a e a u a secao de depuracao. As principais operacoes em um dicion rio s o armazenar e recuperar valores a partir de chaves. Tamb m e possvel a a e remover um par chave:valor com o comando del. Se voc armazenar um valor utilizando uma chave j presente, o e a antigo valor ser substitudo pelo novo. Se tentar recuperar um valor dada uma chave inexistente ser gerado um erro. a a O m todo keys() do dicion rio retorna a lista de todas as chaves presentes no dicion rio, em ordem aleat ria (se e a a o desejar orden -las basta aplicar o m todo sort() na lista devolvida). Para vericar a exist ncia de uma chave, utilize a e e o m todo has key() do dicion rio. e a A seguir, um exemplo de uso do dicion rio: a
>>> 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) 1
5.5
Mais sobre Condicoes
As condicoes de controle utilizadas no while e if acima podem conter outros operadores al m de comparacoes. e Os operadores de comparacao in e not in vericam se um valor ocorre (ou n o ocorre) em uma dada sequ ncia. a e Os operadores is e is not comparam se dois objetos s o na verdade o mesmo objetos; o que s e signicativo no a o contexto de objetos mut veis, como listas. Todos operadores de comparacao possuem a mesma preced ncia, que e a e menor do que a prioridade dos operadores num ricos. e Comparacoes podem ser encadeadas: a < b == c testa se a e menor que b e ainda por cima se b e igual a c. Comparacoes podem ser combinadas atrav s de operadores booleanos and e or, e negados atrav s de not. Estes e e possuem menor prioridade que os demais operadores de comparacao. Entre eles, not e o de maior prioridade e or o de menor. Dessa forma, a condicao A and not B or C e equivalente a (A and (not B)) or C. Naturalmente par nteses podem ser usados para expressar o agrupamento desejado. e
30
Captulo 5. Estruturas de Dados
Os operadores booleanos and and or s o tamb m operadores atalhos : seus argumentos s o avaliados da esquerda a e a para a direita, e a avaliacao p ra quando o resultado se torna conhecido. Ex., se A e C s o verdadeiros mas B e falso, a a ent o A and B and C n o avaliar a express o C. Em geral, o valor de retorno de um operador atalho, quando a a a a usado sobre valores gen ricos e n o como booleanos, e o ultimo valor avaliado na express o. e a a E possvel atribuir o resultado de uma comparacao ou outra express o booleana para uma vari vel. Por exemplo: a a
>>> string1, string2, string3 = , Trondheim, Hammer Dance >>> non_null = string1 or string2 or string3 >>> non_null Trondheim
Observe que em Python, diferentemente de C, atribuicao n o pode ocorrer dentro de uma express o. Programadores C a a podem resmungar, mas isso evita toda uma classe de problemas frequentemente encontrados em programas C: digitar = numa express o quando a intencao era ==. a
5.6
Comparando Sequencias e Outros Tipos
Objetos sequ ncia podem ser comparados com outros objetos sequ ncia, desde que o tipo das sequ ncias seja o e e e mesmo. A comparacao utiliza a ordem l xicograca : primeiramente os dois primeiros itens s o comparados, e se e a diferirem isto determinar o resultado da comparacao, caso contr rio os pr ximos dois itens ser o comparados, e a a o a assim por diante at que se tenha exaurido alguma das sequ ncias. Se em uma comparacao de itens, os mesmos forem e e tamb m sequ ncias (aninhadas), ent o e disparada recursivamente outra comparacao l xicograca. Se todos os itens e e a e da sequ ncia forem iguais, ent o as sequ ncias s o ditas iguais. Se uma das sequ ncias e uma subsequ ncia da outra, e a e a e e ent o a subsequ ncia e dita menor (operador ). A comparacao lexicogr ca utiliza ASCII para denir a ordenacao. a e a Alguns exemplos de comparacoes entre sequ ncias do mesmo tipo: e
(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)
Observe que e permitido comparar objetos de diferentes tipos. O resultado e determinstico, por m, arbitr rio: os tipos e a s o ordenados pelos seus nomes. Ent o, uma lista e sempre menor do que uma string, uma string e sempre menor do a a que uma tupla, etc. Tipos num ricos mistos s o comparados de acordo com seus valores num ricos, logo 0 e igual a e a e 0.0, etc.1
1 As
regras para comparacao de objetos de tipos diferentes n o s o con veis; elas podem variar em futuras vers es da linguagem. a a a o
5.6. Comparando Sequencias e Outros Tipos
31
32
CAP ITULO
SIX
Modulos
Se voc sair do interpretador Python e entrar novamente, todas as denicoes de funcoes e vari veis ser o perdidas. e a a Logo, se voc desejar escrever um programa que dure e melhor preparar o c digo em um editor de textos. Quando e o estiver pronto, dispare o interpretador sobre o arquivo-fonte gerado. Isto se chama gerar um script. A medida que seus programas crescem, pode ser desej vel dividi-los em v rios arquivos para facilitar a manutencao. a a Talvez voc at queira reutilizar uma funcao sem copiar sua denicao a cada novo programa. e e Para permitir isto, Python possui uma maneira de depositar denicoes em um arquivo e posteriormente reutiliz -las a em um script ou secao interativa do interpretador. Esse arquivo e denominado m dulo. Denicoes de um m dulo o o podem ser importadas por outros m dulos ou no m dulo principal. o o Um m dulo e um arquivo contendo denicoes e comandos Python. O nome do arquivo recebe o suxo .py. Dentro o de um m dulo, seu nome (uma string) est disponvel na vari vel global name . Por exemplo, use seu editor de o a a textos favorito para criar um arquivo chamado bo.py no diret rio corrente com o seguinte conte do: o u
# Mdulo Sequncias de Fibonacci o e 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
Agora inicie o interpretador e importe o m dulo da seguinte forma: o

>>> import fibo
Isso n o incorpora as funcoes denidas em fibo diretamente na tabela de smbolos corrente, apenas coloca o nome a do m dulo l . Atrav s do nome do m dulo voc pode acessar as funcoes: o a e o e
>>> 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
33
Se voc pretende utilizar uma funcao frequentemente, e possvel atribuir a ela um nome local: e
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6.1
Mais sobre Modulos
Um m dulo pode conter tanto comandos como denicoes. Os comandos servem ao prop sito de inicializar o m dulo, o o o sendo executados apenas na primeira vez em que o mesmo e importado. 1 Cada m dulo possui sua pr pria tabela de smbolos, que e usada como tabela de smbolos global por todas as funcoes o o denidas no pr prio m dulo. Portanto, o autor do m dulo pode utilizar vari veis globais no m dulo sem se preocupar o o o a o com colis o de nomes acidental com as vari veis globais de usu rio. a a a Por outro lado, se voc sabe o que est fazendo, e possvel o acesso as vari veis globais do m dulo atrav s da mesma e a a o e notacao. O que permite o acesso as funcoes do m dulo: modname.itemname. ` o M dulos podem ser importados por outros m dulos. E costume, por m n o obrigat rio, colocar todos os comandos o o e a o de importacao (import) no incio do m dulo (ou script, se preferir). o Existe uma variante do comando import statement que importa nomes de um dado m dulo diretamente para a tabela o do m dulo importador. Os nomes do m dulo importado s o adicionados a tabela de smbolos global do m dulo o o a o importador. Por exemplo:
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Isso n o introduz o nome do m dulo importado na tabela de smbolos local, mas sim o nome da funcao diretamente. a o Existe ainda uma variante que permite importar diretamente todos os nomes denidos em um dado m dulo. o
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Isso importa todos os nomes exceto aqueles iniciados por um sublinhado ( ).
6.1.1
O Caminho de Busca dos Modulos
Quando um m dulo denominado spam e importado, o interpretador busca por um arquivo chamado spam.py no o diret rio corrente, depois na lista de diret rios especicados pela vari vel de ambiente PYTHONPATH. Esta ultima o o a possui a mesma sintaxe da vari vel de ambiente PATH, isto e, uma lista de caminhos. Quando PYTHONPATH n o a a existir, ou o arquivo n o for achado nesta lista, a busca continua num caminho que depende da instalacao. No caso do a U NIX esse caminho e quase sempre .:/usr/local/lib/python. De fato, m dulos s o buscados pela lista de caminhos especicados na vari vel sys.path inicializada com os camio a a nhos citados acima, o que permite aos programas Python manipularem o processo de busca de m dulos se desejado. o Veja a secao M dulos Padr o para obter mais detalhes. o a
verdade, denicoes de funcoes s o tamb m comandos que s o executados. A execuc ao desses comandos e colocar o nome da funcao a e a na tabela de smbolos global do m dulo. o
1 Na
34
Captulo 6. Modulos
6.1.2
Arquivos Python Compilados
Um fator que agiliza a carga de programas curtos que utilizam muitos m dulos padr o e a exist ncia de um arquivo o a e com extens o .pyc no mesmo diret rio do fonte .py. O arquivo .pyc cont m uma vers o byte-compilada do a o e a fonte .py. A data de modicacao de .py e armazenada dentro do .pyc, e vericada automaticamente antes da utilizacao do ultimo. Se n o conferir, o arquivo .pyc existente e re-compilado a partir do .py mais atual. a Normalmente, n o e preciso fazer nada para gerar o arquivo .pyc. Sempre que um m dulo .py e compilado com a o sucesso, e feita uma tentativa de se escrever sua vers o compilada para o .pyc. N o h geracao de erro se essa a a a tentativa falha. Se por qualquer raz o o arquivo compilado n o e inteiramente escrito em disco, o .pyc resultante a a ser reconhecido como inv lido e, portanto, ignorado. O conte do do .pyc e independente de plataforma, assim um a a u diret rio de m dulos Python pode ser compartilhado por diferentes arquiteturas. o o Algumas dicas dos experts: Quando o interpretador Python e invocado com a diretiva -O, c digo otimizado e gerado e armazenado em o arquivos .pyo. O otimizador corrente n o faz muita coisa, ele apenas remove construcoes assert e instrucoes a a SET LINENO. Quando o -O e utilizado, todo bytecode e otimizado. Arquivos .pyc s o ignorados e arquivos .py s o compilados em bytecode otimizado. a
Passando dois ags -O ao interpretador (-OO) ir forcar o compilador de bytecode a efetuar otimizacoes arrisa cadas que poderiam em casos raros acarretar o mal funcionamento de programas. Presentemente, apenas strings doc s o removidas do bytecode, proporcionando arquivos .pyo mais compactos. Uma vez que alguns a programas podem supor a exist ncia das docstrings, e melhor voc s se utilizar disto se tiver seguranca de que e e o n o acarretar nenhum efeito colateral negativo. a a
Um programa n o executa mais r pido quando e lido de um arquivo .pyc ou de um .pyo em comparacao a a a quando e lido de um .py. A unica diferenca e que nos dois primeiros casos o tempo de carga do programa e menor.
Quando um script e executado diretamente a partir de seu nome da linha de comando, n o s o geradas as a a formas compiladas deste script em arquivos .pyo ou .pyc. 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 o o disparo. E possvel disparar o interpretador diretamente sobre arquivos compilados.
Na presenca das formas compiladas (.pyc e.pyo) de um script, n o h necessidade da presenca da forma a a textual(.py). Isto e util na hora de se distribuir bibliotecas Python dicultando pr ticas de engenharia reversa. a
O m dulo compileall pode criar arquivos .pyc (ou .pyo quando e usado -O) para todos os m dulos em o o um dado diret rio. o
6.2
Modulos Padrao
Python possui um biblioteca padr o de m dulos, descrita em um documento em separado, a Python Library Refea o rence (doravante Library Reference). Alguns m dulos est o embutidos no interpretador; estes possibilitam acesso o a a operacoes que n o s o parte do n cleo da linguagem, seja por eci ncia ou para permitir o acesso a chamadas de a a u e sistema. O conjunto presente destes m dulos e congur vel, por exemplo, o m dulo amoeba s est disponvel em o a o o a sistemas que suportam as primitivas do Amoeba. Existe um m dulo que requer especial atencao: sys, que e embuo tido em qualquer interpretador Python. As vari veis sys.ps1 e sys.ps2 denem as strings utilizadas como prompt a prim rio e secund rio: a a
>>> import sys >>> sys.ps1 >>>
6.2. Modulos Padrao
35
>>> sys.ps2 ... >>> sys.ps1 = C> C> print Yuck! Yuck! C>
Essas vari veis s est o denidas se o interpretador est em modo interativo. a o a a A vari vel sys.path cont m uma lista de strings que determina os caminhos de busca de m dulos conhecidos pelo a e o interpretador. Ela e inicializada para um caminho default determinado pela vari vel de ambiente PYTHONPATH ou a por um valor default interno se a vari vel n o estiver denida. Voc pode modic -la utilizando as operacoes tpicas a a e a de lista, por exemplo:
>>> import sys >>> sys.path.append(/ufs/guido/lib/python)
6.3
A Funcao dir()
A funcao interna dir() e utilizada para se descobrir que nomes s o denidos por um m dulo. Ela retorna uma lista a o ordenada de strings:
>>> import fibo, sys >>> dir(fibo) [__name__, fib, fib2] >>> dir(sys) [__name__, argv, builtin_module_names, copyright, exit, maxint, modules, path, ps1, ps2, setprofile, settrace, stderr, stdin, stdout, version]
Sem nenhum argumento, dir() lista os nomes correntemente denidos:
>>> a = [1, 2, 3, 4, 5] >>> import fibo, sys >>> fib = fibo.fib >>> dir() [__name__, a, fib, fibo, sys]
Observe que ela lista nomes dos mais diversos tipos: vari veis, m dulos, funcoes, etc. a o dir() n o lista nomes de funcoes ou vari veis internas. Se voc desejar conhec -los, eles est o denidos no m dulo a a e e a o padr o builtin : a
>>> import __builtin__ >>> dir(__builtin__) [AccessError, AttributeError, ConflictError, EOFError, IOError, ImportError, IndexError, KeyError, KeyboardInterrupt, MemoryError, NameError, None, OverflowError, RuntimeError, SyntaxError, SystemError, SystemExit, TypeError, ValueError, ZeroDivisionError, __name__, abs, apply, chr, cmp, coerce, compile, dir, divmod, eval, execfile, filter, float, getattr, hasattr, hash, hex, id, input, int, len, long, map, max, min, oct, open, ord, pow, range, raw_input, reduce, reload, repr, round, setattr, str, type, xrange]
36
Captulo 6. Modulos
6.4
Pacotes
Pacotes s o uma maneira de estruturar espacos de nomes para m dulos utilizando a sintaxe de separacao por ponto. a o Como exemplo, o m dulo A.B designa um sub-m dulo chamado B num pacote denominado A. O uso de pacotes o o permite aos autores de grupos de m dulos (como NumPy ou PIL) n o terem que se preocupar com colis o entre os o a a nomes de seus m dulos e os nomes de m dulos de outros autores. o o Suponha que voc deseje projetar uma colecao de m dulos (um pacote) para o gerenciamento uniforme de arquivos e o de som. Existem muitos formatos diferentes (normalmente identicados pela extens o do nome de arquivo, ex. .wav, a .aiff, .au), de forma que voc pode precisar criar e manter uma crescente colecao de m dulos de convers o entre e o a formatos. Ainda podem existir muitas operacoes diferentes passveis de aplicacao sobre os arquivos de som (ex. mixa gem, eco, equalizacao, efeito stereo articial). Logo, possivelmente voc tamb m estar escrevendo uma intermin vel e e a a colecao de m dulos para aplicar estas operacoes. o Aqui est uma possvel estrutura para o seu pacote (expressa em termos de um sistema hier rquico de arquivos): a a
Sound/ __init__.py Formats/ __init__.py wavread.py wavwrite.py aiffread.py aiffwrite.py auread.py auwrite.py ... Effects/ __init__.py echo.py surround.py reverse.py ... Filters/ __init__.py equalizer.py vocoder.py karaoke.py ...
Top-level package Initialize the sound package Subpackage for file format conversions
Subpackage for sound effects
Subpackage for filters
Os arquivos init .py s o necess rios para que Python trate os diret rios como um conjunto de m dulos. Isso foi a a o o feito para evitar diret rios com nomes comuns, como string, de inadvertidamente esconder m dulos v lidos que o o a ocorram a posteriori no caminho de busca. No caso mais simples, init .py pode ser um arquivo vazio. Por m, ele e pode conter c digo de inicializacao para o pacote ou gerar a vari vel all , que ser descrita depois. o a a Usu rios do pacote podem importar m dulos individuais, por exemplo: a o
import Sound.Effects.echo
Assim se carrega um sub-m dulo Sound.Effects.echo. Ele deve ser referenciado com seu nome completo, o como em:
Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4)
Uma alternativa para a importacao e:

from Sound.Effects import echo
Assim se carrega o m dulo sem necessidade de prexacao na hora do uso. Logo, pode ser utilizado como se segue: o 6.4. Pacotes 37
echo.echofilter(input, output, delay=0.7, atten=4)
Tamb m e possvel importar diretamente uma unica vari vel ou funcao, como em: e a
from Sound.Effects.echo import echofilter
Novamente, h carga do sub-m dulo echo, mas a funcao echofilter() est acessvel diretamente sem prexacao: a o a
echofilter(input, output, delay=0.7, atten=4)
Observe que ao utilizar from package import item, o item pode ser um sub-pacote, sub-m dulo, classe, funcao o ou vari vel. O comando import primeiro testa se o item est denido no pacote, sen o assume que e um m dulo e a a a o tenta carreg -lo. Se falhar em encontrar o m dulo uma excecao ImportError e levantada. a o Em oposicao, na construcao import item.subitem.subsubitem, cada item, com excecao do ultimo, deve ser um pacote. O ultimo pode ser tamb m um pacote ou m dulo, mas nunca uma entidade contida em um m dulo. e o o
6.4.1
Importando * de Um Pacote
Agora, o que acontece quando um usu rio escreve from Sound.Effects import * ? Idealmente, poderia se a esperar que todos sub-m dulos presentes no pacote fossem importados. Infelizmente, essa operacao n o funciona o a muito bem nas plataformas Mac ou Windows, onde n o existe distincao entre mai sculas ou min sculas nos sistema a u u de arquivos. Nestas plataformas n o h como saber como importar o arquivo ECHO.PY, deveria ser com o nome a a echo, Echo ou ECHO (por exemplo, o Windows 95 tem o irritante h bito de colocar a primeira letra em mai scula). a u A restricao de nomes de arquivo em DOS com o formato 8+3 adiciona um outro problema na hora de se utilizar arquivos com nomes longos. A unica solucao e o autor do pacote fornecer um ndice explcito do pacote. O comando de importacao utiliza a a seguinte convencao: se o arquivo init .py do pacote dene a lista chamada all , ent o esta lista indica os nomes dos m dulos a serem importados quando o comando from package import * e encontrado. o Fica a cargo do autor do pacote manter esta lista atualizada, inclusive ca a seu crit rio excluir inteiramente o e suporte a importacao direta de todo o pacote atrav s do from package import *. Por exemplo, o arquivo e Sounds/Effects/ init .py poderia conter apenas:
__all__ = ["echo", "surround", "reverse"]
Isso signicaria que from Sound.Effects import * iria importar apenas os tr s sub-m dulos especicados e o no pacote Sound. Se all n o estiver denido, o comando from Sound.Effects import * n o importar todos os a a a sub-m dulos do pacote Sound.Effects no espaco de nomes corrente. H apenas garantia que o pacote o a Sound.Effects foi importado (possivelmente executando seu c digo de inicializacao init .py) juntamente o com os nomes denidos no pacote. Isso inclui todo nome denido em init .py bem como em qualquer subm dulo importado a partir deste. Por exemplo: o
import Sound.Effects.echo import Sound.Effects.surround from Sound.Effects import *
Neste exemplo, os m dulos echo e surround s o importados no espaco de nomes corrente, pois est o denidos no o a a pacote Sound.Effects. O que tamb m funciona quando all estiver denida. e Em geral, a pr tica de importar tudo de um dado m dulo e desaconselhada, principalmente por prejudicar a legibilidade a o do c digo. Contudo, e recomendada em sess es interativas para evitar excesso de digitacao. o o Lembre-se que n o h nada de errado em utilizar from Package import specific submodule! De fato, a a essa e a notacao recomendada a menos que o m dulo efetuando a importacao precise utilizar sub-m dulos hom nimos o o o em diferentes pacotes. 38 Captulo 6. Modulos
6.4.2
Referencias em Um Mesmo Pacote
Os sub-m dulos frequentemente precisam referenciar uns aos outros. Por exemplo, o m dulo surround talvez o o precise utilizar o m dulo echo. De fato, tais refer ncias s o t o comuns que o comando import primeiro busca o e a a m dulos dentro do pacote antes de utilizar o caminho de busca padr o. Portanto, o m dulo surround pode usar o a o simplesmente import echo ou from echo import echofilter. Se o m dulo importado n o for encono a trado no pacote corrente (o pacote do qual o m dulo corrente e sub-m dulo), ent o o comando import procura por o o a um m dulo de mesmo nome no escopo global. o Quando pacotes s o estruturados em sub-pacotes (como em Sound), n o existe atalho para referenciar suba a m dulos de pacotes irm os - o nome completo do pacote deve ser utilizado. Por exemplo, se o m dulo o a o Sound.Filters.vocoder precisa utilizar o m dulo echo no pacote Sound.Effects , e preciso import o a lo como from Sound.Effects import echo.
6.4. Pacotes
39
40
CAP ITULO
SEVEN
Entrada e Sada
Existem diversas maneiras de se apresentar a sada de um programa. Dados podem ser impressos em forma imediata mente legvel, ou escritos em um arquivo para uso futuro. Este captulo vai discutir algumas das possibilidades.
7.1
Renando a Formatacao de Sada
At agora n s encontramos duas maneiras de escrever valores: atrav s de express oes e pelo comando print (uma e o e terceira maneira e utilizar o m todo write() de objetos de arquivo; a sada padr o pode ser referenciada como e a sys.stdout). Veja o documento Library Reference para mais informacoes sobre este t pico. o Frequentemente voc desejar mais controle sobre a formatacao de sada do que simplesmente imprimindo valores e a separados por espacos. Existem duas formas. A primeira e voc mesmo manipular a string atrav s de recortes (slicing) e e e concatenacao. O m dulo padr o string cont m algumas rotinas uteis a esta nalidade. A segunda maneira e o a e utilizar o operador %. O operador % interpreta seu argumento a esquerda como uma string de formatacao de um sprintf() aplicada ao ` argumento a direita do operador. O resultado e uma string formatada. ` Permanece a quest o: como converter valores para strings? Por sorte, Python possui uma maneira de converter a qualquer valor para uma string: basta submet -lo a funcao repr(), ou simplesmente escrev -lo entre aspas reversas e e (). Alguns exemplos:
>>> x = 10 * 3.14 >>> y = 200*200 >>> s = The value of x is + x + , and y is + y + ... >>> print s The value of x is 31.4, and y is 40000... >>> # Aspas reversas tambem funcionam em outros tipos alem de numeros: ... p = [x, y] >>> ps = repr(p) >>> ps [31.400000000000002, 40000] >>> # Converter uma string adiciona barras invertidas e aspas ... hello = hello, world\n >>> hellos = hello >>> print hellos hello, world\n >>> # O argumento de aspas reversas pode ser uma tupla ... x, y, (spam, eggs) "(31.400000000000002, 40000, (spam, eggs))"
A sguir, duas maneiras de se escrever uma tabela de quadrados e cubos:
41
>>> import string >>> for x in range(1, 11): ... print string.rjust(x, 2), string.rjust(x*x, 3), ... # Observe a vrgula final na linha anterior ... print string.rjust(x*x*x, 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
Note que os espacos adicionados entre as colunas se devem a forma de funcionamento do comando print : ele sempre adiciona espaco entre seus argumentos. Este exemplo demonstra a funcao string.rjust(), que justica uma string a direita gerando espacos adicionais ` a esquerda. Existem funcoes an logas string.ljust() e string.center(). Essas funcoes apenas retornam ` a a string formatada. Se a entrada extrapolar o comprimento exigido a string original e devolvida sem modicacao. A raz o para isso e n o apresentar um valor potencialmente corrompido por truncamento (se for desejado truncar o valor a a pode-se utilizar operacoes de recorte como em string.ljust(x, n)[0:n]). Existe ainda a funcao string.zfill() que preenche uma string num rica com zeros a esquerda. Ela entende e ` sinais positivos e negativos.
>>> import string >>> string.zfill(12, 5) 00012 >>> string.zfill(-3.14, 7) -003.14 >>> string.zfill(3.14159265359, 5) 3.14159265359
Um exemplo de uso do operador %:
>>> import math >>> print The value of PI is approximately %5.3f. % math.pi The value of PI is approximately 3.142.
Se h mais do que um formato, ent o o argumento a direita deve ser uma tupla com os valores de formatacao. Exemplo: a a `
42
Captulo 7. Entrada e Sada
>>> table = {Sjoerd: 4127, Jack: 4098, Dcab: 7678} >>> for name, phone in table.items(): ... print %-10s ==> %10d % (name, phone) ... Jack ==> 4098 Dcab ==> 7678 Sjoerd ==> 4127
A maioria dos formatos funciona da mesma maneira que em C, e exigem que voc passe o tipo apropriado. Entretanto, e em caso de erro ocorre uma excecao e n o uma falha do sistema operacional. a O formato %s e mais relaxado: se o argumento correspondente n o for um objeto string, ent o ele e convertido para a a string pela funcao interna str(). H suporte para o modicador * determinar o comprimento ou precis o num a a argumento inteiro em separado. Os formatadores (em C) %n e %p tamb m s o suportados. e a Se voc possuir uma string de formatacao muito longa, seria bom referenciar as vari veis de formatacao por nome, ao e a inv s de por posicao. Isso pode ser obtido passando um dicion rio como argumento a direita e prexando campos na e a ` string de formatacao com %(name)format. Veja o exermplo:
>>> table = {Sjoerd: 4127, Jack: 4098, Dcab: 8637678} >>> print Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d % table Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Isso e particularmente util em combinacao com a nova funcao interna vars(), que retorna um dicion rio contendo a todas as vari veis locais. a
7.2
Leitura e Escrita de Arquivos
A funcao open() retorna um objeto de arquivo, e e frequentemente usada com dois argumentos: open(lename, mode).
>>> f=open(/tmp/workfile, w) >>> print f <open file /tmp/workfile, mode w at 80a0960>
O primeiro argumento e uma string contendo o nome do arquivo. O segundo argumento e outra string contendo alguns caracteres que descrevem o modo como o arquivo ser usado. O par metro mode pode assumir valor r quando o a a arquivo ser s de leitura, w quando for s de escrita (se o arquivo j existir seu conte do pr vio ser apagado), a o o a u e a e a para abrir o arquivo para adicao; qualquer escrita ser adicionada ao nal do arquivo. A opcao r+ abre o a arquivo tanto para leitura como para escrita. O par metro mode e opcional, em caso de omiss o ser assumido r. a a a No Windows e no Macintosh, b adicionado a string de modo indica que o arquivo ser aberto no formato bin rio. a a Sendo assim, existem os modos compostos : rb, wb, e r+b. O Windows faz distincao entre arquivos texto e bin rios: os caracteres terminadores de linha em arquivos texto s o levemente alterados em leituras e escritas. Essa a a mudanca por-tr s-do-pano e util em arquivos texto ASCII, mas ir corromper um arquivo bin rio como no caso de a a a JPEGs ou execut veis. Seja muito cuidadoso ao manipular arquivos bin rios (no caso do Macintosh a sem ntica exata a a a do modo texto depende da biblioteca C subjacente sendo utilizada).
7.2.1
Metodos de Objetos de Arquivos
A ttulo de simplicacao, o resto dos exemplos nesta secao ir assumir que o objeto de arquivo chamado f j foi a a criado. Para ler o conte do de um arquivo chame f.read(size), que l um punhado de dados retornando-os como string. u e O argumento num rico size e opcional. Quando size for omitido ou negativo, todo o conte do do arquivo ser lido e e u a 7.2. Leitura e Escrita de Arquivos 43
retornado. E problema seu se o conte do do arquivo e o dobro da mem ria disponvel na m quina. Caso contr rio, no u o a a m ximo size bytes ser o lidos e retornados. Se o m do arquivo for atingido, f.read() ir retornar uma string vazia a a a ().
>>> f.read() Esse todo o contedo do arquivo.\n e u >>> f.read()
f.readline() l uma unica linha do arquivo. O caracter de retorno de linha (\n) e deixado ao nal da string, s e o sendo omitido na ultima linha do arquivo se ele j n o estiver presente l . Isso elimina a ambiguidade no valor de a a a retorno. Se f.readline() retornar uma string vazia, ent o o arquivo acabou. Linhas em branco s o representadas a a por \n: uma string contendo unicamente o terminador de linha.
>>> f.readline() Essa a primeira linha do arquivo.\n e >>> f.readline() Segunda linha do arquivo\n >>> f.readline()
f.readlines() retorna uma lista contendo todas as linhas do arquivo. Se for fornecido o par metro opcional a sizehint, ser lida a quantidade especicada de bytes e mais o suciente para completar uma linha. Frequentemente, a esta operacao e utilizada para ler arquivos muito grandes sem ter que ler todo o arquivo para a mem ria de uma s vez. o o Apenas linhas completas ser o retornadas. a
>>> f.readlines() [Essa a primeira linha do arquivo.\n, Segunda linha do arquivo\n] e
f.write(string) escreve o conte do da string para o arquivo, retornando None. u

>>> f.write(Isso um teste.\n) e
f.tell() retorna um inteiro que indica a posicao corrente de leitura ou escrita no arquivo, medida em bytes desde o incio do arquivo. Para mudar a posicao utilize f.seek(offset, from what). A nova posicao e computada pela soma do offset a um ponto de refer ncia, que por sua vez e denido pelo argumento from what. O argumento e from what pode assumir o valor 0 para indicar o incio do arquivo, 1 para indicar a posicao corrente e 2 para indicar o m do arquivo. Este par metro pode ser omitido, quando e assumido o valor default 0. a
>>> >>> >>> >>> 5 >>> >>> d
f=open(/tmp/workfile, r+) f.write(0123456789abcdef) f.seek(5) # Vai para o quinto byte f.read(1) f.seek(-3, 2) # Vai para o terceiro byte antes do fim f.read(1)
Quando acabar de utilizar o arquivo, chame f.close() para fech -lo e liberar recursos. Qualquer tentativa de acesso a ao arquivo depois dele ter sido fechado implicar em falha. a
>>> f.close() >>> f.read() Traceback (most recent call last): File "<stdin>", line 1, in ?
44
Captulo 7. Entrada e Sada
ValueError: I/O operation on closed file
Objetos de arquivo podem ter m todos adicionais, tais como isatty() e truncate() que s o usados com menos e a frequ ncia, consulte a Library Reference para obter maiores informacoes. e
7.2.2
O Modulo pickle
Strings podem ser facilmente escritas e lidas de um arquivo. N meros exigem um pouco mais de esforco, uma vez u que o m todo read() s trabalha com strings. Portanto, pode ser utilizada a funcao string.atoi(), que recebe e o uma string 123 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. a a a Para que n o seja necess rio que usu rios estejam constantemente escrevendo e depurando c digo que torna estruturas a a a o de dados persistentes, Python oferece o m dulo padr o pickle. Este m dulo permite que praticamente qualquer o a o objeto Python (at mesmo c digo!) seja convertido para uma representacao string. Este processo e denominado e o pickling. E unpickling e o processo reverso de reconstruir o objeto a partir de sua representacao string. Enquanto estiver representado como uma string, o objeto pode ser armazenado em arquivo, transferido pela rede, etc. Se voc possui um objeto qualquer x, e um objeto arquivo f que foi aberto para escrita, a maneira mais simples de e utilizar este m dulo e: o
pickle.dump(x, f)
Para desfazer, se f for agora um objeto de arquivo pronto para leitura:
x = pickle.load(f)
Existem outras variacoes desse processo uteis quando se precisa aplicar sobre muitos objetos ou o destino da representacao string n o e um arquivo. Consulte a Library Reference para obter informacoes detalhadas. a Utilizar o m dulo pickle e a forma padr o de tornar objetos Python persistentes, permitindo a reutilizacao dos o a mesmos entre diferentes programas, ou pelo mesmo programa em diferentes sess es de utilizacao. A representacao o string dos dados e tecnicamente chamada objeto persistente, como j foi visto. Justamente porque o m dulo pickle a o e amplamente utilizado, v rios autores que escrevem extens es para Python tomam o cuidado de garantir que novos a o tipos de dados sejam compatveis com esse processo.
7.2. Leitura e Escrita de Arquivos
45
46
CAP ITULO
EIGHT
Erros e Excecoes
At agora mensagens de erro foram apenas mencionadas, mas se voc testou os exemplos, talvez tenha esbarrado em e e algumas. Existem pelo menos dois tipos distintos de erros: erros de sintaxe e excecoes.
8.1
Erros de Sintaxe
Erros de sintaxe, tamb m conhecidos como erros de parse, s o provavelmente os mais frequentes entre aqueles que e a ainda est o aprendendo Python: a
>>> while 1 print Hello world File "<stdin>", line 1 while 1 print Hello world SyntaxError: invalid syntax
O parser repete a linha inv lida e apresenta uma pequena echa apontando para o ponto da linha em que o erro foi a encontrado. O erro e detectado pelo token que precede a echa. No exemplo, o erro foi detectado na palavra-reservada print, uma vez que o dois-pontos (:) est faltando. Nome de arquivo e n mero de linha s o impressos para que a u a voc possa rastrear o erro no texto do script. e
8.2
Excecoes
Mesmo que um comando ou express o estejam sintaticamente corretos, talvez ocorra um erro na hora de sua execucao. a Erros detectados durante a execucao s o chamados excec oes e n o s o necessariamente fatais. Logo veremos como a a a trat -las em programas Python. A maioria das excecoes n o s o tratadas e acabam resultando em mensagens de erro: a a a
>>> 10 * (1/0) Traceback (most recent call last): File "<stdin>", line 1 ZeroDivisionError: integer division or modulo >>> 4 + spam*3 Traceback (most recent call last): File "<stdin>", line 1 NameError: spam >>> 2 + 2 Traceback (most recent call last): File "<stdin>", line 1 TypeError: illegal argument type for built-in operation
47
A ultima linha da mensagem de erro indica o que aconteceu. Excecoes surgem com diferentes tipos, e o tipo e impresso como parte da mensagem . Os tipos no exemplo s o: ZeroDivisionError, NameError e TypeError. A string a impressa como sendo o tipo da excecao e o nome interno da excecao que ocorreu. Isso e verdade para todas excecoes pr -denidas em Python, mas n o e necessariamente verdade para excecoes denidas pelo usu rio. e a a O resto da linha e um detalhamento que depende do tipo da excecao ocorrida. A parte anterior da mensagem de erro apresenta o contexto onde ocorreu a excecao. Essa informacao e denominada stack backtrace (N.d.T: rastreamento da pilha para tr s). Em geral, cont m uma lista de linhas do c digo fonte, sem a e o apresentar, no entanto, valores lidos da entrada padr o. a O documento Python Library Reference lista as excecoes pr -denidas e seus signicados. e
8.3
Tratamento de Excecoes
E possvel escrever programas que tratam excecoes especcas. 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 a e a Control-C ou seja l o que for que o sistema operacional suporte). Note que uma interrupcao gerada pelo usu rio a a ser sinalizada pela excecao KeyboardInterrupt. a
>>> while 1: ... try: ... x = int(raw_input("Entre com um nmero: ")) u ... break ... except ValueError: ... print "Opa! Esse nmero no vlido. Tente de novo..." u a e a ...
A construcao try funciona da seguinte maneira: Primeiramente, a cl usula try (o conjunto de comandos entre as palavras-reservadas try e except ) e execua tado.
Se n o for gerada excecao, a cl usula except e ignorada e termina a execucao da construcao try. a a
Se uma execucao ocorre durante a execucao da cl usula try, os comandos remanescentes na cl usula s o a a a ignorados. Se o tipo da excecao ocorrida tiver sido previsto junto alguma palavra-reservada except, ent o ` a essa cl usula ser executada. Ao m da cl usula tamb m termina a execucao do try como um todo. a a a e
Se a excecao ocorrida n o foi prevista em nenhum tratador except da construcao try em que ocorreu, ent o a a ela e entregue a uma construcao try mais externa. Se n o existir nenhum tratador previsto para tal excecao a (chamada unhandled exception), a execucao encerra com uma mensagem de erro.
A construcao try pode ter mais de uma cl usula except para especicar m ltiplos tratadores para diferentes a u excecoes. No m ximo um unico tratador ser ativado. Tratadores s s o sensveis as excecoes levantadas no inte a a o a rior da cl usula try, e n o que tenha ocorrido no inteiror de outro tratador num mesmo try. Um tratador pode ser a a sensvel a m ltiplas excecoes, desde que as especique em uma tupla: u
... except (RuntimeError, TypeError, NameError): ... pass
A ultima cl usula except pode omitir o nome da excecao, servindo como uma m scara gen rica. Utilize esse recurso a a e com extrema cautela, uma vez que isso pode esconder errors do programador e do usu rio. Tamb m pode ser utilizado a e para imprimir uma mensagem de erro, ou re-levantar (re-raise) a excecao de forma que um chamador tamb m possa e trat -la. a
48
Captulo 8. Erros e Excecoes
import string, sys try: f = open(myfile.txt) s = f.readline() i = int(string.strip(s)) 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
A construcao try . . . except possui uma cl usula else opcional, que quando presente, deve ser colocada depois a de todas as outras cl usulas. E util para um c digo que precisa ser executado se nenhuma excecao foi levantada. Por a o exemplo:
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()
Este recurso e melhor do que simplesmente adicionar o c digo do else ao corpo da cl usula try, pois mant m as o a e excecoes levantadas no else num escopo diferente de tratamento das excecoes levantadas na cl usula try. a Quando uma excecao ocorre, ela pode estar associada a um valor chamado argumento da excecao. A presenca e o tipo do argumento dependem do tipo da excecao. Para excecoes possuidoras de argumento, a cl usula else pode a especicar uma vari vel depois da lista de nomes de excecao para receber o argumento. Veja: a
>>> try: ... spam() ... except NameError, x: ... print name, x, undefined ... name spam undefined
Se uma excecao possui argumento, ele e impresso ao nal do detalhamento de express es n o tratadas (unhandled o a exceptions). Al m disso, tratadores de excecao s o capazes de capturar excecoes que tenham sido levantadas no interior de funcoes e a invocadas na cl usula try. Por exemplo: a
>>> 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
8.3. Tratamento de Excecoes
49
8.4
Levantando Excecoes
A palavra-reservada raise permite ao programador forcar a ocorr ncia de um determinado tipo de excecao. Por e exemplo:
>>> raise NameError, HiThere Traceback (most recent call last): File "<stdin>", line 1 NameError: HiThere
O primeiro argumento de raise e o nome da excecao a ser levantada. O segundo argumento, opcional, e o argumento da excecao.
8.5
Excecoes Denidas pelo Usuario
Programas podem denir novos tipos de excecoes, atrav s da criacao de uma nova classe. Por exemplo: e
>>> class MyError: ... def __init__(self, value): ... self.value = value ... def __str__(self): ... return self.value ... >>> try: ... raise MyError(2*2) ... except MyError, e: ... print My exception occurred, value:, e.value ... My exception occurred, value: 4 >>> raise MyError, 1 Traceback (most recent call last): File "<stdin>", line 1 __main__.MyError: 1
Muitos m dulos padr o se utilizam disto para reportar erros que ocorrem no interior das funcoes que denem. o a Mais informacoes sobre esse mecanismo ser o descritas no captulo 9, Classes. a
8.6
Denindo Acoes de Limpeza
A construcao try possui outra cl usula opcional, cuja nalidade e permitir a implementacao de acoes de limpeza, a que sempre devem ser executadas independentemente da ocorr ncia de excecoes. Como no exemplo: e
>>> try: ... raise KeyboardInterrupt ... finally: ... print Goodbye, world! ... Goodbye, world! Traceback (most recent call last): File "<stdin>", line 2 KeyboardInterrupt
50
Captulo 8. Erros e Excecoes
A cl usula nally e executada sempre, ocorrendo ou n o uma excecao. Quando ocorre a excecao, e como se a excecao a a fosse sempre levantada ap s a execucao do c digo na cl usula nally. Mesmo que haja um break ou return dentro o o a do try, ainda assim o finally ser executado. a A construcao try pode ser seguida da cl usula finally ou de um conjunto de cl usulas except, mas nunca a a ambas. Essas opcoes s o mutuamente exclusivas. a
8.6. Denindo Acoes de Limpeza
51
52
CAP ITULO
NINE
Classes
O mecanismo de classes em Python foi adicionado a linguagem de forma a minimizar a sobrecarga sint tica e ` a sem ntica. E uma mistura de mecanismos equivalentes encontrados em C ++ e Modula-3. Assim como e v lido para a a m dulos, classes em Python n o imp e barreiras entre o usu rio e a denicao. Contudo, dependem da cordialidade o a o a do usu rio para n o quebrar a denicao. Todavia, as caractersticas mais importantes de classes foram asseguradas: a a o mecanismo de heranca permite m ltiplas classes base, uma classe derivada pode sobrescrever quaisquer m todos u e de uma classe ancestral, um m todo pode invocar outro m todo hom nimo de uma classe ancestral. E mais, objetos e e o podem armazenar uma quantidade arbitr ria de dados privados. a Na terminologia de C++, todos os membros de uma classe (incluindo dados) s o public, e todos as funcoes membro a s o virtual. N o existem construtores ou destrutores especiais. a a Como em Modula-3, n o existem atalhos para referenciar membros do objeto de dentro dos seus m todos. Um m todo a e e (funcao de classe) e declarado com um primeiro argumento explcito representando o objeto (inst ncia da classe) , que a e fornecido implicitamente pela invocacao. Como em Smalltalk (e em Java), classes s o objetos. Mas em Python, todos os tipos de dados s o objetos. Isso a a fornece uma sem ntica para importacao e renomeamento. Ainda como em C ++ ou Modula-3, tipos pr -denidos n o a e a podem ser utilizados como classes base para extens es de usu rio por heranca. Como em C ++, mas diferentemente o a de Modula-3, a maioria dos operadores (aritim ticos, indexacao,etc) podem ser redenidos para inst ncias de classe. e a
9.1
Uma Palavra Sobre Terminologia
Na falta de uma universalmente aceita terminologia de classes, eu irei ocasionalmente fazer uso de termos comuns a Smalltalk ou C++ (eu usaria termos de Modula-3 j que sua sem ntica e muito pr xima a de Python, mas tenho a a a o impress o de que um n mero menor de usu rios estar familiarizado com esta linguagem). a u a a Eu tamb m preciso alertar para uma armadilha terminol gica para leitores familiarizados com orientacao a objetos: a e o palavra objeto em Python n o necessariamente implica em uma inst ncia de classe. Como em C ++ e Modula-3 e, a a diferentemente de Smalltalk, nem todos os tipos em Python s o classes: tipos b sicos como inteiros, listas e arquivos a a n o s o. Contudo, todos tipos de Python compartilham uma sem ntica comum que e melhor descrita pela palavra a a a objeto. Objetos tem individualidade, e podem estar vinculados a m ltiplos nomes (em diferentes escopos). Essa facilidade e u ` chamada aliasing em outras linguagens. A primeira vista n o e muito apreciada, e pode ser seguramente ignorada ao a lidar com tipos imut veis (n meros, strings, tuplas). Entretanto, aliasing tem um efeito intencional sobre a sem ntica a u a de c digo em Python envolvendo objetos mut veis como listas, dicion rios, e a maioria das entidades externas a o a a um programa como arquivos, janelas, etc. Alias (N.d.T: sin nimos) funcionam de certa forma como ponteiros, em o benefcio do programamdor. Por exemplo, passagem de objetos como par metro e barato, pois s o ponteiro e passado a o na implementacao. E se uma funcao modica um objeto passado como argumento, o chamador vai ver a mudanca o que torna obsoleta a necessidade de um duplo mecanismo de passagem de par metros como em Pascal. a
53
9.2
Escopos e Espacos de Nomes em Python
Antes de introduzir classes, e preciso falar das regras de escopo em Python. Denicoes de classe empregam alguns truques com espacos de nomes. Portanto, e preciso entender bem de escopos e espacos de nomes antes. Esse conheci mento e muito util para o programador avancado em Python. Iniciando com algumas denicoes. Um espaco de nomes e um mapeamento entre nomes e objetos. Presentemente, s o implementados como dicion rios, a a isso n o e perceptvel (a n o ser pelo desempenho) e pode mudar no futuro. Exemplos de espacos de nomes s o: o a a a conjunto de nomes pr -denidos (funcoes como abs() e excecoes), nomes globais em m dulos e nomes locais em e o uma funcao. De uma certa forma, os atributos de um objeto tamb m formam um espaco de nomes. O que h de e a importante para saber e que n o existe nenhuma relacao entre nomes em espacos distintos. Por exemplo, dois m dulos a o podem denir uma funcao de nome maximize sem confus o usu rios dos m dulos devem prexar a funcao com a a o o nome do m dulo para evitar colis o. o a A prop sito, eu utilizo a palavra atributo para qualquer nome depois de um ponto. Na express o z.real, por o a exemplo, real e um atributo do objeto z. Estritamente falando, refer ncias para nomes em m dulos s o atributos: na e o a express o modname.funcname, modname e um objeto m dulo e funcname e seu atributo. Neste caso, existe um a o mapeamento direto entre os os atributos de um m dulo e os nomes globais denidos no m dulo: eles compartilham o o o mesmo espaco de nomes. 1 Atributos podem ser somente de leitura ou n o. Atributos de m dulo s o passveis de atribuicao, voc pode escrever a o a e modname.the answer = 42, e remocao pelo comando del (del modname.the answer). Espacos de nomes s o criados em momentos diferentes e possuem diferentes longevidades. O espaco de nomes que a cont m os nomes pr -denidos e criado quando o interpretador inicializa e nunca e removido. O espaco de nomes e e global e criado quando uma denicao de m dulo e lida, e normalmente duram at a sada do interpretador. o e Os comandos executados pela invocacao do interpertador, ou pela leitura de um script, ou interativamente s o parte a do m dulo chamado main , e portanto possuem seu pr prio espaco de nomes (os nomes pr -denidos possuem o o e seu pr prio espaco de nomes no m dulo chamado builtin ). o o O espaco de nomes local para uma funcao e criado quando a funcao e chamada, e removido quando a funcao retorna ou levanta uma excecao que n o e tratada na pr pria funcao. Naturalmente, chamadas recursivas de uma funcao possuem a o seus pr prios espacos de nomes. o Um escopo e uma regi o textual de um programa Python onde um espaco de nomes e diretamente acessvel. Onde a diretamente acessvel signica que uma refer ncia sem qualicador especial permite o acesso ao nome. e Ainda que escopos sejam determinados estaticamente, eles s o usados dinamicamente. A qualquer momento durante a a execucao, existem exatamente tr s escopos em uso (tr s escopos diretamente acessveis): o escopo interno (que e e e procurado primeiro) contendo nomes locais, o escopo intermedi rio (com os nomes globais do m dulo) e o escopo a o externo (procurado por ultimo) contendo os nomes pr -denidos. e Normalmente, o escopo local referencia os nomes locais da funcao corrente. Fora de funcoes, o escopo local referencia os nomes do escopo global (espaco de nomes do m dulo). Denicoes de classes adicionam um espaco de nomes ao o escopo local. E importante perceber que escopos s o determinados textualmente. O escopo global de uma funcao denida em a um m dulo e o espaco de nomes deste m dulo, sem importar de onde ou de que alias (N.d.T. sin nimo) a funcao o o o e invocada. Por outro lado, a efetiva busca de nomes e din mica, ocorrendo durante a execucao. A evolucao da a linguagem est caminhando para uma resolucao de nomes est tica, em tempo de compilacao, que n o dependa de a a a resolucao din mica de nomes. (de fato, vari veis locais j s o resolvidas estaticamente.) a a a a Um detalhe especial e que atribuicoes s o sempre vinculadas ao escopo interno. Atribuicoes n o copiam dados, a a simplesmente vinculam objetos a nomes. O mesmo e verdade para remocoes. O comando del x remove o vnculo
1 Exceto por uma coisa. Objetos M dulo possuem um atributo de leitura escondido chamado o dict que retorna o dicion rio utilizado para a e a implementar o espaco de nomes do m dulo. O nome dict e um atributo, por m n o e um nome global. Obviamente, utilizar isto violaria a o abstracao de espaco de nomes, portanto seu uso deve ser restrito. Um exemplo v lido e o caso de depuradores post-mortem. a
54
Captulo 9. Classes
de x do espaco de nomes referenciado pelo escopo local. De fato, todas operacoes que introduzem novos nomes usam o escopo local. Em particular, comandos import e denicoes de funcao vinculam o m dulo ou a funcao ao escopo o local (a palavra-reservada global pode ser usada para indicar que certas vari veis residem no escopo global ao inv s a e do local).
9.3
Primeiro Contato com Classes
Classes introduzem novidades sint ticas, tr s novos tipos de objetos, e tamb m sem ntica nova. a e e a
9.3.1
Sintaxe de Denicao de Classe
A forma mais simples de denir uma classe e:

class NomeDaClasse: <comando-1> . . . <comando-N>
Denicoes de classes, como denicoes de funcoes (comandos def) devem ser executados antes que tenham qualquer efeito. Voc pode colocar uma denicao de classe ap s um teste condicional if ou dentro de uma funcao. e o Na pr tica, os comandos dentro de uma classe ser o denicoes de funcoes, mas existem outros comandos que s o pera a a mitidos. Denicoes de funcao dentro da classe possuem um lista peculiar de argumentos determinada pela convencao de chamada a m todos. e Quando se fornece uma denicao de classe, um novo espaco de nomes e criado. Todas atribuicoes de vari veis s o a a vinculadas a este escopo local. Em particular, denicoes de funcao tamb m s o armazenadas neste escopo. e a Quando termina o processamento de uma denicao de classe (normalmente, sem erros), um objeto de classe e criado. Este objeto encapsula o conte do do espaco de nomes criado pela denicao da classe. O escopo local ativo antes da u denicao da classe e restaurado, e o objeto classe e vinculado a este escopo com o nome dado a classe.
9.3.2
Objetos de Classe
Objetos de Classe suportam dois tipos de operacoes: refer ncias a atributos e instanciacao. e Refer ncias a atributos de classe utilizam a sintaxe padr o utilizada para quaisquer refer ncias a atributos em Python: e a e obj.name. Atributos v lidos s o todos os nomes presentes no espaco de nomes da classe quando o objeto classe foi a a criado. Portanto, se a denicao da classe era:
class MyClass: "Um exemplo simples de classe" i = 12345 def f(x): return hello world
ent o MyClass.i e MyClass.f s o refer ncias a atributos v lidos, retornando um inteiro e um objeto m todo, a a e a e respectivamente. Atributos de classe podem receber atribuicoes, logo voc pode mudar o valor de MyClass.i por e atribuicao. doc e tamb m um atributo v lido, que retorna a docstring pertencente a classe: "Um exemplo e a simples de classe". Instanciacao de Classe tamb m utiliza uma notacao de funcao. Apenas nja que o objeto classe n o possui par metros e a a e retorna uma nova inst ncia da classe. Por exemplo: a 9.3. Primeiro Contato com Classes 55
x = MyClass()
cria uma nova inst ncia da classe e atribui o objeto resultante a vari vel local x. a a A operacao de instanciacao (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 denido pela e e classe, init (), veja:
def __init__(self): self.data = []
Quando uma classe dene um m todo e init (), o processo de inst nciacao autom ticamente invoca a a init () sobre a rec m-criada inst ncia de classe. Neste exemplo, uma nova int ncia j inicializada pode ser e a a a obtida por:
x = MyClass()
Naturalmente, o m todo e init () pode ter argumentos para aumentar sua exibilidade. Neste caso, os argumentos passados para a instanciacao de classe ser o delegados para o m todo init (). Como ilustrado em: a e
>>> class Complex: ... def __init__(self, realpart, imagpart): ... self.r = realpart ... self.i = imagpart ... >>> x = Complex(3.0,-4.5) >>> x.r, x.i (3.0, -4.5)
9.3.3
Instancias
Agora, o que podemos fazer com inst ncias ? As unicas operacoes reconhecidas por inst ncias s o refer ncias a a a a e atributos. Existem dois tipos de nomes de atributos v lidos. a O primeiro eu chamo de atributos-de-dados, que correspondem a vari veis de inst ncia em Smalltalk, e a membros a a em C++. Atributos-de-dados n o n o precisam ser declarados. Assim como vari veis locais, eles passam a existir na a a a primeira vez em que e feita uma atribuicao. Por exemplo, se x e uma inst ncia de MyClass criada acima, o pr ximo a o trecho de c digo ir imprimir o valor 16, sem deixar rastro (por causa do del): o a
x.counter = 1 while x.counter < 10: x.counter = x.counter * 2 print x.counter del x.counter
O segundo tipo de refer ncia a atributo entendido por inst ncias s o m todos. Um m todo e uma funcao que pertence e a a e e a uma inst ncia (em Python, o termo m todo n o e aplicado exclusivamente a int ncias de classe: outros tipos de a e a a objetos tamb m podem ter m todos; por exemplo, objetos listas possuem os m todos: append, insert, remove, sort, e e e etc). Nomes de m todos v lidos de uma inst ncia dependem de sua classe. Por denicao, todos atributos de uma classe e a a que s o funcoes equivalem a um m todo presente nas inst ncias. No nosso exemplo, x.f e uma refer ncia de m todo a e a e e v lida j que MyClass.f e uma funcao, enquanto x.i n o e, j que MyClass.i n o e funcao. Entretanto, x.f a a a a a n o e o mesmo que MyClass.f o primeiro e um m todo de objeto , o segundo e um objeto funcao. a e
56
Captulo 9. Classes
9.3.4
Metodos de Objeto
Normalmente, um m todo e chamado imediatamente, isto e: e
x.f()
No nosso exemplo o resultado ser a string hello world. No entanto, n o e obrigat tio chamar o m todo a a o e imediatamente: como x.f e tamb m um objeto (tipo m todo), ele pode ser armazenado e invocado a posteriori. Por e e exemplo:
xf = x.f while 1: print xf()
continuar imprimindo hello world at o nal dos tempos. a e O que ocorre precisamente quando um m todo e chamado ? Voc deve ter notado que x.f() foi chamado sem e e nenhum par metro, por m a denicao da funcao f especicava um argumento. O que aconteceu com o argumento ? a e Certamente Python levantaria uma excecao se o argumento estivesse faltando... Talvez voc j tenha advinhado a resposta: o que h de especial em m todos e que o objeto (a qual o m todo pertence) e a a e e e passado como o primeiro argumento da funcao. No nosso exemplo, a chamada x.f() e exatamente equivalente a MyClass.f(x). Em geral, chamar um m todo com uma lista de n argumentos e equivalente a chamar a funcao na e classe correspondente passando a inst ncia como o primeiro argumento antes dos demais argumentos. a Se voc ainda n o entendeu como m todos funcionam, talvez uma olhadela na implementacao sirva para clarear as e a e coisas. Quando um atributo de inst ncia e referenciado e n o e um atributo de dado, a sua classe e procurada. Se o a a nome indica um atributo de classe v lido que seja um objeto funcao, um objeto m todo e criado pela composicao da a e inst ncia alvo e do objeto funcao. Quando o m todo e chamado com uma lista de argumentos, ele e desempacotado, a e uma nova lista de argumentos e criada a partir da inst ncia original e da lista original de argumentos do m todo. a e Finalmente, a funcao e chamada com a nova lista de argumentos.
9.4
Observacoes Aleatorias
[Talvez se devesse colocar o que est por vir com mais cuidado...] a Atributos de dados sobrescrevem atributos m todos hom nimos. Para evitar conitos de nome acidentais, que podem e o gerar bugs de difcil rastreio em programas extensos, e s bio utilizar algum tipo de convencao que minimize conitos, a como colocar nomes de m todos com inicial mai scula, prexar atributos de dados com uma string unica (quem sabe e u ), ou simplesmente utilizar substantivos para atributos e verbos para m todos. e Atributos de dados podem ser referenciados por m todos da pr pria inst ncia, bem como por qualquer outro usu rio e o a a do objeto. Em outras palavras, classes n o servem para implementar tipos puramente abstratos de dados. De fato, nada a em Python torna possvel assegurar o encapsulamento de dados. Tudo e convencao. Por outro lado, a implementacao Python, escrita em C, pode esconder completamente detalhes de um objeto ou regular seu acesso se necess rio. Isto a pode ser utilizado por extens es a Python escritas em C. o Clientes devem utilizar atributos de dados com cuidado, pois podem baguncar invariantes mantidos pelos m todos e ao esbarrar nos seus atributos. Portanto, clientes podem adicionar a vontade atributos de dados para uma inst ncia ` a sem afetar a validade dos m todos, desde que seja evitado o conito de nomes. Novamente, uma convencao de e nomenclatura poupa muita dor de cabeca. N o existe atalho para referenciar atributos de dados (ou m todos) de dentro de um m todo. Isso na verdade aumenta a e e a legibilidade dos m todos: n o h como confundir uma vari vel local com uma inst ncia global ao dar uma olhadela e a a a a em um m todo desconhecido. e
9.4. Observacoes Aleatorias
57
Por convencao, o primeiro argumento de qualquer m todo e frequentemente chamado self. Isso n o e nada mais do e a que uma convencao, self n o possui nenhum signicado especial em Python. Observe que ao seguir a convencao seu a c digo se torna legvel por uma grande comunidade de desenvolvedores Python e potencialmente poder se beneciar o a de ferramentas feitas por outr m que se baseie na convencao. e Qualquer funcao que e tamb m atributo de classe dene um m todo nas inst ncias desta classe. N o e necess rio que e e a a a a denicao da funcao esteja textualmente embutida na denicao da classe. Atribuir um objeto funcao a uma vari vel a local da classe e v lido. Por exemplo: a
# Funco definida fora da classe a def f1(self, x, y): return min(x, x+y) class C: f = f1 def g(self): return hello world h = g
Agora f, g e h s o todos atributos da classe C que referenciam funcoes, e consequentemente s o todos m todos de a a e inst ncias da classe C, onde h e equivalente a g. No entanto, essa pr tica pode confundir o leitor do programa. a a M todos podem chamar outros m todos utilizando o argumento self : e e
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)
M todos podem referenciar nomes globais da mesma forma que funcoes ordin rias. O escopo global associado a um e a m todo e o m dulo contendo sua denicao de classe (a classe propriamente dita nunca e usada como escopo global!). e o Ainda que seja raro encontrar a necessidade de utilizar dados globais em um m todo, h diversos usos legtimos do e a escopo global. Por exemplo, funcoes e m dulos importados no escopo global podem ser usados por m todos, bem o e como as funcoes e classes denidas no pr prio escopo global. Provavelmente, a classe contendo o m todo em quest o o e a tamb m foi denida neste escopo global. Na pr xima secao veremos um conjunto de raz es pelas quais um m todo e o o e desejaria referenciar sua pr pria classe. o
9.5
Heranca
Obviamente, uma caracterstica de linguagem n o seria digna do nome classe se n o suportasse heranca. A sintaxe a a para uma classe derivada se parece com:
class DerivedClassName(BaseClassName): <statement-1> . . . <statement-N>
O nome BaseClassName deve estar denido em um escopo contendo a denicao da classe derivada. No lugar do nome da classe base tamb m s o aceitas express es. O que e muito util quando a classe base e denida em outro e a o 58 Captulo 9. Classes
m dulo, ex: o
class DerivedClassName(modname.BaseClassName):
Execucao de uma denicao de classe derivada procede da mesma forma que a de uma classe base. Quando o objeto classe e construdo, a classe base e lembrada. Isso e utilizado para resolver refer ncias a atributos. Se um atributo e requisitado n o for encontrado na classe, ele e procurado na classe base. Essa regra e aplicada recursivamente se a a classe base por sua vez for derivada de outra. N o existe nada de especial sobre instanciacao de classes derivadas. DerivedClassName() cria uma nova a inst ncia da classe. Refer ncias a m todos s o resolvidas da seguinte forma: o atributo correspondente e procurado a e e a atrav s da cadeia de derivacao, e refer ncias a m todos s o v lidas desde que produzam um objeto do tipo funcao. e e e a a Classes derivadas podem sobrescrever m todos das suas classes base. Uma vez que m todos n o possuem privil gios e e a e especiais quando invocam outros m todos no mesmo objeto, um m todo na classe base que invocava um outro m todo e e e da mesma classe base, pode efetivamente acabar invocando um m todo sobreposto por uma classe derivada. Para e programadores C++ isso signica que todos os m todos em Python s o efetivamente virtual. e a Um m todo que sobrescreva outro em uma classe derivada pode desejar na verdade estender, ao inv s de substituir, o e e m todo sobrescrito de mesmo nome na classe base. A maneira mais simples de implementar esse comportamento e e chamar diretamente a classe base BaseClassName.methodname(self, arguments). O que pode ser util para os usu rios da classe tamb m. Note que isso s funciona se a classe base for denida ou importada diretamente a e o no escopo global.
9.5.1
Heranca Multipla
Python tamb m suporta uma forma limitada de heranca m ltipla. Uma denicao de classe que herda de v rias classes e u a bases e:
class DerivedClassName(Base1, Base2, Base3): <statement-1> . . . <statement-N>
A unica regra que precisa ser explicada e a sem ntica de resolucao para as refer ncias a atributos de classe. E feita uma a e busca em profundidade da esquerda para a direita. Logo, se um atributo n o e encontrado em DerivedClassName, a ele e procurado em Base1, e recursivamente nas classes bases de Base1, e apenas se n o for encontrado l a busca a a prosseguir em Base2, e assim sucessivamente. a Para algumas pessoas a busca em largura procurar antes em Base2 e Base3 do que nos ancestrais de Base1 parece mais natural. Entretanto, seria preciso conhecer toda a hierarquia de Base1 para evitar um conito com um atributo de Base2. Enquanto a busca em profundidade n o diferencia o acesso a atributos diretos ou herdados de a Base1. E sabido que o uso indiscriminado de heranca m ltipla e o pesadelo da manutencao, sobretudo pela conanca de u Python na adocao de uma convencao de nomenclatura para evitar conitos. Um problema bem conhecido com heranca m ltipla e quando h uma classe derivada de outras que por sua vez possuem um ancestral em comum. Ainda que u a seja perfeitamente claro o que acontecer (a inst ncia possuir uma unica c pia dos atributos de dados do ancestral a a a o comum), n o est claro se a sem ntica e util. a a a
9.5. Heranca
59
9.6
Variaveis Privadas
Existe um suporte limitado a identicadores privados em classes. Qualquer identicador no formato spam (no mnimo dois caracteres no prexo e no m ximo u m como suxo) e realmente substitudo por a classname spam, onde classname e o nome da classe corrente. Essa construcao independe da posicao sint tica do identicador, e pode ser usada para tornar privadas: inst ncias, vari veis de classe e m todos. Pode haver a a a e truncamento se o nome combinado extrapolar 255 caracteres. Fora de classes, ou quando o nome da classe s tem , o n o se aplica esta construcao. a Este procedimento visa oferecer a classes uma maneira f cil de denir vari veis de inst ncia e m todos privados, a a a e sem ter que se preocupar com outras vari veis de inst ncia denidas em classes derivadas ou denidas fora da classe. a a Apesar da regra de nomenclatura ter sido projetada para evitar acidentes, ainda e possvel o acesso e a manipulacao de entidades privadas. O que e util no caso de depuradores, talvez a unica raz o pela qual essa caracterstica ainda a n o tenha sido suprimida (detalhe: derivar uma classe com o mesmo nome da classe base torna possvel o uso de seus a membros privados! Isso pode ser corrigido em vers es futuras). o Observe que c digo passado para exec, eval() ou evalfile() n o considera o nome da classe que o invocou o a como sendo a classe corrente. O modicador global funciona de maneira semelhante, quando se est restrito ao a c digo que foi byte-compilado em conjunto. A mesma restricao se aplica aos comandos getattr(), setattr() o e delattr(), e a manipulacao direta do dicion rio dict . a Aqui est um exemplo de uma classe que implementa seus pr prios m todos getattr () e setattr (), a o e armazenando todos os atributos em vari veis privadas. Da forma como foi codicado este exemplo, ele funcionar at a a e em vers es de Python em que esta caracterstica ainda n o havia sido implementada. o a
class VirtualAttributes: __vdict = None __vdict_name = locals().keys()[0] def __init__(self): self.__dict__[self.__vdict_name] = {} def __getattr__(self, name): return self.__vdict[name] def __setattr__(self, name, value): self.__vdict[name] = value
9.7
Particularidades
` As vezes, e util ter um tipo semelhante ao record de Pascal ou ao struct de C. Uma denicao de classe vazia atende esse prop sito: o
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
Um trecho de c digo Python que espera um tipo abstrato de dado em particular, pode receber ao inv s do tipo abstrato o e uma classe (que emula os m todos que aquele tipo suporta). Por exemplo, se voc tem uma funcao que formata dados e e em um objeto arquivo, voc pode denir uma classe com os m todos read() e readline() que utiliza um buffer e e 60 Captulo 9. Classes
ao inv s do arquivo propriamente dito. e M todos de inst ncia s o objetos, e podem possuir atributos tamb m. e a a e
9.7.1
Excecoes Podem Ser Classes
Excecoes denidas pelo usu rio podem ser identicadas por classes. Atrav s deste mecanismo e possvel criar hierar a e quias extensveis de excecoes. Existem duas novas sem nticas v lidas para o comando raise: a a
raise Class, instance raise instance
Na primeira forma, instance deve ser uma inst ncia de Class ou de uma classe derivada dela. A segunda forma a e um atalho para:
raise instance.__class__, instance
Uma cl usula de excecao pode listar tanto classes como strings. Uma classe em uma cl usula de excecao e compatvel a a com a excecao se e a mesma classe prevista na cl usula ou ancestral dela (n o o contr rio, se na cl usula estiver uma a a a a classe derivada n o haver casamento com excecoes base levantadas). No exemplo a seguir ser impresso B, C, D a a a nessa ordem: order:
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"
Se a ordem das cl usulas fosse invertida (B no incio), seria impresso B, B, B sempre a primeira cl usula v lida e a a a ativada. Quando uma mensagem de erro e impressa para uma excecao n o tratada que for uma classe, o nome da classe e a impresso, e depois a inst ncia da excecao e convertida para string pela funcao str() e e tamb m impressa (ap s um a e o espaco e uma vrgula).
9.7. Particularidades
61
62
CAP ITULO
TEN
E agora?
Espera-se que a leitura deste manual tenha agucado seu interesse em utilizar Python. Agora o que voc deve fazer ? e Voc deve ler, ou pelo menos correr os olhos pela Library Reference que prov material completo de refer ncia sobre e e e tipos, funcoes e m dulos que podem poupar um bocado de tempo na hora de escrever programas em Python. Na o distribuicao padr o de Python, h m dulos para leitura de caixas postais, recuperar documentos via HTTP, gerar a a o n meros aleat rios, escrever programas CGI, comprimir dados, e muito mais. O material de refer ncia pode lhe dar u o e uma boa id ia do que j est disponvel. e a a O principal Web site de Python e http://www.python.org/. Ele cont m c digo, documentacao e links para outras p ginas e o a relacionadas pelo mundo afora. Este site e espelhado em diversos cantos do mundo, como na Europa, Jap o e Austr lia. a a Um site espelho pode ser mais r pido de ser acessado dependendo da sua posicao geogr ca. Outro site importante e a a http://starship.python.net/, que cont m p ginas pessoais de gente envolvida com Python, muito software est disponvel e a a para download neste site. Para quest es relacionadas a Python e reportagem problemas, voc pode enviar uma mensagem para o newsgroup o e comp.lang.python, ou para a lista de e-mail python-list@python.org. Ambos est o vinculados e tanto faz mandar a atrav s de um ou atrav s de outro que o resultado e o mesmo. Existem em m dia 120 mensagens por dia, e e e perguntando e respondendo quest es, sugerindo novas funcionalidades, e anunciando novos m dulos. Antes de subo o meter, esteja certo que o que voc procura n o consta na Frequently Asked Questions (tamb m conhecida por FAQ), e a e em http://www.python.org/doc/FAQ.html, ou procure no diret rio Misc/ da distribuicao (c digo fonte). Os arquivos o o da lista de discuss o est o disponveis em http://www.python.org/pipermail/. A FAQ responde muitas das quest es a a o reincidentes na lista, talvez l esteja a solucao para o seu problema. a
63
64
APENDICE
Edicao de Entrada Interativa e Substituicao por Historico

Algumas vers es do interpretador Python suportam facilidades de edicao e substituicao semelhantes as encontradas o na Korn shell ou na GNU Bash shell. Isso e implementado atrav s da biblioteca GNU Readline, que suporta edicao e no estilo Emacs ou vi. Essa biblioteca possui sua pr pria documentacao, que n o ser duplicada aqui. Por m os o a a e fundamentos s o f ceis de serem explicados. As facilidades aqui descritas est o disponvies nas vers es U NIX e a a a o CygWin do interpretador. Este captulo n o documenta as facilidades de edicao do pacote PythonWin de Mark Hammond, ou do ambiente IDLE a baseado em Tk e distribudo junto com Python.
A.1
Edicao de Linha
Se for suportado, edicao de linha est ativa sempre que o interpretador imprimir um dos prompts (prim rio ou se a a cund rio). A linha corrente pode ser editada usando comandos tpicos do Emacs. Os mais imoportantes s o: C-A a a (Control-A) move o cursor para o incio da linha, C-E para o m, C-B move uma posicao para a esquerda, C-F para ` a direita. Backspace apaga o caracter a esquerda, C-D apaga o da direita. C-K apaga do cursor at o resto da linha a ` e ` direita, C-Y cola a linha apagada. C-underscore e o undo e tem efeito cumulativo.
A.2
Substituicao de Historico
Funciona da seguinte maneira: todas linhas n o vazias s o armazenadas em um buffer (hist rico). C-P volta uma a a o posicao no hist rico, C-N avanca uma posicao. Pressionando Return a linha corrente e alimentada para o interpre o tador. C-R inicia uma busca para tr s no hist rico, e C-S um busca para frente. a o
A.3
Vinculacao de Teclas
A vinculacao de teclas e outros par metros da biblioteca Readline podem ser personalizados por conguracoes colo a cadas no arquivo /.inputrc. Vinculacao de teclas tem o formato:
key-name: function-name
ou
65
"string": function-name
e opcoes podem ser especicadas com:
set option-name value
Por exemplo:
# Qume prefere editar estilo vi: set editing-mode vi # Edico em uma nica linha: a u set horizontal-scroll-mode On # Redefinico de algumas teclas: a Meta-h: backward-kill-word "\C-u": universal-argument "\C-x\C-r": re-read-init-file
Observe que a vinculacao default para Tab em Python e inserir um caracter Tab ao inv s de completar o nome de um e arquivo (default no Readline). Isto pode ser recongurado de volta atrav s: e
Tab: complete
no /.inputrc. Todavia, isto torna mais difcil digitar comandos identados em linhas de continuacao. Preenchimento autom tico de nomes de vari veis e m dulos est o opcionalmente disponvies. Para habilit -los no a a o a a modo interativo, adicione o seguinte ao seu arquivo de inicializacao: 1
import rlcompleter, readline readline.parse_and_bind(tab: complete)
Isso vincula a tecla TAB para o preenchimento autom tico de nomes de funcao. Assim, teclar TAB duas vezes dispara a o preenchimento. Um determinado nome e procurado entre as vari veis locais e m dulos disponveis. Para express es a o o terminadas em ponto, como em string.a, a express o ser avaliada at o ultimo . quando ser o sugeridos a a e a possveis extens es. Isso pode at implicar na execucao de c digo denido por aplicacao quando um objeto que dene o e o o m todo getattr () for parte da express o. e a
A.4
Comentario
Essa facilidade representa um enorme passo em comparacao com vers es anteriores do interpretador. Todavia, ainda o h caractersticas desej veis deixadas de fora. Seria interessante se a indentacao apropriada fosse sugerida em linhas a a de continuacao, pois o parser sabe se um token de identacao e necess rio. O mecanismo de preenchimento poderia a utilizar a tabela de smbolos do interpretador. Tamb m seria util um comando para vericar (ou at mesmo sugerir) o e e balanceamento de par nteses, aspas, etc. e
1 Python executar o conte do do arquivo identicado pela vari vel de ambiente PYTHONSTARTUP quando se dispara o interpretador interatia u a vamente.
66
Apendice A. Edicao de Entrada Interativa e Substituicao por Historico

Python 21

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Python 21

Transféré par

Droits d'auteur :

Formats disponibles

Tutorial de Python

PythonLabs E-mail: python-docs@python.org E-mail Tradutor: rodsenra@gpr.com.br

8.2 8.3 8.4 8.5 8.6

Para Onde Ir a Partir Daqui

Captulo 1. Abrindo o Apetite

Utilizando o Interpretador Python

O Interpretador e seu Ambiente

problema com o pacote Readline da GNU evita isso

Captulo 2. Utilizando o Interpretador Python

Scripts Executaveis em Python

O Arquivo de Inicializacao para Modo Interativo

2.2. O Interpretador e seu Ambiente

Uma Introducao Informal a Python

Utilizando Python Como Uma Calculadora

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

Um valor pode ser atribudo a diversas vari veis simultaneamente: a

>>> >>> 0 >>> 0 >>> 0

>>> 4 * 2.5 / 3.3 3.0303030303 >>> 7.0 / 2 3.5

Captulo 3. Uma Introducao Informal a Python

Display this usage message Hostname to connect to

produz a seguinte sada:

Display this usage message Hostname to connect to

This is ok This is ok This is invalid

>>> word[4] A >>> word[0:2] He >>> word[2:4]

Captulo 3. Uma Introducao Informal a Python

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

>>> uHello World ! uHello World !

Captulo 3. Uma Introducao Informal a Python

>>> urHello\u0020World ! uHello World ! >>> urHello\\u0020World ! uHello\\\\u0020World !

aou >>> u"".encode(utf-8) \xc3\xa4\xc3\xb6\xc3\xbc

>>> unicode(\xc3\xa4\xc3\xb6\xc3\xbc, utf-8) u\xe4\xf6\xfc

3.1. Utilizando Python Como Uma Calculadora

Atribuicao a fatias (slices) e possvel, e isso pode at alterar o tamanho da lista: ` e

A funcao interna len() tamb m se aplica a lista: e

Captulo 3. Uma Introducao Informal a Python

Primeiros Passos em Direcao a Programacao `

3.2. Primeiros Passos em Direcao a Programacao `

Uma vrgula ao nal evita a quebra de linha:

Captulo 3. Uma Introducao Informal a Python

Mais Ferramentas de Controle de Fluxo

Provavelmente uma das mais conhecidas construcoes e o if. Por exemplo:

>>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Clausulas break, continue e else em Lacos

Captulo 4. Mais Ferramentas de Controle de Fluxo

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

>>> print fib(0) None

Captulo 4. Mais Ferramentas de Controle de Fluxo

Mais sobre Denicao de Funcoes

Parametros com Valores Default

4.7. Mais sobre Denicao de Funcoes

if l is None: l = [] l.append(a) return l

Parametros na Forma Chave-Valor

poderia ser chamada em qualquer uma das seguintes maneiras:

por m, existem maneiras inv lidas: e a

parrot() parrot(voltage=5.0, dead) parrot(110, voltage=220) parrot(actor=John Cleese)

Captulo 4. Mais Ferramentas de Controle de Fluxo

for kw in keywords.keys(): print kw, :, keywords[kw]

Poderia ser chamado assim:

Listas Arbitrarias de Argumentos

>>> ... ... >>> >>> 42 >>> 43 >>>

def make_incrementor(n): return lambda x, incr=n: x+incr f = make_incrementor(42) f(0) f(1)

H uma convencao sobre o conte do e formato de strings de documentacao. a u

4.7. Mais sobre Denicao de Funcoes

Captulo 4. Mais Ferramentas de Controle de Fluxo

>>> width = 20 >>> height = 59 >>> width height 900

raise instance.class, instance