python na prática

Python na Pr´ Pratica: a´ tica: Um curso curso objetivo objet ivo de de programac programaç ao a˜ o em Python http://www.async.com.br/projects/pnp/

Christian Christian Robottom Reis Async Open Source [email protected]

Abril de 2004

´ Conteudo 1

Introduç ˜ ao 1.1

1.2

2

1

O que e´ Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2

1.1.1

Linguagem interpretada . . . . . . . . . . . . . . . . . . . . . . . . . .

2

1.1. 1.1.2 2

Tipag ipagem em dinˆ dinâmica . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3

1.1.3 1.1.3

Controle Controle de bloco bloco por por inden indentac taç a˜ o . . . . . . . . . . . . . . . . . . . . .

3

1.1.4

Tipos de alto n´ıvel . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

1.1.5 1.1.5

Orientac Orientaç a˜ o a objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5

Por que Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5

Pyth ython basic a´ s ico: o: invocac invo caç ˜ ao, tipos, operadores e estruturas

6

2.1

Executand tando o o inte interp rpre reta tad dor Pytho ython n inte interrativ tivamen mente . . . . . . . . . . . . . . . .

6

2.2

Criando um programa e executando-o . . . . . . . . . . . . . . . . . . . . . . .

7

2.3 2.3

Tipos ipos,, vari´ ariáveis e valores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8

2.3. 2.3.1 1

Tipos ipos num´ numéricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8

2.3.2

Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9

2.3.3

Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.3.4

Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

2.3. 2.3.5 5

Dici Dicion´ onários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

12

2.4

Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 2.4.1 2.4.1

Operad Operadore oress aritm´ aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.4.2

Operadores sobre cadeias de bits . . . . . . . . . . . . . . . . . . . . . . 15

2.4.3

Operadores Operadores de atribuiç a˜ o . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1

2.5

2.6

3

4

5

1

Operadores condicionais . . . . . . . . . . . . . . . . . . . . . . . . . .

16

2.4. 2.4.5 5

Oper Operad ador ores es lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.4.6 2.4.6

Substituic Substituiç ao a˜ o em strings: o operador % . . . . . . . . . . . . . . . . . . . 18

Estruturas de controle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.5.1 2.5.1

Condicion Condicional: al: a instruc instruç ao a˜ o if . . . . . . . . . . . . . . . . . . . . . . . . 20

2.5.2

Laço ¸o iterativo: for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.5.3

Laço ¸o condicional: while . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.5.4 2.5.4

Excec Exceç o˜ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Func Funç o˜ es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 2.6. 2.6.1 1

Sint Sintax axee básica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.6.2

Truques com argumentos . . . . . . . . . . . . . . . . . . . . . . . . . .

26

2.7

Modulos ´ e o comando import . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2.8

Strings de documentaç a˜ o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Funç ˜ oes pr´ pre´ -definidas

31

3.1

Manipulac Manipulaç ao a˜ o de arquivos: a func fu nç ao a˜ o open() . . . . . . . . . . . . . . . . . . . . 33

3.2

Leitu Leitura ra do teclad teclado: o: raw input()

. . . . . . . . . . . . . . . . . . . . . . . . 34

Orientaç ˜ ao a Objetos

34

4.1

Conceitos de orientaç a˜ o a objetos . . . . . . . . . . . . . . . . . . . . . . . . . .

34

4.2

Objeto Objetos, s, classe classess e instˆ instâncias . . . . . . . . . . . . . . . . . . . . . . . . . . . .

35

4.3

Heranç a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

38

4.4

Introspec Introspeccç ao a˜ o e reflexão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

Algu lguns mo´ dulos importantes 5.1

6

2.4.4

42

Mo´ dulos independentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Fechamento

43

44

Introduç ˜ ao

Este tutorial foi criado para apoiar um curso básico asico da linguagem l inguagem de programac p rogramaç ao a˜ o Python. Em especial, ele tem duas caracter´ caracter´ısticas: ısticas: primeiro, foi escrito originalmente em portuguˆ portugu es, eˆ s, o que e´ raro para um livro técnico ecnico nesta area. a´ rea. Segundo Segundo,, ele é indicado para quem já possui alguma experiência encia em programaç ao, a˜ o, mas que deseja uma noç ão a o prática atica do por que e de como usar Python para programar, sem ter que navegar por horas entre livros e manuais. Uma observac obser vaç ao: a˜ o: este tutorial não ao e´ um guia aprofundado, e nem um manual de referência. encia. A documenta docum entacç ao a˜ o dispon´ disp on´ıvel ıvel em http://www.python.org/docs/ e´ excelente (e melhor do que muitos dos livros publicados sobre Python), e serve de referência referência para os aspectos parti-

2

culares da linguagem.

Conve onvenc nç ˜ oes e Formato Este tutorial assume Python versão ao 2; a versão ao mais recente e´ a 2.3.3. O texto t exto se baseia em um grande conjunto de exemplos, exemplos, que aparecem aparecem indentados em uma seç ão distinta, em uma fonte de largura fixa. Os exemplos, de forma geral, descrevem precisamente a sa´ıda ıda produzida ao digitar os comandos interativamente. Definiç oes o ˜ es importante importantess são ao introduzidas em negrito. Nome Nomess de vari´ ariáveis aveis e expressões o es de código odigo vêm em em uma fonte diferente, com serifa. Quanto ao idioma, os termos em inglês es mais comuns são ao utilizados, com uma explicaç ao a˜ o ´ importante que os termos em inglês prévia evia do que significam. E es sejam conhecidos, porque são ao utilizados correntemente na bibliografia e em discussões oes com outros programadores.

1.1

O que e´ Python?

Python e´ uma linguagem de programaç ao a˜ o1 . Em outras palavras palavras,, e sendo simples simples ao extremo, extremo, usamos Python para escrever escrever software. Esta linguagem tem alguns pontos que a tornam especial:

• E´ uma linguagem interpretada . • Não a o há pré-decl e-d eclara aracç ao a˜ o de variáveis, aveis, e os tipos das variáveis aveis são ao determinados dinamicamente.

• O controle de bloco e´ feito apenas por inden nd enta tacç ˜ ao; n ao a˜ o há delimitadores do tipo BEGIN e END ou { e }. • Oferece tipos de alto n´ n´ıvel ıvel: strings, listas, tuplas, dicionários, arios, arquivos, arquivos, classes. • E´ orientada a objetos; aliás, as, em Python, tudo é um objeto. Nas próximas oxim as seç oes o˜ es estes aspectos são ao discutidos em detalhes.

1.1.1 1.1.1

Linguag Linguagem em interpre interpretada tada

Linguagens de programaç ao a˜ o são ao freqüentemente uentemente classificadas classificadas como como compiladas compiladas ou interpretadas. interpretadas. o´ digo-fonte ) do programa e´ lido por um programa chamado comNas compiladas, o texto (ou codigo-fonte pilador, que cria um arquivo binário, ario, executável avel diretamente pelo hardware da plataforma-alvo. Exemplos deste tipo de linguagem são ao C ou Fortran. A compilac compi laç ao a˜ o e exec e xecuc uç ao a˜ o de um programa simples em C segue algo como: % cc he hell llo. o.c c -o he hell llo o % ./hell ./hello o Hello Hello World World 1

Python é as a` s vezes classifi cado como linguagem de scripting, um termo com o qual n ão concordo concordo muito, já que Python Python é de uso geral, podendo ser ser usada para criar qualquer tipo de software. O termo script geralmente se refere a programas escritos em linguagens interpretadas que automatizam tarefas ou que ‘conectam’ programas distintos.

3

onde cc e´ o programa compilador, compilador, hello.c e´ o arqu arquiv ivo o de código-fonte, odigo-fonte, e o arquivo arquivo criado, hello, e´ um execut´ executável avel bin ario. a´ rio. Em contrapartida, programas escritos em linguagens interpretadas não a o são ao convertidos em um arquivo execut executavel. a´ vel. Eles são ao executados utilizando um outro programa, o interpretador, que leˆ o código-fonte odigo-fonte e o interpreta diretamente, diretament e, durante dur ante a sua execuç ão. ao. Exemplos de linguagem interpreta interpretada da incluem o BASIC BASIC tradicional, tradicional, Perl e Python. Python. Para Para execut executar ar um programa programa Python contido no arquivo hello.py, por exemplo, utiliza-se algo como: % python python hello. hello.py py Hello Hello World World

Note que o programa que executamos diretamente é o interpretador python, fornecendo como parâmetro ametro o arquivo com código-fonte odigo-fonte hello.py. Não a o há o passo de geraç ao ão de executável; avel; o interpretador transforma o programa especificado à medida em que e´ executado. executado.

1.1.2 1.1.2

Tipag Tipagem em din ˆ din âmica amica

a´ vel, que e´ uma Um dos conceitos básicos asic os em program pr ogramac aç ao a˜ o e´ a vari avel u ma associac asso ciaç ao a˜ o entre um nome e um valor. Ou seja, abaixo, neste fragmento na linguagem C: int a; int a = 1;

temos uma variável avel com o nome a sendo declarada, com tipo inteiro e contendo o valor 1. Em Python, Python, n ao a˜ o precisamos declarar variáveis, aveis, nem seus tipos: >>> a = 1

seria seri a a instr i nstruc uç ao a˜ o equivalente; define uma variável avel com o valor 1, que é um valor inteiro.

din âmica amica: o tip Pyth Python on poss possui ui o que que e´ conhe conhecid cido o como como tipagem din ˆ tipo ao qua qual a variável avel est´ está asso asso-ciada pode variar durante a execuç ão ao do programa programa.. Não ao quer dizer que não ao exista exi sta tipo t ipo espec´ e spec´ıfico ıfico definido (a chamada tipagem fraca): embora em Python não ao o declaremos explicitamente, as variáveis aveis sempre assumem um único unico tipo em um determinado momento. >>> a = 1 >>> type(a) >>> a = "1" >>> type(a type(a) ) ’str’> >>> a = 1.0 >>> type(a type(a) ) ’float’>

˜ # a func ¸ao a o ty type pe() () reto retorn rna a o ti tipo po ´ # associado a uma vari avel avel

Tipagem dinâmica, amica, al´ al em e´ m de reduzir a quantidade de planejamento prévio evio (e digitac digi taç ao!) a˜ o!) para escrever um programa, e´ um mecanismo importante para garantir a simplicidade e flexibilidade oes Python. Como os tipos dos argumentos não das funç ˜ a o são ao explicitamente declarados, não a o há restr res tric iç ao a˜ o sobre o que pode ser fornecido como parâmetro. ametro. No exemplo exemplo acima acima,, s ao a˜ o fornecidos argumentos de tipos diferentes a` mesma mesm a funç ao a˜ o type , que retorna o tipo deste argumento. 4

1.1.3

Controle de bloco por indentac indentaç ˜ ao

Na maior parte das linguagens, há instruc inst ruç oes o˜ es ou s´ımbolos ımbolos espec´ıficos ıficos que delimitam delimi tam blocos de codigo o´ digo – os blocos que compõem oem o conteúdo udo de um laç o ou express˜ express ao ão condicional, por exemplo. Em C: if (a < 0) { /* bloco de c ´ o digo odig o */ }

ou em Fortran:

C

if (a .l .lt. t. 0) the hen n ´ bloco de c odigo odigo endif

os blocos são ao delimitados explicitamente — em C por chaves, e em Fortran pelo par then e endif. Em Pyth Python on,, bloc blocos os de código odigo são ao demarcados demarcados apenas por espaços ¸os formando uma inden in dentac taç ao a˜ o visual: ´ " pri rint nt "O val alor or de a e if a == 0: print print "zero" "zero" else: prin pr int t a

Esta propriedade faz com que o código odigo seja muito claro e leg´ıvel ıvel — afinal, garante que a inden in dentac taç ao a˜ o esteja sempre correta — porém em requer costume e um controle mais formal 2 .

1.1.4 1.1.4

Tipos Tipos de alto alto n´ıvel ıvel

Al´ Alem e´ m dos tipos básicos asicos (inteiros, (inteiros, numeros u´ meros de ponto flutuante flutuante,, booleanos booleanos), ), alguns alguns tipos préedeterminados determin ados em Python Py thon merecem m erecem atenc at enç ao a˜ o especial:

Listas: como um vetor em outras linguagens, a lista é um conjunto (ou seq ¨ seq ü ência encia) de valores acessados ( indexados) por um ´ındice ındice num´ numerico, e´ rico, inteiro, começando ¸ando em zero. A lista em Python pode armazenar valores de qualquer tipo. >>> a = ["A", "B", "C", 0, 1, 2] >>> >> > pr prin int t a[ a[0] 0] A >>> >> > pr prin int t a[5] a[5] 2 2

Por exemplo, é importante convencionar se a indentaç ão será ser á feita por uma tabulaç ão ou por um n úmero determinado de espaç os, j á que todos editando um mesmo módulo Python devem usar o mesmo padr ão.

5

Tuplas: tuplas tuplas s˜ sao a˜ o também em seqüˆ uencias eˆ ncias de elementos arbitrários; arios; se comportam como listas com imutaveis a´ veis: uma vez criadas não a excec exc eç ao a˜ o de que são ao imut´ ao podem ser alteradas. Strings: a cadei cadeiaa de caracte caracteres res,, uma forma forma de dado muito muito comum comum;; a string string Python Python á uma seqüˆ uencia eˆ ncia imut´ imutavel, a´ vel, alocada dinamicamente, dinamicam ente, sem restriç ao a˜ o de tamanho. Dicion´ Dicionarios: a´ rios: dicionários arios são ao seqüˆ uencias eˆ ncias que podem utilizar util izar ´ındices ındices de tipos variados, variados, bastando que estes ´ındices ındices sejam imutáveis aveis (números, umeros, tuplas e strings, por exemplo) exemplo).. Dicion´ Dicionários arios são ao conhecidos em outras linguagens como arrays associativos ou hashes. >>> au >>> auto tor r = {" {"no nome me" " : "C "Chr hris isti tian an", ", "i "ida dade de": ": 28 28} } >>> print print autor["no autor["nome"] me"] Christian >>> print print autor["id autor["idade"] ade"] 28

Arquivo: Python Python possui possui um tipo pré-definido e-definido para manipular manipular arquivos; arquivos; este tipo permite que seu conteúdo udo seja facilmente lido, alterado e escrito. Classes Classes e Inst ˆ Inst âncias: ancias: classes classes s˜ s ao a˜ o estruturas estrutu ras especiais que servem para apoiar programac pro gramaç ão ao orientada a objetos; determinam um tipo t ipo customizado com dados e operaç ões oes particulares. Instâncias ancias são ao as expressões oes concretas destas classes. Orientaç ão ao a objetos em Python é descrita em maiores maior es detalhes detal hes na seç ao a˜ o 4. 1.1.5

Orientaç ˜ ao a objetos

Orien Or ientac taç ao a˜ o a objetos (OO) é uma forma conceitual de estruturar um programa: ao invés es de definirmos variáveis aveis e criarmos cr iarmos funç oes o˜ es que as manipulam, definimos objetos que possuem dados pr´ proprios o´ pri os e ac a ç oes o˜ es associadas. O programa orientado a objetos é resultado r esultado da ‘colaboraç ao’ a˜ o’ entre estes objetos. Em Python, todos os dados podem ser considera considerados dos objetos: objetos: qualquer qualquer variável avel — mesmo as dos tipos básicos asicos e pré-definidos e-definidos — possui um valor e um conjunto de operaç ões oes que pode e´ todo) ser realizado sobre este. Por exemplo, toda string em Python possui uma operaç ão ao (ou m etodo chamada upper, que gera uma string nova com seu conteúdo udo em maiúsculas: usculas: >>> a = "H "Hel ell lo" >>> a.upper( a.upper() ) ’HELLO’

Como a maior parte das linguagens que são ao consideradas ‘orientadas a objeto’, Python oferece um tipo especial para definir objetos customizados: a classe. Python suporta também em funcionalidades comuns na orientac or ientaç ão ao a objetos obj etos:: heranc hera nç a, heranc h eranç a m ultipla, u ´ ltipla, polimorfismo, reflexão ao e intr in trosp ospecc ecç ao. a˜ o.

6

1.2 1.2

Por que que Py Pyth thon on? ?

Dado que existe uma grande diversidade de linguagens diferentes, por que aprender Python é é interessante ou mesmo importante? Na minha opinião, ao, a linguagem combina um conjunto unico u ´ nico de vantagens: vantagens:

• Os conceitos fundamentais da linguagem são ao simples de entender. • A sintaxe da linguagem e´ clara e fácil acil de aprender; o código odigo produzido e´ normalmente curto curt o e leg´ıvel. ıvel .

• Os tipos pré-definidos e-definidos inclu´ıdos ıdos em Python s ao a˜ o poderosos, e ainda assim simples de usar. • A linguagem possui um interpretador de comandos interativo que permite aprender e testar rapidamente trechos de código. odigo.

• Python e´ expressivo, com abstraç oes o ˜ es de alto n´ıvel. ıvel. Na grande maioria dos casos, um programa em Python será muito mais curto que seu correspondente escrito em outra linguagem. gem. Isto Isto tamb´ também em faz com o ciclo de desenvolvimento seja rápido apido e apresente potencial de defeitos reduzido – menos código, odigo, menos oportunidade para errar.

• Existe suporte para uma diversidade diversidade grande de bibliotecas externas. externas. Ou seja, pode-se fazer em Python qualquer tipo de programa, mesmo que utilize gráficos, aficos , funç oes o˜ es matemáticas aticas complexas, ou uma determinada base de dados SQL.

• E´ poss´ıvel ıvel escrever extens oes o ˜ es a Python em C e C++ quando é necessário ario desempenho máximo, aximo, ou quando for desejável avel fazer interface com alguma ferramenta que possua biblioteca apenas nestas linguagens.

• Python permite que o programa execute inalterado em múltiplas ultiplas plataformas; em outras palavras, palavras, a sua aplicaç ao a˜ o feita para Linux normalmente funcionará sem problemas em Windows e em outros sistemas onde existir um interpretador Python.

• Python e´ pouco punitiv punitivo: o: em geral, geral, ‘tudo pode’ pode’ e há poucas restric restri ç oes o˜ es arbitrárias. arias. Esta propriedade acaba por tornar prazeroso o aprendizado e uso da linguagem.

• Python e´ livre: além em do interpretador ser distribu´ distribu´ıdo ıdo como software livre (e portanto, gratuitamente), pode ser usado para criar qualquer tipo de software — proprietário ario ou livre. O projeto e implement i mplementac aç ao a˜ o da linguagem é discutido aberta e diariamente em uma lista de correio eletrônico, onico, e qualquer um é bem-vindo bem-v indo para propor alteraç oes o˜ es por meio de um processo simples e pouco burocrático. atico. Ao longo das próximas oxim as seç oes o˜ es serão ao expostos aos poucos os pontos concretos que demonstram estas vantagens.

Python basic a´ s ico: o: invoca invo cacç ˜ ao, tipos, operadores operadores e estruturas estruturas

2

Esta primeira primeir a seç ao a˜ o aborda os aspectos essenciais da linguagem. Por falta de um lugar melhor, será introduzido aqui o s´ımbolo ımbolo para comentários arios em Python: quando aparece o caracter suste3 nido ( #) no código-fonte, odigo-fonte, o restante da linha e´ ignorado. 3

Também conhecido como ‘número’, ‘jogo da velha’, ‘cardinal’ e ‘lasagna’.

7

2.1

Executan Executando do o interpr interpretad etador or Python Python interati interativame vamente nte

Python Python está dispon´ıvel ıvel tanto para Windows e Macintosh como para os diversos diversos Unix (incluindo o Linux). Lin ux). Cada plataform p lataformaa possui um pacote pacot e espec´ıfico ıfico para instalac i nstalaç ão, ao, que normalmente inclui um grande número umero de bibliotecas de código odigo e um programa executável avel python 4 . Este e´ o interpretador Python que usaremos para executar nossos programas. Para iniciar, vamos executar o interpretador interativamente, no modo shell. Em outr outras as palavras, vamos entrar o código-fonte odigo-fonte diretament diretamente, e, sem criar um arquiv arquivo o separado separado.. Para este fim, execute o interpretador (digitando apenas ‘ python ’). Será impresso algo como o seguinte (dependendo de qual sistema estiver usando): % py pyth thon on Pyth Py thon on 2. 2.3. 3.3 3 (# (#1, 1, De Dec c 22 20 2003 03, , 15 15:3 :38: 8:09 09) ) [GCC [GCC 2.95.4 2.95.4 200110 20011002 02 (Debia (Debian n prerel prereleas ease)] e)] on linux2 linux2 Type Type "help" "help", , "copyr "copyrigh ight", t", "credi "credits" ts" or "licen "license" se" for more more information. >>>

Este s´ımbolo ımbo lo >>> chamamos de prompt , e indica que o interpretador está aguardando ser digitado digitado um comando. comando. O shell Python oferece oferece uma excelente excelente forma de testar c ódigo, odigo, e vamos começ ar com algumas algu mas instru ins trucç oes o˜ es simples. >>> a = 1 >>> >> > pr prin int t a 1 >>> >> > b = "H "Hel ello lo wo worl rld" d" >>> >> > pr prin int t b Hello Hello world world

Neste Neste exemplo exemplo,, são ao introduzidos dois aspectos básicos: asicos: primeiro, primeir o, a atribuic atri buiç ao a˜ o de variáveis; aveis; segundo, segun do, a instruc inst ruç ao a˜ o print, que exibe valores e o conteúdo udo de variáveis. aveis. A forma interativa de executar o Python é conveniente; no entanto, não ao armazena o código odigo digitado, servindo apenas para testes e procedimentos simples. Para programas mais complexos, o c odigo-fonte o´ digo-fonte e´ normalmente escrito e armazenado em um arquivo.

2.2

Criando Criando um program programa a e executa executandondo-o o

o´ dulo. Nos casos Em Python, um arquivo arquivo contendo instruç oes o˜ es da linguagem é chamado de m odulo casos mais simples pode-se usar um único unico módulo, odulo, executando-o diretamente; no entanto, é interesinteressante saber que é poss´ıvel ıvel sub-dividir o programa em arquivos arquivos separados e facilmente integrar as func fun ç oes o˜ es definidas definidas neles. Para Para criar criar um arquivo arquivo contendo contendo um programa, programa, basta basta usar qualquer qualquer editor editor de texto. texto. Para Para um primeiro exemplo, exemplo, crie um arquiv arquivo o hello.py contendo as seguintes linhas: 4

Normalmente, é inclu´ı do um ambiente de ediç ão e execuç ão simples, como como o IDLE, também escrito em Python. Estes podem ser também utilizados.

8

a = "H "Hel ello lo" " b = "w "wor orld ld" " print print a,b

E a seguir, execute-o da seguinte forma: % python python hello. hello.py py

Ou seja, execute o interpretador e passe como parâmetro o nome do arquivo que contém em o codigo o´ digo a ser executado. O resultado impresso deve ser: Hello Hello world world

Perceba bem que não ao há preâmbulo ambulo algum algum no código-fonte; odigo-fonte; escrev escrevemos emos diretamente diretamente o código odigo 5 a ser executado . Nas próximas oxi mas sec s eç oes o˜ es do tutorial, estaremos utilizando bastante bastante o modo shell; no entanto, para exerc´ıcios ıcios e exemplos exemplo s mais extensos que algumas al gumas linhas, lin has, vale a pena usar m ódulos odulos para permitir edic ed iç ao a˜ o e revisão. ao.

2.3 2.3

Tipo Tipos, s, va vari riáveis a´ veis e valores

Nomes de variáveis aveis começam ¸am sempre com uma letra, não ao contém em espaços, ¸o s, e assim ass im como co mo tudo t udo em Python, são ao sens´ıveis ıveis a caixa ( case-sensitive) — em outras palavras, minúscula usculass e mai mai usculas u´ sculas fazem, sim, diferenc di ferenç a. Como explicado anteriormente, anter iormente, a vari´ vari avel a´ vel não ao precisa ser pré-declarada e-declarada e seu tipo e´ determinado dinamicamente.

2.3. 2.3.1 1

Tipos ipos num num ericos e´ ricos

Tipos numéricos ericos representam valores numérico ericos. s. Em Pytho Python n há alguns tipos numéricos ericos préedefinid definidos: os: inteiro inteiross (int), números umeros de ponto flutuante ( float), boolea booleanos nos ( bool ) e complexos (complex). Estes Estes tipos suportam suportam as operac operaç oes o ˜ es matemáticas aticas comuns como adiç ao, a˜ o, subtrac subt raç ao, a˜ o, multip mul tiplic licac açao a˜ o e divisão, ao, e podem ser convertidos entre si. Uma obse o bservac rvaç ao: a˜ o: booleanos foram adicionados na versão ao Python Pyt hon 2.2; 2.2 ; sua utilizac utili zaç ao a˜ o e´ normalmente associada a expressões oes condiciona condicionais. is. Maiores Maiores detalhes detalhes sobre este tipo estão ao dispo di spon´ n´ıveis ıve is na seç ao a˜ o 2.4.4. A seguir segui r alguns alg uns exemplos de criac cri aç ao a˜ o de variáveis aveis numéricas: ericas: >>> >>> >>> >>>

a = 1 preco = 10.99 t = True i = 4+3j

# # # #

valor valor valor valor

5

inteiro ponto flutuante, ou float. booleano complexo

Em Unix, é poss´ı vel criar programas programas em Python e executá-los executá-los usando usando apenas o nome do módulo (sem digitar o nome do interpretador python). Basta Basta adicionar a linha ‘mágica’ ‘mágica’ #!/usr/bin/env #!/usr/bin/env python ao in´ı cio do módulo e dar permissão de execuç ão ao arquivo. arquivo. Note que isto não evita evita que seja necessário necessário que o interpretado interpretadorr esteja instalado no sistema; apenas permite que se possa omitir digitar o seu nome.

9

Valores inteiros podem também em ser fornecidos em base octal e hexadecimal: >>> >>> >> > 57 >>> >>> >> > 255

a = 071 prin pr int t a a = 0xFF prin pr int t a

Para ser considerado um float, o número umero deve possuir um ponto e uma casa decimal, mesmo que seja seja zero. zero. O fato de ser conside considerad rado o um float float é importante para a operaç ao a˜ o divisão, ao, pois dependendo do tipo dos operandos, a divisão e´ inteira ou em ponto flutuante. ˜ >>> 5 / 2 # divis ao ao inteir inteira, a, result resultado ado inteir inteiro o 2 ˜ >>> 5 / 2. 2.0 # di divis ao a o em po pont nto o fl flut utua uant nte e 2.5 >>> 5 * 2.13 10.649999999999999

Aten At encç ao a˜ o especial para este terceiro exemplo, que demonstra uma particularidade da represent repr esentac aç ao a˜ o e impressão a o de números umeros de ponto flutua flutuante. nte. Numeros u ´ meros deste tipo, como o valor 2.13 do exemplo, exempl o, possuem poss uem uma representaç ão ao interna particular devido a` natureza nat ureza dos intr´ i ntr´ınseca ınseca dos computadores comp utadores digitais; digitai s; operaç oes o ˜ es realizadas sobre eles têm em precisão ao limitada, e por este motivo o resultado impresso diverge ligeiramente do resultado resultado aritmeticamente aritmeticamente correto. correto. Na pr atica, a´ tica, o resultado obtido e´ prati6 camente equivalente equivalente a 10.65 .

Determinando o tipo de uma vari avel a´ vel usar a func f unç ao a˜ o type():

Para descobrir o tipo atual de uma variável, avel, pode-se

>>> a = 1 >>> print print type(a type(a) ) ’int’> >>> a = "hum" >>> print print type(a type(a) ) >

Uma das vantagens de Python são ao os tipos complexos que vêm e m pré-definidos, e-definidos, introduzidos na seç ao a˜ o 1.1.2. 1. 1.2. As seç oes o ˜ es seguintes cobrem estes tipos. 6

Todas as linguagens de programaç ão convencionais utilizam este mesmo mecanismo de representaç ão, e na prática não resultam grandes problemas com isso, mas Python deixa transparecer esta particularidade em algumas situaç ões, como esta. O tutorial Python em http://www.python.org/docs/current/tut/ inclui uma seç ão sobre sobr e as nuances nuan ces do uso e representac represe ntaç ão de n úmeros de ponto po nto flutuante. utuante .

10

2.3. 2.3.2 2

Lista Listass

seq ü ência encia: um conjunto linear A lista e´ uma seq ¨ linear (como um vetor em outras outras linguage linguagens) ns) de valores valores indexad indexados os por um número umero inteiro. Os ´ındices ındices são ao iniciado iniciadoss em zero e atribu´ıdos ıdos seq¨ sequencialmente u¨ encialmente a part partir ir dest deste. e. A lista lista pode pode cont conter er quai quaisq sque uerr valor alores es,, incl inclui uind ndo o valo valore ress de tipos tipos mist mistos os,, e até outra outrass listas. Para criar uma lista, usamos colchetes e v´ırgulas ırgulas para enumerar os valores: >>> >>> >> > >>> >> > >>> >> >

numero nume ros s opco op coes es mode mo delo los s list li stas as

= = = =

[1, 2, 3] ["na [" nao" o", , "s "sim im", ", "talv "talvez ez"] "] [3.1 [3 .1, , 3. 3.11 11, , 95 95, , 98 98, , 20 2000 00, , "M "Mil ille leni nium um", ", "X "XP" P"] ] [num [n umer eros os, , op opco coes es] ]

Neste exemplo exemplo criamos quatro listas diferentes, com elementos de tipos diversos. diversos. A quarta lista tem como elementos outras listas: em outras palavras, é uma lista de listas: >>> print print listas listas [[1, [[ 1, 2, 3] 3], , [’ [’na nao’ o’, , ’s ’sim im’, ’, ’t ’tal alve vez’ z’]] ]]

Para acessar um elemento elemen to espec´ıfico ıfico de uma lista, li sta, usamos usam os o nome no me da lista l ista seguido segui do do ´ındice ındice entre colchetes: >>> print print numero numeros[0 s[0] ] 1 >>> print print opcoes opcoes[2] [2] talvez >>> print print modelo modelos[4 s[4] ] 2000

Usando Usand o ´ındices ındi ces negativos, negat ivos, as a s posic p osiç oes o ˜ es s˜ s ao a˜ o acessadas a partir do final da lista, -1 indicando o ultimo u´ ltimo elemento: >>> print print numero numeros[s[-1] 1] 3 >>> print print modelo modelos[s[-2] 2] Millenium

Python oferece um mecanismo para criar ‘fatias’ de uma lista, ou slices. Um slice e´ uma lista gerada gerada a partir de um fragmento fragmento de outra outra lista. O fragmento fragmento é especificado especi ficado com co m dois ´ındices, ındices, separados por dois pontos; pontos; o slice resultante resultante contém em os elementos cujas posic p osiç oes o ˜ es vão ao do primeiro ´ındice ındice ao segundo, segundo, não ao incluindo o ultimo u ´ ltimo elemento. elemento. Se omitirmos omitirmos um dos ´ındices ındices no slice, slice, assume-se in´ıcio ıcio ou fim da lista. li sta. >>> print print numero numeros[: s[:2] 2] [1, [1 , 2] >>> print print opcoes opcoes[1: [1:] ] [’sim’, [’sim’, ’talvez’] ’talvez’] >>> print print modelo modelos[1 s[1:5] :5] [3.10000 [3.100000000 00000000 0000001, 001, 95, 98, 2000] 2000]

11

Note que o terceiro exemplo demonstra a mesma particularidade referente à à represent repr esentac aç ao a˜ o de números umeros de ponto flutuante, descrita na seç ão ao 2.3.1: 2.3.1: ao imprimir imprimir a lista, lista, Python Python exibe exibe a repres rep resen enta tacçao ao impressos com precisão ao com˜ interna dos seus elementos, e portanto, floats são pleta.

Metodos e´ todos da Lista Na seç ao a˜ o 1.1.5 introduzimos introduzimos um conceito conceito central da linguage linguagem: m: ‘tudo é um objeto´; uma lista em Python, sendo um objeto, possui um conjunto de operaç ões oes próprias oprias e´ todo e´ usado para descrever operac que manipulam seu conteúdo. udo. O nome metodo o peraç oes o ˜ es de um objeto; metodos e´ todos são ao acessados no código-fonte odigo-fonte digitando-se um ponto após os o nome da variável, a vel, e a seguir o nome do método. etodo. Para executar (ou chamar ) um método, etodo, usamos parênteses enteses após os seu nome, fornecendo argumentos mentos conforme conforme necess´ necessário. ario. Abaixo Abaixo são ao exemp exemplifi lifica cados dos dois dois exemp exemplos los de chama chamada dass de métodos etodos em listas: >>> >>> [1, >>> >>> [0,

numeros. numeros.appen append(0) d(0) print print numero numeros s 2, 3, 0] numeros. numeros.sort( sort() ) print print numero numeros s 1, 2, 3]

Observe Obser ve com co m atenc at enç ao a˜ o este exemplo, que demonstra os conceitos fundamentais descritos nos parágrafos agrafos anteriores:

• O método etodo append(v) recebe como argumento um valor, e adiciona este valor ao final da lista.

• O m etodo e´ todo sort() ordena a lista, modificando-a. Não ao recebe argumentos. A lista possui uma série erie de outros métodos; etodos; consulte a referência encia Python para uma um a descric descri ç ao a˜ o completa (e veja também em a func fun ç ao a˜ o dir() na sec se ç ao a˜ o 4.4).

2.3.3 2.3.3

Tuplas uplas

A tupla e´ uma seqüˆ uencia, eˆ ncia, como a lista: armazena um conjunto de elementos acess´ıveis ıveis por um ´ındice ındice inteiro. in teiro. A tupla e´ imutável; avel; uma vez criada, não ao pode ser modificada. Para criar uma tupla use parênteses, enteses, e v´ırgulas ırgulas para p ara separar seus elementos: element os: >>> t = (1, 3, 5, 7) >>> >> > pr prin int t t[ t[2] 2] 5

A tupla e´ utilizada em algumas situac sit uaç oes o ˜ es importantes: como a lista de argumentos de uma func fu nç ao a˜ o ou método, etodo, como chave em dicionários, arios, e em outros casos onde fizer sentido ou for mais eficiente um conjunto fixo de valores.

12

2.3. 2.3.4 4

Stri String ngss

A string, string, como citado anteriorme anteriormente, nte, e´ uma seqüˆ uencia ência imutável avel com um propósito osito especial: armazenar cadeias de caracteres. >>> a = "M >>> "Mon ondo do Bi Biza zarr rro" o" >>> >> > pr prin int t a Mondo Mondo Bizarro Bizarro

Strings podem ser delimitadas tanto com aspas simples quanto duplas; se delimitamos com aspas aspas duplas, podemos podemos usar as aspas simples simples como parte literal da string, string, e vice-versa. vice-versa. Para Para inserir na string aspas literais do mesmo tipo que o delimitador escolhido, prefixe-as com uma contra-barra \. As atribui at ribuicç oes o˜ es abaixo abaixo s˜ s ao a˜ o equivalentes: equivalentes: >>> b = "A >>> "All ll’s ’s qu quie iet t on th the e ea east ster ern n fr fron ont. t." " >>> >> > c = ’All ’All\’ \’s s qu quie iet t on th the e ea east ster ern n fr fron ont. t.’ ’ >>> b == c True

São ao usados caracteres especiais para denotar quebra de linha ( \n), tabul t abulac aç ao a˜ o ( \t) e outros. ´ o pr >>> a = "H >>> "Hoj oje\ e\n\ n\t t e prim imei eiro ro di dia. a." " >>> >> > pr prin int t a Hoje ´ o pr e prim imei eiro ro di dia. a.

Para criar uma string com múltiplas ultiplas linhas, e´ util u´ til o delimitador aspas triplas: as linhas podem ser quebradas diretamente, e a string pode ser finalizada com outras três aspas consecutivas: consecutivas: a = "" """I "I we wear ar my su sung ngla lass sses es at ni nigh ght t So I can so I can Keep Ke ep tr trac ack k of th the e vi visi sion ons s in my ey eyes es"" """ "

Finalmente, como toda seqüˆ uencia, eˆ ncia, a string pode ser indexada ou dividida em slices, usando o operador colchetes: >>> a = "Anticons "Anticonstitu tituciona cionaliss lissimame imamente" nte" >>> >> > pr prin int t a[ a[0] 0] A >>> >> > pr prin int t a[ a[13 13] ] i >>> >> > pr prin int t a[ a[:4 :4] ] Anti >>> print print a[-5:a[-5:-1] 1] ment

A string possui um operador especial, a porcentagem ( %), que será descrito na seç ao a˜ o 2.4.6. Possui ainda um grande número umero de métodos, etodos, descritos em detalhes detal hes na seç ão ao String Methods do manual de referência encia Python. 13

2.3. 2.3.5 5

Dici Dicion onários a´ rios

Um dicionário ario representa uma coleç ao a˜ o de elementos elementos onde onde é poss´ıvel ıvel utilizar utili zar um ´ındice ındice de qualquer tipo imutável, avel, ao contrário ario da lista, onde ´ındices ındices são ao sempre inteiros seqüencialmente uencialmente ´ costumeiro usar os termos chave e valor (key/value) para descrever os elemenatri at ribu´ bu´ıdos. ıd os. E tos de um dicionário ario - a chave é o ´ındice, ındi ce, e o valor, val or, a informa inf ormacç ao a˜ o correspondente àquela aquela chave. Para declarar dicionários, arios, utilizamos utili zamos o s´ımbolo ımbolo chaves, separando o ´ındice ındice do valor por dois d ois pontos e separando s eparando os pares ´ındice-valor ındice-valor por v´ırgulas: ırgulas: ´" : "caf e", ´ ˜ >>> re >>> refe feic icoe oes s = {" {"ca caf fe e", "almoc "almoc ¸ o" : "m ¸o" "mac acar arr r ao", ao", ... "jantar" : "sopa"} >>> print print refeicoes refeicoes["alm ["almoc oc ¸o"] macarrao >>> pr prec ecos os_m _mod odel elo os = {98 : 89 89, , 99 : 11 119 9, 20 2000 00 : 19 199} 9} >>> print print precos_mo precos_modelos delos[98] [98] 89

Neste exemplo criamos dois dicionários arios com três es elemen elementos tos cada cada um. As chave chavess do dicionário ario refeicoes são ao as strings ”café”, e”, ”almoço”e ¸o”e ”jantar”, e os valores respectivos, respectivos, as strings ”café”, e”, ”macarrão”e ao”e ”sopa”.

Metodos e´ todos do Dicion´ Dicionario a´ rio

O dicionário ario também em possui alguns métodos etodos notáveis: aveis:

• keys() retorna uma lista (sim, exatamente, do tipo lista) com as chaves do dicionário; • values() retorna uma lista com os valores do dicionário; ario; • items() retorna uma lista de tuplas com o conteúdo udo do dicionário, ario, cada tupla contendo um par (chave, valor); >>> precos_modelos.keys() precos_modelos.keys() [99, [9 9, 98 98, , 20 2000 00] ] >>> precos_modelos.values() precos_modelos.values() [119 [1 19, , 89 89, , 19 199] 9] # A or orde dem m do dos s el elem emen ento tos s re reto torn rnad ados os po por r ke keys ys() () e ´ ar ´ ˜ # values values() () e arbi bitr tr´ a ria; aria ; nao a o co conf nfie ie ne nela la. .

• has key(k) verifica se a lista possui aquela chave: >>> precos_modelos.has_key(98) precos_modelos.has_key(98) True >>> precos_modelos.has_key(97) precos_modelos.has_key(97) False

• update(d2) atualiza o dicionário ario com base em um segundo dicionário ario fornecido como parâmetro; ametro; elementos do dicionário ario original que também em existem no segundo são ao atualizados; elementos que existem no segundo mas que não ao existem no original são ao adicionados a este. 14

>>> precos precos_mo _model delos. os.upd update ate({2 ({2000 000 : 600, 600, 2001: 2001: 700}) 700}) >>> print print precos_mo precos_modelos delos {99: {9 9: 40 400, 0, 98 98: : 30 300, 0, 20 2001 01: : 70 700, 0, 20 2000 00: : 60 600} 0}

No exemplo acima, observe que a chave 2000 foi atualizada, e 2001, acrescentada. ´ poss´ıvel E ıvel usar o dicionário ario como uma estrutura de dados simples, com campos para cada info in forma rmacç ao a˜ o a ser armazenada. Por exemplo, para armazenar informaç ão ao sobre um produto hipotético, etico, com código, odig o, descric descr iç ao a˜ o e prec pre ç o: ´ >>> pr >>> prod odut uto o = {" {"c c odigo":7 odigo":771, 71, "desc":" "desc":"Copo Copo", ", "prec "prec ¸o":10.22} ´ >>> print print produt produto[" o["c c odigo"] odigo"] 771 >>> print print produto[" produto["desc" desc"] ] Copo

´ um padrão E ao comum criar listas de dicionários arios neste formato, cada ´ıtem ıtem na lista l ista correspondendo a um produto em particular.

2.4 2.4

Oper Operad ador ores es

O próximo oximo tópico opico essencial da linguagem são ao operadores , s´ımbolos ımbolos que q ue operam sobre vari aveis a´ veis e valores.

2.4.1 2.4.1

Operad Operador ores es aritm aritméticos e´ ticos

A maior parte dos operadores aritméticos eticos em Python funciona de maneira intuitiva e análoga aloga aos operadores em outras linguagens. Demonstrando por exemplo: >>> print a + 3 10 >>> print a - 2 5 >>> print a / 2 3

# adic ¸˜ ao ao

>>> print a / 2.5 2.8

˜ # divis ao a o em po pont nto o fl flut utua uant nte: e: pelo pelo # menos um argumento deve ser float

>>> print a % 4 3 >>> print a * 2 14 >>> print a ** 2 49

˜ # resto da divis ao ao inteir inteira a

# subtrac ¸˜ ao ao ˜ # divis ao ao inteir inteira: a: argume argumento ntos s inteir inteiros os # e resultado inteiro

# multiplicac ¸˜ ao ao # exponenciac ¸˜ ao ao

15

A exponenci expon enciac aç ao a˜ o também em pode ser feita por meio de uma funç ão, ao, pow(), como descrito na seç ao a˜ o 3. A raiz quadrada e outras funç oes o ˜ es matemáticas aticas est˜ est ao a˜ o implementadas no módulo odulo math; veja vej a a seç ao a˜ o 5 para maiores detalhes. Com excec exc eç ao a˜ o da d a exponenc exp onenciac iaç ao a˜ o e da divisão ao inteira, estes operadores são ao bastante comuns em linguagens de programac p rogramaç ao. a˜ o. Os operadores aritméticos eticos podem ser usados em floats também: em: >>> a = 1.15 >>> print a / a - a * a + a 0.57349375

e os operadores de adic adi ç ão ao ( +) e mult m ultipl iplicac icaçao a˜ o ( *), em strings: >>> a = "e "exa xat to" >>> print a * 2 exatoexato >>> pr prin int t "q "qua uas se " + a quase quase exato exato

, listas: >>> a = [-1, 0] >>> b = [1, 2, 3] >>> print b * 3 [1, 2, 3, 1, 2, 3, 1, 2, 3] >>> print a + b [-1, 0, 1, 2, 3]

e tuplas: >>> a = (1, 2) >>> print a + (2, 1) (1, 2, 2, 1)

Como exemplificado exempl ificado acima, o operador operado r adic adi ç ao a˜ o (e multipl mult iplicac icaç ao) a˜ o) serve para concatenar concatenar listas, tuplas tuplas e string strings. s. Não ao pode ser utilizado com dicionários arios (que podem ser atualizados usando a func fu nç ao a˜ o update(), mas para os quais quai s a operaç ão ao de d e concat co ncatenac enaç ao a˜ o não ao faria sentido).

2.4.2 2.4.2

Operador Operadores es sobr sobree cadeias cadeias de bits

Para inteiros, existem operadores que manipulam seus valores como cadeias de bits (operadores bit-wise) de acordo com a aritmética etica booleana: >>> a = 0xa1 >>> b = 0x01 >>> >> > pr prin int t a, b 161, 16 1, 1

# pa para ra im impr prim imir ir os va valo lore res s de deci cima mais is

16

>>> a & b 1 >>> a | b 161 >>> a << 1 322 >>> b >> 1 0 >>> ã -162

# and # or # shift para esquerda # shift para direita ˜ # invers ao a o em co comp mple leme ment nto o de 2

Note que a representaç ao a˜ o dos valores inteiros, por padrão, ao, e´ decimal: aqui, embora fornecemos os valores em base hexadecimal, os resultados aparecem na base 10.

2.4.3

Operadores de atribuiç ˜ ao

O operador mais simples, e que já fui utilizado em diversos exemplos anteriores, é o operador de atri at ribui buicçao. a˜ o. Este operador é representado por um unico u ´ nico s´ımbolo ımbolo de igualdade, =, definindo uma variável avel e automaticamente atribuindo a ela um valor. O exemplo abaixo define uma variável variável a, com valor inteiro 1. >>> a = 1

Existem formas variantes deste operador que o combinam com os operadores aritméticos e bit-wise bit-wi se introduzidos int roduzidos nas seç oes o˜ es anteriores. anteriores. Estas formas formas foram introduzid introduzidos os na versão ao Python 2.0, e existem primariamente para oferecer uma maneira conveniente de re-atribuir um valor transformado a uma variável. avel. A sintaxe para o operador combinado utiliza utili za o s´ımbolo ımbolo do operador aritm´ aritm ético/bit-wise etico/bit-wise relevante levante,, seguido seguido da igualdade igualdade.. Este operador operador combinad combinado o efetua efetua a operac operaç ão ao sobre o valor da variável, avel, já atribuindo o resultado a esta mesma. Exemplificando: >>> >>> >>> >> > 2 >>> >>> >> > 1 >>> >>> >> > 10

2.4.4 2.4.4

a = 1 a += 1 prin pr int t a a /= 2 prin pr int t a a *= 10 prin pr int t a

Operador Operadores es condicion condicionais ais

Tradicionalmente, Tradicionalmen te, programaç ao a˜ o envolve testar valores (e tomar decisões oes com base no resultado do teste). teste). Um teste teste e´ essen essencia cialme lmente nte uma expre express˜ ssão ao condici condicion onal al que tem um result resultad ado o verda verdade deiro iro ou falso. Esta seç ao a˜ o descreve os operadores condicionais mais comuns em Python. 17

A partir da versão ao 2.2 de Python Python,, existe um tipo numérico erico que representa o resul´ tado tado de um teste teste condic condicion ional: al: o tipo tipo boole booleano ano.. E um tipo basta bastante nte simple simples, s, possui possuindo ndo apenas dois valores poss´ıveis: ıveis: True e False. A partir partir da da vers˜ versão ao 2.3 de Python, qualquer qual quer comparac comp araç ao a˜ o retorna um valor booleano; versões oes anteriores retornavam 1 ou 0, respectiv respectivamen amente. te. Na prática, atica, o resultado é equivalente, ficando apenas mais expl´ıcito ıci to e leg´ıvel ıvel o resulta resu ltado. do.

Igualdade >>> print False >>> print True >>> pr prin int t True >>> pr prin int t True

2 == 4

# igualdade

2 != 4

# diferente de

"a" "a " == "a "a" " "a" "a " != "b "b" "

Comp Co mpar arac aç ˜ ao >>> print 1 < 2 True >>> print 3 > 5 False >>> print 3 >= 4 False

# menor que # maior que # maior ou igual que

Compar Com parac aç oes o˜ es podem ser realizadas também em com outros tipos de variáveis; aveis; para strings, listas ou dicionários, arios, as comparaç oes o˜ es ‘maior que’ e ‘menor que’ se referem ao número umero e ao valor dos elementos, mas por não ao serem terrivelmente claras não ao são ao muito freqüentemente uentemente usadas 7 . >>> [2 >>> [2,2 ,2,3 ,3] ] < [2 [2,3 ,3,2 ,2] ] True >>> >> > "a "aba baca cate te" " < "p "per era" a" True

Dica: quan quando do comp compar aran ando do o númer u mero o de elem elemen ento toss de uma uma seq¨ seqüˆ uenci eˆ nciaa ou dici dicion´ onário, ario, e´ normalmente normalment e utilizada uti lizada a func f unç ao a˜ o len(), que retorna o ‘comprimento’ da seqüˆ uencia. eˆ ncia. Presenc Pres enç a em Seq ¨ Seq ü ências encias Para seqüˆ uencias eˆ ncias e dicion´ dicionários, arios, existe o operador in, que verifica se o elemento está contido no conjunto; no caso do dicionário, ario, o operador testa t esta a presenç a do valor valo r na seqüˆ uencia ência de chaves. chaves. >>> "x >>> "x" " in "c "cha ha" " False >>> >> > 1 in [1 [1,2 ,2,3 ,3] ] True 7

A exceç ão óbvia é na ordenaç ão de seqüências contendo elementos destes tipos.

18

2.4.5 2.4.5

Operad Operador ores es logicos o´ gicos

Os operadores lógicos ogicos not, and e or permitem modificar e agrupar o resultado de testes condicionais: >>> no >>> nome me = "p "ped edro ro" " >>> id idad ade e = 24 >>> >> > no nome me == "p "ped edro ro" " an and d id idad ade e == 25 False >>> no nome me == "pe pedr dro" o" an and d id ida ade < 25 True >>> >> > le len( n(no nome me) ) < 10 or no not t no nome me == "p "ped edro ro" " False

Estes operadores são ao utilizados utilizados com freq¨ frequˆ u¨ encia eˆ ncia nas estruturas est ruturas de d e controle descritas na seç ão ao 2.5.

Comb Co mbin inac aç ˜ ao de operadores Python oferece uma forma fo rma impl´ i mpl´ıcita ıcita de combinar comb inar operaç oes o˜ es condicionais, sem o uso de operadores lógicos. ogicos. Por exemplo, exemplo, para verificar verificar se um valor valor está entre dois extremos, pode-se usar a seguinte sintaxe: if 0 < a < 10: prin pr int t "E "Ent ntre re ze zero ro e de dez" z"

Podem Podem também em ser comparados comparados diversos diversos valores simultaneamente: if a == b == c: ˜ ˆ prin pr int t "S "S˜ ao identicos" enticos"

e mesmo combinados operadores comparativos com operadores de igualdade: if a == b <= c: ˜ ˆ prin pr int t "S "S˜ ao identicos" enticos"

Esta expressão ao verifica se a e´ igual a b e além em disso, se b e´ menor ou igual a c.

2.4.6

Substituiç ˜ ao em strings: o operador %

Uma operac oper aç ao a˜ o muito util u´ til para processamento de texto é a substit subs tituic uiç ao a˜ o de s´ımbolos ımbolos em strings. st rings. ´ particularmente adequada para gerarmos strings formatadas contendo algum valor variável, E avel, como o clássico assico formulário: ”Nome: Idade: anos”. 1. Escreve-se Escreve-se a string normalmente, usando um s´ımbolo ımbolo especial no lugar da lacuna:

• %d: para substituir inteiros • %f: para substituir floats 19

• %s: para substituir outra string >>> a = "To >>> Tot tal de ite tens ns: : %d" >>> >> > b = "Cu Cus sto to: : %f %f" "

2. Para efetuar a substituiç ao, a˜ o, aplica-se um operador % sobre a string contendo o s´ımbolo ımbolo de forma fo rmata tacç ao, a˜ o, seguido do valor ou variável avel a substituir: >>> print a % 10 Tota To tal l de it iten ens: s: 10

Como pode ser visto, o s´ımbolo ımbolo e´ substitu´ıdo ıdo pelo valor fornecido. Podem ser utilizados tanto valores expl´ıcitos ıcitos quanto vari´ variaveis a´ veis para a substit s ubstituic uiç ao: a˜ o: >>> cu >>> cust sto o = 5. 5.50 50 >>> >> > pri rint nt b % cu cust sto o Custo: Custo: 5.500000 5.500000

Caso sejam múltiplos ultiplos valores a substituir, use uma tupla: >>> pr >>> prin int t "C "Cli lien ente te: : %s %s, , Va Valo lor r %f %f" " % (" ("hu hung ngry ry.c .com om", ", 40 40.3 .30) 0) Fornecedo Fornecedor: r: hungry.co hungry.com, m, Custo Custo 40.300000 40.300000

Este operador permite ainda utilizar um número umero junto j unto ao s´ımbolo ımbolo porcentagem para reservar res ervar um tamanho total a` string: >>> a = "Q >>> "Qua uant ntid idad ade: e: %4 %4d" d" >>> print a % 3 >>> print a % 53 >>> print a % 120 Quantidade: 3 Quantidade: 53 Quan Qu anti tida dade de: : 12 120 0

´ poss´ E p oss´ıvel ıvel control cont rolar ar a form f ormatac ataç ao a˜ o de tipos numéricos ericos de maneira especial através es de modificadores nos s´ımbolos ımbolos no formato f ormato m .n. Como acima, m indica o total de caracteres reservados. Para floats, n indi indica ca o número umero de casas casas decim decimais; ais; para para inteiros, inteiros, indica indica o tamanho tamanho total do do número, umero, preenchido com zeros à esquerda. Ambos os modificadores podem ser omitidos. >>> e = 2. 2.73 731 13 >>> p = 3. 3.14 141 15 >>> sete = 7 >>> print "Euler: %.7f" % e Euler: Euler: 2.731300 2.7313000 0 >>> print "Pi: %10.3f" % p Pi: 3.142 >>> pri print "Se "Sete: %10 %10.3d" % sete Sete: 007

20

# 7 casas decimais # 10 espaço ¸os, s, 3 ca casa sas s ´ # 10 es espaços, 3 d ıgitos ıgitos ´ um in # (e inte teir iro) o)

2.5

Estrut Estrutur uras as de contr controle ole

Toda linguagem de programaç ao a˜ o possui instruç oes o˜ es que controlam controlam o fluxo de execuc execuç ão; a o; em Python, Python, h´ h a´ um conjunto conj unto pequeno e poderoso podero so de instruc ins truç ões, oes, descritas nas seç oes o ˜ es a seguir.

2.5.1

Condicional: a instruç ˜ ao if

A inst i nstru rucç ao a˜ o condicional básica asica de Python e´ o if. A sintaxe é descrita a seguir (lembrando que a inden in dentac taç ao a˜ o e´ que delimita o bloco): ˜ if condic condic ¸ao: ao: ´ # bloco de c odigo odigo ˜ elif elif condic condic ¸ao: ao: # ou outr tro o bl bloc oco o else: # bl bloc oco o fi fina nal l

As cond c ondic iç oes o˜ es acima são ao comparac comp araç oes o˜ es feitas utilizando os operadores condicionais descritos na sec seç ao a˜ o 2.4.4, possivelmente combinados por meio dos operadores lógicos ogicos descritos na seç ao a˜ o 2.4.5. a = 2 b = 12 if a < 5 and b * a > 0: print print "ok" "ok"

sen ˜ ao se A inst i nstruc ruç ao a˜ o elif permite que se inclua uma exceç ão ao condicional — algo como ”... sen ˜ isso ...”. O else é uma u ma excec exce ç ao a˜ o absoluta 8 . if nome nome == "p "ped edro ro": ": idad id ade e = 21 ´ elif el if no nome me == "j "jos os´ e": e": idad id ade e = 83 else: idade = 0 ´ nome="alvaro" alvaro" para o bloco acima, será atribu´ Provendo nome="´ at ribu´ıdo ıdo o valor valo r zero a idade.

2.5.2

Laço ¸o iterativo: for

Há apenas dois tipos de laç os em Python: for e while. O primeiro tipo, mais freqüentemente uentemente utilizado, percorre uma seqüˆ uencia eˆ ncia em ordem, a cada ciclo substituindo a variável especificada por um dos elementos. Por exemplo: 8

Não há nenhuma estrutura do tipo switch/case, mas é poss´ı vel simulá-la usando uma expressão if com um elif para cada caso diferente.

21

>>> jan_ke jan_ken_p n_pon on = ["pedr ["pedra", a", "papel "papel", ", "cenou "cenoura" ra"] ] >>> >> > fo for r it item em in ja jan_ n_ke ken_ n_po pon: n: ... print item ... pedra papel cenoura

A cada c ada iterac iter aç ao, a˜ o, item recebe o valor de um elemento da seqüˆ uencia. eˆ ncia. Para efetuar efetu ar uma laç o com um número umero fixo de iteraç oes, o˜ es, costuma-se usar o for em conjunto con junto com a funç ao a˜ o range, que gera seqüˆ uencias eˆ ncias de números: umeros: >>> fo >>> for r i in ra rang nge( e(1, 1,4) 4): : ... print "% "%da vo volta" % i ... 1a vo volt lta a 2a vo volt lta a 3a vo volt lta a

Iteraç ˜ ao em dicionarios a´ rios Para iterar em dicionários, arios, podemos usar as funç oes o ˜ es keys() ou values() para gerar uma lista: >>> di >>> dict ct = {" {"ba bata tata ta": ": 50 500, 0, "a "ab b obora": ´ obora": 1200, 1200, ... "cebola": 800} >>> >> > fo for r e in di dict ct.k .key eys( s(): ): ... prin pr int t "It Item em: : %8s Peso Peso: : %8 %8s" s" % (e (e, , dic ict[ t[e e]) Item: cebola Peso: 800 Item: batata Peso: 500 ´ Item It em: : ab ab´ o bora obor a Pes Peso: 120 200 0

Note que porque o dicionário ario em si não ao possui um conceito de ordem, a lista que resulta do metodo e´ todo keys() possui poss ui ordenac orde naç ao a˜ o arbitrária. aria. Por este motivo, no exemplo acima, o laço ¸o não ao segue a declar de clarac aç ao a˜ o do dicionário. ario.

Controle adicional em laços ¸o s Para ambos os tipos de laço, ¸o, existem duas instruç oes o ˜ es de controle adicional, continue e break. A primeira reinicia uma nova iteraç ao a˜ o imediatamente, interrompendo interr ompendo a iteraç ao a˜ o atual; a segunda faz o laç o terminar termi nar imediatamente. imed iatamente. A forma geral do laç o for e: e´ : ´ ëncia: ˆ for fo r vari vari´ a vel in se avel seq qu encia: ´ # bloco de c odigo odigo else: # bl bloc oco o ex exec ecut utad ado o na au aus sˆ e ncia enci a de um br brea eak k

Note a presenc pr esenç a da cl´ cl ausula a´ usula else . Esta Esta cláusula ausula e´ executa exe cutada da quando quand o a sa´ıda ıda do laç o n ao ˜ for determinada por uma instru ins trucç ao a˜ o break. Um exemplo clarifica este mecanismo: 22

valores = [2, 4, 5, 2, -1] for fo r i in va valo lore res: s: if i < 0: prin pr int t "N "Neg egat ativ ivo o en enco cont ntra rado do: : %d %d" " % i break else: print print "Nenhum "Nenhum negativo negativo encontrad encontrado" o"

2.5.3

Laço ¸o condicional: while

O segundo tipo de laço, ¸o , while, e´ utilizado quando necessitamos fazer um teste a cada iteraç ão ao do lac la ç o. ˜ while while condic condic ¸ao: ao: ´ # bloco de c odigo odigo else: # bl bloc oco o ex exec ecut utad ado o na au aus sˆ e ncia enci a de um br brea eak k

Como o laç o for, o while whi le possui uma cl ausula a´ usula else. Um exemplo do uso de while segue: >>> m = 3 * 19 >>> n = 5 * 13 >>> >> > co cont ntad ador or = 0 >>> while m < n: ... m = n / 0.5 ... n = m / 0.5 ... contador = con contador + 1 ... >>> >> > pr prin int t "I "Ite tera ramo mos s %d ve veze zes. s." " % co cont ntad ador or Iteram Iteramos os 510 vezes. vezes.

Não a o há uma instruç ao a˜ o especial para efetuar um laço ¸o com teste ao final da iteraç ão ao (como o ... while() em C ), mas laç o do ... mas pode pode-se -se usar usar um while while infinito infinito — usand usando o uma condi condicç ão ao verdadeira, fixa — em combinac com binaç ao a˜ o com um teste e break internos: >>> l = [" ["a" a", , "b" b", , "c" c"] ] >>> i = len(l) - 1 >>> >> > wh whil ile e Tr True ue: : ... print l[i] ... i = i - 1 ... if i < 0: ... break ... c b a

23

Veracidade e falsidade falsi dade de condiç ˜ oes As estruturas if e while utilizam utili zam condiç oes o˜ es lógicas ogicas para controle, controle, avalian avaliando-a do-ass de maneira booleana. booleana. Como qualquer qualquer valor valor ou express˜ expressão pode ser usado como condic condi ç ao, a˜ o, e´ importante impor tante entender ent ender qual o mecanismo mecanism o de avaliaç ão ao da linguagem. Em Python, falso e´ denotado:

• pelo booleano False, • pelo valor 0 (zero), • pela lista, dicionário, ario, tupla ou string vazios, de tamanho zero, • pelo valor especial None, que significa nulo. Qualquer outro valor simples e´ considerado verdadeiro. Instâncias ancias podem definir regras mais complexas para avaliaç ao; a˜ o; para detalhes consulte a seç ão ao Basic customization do manual de referência encia Python.

2.5.4

Exceç ˜ oes

Com os dois d ois tipos de laç os descritos na seç ão ao anterior, todas as necessidades ‘normais’ de controle de um programa podem ser implementadas. No entanto, quando algo inesperado ocorre, ou uma um a condi co ndicç ao a˜ o de erro conhecido é atingida, Python oferece uma forma adicional de controlar o fluxo de execuç ao: a˜ o: a excec ex ceç ao. a˜ o. A excec exc eç ao a˜ o e´ um recurso de linguagens de programaç ão ao modernas que serve para informar que uma condic condi ç ao a˜ o incomum ocorreu. Embora existam outras aplicaç oes, o ˜ es, em geral comunicamse através es de exceç oes o ˜ es erros ou problemas problem as que ocorrem ocor rem durante durant e a execuç ão ao de um programa. Exce Ex cecç oes o˜ es são ao internamente internam ente geradas pelo interpretado in terpretadorr Python quando situac sit uaç oes o ˜ es excepcionais ocorrem. No exemplo abaixo, >>> a = [1, 2, 3] >>> >> > pr prin int t a[ a[5] 5]

o codigo o´ digo interno do interpretador sabe que não ao podemos acessar uma lista através es um ´ındi ın dice ce não-existente, ao-existent e, e gera uma exceç ão: ao: Traceb Traceback ack (most (most recent recent call call last): last): File Fi le "< " n>", ", li line ne 1, in ? Inde In dexE xErr rror or: : li list st in inde dex x ou out t of ra rang nge e

Vamos analisar a mensagem exibida. A primeira linha anuncia um traceback, que e´ a forma como e´ exibida exib ida a pilha de execuç ão ao que gerou a exceç ão. ao. A segunda segunda indica indica a linha de c odigo o ´ digo na qual ocorreu o problema, e o arquivo. Como estamos usando o modo interativo neste exemplo, o arquivo aparece como , que e´ a entrada padrão. ao. A terceira terceira linha linha indica indica o tipo de exce ex cecç ao a˜ o levantada — neste caso, IndexError — e informa uma mensagem que descreve mais especificamente especificamente o problema.

24

Tratando Trata ndo exce ex cecç ˜ oes A exceç ao a˜ o normalme normalmente nte imprime imprime um traceba traceback ck e interrompe interrompe a execuc execuç a˜ o do programa. Uma aç ao a˜ o comum e´ testar e controlar contr olar a exceç ao; a˜ o; para este fim, usamos uma cláusula ausula try / except except: >>> a = [1, 2, 3] >>> >> > tr try: y: ... print a[5] ... except except IndexErr IndexError: or: ˜ ... prin pr int t "O ve veto tor r nao nao po poss ssui ui tant tantas as posi posic çoes!" oes!" ˜ O ve veto tor r na nao o po poss ssui ui ta tant ntas as po posi sic c ¸oes! oes!

A inst i nstruc ruç ao a˜ o try captura capt ura exceç oes o˜ es que ocorrerem no seu bloco de código; odigo; a linha except determina determin a quais tipos de exceç ao a˜ o serão ao capturados. A sintaxe da cláusula ausula except segue os formatos: except except tipo_da_ tipo_da_exce excecao cao [, variavel variavel_da_ _da_exce excecao]: cao]: ´ # bloco de c odigo odigo

ou except except (tipo_ex (tipo_exceca cecao_1, o_1, tipo_exce tipo_excecao_2 cao_2, , ...) [, variavel_da_excecao]: variavel_da_excecao]: ´ # bloco de c odigo odigo

O primeiro elemento elemento da cláusula ausula except e´ um tipo da exceç ao, a˜ o, ou uma tupla de tipos caso multiplas u´ ltipl as exceç oes o˜ es devam devam ser tratadas da mesma mesma forma. O segundo elemento elemento é opcional; permite que seja capturada uma instância ancia que qu e armazena ar mazena informaç oes o ˜ es da exceç ao. a˜ o. Um uso trivial trivial desta desta instância ancia e´ imprimir a mensagem de erro: >>> a = "foo" >>> print a + 1 Traceb Traceback ack (most (most recent recent call call last): last): File Fi le "< " n>", ", li line ne 1, in ? Type Ty peEr Erro ror: r: ca cann nnot ot ad add d ty type pe "i "int nt" " to st stri ring ng

Podemos capturar e tratar de forma especial o erro acima, imprimindo a mensagem fornecida e continuando a execuç ao a˜ o normalmente. >>> tr >>> try: y: ... print a + 1 ... except except TypeEr TypeError ror, , e: ... print "Um "Um err erro oco ocorreu: %s" %s" % e ... Um er erro ro oc ocor orre reu: u: ca cann nnot ot ad add d ty type pe "i "int nt" " to st stri ring ng >>>

Diversos tipos de exceç oes o ˜ es vêm em pré-definidas e-definidas pelo interpretador Python; o guia de referência encia contém em uma lista completa e os casos onde são levantadas. Note também em que q ue esta introduç ao a˜ o a Errors and Exceptions Exceptions do tutorial exce excecç oes o˜ es não ao cobre a sua sintaxe completa; consulte a seç ão ao Errors Python para maiores detalhes. 25

2.6

Funç ˜ oes

Func Fu nç oes o˜ es são ao bloc blocos os de de código odigo com um nome; recebem recebem um conjunto conjunto de parâmetros ametros (ou argumentos) e retornam retornam um um valor valor.. Python possui, possui, como seria esperado esperado de uma linguagem linguagem de programa programacç ão ao completa, suporte a funç oes. o˜ es. Existem diversas funç oes o˜ es pré-definidas e-definidas pelo interpretador, descritas na sec se ç ao a˜ o 3; a seç ao a˜ o atual detalha det alha as formas for mas de definir funç oes o ˜ es em em c odigo o´ digo Python.

2.6. 2.6.1 1

Sint Sintax axee basica a´ sica

A sintaxe sin taxe geral para definir defini r uma funç ao a˜ o e: e´ : def nome_f nome_func uncao( ao(arg arg_1, _1, arg_2, arg_2, ..., ..., arg_n) arg_n): : # # bloco de c ´ o digo odig o co cont nten endo do co corp rpo o da fu func nc ¸˜ ao ao # ´ opcion return return valor_de valor_de_reto _retorno rno # retornar retornar e opcional al

O codigo o´ dig o da d a func f unç ao, a˜ o, uma vez avaliado avaliado pelo interpretad interpretador or,, define define um nome local. local. Os argumentos são ao valores fornecidos quando chamada a funç ão, ao, e que ficam dispon´ıveis ıveis por meio de variáveis aveis locais l ocais no corpo da d a funç ao. a˜ o. No exemplo abaixo, temos uma u ma funç ao a˜ o que recebe uma lista de dicionários arios como parâmetro, ametro, e uma u ma func fun ç ao a˜ o que recebe um dicionário. ario. A primeira itera pela lista recebida, e passa o elemento atual como argumento para a segunda. def imprime_ imprime_carda cardapio pio (pratos) (pratos): : print print "Carda "Cardapio pio para para hoje\n hoje\n" " for fo r p in pr prat atos os: : imprime_prato(p) prin pr int t "\ "\nT nTot otal al de pr prat atos os: : %d %d" " % le len( n(pr prat atos os) ) def imprime_ imprime_prato prato(p) (p) print print "%s ...... ........ .. %10.2f %10.2f" " % (p["no (p["nome" me"], ], p["pre p["preco" co"]) ])

Ao ser interpretado, o código odigo acima define dois nomes locais: imprime cardapio e imprime prato . Para que a funç ao a˜ o seja de fato executada, usamos este nome seguido dos argumentos passados entre parênteses: enteses: ´ # de defi fino no di dici cion on´ arios arios descre descreven vendo do os p1 = {" {"no nome me": ": "A "Arr rroz oz co com m br broc ocol olis is", ", p2 = {" {"no nome me": ": "Soj "Soja a co com m le legu gume mes" s", , p3 = {"nome {"nome": ": "Lenti "Lentilha lhas", s", "preco "preco": ": list li sta_ a_pr prat atos os = [p [p1, 1, p2 p2, , p3 p3] ]

pratos pratos "pre "p reco co": ": 9. 9.90 90} } "pre "p reco co": ": 7.80 7.80} } 4.80} 4.80}

# e ch cham amo o um uma a fun unc c ¸˜ a o, pa ao, pass ssan ando do os pr prat atos os co como mo ar argu gume ment nto o imprime_cardapio(lista_pratos)

o que resulta na seguinte seguint e sa´ıda ıda quando executado: 26

Cardap Cardapio io para para hoje hoje Arroz Arroz com brocol brocolis is ...... ......... ..... .. 9.90 9.90 Soja Soja com legume legumes s ...... ......... ..... .. 7.80 7.80 Lentilhas Lentilhas ......... ........... .. 4.80 Tota To tal l de pr prat atos os: : 3

Retornando um valor No exemplo exemplo acima, as funç oes o ˜ es não ao ‘retornam’ valor algum, apenas exibindo exib indo infor i nformac maç ao. a˜ o. Para retornar um valor, basta usar a expressão return dentro dent ro da func f unç ao. a˜ o. A primeira pergunta conceitual aqui seria ‘retornar para quem?’; a resposta direta é ‘para quem invocou a funç ao’. a˜ o’. Demonstrando por exemplos, a funç ao a˜ o abaixo: def bar(t) bar(t): : retu re turn rn "T "The he rai ain n in Spa pain in fa fall lls s ma mai inl nly y in th the e %s. s." " % t

define um valor de retorno, que é uma string; ao chamar esta funç ao a˜ o com um argumento: a = bar("p bar("plai lains" ns") )

o codigo o´ dig o da d a func f unç ao a˜ o e´ avaliado e um valor, retornado, sendo armazenado na variável a (observe o uso do operador de atribuiç ao ão seguido s eguido da chamada da d a func f unç ão). ao). Para Para visualizar visualizar o valor valor retornado, usamos a conveniente instruc inst ruç ao a˜ o print: >>> pr >>> prin int t a The Th e ra rain in in Sp Spai ain n fa fall lls s ma main inly ly in th the e pl plai ains ns. .

Dica: para retornar conjuntos de valores, basta retornar uma seqüˆ uencia eˆ ncia ou outro valor de tipo composto. 2.6.2 2.6.2

Truques ruques com argument argumentos os

Argumentos nomeados Argumentos podem ser fornecidos à func fu nç ao a˜ o especificando-se o nome do parâmetro ametro ao qual corre correspo spond ndem. em. O c odigo o ´ digo abaixo e´ equivalente a` chamada no exemplo anterior: a = bar(t= bar(t="pl "plain ains") s")

mas fica explicitamente declarado que o parâmetro ametro correspond correspondee ao argumen argumento to t. NormalNormalmente são ao nomeados argumentos para tornar a leitura do código odigo mais fácil; acil; no entanto, veremos a seguir como são ao essenciais para utilizar uma das formas de listas de argumentos variáveis. aveis.

27

Valores padr ˜ padr ˜ ao Uma das funcionalidades funci onalidades mais mai s interessantes interessan tes nas func fun ç oes ões Python e´ a possibilidade de definir valores padrão: ao: def aplica_m aplica_multa( ulta(valo valor, r, taxa=0.1) taxa=0.1): : retu re turn rn va valo lor r + va valo lor r * ta taxa xa

Neste Neste exemp exemplo, lo, o valor valor padr˜ padrão ao para para a vari´ variável avel taxa e´ 0.1; .1; se se não ao for definido definido este este argumen argumento, to, o valor padrão ao será utilizado. >>> print print aplica_mu aplica_multa(1 lta(10) 0) 11.0 >>> print print aplica aplica_mu _multa lta(10 (10, , 0.5) 0.5) 15.0

Dica: Não ao utilize como valor padrão ao listas, dicionários arios e outros valores mutáveis; aveis; os valores padrão ao são ao avaliados avaliados apenas apenas uma vez e o resultado obtido obtido não é o que intuitivamente intuitivamente se esperaria. esperaria. Conjuntos de argumentos opcionais Uma forma de definir conjuntos de argumentos opcionais utiliza parâmetros ametros ‘curinga’ ‘curinga’ que assumem valores valores compostos compostos.. Pode ser fornecido fornecido um parâmetro ametro cujo nome e´ prefixado por um s´ımbolo ımbolo asterisco, que assumir´ assumir á um conjunto ordenado de argumentos: def desculpa desculpa(alvo (alvo, , *motivos *motivos): ): d = "D "Des escu culp lpas as %s %s, , ma mas s es esto tou u do doen ente te" " % al alvo vo for fo r mo moti tivo vo in mo moti tivo vos: s: d = d + " e %s" % motivo retu re turn rn d + ". "." " >>> descul desculpa( pa("se "senho nhor", r", "meu "meu gato gato fugiu" fugiu", , ... "minha tia veio visitar") "Descu "Des culp lpas as se senh nhor or, , ma mas s es esto tou u do doen ente te e me meu u ga gato to fu fugi giu u e mi minh nha a tia veio veio visita visitar." r."

ou um parâmetro ametro que assume um conjunto de argumentos nomeados, prefixado de dois asteriscos: def equipe(d equipe(direto iretor, r, produtor, produtor, **atores **atores): ): for person personage agem m in atores atores.ke .keys( ys(): ): print print "%s: "%s: %s" % (perso (personag nagem, em, atores atores[pe [perso rsonag nagem] em]) ) prin pr int t ""-" " * 20 prin pr int t "D "Dir iret etor or: : %s %s" " % di dire reto tor r print print "Produ "Produtor tor: : %s" % produt produtor or >>> equipe(d equipe(direto iretor="P r="Paul aul Anderson Anderson", ", ... produtor="Paul Anderson",

28

... ...

Frank="Tom Cruise", Edmund="Pat Healy", Linda="Julianne Moore")

Frank: Frank: Tom Cruise Cruise Edmund Edmund: : Pat Healy Healy Linda: Linda: Julian Julianne ne Moore Moore -------------------Direto Diretor: r: Paul Paul Anders Anderson on Produtor Produtor: : Paul Anderson Anderson

ou ainda as duas formas formas combinada combinadas. s. Estes Estes parâmetros ametros especiais devem necessariamente ser os ultimos u´ ltimos definidos na lista de parâmetros amet ros da func f unç ao. a˜ o. Note que estes argumentos especiais não ao agregam parâmetros ametros que correspondem correspondem a argumentos explicitamente definidos, como alvo, diretor e produtor nos exemplos acima; estes são ao processados de maneira normal. Conjuntos de argumentos opcionais são ao uma excelente forma de conferir flexibilidade a uma func fu nç ao a˜ o mantendo compatibilidade com código odigo pr´ pr e-existente, e´ -existente, sem prejudicar a sua legibilidade.

Escopo de vari aveis a´ veis Embora o tema escopo seja complexo, e não ao esteja restrito apenas a func fu nç oes, o˜ es, cabe aqui uma observaç ão ao sobre o escopo das variáveis aveis definidas definid as no corpo de funç oes. o ˜ es. Tanto as variáveis aveis definidas definid as no corpo de uma funç ão, ao, como a variável avel i no exemplo abaixo, quanto os argumentos argumentos da funç ão a o são ao acess´ıveis ıveis apenas no escopo local; em outras palavras, apenas apenas no bloco de c odigo o ´ digo da própria opr ia func f unç ao. a˜ o. v = 0 w = 1 def verifi verifica( ca(a, a, b): i = 0 ´digo, v, w, a, b e i s ao ˜ ´ # Ne Nest ste e blo loco co de c o a o ac aces ess s ıveis. ıveis. def cancel cancela(x a(x, , y): i = 0 ´digo, v, w, x, y e i s ao ˜ ´ # Ne Nest ste e blo loco co de c o a o ac aces ess s ıveis, ıveis, ˜ ˜ # mas note que *este* i n ao a o te tem m ne nenh nhum uma a re rela lac c ¸ao a o co com m ˜ # o i da func ¸ao ao verifi verifica( ca() ) acima. acima.

Variáveis aveis definidas no corpo principal (ou seja, definidas em um bloco não-indentado, ao-indentado, como as variáveis aveis v e w acima) de um módulo odulo podem ser lidas em qualquer funç ao a˜ o contida naquele 9 arquivo; no entanto, não ao podem ser alteradas . Caso se deseje definir ou atribuir um novo valor a uma variável global, gl obal, existe uma instruc i nstruç ao a˜ o especial, global. Esta instruc instr uç ao a˜ o indica que a variável avel cujo nome for especificado é para ser definida no escopo global, e não ao local. v = 0 9

O motivo pelo qual existe esta distinç ão está intimamente associado a` forma como Python atribui variáveis. Ao realizar uma operaç ão de atribuiç ão, a variável é sempre defi nida no escopo local; acesso a` variável, no entanto, efetua uma busca nos escopos, do mais local para o mais global.

29

def processa processa(t): (t): glob gl obal al v v = 1

No código odig o acima, aci ma, a funç ao a˜ o altera o valor da variável avel global v. Há duas funç oes o˜ es uteis u´ teis para estudar os escopos que se aplicam em um determinado contexto:

• locals(), que retorna um dicionário ario descrevendo o escopo local ao contexto atual; os itens do dicionário ario são ao compostos dos nomes das variáveis aveis definidas neste escopo e os valores aos quais correspondem. correspondem.

• global(), que retorna um dicionário ario semelhante ao da funç ao a˜ o locals(), mas que descreve o escopo global. O escopo de variáveis aveis funciona de maneira semelhante quando tratando com métodos etodos e defin de finic iç oes o˜ es de classes, que serão ao discutidos discuti dos na seç ao a˜ o 4.

2.7

Modulos o´ dulos e o comando import

o´ dulo. Como dito anteriormente, cada arquivo contendo código odigo Pytho Python n e´ denominado um m odulo Na grande maioria das ocasiões oes utilizamos um ou mais módulos odulos Python em combinaç a˜ o: o interpretador interativo e´ adequado para realizar experimentos curtos, mas não ao para escrever codigo o´ dig o de produc prod uç ao. a˜ o. Um módulo odulo Python consiste de código-fonte odigo-fonte contido em um arquivo denominado com a extensão ao .py; como tal, pode conter variáveis, aveis , funç oes o˜ es e classes; para fins de nomenclatura, o´ dulo. qualquer um destes elementos contidos em um módulo odulo e´ considerado um atributo do m odulo Python, através e s do módulo, odulo, oferece excelentes mecanismos para modularizar código-fonte. odigo-fonte. Esta Est a modular mod ularizac izaç ao a˜ o pode ter diversas motivac m otivaç oes: o˜ es: o programa programa pode ser grande demais, demais, ter subpartes reusáveis aveis que devem ser separadas, ou ainda necessitar de módulos escritos por terceiros. Esta Est a seç ao a˜ o introduz este conceito através es do comando import.

Importando modulos o´ dulos e atributos de m odulos o´ dulos A instruc inst ruç ao a˜ o básica asica para manipular módulos odulos 10 e´ import. O modulo ´ deve estar no caminho de procura de módulos odulos do interpretador . No exemplo a seguir, um módulo odulo com o nome os.py e´ importado. importado. Observe Observe que a extens˜ extensão ao .py nao i nclu´ıda ıda no n o comando com ando import — apenas o nome principal: ˜ e´ inclu´ >>> im >>> impo port rt os >>> print print os.get os.getcwd cwd() () /home/kiko

O m odulo o´ dulo os define algumas algu mas func fu nç oes o ˜ es internamente. inter namente. No exemplo acima, invocamos a funç ão ao ´ importante esta getcwd() contida neste, prefixando prefixan do a funçao . E ˜ com o nome do modulo ´ 10

O caminho de procura é uma lista de diretórios onde o interpretador Python busca um módulo quando uma instruc inst ruç ão import é processada; normalmente esta lista inclui o diretório atual e os diretórios de biblioteca padrão. Pode ser manipulado pela variável de ambiente PYTHONPATH ou pelo m ódulo ódulo sys.path.

30

impo port rt m odulo ´ odulo, acessamos os atributos de um módulo obse ob serv rvac aç ao: a˜ o: ao usar a forma im odulo usando esta sintaxe, idêntica entica a` utilizada para acessar métodos etodos da lista l ista conforme conf orme descrito descr ito na seç ao a˜ o 2.3.2.

Existe uma segunda forma do comando import que funciona de forma diferente. Ao invés es de impo import rtaar o módulo odulo inteir inteiro, o, o que nos obriga obriga a usar usar as func funç oes o ˜ es prefi prefixa xada dass pelo pelo nome nome do módulo, odulo, este formato importa um atributo do módulo, odulo, deixando-o acess´ıvel ıvel localmente: localment e: >>> fr >>> from om os im impo port rt ge getc tcwd wd >>> print print getcwd getcwd() () /home/kiko

´ Funç ˜ oes uteis Há algumas funç oes o˜ es pré-definid e-definidas as no interpreta interpretador dor bastante bastante uteis u ´ teis quando lidando com módulos odulos e os atributos contidos em módulos: odulos: ´ • dir(nome m´ m odulo) odulo) retorna retorna uma lista dos nomes nomes dos atributos atributos contidos contidos em um m´ m odulo, o ´ dulo,

o que permite que você descubra interativamente interat ivamente quais s´ımbolos ımbolos e funç oes o ˜ es o compõem. oem. print dir(os) dir(os) a partir do interpretador Python. Experimente, por exemplo, exemplo, executar executar print ´ • reload(nome m´ m odulo) odulo) recarrega o módulo odulo importado a partir do seu arquivo; desta

maneira, alteraç oes o˜ es podem ser efetuadas no arquivo do módulo o dulo e já utilizadas em uma sessão ao do interpretador, sem que seja necessário ario reiniciá-lo. a-lo. O mecanismo m ecanismo de importac i mportaç ao a˜ o possui uma série erie de nuances especiais, que estão ao associados ao topico o´ pico escopo, es copo, introduzido introdu zido na seç ão ao anterior, e aos namespaces, que resumidamente determinam o conjunto conju nto de atributos acess´ıveis ıveis em um determinado det erminado contexto. Uma descric descri ç ão ao mais detalhada destes tópicos opicos e´ ofereci of erecida da na n a seç ao a˜ o Python Scopes and Name Spaces do tutorial Python.

2.8

Strings de documentaç ˜ ao

Um recurso especialmente util u ´ til em Python e´ o suporte nativo à docume doc ument ntac aç ao a˜ o de código odigo por meio de strings localizadas estrategicamente, chamadas docstrings. Modulos, o´ dulos, classes, funç oes o˜ es e até proprieda propriedades des podem ser descritas descritas por meio de docstrings docstrings;; o exemplo exemplo a seguir seguir demonstra demonstra um modulo o´ dulo hipotético, etico, financ.py, documentado documentado adequadamente: adequadamente: """M´ """M ´ o dulo odul o qu que e co cont nt´ em ´ e m fu func nc ¸oes ˜ oes financei financeiras. ras.""" """ def calcula_ calcula_juros juros(val (valor, or, taxa=0.1 taxa=0.1): ): """Cal """Calcul cula a juros juros sobre sobre um valor. valor. Aplica Apli ca um uma a ta taxa xa de ju juro ros s fo forn rnec ecid ida a so sobr bre e um va valo lor r e re reto torn rna a o re resu sult ltad ado. o. Se om omit itid ida a a ta taxa xa, , o va valo lor r ´ utilizado 0.1 0. 1 se ser ra utilizado""" """ # ... class class Pagament Pagamento: o: """Cla """Classe sse que repres represent enta a um pagame pagamento nto a ser efetua efetuado. do.

31

Inclui Inclui informac informac ¸o ˜es de cr e ´dito e d ebito. ´ ebito. Permite Permite efetuar efetuar ˜ ˜ operac ¸oes oes como como devolu devoluc c ¸ao, ao, cancelame cancelamento, nto, transfer transfer ˆ e ncia enci a e paga pa game ment nto o em si si. . Po Poss ssui ui o se segu guin inte te ci cicl clo o de vi vida da: : ... """

As docstrings do módulo odulo acima podem ser visualizadas visualizadas em tempo de execuc execuç ão, ao, e mesmo a partir do modo interativo do interpretador por meio da funç ao a˜ o help() e do atributo doc : >>> import import financ financ >>> help(calcula_juros) help(calcula_juros) Calc Ca lcul ula a ju juro ros s so sobr bre e um va valo lor. r. Aplica Apli ca um uma a ta taxa xa de ju juro ros s fo forn rnec ecid ida a so sobr bre e um va valo lor r e re reto torn rna a o re resu sult ltad ado. o. Se om omit itid ida a a ta taxa xa, , o va valo lor r ´ utiliz 0.1 0. 1 se ser ra utilizado ado >>> print print financ.__ financ.__doc__ doc__ ´ ˜ M´ o dulo odul o qu que e co cont nt´ em e m fu func nc ¸oes oes financei financeiras. ras.

pr opri op a func fu nçao ´ ria ˜ calcula juros; Observe que a funç ao a˜ o help recebe como argumento a pr ´ pode parecer pouco usual mas é um padrão ao comum em Python.

Este recurso e´ extremamente util u´ til para o aprendizado da linguagem quando explorando objetos pré-definidos; e-definidos; utilize-o sempre que estiver necessitando de uma referência encia rápida: apida: >>> len([1,2 len([1,2,3]) ,3]) 3 >>> help(len help(len) ) Help He lp on bu buil iltt-in in fu func ncti tion on le len: n: len(...) len(ob len(objec ject) t) -> intege integer r Retu Re turn rn th the e nu numb mber er of it item ems s of a se sequ quen ence ce or ma mapp ppin ing. g.

Docstrings podem também em ser processadas utilizando ferramentas externas, como o epy11 doc , gerando referências encias em formatos navegáveis aveis como HTML.

Funç ˜ oes pr´ pre-definidas e´ -definidas

3

Python possui uma série erie de func f unç oes o˜ es pré-definidas, e-definidas, que já estão ao dispon´ıveis ıveis quando executamos o interpretador, sem ter que recorrer a bibliotecas externas. externas. Algumas funç oes o ˜ es importantes que ainda não ao foram apresentadas no texto seguem: 11

Dispon´ı Dispon´ı vel em http://epydoc.sourceforge.net/ ; um exemplo da documentaç ão gerada pode ser consultado em http://www.async.com.br/projects/kiwi/api/ .

32

• range(a,b): rece recebe be dois dois inte inteiro iros, s, reto retorn rnaa uma uma list listaa de inte inteir iros os entre entre a e b, não ao incluindo b. Esta funç ao a˜ o e´ freqüentemente uentemente utilizada utili zada para iterar laç os for. >>> print print range( range(1,1 1,10) 0) [1, 2, 3, 4, 5, 6, 7, 8, 9]

• len(a): retorna retorna o comprimen comprimento to da vari´ variável avel a: para listas, tuplas e dicionários, arios, retorna o numero u´ mero de elementos; para strings, o número umero de caracteres; e assim por diante. >>> print print len([1 len([1,2, ,2,3]) 3]) 3 round(a, a, n): rece • round( recebe be um float float e um número; umero; retorna o float arredondado com este

numero u´ mero de casas decimais. pow(a, n): recebe dois inteiros; • pow(a, i nteiros; retorna o resultado da exponenciaç ão ao de a a` ordem n.

´ equivalente a` sintaxe a * * n . E

• chr(a): recebe um inteiro (entre 0 e 255) como parâmetro, retornando o caracter correspondente da tabela ASCII. >>> print print chr(97 chr(97) ) "a"

• unichr(a): como chr(), rece recebe be um inte inteiro iro (aqu (aquii vari varian ando do entr entree 0 e 6553 65535) 5),, reto retorn rnan ando do o caracter Unicode correspondente.

• ord(a): recebe um unico u´ nico caracter como parâmetro, ametro, retornando o seu código odigo ASCII. >>> print print ord("a ord("a") ") 97

• min(a, min(a, b): retorna retorna o menor menor entre a e b, sendo aplicável avel a valores de qualquer tipo. max(a, b): retorna • max(a, retorna o maior entre a e b.

• abs(n): retorna o valor absoluto de um número. umero. • hex(n) e oct(n): retornam uma string stri ng contendo a representaç ao a˜ o em hexadecimal e octal, respectivamente, de um inteiro. Há também em func fu nç oes o˜ es de conversão ao expl´ expl´ıcita ıcita de tipo; as mais freq¨ freq uentemente u ¨ entemente utilizadas incluem:

• float(n): converte um inteiro em um float. >>> print print float( float(1) 1) 1.0

33

• int(n): converte um float em inteiro. >>> print print int(5. int(5.5) 5) 5

• str(n): con converte verte qualqu qualquer er tipo em uma string. string. Tipo Tiposs seqüencias uencias são ao convertidos de forma literal, peculiarmente. >>> print print str([1 str([1,2, ,2,3]) 3]), , str({" str({"a": a": 1}) [1, 2, 3] {’a’ {’a’: : 1}

• list(l) e tuple(l) : con converte vertem m uma seqüencia uencia em uma lista ou tupla, respectivamente. ´ >>> print print list(" list("´ abaco") abaco") ´ [’´ [’ a ’, ’b a’, ’b’, ’, ’a ’a’, ’, ’c ’c’, ’, ’o ’o’] ’]

Além em desta d estass func fu nç oes, o˜ es, existe existe uma grande grande biblioteca biblioteca dispon dispon´´ıvel ıvel nos m´ m odul o ´ dulos os já fornecidos com o Python. Python. Alguns Alguns destes módulos odulos s˜ s ao a˜ o discutidos discutid os na seç ao a˜ o 5; como sempre, o manual Python é a referência encia definitiva no assunto. As seç oes o˜ es seguintes seguint es discutem discut em algumas algum as funç oes o ˜ es pré-definidas e-definidas com comportamento especialmente relevante. relevante.

3.1

Manipulaç ˜ ao de arquivos: arquivo s: a func f unç ˜ ao open()

A func fun ç ao a˜ o open e´ uma das mais poderosas do Python; serve para obter uma referência referência a um objeto do tipo arquivo. Assumindo que temos um arquivo chamado arquivo.txt, contendo um trecho de um livro famoso, podemos codificar o seguinte exemplo: >>> a = open(" open("arq arquiv uivo.t o.txt" xt") ) >>> >> > pr prin int t a >

Uma vez obtida a referência encia ao objeto arquivo, podemos usar métodos etodos espec´ıficos ıficos deste, como o método etodo read(), que retorna o conteúdo udo do arquivo: >>> te >>> text xto o = a. a.re read ad() () >>> >> > pr prin int t te text xto o ‘... ‘. ..Wo Woul uld d yo you u te tell ll me me, , pl plea ease se, , whic wh ich h wa way y I ou ough ght t to go fr from om he here re?’ ?’ ‘Tha ‘T hat t de depe pend nds s a go good od de deal al on wh wher ere e yo you u wa want nt to ge get t to to,’ ,’ said sa id th the e Ca Cat. t. ‘I do don’ n’t t mu much ch ca care re wh wher eree--’ -’ sa said id Al Alic ice. e. ‘The ‘T hen n it do does esn’ n’t t ma matt tter er wh whic ich h wa way y yo you u go go,’ ,’ sa said id th the e Ca Cat. t.

34

Sintaxe

O formato f ormato geral da func fu nç ao a˜ o open e: e´ :

open(nome_do_arquivo, open(nome_do_arquivo, modo)

Ambos os parâmetros ametros são ao strings. strings. O modo determina determina a forma como o arquivo arquivo será aberto e e´ composto de uma ou mais letras; ‘r’ (ou nada) abre para leitura, ‘w’ abre para escrita, ‘a’ abre para escrita, com dados escritos acrescentados ao final do arquivo. Se um s´ımbolo ımbolo ‘+’ for agregado ao modo, o arquivo pode ser lido e escrito simultaneamente.

Metodos e´ todos do objeto arquivo O objeto arquivo possui um conjunto de métodos etodos uteis; u´ teis; os mais importantes são ao descritos abaixo. Note que o arquivo possui um conceito de posiç ão ao atual: em um dado momento, operaç oes o˜ es serão ao realizadas reali zadas com base em uma um a certa posiç ão. ao. Alguns métodos etodos utilizam utili zam ou alteram esta posic po siç ao; a˜ o; outros são ao operac ope raç oes o˜ es globais, gl obais, independentes da posic posi ç ão ao dela.

• read(): como visto visto acima, retorna retorna uma string unica u´ nica com todo o conte´ conteúdo udo do arquivo. • readline(): retorna a próxima oxima linha li nha do arquivo, arq uivo, e incrementa increm enta a posic po siç ão ao atual. • readlines(): retorna todo o conteúdo udo do arquivo em uma lista, uma linha do arquivo por elemento da lista.

• write(data): escrev escrevee a string data para o arquivo, na posic po siç ao a˜ o atual ou ao final do arquivo, arquivo, dependendo dependendo do modo de abertura. Esta funç ão ao falha se o arquivo foi aberto com modo ‘r’.

• seek(n): muda a posic po siç ao a˜ o atual do arquivo para o valor indicado em n. • close(): fecha o arquivo. Qualquer arquivo pode ser aberto e lido desta forma; experimente com esta funç ão, ao, abrindo alguns arquivos locais, lendo e modificando-os.

3.2

Leitur Leitura a do teclad teclado: o: raw input()

Outra Out ra funç ao a˜ o util u´ til sobretudo para programas Python interativos é a funç ao a˜ o raw input : leˆ do teclado uma string, st ring, e a retorna. reto rna. Esta funç ao a˜ o possui um parâmetro ametro opcional, que é uma mensagem a ser fornecida fornecida ao usu´ usu ario. a´ rio. O exemplo seguinte utiliza um módulo odulo com o nome leitura.py: a = ra raw_ w_in inpu put( t("E "Ent ntre re co com m um n u ´mero de 0 a 10: ") n = in int( t(a) a) if not 0 < n < 10: ´ ´ prin pr int t "N "N´ umero umero inv´ invalido." alido." if n % 2 == 0: ´ Pa prin pr int t "E Par" r" else: ´ Impar" ´ prin pr int t "E Impar"

Este exemplo, quando executado e sendo fornecido o número 7, gera ger a a seguinte segui nte sa´ıda: ıda: 35

>>> import import leitur leitura a ´mero de 0 a 10: 7 Ent ntre re co com m um n u ´ ´ E Impar Impar

Orientaç ˜ ao a Objetos

4

Embora termos importantes como classes, objetos e módulos odulos tenham sido introduzidos anteriormente, ainda não ao discutimos em detalhes os conceitos e a implementaç ão ao de orientaç ao a˜ o a objetos (OO) em Python. Python suporta orientaç ao a˜ o a objetos utilizando um modelo flex´ flex´ıvel ıvel e particularmente homogêneo, eneo, que simplifica a compreensão ao dos mecanismos OO fundamentais da linguagem.

4.1

Conceitos de orientaç ˜ ao a objetos

Orien Or ienta tacç ao a˜ o a objetos e´ um termo que descreve uma série erie de técnicas ecnicas para estruturar est ruturar soluç oes o˜ es para pro gram amac aç ˜ ao OO, que e´ problemas computacionais. No nosso caso espec´ espec´ıfico, ıfico, vamos falar de progr um paradigma de programaç ao a˜ o no qual um programa é estruturado em objetos, e que enfatiza os aspectos aspec tos abstrac abst raç ao, a˜ o, encapsulamento, encapsu lamento, polimorfismo polimorfi smo e heranç a 12 . Convenciona Convencionalmente, lmente, um programa tem um fluxo linear, seguindo por uma funç ão ao principal (ou o corpo principal do programa, dependendo da linguagem de programaç ão) ao) que invoca func fu nç oes o˜ es auxiliares para executar certas tarefas à medida que for necessário. ario. Em Python e´ perfeipro gram amac aç ˜ ao procetamente poss´ıvel ıvel programar program ar desta forma, convencionalmente chamada de progr dural. Programas que utilizam conceitos OO, ao invés es de definir funç oes o˜ es independentes que são ao 13 dom´ınio ınio ) em partes inutilizadas em conjunto, dividem conceitualmente o ‘problema’ (ou dom´ dependentes ( objetos), que podem conter atributos que os descrevem, e que implementam o e´ todos). Objeto comportamento do sistema através es de funç oes o˜ es definidas nestes objetos ( metodos Objetoss (e seus métodos) etodos) fazem referência encia a outros objetos e métodos; etodos; o termo ‘envio de mensagens’ é utilizado utili zado para descrever a comunicaç ao a˜ o que ocorre entre os métodos etodos dos diferentes objetos. Na prática, atica, um programa orientado a objetos em Python pode ser descrito como um con junto de classes — tanto pr e-definidas e´ -definidas quanto definidas pelo usuário ario — que possuem atributos e metodos, e´ todos, e que s ao a˜ o instanciadas em objetos, obj etos, durante a execuç ao a˜ o do programa. A seç ao a˜ o seguinte concretiza estes conceitos com exemplos.

4.2

Objet Objetos, os, classe classess e inst inst âncias ancias

Objetos são ao a unidade fundamental de qualquer sistema orientado a objetos. Em Python, como introduzido introdu zido na seç ao a˜ o 2.3.2, tudo e´ um objeto — tipos, valores, classes, funç oes, o ˜ es, métodos etodos e, é claro, instâncias: ancias: todos possuem atributos e métodos etodos associados. asso ciados. Nesta seç ão ao serão ao descritas as estruturas da linguagem para suportar objetos definidos pelo programador . 12

Mais detalhes sobre conceitos fundamentais de OO podem ser obtidos em http://en.wikipedia.org/

wiki/Object-oriented_programming 13

O ‘problema’ ou ‘dom´ı nio’ de um software compreende o conjunto de tarefas essenciais que este deve realizar; por exemplo, exemplo, o dom´ı nio de um editor de textos textos compreende compreende escrever escrever,, corrigir e alterar documento documentoss —e um conceito fundamental, muito provavelmente modelado em uma classe OO, seria o Documento.

36

Classes Em Python, a estrutura fundamental para definir novos objetos é a classe. Uma classe e´ definida em código-fonte, odigo-fonte, e possui nome, um conjunto de atributos e métodos. etodos. Por exemplo, em um programa que manipula formas geométricas, etricas, seria poss´ıvel ıvel conceber uma classe denominada Retangulo:

• Esta classe possuiria dois atributos: lado a e lado b, que representariam as dimensões oes dos seus lados.

• A classe poderia realizar operaç oes o ˜ es como calcula area e calcula perimetro , e que retornariam os valores apropriados. Um exemplo exempl o de uma implement i mplementac aç ao a˜ o poss´ıvel ıvel desta des ta classe cl asse est´ est á no módulo odulo retangulo.py a seguir: class class Retangul Retangulo: o: lado la do_a _a = No None ne lado la do_b _b = No None ne def __init__( __init__(self, self, lado_a, lado_a, lado_b): lado_b): self.l self.lado ado_a _a = lado_a lado_a self.l self.lado ado_b _b = lado_b lado_b ˆ print print "Crian "Criando do nova nova inst inst ancia ancia Retangulo Retangulo" " def calcula_area(self): calcula_area(self): return return self.l self.lado ado_a _a * self.l self.lado ado_b _b ´ def de f calc calcul ula a pe per r ımetro(self): ımetro(self): retu re turn rn 2 * se self lf.l .lad ado_ o_a a + 2 * se self lf.l .lad ado_ o_b b

Esta classe classe define define os dois atributos atributos descrito descritoss acima, e trˆ tr ês es métodos. etodos. Os tr es eˆ s métodos etodos definidos incluem sempre, como primeiro argumento, uma variável avel denominada self , que e´ manipulada no interior do método. etodo. Este Este é um ponto fundamental da sintaxe Python para métodos: etodos: o primeiro argumento e´ especial, e convenciona-se utilizar o nome self para ele; logo a seguir será será discutido para que existe. Dois dos métodos etodos codificados correspondem às as operac oper aç oes o˜ es descritas inicialmente, e há um init it (). O nome metodo e´ todo especial inclu´ıdo: ıdo: in nome dest destee método etodo tem significância ancia particular em Python: e´ o método etodo construtor, um método etodo opcional invocado quando a classe é instanciada, que e´ o nome dado à aç ao a˜ o de criar objetos a partir de uma classe.

Inst ˆ Inst âncias ancias A instância ancia e´ objeto objeto criado criado com base base em uma classe classe definid definida. a. Este Este conceit conceito o é peculiar, e leva l eva algum tempo para se fixar. Uma descriç ão ao abstrata da dualidade classe-instância: ancia: a classe e´ apenas uma matriz, que especifica objetos, mas que não pode ser utilizada util izada diretamente; a instância ancia representa representa o objeto objeto concretizad concretizado o a partir partir de uma classe. classe. Eu costumo dizer dizer que a classe e´ ‘morta’, existindo apenas no código-fonte, odigo-fonte, e que a instância ancia e´ ‘viva’, porque durante a exec execuc uç ao a˜ o do do prog progra rama ma são ao as instância anciass que que de fato fato ‘func ‘funcion ionam’ am’ atrav´ através es da invocaç ao a˜ o de métodos etodos e manipula mani pulacç ao a˜ o de atributos.

37

Conceitualmente, a instância ancia possui possui duas proprieda propriedades des fundamen fundamentais: tais: a classe a partir partir da qual foi criada, que define suas propriedades e métodos padrão, ao, e um estado, que representa o con junto de valores das propriedades propriedades e m étodos etodos definidos naquela instância ancia espec´ıfica. ıfica. A inst ancia aˆ ncia possui um ciclo de vida: e´ criada (e neste momento seu construtor é invocado), manipulada conforme necessário, ario, e destru´ dest ru´ıda ıda quando qu ando n ao a˜ o for mais util u´ til para o programa programa.. O estado da instˆ instância ancia evolui ao longo do seu ciclo de vida: seus atributos são ao definidos e têm em seu valor alterado através es de seus métodos etodos e de manipulaç ao a˜ o realizada por outros objetos. O que Python chama de ‘instância’ ancia’ e´ freqüentemente uentemente denominado ‘objeto’ em outras outras linguage linguagens, ns, o que cria alguma alguma confusão a o uma vez que qualquer dado em Python Python pode ser considerad considerado o um ‘objeto’. ‘objeto’. Em Python, Python, instâncias ancias são ao objetos criados a partir de uma classe definida pelo programador . Retomand Retomando o o nosso exemplo exemplo acima: a partir da classe classe Retangulo que foi definida, poder´ıamos ıamos instanciar i nstanciar objetos retˆ retangulo aˆ ngulo espec´ espec´ıficos: ıficos: um com lados de comprimento 1 e 2, e outro com lados de comprimento 2 e 3: >>> from from retang retangulo ulo import import Retang Retangulo ulo >>> >> > r1 = Re Reta tang ngul ulo( o(1, 1, 2) Criand Criando o nova nova inst inst ancia ˆ ancia Retˆ Retangulo ˆ angulo >>> >> > r2 = Re Reta tang ngul ulo( o(2, 2, 3) ˆ ˆ Criand Criando o nova nova inst inst ancia ancia Retˆ Retangulo angulo

Observe que ao instanciar o retângulo: angulo:

• Foi importado e utilizado o nome da classe seguido de parênteses. enteses. • Foram fornecidos como argumentos — entre parênteses enteses — dois valores, correspondendo aos comprimentos dos lados diferentes dos retângulos angulos (1 e 2 para o primeiro retângulo, angulo, e 2 e 3 para o segundo).

• Estes Estes argum argumen entos tos são a o pass passad ados os — tran transp spar aren ente teme ment ntee — para para o método etodo constr construto utorr da classe classe Retangulo. O código odigo do método etodo est´ est a´ reproduzido aqui para facilitar a leitura: def __init__ __init__(self (self, , lado_a, lado_a, lado_b): lado_b): self.l self.lado ado_a _a = lado_a lado_a self.l self.lado ado_b _b = lado_b lado_b ˆ print print "Crian "Criando do nova nova inst inst ancia ancia Retangul Retangulo" o"

Aqui cabe uma pausa para revelar o propósito osito da variável avel self , definida como primeiro sobre a qual aquele m´ metodo foi ˆ ˆ ´ argumento dos métodos etodos.. Esta Esta vari´ variável avel representa a inst ancia invocado. Esta proprie propriedade dade e´ de importância ancia fundamental para OO em Python, porque através es desta desta vari´ variável avel e´ que atributos e métodos etodos desta instância ancia podem ser manipulados no código odigo dos seus métodos. etodos. Continuando com a análise alise do bloco de código odigo acima:

38

• Nas duas primeiras linhas do método etodo — onde é feita atribuiç ao a˜ o — o código odigo do construtor ˆ ˆ está atribuindo valores para dois atributos, lado a e lado b , na inst ancia , aqui representada pelo argumento self . Neste Neste momento, momento, o estado da instância ancia passa a conter os dois atributos novos. novos.

• O construtor const rutor inclui i nclui uma um a instruc inst ruç ao a˜ o print didática atica que imprime uma mensagem para demonstrar que foi executado; a mensagem m ensagem aparece na sa´ıda ıda do interpret i nterpretador. ador. Uma vez instanciados os retângulos, angulos, podemos acessar seus métodos etodos.. De maneir maneiraa idêntica entica aos métodos etodos da lista apresentados na seç ão ao 2.3.2, a sintaxe utiliza um ponto seguido do nome do metodo e´ todo acompanhado de parênteses: enteses: >>> print print r1.calcul r1.calcula_are a_area() a() 2 >>> print print r2.calcul r2.calcula_per a_perimet imetro() ro() 10

Conforme esperado, as func fu nç oes o ˜ es retornaram os valores apropriados para cada instância. ancia. Fazendo mais uma demonstraç ao a˜ o do uso do argumento self, vamos observar o código odigo de um dos metodos: e´ todos: def calcula_area(self): calcula_area(self): return return self.l self.lado ado_a _a * self.l self.lado ado_b _b

O onipresente argumento self aqui e´ utilizado como meio de acesso aos atributos lado a e lado b. Este código odigo permite visualizar o funcionamento pleno deste mecanismo: ao ser invocado o método etodo calcula area sobre a instância ancia r1, o argumento self assume como valor esta mesma instância; ancia; portanto, acessar atributos de self internamente ao método etodo equivale, na prática, atica, a acessar atributos de r1 externamente. Em Python e´ poss´ıvel, ıvel, inclusive, acessar os atributos da instância ancia diretamente, sem a necessidade de usar um método: etodo: >>> print print r1.lad r1.lado_a o_a 1 >>> print print r1.lad r1.lado_b o_b 2

Os valores, logicamente, correspondem aos inicialmente fornecidos à instância ancia por meio do seu construtor.

Atributos Privados e Protegidos Algumas linguagens permitem restringir acesso aos atria´ vel privada. Pyth butos de uma instância, ancia, oferecendo o conceito de vari avel Python on não ao possui uma const con struc ruç ao a˜ o sintática atica literalmente equivalente, mas existem duas formas de indicar que um atributo não ao deve ser acessado acessado externamente: externamente:

39

• A primeira forma e´ implementada por meio de uma convenc convenç ão, ao, não ao havendo suporte espec´ıfico ıfico na linguagem em si: convenciona convenciona-se -se que atributos e métodos cujo nome e´ iniciado por um sublinhado (como metodo a ) não ao devem ser acessados externamente em situ si tuac aç oes o˜ es ‘normais’.

• A segunda segun da forma fo rma estende esta convenç ão ao com suporte no próprio oprio interpretador: métodos etodos e atributos cujo nome e´ iniciado por dois sublinhados (como metodo a ) são ao considerados dos de fato fato priv privad ados os,, e têm em seus seus nomes nomes alter alterado adoss de maneir maneiraa transp transpare arente nte pelo pelo interpr interpreta etador dor para assegurar esta proteç ao. a˜ o. Este mecanismo é descrito em maior detalhes na seç ão ao Private Variables do tutorial Python.

4.3

Heranc Heranç a

he ranc nç a: uma maUm mecanismo fundamental em sistemas orientados a objetos modernos é hera neira de derivar classes novas a partir da definiç ão ao de classes existentes, denominadas neste contexto classes-base. As classes classes deriva derivadas das possuem possuem acesso acesso transparente transparente aos atributos atributos e métodos das classes base, e podem redefinir estes conforme conveniente. Hera Heranc nç a é uma forma simples de promover reuso através es de uma generalizaç ao: a˜ o: desenvolvese uma classe-base com funcionalidade genérica, erica, aplicável avel em diversas situaç oes, o ˜ es, e definem-se subclasses concretas, con cretas, que qu e atendam a situaç ões oes espe e spec´ c´ıficas. ıfic as. Classes Python suportam heranç a simples e heranç a m últipla. ultipla. Os exemplos até agora evitaram o uso de heranç a, mas nesta seç ão ao e´ poss´ p oss´ıvel ıvel apresentar a sintaxe geral para definiç ão ao de uma classe: class class nome-cla nome-classe(b sse(base1 ase1, , base2, base2, ..., basen): basen): atribu atributoto-1 1 = valorvalor-1 1 . . atribu atributoto-n n = valorvalor-n n ´ def nome-m nome-m´ etodoetodo-1(s 1(self elf, , arg1, arg1, arg2, arg2, ..., ..., argn): argn): ´ # bloco de c ´ o digo do m etodo odi etodo . . ´ def nome-m nome-m´ etodoetodo-n(s n(self elf, , arg1, arg1, arg2, arg2, ..., ..., argn): argn): ´ # bloco de c ´ o digo do m etodo odi etodo

Como pode ser observado acima, acima, classes base s ão ao especificadas especificadas entre parˆ par enteses ênteses após os o nome da classe sendo definida. Na sua forma mais simples: class class Foo: Foo: a = 1 def cheese(se cheese(self): lf): print "cheese" "cheese" def foo(self) foo(self): : print print "foo" "foo"

40

class class Bar(Foo) Bar(Foo): : def bar(self) bar(self): : print print "bar" "bar" ´ # m etodo etodo redefini redefinido do

def foo(self): prin pr int t "f "foo oo de ba bar! r!" "

uma instância ancia da classe Bar tem acesso aos métodos etodos cheese(), bar() e foo(), este u´ ltimo sendo redefinido localmente: ultimo >>> b = Bar() >>> b.cheese b.cheese() () cheese >>> b.foo() foo de bar! >>> b.bar( b.bar() ) foo >>> print b.a 1

´ # sa ´ ı da de ıda demo mons nstr tra a m etodo etodo redefinid redefinido o # em Bar

# acesso transparente ao atributo # definido em Foo

enquanto uma instância ancia da classe Foo tem acesso apenas às as func fun ç oes o˜ es definidas nela, foo() e cheese: >>> f = Foo() >>> f.foo( f.foo() ) foo

Invocando m´ metodos e´ todos de classes-base Para acessar os métodos etodos de uma uma classe-b classe-base ase,, usamos usamos uma const con struc ruç ao a˜ o diferente para invocá-los, a-los, que permite especificar qual classe armazena o método sendo chamado. Seguindo o exemplo, vamos novamente a redefinir o método Bar.foo(): class class Bar(Foo) Bar(Foo): : # ... def foo(self) foo(self): : Foo.foo(self) prin pr int t "f "foo oo de ba bar! r!" "

Nesta versão, ao, o método etodo foo() inclui uma chamada ao método etodo Foo.foo(), que conforme indicado pelo seu nome, é uma referência encia direta ao método etodo da classe base. base. Ao instanciar instanciar um objeto desta classe: >>> b = Bar() >>> b.foo( b.foo() ) foo foo fo o de ba bar! r!

41

pode-se observar que são ao executados ambos os métodos etodos especific especificado ados. s. Este padr˜ padrão, ao, aqui demonstrado de forma muito simples, pode ser utilizado em situaç oes o ˜ es mais elaboradas; seu uso mais freqüente uente e´ para invocar, a partir de um construtor de uma classe, o construtor das suas classes-base.

´ Funç ˜ oes Uteis instâncias: ancias:

Há duas d uas funç oes o˜ es particularmente uteis u ´ teis para estudar uma hierarquia de classes e

• isinstance(objeto, isinstance(objeto, classe) : retorna verdadeiro se o objeto for uma instância ancia da classe especificada, ou de alguma de suas subclasses.

• issubclas issubclass(cl s(classe asse a, classe classe b) : retorna retorna verdadeiro verdadeiro se a classe classe especificad especificadaa como classe a for uma subclasse da classe b , ou se for a própria opria classe b .

Atributos de classe versus atributos de inst ˆ inst ância ancia Uma particularidade em Python, que deriva da forma transparente como variáveis aveis são ao acessadas, é a distinc dist inç ao a˜ o entre atributos definidos em uma classe, e atributos definidos em uma instância ancia desta classe. Observe o código odigo a seguir: class class Foo: Foo: a = 1

A classe acima define uma variável avel a com o valor 1. Ao instanciar esta classe, >>> f = Foo() >>> >> > pr prin int t f. f.a a 1

observa-se que a variável avel parece estar definida na instância. anci a. Esta observa o bservacç ao a˜ o convida a algumas indagac ind agaç oes: o˜ es:

• Onde está definida a variável avel a – na classe ou na instância? ancia? • Se atribuirmos um novo valor a f.a, como abaixo: >>> f.a = 2

estamos alterando a classe ou a instância? ancia?

• Uma vez atribu´ at ribu´ıdo ıdo o novo valor, que valor aparecer´ aparecer á para o atributo a no próximo oximo objeto instanciado a partir de Foo? As respostas para estas perguntas são ao todas relacionadas a um mecanismo central em Python, que e´ o protocolo getattr. Este protocolo dita como atributos são ao transparentemente localizados em uma hierarquia de classes e suas instâncias, e segue a seguinte receita: 1. Ao acessar acessar um atribut atributo o de uma instância ancia (por meio de uma variável avel qualquer ou self) o interpretador tenta localizar o atributo no estado da instância. ancia. 42

2. Caso Caso não ao seja localizado, busca-se o atributo na classe da instância em questão. ao. Por sinal, este passo e´ o que permite que métodos etodos de uma classe sejam acess´ıveis ıveis a partir de suas instâncias. ancias. 3. Caso Caso não ao seja localizado, busca-se o atributo entre as classes base definidas para a classe da instância. ancia. 4. Ao atribuir uma variável avel em uma uma instˆ instância, ancia, este atributo e´ sempre definido no estado local da instância. ancia. Uma vez vez compre compreen endid dido o este este mecani mecanismo smo,, e´ poss´ poss´ıvel ıvel elucid elucidar ar respo resposta stass para para as quest˜ questões oes acima. acima. No exemplo, a variável avel a está definida na classe Foo, e pelo ponto ponto 2 acima descrito, descrito, e´ acess´ ace ss´ıvel ıve l como se fosse definida pela própria opria instância. ancia. Ao atribuir atribuir um valor valor novo a f.a, estamos definindo uma nova variável avel a no estado local da variável avel f, o que não ao tem nenhum impacto sobre a variável avel a definida em Foo, nem sobre novas instâncias ancias criadas a partir desta. Se o descrito acima parece confuso, não ao se preocupe; o mecanismo normalmente funciona exatame exatamente nte da maneira maneira que se esperaria esperaria de uma linguagem linguagem orientada orientada a objetos. objetos. Existe Existe apenas uma situac sit uaç ao a˜ o ‘perigosa’, que ocorre quando usamos atributos de classe com valores mutáveis, mutáveis, como listas listas e dicion´ dicionários. arios. class class Foo: Foo: a = [1,2]

Nesta Nest a situac sit uaç ao, a˜ o, quando criamos uma instância ancia a partir de Foo, a variável avel a pode ser alterada at ribu buic iç ˜ ao, a regra 4 descrita acima não por meio desta instância ancia.. Como Como não ao foi realizada atri ao se aplica: >>> >>> >>> >>> >> > [1,

f = Foo() f.a.appe f.a.append(3) nd(3) g = Foo() prin pr int t g. g.a a 2, 3]

e a variável avel da classe é de fato modificada modificada.. Esta particula particularidad ridadee e´ freqüentemente uentemente fonte de ao se utili utilize ze vari variáveis a´ veis bugs bugs dif´ dif´ıceis ıceis de localizar localizar,, e por este motivo motivo se recomend recomendaa fortemente fortemente que n ˜ de tipos mutaveis a´ veis em classes.

4.4

˜ Introspecç ˜ ao e reflex ao

Intr In trosp ospecc ecç ao a˜ o e reflexão a o são ao propriedades de sistemas orientados a objetos que qualificam a existência encia de mecanismos para descobrir e alterar, em tempo de execuç ão, ao, informa inf ormacç oes o˜ es estruturais sobre um programa e objetos existentes neste. Python possui tanto caracter´ caracter´ısticas ısticas introspectivas introspectivas quanto reflexivas. reflexivas. Permite obter em tempo de execuc exec uç ao a˜ o informa inf ormacç oes o˜ es a respeito do tipo dos objetos, incluindo informaç oes o ˜ es sobre a hierarquia de classe classes. s. Preserv Preservaa também em metadados que descrevem a estrutura do programa sendo executado, e permitindo que se estude como está organizado este sem a necessidade de ler o seu codigo-fonte. o´ digo-fonte. 43

Algumas Algu mas funç oes o˜ es e atributos são ao particularmente importantes neste sentido, e são ao apresentaapresentadas nesta nest a sec s eç ao: a˜ o:

• dir(obj): esta funç ao a˜ o pré-definida e-definida lista todos os nomes de variáveis aveis definidos em um determinado objeto; foi apresentada anteriormente como uma forma de obter as variáveis aveis definidas em um módulo, odulo, e aqui pode ser descrita em sua glória oria completa: completa: descrev descrevee o conteúdo udo de qualquer objeto Python, incluindo classes e instâncias. ancias. obj. j. cl clas ass s : este atributo • ob atributo da instância ancia armazena o seu objeto classe correspondente.

• ob obj. j. di dict ct : este atributo atributo de instâncias ancias e classes oferece acesso ao seu estado local. • obj. obj. module module : este atributo de instâncias ancias e classes armazena uma string com o nome do módulo odulo do qual foi importado. classe. . bases bases : esta atributo da classe armazena em uma tupla as classes das quais • classe

herda.

• classe classe. . name name : este atributo da classe armazena uma string com o nome da classe.

Alguns modulos o´ dulos importantes

5

Há um grande conjunto conjunto de m´ m odulos o ´ dulos que se instalam juntamente com o interpretador Python; são descrito descr itoss nesta nest a seç ao a˜ o alguns dos mais interessantes.

• sys: oferece várias ari as operac oper aç oes o˜ es referentes ao próprio oprio interpretador. Inclui: path , uma lista dos diretórios orios de busca de módulos odulos do python, argv, a lista de parâmetros ametros passados na linha de comando e exit() , uma u ma func fun ç ao a˜ o que termina o programa.

• time: oferece funç oes o˜ es para manipular manipular valores valores de tempo. Inclui: Inclui: time(), uma funç ao a˜ o que retorna o timestamp14 atual; sleep(n), que pausa a execuc execuç ão ao por n segundos; e strftime(n), que formata um timestamp em uma string de acordo com um formato fornecido.

• os: oferece ofer ece func fu nç oes o˜ es relacionadas rel acionadas ao ambiente de execuç ão ao do sistema. Inclui: mkdir(), que cria diret diretorios; o´ rios; rename(), que altera nomes e caminhos de arquivos; e system, que executa executa comandos do sistema.

• os.path: oferece funç oes o˜ es de d e manipu man ipulac laç ao a˜ o do caminho independente de plataforma. Inclui: isdir(p) , que testa se d e´ um diretório; orio; exists(p), que testa se p existe; join(p,m), que retorna uma string com os dois caminhos p e m concatenados.

• string: oferece funç oes o˜ es de manip m anipulac ulaç ao a˜ o de string (que também em estão ao dispon´ disp on´ıveis ıvei s como co mo spli lit( t(c, c, s, p) , que divide a string c em até p parti metodos e´ todos da string). Inclui: sp par ticç oes ˜ separadas separ adas pelo p elo s´ımbolo ımb olo s, retornando-as em uma lista; lower(c), que retorna a string c convertida em minúsculas; usculas; e strip(c), que retorna c removendo espaços ¸o s e quebras de linha do seu s eu in´ıcio ıcio e fim. 14

O número de segundos desde 1 de janeiro, 1970, 1970, que por sinal é a data padrão do in´ı cio do tempo no Unix. o

44

• math: func fun ç oes o˜ es matemáticas aticas gerais. gerai s. Inclui func f unç oes o˜ es como cos(x) , que retorna o cosseno hypot(x, x, y); que retorna a distância de x; hypot( ancia euclidiana entre x e y; e exp(x) ; que retorna o exponencial de x.

• random: gerac ger aç ao a˜ o de números umeros randômicos. omicos. Inclui: Inclui: random(), que retorna um número umero randômico o mico entre 0 e 1; randrange(m,n), que retorna um randômico omico entre m e n; choice(s), que retorna um elemento randômico omico de uma seqüˆ uência encia s.

• getopt: processamento de argumentos de comando de linha; ou seja, os parâmetros parâmetros que passamos para o interpretador inter pretador na linha linh a de execuç ão. ao. Inclui: getopt(), que retorna duas listas, uma com argumentos argument os e outra out ra com opc op ç oes o ˜ es da linha de comando.

• Tkinter: um módulo odulo que permite a criaç ao a˜ o de programas com interface gráfica, afica, incluindo janelas, botões oes e campos texto. A documenta docum entacç ao a˜ o do Python inclui i nclui uma descric descr iç ao a˜ o detalhada (e muito boa) de cada um destes modulos o´ dulos e de seus membros.

5.1

Modulos o´ dulos independentes independentes

Al´ Alemdosm´ e´ mdosmódulos odulos distribu distribu´´ıdos ıdos com o Python, Python, existem existem vário a rioss módulos odulos auxiliare auxiliares. s. Justamente Justamente por serem numerosos numerosos e independentemente independentemente fornecidos, não ao é poss´ıvel ıvel descrevˆ descreve-los eˆ -los na sua totalidade; vou apenas citá-los; a-los; podem po dem ser obtidas obti das maiores informac i nformaç oes o ˜ es nos links providos.

• win32pipe: permite, permite, na plataforma plataforma Windows, Windows, executar executar programas programas win32 e capturar capturar sua sa´ıda ıda em uma string para manipulaç ao a˜ o posterior. Acompanha a distribuiç ao a˜ o Activestate Python: http://www.activestate.com/Products/ActivePython/ .

• PIL: Python Imaging Library, Library, que oferece funç oes o ˜ es para par a processamento, pr ocessamento, manipulaç ão ao e exib exibic iç ao a˜ o de imagens. http://www.pythonware.com/products/pil/

• NumPy: provê mecanismos simples e de alto desempenho para manipular matrizes multidimensionais; dimensio nais; ideal para par a operaç oes o˜ es numéricas ericas de alto volume que necessitem de velocidade. http://numpy.sourceforge.net/

• HTMLgen: uma bibliot bibliotec ecaa de classe classess que gera gera docume documento ntoss HTML HTML confor conforme me padr˜ padrões oes préedefinidos. definidos. Oferece Oferece classes classes para manipul manipular ar tabelas, tabelas, listas, listas, e outros outros elemento elementoss de formatac formataç ão. ao. http://starship.python.net/crew/friedrich/HTMLgen/html/

• DB-API : Database Database Application Application Programming Programming Interface Interface;; na realidad realidade, e, um conjunto de modulos o´ dulos que acessam acessam bases bases de dados dados de uma forma padroniza padronizada. da. A API especifica especifica uma forma homogênea enea de se fazer consultas consul tas e operac o peraç ões oes em bases de dados relacionais (SQL); diversos módulos odulos implementam imp lementam esta est a API para par a bases de dados espec´ıficas. ıficas. http://www.python.org/topic http://www.python.org/topics/databas s/database/ e/

• mx: oferece uma série erie de extensões oes a` linguagem, li nguagem, incluindo incluind o operaç oes o ˜ es complexas de data e hora, h ora, funç oes o˜ es nativas estendidas, e ferramentas para processamento de texto. http://www.egenix.com/files http://www.egenix.com/files/python/ /python/

45

• PyGTK: E´ outro pacote p acote que permite permi te construir constr uir aplicaç oes o ˜ es gráficas aficas com o Python; pode ser usado em conjunto com o Glade, um construtor visual de interfaces. http://www.pygtk.org/

• wxPython : uma biblioteca biblioteca de classes classes que permite permite construir construir aplicac aplicaç oes o ˜ es gráficas aficas multiplataforma usando Python. Há um construtor const rutor visual vi sual de interfaces i nterfaces dispon´ d ispon´ıvel, ıvel, o Boa Constructor. http://www.wxpython.org/ Todos os módulos odulos citados se comportam como módulos odulos Python ‘normais’; são ao utilizados por meio mei o da instruc inst ruç ao a˜ o import, e boa parte part e possui possu i documentac document aç ão ao e s´ımbolos ımbolos internos i nternos list aveis. a´ veis. Esta não ao e´ uma lista exaustiva, e há muitos outros módulos odulos uteis; u´ teis; há boas referências encias que listam módulos odulos externos, exter nos, incluindo inclui ndo o ´ındice ındice de d e pacotes oficial ofici al PyPI: http://www.python.org/pypi.

6

Fecha echame men nto

Aqui termina este tutorial, que cobre os aspectos fundamentais da linguagem Python. Com base no texto, e´ poss´ıvel ıvel enfrentar uma tarefa pr atica, a´ tica, que irá exercitar seu conhecimento e ampliar sua experiência. encia. Escolha um problema, e tente passar da sua modelagem para Python.

46

python na prática

Recommend Documents