Apostila Python.pdf

Tutorial PythonRelease 2.4.2

Guido van RossumFred L. Drake, Jr., editorTraduo: Python Brasil

23 de novembro de 2005

Python Software FoundationEmail: [email protected] Python Brasil

http://pythonbrasil.com.br

Copyright 2001-2004 Python Software Foundation. All rights reserved.

Copyright 2000 BeOpen.com. All rights reserved.

Copyright 1995-2000 Corporation for National Research Initiatives. All rights reserved.

Copyright 1991-1995 Stichting Mathematisch Centrum. All rights reserved.

Traduo: Pedro Werneck, Osvaldo Santana Neto, Jos Alexandre Nalon, Felipe Lessa, Pedro de Medeiros, RafaelAlmeida, Renata Palazzo, Rodrigo Senra e outros.

Reviso: Pedro Werneck, Osvaldo Santana Neto, Pedro de Medeiros.

Veja a parte final deste documento para informaes mais completas sobre licenas e permisses.

Resumo

Python uma linguagem de programao poderosa e de fcil aprendizado. Ela possui estruturas de dados de alto-nvel eficientes, bem como adota uma abordagem simples e efetiva para a programao orientada a objetos. Suasintaxe elegante e tipagem dinmica, em adio sua natureza interpretada, tornam Python ideal para scripting epara o desenvolvimento rpido de aplicaes em diversas reas e na maioria das plataformas.

O interpretador de Python e sua extensa biblioteca padro esto disponveis na forma de cdigo fonte ou binriopara a maioria das plataformas a partir do site, http://www.python.org/, e deve ser distribudos livremente. Nomesmo stio esto disponveis distribuies e referncias para diversos mdulos, programas, ferramentas e docu-mentao adicional contribudos por terceiros.

O interpretador de Python facilmente extensvel incorporando novas funes e tipos de dados implementadosem C ou C++ (ou qualquer outra linguagem acessvel a partir de C). Python tambm se adequa como linguagemde extenso para customizar aplicaes.

Este tutorial introduz o leitor informalmente aos conceitos bsicos e aspectos do sistema e linguagem Python. aconselhvel ter um interpretador Python disponvel para se poder por a mo na massa, porm todos os exemplosso auto-contidos, assim o tutorial tambm pode ser lido sem que haja a necessidade de se estar on-line.Para uma descrio dos mdulos e objetos padro, veja o documento Referncia da Biblioteca Python. O Manualde Referncia Python oferece uma definio formal da linguagem. Para se escrever extenses em C ou C++,leia Extendendo e Embutindo o Interpretador Python e Manual de Referncia da API Python/C. Existem tambmdiversos livros abordando Python em maior profundidade.

Este tutorial no almeja ser abrangente ou abordar todos os aspectos, nem mesmo todos os mais frequentes. Aoinvs disso, ele introduz muitas das caractersticas dignas de nota em Python, e fornecer a voc uma boa idiasobre o estilo e o sabor da linguagem. Aps a leitura, voc deve ser capaz de ler e escrever programas e mdulosem Python, e estar pronto para aprender mais sobre os diversos mdulos de biblioteca descritos na Referncia daBiblioteca Python

A traduo original do tutorial da verso 2.1 foi patrocinada pela GPr Sistemas Ltda (http://www.gpr.com.br).A atualizao do tutorial para esta verso foi realizada por voluntrios do projeto PythonDoc-Brasil.(http://www.pythonbrasil.com.br/moin.cgi/PythonDoc)

SUMRIO

1 Abrindo o Apetite 1

2 Utilizando o Interpretador Python 32.1 Disparando o Interpretador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.2 O Interpretador e seu Ambiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Uma Introduo Informal a Python 73.1 Utilizando Python Como Uma Calculadora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73.2 Primeiros Passos em Direo Programao . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 Mais Ferramentas de Controle de Fluxo 194.1 Construo if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.2 Construo for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.3 A Funo range() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.4 Clusulas break, continue e else em Laos . . . . . . . . . . . . . . . . . . . . . . . . . 204.5 Construo pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.6 Definindo Funes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.7 Mais sobre Definio de Funes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

5 Estruturas de Dados 295.1 Mais sobre Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295.2 O comando del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335.3 Tuplas e Sequncias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335.4 Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345.5 Dicionrios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355.6 Tcnicas de Lao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365.7 Mais sobre Condies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375.8 Comparando Sequncias e Outros Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

6 Mdulos 396.1 Mais sobre Mdulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406.2 Mdulos Padro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416.3 A Funo dir() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426.4 Pacotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

7 Entrada e Sada 477.1 Refinando a Formatao de Sada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477.2 Leitura e Escrita de Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

8 Erros e Excees 538.1 Erros de Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538.2 Excees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538.3 Tratamento de Excees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548.4 Levantando Excees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

i

8.5 Excees Definidas pelo Usurio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568.6 Definindo Aes de Limpeza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

9 Classes 599.1 Uma Palavra Sobre Terminologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599.2 Escopos e Espaos de Nomes em Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599.3 Primeiro Contato com Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619.4 Observaes Aleatrias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639.5 Herana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649.6 Variveis Privadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659.7 Particularidades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669.8 Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679.9 Geradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689.10 Expresses Geradoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

10 Um Breve Passeio Pela Biblioteca Padro 7110.1 Interface Com o Sistema Operacional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7110.2 Caracteres Coringa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7110.3 Argumentos da Linha de Comando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7210.4 Redirecionamento de Erros e Encerramento do Programa . . . . . . . . . . . . . . . . . . . . . . 7210.5 Reconhecimento de Padres em Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7210.6 Matemtica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7310.7 Acesso Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7310.8 Data e Hora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7310.9 Compresso de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7410.10 Medio de Desempenho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7410.11 Controle de Qualidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7510.12 Baterias Includas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

11 Um Breve Passeio Pela Biblioteca Padro Parte II 7711.1 Formatando Sada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7711.2 Templating . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7811.3 Working with Binary Data Record Layouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7911.4 Multi-threading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7911.5 Logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8011.6 Referncias Fracas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8111.7 Trabalhando com Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8111.8 Decimal Floating Point Arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

12 E agora? 85

A Edio de Entrada Interativa e Substituio por Histrico 87A.1 Edio de Linha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87A.2 Substituio de Histrico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87A.3 Vinculao de Teclas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87A.4 Comentrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

B Floating Point Arithmetic: Issues and Limitations 91B.1 Representation Error . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

C History and License 95C.1 History of the software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95C.2 Terms and conditions for accessing or otherwise using Python . . . . . . . . . . . . . . . . . . . 96C.3 Licenses and Acknowledgements for Incorporated Software . . . . . . . . . . . . . . . . . . . . 98

D Glossary 107

ndice Remissivo 111

ii

CAPTULO

ONE

Abrindo o Apetite

Se alguma vez voc j escreveu um extenso script de shell, provavelmente se sentiu assim: voc adoraria adicionarmais uma caracterstica, mas j est to lento, e to grande, e to complicado; ou a nova caracterstica implicanuma chamada de sistema ou funo s acessvel a partir do C. . . Tipicamente o problema em questo no srioo suficiente para motivar a re-escrita do script em C; talvez o problema exija cadeias de caracteres de comprimentovarivel ou tipos (como listas ordenadas de nomes de arquivos) que so fcilmente manipulveis na shell, pormdemandam muito esforo de implementao em C, ou talvez voc nem esteja suficientemente familiarizado comC.

Outra situao: suponha que voc tenha que trabalhar com diversas bibiotecas em C, e o tpico cicloescreve/compila/testa/re-compila seja muito lento. Voc precisa desenvolver software de uma forma mais gil.Ou, suponha que voc escreveu um programa que precise fazer uso de uma linguagem de extenso, e voc noquer projetar a linguagem, implementar e depurar um interpretador para ela, para s ento estabelecer o vnculocom sua aplicao original.

Nestes casos, Python possivelmente exatamente do que voc est precisando. Python simples de usar, semdeixar de ser uma linguagem de programao de verdade, oferecendo muito mais estruturao e suporte paraprogramas extensos do que shell scripts oferecem. Por outro lado, Python tambm oferece melhor verificao deerros do que C, e por ser uma linguagem de alto nvel, ela possui tipos nativos de alto nvel: dicionrios e vetores(arrays) flexveis que lhe custariam dias para obter uma implementao eficiente em C. Devido ao suporte nativoa tipos genricos, Python aplicvel a um domnio de problemas muito mais vasto do que Awk ou at mesmo Perl,ainda assim Python to fcil de usar quanto essas linguagens sob diversos aspectos.

Python permite que voc organize seu programa em mdulos que podem ser reutilizados em outros programasescritos em Python. A linguagem prov uma vasta coleo de mdulos que podem ser utilizados como base parasua aplicao ou como exemplos para estudo e aprofundamento. Alguns desses mdulos implementam manip-ulao de arquivos, chamadas do sistema, sockets, e at mesmo acesso a bibiotecas de construo de interfacesgrficas, como Tk.

Python uma linguagem interpretada, que pode fazer com que voc economize um tempo considervel, uma vezque no h necessidade de compilao e vinculao(linking) durante o desenvolvimento. O interpretador pode serusado interativamente, o que torna fcil experimentar diversas caractersticas da linguagem, escrever programasdescartveis, ou testar funes em um desenvolvimento bottom-up. tambm uma til calculadora de mesa.Python permite a escrita de programas compactos e legveis. Programas escritos em Python so tipicamente maiscurtos do que seus equivalentes em C ou C++, por diversas razes:

os tipos de alto-nvel permitem que voc expresse operaes complexas em uma nico comando (statement); a definio de bloco feita por identao ao invs de marcadores de incio e fim de bloco;

no h necessidade de declarao de variveis ou parmetros formais;

Python extensvel: se voc sabe como programar em C, fcil adicionar funes ou mdulos diretamenteno interpretador, seja para desempenhar operaes crticas em mxima velocidade, ou para vincular programasPython a bibliotecas que s estejam disponvies em formato binrio (como uma bibloteca grfica de terceiros).Uma vez que voc tenha sido fisgado, voc pode vincular o interpretador Python a uma aplicao escrita em C eutiliz-la como linguagem de comandos ou extenso para esta aplicao.

1

A propsito, a linguagem foi batizada a partir do famoso show da BBC Monty Pythons Flying Circus e notem nada a ver com repulsivos rpteis. Fazer referncias citaes do show na documentao no s permitido,como tambm encorajado!Agora que voc est entusiasmado com Python, vai desejar examin-la com maior detalhe. Partindo do princpioque a melhor maneira de aprender uma linguagem usando-a, voc est agora convidado a faz-lo com estetutorial.

No prximo captulo, a mecnica de utilizao do interpretador explicada. Essa informao, ainda que mundana, essencial para a experimentao dos exemplos apresentados mais tarde.

O resto do tutorial introduz diversos aspectos do sistema e linguagem Python por intermdio de exemplos. Seroabordadas expresses simples, comandos, tipos, funes e mdulos. Finalmente, sero explicados alguns con-ceitos avanados como excees e classes definidas pelo usurio.

2 Captulo 1. Abrindo o Apetite

CAPTULO

TWO

Utilizando o Interpretador Python

2.1 Disparando o Interpretador

O interpretador freqentemente instalado como /usr/local/bin/python nas mquinas em que disponibilizado;adicionando /usr/local/bin ao caminho de busca (search path) da shell de seu UNIX torna-se possvel inici-lodigitando:

python

na shell. Considerando que a escolha do diretrio de instalao uma opo de instalao, outras localizaes sopossveis; verifique com seu guru local de Python ou com o administrador do sistema. (Ex., /usr/local/python uma alternativa popular para instalao.)Em computadores com Windows, Python instalado geralmente em C:\Python24, apesar de voc poder mudarisso enquanto est executando o instalador. Para adicionar esse diretrio ao path, voc pode digitar o seguintecomando no DOS:

set path=%path%;C:\python24

Digitando um caracter EOF() (Control-D on UNIX, Control-Z no Windows) diretamente no prompt forao interpretador a sair com status de sada zero. Se isso no funcionar, voce pode sair do interpretador atravs dadigitao do seguinte: import sys; sys.exit().As caractersticas de edio de linha no so muito sofisticadas. Sobre UNIX, seja l quem for que tenha instaladoo interpretador talvez tenha habilitado o suporte biblioteca readline da GNU, que adiciona facilidades maiselaboradas de edio e histrico de comandos. Teclar Control-P no primeiro prompt oferecido pelo Python ,provavelmente, a maneira mais rpida de verificar se a edio de linha de comando e suportada. Se houver umbeep, voc possui edio de linha de comando; veja o Apndice A para uma introduo as teclas especiais. Senada acontecer, ou se ^P aparecer na tela, a opo de edio no est disponvel; voc apenas ser capaz de usaro backspace para remover caracteres da linha corrente.

O interpretador trabalha de forma semelhante a uma shell de UNIX: quando disparado com a sada padro conec-tadaa um console de terminal (tty device), ele l e executa comandos interativamente; quando disparado com umnome de arquivo como parmetro ou com redirecionamento da entrada padro para um arquivo, o interpretadorir ler e executar o script contido em tal arquivo.

Uma segunda forma de disparar o interpretador python -c command [arg] ..., que executa o(s) co-mando(s) especificados na posio command, analogamente opo de shell -c. Considerando que comandosPython possuem freqentemente espaos em branco (ou outros caracteres que sejam especiais para a shell) aconselhvel que o comando especificado em command esteja dentro de aspas duplas.Alguns mdulos Python so tambm teis como scripts. Estes podem ser chamados usando python -m module[arg] ..., que executa o arquivo fonte para module como se voc tivesse digitado seu caminho completo nalinha de comando.

3

Observe que h uma diferena entre python file e python >> ); para linhas de continuao do comando corrente, o prompt secundrio default so trs pontos (... ).O interpretador imprime uma mensagem de boas vindas, informando seu nmero de verso e uma nota legal decopyright antes de oferecer o primeiro prompt:

pythonPython 1.5.2b2 (#1, Feb 28 1999, 00:02:06) [GCC 2.8.1] on sunos5Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam>>>

Linhas de continuao so necessrias em construes multi-linha. Como exemplo, d uma olhada nesse comandoif:

>>> o_mundo_eh_plano = 1>>> if o_mundo_eh_plano:... print "Cuidado para no cair fora dele!"...

Cuidado para no cair fora dele!

2.2 O Interpretador e seu Ambiente

2.2.1 Tratamento de Erros

Quando ocorre um erro, o interpretador imprime uma mensagem de erro e a situao da pilha (daqui em diantestack trace). No modo interativo, retorna-se ao prompt primrio; quando a entrada vem de um arquivo, o interpre-tador aborta sua execuo com status de erro diferente de zero aps imprimir o stack trace (Excees tratadas porum except num bloco try no so consideradas erros neste contexto). Alguns erros so incondicionalmentefatais e causam a sada com status diferente de zero; isto se aplica a inconsistncias internas e alguns casos de

4 Captulo 2. Utilizando o Interpretador Python

exausto de memria. Todas as mensagens de erro so escritas na sada de erros padro (standard error), enquantoa sada dos demais comandos direcionada para a sada padro.

Teclando o caracter de interrupo (tipicamente Control-C ou DEL) no prompt primrio ou secundrio cancela aentrada de dados corrente e retorna-se ao prompt primrio. 1 Provocando uma interrupo enquanto um comandoest em execuo levanta a exceo KeyboardInterrupt, a qual pode ser tratada em um bloco try.

2.2.2 Scripts Executveis em Python

Em sistemas UNIXBSD, scripts Python podem ser transformados em executveis, como shell scripts, pela inclusodo cabealho

#! /usr/bin/env python

(Assumindo que o interpretador foi includo do caminho de busca do usurio (PATH)) e que o script tenha apermisso de acesso habilitada para execuo. O #! deve estar no incio do arquivo .Em algumas plataformasesta linha inicial deve ser finalizada no estilo UNIX-style com (\n), ao invs do estlo Mac OS (\r) ou mesmoa terminao tpica do Windows (\r\n). Observe que o caracter # designa comentrios em Python.Para atribuir permisso de execuo (plataforma Unix) ao seu script Python, utilize o comando chmod:

$ chmod +x meuscript.py

2.2.3 Codificao em Arquivos de Cdigo-fonte

possvel usar codificao diferente de ASCII() em arquivos de cdigo Python. A melhor maneira de faz-lo atravs de um comentrio adicional logo aps a linha #!:

# -*- coding: encoding -*-

Com essa declarao, todos os caracteres no cdigo-fonte sero tratados como encoding, mas ser possvel es-crever strings Unicode diretamente. A lista de codificaes possveis pode ser encontrada na Referncia da Bib-lioteca Python, na seo codecs.

Por exemplo, para escrever strings unicode incluindo o smbolo monetrio para o Euro, ISO-8859-15 pode serusado, com o smbolo tendo o valor 164. Este script exibir o valor 8364 (Unicode correspondente ao smbolo doEuro) e retornar:

# -*- coding: iso-8859-15 -*-

currency = u" "print ord(currency)

Se o seu editor capaz de salvar arquivos UTF-8 com um byte order mark (conhecido como BOM), voc podeus-lo ao invs da declarao de codificao. O IDLE capaz de fazer isto se Options/General/DefaultSource Encoding/UTF-8 estiver habilitado. Note que esta assinatura no reconhecida por verses antigas(Python 2.2 e anteriores), e pelo sistema operacional para arquivos com a declarao #! (usada somente emsistemas UNIX).Usando UTF-8 (seja atravs da assinatura ou de uma declarao de codificao), caracteres da maioria das lnguasdo mundo podem ser usados simultaneamente em strings e comentrios. No possvel usar caracteres no-ASCIIem identificadores. Para exibir todos esses caracteres adequadamente, seu editor deve reconhecer que o arquivo UTF-8, e deve usar uma fonte que tenha todos os caracteres usados no arquivo.

1Um problema com o pacote Readline da GNU evita isso

2.2. O Interpretador e seu Ambiente 5

2.2.4 O Arquivo de Inicializao para Modo Interativo

Quando voc for utilizar Python interativamente, pode ser til adicionar uma srie de comandos a serem execu-tados por default antes de cada sesso de utilizao do interpretador. Isto pode ser obtido pela configurao davarivel de ambiente PYTHONSTARTUP para indicar o nome do arquivo script que contm o script de inicial-izao. Essa caracterstica assemelha-se aos arquivos .profile de shells UNIX.

O arquivo s processado em sesses interativas, nunca quando Python l comandos de um script especificadocomo parmetro, nem tampouco quando /dev/tty especificado como a fonte de leitura de comandos (casocontrrio se comportaria como uma sesso interativa). O script de inicializao executado no mesmo con-texto (doravante namespace) em que os comandos da sesso interativa sero executados, sendo assim, os objetosdefinidos e mdulos importados podem ser utilizados sem qualificao durante a sesso interativa. possveltambm redefinir os prompts sys.ps1 e sys.ps2 atravs deste arquivo.

Se for necessrio ler um script adicional de inicializao a partir do diretrio corrente, voc pode programarisso a partir do script de inicializao global, por exemplo if os.path.isfile(.pythonrc.py):execfile(.pythonrc.py). Se voc deseja utilizar o script de inicializao em outro script, voc devefaz-lo explicitamente da seguinte forma:

import osfilename = os.environ.get(PYTHONSTARTUP)if filename and os.path.isfile(filename):

execfile(filename)

6 Captulo 2. Utilizando o Interpretador Python

CAPTULO

THREE

Uma Introduo Informal a Python

Nos exemplos seguintes, pode-se distinguir a entrada da sada pela presena ou ausncia dos prompts (>>> and ... ): para repetir o exemplo, voc deve digitar tudo aps o prompt, quando o mesmo aparece; linhas queno comearem com o prompt so na verdade as sadas geradas pelo interpretador.

Observe que existe um segundo prompt indicando a linha de continuao de um comando com mltiplas linhas, oqual pode ser encerrado pela digitao de um linha em branco.

Muitos dos exemplos neste manual, at mesmo aqueles digitados interativamente, incluem comentrios. Comen-trios em Python so delimitados pelo caracter #, e se extendem at o final da linha. Um comentrio podeaparecer no incio da linha, depois de um espao em branco ou cdigo, mas nunca dentro de uma string (literal).O delimitar de comentrio dentro de uma string interpretado como o prprio caracter.

Alguns exemplos:

# primeiro comentrioSPAM = 1 # e esse o segundo comentrio

# ... e ainda um terceiro !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 primrio, >>> .(No deve demorar muito.)

3.1.1 Nmeros

O interpretador atua como uma calculadora bem simples: voc pode digitar uma expresso e o valor resultandoser apresentado aps a avaliao da expresso. A sintaxe da expresso a usual: operadores +, -, * e / funcionamda mesma forma que em outras linguagens tradicionais (por exemplo, Pascal ou C); parnteses podem ser usadospara definir agrupamentos. Por exemplo:

7

>>> 2+24>>> # Isso um comentrio... 2+24>>> 2+2 # e um comentrio na mesma linha de um comando4>>> (50-5*6)/45>>> # Diviso inteira retorna com aredondamento para base... 7/32>>> 7/-3-3

O sinal de igual (=) utilizado para atribuio de um valor a uma varivel. Nenhum resultado exibido at oprximo prompt interativo:

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

Um valor pode ser atribudo a diversas variveis simultaneamente:

>>> x = y = z = 0 # Zero x, y e z>>> x

0>>> y0>>> z

0

H total suporte para ponto-flutuante; operadores com operandos de diferentes tipos convertem o inteiro paraponto-flutuante:

>>> 3 * 3.75 / 1.57.5>>> 7.0 / 23.5

Nmeros complexos tambm so suportados; nmeros imaginrios so escritos com o sufixo j ou J. Nmeroscomplexos com parte real no nula so escritos como (real+imagj), ou podem ser criados pela chamada defuno complex(real, imag).

8 Captulo 3. Uma Introduo Informal a Python

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

Nmeros complexos so sempre representados por dois nmeros ponto-flutuante, a parte real e a parte imaginria.Para extrair as partes de um nmero z, utilize z.real e z.imag.

>>> a=1.5+0.5j>>> a.real1.5>>> a.imag0.5

As funes de converso para ponto-flutuante e inteiro (float(), int() e long()) no funcionam paranmeros complexos no existe maneira correta de converter um nmero complexo para um nmero real. Utilizeabs(z) para obter sua magnitude (como ponto-flutuante) ou z.real para obter sua parte real.

>>> a=3.0+4.0j>>> float(a)Traceback (most recent call last):

File "", line 1, in ?TypeError: cant convert complex to float; use abs(z)>>> a.real3.0>>> a.imag4.0>>> abs(a)5.0

No modo interativo, a ltima expresso a ser impressa atribuda a varivel _. Isso significa que ao utilizar Pythoncomo uma calculadora, muitas vezes mais fcil prosseguir com os clculos da seguinte forma:

>>> tax = 12.5 / 100>>> price = 100.50>>> price * tax12.5625>>> price + _113.0625>>> round(_, 2)113.06

Essa varivel especial deve ser tratada somente para leitura pelo usurio. Nunca lhe atribua explicitamente umvalor do contrrio, estaria se criando uma outra varivel (homnima) independente, que mascararia o comporta-mento mgico da varivel especial.

3.1.2 Strings

Alm de nmeros, Python tambm pode manipular strings, que podem ser expressas de diversas formas. Elaspodem ser delimitadas pos aspas simples ou duplas:

3.1. Utilizando Python Como Uma Calculadora 9

>>> spam eggsspam 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 contm mais de uma linha podem ser construdas de diversas maneiras. Terminadores de linha podemser 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 espaos em branco no inicio da linha so \significativos."

print oi

Observe que terminadores de linha ainda precisam ser embutidos na string usando \n; a quebra de linha aps altima barra de escape seria ignorada. Este exemplo produziria o seguinte resultado:

Esta eh uma string longa contendodiversas linhas de texto assim como voce faria em C.

Observe que os espaos em branco no inicio da linha so significativos.

No entanto, se a tornarmos uma string crua (raw), as sequncias de \n no so convertidas para quebras de linha.Tanto a barra invertida quanto a quebra de linha no cdigo-fonte so includos na string como dados. Portanto, oexemplo:

oi = r"Esta eh uma string longa contendo\n\diversas linhas de texto assim como voce faria em C.\n\

Observe que os espaos em branco no inicio da linha so \significativos."

print oi

teria como resultado:

Esta eh uma string longa contendo\n\diversas linhas de texto assim como voce faria em C.\n\

Observe que os espaos em branco no inicio da linha so \significativos

Ou, strings podem ser delimitadas por pares de aspas trplices: " ou . Neste caso no necessrio embutirterminadores de linha, pois o texto da string ser tratado verbatim.

print """Usage: thingy [OPTIONS]

-h Display this usage message-H hostname Hostname to connect to

"""


produz a seguinte sada:

Usage: thingy [OPTIONS]-h Display this usage message-H hostname Hostname to connect to

O interpretador imprime o resultado de operaes sobre strings da mesma forma que as strings so formatadasna digitao: dentro de aspas, e com caracteres especiais embutidos em escape sequences, para mostar seu valorcom preciso. A string ser delimitada por aspas duplas se ela contm um nico caracter de aspas simples enenhum de aspas duplas, caso contrrio a string ser delimitada por aspas simples. ( O comando print, descritoposteriormente, 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>>> wordHelpA>>>

Duas strings literais justapostas so automaticamente concatenadas; a primeira linha do exemplo anterior poderiater sido escrita como word = HelpA; isso funciona somente com strings literais, no com expressesarbitrrias:

>>> str ing # >> str.strip(str) + ing # >> str.strip(str) ing # >> word[4]A>>> word[0:2]He>>> word[2:4]lp

ndices de fatias slice seguem uma padronizao til; a omisso do primeiro ndice equivale a zero, a omisso dosegundo ndice equivale ao tamanho da string sendo fatiada.

>>> word[:2] # Os dois primeiros caracteresHe>>> word[2:] # Tudo exceto os dois primeiros caractereslpA

Diferentemente de C, strings no podem ser alteradas em Python. Atribuir para uma posio (ndice) dentro deuma string resultar em erro:


>>> word[0] = xTraceback (most recent call last):

File "", line 1, in ?TypeError: object doesnt support item assignment>>> word[:1] = SplatTraceback (most recent call last):

File "", line 1, in ?TypeError: object doesnt support slice assignment

Entretanto, criar uma nova string com o contedo combinado fcil e eficiente:

>>> x + word[1:]xelpA>>> Splat + word[4]SplatA

Aqui est um invariante interessante relacionado a operaes de slice: s[:i] + s[i:] equals s.>>> word[:2] + word[2:]HelpA>>> word[:3] + word[3:]HelpA

ndices de slice degenerados so tratados graciosamente (N.d.T: este termo indica robustez no tratamento deerros): um ndice muito maior que o comprimento trocado pelo comprimento, um limitante superior que sejamenor que o limitante inferior produz uma string vazia como resultado.

>>> word[1:100]elpA>>> word[10:]

>>> word[2:1]

ndices podem ser nmeros negativos, para iniciar a contagem a partir da direita ao invs da esquerda. Porexemplo:

>>> word[-1] # O tlimo caracterA>>> word[-2] # O penltimo caracterp>>> word[-2:] # Os dois ltimos caracterespA>>> word[:-2] # Tudo exceto os dois ltimos caracteresHel

Observe que -0 o mesmo que 0, logo neste caso no se conta a partir da direita!

>>> word[-0] # ( -0 == 0)H

Intervalos fora dos limites da string so truncados, mas no tente isso em indexaes com um nico ndice (queno seja um slice):


>>> word[-100:]HelpA>>> word[-10] # errorTraceback (most recent call last):

File "", line 1IndexError: string index out of range

A melhor maneira de lembrar como slices funcionam pensar nos ndices como ponteiros para os espaos entrecaracteres, onde a beirada esquerda do primeiro caracter 0. Logo a beirada direita do ltimo caracter de umastring 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 fileira de nmeros indica a posio dos ndices 0..5 na string; a segunda fileira indica a posio dosrespectivos ndices negativos. Um slice de i at j consiste em todos os caracteres entre as beiradas i e j, respecti-vamente.

Para ndices positivos, o comprimento do slice a diferena entre os ndices, se ambos esto dentro dos limites dastring, ex, o comprimento de word[1:3] 2.A funo interna (N.d.T: interna == built-in) len() devolve o comprimento de uma string:

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

See Also:Sequncias(../lib/typesseq.html)

Strings, e strings Unicode, descritas na prxima seo, so exemplos de sequncias e suportam as operaescomuns associadas com esses objetos.

Mtodos de Strings(../lib/string-methods.html)

Tanto strings comuns quanto Unicode suportam um grande nmero de mtodos para busca e transformao.

Operaes de Formatao de Strings(../lib/typesseq-strings.html)

As operaes de formatao em que strings 8-bits e Unicode so o operando esquerda do operador % sodescritas em mais detalhes aqui.

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 emanipular dados Unicode (veja http://www.unicode.org/) e se integra bem aos demais objetos strings pr-existentes,de forma a realizar auto-converses quando necessrio.

Unicode tem a vantagem de prover um nico nmero ordinal para cada caracter usado em textos modernos ouantigos. Previamente, havia somente 256 nmeros ordinais. Logo, mapeamentos entre conjuntos de caracterese os 256 nmeros ordinais precisavam ser indexados por cdigos de pgina. Isso levou a uma enorme confusoespecialmente no mbito da internacionalizao (tipicamente escrito como i18n i + 18 caracteres + n)de software. Unicode resolve esses problemas ao definir um nico cdigo de pgina para todos os conjuntos decaracteres.


Criar strings Unicode em Python to simples quanto criar strings normais:

>>> uHello World !uHello World !

O pequeno u antes das aspas indica a criao de uma string Unicode . Se voc desejar incluir caracteres especiaisna string, voc pode faz-lo atravs da codificao Python Unicode-Escape.

>>> uHello\u0020World !uHello World !

O cdigo de escape \u0020 indica a insero do caracter Unicode com valor ordinal 0x0020 (o espao embranco) na posio determinada.Os outros caracteres so interpretados atravs de seus respectivos valores ordinais diretamente para os valoresordinais em Unicode. Se voc possui strings literais na codificao padro Latin-1 que utilizada na maioriado oeste europeu, voc achar conveniente que os 256 caracteres inferiores do Unicode coincidem com os 256caracteres inferiores do Latin-1.

Para experts, existe ainda um modo cru (N.d.T: sem processamento de caracteres escape) da mesma forma queexiste para strings normais. Basta prefixar a string com ur para utilizar a codificao Python Raw-Unicode-Escape. S ser aplicado a converso \uXXXX se houver um nmero mpar de barras invertidas antes do escapeu.

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

O modo cru (N.d.T: raw) muito til para evitar excesso de barras invertidas, por exemplo, em expresses regu-lares.

Alm dessas codificaes padro, Python oferece um outro conjunto de maneiras de se criar strings Unicode sobreuma codificao padro.

A funo interna unicode() prov acesso a todos os Unicode codecs registrados (COders and DECoders).Alguns dos mais conhecidos codecs so : Latin-1, ASCII, UTF-8, and UTF-16. Os dois ltimos so codificaesde tamanho varivel para armazenar cada caracter Unicode em um ou mais bytes. A codificao default ASCII,que trata normalmente caracteres no intervalo de 0 a 127 mas rejeita qualquer outro com um erro. Quando umastring Unicode impressa, escrita em arquivo ou convertida por str(), a codificao padro utilizada.

>>> u"abc"uabc>>> str(u"abc")abc>>> u""u\xe4\xf6\xfc>>> str(u"")Traceback (most recent call last):

File "", line 1, in ?UnicodeEncodeError: ascii codec cant encode characters in position0-2: ordinal not in range(128)

Para se converter uma string Unicode em uma string 8-bits usando uma codificao especfica, basta invocar omtodo encode() de objetos Unicode passando como parmetro o nome da codificao destino. prefervelutilizar nomes de codificao em letras minsculas.


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

Tambm pode ser utilizada a funo unicode() para efetuar a convero de um string em outra codificao.Neste caso, o primeiro parmetro a string a ser convertida e o segundo o nome da codificao almejada. O valorde retorno da funo a string na nova codificao.

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

3.1.4 Listas

Python possui diversas estruturas de dados nativas, utilizadas para agrupar outros valores. A mais verstil delas alista (list), que pode ser escrita como uma lista de valores separados por vrgula e entre colchetes. Mais importante,os valores contidos na lista no precisam ser do mesmo tipo.

>>> a = [spam, eggs, 100, 1234]>>> a

[spam, eggs, 100, 1234]

Da mesma forma que ndices de string, ndices de lista comeam do 0, listas tambm podem ser concatenadas esofrer 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] + [Boo!][spam, eggs, 100, spam, eggs, 100, spam, eggs, 100, Boo!]

Diferentemente de strings, que so imutveis, possvel mudar elementos individuais da lista:

>>> a

[spam, eggs, 100, 1234]>>> a[2] = a[2] + 23>>> a

[spam, eggs, 123, 1234]

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


>>> # 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 funo interna len() tambm se aplica a lista:

>>> len(a)8

possvel aninhar listas (criar listas contendo outras listas), por exemplo:

>>> q = [2, 3]>>> p = [1, q, 4]>>> len(p)3>>> p[1][2, 3]>>> p[1][0]2>>> p[1].append(xtra) # See section 5.1>>> p[1, [2, 3, xtra], 4]>>> q[2, 3, xtra]

Observe que no ltimo exemplo, p[1] e q na verdade se referem ao mesmo objeto! Mais tarde retornaremos asemntica do objeto.

3.2 Primeiros Passos em Direo Programao

Naturalmente, ns podemos utilizar Python para tarefas mais complicadas do que somar dois nmeros. A ttulode exemplificao, ns podemos escrever o incio da sequncia de Fibonacci assim:


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

112358

Este exemplo introduz diversas caractersticas ainda no mencionadas.

A primeira linha contm uma atribuio mltipla: as variveis a e b simultaneamente recebem os novosvalores 0 e 1. Na ltima linha h outro exemplo de atribuio mltipla demonstrando que expresses dolado direito so sempre avaliadas primeiro, antes da atribuio. As expresses do lado direito so avaliadasda esquerda para a direita.

O lao while executa enquanto a condio (aqui:b < 10) permanecer verdadeira. Em Python, como emC, qualquer valor inteiro no nulo considerado verdadeiro (valor true), zero tem valor false. A condiopode ser ainda uma lista ou string, na verdade qualquer sequncia; qualquer coisa com comprimento nonulo tem valor true e sequncias vazias tem valor false. O teste utilizado no exemplo uma simples com-parao. Os operadores padro para comparao so os mesmos de C: < (menor que), > (maior que), ==(igual), = (maior ou igual) and != (diferente).

O corpo do lao identado: identao em Python a maneira de agrupar comandos. Python (ainda!) nopossui facilidades automticas de edio de linha. Na prtica voc ir preparar scripts Python complexosem um editor de texto; a maioria dos editores de texto possui facilidades de identao automtica. Quandocomandos compostos forem alimentados ao interpretador interativamente, devem ser encerrados por umalinha em branco (j que o parser no tem como adivinhar qual a ltima linha do comando). Observe quetoda linha de um mesmo bloco de comandos deve possuir a mesma identao.

O comando print escreve o valor da expresso dada. Ele difere de apenas escrever a expresso no inter-pretador (como foi feito no exemplo da calculadora) ao aceitar mltiplas expresses e strings. Strings soimpressas sem aspas, um espao inserido entre itens de forma a formatar o resultado assim:

>>> i = 256*256>>> print The value of i is, iThe value of i is 65536

Uma vrgula ao final 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 prximo prompt se a ltima linhano foi completada.

3.2. Primeiros Passos em Direo Programao 17

CAPTULO

FOUR

Mais Ferramentas de Controle de Fluxo

Alm do while recm apresentado, Python possui as estruturas usuais de controle de fluxo conhecidas em outraslinguagens, com algumas variaes:

4.1 Construo if

Provavelmente uma das mais conhecidas construes o if. Por exemplo:

>>> x = int(raw_input("Por favor entre com um numero inteiro: "))>>> if x < 0:... x = 0... print Negativo mudou para zero... elif x == 0:... print Zero... elif x == 1:... print Um... else:... print Mais...

Pode haver zero ou mais sees elif. A seo else opcional. A palavra-chave elif uma abreviaopara else if, e til para evitar identao excessiva. Uma sequncia if . . . elif . . . elif . . . substitui asconstrues switch e case encontradas em outras linguagens.

4.2 Construo for

A construo for em Python difere um pouco do que se est acostumado em C ou Pascal. Ao invs de se iterarsobre progresses aritimticas (como em Pascal), ou fornecer ao usurio a habilidade de definir tanto o passo daiterao quanto a condio de parada (como em C), o for de Python itera sobre os itens de uma sequncia (umalista ou uma string), na ordem em que aparecem na sequncia. Por exemplo :

>>> # Medindo algumas strings:... a = [gato, janela, defenestrar]>>> for x in a:... print x, len(x)...

gato 4janela 6defenestrar 11

No seguro modificar a sequncia sobre a qual se baseia o lao de iterao (isto s pode acontecer se a sequnciafor mutvel, isto , uma lista). Se voc precisar modificar a lista sobre a qual se est iterando, por exemplo, para

19

duplicar itens selecionados, voc deve iterar sobre uma cpia da lista ao invs da prpria. A notao de slice bastante conveniente para isso:

>>> for x in a[:]: # faz uma cpia da lista inteira... if len(x) > 6: a.insert(0, x)...

>>> a

[defenestrar, gato, janela, defenestrar]

4.3 A Funo range()

Se voc precisar iterar sobre sequncias numricas, a funo interna range() a resposta. Ela gera listascontendo progresses aritimticas, por exemplo:

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

O ponto de parada fornecido nunca gerado na lista; range(10) gera uma lista com 10 valores, exatamente osndices vlidos para uma sequncia de comprimento 10. possvel iniciar o intervalo em outro nmero, ou alterara razo da progreso (inclusive com passo negativo):

>>> 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 sequncia, combine range() e len() da seguinte forma:

>>> a = [Mary, had, a, little, lamb]>>> for i in range(len(a)):... print i, a[i]...

0 Mary1 had2 a3 little4 lamb

4.4 Clusulas break, continue e else em Laos

O break, como no C, quebra o lao mais interno de um for ou while.

O continue, tambm emprestado do C, continua o prximo passo do lao mais interno.

Laos podem ter uma clusula else, que executada sempre que o lao se encerra por exausto da lista (no casodo for) ou quando a condio se torna falsa (no caso do while), mas nunca quando o lao encerrado por umbreak. Isto exemplificado no prximo exemplo que procura nmeros primos:

20 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:... # loop fell through without finding a factor... print n, is a prime number...

2 is a prime number3 is a prime number4 equals 2 * 25 is a prime number6 equals 2 * 37 is a prime number8 equals 2 * 49 equals 3 * 3

4.5 Construo pass

A construo pass no faz nada. Ela pode ser usada quando a sintaxe exige um comando mas a semntica doprograma no requer nenhuma ao. Por exemplo:

>>> while True:... pass # Busy-wait para interrupo de teclado...

4.6 Definindo Funes

Ns podemos criar uma funo que escreve a srie de Fibonacci at um limite arbitrrio:

>>> 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 funao que acabamos de definir... fib(2000)1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

A palavra-reservada def serve para definir uma funo. Ela deve ser seguida do nome da funo, da lista formalde parmetros entre parnteses e dois pontos.

O corpo da funo deve comear na linha seguinte e deve ser identado. Opcionalmente, a primeira linha do corpoda funo pode ser uma string literal, cujo propsito documentar a funo. Se presente, essa string chama-sedocstring.

Existem ferramentas que utilizam docstrings para produzir automaticamente documentao impressa, on-line, ouainda permitir que o usurio navegue interativamente pelo cdigo. uma boa prrica incluir sempre docstringsem suas funes, portanto, tente fazer disto um hbito.

A execuo da funo gera uma nova tabela de smbolos utilizada para as variveis locais da funo, mais pre-cisamente, toda atribuio a varivel dentro da funo armazena o valor na tabela de smbolos local. Referncias

4.5. Construo pass 21

a variveis so buscadas primeiramente na tabela local, ento na tabela de smbolos global e finalmente na tabelade smbolos interna (built-in). Portanto, no se pode atribuir diretamente um valor a uma varivel global den-tro de uma funo (a menos que se utilize a declarao global antes), ainda que variveis globais possam serreferenciadas livremente.

Os parmetros reais (argumentos) de uma chamada de funo so introduzidos na tabela de smbolos local dafuno chamada, portanto, argumentos so passados por valor (onde valor sempre uma referncia para objeto,no o valor do objeto)1 Quando uma funo chama outra, uma nova tabela de smbolos criada para tal chamada.Uma definio de funo introduz o nome da funo na tabela de smbolos corrente. O valor do nome da funopossui um tipo que reconhecido pelo interpretador como uma funo definida pelo usurio. Esse valor pode seratribudo para outros nomes que tambm podem ser usados como funes. Esse mecanismo serve para renomearfunes:

>>> fib

>>> f = fib>>> f(100)1 1 2 3 5 8 13 21 34 55 89

Voc pode afirmar que fib no uma funo, mas um procedimento. Em Python, assim como em C, procedi-mentos so apenas funes que no retornam valores. Na verdade, falando tecnicamente, procedimentos retornamum valor, ainda que meio chato. Esse valor chamado None ( um nome interno). A escrita do valor None supressa pelo interpretador se ele estiver sozinho. Voc pode verificar isso se quiser.

>>> print fib(0)None

muito simples escrever uma funo que retorna a lista da srie de Fibonacci, ao invs de imprimi-la:

>>> def fib2(n):... """Retorna a lista contendo a serie de Fibonacci ate n"""... result = []... a, b = 0, 1... while b < n:... result.append(b) # veja abaixo... a, b = b, a+b... return result...

>>> f100 = fib2(100) # invoca>>> f100 # escreve resultado[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Este exemplo, como sempre, demonstra algumas caractersticas novas:

A palavra-chave return termina a funo retornando um valor. Se return no for seguido de nada,ento retorna o valor None. Se a funo chegar ao fim sem o uso explcito do return, ento tambm serretornado o valor None.

O trecho result.append(b) chama um mtodo do objeto lista result. Um mtodo uma funoque pertence a um objeto e chamada atravs de obj.methodname, onde obj um objeto qualquer,e methodname o nome de um mtodo que foi definido pelo tipo do objeto. Tipos diferentes definemmtodos diferentes. Sobretudo, mtodos de diferentes tipos podem ser homnimos sem ambiguidade (possvel definir seus prprios tipos de objetos e mtodos, utilizando classes, como ser discutido mais tardeneste tutorial).

1De fato, passagem por referncia para objeto seria uma melhor descrio, pois quando um objeto mutvel for passado, o chamador irperceber as alteraes feitas pelo chamado (como a insero de itens em uma lista).


O mtodo append() mostrado no exemplo, definido para todos objetos do tipo lista. Este mtodopermite a adio de novos elementos lista. Neste exemplo, ele equivalente a result = result +[b], s que append() ainda mais eficiente.

4.7 Mais sobre Definio de Funes

Ainda possvel definir funes com um nmero varivel de argumentos. Existem trs formas que podem sercombinadas.

4.7.1 Parmetros com Valores Default

A mais til das trs especificar um valor default para um ou mais argumentos. Isso cria uma funo que podeser invocada com um nmero menor de argumentos do que quando foi definida.

def ask_ok(prompt, retries=4, complaint=Yes or no, please!):while 1:

ok = raw_input(prompt)if ok in (y, ye, yes): return Trueif ok in (n, no, nop, nope): return Falseretries = retries - 1if retries < 0: raise IOError, refusenik userprint complaint

Essa funo pode ser chamada de duas formas: ask_ok(Do you really want to quit?) ou comoask_ok(OK to overwrite the file?, 2).Este exemplo tambm introduz a keyword in, que verifica se uma sequncia contm ou no um determinadovalor.

Os valores default so avaliados durante a definio da funo, e no escopo em que a funo foi definida:

i = 5

def f(arg = i):print arg

i = 6f()

ir imprimir 5.

Aviso importante: Valores default so avaliados apenas uma vez. Isso faz diferena quando o valor default umobjeto mutvel como uma lista ou dicionrio. Por exemplo, a funo a seguir acumula os argumentos passadosem chamadas subsequentes:

def f(a, L=[]):L.append(a)return L

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

Isso ir imprimir:

4.7. Mais sobre Definio de Funes 23

[1][1, 2][1, 2, 3]

Se voc no quiser que o valor default seja compartilhado entre chamadas subsequentes, pode reescrever a funoassim:

def f(a, L=None):if L is None:

L = []L.append(a)return L

4.7.2 Parmetros na Forma Chave-Valor

Funes tambm podem ser chamadas passando argumentos no formato chave-valor como keyword = value.Por 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", typeprint "-- 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)

porm, existem maneiras invlidas:

parrot() # parmetro exigido faltandoparrot(voltage=5.0, dead) # parmetro no-chave-valor depois de parmetro chave-valorparrot(110, voltage=220) # valor duplicado para mesmo parmetroparrot(actor=John Cleese) # parmetro desconhecido

Em geral, uma lista de argumentos tem que apresentar todos argumentos posicionais antes de qualquer um dosseus argumentos chave-valor, onde as chaves tm que ser escolhidas a partir dos nomes formais dos argumentos.No importante se um dado argumento j possuia valor default ou no. Nenhum argumento deve receber umvalor mais do que uma nica vez. Nomes de parmetros formais correspondendo a argumentos posicionais nopodem ser usados na forma chave-valor em uma mesma chamada. O prximo exemplo ilustra essa limitao.

>>> def function(a):... pass...

>>> function(0, a=0)Traceback (most recent call last):

File "", line 1, in ?TypeError: function() got multiple values for keyword argument a


Quando o ltimo parmetro formal for **name, ele armazenar todos os parmetros efetivamente passados paraa funo, exceto aqueles que no correspondiam a parmetros formais. Isto pode ser combinado com o parmetroformal *name (descrito na prxima sub-seo) que recebe a lista contendo todos argumentos posicionais que nocorrespondiam a parmetros formais. O importante que (*name deve ser declarado antes de **name.) Siga oexemplo:

def cheeseshop(kind, *arguments, **keywords):print "-- Do you have any", kind, ?print "-- Im sorry, were all out of", kindfor arg in arguments: print argprint -*40keys = keywords.keys()keys.sort()for kw in 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 LimburgerIts very runny, sir.Its really very, VERY runny, sir.----------------------------------------

client : John Cleeseshopkeeper : Michael Palinsketch : Cheese Shop Sketch

Note que o mtodo sort() da lista de chaves em keywords chamado antes de exibir o contedo do dicionrio;se isso no fosse feito, eles seriam exibidos em ordem arbitrria.

4.7.3 Listas Arbitrrias de Argumentos

Finalmente, a opo menos frequentemente usada chamar a funo com um nmero arbitrrio de argumentos.Esses argumentos sero encapsulados em uma sequncia (tupla). Antes do nmero varivel de argumentos, zeroou mais argumentos normais podem estar presentes.

def fprintf(file, format, *args):file.write(format % args)

4.7.4 Desempacotando Listas de Argumentos

A situao inversa ocorre quando os argumentos j esto numa lista ou tupla mas necessrio que elas sejamdesempacotadas para uma chamada de funo que requer argumentos separados. Por exemplo, a funo range()espera argumentos separados, start e stop. Se eles no estiverem disponveis separadamente, escreva a chamadade funo com o operador * para retir-los da lista ou tupla:


>>> range(3, 6) # normal call with separate arguments[3, 4, 5]>>> args = [3, 6]>>> range(*args) # call with arguments unpacked from a list[3, 4, 5]

4.7.5 Funes Lambda

Dada a demanda do pblico, algumas caractersticas encontradas em linguagens de programao funcionais (comoLisp) foram adicionadas a Python. Com a palavra-chave lambda, funes curtas e annimas podem ser criadas.Aqui est uma funo que devolve a soma de seus dois argumentos: lambda a, b: a+b. Funes Lambdapodem ser utilizadas em qualquer lugar que exigiria uma funo tradicional. Sintaticamente, funes Lambdaesto restritas a uma nica expresso. Semanticamente, ela so apenas acar sinttico para a definio de funesnormais. Assim como definies de funes aninhadas, funes lambda no podem referenciar variveis de umescopo mais externo:

>>> def make_incrementor(n):... return lambda x: x + n...

>>> f = make_incrementor(42)>>> f(0)42>>> f(1)43

4.7.6 Strings de Documentao

H uma conveno sobre o contedo e formato de strings de documentao.

A primeira linha deve ser sempre curta, representando um consiso sumrio do propsito do objeto. Por brevidade,no deve explicitamente se referir ao nome ou tipo do objeto, uma vez que estas informaes esto disponviespor outros meios (exceto se o nome da funo for o prprio verbo que descreve a finalidade da funo). Essa linhadeve comear com letra maiscula e terminar com ponto.

Se existem mltiplas linhas na string de documentao, a segunda linha deve estar em branco, visulamente sepa-rando o sumrio do resto da descrio. As linhas seguintes devem conter um ou mais pargrafos descrevendo asconvenes de chamada ao objeto, seus efeitos colaterais, etc.O parser do Python no toca na identao de comentrios multi-linha. Portanto, ferramentas que processem stringsde documentao precisam lidar com isso (se desejado). Existe uma conveno para isso. A primeira linha nonula aps a linha de sumrio determina a identao para o resto da string de documentao. A partir da, espaosem branco podem ser removidos de todas as linhas da string.

Aqui est um exemplo de uma docstring multi-linha:


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


CAPTULO

FIVE

Estruturas de Dados

Este captulo descreve alguns pontos j abordados, porm com mais detalhes, e ainda adiciona outros pontosinditos.

5.1 Mais sobre Listas

O tipo list possui mais mtodos. Aqui esto todos os mtodos disponvies em um objeto lista.append(x)

Adiciona um item ao fim da lista; equivalente a a[len(a):] = [x].extend(L)

Extende a lista adicionando no fim todos os elementos da lista passada como parmetro; equivalente aa[len(a):] = L.

insert(i, x)Insere um item em uma posio especificada. O primeiro argumento o ndice do elemento anterior ao queest para ser inserido, assim a.insert(0, x) insere no incio da lista, e a.insert(len(a), x) equivalente a a.append(x).

remove(x)Remove o primeiro item da lista cujo valor x. gerado um erro se este valor no existir.

pop([i])Remove o item na posio dada e o retorna. Se nenhum item for especificado, a.pop() remove e retornao ltimo item na lista. (Os colchetes ao redor de i indicam que o parmetro opcional, no que voc devadigit-los naquela posio. Voc ver essa notao com frequncia na Referncia da Biblioteca Python.)

index(x)Retorna o ndice do primeiro item cujo valor igual ao argumento fornecido em x, gerando erro se estevalor no existe

count(x)Retorna o nmero de vezes que o valor x aparece na lista.

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

29

>>> a = [66.25, 333, 333, 1, 1234.5]>>> print a.count(333), a.count(66.25), a.count(x)2 1 0>>> a.insert(2, -1)>>> a.append(333)>>> a

[66.25, 333, -1, 333, 1, 1234.5, 333]>>> a.index(333)1>>> a.remove(333)>>> a

[66.25, -1, 333, 1, 1234.5, 333]>>> a.reverse()>>> a

[333, 1234.5, 1, 333, -1, 66.25]>>> a.sort()>>> a

[-1, 1, 66.25, 333, 333, 1234.5]

5.1.1 Usando Listas como Pilhas

Os mtodos de lista tornam muito fcil utilizar listas como pilhas, onde o item adicionado por ltimo o primeiroa ser recuperado (poltica ltimo a entrar, primeiro a sair). Para adicionar um item ao topo da pilha, useappend(). Para recuperar um item do topo da pilha use pop() sem nenhum ndice. Por exemplo:

>>> stack = [3, 4, 5]>>> stack.append(6)>>> stack.append(7)>>> stack[3, 4, 5, 6, 7]>>> stack.pop()7>>> stack[3, 4, 5, 6]>>> stack.pop()6>>> stack.pop()5>>> stack[3, 4]

5.1.2 Usando Listas como Filas

Voc pode tambm utilizar uma lista como uma fila, onde o primeiro item adicionado o primeiro a ser recuperado(poltica primeiro a entrar, primeiro a sair). Para adicionar um elemento ao fim da fila utiliza append(). Pararecuperar um elemento do incio da fila use pop() com 0 no ndice. Por exemplo:

30 Captulo 5. Estruturas de Dados

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

Existem trs funes internas que so muito teis sobre listas: filter(), map(), e reduce().filter(function, sequence) retorna uma sequncia consistindo dos itens pertencentes a sequncia para osquais function(item) verdadeiro. If se a sequncia for string ou tuple, o resultado ser sempre do mesmotipo; caso contrrio, ser sempre uma lista. Por exemplo, para computar nmeros primos:

>>> 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 sequncia e retorna a lista de valores retor-nados a cada aplicao. 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 sequncia pode ser passada; a funo a ser aplicada deve possuir tantos parmetros formais quantassequncias forem alimentadas para map, e chamada com o item correspondente de cada sequncia (ou Nonecaso se uma sequncia for menor que a outra). Se None for passado no lugar da funo, ento ser aplicada umafuno que apenas devolve os argumentos recebidos.

>>> seq = range(8)>>> def square(x, y): return x+y...

>>> map(add, seq, seq)[0, 2, 4, 6, 8, 10, 12, 14]

reduce(function, sequence) retorna um nico valor construdo a partir da sucessiva aplicao da funobinria function a todos os elementos da lista fornecida, dois de cada vez. Por exemplo, para computar a soma dos10 primeiros nmeros inteiros:

>>> def add(x,y): return x+y...

>>> reduce(add, range(1, 11))55

Se apenas houver um nico elemento na sequncia fornecida como parmetro, ento seu valor ser retornado. Sea sequncia for vazia uma exceo ser levantada.

5.1. Mais sobre Listas 31

Um terceiro argumento pode ser passado para indicar o valor inicial. Neste caso, reduo de sequncias vaziasretornar o valor inicial. Se a sequncia no for vazia, a reduo se iniciar a partir do valor inicial.

>>> def sum(seq):... def add(x,y): return x+y... return reduce(add, seq, 0)...

>>> sum(range(1, 11))55>>> sum([])0

No use este exemplo de funo para somar: como somar nmeros uma necessidade comum, fornecemos umafuno sum(sequence) que funciona exatamente como essa. New in version 2.3.

5.1.4 Abrangncia de Lista (List Comprehensions)Abrangncia de listas (ou list comprehensions) permitem a criao de listas de forma concisa sem apelar para o usode map(), filter() e/ou lambda. A definio resultante tende a ser mais clara do que o uso das construesfuncionais citadas anteriormente. Cada abrangncia de lista consiste numa expresso seguida da clusula for, eento zero ou mais clusulas for ou if. O resultado ser uma lista proveniente da avaliao da expresso nocontexto das clusulas for e if subsequentes. Se a expresso gerar uma tupla, a mesma deve ser inserida entreparnteses.

>>> freshfruit = [ banana, loganberry , passion fruit ]>>> [weapon.strip() for weapon in freshfruit][banana, loganberry, passion fruit]>>> vec = [2, 4, 6]>>> [3*x for x in vec][6, 12, 18]>>> [3*x for x in vec if x > 3][12, 18]>>> [3*x for x in vec if x < 2][]>>> [[x,x**2] for x in vec][[2, 4], [4, 16], [6, 36]]>>> [x, x**2 for x in vec] # erro - parenteses requerido para tuplas

File "", line 1 in ?[x, x**2 for x in vec]

^

SyntaxError: invalid syntax>>> [(x, x**2) for x in vec][(2, 4), (4, 16), (6, 36)]>>> vec1 = [2, 4, 6]>>> vec2 = [4, 3, -9]>>> [x*y for x in vec1 for y in vec2][8, 6, -18, 16, 12, -36, 24, 18, -54]>>> [x+y for x in vec1 for y in vec2][6, 5, -7, 8, 7, -5, 10, 9, -3]>>> [vec1[i]*vec2[i] for i in range(len(vec1))][8, 12, -54]

Abrangncia de listas muito mais flexvel do que map() e pode ser aplicada a expresses complexas e funesaninhadas:


5.2 O comando del

Existe uma maneira de remover um item de uma lista a partir de seu ndice, ao invs de seu valor: o comandodel. Ele difere do mtodo pop, que retorna o item removido. Ele tambm pode ser utilizado para remover fatias(slices) da lista. Por exemplo:

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]>>> del a[0]>>> a

[1, 66.25, 333, 333, 1234.5]>>> del a[2:4]>>> a

[1, 66.25, 1234.5]

del tambm pode ser utilizado para apagar variveis:

>>> del a

Referenciar a varivel a posteriormente a sua remoo constitui erro (pelo menos at que seja feita uma novaatribuio para ela). Ns encontraremos outros usos para o comando del mais tarde.

5.3 Tuplas e Sequncias

Ns vimos que listas e strings possuem muitas propriedades em comum como indexao e operaes de slicing.Elas so dois dos exemplos possveis de sequncias. Como Python uma linguagem em evoluo, outros tiposde sequncias podem ser adicionados. Existe ainda um outro tipo de sequncia j presente na linguagem: a tupla(tuple).Uma tupla consiste em uma sequncia imutvel de valores separados por vrgulas.

>>> 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 so sempre envolvidas por parnteses. Na criao, tuplas podem serenvolvidas ou no por parnteses, desde que o contexto no exija os parnteses (como no caso da tupla pertencera uma expresso maior).Tuplas podem ser usadas de diversas formas: pares ordenados, registros de empregados em uma base de dados,etc. Tuplas, assim como strings, so imutveis. No possvel atribuir valores a itens individuais de uma tupla(voc pode simular o mesmo efeito atravs de operaes de fatiamento e concatenao). Tambm possvel criartuplas contendo objetos mutveis, como listas.Um problema especial a criao de tuplas contendo 0 ou 1 itens: a sintaxe tem certos truques para acomodarestes casos. Tuplas vazias so construdas por uma par de parnteses vazios. E uma tupla unitria construda porum nico valor e uma vrgula entre parnteses (sem a vrgula a tupla no ser gerada!). Feio, mas efetivo:

5.2. O comando del 33

>>> empty = ()>>> singleton = hello, # >> len(empty)0>>> len(singleton)1>>> singleton(hello,)

O comando t = 12345, 54321, hello! um exemplo de empacotamento em tupla (tuple packing):os valores 12345, 54321 e hello! so empacotados juntos em uma tupla. A operao inversa tambm possvel:

>>> x, y, z = t

Isto chamado de desempacotamento de sequncia (sequence unpacking), e requer que a lista de variveis do ladoesquerdo corresponda ao comprimento da sequncia direita. Sendo assim, a atribuio mltipla um caso deempacotamento e desempacotamento de tupla.

Existe ainda uma certa assimetria aqui: empacotamento de mltiplos valores sempre cria tuplas, mas o desempa-cotamento funciona para qualquer sequncia.

5.4 Sets

Python tambm inclui um tipo de dados para conjuntos (sets). Um conjunto uma coleo desordenada dedados, sem elementos duplicados. Usos comuns para isso incluem verificaes da existncia de objetos em outrossequncias e eliminao de items duplicados. Conjuntos tambm suportam operaes matemticas como unio,interseo, diferena e diferena simtrica.

Uma pequena demonstrao:

>>> basket = [apple, orange, apple, pear, orange, banana]>>> fruits = set(basket) # create a set without duplicates>>> fruitsset([orange, pear, apple, banana])>>> orange in fruits # fast membership testingTrue>>> crabgrass in fruitsFalse

>>> # Demonstrate set operations on unique letters from two words...

>>> a = set(abracadabra)>>> b = set(alacazam)>>> a # unique letters in aset([a, r, b, c, d])>>> a - b # letters in a but not in bset([r, d, b])>>> a | b # letters in either a or bset([a, c, r, d, b, m, z, l])>>> a & b # letters in both a and bset([a, c])>>> a ^ b # letters in a or b but not bothset([r, d, b, m, z, l])


5.5 Dicionrios

Outra estrutura de dados interna de Python, e muito til, o dicionrio. Dicionrios so tambm chamados dememria associativa, ou vetor associativo . Diferentemente de sequncias que so indexadas por inteiros,dicionrios so indexados por chaves (keys), que podem ser de qualquer tipo imutvel (como strings e inteiros).Tuplas tambm podem ser chaves se contiverem apenas strings, inteiros ou outras tuplas. Se a tupla contiver,direta ou indiretamente, qualquer valor mutvel no poder ser chave. Listas no podem ser usadas como chavesporque so mutveis.

O melhor modelo mental de um dicionrio um conjunto no ordenado de pares chave-valor, onde as chaves sonicas em uma dada instncia do dicionrio.

Dicionrios so delimitados por : {}. Uma lista de pares chave:valor separada por vrgulas dentro desse delimita-dores define a constituio inicial do dicionrio. Dessa forma tambm ser impresso o contedo de um dicionrioem uma seo de depurao.

As principais operaes em um dicionrio so armazenar e recuperar valores a partir de chaves. Tambm possvelremover um par chave:valor com o comando del. Se voc armazenar um valor utilizando uma chave j presente,o antigo valor ser substitudo pelo novo. Se tentar recuperar um valor dada uma chave inexistente ser geradoum erro.

O mtodo keys() do dicionrio retorna a lista de todas as chaves presentes no dicionrio, em ordem arbitrria (sedesejar orden-las basta aplicar o mtodo sort() na lista devolvida). Para verificar a existncia de uma chave,utilize o mtodo has_key() do dicionrio ou a keyword in.A seguir, um exemplo de uso do dicionrio:

>>> tel = {jack: 4098, sape: 4139}>>> tel[guido] = 4127>>> tel{sape: 4139, guido: 4127, jack: 4098}>>> tel[jack]4098>>> del tel[sape]>>> tel[irv] = 4127>>> tel{guido: 4127, irv: 4127, jack: 4098}>>> tel.keys()[guido, irv, jack]>>> tel.has_key(guido)True>>> guido in telTrue

A construtora dict() produz dicionrios diretamente a partir de uma lista de chaves-valores, armazenadas comotuplas. Quando os pares formam um padro, list comprehensions podem especificar a lista de chaves-valores deforma mais compacta.

>>> dict([(sape, 4139), (guido, 4127), (jack, 4098)]){sape: 4139, jack: 4098, guido: 4127}>>> dict([(x, x**2) for x in (2, 4, 6)]) # use a list comprehension{2: 4, 4: 16, 6: 36}

Mais adiante no tutorial aprenderemos sobre Geradores, que so ainda mais adequados para fornecer os pareschave-valor para dict().Quando chaves so apenas strings, mais fcil especificar os pares usando argumentos chave-valor:

>>> dict(sape=4139, guido=4127, jack=4098){sape: 4139, jack: 4098, guido: 4127}

5.5. Dicionrios 35

5.6 Tcnicas de Lao

Ao percorrer um dicionrio com um lao, a chave e o valor correspondente podem ser obtidos simultaneamentecom o mtodo iteritems().

>>> knights = {gallahad: the pure, robin: the brave}>>> for k, v in knights.iteritems():... print k, v...

gallahad the purerobin the brave

Ao percorrer uma sequncia qualquer, o ndice da posio atual e o valor correspondente podem ser obtidossimultaneamente usando a funo enumerate().

>>> for i, v in enumerate([tic, tac, toe]):... print i, v...

0 tic1 tac2 toe

Para percorrer duas ou mais sequncias simultaneamente com o lao, os items podem ser agrupados com a funozip().

>>> questions = [name, quest, favorite color]>>> answers = [lancelot, the holy grail, blue]>>> for q, a in zip(questions, answers):... print What is your %s? It is %s. % (q, a)...

What is your name? It is lancelot.What is your quest? It is the holy grail.What is your favorite color? It is blue.

Para percorrer uma sequncia em ordem reversa, chame a funo reversed() com a sequncia na ordemoriginal.

>>> for i in reversed(xrange(1,10,2)):... print i...

97531

Para percorrer uma sequncia de maneira ordenada, use a funo sorted(), que retorna uma lista ordenada comos items, mantendo o original inalterado.

>>> basket = [apple, orange, apple, pear, orange, banana]>>> for f in sorted(set(basket)):... print f...

applebananaorangepear


5.7 Mais sobre Condies

As condies de controle utilizadas no while e if podem conter quaisquer operadores, no apenas comparaes.

Os operadores de comparao in e not in verificam se um valor ocorre (ou no ocorre) em uma dada sequncia.Os operadores is e is not comparam se dois objetos so na verdade o mesmo objetos; o que s significativono contexto de objetos mutveis, como listas. Todos operadores de comparao possuem a mesma precedncia,que menor do que a prioridade dos operadores numricos.

Comparaes podem ser encadeadas: Por exemplo a < b == c testa se a menor que b e ainda por cima se b igual a c.

Comparaes podem ser combinadas atravs de operadores booleanos and e or, e negados atravs de not. Estespossuem menor prioridade que os demais operadores de comparao. Entre eles, not o de maior prioridade eor o de menor. Dessa forma, a condio A and not B or C equivalente a (A and (not B)) or C.Naturalmente, parnteses podem ser usados para expressar o agrupamento desejado.Os operadores booleanos and and or so tambm operadores atalhos : seus argumentos so avaliados da esquerdapara a direita, e a avaliao pra quando o resultado se torna conhecido. Por exemplo, se A e C so verdadeiros masB falso, ento A and B and C no retorna a expresso C. Em geral, quando usado sobre valores genricos eno como booleanos, o valor de retorno de um operador atalho o ltimo valor avaliado na expresso.

possvel atribuir o resultado de uma comparao ou outra expresso booleana para uma varivel. Por exemplo:>>> string1, string2, string3 = , Trondheim, Hammer Dance>>> non_null = string1 or string2 or string3>>> non_nullTrondheim

Observe que em Python, diferentemente de C, atribuio no pode ocorrer dentro de uma expresso. Progra-madores C podem resmungar, mas isso evita toda uma classe de problemas frequentemente encontrados em pro-gramas C: digitar = numa expresso quando a inteno era ==.

5.8 Comparando Sequncias e Outros Tipos

Objetos sequncia podem ser comparados com outros objetos sequncia, desde que o tipo das sequncias seja omesmo. A comparao utiliza a ordem lxicografica : primeiramente os dois primeiros itens so comparados, ese diferirem isto determinar o resultado da comparao, caso contrrio os prximos dois itens sero comparados,e assim por diante at que se tenha exaurido alguma das sequncias. Se em uma comparao de itens, os mesmosforem tambm sequncias (aninhadas), ento disparada recursivamente outra comparao lxicografica. Setodos os itens da sequncia forem iguais, ento as sequncias so ditas iguais. Se uma das sequncias umasubsequncia da outra, ento a subsequncia a menor (operador

CAPTULO

SIX

Mdulos

Se voc sair do interpretador Python e entrar novamente, todas as definies de funes e variveis sero perdidas.Logo, se voc desejar escrever um programa que dure melhor preparar o cdigo em um editor de textos. Quandoestiver pronto, dispare o interpretador sobre o arquivo-fonte gerado. Isto se chama gerar um script.

A medida que seus programas crescem, pode ser desejvel dividi-los em vrios arquivos para facilitar amanuteno. Talvez voc at queira reutilizar uma funo sem copiar sua definio a cada novo programa.

Para permitir isto, Python possui uma maneira de depositar definies em um arquivo e posteriormente reutiliz-las em um script ou seo interativa do interpretador. Esse arquivo denominado mdulo. Definies de ummdulo podem ser importadas por outros mdulos ou no mdulo principal.

Um mdulo um arquivo contendo definies e comandos Python. O nome do arquivo recebe o sufixo .py.Dentro de um mdulo, seu nome (uma string) est disponvel na varivel global __name__. Por exemplo, useseu editor de textos favorito para criar um arquivo chamado fibo.py no diretrio corrente com o seguinte contedo:

# Mdulo Sequncias de Fibonacci

def fib(n): # write Fibonacci series up to na, b = 0, 1while b < n:

print b,a, b = b, a+b

def fib2(n): # return Fibonacci series up to nresult = []a, b = 0, 1while b < n:

result.append(b)a, b = b, a+b

return result

Agora inicie o interpretador e importe o mdulo da seguinte forma:

>>> import fibo

Isso no incorpora as funes definidas em fibo diretamente na tabela de smbolos corrente, apenas coloca onome do mdulo l. Atravs do nome do mdulo voc pode acessar as funes:

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

39

Se voc pretende utilizar uma funo frequentemente, possvel atribuir a ela um nome local:

>>> fib = fibo.fib>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377

6.1 Mais sobre Mdulos

Um mdulo pode conter tanto comandos como definies. Os comandos servem ao propsito de inicializar omdulo, sendo executados apenas na primeira vez em que o mesmo importado.1

Cada mdulo possui sua prpria tabela de smbolos, que usada como tabela de smbolos global por todas asfunes definidas no prprio mdulo. Portanto, o autor do mdulo pode utilizar variveis globais no mdulo semse preocupar com coliso de nomes acidental com as variveis globais de usurio.

Por outro lado, se voc sabe o que est fazendo, possvel o acesso as variveis globais do mdulo atravs damesma notao. O que permite o acesso s funes do mdulo: modname.itemname.

Mdulos podem ser importados por outros mdulos. costume, porm no obrigatrio, colocar todos os coman-dos de importao (import) no incio do mdulo (ou script, se preferir).Existe uma variante do comando import statement que importa nomes de um dado mdulo diretamente para atabela do mdulo importador. Os nomes do mdulo importado so adicionados a tabela de smbolos global domdulo 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 no introduz o nome do mdulo importado na tabela de smbolos local, mas sim o nome da funo direta-mente.

Existe ainda uma variante que permite importar diretamente todos os nomes definidos em um dado mdulo.

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

Quando um mdulo denominado spam importado, o interpretador busca por um arquivo chamado spam.pyno diretrio corrente, depois na lista de diretrios especificados pela varivel de ambiente PYTHONPATH. Estaltima possui a mesma sintaxe da varivel de ambiente PATH, isto , uma lista de caminhos. Quando PYTHON-PATH no existir, ou o arquivo no for achado nesta lista, a busca continua num caminho que depende da insta-lao. No caso do UNIX esse caminho quase sempre .:/usr/local/lib/python.

De fato, mdulos so buscados pela lista de caminhos especificados na varivel sys.path inicializada com oscaminhos citados acima, o que permite aos programas Python manipularem o processo de busca de mdulos sedesejado.Note que devido ao fato do diretrio contendo o script executado estar no caminho de busca, importante que oscript no tenha o mesmo nome que um mdulo da biblioteca padro, ou Python vai tentar carregar o script como

1Na verdade, definies de funes so tambm comandos que so executados. A execuo desses comandos colocar o nome dafuno na tabela de smbolos global do mdulo.

40 Captulo 6. Mdulos

tal quando aquele mdulo for importado. Na maior parte das vezes essa no a inteno e resultar em um erro.Veja a seo 6.2,Mdulos Padro, para mais detalhes.

6.1.2 Arquivos Python Compilados

Um fator que agiliza a carga de programas curtos que utilizam muitos mdulos padro a existncia de um arquivocom extenso .pyc no mesmo diretrio do fonte .py. O arquivo .pyc contm uma verso byte-compilada dofonte .py. A data de modificao de .py armazenada dentro do .pyc, e verificada automaticamente antes dautilizao do ltimo. Se no conferir, o arquivo .pyc existente re-compilado a partir do .py mais atual.

Normalmente, no preciso fazer nada para gerar o arquivo .pyc. Sempre que um mdulo .py compilado comsucesso, feita uma tentativa de se escrever sua verso compilada para o .pyc. No h gerao de erro se essatentativa falha. Se por qualquer razo o arquivo compilado no inteiramente escrito em disco, o .pyc resultanteser reconhecido como invlido e, portanto, ignorado. O contedo do .pyc independente de plataforma, assimum diretrio de mdulos Python pode ser compartilhado por diferentes arquiteturas.

Algumas dicas dos experts:

Quando o interpretador Python invocado com a diretiva -O, cdigo otimizado gerado e armazenadoem arquivos .pyo. O otimizador corrente no faz muita coisa, ele apenas remove construes asserte instrues SET_LINENO. Quando o -O utilizado, todo bytecode otimizado. Arquivos .pyc soignorados e arquivos .py so compilados em bytecode otimizado.

Passando dois flags -O ao interpretador (-OO) ir forar o compilador de bytecode a efetuar otimizaes ar-riscadas que poderiam em casos raros acarretar o mal funcionamento de programas. Presentemente, apenasstrings __doc__ so removidas do bytecode, proporcionando arquivos .pyo mais compactos. Uma vezque alguns programas podem supor a existncia das docstrings, melhor voc s se utilizar disto se tiversegurana de que no acarretar nenhum efeito colateral negativo.

Um programa no executa mais rpido quando lido de um arquivo .pyc ou de um .pyo em comparaoa quando lido de um .py. A nica diferena que nos dois primeiros casos o tempo de carga do programa menor.

Quando um script executado diretamente a partir de seu nome da linha de comando, no so geradas asformas compiladas deste script em arquivos .pyo ou .pyc. Portanto, o tempo de carga de um script podeser melhorado se transportarmos a maioria de seu cdigo para um mdulo e utilizarmos outro script apenaspara o disparo. possvel disparar o interpretador diretamente sobre arquivos compilados.

Na presena das formas compiladas (.pyc e.pyo) de um script, no h necessidade da presena da formatextual(.py). Isto til na hora de se distribuir bibliotecas Python dificultando prticas de engenhariareversa.

O mdulo compileall pode criar arquivos .pyc (ou .pyo quando usado -O) para todos os mdulosem um dado diretrio.

6.2 Mdulos Padro

Python possui um biblioteca padro de mdulos, descrita em um documento em separado, a Python LibraryReference (doravante Library Reference). Alguns mdulos esto embutidos no interpretador; estes possibilitamacesso a operaes que no so parte do ncleo da linguagem, seja por eficincia ou para permitir o acesso achamadas de sistema. O conjunto presente destes mdulos configurvel, por exemplo, o mdulo amoebas est disponvel em sistemas que suportam as primitivas do Amoeba. Existe um mdulo que requer especialateno: sys, que embutido em qualquer interpretador Python. As variveis sys.ps1 e sys.ps2 definem asstrings utilizadas como prompt primrio e secundrio:

6.2. Mdulos Padro 41

>>> import sys>>> sys.ps1>>>

>>> sys.ps2...

>>> sys.ps1 = C> C> print Yuck!Yuck!C>

Essas variveis s esto definidas se o interpretador est em modo interativo.

A varivel sys.path contm uma lista de strings que determina os caminhos de busca de mdulos conhecidospelo interpretador. Ela inicializada para um caminho default determinado pela varivel de ambiente PYTHON-PATH ou por um valor default interno se a varivel no estiver definida. Voc pode modific-la utilizando asoperaes tpicas de lista, por exemplo:

>>> import sys>>> sys.path.append(/ufs/guido/lib/python)

6.3 A Funo dir()

A funo interna dir() utilizada para se descobrir que nomes so definidos por um mdulo. Ela retorna umalista ordenada de strings:

>>> import fibo, sys>>> dir(fibo)[__name__, fib, fib2]>>> dir(sys)[__displayhook__, __doc__, __excepthook__, __name__, __stderr__,__stdin__, __stdout__, _getframe, api_version, argv,builtin_module_names, byteorder, callstats, copyright,displayhook, exc_clear, exc_info, exc_type, excepthook,exec_prefix, e

Apostila Python.pdf

Documents

Transcript of Apostila Python.pdf