1Introdução a Linguagem de Programação Com Python

IN T R O D U Q Á O Á P R O G R A M A Q Á O COM

PYTHON Algoritmos e lógica de programado para iniciantes

novatec

Nilo Ney Coutinho Menezes

introdujo á Programado com Python Algoritmos e lógica de programado para iniciantes

Introdujo á Programado com Python Algoritmos e lógica de programado para iniciantes

Nilo Ney Coutinho Menezes

Klnvafar

Copyright © 2010 da Novatec Editora Ltda. Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodujo desta obra, mesmo parcial, por qualquer processo, sem prévia autorizado, por escrito, do autor e da Editora. Editor: Rubens Prates Revisao gramatical: Patrizia Zagni Editoragáo eletrónica: Camila Kuwabata Capa: Víctor Bittow ISBN: 978-85-7522-250-8 Histórico de impressoes: Novembro/2010 Primeira edi^ao

Novatec Editora Ltda. Rúa Luís António dos Santos 110 02460-000 - Sao Paulo, SP - Brasil Tel.:+55 112959-6529 Fax: +55112950-8869 E-mail: [email protected] Site: novatec.com.br Twitter: twitter.com/novateceditora Facebook: facebook.com/novatec Linkedln: linkedin.com/in/novatec

A minha esposa, Chris, e meusfilhos, Igor, Hanna e Iris.

Sumário

Agradecimentos................................................................................................................... ........................ 11

Prefácio...............................................................................................................12 Introdujo...........................................................................................................13 Capítulo 1* M otivado................................................................................................................................ 16

aaa

1.1Vocé quer aprender a programar?.............................................................. 16 1.2 Como está seu nivel de paciencia?.......................................................... 17 13 Quanto tempo vocé pretende estudar?...................................................... 18 1.4 Qual o objetivo de programar?................................................................. 18 1.4.1 Escrever páginas web.................................................................. 18 14.2 Acertar seu relógio.................................. ....................... ................. 19 1.43 Aprender a usar mapas........................... ................ 1.4.4 Mostrar para seus amigos que vocé sabe programar. 1.4.5 Parecer éstranho..................................................... 1.4.6 Entender melhor como seu computador funciona.............. 20 1.4.7 Cozinhar.......................................................................................... 20 1.4.8 Salvar o m undo..................................................................... 21 1.4.9 Software livre.................................................................................... 21 1.5 Por que Python?....................................................................................... 21 Capitulo 2 Preparando o ambiente....................................................................................................24

2.1 Instalado de Puhor ...............................................................................24 1) i Windows........................................................................................... 24 2.1.2 l.in..x............................................................................................... 30 2.13 Mac OS X...................................................................................30 2.2 Usando o interpretador ......................................................................... >0 23 Editando arquivos.....................................................................................-2 2.-* Cuidados ao dig.tar seos programas..................................................... 36 25 Os primeros programas...........................................................................36 2.6 Cenceños de vaiáveis e atribuido...........................................................39

Introdujo á Programado com Python

Capítulo 3»Variáveis e entrada de dados.............................................................. 44 3.1 Nomes de variáveis.................................................................................. 44 3.2 Variáveis numéricas..................................................................................45 3.2.1 Representadlo de valores numéricos................................................. 46 33 Variáveis do tipo Lógico........................................................................... 48 331 Operadores relacionáis.....................................................................48 33.2 Operadores lógicos.................................................................... 50 333 Expressóes lógicas............................................................................ 53 3.4 Variáveis siring.........................................................................................54 3.4.1 Operases co::: strings.....................................................................56 33 Sequéncias e tempo.................................................................................. 61 3.6 Rastreamento...........................................................................................62 3.7 Kntrada de dados.....................................................................................63 3.71 Conversao da entrada de dados........................................................ 64 3.72 Errus comuns.................................................................................. 66 Capítulo 4 “Condi^oes.......................................................................................... 69 4.1 if...............................................................................................................69 4.2 else...........................................................................................................73 43 Escrutaras anmhadas...............................................................................74 4.4 elif............................................................................................................76 Capítulo 5«Repeti^óes.........................................................................................78 5.1 Contadores............................................................................................... 80 5.2 Acumuladores..........................................................................................83 5.3 Interrompendo a repetido....................................................................... 85 5.4 RepetiQoes aninhadas.............................................................................. 87 Capitulo 6 Listas.................................................................................................90 6.1 Trabalhando com índices......................................................................... 92 6.2 Cópia e íanamento de listas..................................................................... 93 63 Tamanho de listas............................................................. 95 6.4 Adi^üo de elementos................................................................................ 96 63 Remojo de elementos da lista................................................................99 6.6 Usando listas como filas.........................................................................100 6.7 Uso de listas como pilhas........................................................................101 6.8 Pesquisa.................................................................................................103 6.9 Usando for..............................................................................................-04 6.10 Range....................................................................................................106 6.1J Enumérate.............................................................................................107 6.12 Operantes com lisias............................................................................ 1C8 613 Aplicables.............................. 108 6.14 Listas com strings............................................................................110

Sumário

6.15 Listas dentro de listas............................................................................... 110 6.16 O rdenado................................................................. 112 6.17 Dicionários.................................................................................................U7 6.18 Dicionários com listas.............................................................................. 120 Capítulo 7 » Trabalhando com strin g s................................................................................................... 123

7.1Verificagao parcial de strings:...................................................................... 124 7.2 Contagem................................................................................................... 126 73 Pesquisa de strings..................................................................................... 126 7.4 Posicionamento de strings.......................................................................... 129 75 Quebra ou separadlo de strings................................................................ 130 7.6 Substituidlo de strings................................................................................ 131 7.7 Remogáo de espagos em branco................................................................. 131 7.8 Validagao por tipo de conteúdo..................................................................132 7.9 Formatagáo de strings................................................................................134 7.9.1 Formatagao de números.................................................................137 7.10Jogo da forca...............................................................................................141 Capítulo 8 ■F u n d e s ........................................................................................................................................145

8.1Variáveis locáis e globais............................................................................. 151 8.2 Fungoes recursivas............................................................... 83 Validagao............ .7.................................................................................................................. 156 8.4 Parámetros opcionais.................................................................................157 8.5 Nomeando parámetros...............................................................................159 8.6 FungSes como parámetro..........................................................................160 8.7 Empacotamento e desempacotamento de parámetros..............................162 8.8 Desempacotamento de parámetros........................................................... 162 8.9 Fungoes Lambda........................................................................................ 163 8.10 Módulos................................................................................................... 164 8.11 Números aleatorios................................................... 8.12 A fungao type............................................................................................167 Capítulo 9 ■Arquivos...............................................................................

9.1

Parámetros da linha de comando..................

9.7 Ci«-: oCao Next para continuar. Vocé deve estar com urna janela parecida com a da figura 2.8. Essa janela periilite escolher onde instalar os arquivos do interpretador Python. Vocé pode rnudar a pasta ou simplesmente aceitar o local proposto (padrao). Clique no lio 1:3o Next para continuar.

28

In trodujo á Programado com Python

Figura 2.7 - Janela do instalador do Python.

Figura 2.8 - Janela do instalador pedindo confirmando da pasta (diretório) de instalando do Python. A janela da figura 2.9 permite selecionar que partes do pacote do Python queremos instalar. Essa janela é útil para utilizadores mais av ad ad o s da linguagem, mas vamos simplesmente aceitar o padrao, clicando no botao Next para continuar. Finalmente cometamos a instalar os arquivos que precisamos. Urna barra de progresso como a da figura 2.10 será exibida. Aguarde a finalizado do processo.

Capítulo 2 ■ Preparando o ambiente

29

/\ instalagáo foi concluida. Clique no botáo Finish, mostrado na figura 2.11, para icnninar o instalador.

Figura 2.11 - Janela clcfimHzci0o do instalador.

30

In trodujo á Programado com Python

2 .1 .2 L in u x

Grande parte das d i s t r ib u t e s Linux inclui urna versao do interpretador Python. Porém, as versdes mais utilizadas sao a 2.5 ou a 2.6. Precisamos do interpretador na versao 3.1 ou superior. Para verificar a versao de seu interpre­ tador, digite python -V na linha de comando. No U buntu (versao 10.04), digite: sudo apt-get i n s ta ll python3.1 sudo apt-get in s ta l l idle-python3.1

Vocé precisa de permissoes de administrador (root) para efetuar a instalagáo. 2 .1 .3 M ac OS X

Tanto o Mac OS X Leopard quanto o Snow Leopard vém com urna versao do interpretador Python da Apple. No entanto, essa versao nao é a versao 3.1. Para contornar o problema, instale o MacPorts1, fazendo o download do arquivo dmg e depois instalando o Python 3.1 com: sudo port in s ta l l python31

Para executar o interpretador recém-instalado, digite python3.l na linha de comando.

2.2 Usando o interpretador Com o Python instalado, vamos comegar a trabalhar. O IDLE é urna interface gráfica para o interpretador Python, permitindo também a edigao e execugao de nossos programas. N o Windows, vocé deve ter urna pasta no m enu Iniciar > Programas > Python 3.1. Escolha IDLE. No Linux, abra o terminal e digite: idle-python3.1

&

No Mac OS X: abra o terminal e digite: IDLE3.1 &

1 http://www.macports.org/

Capítulo 2 ■ Preparando o ambiente

31

A janela inicial do IDLE, no Windows 7, é mostrada na figura 2.12. Se vocé utiliza o Mac OS X, Linux ou urna versäo diferente de Windows, essa janela nao será exatamente igual à d a figura, mas muito parecida.

Figura 2.12 - Janela inicial do IDLE. Observe que o cursor está posicionado dentro da janela Python Shell e que a linha de comandos é iniciada pela sequencia » > . Digite: p rin t(" O i” )

Pressione a tecla ENTER. Vocé deve obter urna tela parecida com a d a figura 2.13.

Figura 2.23 - IDLE mostrando o resultado de print(ccOi”). Uma das grandes vantagens do Python é contar com o interpretador de comantíos. Vocé pode abrir urna janela como essa sempre que tiver alguma dúvida em Python. O interpretador permite que vocé verifique o resultado de um comando instantáneamente. Veremos mais adiante que esse tipo de verificagáo é muito importante e facilita o aprendizado da linguagem.

32

Introduçâo à Programado com Python

2.3 Editando arquivos Nem só de experimentos vive o programador Python. Um programa nada mais é que um arquivo-texto, escrito em um formato especial (linguagem). No caso da linguagem Python, podemos usar qualquer editor de textos disponivel: PSPad no Windows, TextMate no Mac OS X, Vi Ou Emacs no Linux. O que você nâo deve utilizar é úm editor de textos como o Microsoft Word ou o OpenOffi.ee. Esses programas gravam seus arquivos em formatos especiáis que nâo podem ser utilizados para escrever programas, salvo se você escolher gravar apenas texto ou simplesmente gravar no formato txt. Além disso, um editor de textos comum nâo foi feito para escrever programas. Você pode também utilizar o editor de textos incluido na instalaçâo do in­ terpretador Python. Com o interpretador aberto, dique no menu File e depois selecione a opçâo NewWindow, como mostra a figura 2.14.

Como utilizamos a versao 3.1 do interpretador, é muito importante que vocé use um editor de textos correto. Isso é, um editor que suporte a edigáo de textos em UTF-8. Se vocé nao sabe o que é UTF-8 ou se o seu editor de textos suporta esse formato de codificagáo, utilize o IDLE como editor de textos. Além de suportar a edigao no formato UTF-8, que permitirá a utilizagao de acentos em nossos programas, ele é preparado para colorir nossos programas em Python, tornando a leitura mais fácil.

Capítulo 2 ■ Preparando o ambiente

33

Figura 215 —Janela do editor de textos do IDLE. Urna nova janela, como a da figura 2.15, deverá aparecer. É nessa janela que cscreveremos nossos programas. Observe que embora parecida com a janela principal do IDLE, a janela tem opgoes de menú diferentes da outra. Para es­ clarecer essa separagao, chamaremos a prim eira de janela do interpretador e a segunda de janela do editor de textos. Se vocé ainda estiver em dúvida, a janela do editor de textos é a que apresenta a opcáo Run no menú. Experimente um pouco e escreva: print("Oi") Su a janela do editor de textos deverá ser semelhante á mostrada na figura 2.16. -

-

i' E'1«1 ‘ ■l'f r •»«•«« i p- > r o ¿ - ; .

-;u;i

Optioni

V»; -iri->ws

Help .1 1

1

-11 |lh : íjC ól: 1 IU

Figura 216 - Editor de textos com o programajá digitado. Agora que escrevemos nosso pequeño programa, vamos salvá-lo. Escolha a Opgao Save do menú File, como mostra a figura 2.17.

34

Introduçâo à Programaçâo corn Python

Iff) | |

Edit Format Run

New Window Open... ' Becent Files... Open Module.,. OassBrawSer Path Browser

:• §

Options Windows .Help

Ctrl-N Ctrl+O .* Alt~M Alt+C

Saveis.,. QrllShift+S Save Copy As,.. Altr-Shift+S Print Window

Ctrl+P

: jin: 2¡Col: 0

Figura 2.17 - Janela do editor de textos com o menú File aberto e a opgdo Save selecionada. Urna janela-padrao de gravadlo de arquivos será exibida. A janela m uda com a versao do sistema operacional, mas se vocé utiliza Windows 7, ela parecerá com a da figura 218. Escreva testpy no nome do arquivo e dique no botáo para salvar. Aten^áo: a extensao .py nao é adicionada automáticamente pelo IDLE. Lembre-se de sempre gravar seus programas escritos em Python com a extensao .py.

Figura 218 - Janela de gravaçâo de arquivos do Windows 7. Agora dique no menu Run para executar seu programa. Vocé pode também pressionar a tecla F5 com o mesmo efeito. Essa operaçâo pode ser visualizada na figura 2.19.

Capitulo 2 ■ Preparando o ambiente

35

Figura 2.19 - Janela do interpretador mostrando a execugáo do programa. Seu program a será executado na outra. janela, a do interpretador. Veja que urna iinha com a palavra RESTART apareceu, como na figura 2.20. Observe que obtivemos o mesmo resultado de nosso prim eiro teste.

Figura 2.20 - Janela do interpretador mostrando a execugáo do programa. Experimente modificar o texto entre aspas e executar novamente o programa, pressionando a tecla F5 na janela do Editor ou selecionando Run no menú. Agora estamos com tudo instalado para continuar aprendendo a programar. Durante todo o livro, programas de exemplo seráo apresentados. Vocé deve digitá-los na janela do editor de textos, gravá-los e executá-los. Vocé pode voltar n Jet" as segoes 2.2 e 2.3 sempre que precisar. Com o tempo essas tarefas serao memorizadas e realizadas sem esforgo. Experimente gravar seus programas em um diretório específico em seu compu tador. Isso ajudará a encontrá-los mais tarde. Urna dica é criar u m diretório pura cada capítulo do livro, mas vocé pode organizar os exemplos como quiser. Vocé pode tam bém fazer cópias dos exemplos e alterá-los sem receio. Em bora

36

In trodujo á Programado com Python

vocé possa baixar todos os exemplos já digitados, é altamente recomendado que vocé leia o livro e digite cada programa. Essa prática ajuda a memorizar as co n struyes da linguagem e facilita a leitura dos programas.

2.4 Cuidados ao digitar seus programas Ao digitar um programa no editor de textos, verifique se vocé o copiou exatamente como apresentado. Em Python, vocé deve tomar cuidado com os seguintes itens: 1. Letras maiúsculas e minúsculas sao diferentes. Assim, print e Print sao

completamente diferentes, causando um erro caso vocé digite o P maiúsculo. No inicio, é comum termos o hábito de escrever a primeira letra de cada linha em letras maiúsculas, causando erros em nossos programas. Em caso de erro, leia atentamente o qué vocé digitou e compare com a listagem apresentada no livro. 2. Aspas sao muito importantes e nao devem ser esquecidas. Toda vez que abrir aspas, nao esquega de fechá-las. Se vocé esquecer, seu programa nao funcionará. Observe que o IDLE muda a cor do texto entre aspas, facilitando essa verificagáo. 3. Parénteses nao sao opcionais em Python. Nao remova os parénteses dos programas e preste a mesma atengáo dada ás aspas para abri-los e fechá-los. Todo paréntese aberto deve ser fechado. 4. Espagos sao muito importantes. A linguagem Python se baseia na quantidade de espago em branco antes do inicio de cada linha para realizar diversas operagoes, explicadas posteriormente no livro. Nao esquega de digitar o texto dos programas com o mesmo alinhamento apresentado no livro. Observe também que o IDLE ajuda nesses casos, avisando sobre problemas de alinhamento. Nunca junte duas linlias em urna só até sentir-se seguro sobre como escrever corretamente em Python.

2.5 Os primeiros programas Vamos analisar nosso primeiro programa. A figura 2.21 mostra a separagáo entre o nome da fungao, os parénteses, a mensagem e as aspas. É muito importante saber o nome de cada urna dessas partes para o correto entendimento dos conceitos e programas apresentados.

Capítulo 2 ■ Preparando o ambiente

37

Figura 2.21 - Ñames dos elementos do primeiro programa. A fungáo print informa que vamos exibir algo na tela. Pode-se dizer que a fungáo exibe urna mensagem na tela do computador. Sempre que quisermos m ostrar ¡ligo para o usuário do computador, como urna mensagem, urna pergunta ou o resultado de urna operagáo de cálculo, utilizaremos a fungáo print. Para separar os programas do texto explicativo do livro, todo trecho de pro­ grama, fungbes, variáveis e demais itens em Python serao apresentados com 11ma fonte de texto diferente (monoespagada), como a utilizada para explicar ¡i fungáo print. V>> 2+3 5

Nlío esquega de pressionar a tecla ENTER para que o interpretador saiba que voce terminou a digitagao. O resultado deve ser apresentado na linha seguinte. Podemos tam bém subtrair valores, como na listagem 2.2.

In tro du jo á Programado com Python

38

Listagem 2.2 - Subtra^áo » > 5-3 2

Podemos combinar adigáo e subtragáo na mesma linha, como mostra a lis­ tagem 23. Listagem 2.3 —A d i0 o e subtra^áo » > 10-4+2 8

A multiplicagao é representada por um asterisco (*), e a divisao, pela barra (/), como m ostra a listagem 2.4. Listagem 2.4 - M ultiplicado e divisao »> 2*10 20

» > 20/4 5.0

Para elevar um número a um expoente, utilizaremos dois asteriscos (**) para representar a operagao de exponenciagáo. Observe que nao há qualquer espago entre os dois asteriscos. Assim, para calcularmos 23, escreveremos de forma semelhante ao conteúdo da listagem 2.5. Listagem 2.5 - E x p o n e n c ia l » > 2**3 8

Podemos tam bém obter o resto da divisao de dois números usando o símbolo %. Assim, para calcularmos o resto da divisao entre 10 e 3, digitaríamos como m ostrado na listagem 2 .6. Listagem 2.6 - Resto da divisao inteira »>

10 %

3

1 » > 16 % 7 2

63 % 8

Capítulo 2 ■ Preparando o ambiente

39

Os parénteses sao utilizados em Python da mesma forma que em expressoes matemáticas, ou seja, para alterar a ordem de execugao de urna operagáo. Para relembrar a ordem de precedencia das operagoes, temos as seguintes prioridades: 1. Exponenciagáo ou potenciagáo (**). 2. M ultiplicado (*) e divisáo (/ e %). 3. Adigao (+) e subtragao (-). A expressáo 1500 + (1500 * 5 / 100) é equivalente a:

1500 Nao esqueja de que, em Python, como na matemática, as operagoes de mesma prior idade sao realizadas da esquerda para direita. Utilize parénteses sempre que precisar alterar a ordem de execugao das operagoes e tam bém para au­ mentar a clareza da fórmula. Exercício 2.1 - Converta as seguintes expressoes matemáticas para que possam ser calculadas usando o interpretador Python. 10 + 20 x 30 4 2 -s- 30 (94 + 2) x 6 -1 Exerdcio 2.2 - Digite a seguinte expressáo no interpretador: 10

%3

* 10 ** 2 + 1 - 10 * 4 / 2

Tente resolver o mesmo cálculo usando apenas lápis e papel. Observe como a prioridade das operagoes é importante.

2.6 Conceitos de variáveis e atribuido Além ele operagoes simples de cálculo, o interpretador tam bém pode ser usado pn ra. realizar operagoes mais complexas e mesmo executar programas com­ pletos. Antes de continuarmos, é importante observar o conceito de variáveis o como podemos usá-las em um programa. Em matemática, aprendemos o epnceito de variável para representar incógnitas em equagoes do tipo x + 1 = 2,

In tro du jo á Programado com Python

40

onde devemos determinar o valor de x resolvendo a equagao. Em programagao, variáveis sao utilizadas para armazenar valores e para dar nome a urna área de memoria do computador onde armazenamos dados. Variáveis seráo melhor estudadas no capítulo 3. Por enquanto, podemos imaginar a memoria do computador como urna grande estante, onde cada compartimento tem um nome. Para armazenar algo nesses compartimentos, usaremos o símbolo de igualdade (=) entre o nome do compartimento e o valor que queremos arma­ zenar. Chamaremos essa operagáo de atribuida o, onde um valor é atribuido a urna variável. Quando lermos nosso programa, as operacoes de atribuigáo serao chamadas de “recebe”, ou seja, urna variável recebe um valor. Para simplificar as explicagoes de como um programa funciona, utilizaremos bolas pretas © com números, para relacionar urna determinada linha a um texto explicativo. Esses símbolos nao fazem parte do programa e nao devem ser digitados nem no interpretador nem no editor de textos. Como quase tudo na vida, aprende-se a programar programando. Vamos escrever outro programa. Observe a listagem 2.7: Listagem 2.7 - 0 primeiro programa com variáveis . a =2O b=3© print (a + b) © Vejamos o que cada linha significa. Em 0> temos a = 2. Leia “a recebe 2 ”. Essa linha diz que urna variável chamada a receberá o valor 2. Variáveis em programagáo tém o mesmo significado que em matemática. Vocé pode entender urna variável como urna forma de guardar valores na memoria do computador. Toda variável precisa ter um nome para que seu valor possa ser utilizado posterior­ mente. Esse conceito ficará mais claro um pouco mais adiante. Em © , temos b = 3. Leia “b recebe 3”. Essa linha realiza um trabalho muito parecido com o da linha anterior, mas a variável se chama b e o valor é o nú­ mero 3. Para entender o que faz essa linha, imagine que criamos um espago na memoria do computador para guardar outro valor, no caso, 3. Para podermos usar esse valor mais tarde, chamamos esse espago de “b”. A linha 0 solicita que o resultado da soma do conteúdo da variável a com o conteúdo da variável b seja exibido na tela. A fungáo print realiza a impressáo, mas antes o resultado de a + b é calculado. Veja que nessa linha estamos ordenando

Capítulo 2 ■ Preparando o ambiente

no programa que calcule a + b e que exiba o resultado na tela. Como em mate­ mática, passamos parámetros ou valores para urna fungáo usando parénteses. lisses parénteses sao requeridos pelo interpretador Python. Vale lem brar de /(x), onde f é o nome da funqáo e x um parámetro. N o exemplo anterior, print é o nome d a fungáo, e o resultado de a + b, o valor passado como parámetro. No decorrer deste livro, veremos diversas fungoes disponíveis no Python para realizar operacoes com o computador, como, por exemplo, 1er valores do teclado i >u gravar dados em um arquivo. Vocé pode experimentar o programa da listagem 2.7 n a janela do interpretador Python, como mostra a segáo 2 .2 . O resultado desse programa pode ser visto na listagem 2 .8. Ijstagem 2.8 - Exemplo mostrado no interpretador >>> a = 2 »> b = 3 >>> p rin t ( a + b ) 5

As duas prim eiras linhas nao enviam nada para a tela, por isso, apenas o re­ sultado da terceira linha é mostrado. Vocé pode estar se perguntando por que criamos duas variáveis, a e b, para somar dois números? Poderíamos ter obtido o mesmo resultado de diversas formas, como na listagem 2.9. Listagem 2.9 - Outra forma de resolver o problema p rin t (2 + 3)

ou mesmo como m ostra a listagem 2 .10. Listagem 2.10 - Outra forma de resolver o problema p rin t (5)

Untáo, por que escolhemos resolver o problema usando variáveis? Primeiramenlu para podermos falar de variáveis, mas também para exemplificar urna grande (Ii ícrenga entre resolver um problema no papel e por meio de u m computador. Quando estamos resolvendo um problema de matemática no papel, como sumar dois números, realizamos diversos cálculos mentalmente e escrevemos parte desse processo no papel quando necessário. Depois de escrito no papel,

In tro du jo á Programado com Python

42

m udar os valores nao é tao simples. Ao programarmos um computador, estamos transferindo esse cálculo para o computador. Como programar é descrever os passos para a solugao do problema, é aconselhável escrevermos programas o mais claramente possível, de forma que possamos alterá-los caso precisemos e, mais importante, que possamos entendé-los mais tarde. N a listagem 2.9, o problema foi representado como sendo a soma de 2 e 3. Se precisarmos m udar as parcelas dessa soma, teremos que escrever outro pro­ grama. Isso tam bém é válido para o primeiro programa, mas observe que ao utilizarmos variáveis estamos dando nome aos valores de entrada de nosso pro­ blema, aumentando, assim, a facilidade de entendermos o que o programa faz. Já a solu^ao apresentada na listagem 2.10 nao descreve o problema em si. Es­ tamos apenas ordenando ao computador que imprim a o número 5 na tela. Nao fizemos qualquer registro do que estávamos fazendo, ou de que nosso problema era somar dois números. Isso ficará mais claro no exemplo a seguir. Veja a listagem 2.11. Listagem 2.11 - Cálculo de aumento de salário sa la rio = 1500 O aumento = 5 © p rin t (s a lá rio + (s a lá rio * aumento / 100)) @

Em O temos urna variável que é chamada salário, recebendo o valor 1500. Em ©, outra variável, aumento, recebe o valor 5. Finalmente, em © descrevemos a fórmula que calculará o valor do novo salário depois de receber um aumento. Teríamos, entáo, um resultado como o da listagem 2.12. Listagem 2.12 - Resultado do aumento de salário no interpretador > » sa lá rio = 1500 > » aumento = 5 » > p rin t (sa lá rio + (s a lá rio * aumento / 100 )) 1575.0

O programa da listagem 2.11 pode ser escrito de forma mais direta, utilizando outra fórmula sem variáveis. Veja a alternativa da listagem 2.13. Listagem 2.13 - Alternativa para o cálculo de aumento de salário p rin t (1500 + (1500 * 5 / 100))

Capítulo 2 ■ Preparando o ambiente

43

O objetivo desse exemplo é apresentar a diferenga entre descrevermos o proble­ ma de forma genérica, separando os valores de entrada do cálculo. O resultado é idéntico: a diferencia está na clareza da representado de nosso problema. Se m udarmos o valor de salário, na prim eira linha da listagem 2 .11, obteremos o resultado correto na saída do programa, sem precisar nos preocuparmos novamente com a fórmula do cálculo. Observe tam bém que, se fizermos a mesma coisa no program a da listagem 2.13, teremos que m udar o valor de salário em duas posigóes diferentes da fórmula, aumentando nossas chances de esquecer urna délas e, consequentemente, de recebermos um resultado incorre to. Ao utilizamos variáveis, podemos referenciar o mesmo valor várias vezes, sem esquecer que podemos utilizar nomes mais significativos que simples x ou y para aumentar a clareza do programa. Por exemplo, na listagem 2.11, registramos a fórmula para o cálculo do aumento especificando o nom e de cada variável, facilitando a leitura e o entendimento. Se vocé já utilizou urna plan ilh a eletrónica, com o M icrosoft Excel ou OpenOffice Cale, o conceito de variável pode ser entendido como as células de urna planilha eletrónica. Vocé pode escrever as fórmulas de sua planilha sem utilizar outras células, mas teña que reescrevé-las toda vez que os valores mudassem. Assim como as células de urna planilha eletrónica, as variáveis de u m program a podem ser utilizadas diversas vezes e em lugares diferentes. Exercído 2.3 - Faga um program a que exiba seu nom e n a tela. E x e rd d o 2 .4 - Escreva um program a que exiba o resultado de 2a x 3b, onde a vale 3 e b vale 5. Exercído 2.5 - M odifique o prim eiro program a, listagem 2.7, de forma a calcular a som a de trés variáveis. Exercído 2 .6 - M odifique o program a da listagem 2.11, de forma que ele calcule u m aum ento de 15% para um salário de R$ 750,00.

CAPÍTULO

3

Variáveis e entrada de dados

O capítulo anterior apresentou o conceito de variáveis, mas há. mais por descobrir. Já sabemos que variáveis tém nomes e que estes permitem acessar os valores dessas variáveis em outras partes do programa. Neste capítulo, vamos ampliar nosso conhecimento sobre variáveis estudando novas operaQoes e novos tipos de dados.

3.1 Nomes de variáveis Em Python, nomes de variáveis devem iniciar obrigatoriamente com urna letra, mas podem conter números e o símbolo sublinhado (_)■Vejamos exemplos de nomes válidos e inválidos em Python na tabela 3.1. Jabela 31 - Exemplo de nomes válidos e inválidos para variáveis Nome al

Válido

Comentarios

Sim

Emboracontenhaumnúmero, onomea1 inicia comletra.

velocidade

Sim

Nomeformadoporletras.

velocidade90

Sim

Nomeformadoporletrase números, mas iniciadoporletras.

salário_médio

Sim

0 símbolosublinha (_) épermitidoefacilita a leituradenomesgrandes.

saláriomedio

Nao

Nomesdevariáveisnaopodemconterespatosembranco.

_b

Sim

0 sublinha ( J éaceitoemnomesdevariáveis, mesmonoinicio.

1a

Nao

Nomesdevariáveisnaopodemcomegarcomnúmeros.

A versáo 3 da linguagem Python permite a utilizadlo de acentos em nomes de variáveis, pois, por padráo, os programas sao interpretados utilizando-se um conjunto de caracteres chamado UTF-8 1, capaz de representar praticamente todos as letras dos alfabetos conhecidos. Variáveis tém outras propriedades além de nome e conteúdo. Urna délas é conhecida como tipo e define a natureza dos dados que a variável armazena. Python tem vários tipos de dados, mas os mais comuns sao números inteiros, 1 http://pt.wikipedia. org/wiki/Uif-8

Capítulo 3 ■Variáveis e entrada de dados

45

números de ponto flutuante e strings. Além de poder armazenar números e letras, as variáveis em Python também armazenam valores como verdadeiro ou falso. Dizemos que essas variáveis sao do tipo lógico. Veremos mais sobre variáveis do tipo lógico na segáo 33.

TRÍVIA A maior parte das linguagens de programaçâo foi desenvolvida nos Es­ tados Unidos ou considerando apenas nomes escritos na língua inglesa como nomes válidos. Por isso acentos e letras consideradas especiáis nao sao aceitos como nomes válidos na maior parte das linguagens de programaçâo. Essa restriçâo é um problema nao só para falantes do portugués, mas de muitas outras línguas que utilizam acentos ou mesmo outros alfabetos. O padráo americano é baseado no conjunto de caracteres ASCII desenvolvido na década de 1960. Com a globalizaçâo da economía e o advento da Internet, as aplicaçôes mais modernas sâo escritas para trabalhar com um conjunto de caracteres dito universal, chamado Unicode r ) . (’) http://pt.wikipedia.org/wiki/Ascii (**) http://pt.wikipedia.org/wiki/Unicode

3.2 Variáveis numéricas Dizemos que urna variável é numérica quando armazena números inteiros ou de ponto flutuante. Os números inteiros sao números sem parte decimal, como 1, 0, -5, 550, -47, 30000. Números de ponto flutuante ou decimais sao números com parte decimal, como 1.0, 5.478,10.478, 30000.4. Observe que 1.0, mesmo tendo zero na parte decimal, é um número de ponto flutuante. Em Python e na maioria das linguagens de programagáo utilizamos o ponto e nao a vírgula como separador entre a parte inteira e fracionária de um núme­ ro. Isso também é urna heranga da língua inglesa. Observe também que nao utilizamos nada como separador de milhar. Exemplo: 1.000,000 (um milháo) é escrito 1000000 .

46

In tro du jo á Programado com Python

Exercício3.1 - Complete a tabela a seguir, marcando inteiro ou ponto flutuante dependendo d o núm ero apresentado. Número 5

3 .2 .1

Tiponumérico ® inteiroO pontoflutuante

5.0

O inteiro© pontoflutuante

4.3

O inteiro© pontoflutuante

-2

® inteiro O pontoflutuante

100

© inteiro O pontoflutuante

1.333

O inteiro® pontoflutuante

R e p re s e n t a d o de v a lo re s n u m é rico s

Internamente, todos os números sao representados utilizando o sistema binário, ou seja, de base 2. Esse sistema permite apenas os dígitos 0 e 1. Para representar números maiores, combinamos vários dígitos, exatamente como fazemos com o sistema decimal, ou de base 10, que utilizamos. Vejamos primeiro como isso funciona na base 10: 531 = 5 x 102 + 3 x 101 + 1 x 10® = 5x100 + 3x10 + 1 x 1 =500+30+1 = 531

Multiplicamos cada dígito pela base elevada a um expoente igual ao número de casas á direita do dígito em questao. Como em 531 o 5 tem 2 dígitos á direita, multiplicamos 5 x 102. Para o 3, temos apenas outro dígito á direita, logo, 3 x 101. Finalmente, para o 1, sem dígitos á direita, temos 1 x 10°. Somando esses componentes, temos o número 531. Fazemos isso tao rápido que é natural ou automático pensarmos desse jeito. A mudanza para o sistema binário segue o mesmo processo, mas a base agora é 2, e nao 10. Assim, 1010 em binário representa: 1010 = l x 2 3 + 0 x 2 z + l x 2 1 + 0 x 2 e = l x 8 + 0 x 4 + l x 2 + 0 x l = 8 + 2 = 10

Autilizacao do sistema binário é transparente em Python, ou seja, se vocé nao solicitar explicitamente que esse sistema seja usado, tudo será apresentado na

Capítulo 3 ■Variáveis e entrada de dados

47

base 10 utilizada no dia-a-dia. A importancia da nogao de diferenga de base é importante, pois ela explica os limites da representagao. O limite de representagáo é o valor mínimo e máximo que pode ser representado em urna variável numérica. Esse limite é causado pela quantidade de dígitos que foram reserva­ dos para armazenar o núm ero em questáo. Vejamos como funciona n a base 10. Se vocé tem apenas 5 dígitos para representar um número, o maior número é 99999. E o m enor seria (-99999). O mesmo acontece no sistema binário, sendo que lá reservamos um dígito para registrar os sinais de positivo e negativo. Para núm eros inteiros, Python utiliza um sistema de precisao ilimitada que permite a representagao de números muito grandes. E como se vocé sempre pudesse escrever novos dígitos á m edida que for necessário. Vocé pode calcular em Python valores como 2 1000000 (2 ** 1000000) sem problemas de representagao, mesmo quando o resultado é um número de 301030 dígitos. Em ponto flutuante, temos limite e problemas de representagao. Um número decimal é representado em ponto flutuante utilizando-se urna m antissa e um expoente (sinal * mantissa x baséac?oma!). Tanto a mantissa quanto o expoente tém u m número de dígitos máximos que lim itam os números que podem ser representados. Vocé nao precisa se preocupar com isso no momento, pois esses valores sao bem grandes e vocé nao terá problemas na m aioria de seus programas. Vocé pode obter mais informagoes acessando http://pt.wikiped.ia. org/wiki/Ponto_flutuante. A versáo 3.1.2 do P ython, ro d an d o em M ac OS X, tem com o lim ites 2.2250738585072014 x lO'308 e 1.7976931348623157 x 10308, suficientemente grandes e pequeños para quase qualquer tipo de aplicagáo. É possível encon­ trar problemas de representagao em fungáo de como os números decimais sao convertidos em números de ponto flutuante. Esses problemas sao bem conhecidos e afetam todas as linguagens de programagao, nao sendo u m problema específico do Python. Vejamos u m exemplo: o núm ero 0.1 nao tem nada de especial no sistema decimal, mas é urna dízima periódica no sistema binário. Vocé nao precisa se preocupar com esses detalhes agora, mas pode investigá-los mais tarde quan­ do precisar (normalmente cursos de computagao apresentam urna disciplina chamada cálculo numérico para abordar esses tipos de problemas). Digite no interpretador 3 * 0.1

48

In tro du jo á Programado com Python

Vocé deve ter obddo como resultado 030000000000000004, e nao 03, como esperado. Nao se assuste: nao é um problema de seu computador, mas de representado. Se for necessário durante seus estudos de cálculos mais preci­ sos ou se os resultados em ponto flutuante nao satisfizerem os requisitos de precisao esperados, verifique os módulos decimals e fractions. A docum entado do Python traz urna página específica sobre esse tipo de problema: http://docs. python. org/py3k/tutoriál/floatingpoint. html.

3.3 Variáveis do tipo Lógico Muitas vezes queremos armazenar um conteúdo simples: verdadeiro ou falso em urna variável. Nesse caso, utilizaremos um tipo de variável chamado tipo lógico ou booleano. Em Python, escreveremos True para verdadeiro e False para falso (listagem 3.1). Observe que o T e o F sao escritos com letras maiúsculas. Listagem 3.1 - Exemplo de variáveis do tipo lógico resultado = True aprovado = False 3 .3 .1

O p e ra d o re s re la c io n á is

Para realizarmos comparagoes lógicas, utilizaremos operadores relacionáis. A lista de operadores relacionáis suportados em Python é apresentada na tabela 3.2. Jabela 3.2 - Operadores relacionáis Operador

Operado

Símbolomatemático

==

¡gualdade

>

maiorque

<

menorque

= <

!=

diferente

&

>=•

maiorou igual

>



O resultado de urna comparagao é um valor do tipo lógico, ou seja, True (verda­ deiro) ou False (falso). Utilizaremos o verbo “avahar” para indicar a resolugáo de urna expressáo.

Capítulo 3 ■Variáveis e entrada de dados

49

l.istagem 3.2 - Exemplo de uso de operadores relacionáis >>> a »> b >>> c >>> d »> a False >>> b True >>> a True >» a True »> b True >>> c True »> d False >>> d True

== b

# # # # #

>a

# b é maior que a?

= a

# b é maior ou igual a a?

= e = 5 é verdadeiro, assim como 5 media print(aprovado)

Se urna expressao contém operagoes aritméticas, estas devem ser calculadas antes que os operadores relacionáis sejam avaliados. Quando avahamos urna expressao, substituimos o nome das variáveis por seu conteúdo e só entáo verificamos o resultado da comparagao. Exercício 3.2 - Complete a tabela abaixo, respondendo True ou False. Considere a = 4 ,b = 10, c = 5.0,d = 1 e f = 5. Expressao

3 .3 .2

Resultado .

a= c

O True©False

ab

O True©False

c!=f

©TrueO False

a==b

O True © False

ca

©True O False

c*= f f>=c

O True © False

'}

,

©True O False

cperagáo de negagáo também é chamada de inversáo, pois um valor verdadeiro negado se torna falso e vice-versa. A tabela verdade do operador not (nao) é ¡ipresentada na tabela 3.4. Tabela 3.4 - Tabela verdade do operador not (nao)

Llstagem 3.4 - Operador not >>> not True False

>>> not False True

3 .3 .2 .2

O perador and

( ) operador and (e) tem sua tabela verdade representada na tabela 3.5. O ope­ rador and (e) resulta verdadeiro apenas quando seus dois operadores forem Verdadeiros. Tabela 3.5 - Tabela verdade do operador and (e)

52

Introduçâo à Programaçào corn Python

Listagem 3.5 - Operador and » > True and True True » > True and False False » > False and True False >>> False and False False

3 .3 .2 .3

O perador or

A tabela verdade do operador or (ou) é apresentada n a tabela 3.6. A regra fun­ dam ental do operador or (ou) é que ele resulta em falso apenas se seus dois operadores também forem falsos. Se apenas um de seus operadores é verdadeiro, ou se os dois o sao, o resultado da operaçâo é verdadeiro. Tabela 3.6 - Tabela verdade do operador or(ou)

Listagem 3.6 - Operador or >>> True o r True True >>> True o r False True » > False or True True » > False or False False Exercido 3 .3 - Complete a tabela a seguir utilizando a - True, b = False e c = True. Expressáo

Resultado

a and a

'® True O False

bandb

O True©False

note

O True ©False

notb

® True O False

Capítulo 3 ■Variáveis e entrada de dados

53

Expressáo

3 .3 .3

Resultado

nota

O True © False

aandb

O True © False

bande

O True© False

aorc

©True O False

borc

©True O False

aorc

©True O False

borc

© TrueO False

cora

® TrueO False

corb

©True O False

core

©TrueO False

borb

O True© False

E x p re ssó e s ló g ic a s

Os operadores lógicos podem ser combinados em expressóes lógicas mais complexas. Quando urna expressáo tiver mais de um operador lógico, avalia-se o operador not (nao) primeiramente, seguido do operador and (e) e finalmente or (ou). Vejamos a seguir a ordem de avaliagáo da expressáo, onde a operacáo sendo avaliada é siiblinhada, e o resultado, mostrado na linha seguinte. Trueor Falseand notírue TrueorFalse True

Os operadores relacionáis também podem ser utilizados em expressóes com operadores lógicos. salário> 1000and idade >18

Nesses casos, os operadores relacionáis devem ser avahados primeiramente. Fagamos salário = 100 e idade = 20.Teremos: salário>1000 and idade >18 100 > 1000and20 >18 FalseandTrue False

A grande vantagem de escrever esse tipo de expressáo é representar condigóes c|iic podem ser avahadas com valores diferentes. Por exemplo: imagine que

Introduçâo à Programaçâo corn Python

54

salario > 1000 and idade > 18 seja urna condigáo para um empréstimo de compra de um carro novo. Quando salário = 100 e idade = 20 , sabemos que o resultado da expressao é falso e podemos interpretar que, nesse caso, a pessoa nao receberia o empréstimo. Avaliemos a mesma expressao com salário = 2000 e idade = 30. salário> 1000and idade >18 2000>1000 and30 >18 TrueandTrue True

Agora o resultado é True (verdadeiro) e poderíamos dizer que a pessoa atende as condigoes para obter o empréstimo. Exercício 3.4 —Escreva urna expressao para determ inar se urna pessoa deve ou nao pagar imposto. Considere que pagam im posto pessoas cujo salário é maior que R$ 1200. Exercício 3.5 - Calcule o resultado d a expressao A % B and C o r D, utilizando os valores da tabela a seguir.

Exercício 3 .6 - Escreva urna expressao que será utilizada para decidir se um aluno foi o u nâo aprovado. Para ser aprovado, todas as m édias d o aluno devem ser maiores que 7. Considere que o aluno cursa apenas très matérias e que a n o ta de cada urna está arm azenada ñas seguintes variáveis: m atérial, matéria2 e matéria3.

3.4 Variáveis string Variáveis do tipo string armazenam cadeias de caracteres como nomes e textos em geral. Chamamos cadeia de caracteres urna sequencia de símbolos como letras, números, sinais de pontuagao etc. Exemplo: Joáo e Maria comem pao. Nesse caso, Joao é urna sequencia com as letras J, o, á, o. Para simplificar o texto utilizaremos o nom e string para mencionar cadeias de caracteres. Podemos imaginar urna string como urna sequencia de blocos, onde cada letra, número ou espago em branco ocupa urna posigáo, como m ostra a figura 3.1.

Capítulo 3 ■Variáveis e entrada de dados

55

String M

J

a

Figura 3.1 - Representaçâo de urna string. Para possibilitar a separagáo entre o texto do seu programa e o conteúdo de urna string, utilizaremos aspas (“) para delimitar o inicio e o fim da sequéncia de caracteres. Voltando ao exemplo anterior, escreveremos “Joao e María comem pao”. Veja que nesse caso nao há qualquer problema em udlizarmos espagos. Na verdade, o computador praticamente ignora tudo que escrevemos entre aspas, mas veremos mais tarde que nao é bem assim. As variáveis do tipo string sao utilizadas para armazenar sequencias de caracteres, normalmente utilizadas em textos ou mensagens. O tipo string é muito útil e bastante utilizado para exibir mensagens ou mesmo para gerar outros arquivos. Urna string em Python tem um tam anho associado, assim como um conteúdo que pode ser acessado caractere a caractere. O tamanho de urna string pode ser obtido utilizando-se a fungao len. Essa fungao retorna o número de carac­ teres na string. Dizemos que urna fungao retorna um valor quando podemos substituir o texto da fungao por seu resultado. A fungao len retorna um valor do tipo inteiro, representando a quantidade de caracteres contidos na string. Se a string é vazia (representada simplesmente por ou seja, duas aspas sem nada entre elas, nem mesmo espagos em branco), seu tamanho é igual a zero. Fagamos alguns testes como mostra a listagem 3.7. Listagem 3.7 - A funcao len » > p rin t (len("A")) 1 >>> p rin t (len("AB")) 2

» > p rin t (lenC "')) 0 >>> p rin t (lenf'O rato roeu a roupa")) 19

Como dito anteriormente, outra característica de strings é poder acessar seu conteúdo caractere a caractere. Sabendo que urna string tem um determinado tamanho,podemos acessar seus caracteres utilizando um número inteiro para representar sua posiçâo. Esse número é chamado de índice e começamos a

Introduçâo à Programaçâo com Python

56

contar de zéro. Isso quer dizer que o primeiro caractère da string é de posiçâo ou indice 0. Observe a figura 3.2. String Ind ice

Conteùdo Figura 3.2 —Indices e conteùdo de urna variâvél string. Para acessar os caracteres de um a string devemos informar o indice ou posiçâo do caractère entre colchetes ([ ]). Como o primeiro caractère de um a string é o de índice 0 , podemos acessar valores de 0 até o tam anho da string menos 1. Logo, se a string contém 9 caracteres, podemos acessar os caracteres de 0 a 8. Veja o resultado de alguns testes com strings na listagem 3.8. Se tentarmos acessar um indice maior que a quantidade de caracteres d a string, o interpre­ tador emitirá um a mensagem de erro. Listagem 3.8 - Manipulaçâo de strings no interpretador » > a = "ABCDEF" >>> p rin t(a [0 ]) A » > p rin t(a [l]) B » > p rin t(a [5 ]) F » > p rin t(a [6 ]) Traceback (most recent c a li l a s t ) : F ile "cstdins", lin e 1, in IndexError: strin g index out o f range » > p rin t(le n (a )) 6

3 .4 .1

O p era çô es com strin g s

As variâveis de üpo string suportam operaçôes como fatiamento, concatenaçâo e composiçâo. Por fatiamento, podemos entender a capacidade de utilizar ape­ nas um a parte de um a string, ou um a fatia. A concatenaçâo nada mais é que poder ju n tar duas ou mais strings em um a nova string maior. A composiçâo é muito utilizada em mensagens que enviamos a tela e consiste em utilizar strings como modelos onde podemos inserir outras strings. Veremos cada um a dessas operaçôes nas seçôes a seguir.

Capítulo 3 ■Variáveis e entrada de dados

57

3 .4 .1 .1 C o n cate n ad o O conteúdo de variáveis string podem ser somados, ou melhor, concatenados. Para concatenar duas strings, utilizamos o operador de adigao (+). Assim, "AB" + "C" é igual a "ABC". Um caso especial de concatenagáo é a repetigáo de urna string várias vezes. Para isso, utilizamos o operador de multiplicagáo (*): "A" * 3 é igual a "AAA". Vejamos alguns exemplos na listagem 3.9. Listagem 3.9 - Exemplo de concatenado » > s = "ABC" » > p rin t (s + "C") ABCC » > p rin t (s + "D" * 4) ABCDDDD » > p rin t ("X" + "-"*10 + "X") X— ............ X » > p rin t (s+"x4 = M +s*4) ABCx4 = ABCABCABCABC

3 .4 .1 .2 Composigao Juntar várias strings para construir urna mensagem nem sempre é prático. Por exemplo, exibir que "3oao tem X anos", onde X é urna variável numérica. Usando a composigao de strings do Python, podemos escrever de forma sim­ ples e clara: "3oáo tem %d anos"

%

X

Onde o símbolo de % foi utilizado para indicar a composigao da string an­ terior com o conteúdo da variável X O %d dentro da primeira string é o que chamamos de marcador de posigao. O marcador indica que naquela posigao estaremos colocando um valor inteiro, daí o %d. I’ython suporta diversas operagoes com marcadores. Veremos mais sobre mar­ cadores em outras partes do livro. A tabela 3.7 apresenta os principáis tipos de marcadores. Veja que os marcadores sao diferentes de acordo com o tipo de variável que vamos utilizar. Tabela 3.7 - Marcadores Marcador

Tipo

%d

Números inteiros

%s

Strings

%f

Númerosdécimais

In tro du jo a Programado com Python

58

Imagine que precisamos apresentar u m número como 001 ou 002, mas que também pode ser algo como 050 o u 561. Nesse caso, estamos querendo apre­ sentar um núm ero com tres posigöes, completando com zeros á esquerda se o número for menor. Podemos realizar essa operagao utilizando "%03d" % X. Observe que adicionamos 03 entre o %e o d. Se vocé precisar apenas que o número ocupe tres posigöes, m as nao desejar zeros ä esquerda, basta retirar o zero e utilizar "Jßd” %x. Isso é muito im portante quando estamos gravando dados em um arquivo ou simplesmente exibindo informagöes na tela. Vejamos alguns exemplos na listagem 3.10. Listagem 3.10 - Exemplo de composi$ao com marcadores » > idade = 22 » > p r in t( “[%d]"

%

idade)

[ 22]

» > print("[%03d]"

%

idade)

[022] » > print("[%3d]" % idade) [ 22]

» > print("[% -3d]" % idade) [22

]

Quando formatamos números decimais, podemos utilizar dois valores entre os símbolo de %e a letra f . O primeiro indica o tam anho total em caracteres a reservar, e o segundo, o núm ero de casas decimais. Assim, %5.2f diz que es­ taremos imprím indo um número decimal utilizando cinco posicöes, sendo que duas sao para a parte decimal. Isso é muito interessante para exibir o resultado de cálculos ou representar dinheiro. Por exemplo, para exibir 5 reais, vocé pode utilizar "R$%f'" %5, mas o resultado nao é bem o que esperamos, pois normalmente utilizamos apenas dois dígitos após a vírgula quando falamos de dinheiro. Vejamos alguns exemplos na listagem 3.11. Listagem 3.11 - Exemplos de composi^ao com números dedmais >>> p r in t( “%5f" % 5) 5.000000 » > p rin tr% 5 .2 f" % 5) 5.00 print(''% 10.5f" % 5)

Capítulo 3 ■Variáveis e entrada de dados

59

O poder da composigáo realmente aparece quando precisamos combinar varios valores em urna nova string. Imagine que Joáo tem 22 anos e apenas R$ 5134 no bolso. Para exibir essa mensagem, podemos utilizar: ”%s tem %d anos e apenas R$%5.2f no bolso" % ("Doao", 22, 51.34)

Python suporta diversas operagoes com marcadores. Veremos m ais sobre marcadores em outras partes do livro. Quando temos mais de u m marcador na string, somos obrigados a escrever os valores a substituir entre parénteses. Agora, vejamos exemplos com outros tipos e utilizando-se mais de urna variável na composiQáo, na listagem 3.12. Listagem 3.12 - Exemplo de composiQáo de string » > nome = “3oao" » > idade = 22 » > grana = 51.34 » > p r in t( ”%s tem %d anos e R$%f no bolso." % (nome, idade, grana)) 3oáo tem 22 anos e R$51.340000 no bolso. » > print("%12s tem %3d anos e R$%5.2f no bolso." % (nome, idade, grana)) 3oáo tem 22 anos e R$51.34 no bolso. » > print("%12s tem %03d anos e R$%5.2f no bolso." % (nome, idade, grana)) 3oáo tem 022 anos e R$51.34 no bolso. » > print("%-12s tem %-3d anos e R$%-5.2f no bolso." % (nome, idade, grana)) 3oao tem 22 anos e R$51.34 no bolso.

3 .4 .1 .3

Fatiam en to

O fatiamento em Python é m uño poderoso. Imagine nossa string de exemplo da figura 3.2. Podemos fatiá-la de forma a escrever apenas seus dois primeiros caracteres AB utilizando como índice [0:2]. O fatiamento funciona com a u ti lizagao d e dois pontos no índice da string. O núm ero á esquerda dos dois pontos indica a posigáo de inicio d a fatia, e o a direita, do fim. No entanto, é preciso ter atengáo ao final, pois no exemplo anterior utilizamos 2, e o C, que é o caractere na posigáo 2, nao foi incluido. Dizemos que isso acontece porque o final da fatia nao é incluido na mesma, sendo deixado de fora. Entenda [0:2] como a fatia de caracteres da posigáo 0 até a posigáo 2, sem incluí-la, ou o intervalo fechado em 0 e aberto em 2. Vejamos outros exemplos de fatias na listagem 3.13.

Introduçâo à Programaçâo corn Python

60

Listagem 3.13 - Exemplo de fatiamento » > S="ABCDEFGHI" > » p rin t (s [0 :2]) AB > » p rin t (s [ l:2 ]) B > » p rin t (s [2 :4 ]) CD > » p rin t (s [0 :5]) ABCDE » > p rin t ( s [ l : 8]) BCDEFGH

Podemos também omitir o número da esquerda ou o da direita para representar do inicio ou até o final. Assim, [:2] indica do inicio até o segundo caractere (sem incluí-lo) e [1:] indica do caractere de posi§ao 1 até o final da string. Observe que nesse caso nem precisamos saber quantos caracteres a string contém. Se omitirmos o inicio e o fim da fatia, estamos fazendo apenas urna copia de todos os caracteres da string para urna nova string. Podemos tam bém utilizar valores negativos para indicar posi^oes a partir da direita. Assim -1 é o último caractere, -2, o penúltimo, e assim por diante. Veja o resultado de testes com índices negativos na listagem 3.14. Listagem 3.14 - Exemplo de fatiam ento com omissáo de valores e com índices negativos » > s="ABCDEFGM" » > p rin t ( s [ :2]) AB » > p rin t ( s [ l : ]) BCDEFGHI » > p rin t (s [ 0 : - 2 ]) ABCDEFG » > p rin t p rin t ( s [ - 1 :]) I >>> p rin t ( s [ -5 :7]) EFG »> p rin t 9] » > Z[0] 15 » > Z[l] 8

» > Z[2] 9

Utilizando o nome da lista e um índice podemos m udar o conteúdo de um elemento. Observe os testes no interpretador, apresentados n a listagem 6.4. Listagem 6.4 - M odificado de urna lista »> »> 15 »> »> 7 »> [7,

Z=[15,8,9] Z[0] Z[0]=7 Z[0] Z 8, 9]

Quando criamos a lista Z, o primeiro elemento era o número 15. Por isso, Z[0] era 15. Quando executamos Z[0]=7, alteramos o conteúdo do primeiro elemento para 7. Isso pode ser verificado quando pedimos para exibir Z, agora com 7,8 e 9 como elementos. Vejamos um exemplo onde um aluno tem cinco notas e n o qual desejamos calcular sua média aritmética. Veja o programa na listagem 6.5. Listagem 6.5 - Cálculo da media notas=[6,7,5J8,9] O soma=0 x=0 while x »> [1, »> [1, »> »> [6, »> [6,

L=[l,2,3j4,5] V=L

L 2, 3,

4, 5]

V 2 , 3, 4 , 5] V[0]=6 V 2 , 3, 4 , 5] L 2 , 3 , 4 , 5]

In tro d u jo h Programado com Python

94

Veja que ao modificamos v, modificamos também o conteúdo de L. Isso porque urna lista em Python é um objeto e, quando atribuimos um objeto a outro, estamos apenas copiando a mesma referencia da lista e nao seus dados em si. Nesse caso, V funciona como um apelido de L, ou seja, V e L sao a mesma lista. Vejamos o que acontece no gráfico da figura 6.1.

Figura 6.1 - D u a s variáveis referenciando a m esm a lista.

Q uando modificamos V [0 ], estamos modificando o mesmo valor de ambos sao referencias, ou apelidos para a mesma lista na memoria.

L [0 ],

pois

Dependendo da aplicacäo, esse efeito pode ser desejado ou nao. Para criar um copia independente de urna lista, utilizaremos outra sintaxe. Vejamos o resultado das operagöes da listagem 6.9. Listagem 6.9 - Copia de listas » > v= l [ : ] » > V [0 ]= 6 »> L

[1, 2j 3,

4,

5]

2, 3, 4,

5]

»> V

[6,

A o e s c r e v e r m o s L [: ] e s t a m o s n o s r e f e r i n d o a u r n a n o v a c o p i a d e L. A s s i m L e V s e re fe re m a á re a s d if e r e n te s n a m e m o r ia , p e r m i tin d o a lte r á -la s d e fo rm a i n d e p e n d e n t e , c o m o n a f i g u r a 6 .2 .

V Figura 6.2 —D uas variáveis referenciando duas listas.

Podemos tam bém fatiar urna lista, da mesma forma que fizemos com strings no capítulo 3.‘Vejamos alguns exemplos no interpretador na listagem 6.10.

Capítulo 6 ■Listas

95

Listagem 6.10 - Fatiamento de listas » > L =[l,2,3j4,5]

»> L[0:5] [1, 2j 3, 4, 5] » > L[:5]

[1, 2, 3, 4, 5] »> L[: -1] [1, 2 , 3 , 4] » > L[l:3]

[2, 3] » > L[l:4]

[2, 3, 4] » > L[3:]

K 5] » > L[:3]

[1,

2,

3]

» > L[-l] 5

»> L[-2] 4

Veja que índices negativos tam bém funcionam. Um índice negativo cometa a contar do últim o elemento, m as observe que cometamos de -1. Assim L[0] representa o prim eiro elemento, L[-l], o último, L[-2], o penúltimo, e assim por diante.

6.3Tamanhode listas Podemos usar a fungáo len com listas. O valor retornado é igual ao núm ero de elementos d a lista. Veja alguns testes na listagem 6.11. Listagem 6.11 -Tam anh o de listas »> >» 3 »> >>>

L=[12,9,5] len(L) V=[] len(V)

A funcáo len pode ser utilizada em repetigoes para controlar o limite dos índices. Veja o exemplo na listagem 6.12.

96

In tro du jo á Programado com Python

Listagem 6.12 - Repetido comtamanho da lista fixo L=[l,2,3] x=0 while x < 3: prin t(L [x ]) x+=l

Isso pode ser reescrito como na listagem 6.13. Listagem 6.13 - Rep etido com tamanho da lista usando len L=[1 j 2j 3]

x=0 while x < len(L): p rin t(L[x]) x+=l

A v a n ta g e m

é q u e s e tro c a rm o s L p a ra :

L=[7j 8,9,10,11,12] O resto do programa continuaría funcionando, pois utilizamos a fungáo len para calcular o tam anho da lista. Observe que o valor retornado pela fungáo len é um núm ero que nao pode ser utilizado como índice, mas que é pérfeito para testarmos os limites de urna lista, como fizemos na listagem 6.13. Isso acontece porque len retorna a quantidade de elementos na lista e nossos índices comegam a ser num erados de 0 (zero). Assim, os índices válidos de urna lista ( l) variam de 0 até o valor de len(L)-l.

6.4 Adifáo de elementos Urna das principáis vántagens de trabalharmos com listas é poder adicionar novos elementos durante a execugáo do programa. Vejamos u m teste no in­ terpretador (listagem 6.14). Para adicionar um elemento ao fim da lista, utilizaremos o método append. Em Python, chamamos um método escrevendo seu nom e logo após o nom e do objeto. Como listas sao objetos, sendo La lista, teremos L.append(valor). Métodos sao recursos de orientagáo a objetos, suportados e muito usados em Python. Vocé pode imaginar um método como urna fungáo do objeto. Quando invocado, ele já sabe a qué'objeto estamos nos referindo, pois o informamos á esquerda do ponto. Falaremos mais sobre métodos no capítulo 10: por enquanto, observe como os utilizamos e saiba que sao diferentes de fungóes.

Capítulo 6 «Listas

97

Listagem 6.14 - Adigáo de elementos á lista » > L=[] >>> L.append("a") »> L [ ’a ’] >>> L.append("b") »> L [ 'a ', 'b '] » > L.appendC'c") »> L [ 'a ', ' b ', ' c 1] » > len(L) 3

Vejamos um program a que le números até que 0 seja digitado. Esse programa ilepois os im prim irá na mesma ordem em que foram digitados (listagem 6.15). Listagem 6.15 - Adi$áo de elementos á lista ;

L = [] while True: n= int(input(''D igite um número (0 s a i):" )) i f n == 0: break L.append(n) while x < len(L): prin t(L [x ]) x=x+l

lisse simples program a é capaz de 1er e imprim ir um número inicialmente indeterminado de valores. Isso é possível porque adicionamos elementos á lista Lconforme necessário. Outra forma de adicionarmos elementos a urna lista é com adigáo de listas (listagem 6.16). Quando adicionamos apenas um elemento, tanto L.append(l) quanto L+[l] produzem o mesmo resultado. Perceba que em L+[l] escrevemos o elemento ¡i adicionar dentro de urna lista ([l]) e que, em append, apenas 1. Isso porque quando adicionamos urna lista a outra o interpretador executa um método chamado extend que adiciona os elementos de urna lista a outra. Vejamos alguns cxcmplos na listagem 617.

In tro d u jo á Programado com Python

Listagem 6.16 - A dido de listas »> l=[] »>

L=L+[1]

>» L [1 ] » > L +=[2]

»> L [1 , 2] > » L + = [ 3 ,4 ,5 ] »>

L

[ 1 , 2 , 3 , 4 , 5]

Listagem 6.17 - A dido de elementos e listas » > L=["a"] >>> L .a p p e n d ( " b " ) »> L [ ' a 'j ’b ‘ ] » > L .e x t e n d ( [ ,,c " ] ) >» L [ 'a ’ , »> .

'b ',

- c 1]

L .a p p e n d ( [ " d " J " e " ] )

»> L [ 'a ',

- b ',

'c ',

[ ' d 1, ' e ' ] ]

>>> L . e x t e n d ( [ " f " , " g " , " h " ] ) »>

L

[ 'a ',

'b ',

' c ' , [ 'd ' j

'e '] ,

'f ,

'g ',

'h ']

O m é t o d o exten d s e q u e r a c e i t a p a r á m e t r o s q u e n a o s e j a m li s t a s . S e v o c é u t i l i z a r o m é t o d o append c o m u r n a l i s t a c o m o p a r á m e t r o , e m v e z d e a d i c i o n a r o s e le ­ m e n t o s n o f i m d a l i s t a , append a d i c i o n a r á a l i s t a i n t e i r a , m a s c o m o a p e n a s u m n o v o e l e m e n t o . T e r e m o s e n t a o l i s t a s d e n t r o d e l i s t a s ( l i s t a g e m '6.18).

Listagem 6.18 - Adiqío de elementos e listas com append »>

L = ["a "]

>>> L .a p p e n d ( [ " b " ] ) >>> L .a p p e n d ( [ ”c ’, , " d " ] ) > » le n ( L ) 3 » > L[ 1 ]

m » > L [2 ] [•C ,

'd ']

99

Capítulo 6 ■Listas

» > len(L[2]) 2 » > L [2 ] [1 ]

'd '

Esse conceito é interessante, pois permite a utilizado de estruturas de dados mais complexas, como matrizes, árvores e registros. Por enquanto, vamos utilizar csse recurso para armazenar múltiplos valores por elemento. Exercício 6.2 - Faga u m program a que leia duas listas e que gere urna terceira com os elementos das duas primeiras. Exercício 6.3 - Faga um program a que percorra duas listas e gere urna terceira sem elementos repetidos.

6.5 Remojo de elementos da lista Como o tamanho da lista pode variar, permitindo a adigáo de novos elementos, podemos tam bém retirar alguns elementos da lista ou mesmo todos eles. Para isso utilizaremos a instrugao del (listagem 6.19). Listagem 6.19 -

R e m o jo de elementos

» > L=[,,a,,,"b","c"] » > del L[l] >» L [ 'a ', 'c '] » > del L[0] »> L

[ ’C ] íi importante notar que o elemento excluido nao ocupa mais lugar na lista, fazendo com que os índices sejam reorganizados, ou melhor, que passem a ser calculados sem esse elemento. Podemos também apagar fatias inteiras de urna só vez (listagem 6.20). Listagem 6.20 - Rem ojo de fatias

>» »> »> [0,

L=list(range(101)) del L[l:99] L 99, 100]

100

In tro du jo à Programaçâo com Python

6.6 Usando listas como filas Urna lista pode ser utilizada como fila se obedecermos certas regras de inclusâo e eliminaçâo de elementos. Em urna fila, a inclusao é sempre realizada no fim, e as remoçôes sao feitas no inicio. Dizemos que o primeiro a chegar é o primeiro a sair (FIFO - First In First Out). É mais simples de entender se imaginarmos urna fila de banco. Quando a agéncia abre pela m anha, a fila está vazia. Quando os clientes começam a chegar, eles vâo diretamente para o fim da fila. Os caixas entâo começam a atender esses clientes por ordem de chegada, ou seja, o cliente que chegou primeiro será atendido primeiro. Urna vez o cliente atendido, ele sai da fila e um novo cliente passa a ser o primeiro da fila e o próximo a ser atendido. Para escrevermos algo similar em Python, imaginaremos urna lista de clientes; representando a fila, onde o valor de cada elemento é igual à ordem de chegada do cliente. Vamos imaginar urna lista inicial com 10 clientes. Se ou tro cliente chegar, realizaremos um append para que ele seja inserido no fim da fila (fila . ' append(último)). Para retirarmos um cliente da fila e atendé-lo, poderíamos fazer del fila[0 ] , porém, isso apagaria o cliente da fila. Se quisermos retirá-lo da fila é, ao mesmo tempo, obter o elemento retirado, podemos utilizar o método pop fila. pop(0 ). O método pop retoma o valor do elemento e o excluí da fila. Passamos 0 como parámetro para indicar que queremos excluir o primeiro elemento. Veja o programa completo na listagem 6.21. Exercício 6 .4 - O que acontece se nâo verificarmos se a lista está vazia antes de chamarmos o método pop? Exercício 6.5 - Altere o program a d a listagem 6.21 de forma a poder trabalhar. com vários comandos digitados de urna só vez. Atualmente; apenas um comando pode ser inserido por vez. Altere-o de forma a considerar operagáo como urna string. Exemplo: AAAFFFS significaría très atendimentos, très chegadas de novos clientes e, finalmente, a saída do programa. Exercício 6.6 - M odifique o program a para trabalhar com duas filas. Para faci­ litar seu trabalho, considere o comando A para atendimento da fila 1 e B para atendimento da fila 2. O mesmo para a chegada de clientes: F para fila 1 e G para fila 2.

Capítulo 6 ■Listas

101

Listagem 6.21 - S im u la d o de urna fila de banco

último = 10 fila = list(ra n g e (ljú ltim o + l)) while True: print("\nExistem %d clien te s na fila" % len(fila)) p rin t(" F ila a tu a l:“, fila) prin t("D ig ite F para adicionar um clie n te ao fim da fila ,”) print("ou A para re a liz a r o atendimento. S para s a ir ." ) operario = in p u t(“Operacao (F, A ou S ):“) i f operagao == "A": if(len(fila))> 0: atendido = fila.pop(0) p rin t("C lie n te %d atendido" % atendido) else: p rin t(" F ila vazi-a! Ninguém para atender.") e l i f operatáo == "F " : último+=l # Incruenta o tic k e t do novo c lien te fila.append(últim oelif operacáo == “S": break e lse: p rin tC ’Operafao inválida! D igite apenas F, A ou S!")

6.7 Uso de listas como pilhas Urna pilha tem urna política de acesso bem definida: novos elementos sao adicionados ao topo. A retirada de elementos tam bém é feita pelo topo. Imagine urna pilha de pratos a lavar. Retiramos o prato que está no topo da pilha para lavar e, se mais alguns pratos chegarem, estes seráo também adicio­ nados ou empilhados ao topo, ou seja, um sobre o outro. N a pilha, o último elemento a chegar é o primeiro a sair (U FO - Last In First Out). Por enquanto vamos nos concentrar ñas pilhas de prato. Veja o programa da listagem 6.22, que simula urna pia de cozinha, cheia de pratos. Vocé deve ter percebido que o exemplo da listagem 6.22 é muito parecido com o programa da listagem 6.21. Isso porque a grande diferenga entre pilhas e filas é o elemento que escolhemos para retirar. Em urna fila, o primeiro elemento é retirado primeiro. Já em pilhas, retira-se a partir do último elemento. A única mudan ija em Python é o valor que passamos para o método pop. N o caso de urna, pilha, como retiramos o último elemento, passamos -1 a pop.

In tro du jo á Programado com Python

102

Listagem 6.22 - Pilha de pratos prato = 5 pilha = list(ra n g e (l,p ra to + l)) while True: print("\nExistem %d pratos na pilha" % len (p ilh a)) p rin t("P ilh a a tu a l:" , pilha) prin t("D ig ite E para empilhar um novo p ra to /') print("ou D para desempilhar. S para s a i r ." ) operacáo = input("Opera?áo (E, D ou S ):") i f o p erado == "D": i f (le n (pilha))> 0 : lavado = p ilh a.p o p (-l) p rin t("P rato %d lavado" % lavado) else: p rin t("P ilh a vazia! Nada para la v a r." ) e l i f o p erado == "E": prato+=l # Novo prato pilha.append(prato) e l i f operacáo == "S": break else: print("O perario inválida! D igite apenas E, D ou S !”)

Vocé pode tam bém observar o uso de pilhas com seu browser de Internet. Abra algumas páginas, clicando em seus links. Observe como o histórico de navega^ao é modificado. Cada novo link adiciona urna página a seu histórico de navegagao. Se vocé clicar em voltar urna página, o browser utilizará a úlüma página que entrou no histórico. Nesse caso, o histórico do browser funciona como urna pilha. Na realidade, ele é u m pouco mais complexo, pois permite que voltemos várias vezes e que depois possamos voltar no outro sentido se necessário (avanzar). Agora fa » S=["mafas", "peras", "kiwis"] » > print(len(S )) 3 > » p rint(S [0])

macas

» > p rin t(S [l]) peras » > p rint(S [2]) kiwis

O programa da listagem 6.37 lé e imprime urna lista de compras até que seja digitado fim. Listagem 6.37 - Lendo e imprimindo urna lista de compras compras=[] while True: produto=input("Produto:") i f produto == "fim": break compras. append(produto) fo r p in compras: print(p)

6.15 Listas dentro de listas Um fator interessante é que podemos acessar as strings dentro da lista letra por letra, usando um segundo índice. Vejamos as listagens 638 e 639.

Capítulo 6 ■Listas

111

Listagem 6.38 - Listas com strings, acessando letras > » S=["maçis", "peras", "kiwis"] >>> p rin t(S [0 ][0]) » > p rin t(S [0 ][l]) > » p rin t(S [l][l] ) e » > print(S [2][2])

Listagem 6.39 - Impressáo de urna lista de strings, letra a letra L=["maçâs", "peras", "kiwis"] for s in L: fo r le tra in s: p rin t(le tra )

Isso nos leva a outra vantagem das listas em Python: listas dentro de listas. Como bonus, temos também que os elementos de um a lista nâo precisam ser do mesmo tipo. Vejamos um exemplo onde teriamos uma lista de compras na listagem 6.40. O primeiro elemento seria o nome do produto, o segundo, a quantidade, e o terceiro, seu preço. Listagem 6.40 - Listas com elementos de tipos diferentes produtol = [ "raaçâ", 10, 0.30] produto2 = [ "pera", 5, 0.75] produto3 = [ "kiwi", 4, 0.98]

Assim, produtol, produto2 , produto3 seriam très listas com très elementos cada uma. Observe que o primeiro elemento é do tipo string, o segundo, do tipo inteiro, e o terceiro, do tipo ponto flutuante (float) ! Vejamos agora outra lista na listagem 6.41 Listagem 6.41 - Listas de listas produtol = [ "maçâ", 10, 0.30] produto2 = [ "péra", 5, 0.75] produto3 = [ “kiwi", 4, 0.98] compras = [ produtol, produto2, produto3] print(compras)

112

Introduçâo à Programaçâo com Python

Agora temos um a lista chamada compras, também com très elementos, mas cada elemento é um a lista à parte. Para imprim ir essa lista, teríamos o programa da listagem 6.42. Listagem 6.42 - Impressáo das compras produtol = [ "maçà", 10, 0.30] produto2 = [ "pêra”, 5, 0.75] produto3 = [ "kiwi", 4, 0.98] compras = [ produtol, produto2, produto3] fo r e in compras: printf'P roduto: %s" % e[0]) print("Quantidade: %d" % e [ l] ) print("P reço: %5.2f" % e[2])

Da mesma. forma, poderiamos ter acessado o preço do segundo elemento com compras [ 1] [2]. Vejamos agora um program a completo, capaz de perguntar nome do produto, quantidade e preço e, no final, im prim ir um a lista de compras completa. Listagem 6.43 - Criaçâo e impressáo da lista de compras compras = [ ] while True: produto = input("Produto: “) i f produto == "fim": break quantidade = int(input("Quantidade: ")) preço = f!oat(input("Preço: ")) compras.append([produto, quantidade, preço]) soma = 0.0 fo r e in compras: print("%20s x%5d %5.2f %6.2f" % (e[0], e [ l ] ,e [ 2 ], e [ l] * e [ 2 ])) soma += e [ l] * e[2] p rin t("T o tal: %7.2f" % soma)

6.16 Ordenado Até agora, os elementos de nossas listas apresentam a mesma ordem em que foram entrados, sem qualquer ordenado. Para ordenar um a lista, realizaremos uma operagao semelhante a pesquisa, mas trocando a ordem dos elemencos

Capítulo 6 ■Listas

113

quando necessário. Um algoritmo rauito simples de ordenagáo é o “Bubble Sort” ou método de bolhas. Por ser lento, vocé nao deve utilizá-lo com listas grandes e é fácil de aprender. A ordenagáo pelo método de bolhas consiste em comparar dois elementos a cada vez. Se o valor do primeiro elemento for maior que o do segundo, eles trocarao de posigáo. Essa operagáo é entao repetida para o próximo elemento até o fim da lista. O método de bolhas exige que percorramos a lista várias vezes. Por isso, utilizaremos um marcador para saber se chegamos ao fim da lista trocando ou nao algum elemento. Esse método tem outra propriedade, que é posicionar o maior elemento na última posicao da lista, ou seja, sua posi^ao correta. Isso permite eliminar um elemento do fim d a lista a cada passagem completa. Vejamos o programa da listagem 6.44. Listagem 6.44 - O rdenado pelo método de bolhas L=[7,4,3,12,8] fim=5 O while fim > 1: © trocou=False © x=0 O while xc(fim-l): © i f L[x] > L[x+1]: © trocou=True © temp=L[x] © L[x]=L[x+l] L[x+l]=temp x+=l i f not trocou: © break fim-=l © fo r e in L: p rin t(e )

Execute o program a e tente entender como ele funciona. Em ©> utilizamos a variável finí para marcar a quantidade de elementos da lista. Precisamos marcar o fim ou a posicao do último elemento porque no “Bubble Sort” nao precisamos verificar o últim o elemento após urna passagem completa. Em © aerificam os se fim> l, pois como comparamos o elemento atual(L[x]) com o seguinte(L[x+l]), precisamos de, no mínimo, dois elementos. Utilizamos a variável trocou em © para indicar que nao realizamos nenhuma troca. O valor de trocou será utili­ zado mais tarde para verificar se já temos a lista ordenada ou nao. A variável

114

Introduçâo à Programaçâo com Python

x O será utilizada como índice, comegando da posigao 0. Nossa condigáo do segundo while 0 é especial, pois temos que garantir um próximo elemento para comparar com o atual. Isso faz com que a condigáo de saída desse while seja x

Um dicionário é acessado por suas chaves. Para obter o prego da alface, digite no interpretador, depois de ter criado a tabela, tabela["Alface"], onde tabela é o nome da variável do tipo dicionário e ‘Alface” é nossa chave. O valor retornado é o mesmo que associamos na tabela, ou seja, 0,45. Diferentemente de listas, onde o índice é um número, dicionários utilizara suas chaves como índice. Quando atribuimos um valor a urna chave, duas coisas podem ocorrer: 1. Se a chave já existe: o valor associado é alterado para o novo valor. 2. Se a chave nao existe: a nova chave será adicionada ao dicionário.

In tro d u jo á Programado com Python

118

Observe a listagem 6.46. Em Oí acessamos o valor associado á chave “Tomate”. Em O , alteramos o valor associado á chave “Tomate” para um novo valor. Observe que o valor anterior foi perdido. Em O í criamos urna nova chave, “Cebóla” que é adicionada ao dicionário. Veja tam bém como Python imprime o dicionário. O utra diferenga entre dicionários e listas é que, ao utilizarmos dicionários, perdemos a nogáo de ordem. Observe que, durante a manipulagao do dicionário, a ordem das chaves foi alterada. Listagem 6 .4 6 - Fundonamento do dicionário » > tab ela = { "Alface": 0.45, "Batata": 1.20, "Tomate”: 2.30, ... “F eijao": 1.50 } » > p rin t(ta b e la ["Tomate"]) O 2.3 » > p rin t(ta b e la ) { 'B a ta ta ': 1.2 , 'A lfa ce': 0.45, 'Tomate': 2.3, 'F e ija o 1: 1.5} » > tabela["Tomate“] = 2.50 O » > print(tabela["Tom ate"]) 2.5 » > tabela["Cebóla”] = 1.20 © » > p rin t(tab e la) { 'B atata': 1.2, 'A lface': 0.45, 'Tomate': 2.5, 'C ebóla': 1.2, 'F e ija o ': 1.5}

Quanto ao acesso aos dados, temos que verificar se urna chave existe antes de acessá-la (listagem 6.47). Listagem 6 .4 7 - Acesso a urna chave inexistente >>> tab ela = { "Alface": 0.45, "Batata": 1.20, ... "Tomate": 2.30, ... "Feijao": 1.50 } >>> print(tabela["M anga"]) Traceback (most recent c a li l a s t ) : F ile "", lin e 1, in KeyError: 'Manga'

Se a chave nao existir, urna excegao do tipo KeyError será ativada. Para verificar se urna chave pertence ao dicionário, podemos usar o operador in (listagem 6.48).

Capítulo 6 ■Listas

119

Listagem 6.48 - V erificado da existencia de urna chave » > tab ela = { "Alface": 0.45, "Batata": 1,20, "Tomate": 2.30, "Feijao": 1.50 > >>> print("Manga" in tabela) False >>> print("B atata" in tabela) True

Podemos também obter urna lista com as chaves do dicionário, ou mesmo urna lista dos valores associados (listagem 6.49). Listagem 6.49 - Obtengo de urna lista de chaves e valores >>> tab ela = { "Alface": 0.45, "Batata": 1.20, ... "Tomate": 2.30, — "Feijao": 1.50 > » > p rin t(tab e la.k ey s()) d ic t_ k ey s(['B atata', 'A lfa ce', 'Tomate', 'F e ija o ']) » > p rin t(tab e la.v alu esQ ) dict_values([1.2, 0.45, 2.3, 1.5])

Observe que os métodos keys() e valúes () retornam geradores. Vocé pode utilizá-los diretamente dentro de um for ou transformá-los em lista usando a fungao list. Vejamos u m programa que utiliza dicionários para exibir o prego de um produto n a listagem 6.50.

a

Listagem 6.50 - Obtengo do prego com um dicionário tab ela = { "Alface": 0.45, "Batata": 1.20, "Tomate": 2.30, "Feijao": 1.50 } while True: produto=input("Digite o nome do produto, fim para term inar:") i f produto == "fim": break i f produto in tabela: O print("Preco %5.2f" % tabela[produto]) 0 else: print("Produto nao encontradol")

120

In tro d u jo á Programado com Python

Em O verificamos se o dicionário contém a chave procurada. Em caso afirma­ tivo, imprimimos o prego associado á chave, ou haverá urna mensagem de erro. Para apagar urna chave, utilizaremos a instrugáo del (listagem 6.51). Listagem 6.51 - Exdusáo de urna associagáo do dicionário » > tab ela = { “Alface": 0.45, "Batata”: 1.20, "Tomate”: 2.30, "Feijao": 1.50 } » > del tabela["Tomate"] > » p rin t(tab e la) { 'B a ta ta ': 1.2, 'A lface': 0.45, 'F e ija o ': 1.5}

Vocé pode estar se perguntando quando utilizar listas e quando utilizar dicionários.Tudo depende do que vocé deseja realizar. Se seus dados sao fácilmente acessados por suas chaves, quase nunca vocé precisa acessá-los de urna só vez: um dicionário é mais interessante. Além disso, vocé pode acessar os valores associados a urna chave rápidamente sem pesquisar. A implementagáo interna de dicionários também garante urna boa velocidade de acesso quando temos muitas chaves. Porém, um dicionário nao organiza suas chaves, ou seja, as priméiras chaves inseridas nem sempre seráo as primeiras na lista de chaves. Se seus dados precisam preservar a ordem de insergáo (fila, p ilh a,...), dicionários nao seráo urna opgao.

6.18 Dicionários com listas Em Python, podemos ter dicionários nos quais as chaves sao assodadas a listas ou mesmo a outros dicionários. Imagine urna relagáo de estoque de mercadorias onde teríamos, além do prego, a quantidade em estoque (listagem 651). Listagem 6.52 - Dicionário com listas estoque={ "tomate": [ 1000, 2.30], "alface": [ 500, 0.45], "batata": [ 2001, 1.20], "feijao ": [ 100, 1.50] }

Nesse caso, o nome do produto é a chave, e a lista consiste nos valores as­ sociados, urna lista por chave. O primeiro elemento da lista é a quantidade disponível, e o segundo, o prego do produto.

Capítulo 6 ■Listas

121

Urna aplicado seria processarmos urna lista de operagóes e calcular o prego total de venda, atualizando também a quantidade em estoque. Listagem 6.53 - Exemplo de didonário com estoque e o p e ra re s de venda estoque={ "tomate": [ 1000, 2.30]., " alfa ce": [ 500, 0.45], "batata": [ 2001, 1 . 20 ], "feijao ": [ 100, 1.50] } venda = [ [”tomate", 5], ["batata", 10], ["a lface ",5]] to ta l = 0 p rin t("Vendas: \n ") fo r operagao in venda: produto, quantidade = operado O prego = estoque[produto][1] © custo = prego * quantidade print("%12s: %3d x %6.2f = %6.2f" % (produto, quantidade,prego,custo)) estoque[produto][0] -= quantidade © tota!+=custo p rin t(" Custo to ta l: %21.2f\n” % to ta l) p rin t("Estoque:\n ") fo r chave, dados in estoque.item s(): © print("Descrigao: ", chave) print("Quantidade: ", dados[0]) print("Prego: %6.2f\n" % dados[1])

Em O utilizamos urna operagao de desempacotamento, como já fizemos com for e enumérate. Como operagao é urna lista com dois elementos, ao escrevermos produto, quantidade temos o primeiro elemento de operagao atribuido a produto, e o seguido, a quantidade. Dessa forma, a construgáo é equivalente a: produto = operagao[0] quantidade = operagao[l]

Em ©, utilizamos o conteúdo de produto como chave no didonário estoque. Como nossos dados sao urna lista, escolhemos o segundo elemento, que armazena o pregó do referido produto. Observe que atribuir nomes a cada um desses componentes facilita a leitura do programa. Imagine escrever: prego = estoque[operagao[0]][l]

Em ©, atualizamos a quantidade em estoque subtraindo a quantidade vendida do estoque a cual,

122

In tro du jo á Programado com Python

Já em O utilizamos o método items do objeto dicionário. O método ítems retorna urna tupia contendo a chave e o valor de cada item armazenado no dicionário. Usando um for com duas variáveis, chave e dados, efetuamos o desempacotamento desses valores em urna só passagem. Para entender m elhor como isso acontece, experimente alterar o programa para exibir o valor de chave e dados a cada iteradlo. Exercído 6 .1 7 -A ltere o program a da listagem 6.53 de forma a solicitar ao usuário o produto e a quantidade vendida. Verifique se o nom e do produto digitado existe no dicionário e só entáo efetue a baixa em estoque. Exercído 6.18 - Escreva um program a que gere um dicionário, onde cada chave seja u m caractere e seu valor seja o núm ero desse caractere encontrado em urna frase lida. Exemplo: O rato -> { “O ”:!, “r ”:l, “a”: 1, “t”:l, “o”:!}

CAPÍTULO 7

Trabalhando com strings

No capítulo 3 vimos que podemos acessar strings como listas, mas também falamos que strings sâo imutáveis em Python. Vejamos o que acontece na listagem 7.1. Listagem 7.1 - Alteraçâo de urna string » > S="Alô mundo” > » p rint(S [0]) A >>> S[0]=”a" Traceback (most recent c a li l a s t ) : F ile "", lin e 1, in TypeError: 's t r ' object does not support item assignment

Se quisermos trabalhar caractère a caractère com strings, alterando seu valor, temos que primeiramente transformá-la em urna lista (listagem 7.2). Listagem 7.2 - Convertendo urna string em lista » > L=list("Aló Mundo”) » > L[0]="a” >>> print(L) [ ' a ' P ' l ' j 'ó ', ' 'M ', 'u ', 'n ', 'd ', 'o '] > » s=”".join(L) > » p rin t(s ) aló Mundo

A funçâo lis t transforma cada caractère da string em um elemento da lista retornada. Já o método join faz a operaçâo inversa, transformando os elementos da lista em string.

In tro du jo á Programado com Python

124

7.1 Verificado parcial de strings Quando vocé precisar verificar se urna string cometa ou termina com alguns caracteres, vocé pode usar os métodos startswith e endswith. Esses métodos verificam apenas os primeiros (startswith) ou os últimos (endswith) caracteres da string, retornando True caso sejam iguais ou False em caso contrário. Listagem 7.3 - V erificado parcial de strings » > nome="Doao da Silva" » > nome.startswith("Toao") True » > nom e.startswith("joao”) False » > nome.endswith("Silva") True

Observe a listagem 73. Veja que comparamos “Joao da Silva” com “joao” e obtivemos False. Esse é u m detalhe pequeño, m as importante, pois startswith e endswith consideram letras maiúsculas e minúsculas como letras diferentes. Vocé pode resolver esse tipo de problema convertendo a string para maiúsculas ou minúsculas antes de realizar a comparado. O método lower retorna urna copia da string com todos os caracteres minúsculos, e o método upper retorna urna copia com todos os caracteres maiúsculos. Veja os exemplos na listagem 74. Listagem 7.4 - Exemplos de conversáo em maiúsculas e minúsculas > » s="0 Rato roeu a roupa do Rei de Roma" » > s.low er() 'o rato roeu a roupa do r e i de roma' » > s.upper() '0 RATO ROEU A ROUPA DO REI DE ROMA' » > s-lower( ) .startsw ith ("o rato") True >>> s . upper( ) . startsw ith ("0 RATO") True

Nao se esquega de comparar com urna string onde todos os caracteres sao maiúsculos ou minúsculos, dependendo se vocé utilizou upper ou lower, res­ pectivamente. O utra forma de verificar se urna palavra pertence a urna string é utilizando o operador in. Vejamos os exemplos da listagem 7.5.

Capítulo 7 ■Trabalhando com strings

125

Listagem 7.5 - Pesquisa de palavras em urna string usando in » > s="Maria Amélia Souza" » > "Amelia" in s True » > "Maria" in s True » > "Souza" in s True » > “a A" in s True » > "amélia" in s False

Vocé tam bém pode testar se urna string nao está contida em outra, utilizando not in (listagem 7.6). Listagem 7.6 - Pesquisa de palavras em urna string usando not in s="Todos os caminhos levam a Roma" > » "levam" not in s False » > "Caminhos" not in s True >>> "AS” not in s True »>-

Veja que aqui tam bém letras maiúsculas e minúsculas sao diferentes. Vocé pode combinar lower e upper com in e not in para ignorar esse tipo de diferencia, como m ostra a listagem 7.7. Listagem 7.7 ®Combina$áo de lower e upper com in e not in >>> s=”Doao comprou urn carro" > » "joao" in s . lower() True >>> "CARRO" in s.upperQ True » > "comprou" not in s.low er() False > » "barco" not in s . lower() True

O operador in também pode ser utilizado com listas normáis, facilitando, assim, a pesquisa de elementos dentro de lima lista.

126

In tro du jo á Programado com Python

7.2 Contagem Se vocé precisar contar as ocorréncias de urna letra ou palavra em urna string, utilize o método count. Veja o exemplo na listagem 7.8. Listagem 7.8 - Contagem de letra e palavras >>> t="um t ig r e , dois tig re s , tr e s tig res" » > t.c o u n t(" tig re " ) 3 » > t.c o u n t(" tig re s " ) 2

>>> t.c o u n t(" t" ) 4 > » t.co u n t("z") 0

7.3 Pesquisa de strings Para pesquisar se urna string está dentro de outra e obter a posigáo da primeira ocorréncia, vocé pode utilizar o método find (listagem 7.9). Listagem 7.9 - Pesquisa de strings com find » > s="Alo mundo" >>> s.find("mun") 4 » > s.find("ok") -1

Caso a string seja encontrada, vocé obterá um valor maior ou igual a zero, ou -1, em caso contrário. Observe que o valor retornado, quando m aior ou igual a zero, é igual ao índice que pode ser utilizado para obter o primeiro caractere da sixing procurada. Se o objetivo fbr pesquisar, mas da direita para a esquerda, utilize o método rfind, que realiza essa tarefa (listagem 7.10). Listagem 7.10 - Pesquisa de strings com rfind > » s="Um dia de sol" » > s.rfind(“d") s.find("d")

Capítulo 7 ■Trabalhando com strings

127

Tanto find quanto rfind suportam duas opgoes adicionáis: inicio (start) e fim (end). Se vocé especificar inicio, a pesquisa comegará a partir dessa posigao. Se vocé especificar o fim, a pesquisa utilizará essa posigao como último caractere a considerar na pesquisa. Veja os exemplos na listagem 7.11. Listagem 7.11 - Pesquisa de strings, limitando o inicio ou o fim >>> »> 15 »> 28 >>> 15 >>>

s="um tig re , dois tig re s , tr e s tig res" s. find ("tig res" ) s . rfind("tig res" ) s . find(" tig re s " ,7) #início=7 s.find("tigres",30) #início=30

-1 >>> s.find("tigres",0,10) #início=0 fim=10

-1 Podemos usar o valor retornado por find e rfind para achar todas as ocorrencias da string. Por exemplo, o programa da listagem 7.12 produz a saída da listagem 7.13. Listagem 7.12 - Pesquisa de todas as ocorréncias s="um tig re , dois tig re s , tre s tig res" p=0 while(p>-l): p=s.find("tigre", p) i f p>=0: print("P osifao: %d" % p)

P+=1 I Listagem 7.13 - Resultado da pesquisa Posiqáo: 3 Posicáo: 15 Posicao: 28

Os métodos index e r index sao bem parecidos com find e rfind, respectivamente. A maior diferenga é que se a substring nao for encontrada, index e rindex langam urna excegáo do tipo ValueError.

128

In tro du jo á Programado com Python

Exera'cio7.1 - Escreva um programa que leia duas stxings. Verifique se a segunda ocorre dentro da prim eira e im prim a a posiQáo de inicio. I a string: AABBEFAATT 2a string: BE Resultado: BE encontrado n a posi^ao 3 de AABBEFAATT Exerrido 7.2 - Escreva um program a que leia duas strings e gere urna terceira com os caracteres com uns ás duas strings lidas. I a string: AAACTBF 2a string: CBT Resultado: CBT A ordem dos caracteres da string gerada nao é importante, mas deve conter todas as letras comuns a ambas. Exercído 7.3 - Escreva um program a que leia duas strings e gere urna terceira apenas com os caracteres que aparecem em urna délas. I a string: CTA 2a string: ABC 3a string: BT A ordem dos caracteres da terceira string nao é importante. Exercído 7.4 - Escreva u m program a que leia urna string e im prim a quantas vezes cada caractere aparece nessa string. String: TTAAC Resultado: T :2 x A: 2x C: lx

Capítulo 7 ■Trabalhando com strings

129

Exercício 7.5 - Escreva um program a que leia duas strings e gere urna terceira, n a qual os caracteres da segunda foram retirados da primeira. I a string: AATTGGAA 2a string: TG 3a string: AAAA Exercício 7.6- Escreva um program a que leia très strings. Imprima o resultado da substituiçâo na prim eira, dos caracteres da segunda pelos da terceira. I a string: AATTCGAA 2a string: TG 3a string: AC Resultado: AAAACCAA

7.4 Posicionamento de strings Python também traz métodos que ajudam a apresentar strings de formas mais intéressantes. Vejamos o método center, que centraliza a string em um número de posiçôes passado como parámetro, preenchendo com espaços à díreita e à esquerda até que a string esteja centralizada (listagem 7.14). Listagem 7.14 - Centralizaçâo de texto em urna string » > s="tigre"

» > print ( *"+s . cente r ( 10)+"X") X tig re

X »> print ("X"+s.center(1 0 ," ." )+"X") X ..tig re ...X

Se além do tamanho vocé também passar o caractère de preenchimento, este será utilizado no lugar de espaços em branco. Se o que vocé deseja é apenas completar a string com espaços à esquerda, vocé pode udlizar o método ljust. Se deseja completar com espaços à direita, utilize rjust (listagem 7.15).

130

Introduçâo à Programado com Python

Listagem 7.15 - Preenchimento de strings com espatos > » s=',tig n e,, » > s .lju s t(2 0 ) 'tig re » > s .rju s t(2 0 ) ' tig r e ' » > s .lju s t(2 0 ," ." ) 't i g r e ............................ ' » > s .rju s t(2 0 j" -" ) ’..................-------t i g r e '

Hssas fungoes sao úteis quando precisamos criar relatórios ou simplesmente alinhar a saída dos programas.

7.5 Quebra ou separaçâo de strings O método split quebra urna string a partir de um caractère passado como parámetro, retornando urna lista com as substrings já separadas. Veja um exemplo n a listagem 7.16. Listagem 7.16 —Separaçâo de strings » > s="um tig re , dois tig re s , tr è s tig res" » > s .s p l it ( " ," ) ['um t i g r e ', ’ dois t i g r e s ', ' tr è s ti g r e s '] » > s •s p l i t (" ") ['um ', 't i g r e , ', 'd o i s ', 't i g r e s , ', 't r è s ', 't i g r e s '] > » s . s p l i t () ['um ', 't i g r e , ', 'd o i s ', 't i g r e s , ', 't r e s ', 't i g r e s ']

Observe que o caractère que utilizamos para dividir a string nâo é retornado na lista, ou seja, ele é utilizado para separar a string e depois descartado. Se você desej a separar urna string, com várias linhas de texto, vocé pode utilizar o método splitlines (listagem 7.17). Listagem 7.17 - Quebra de strings de várias linhas >>> m=”Uma linha\noutra linha\ne mais uma\n" >>> m .s p litlin e s () ['Urna lin h a ', 'outra lin h a ', 'e mais urna']

Capítulo 7 ■Trabalhando com strings

131

7.6 Substituiçâo de strings Para substituir trechos de uma string por outros, utilize o método replace. Com o método replace, o primeiro parámetro é a string a substituir, e o segundo, o conteúdo que a substituirá. Opcionalmente, podemos passar um terceiro parámetro que limita quantas vezes queremos realizar a repetiçâo. Vejamos alguns exemplos na listagem 7.18. Listagem 7.18 - Substituiçâo de strings > » s="um t ig r e , dois tig re s , tr è s tig re s" >>> s.re p la ce (" tig re" , "gato") ‘um gato, dois gatos, tr è s gatos' » > s. replace ("tig re" , "gato", 1) 'um gato, dois tig re s , trè s tig re s ' >>> s .re p la ce ("tig re", "gato", 2) 'um gafù, dois gatos, trè s tig r e s ' >>> s.re p la ce O 'tig re", "") 'um , dois s , trè s s ' » > s.replace("", '-u-m- - t - i - g - r - e - ,- -d -o -i-s- - t- i - g - r - e - s - ,- - t- r - ê - s - - t - i - g - r - e - s - '

Se você passar um a string vazia no segundo parámetro, o trecho será apagado. Se o primeiro parámetro for um a string vazia, o segundo será inserido antes de cada caractère da string.

7.7 Remojo de espatos em branco O método strip é xjilizado para remover espatos em branco do inicio ou fim da string. Já os métodos lstrip e rstrip removem apenas os caracteres em branco Aesquerda ou á direita, respectivamente (listagem 7.19). Listagem 7.19 - R e m o jo de espatos em branco com strip, lstrip e rstrip >>> t=" Ola >>> t .s tr i p Q ' Olá' >>> t . l s t r i p ( ) 'Olá ' » > t .r s t r i p ( ) ’ Olá'

Se vocé passai: um parámetro tanto para strip qiianto para lstrip ou rstrip, este será utilizado como caraclere a remover (listagem 7.20).

In tro d u jo á Programado com Python

132

Listagem 7.20 - R e m o jo de caracteres com strip, Istrip e rstrip » > s = " .../ / / 0 1 á / / / .. ." »>

s.lstrip(".")

'/ / / O l á / / / . . . ' >>> s .rs tn ip (" ." ) '. . . / / / O l á / / / ' >>> S.StripC'.")

• / / /O lá / // ’ » > s.strip("./") 'Olá'

7.8 Validado por tipo de conteúdo Strings em Python podem ter seu conteúdo analisado e verificado utilizando-se métodos especiáis. Esses métodos verificam se todos os caracteres sao letras, números ou urna com binado destes. Vejamos alguns exemplos na listagem 7.21. Listagem 7.21 - V alid ado de strings por seu conteúdo » > s="125" > » p=”aló mundo" » > s.isalnum ()

True >>> p.isalnumO False >>> s.isalp h a() False » > p .isalpha() False

O método isalnum retorna verdadeiro se a string nao estiver vazia e se todos os seus caracteres sao letras e/ou números. Se a string contiver outros tipos de caracteres, como espagos, vírgula, exclamagao, interrogagao ou caracteres de controle, retom a False. Já isalpha é mais restritivo, retornando verdadeiro apenas se todos os caracteres forem letras, incluindo vogais acentuadas. Retorna falso se algum outro tipo de caractere for encontrado na string ou se esta estiver vazia. O método isdigit verifica se o valor consiste em números, retornando True se a string nao estiver vazia e contiver apenas números. Se a string contiver espagos, pontos, vírgulas ou sinais (+ ou -), retorna falso (listagem 7.22).

Capítulo 7 ■Trabalhando com strings

133

Listagem 7.22 - Validaçâo de strings com números » > "7 7 1 ".isd ig it() True > » "10.4" .is d ig it( ) False » > "+ 10",isdigit() False » > "-5“ .ls d ig it( ) False

Os métodos isdigit e isnumeric sâo parecidos, e diferenciâ-los envolve um conhecimentp de Unicode mais aprofundado, isdigit retorna True para caracteres definidos como dígitos numéricos em Unicode, indo além de nossos 0 a 9, como, por exemplo um 9 tibetano (\u0f29). isnumeric é mais abrangente, incluindo dígitos e representaçôes numéricas como fraçôes, por exemplo, 1/3 (\u2i53). Vejamos alguns testes na listagem 7.23. Listagem 7.23 - Diferenciaçâo de isnumeric de isdigit » > umterço="\u2153" » > novetibetano=,,\u0f29" >>> um terço.isdigit() False > » umterço.isnumeric() True > » novetibetano.isdigit() True > » novetibetano.isnum eric() True

Podemos tam bém verificar se todos os caracteres de um a string sao letras maiúsculas ou minúsculas usando is upper e islower, respectivamente (listagem 7.24). Listagem 7 .2 4 - Verificaçâo de maiúsculas e minúsculas » > s=”ABC" > » p="abc" > » e=,,aBc” > » s.isupper() True > » s.islow er() False > » p.isupper() False

In trodujo á Programado com Python

134

>>> p-.islower() True » > e.isupperQ False » > e.islow er() False

Temos também como verificar se a string contém apenas caracteres em branco, como espagos, marcas de tabulagao (TAB), quebras de linha (LF) ou retorno de carro (CR). Para isso, vamos utilizar o método isspace, como mostra a listagem 7.25. Listagem 7.25 - V erificad» se a string contém apenas caracteres de espa$amento » > " \t\n \r ".isspaceQ True >>> "YtAló".isspaceQ False

Se vocé precisar verificar se algo pode ser impresso na tela, o método isprintable pode ajudar. Ele retorna False se algum caractere que nao pode ser impresso for encontrado na string. Vocé pode utilizá-lo para verificar se a impressao de urna string pode causar efeitos indesejados no terminal ou na formatagáo de u m arquivo (listagem 7.26). Listagem 7.26 - V erificado se a string pode ser impressa >>> " \n \t" .is p rin ta b le () False » > "\nAló11. is p rin ta b le () False » > "Alo m undo".isprintable() True

7.9 Formatagáo de strings Aversáo 3 do Python introduziu urna nova forma de representar máscaras em strings. Essa nova forma é mais poderosa que as tradicionais máscaras que utilizamos, combinando %d, %s, %f. A nova forma representa, os valores a substituir entre chaves. Vejamos um exemplo na listagem 7.27.

Capítulo 7 ■Trabalhando com strings

135

Listagem 7.27 - Formata{áo de strings com o método format > » "{0} {1}“.form at(”Aló", "Mundo") 'Alo Mundo' > » ”{0} x {1} R${2}\format (5, "maga", "1.20") '5 x maga R$1.20‘

O número entre cólcheles é urna referencia aos parámetros passados ao método format, onde 0 é o primeiro parámetro, 1, o segundo, e assim por diante, como os índices de urna lista. Urna das vantagens da nova sintaxe é poder utilizar o mesmo parámetro várias vezes na string (listagem 7.28). Listagem 7.28 - Uso do mesmo parámetro mais de urna vez » > "{0} {1} {0}".fó rm a te-","x ")

Isso também permite a completa reordenagao da mensagem, como imprimir os parámetros em outra ordem (listagem 7.29). Listagem 7.29 - A lterado da ordem de u tiliza d o dos parámetros » > "{1} {0}". format ("primeiro"., "segundo”) 'segundo prim eiro'

A nova sintaxe permite também especificar a largura de cada valor, utilizando o símbolo de dois pontos (:) após a posigao do parámetro, como 0:10 da lista­ gem 7.30, que significa: substitua o primeiro parámetro com urna largura de 10 caracteres. Se o primeiro parámetro for menor que o tamañito informado, espagos serio utilizados para completar as posigoes que faltam. Se o parámetro for maior que o tam anho especificado, ele será impresso em sua totalidade, ocupando mais espago que o inicialmente especificado. Listagem 7.30 - Lim itad o do tamanho de impressáo dos parámetros » > "{0:10) { l) ” .format{"123", "456") '123 456' >» ”X{0:10 }X” . fo rmat (" 12.3'") ’X123 X’ » > "X{0:10}X". format ("123456789012345 ”) ’X123456789012345X1

Podemos também especificar se queremos os espagos adicionáis á esquerda ou á direita do valor, utilizando os símbolos de maior (>) e menor ( "X{0:10}X".format( ’,123") 'X 123X'

Se quisermos o valor entre os espaços, de forma a centralizá-lo, podemos utilizar o circunflexo C"'), como mostra a listagem 7.32. Listagem 7.32 - Centralizado » > ”X{0: A10}X".format( "123") 'X 123 X’

Se quisermos outro caractère no lugar de espaços, podemos especificá-lo logo após os dois pontos (listagem 733). Listagem 7.33 - Especificado de espaços à esquerda ou à direita » > "X{0: .X".format("123") 1X123............ X' » > "X{0: !>10}X".format("123") *X! ! ! ! ! ! !123X1 >>> "X{0 : *A10}X". format ( " 123 " ) 'X***123****X'

Se o parámetro é urna lista, podemos especificar o índice do elemento a subs­ tituir dentro da máscara (listagem 7.34). Listagem 7.34 - Máscaras com elementos de urna lista » > "{0[1]> {0[2]}” .form at([“123", "456"]) ’123 456'

O mesmo é válido para dicionários (listagem 7.35). Listagem 7.35 - Máscaras com elementos de um dicionário » > ”{0[nome]} {0[telefone]}".form at({ "telefone": 572, "nome" : "Maria”}) 'Maria 572'

Observe que dentro da string escrevemos nome e telefone entre colchetes, mas sem aspas, como normalmente fallamos ao utilizar dicionários. Essa sintaxe é especial para o método format.

Capítulo 7 ■Trabalhando com strings

137

7 .9 .1 Fo rm ata^ áo de n ú m ero s

A nova sintaxe também permite a formatagáo de números. Por exemplo, se especificarmos o tam anho a imprim ir com um zero á esquerda, o valor será impresso com a largura determinada e com zeros á esquerda completando o tamanho (listagem 736). Listagem 7.36 - Zeros á esquerda » > "{0:05}" .format(5) '00005'

Podemós também utilizar outro caractere, diferente de 0, mas nesse caso, de­ vemos escrever o caractere á esquerda do símbolo de igualdade (listagem 737). Listagem 7.37 - Preenchimento com outros caracteres » > "{0:*=7}".format(32) i* * * * * 3 2 '

Podemos tam bém especificar o alinhamento dos números que estamos imprimindo usando e л (listagem 738). Listagem 7.38 - Com binado de vários códigos de formatagáo > » "{0:*A10}".format(123) ■**»j23****'

» > "{0:* “{:c}''.form at(65) 'A '

» > ”{ :o)".format(5678) '13056'

Capítulo 7 ■Trabalhando com strings

139

» > "{:x}".fórm ate5678) ' 162 e' > » ”{:X}" .format(5678) ' 162E'

Os formatos d e n sao parecidos. O formato d é semelliante ao que utilizamos ao formatar os números com %d. A diferenga entre o formato d e o n é que o n leva em consideragáo as configuragoes regionais da máquina do usuário. Ve­ jam os alguns exemplos na listagem 7.42. Observe que antes de configurarmos a m áquina para o portugués d o Brasil o resultado de d e n eram iguais. Após a configuragáo regional, o formato n passou a exibir os números utilizando pontos para separar os milhares. Listagem 7.42 - 0 formato d e o formato n » > "{:d}".format(5678) '5678' » > "{:n}" .format(5678) '5678' » > import lócale > » ló ca le .s e tlo c a le (ló c a le . LC_ALL, "pt_BR.utf-8") 'pt_B R.utf-8' » > "{:n}".format(5678) '5.678' T a b e la 7.2 - F o r m a to s d e n ú m e r o s d é c im a is

Código

Describo

Exemplo(1345)

e

Notado científica come minúsculo

1.345000e+00

E

Notado científica come maiúsculo

1.345000E+00

f

Decimal

1.345000

g G

Genérico

1.345

Genérico

1.345

n

Local

%

Percentual

1,345 134.500000%

Para números decimais, temos também vários códigos. O código f já conhecemos e funciona de forma semelhante ao que utilizamos em %f. O formato n utiliza as configuragSes regionais p ara im prim ir o número. Em portugués, essa configuragáo utiliza o ponto como separador de m ilhar e a vírgula como separador decimal, produzindo números mais fáceis de entender. Vejamos exemplos na listagem 7.43.

Introduçâoà Programaçâo com Python

140

Listagem 7.43 - Formata$áo de números decimais » > "{:f}" .format(1579.543) '1579.543000' » > ”{: n} " .format(1579.543) '1579.54' » > import lócale » > lócale.setlocale(lócale.LC_ALL,''pt_BR.utf-8") ’pt_BR.utf-8’ » > "{:n}“ .format(1579.543) ■1.579,54’

Os formatos e e Eimprimem o número utilizando notagao científica. Isso quer dizer que a parte decimal vai ser substituida por um expoente. Por exemplo: 10043 em no tagao científica será impresso 1.004500e+03. Para entender esse formato, devemos entender suas partes. O número á esquerda de e é o que chamamos de mantissa, e o número á direita, o expoente. A base é sempre 10 e, para recompor o número, multiplicamos a mantissa pela base 10 elevada ao expoente. No caso de 1.004500e+03, teríamos: 1.004500 x 103 = 1.004500 * 1000 = 1004.5 A vantagem de utilizar notagao científica é poder representar números muito grandes ou muito pequeños em pouco espago. A diferenga entre o formato e e o E é que queremos exibir o e que separa a mantissa do expoente, ou seja, um e m inúsculo ou um Emaiúsculo. Os formatos g e Gsao chamados de genéricos, pois dependendo do número, eles sao exibidos como no formato f ou como no e ou E. O tipo % simplesmente multiplica o valor 100 antes de imprimi-lo, assim, 0,05 é impresso como 5%. Veja alguns exemplos na listagem 7.44. Listagem 7.44 - Formata$áo de números dedmais » > "{: 8e}" .format(3.141592653589793) 13 .141593e+00' » > "{:8E}".format(3.141592653589793) '3.141593E+00' >» “{: 8g> . format (3.141592653589793) ’ 3.14159' » > "{:8G>".fo rmat(3.141592653589793) ' 3.14159' >>> "{:8g}".fonnat(3.14) ' 3.14'

Capítulo 7 ■Trabalhando com strings

141

» > ''{:8G}".format(3.14) ' 3.14' » > ”{: 5 . 2 %}".format ( 0 .05) ■5.00%'

7.10Jogodaforca Vejamos um jogo muito simples, mas que ajuda a trabalhar com strings. O jogo d a forca é simples e pode até se tornar divertido. Listagem 7.45 Jogo da forca palavra = input(''D igite a palavra se c re ta :" ).lo w e r().s trip () O for x in range(100): p rin t() 0 digitadas = [] acertos = [] erros = 0 while True: senha="" for le tra in palavra: senha +=letra i f le tra in acertos else 0 print(senha) i f senha == palavra: print("Vocé acertou!") break ten ta tiv a = input("\nD igite uma l e t r a l o w e r ( ) .s trip Q i f ten ta tiv a in digitadas: print("Vocé já tentou esta le tra !" ) continué © else: digitadas += te n tativ a i f ten ta tiv a in palavra: acertos += te n tativ a else: erros += 1 print("Voce erroü!”) print("X==:==\nX : ") print("X 0 " i f erros > 1 else “X") linha2="" i f erros == 2: linha2 = " | "

142

In tro d u jo á Programado com Python

e l i f erro s == 3: linha2 = " \ | " e l i f erros >= 4: lin h a 2 = " \ | / " print("X%s" % linha2) linha3="" i f erros == 5: linha3+=" / " e l i f erros>=6: linha3+=” / \ ” print("X%s" % linha3) print("X\n===========") i f erros == 6: print("Enforcado!") break

Veja como é simples escrever um jogo d a forca em Python. Vamos analisar o que essa listagem faz. Em 0> aproveitamos o retorno de input para chamar os m étodos de string lower e strip. Veja como escrevemos urna chamada após a outra. Isso é possível porque input, lower e strip retornam um objeto string. O resultado final d a string digitada pelo usuário, convertida para letras m inús­ culas e com espatos em branco no inicio e no fim eliminados, é atribuido á variável palavra. É essa variável que vai armazenar a palavra a ser adivinhada pelo jogador. Em O pulam os várias linhas para que o jogador nao veja o que foi digitado como palavra. A ideía é que urna jogador escreva urna palavra secreta e que outro tente descobri-la. Em 0 , temos urna nova forma de condigáo que facilita decisoes simples. O if imediato ou na mesma linha serve para decidir o valor a retornar, dependendo de urna condigao. É como o if que já conhecemos, mas o valor verdadeiro fica á esquerda do if, e a condigao, á sua direita. O else nao tem : e indica o resultado caso a condigáo seja falsa. N o exemplo, letra é o valor a retornar se a condigao letra in acertos for verdadeira, e é o valor se o resultado for falso. Assim: senha += le t r a i f le t r a in acertos else

substitui: i f l e tr a in ac ertos: senha += l e tr a else: senha

Capítulo 7 ■Trabalhando com strings

143

A vantagem dessa construçâo é que escrevemos tudo em urna sô linha. Esse recurso é intéressante para expressôes simples e nâo deve ser utilizado para todo e qualquer caso. No jogo da força, usamos essa construçâo para mostrar a palavra secreta na tela, mas substituindo todas as letras ainda nâo adivinhadas por um Em O) utilizamos a instruçâo continue. Ainstruçâo continue é similar ao break que já conhecemos, mas serve para indicar que devemos ignorar todas as linhas até o fim da repetiçâo e voltar para o inicio, sem terminâ-la. N o jogo d a força, isso faz com que a execuçâo passe de O para o while diretamente, pulando todas as linhas depois delà. Quando utilizada com while, continue causa a reavaliaçâo da condiçâo da repetiçâo; quando utilizada com for, faz com que o próximo elemento seja utilizado. Considere continue como vá para o fim d a repetiçâo e volte para a linha de for ou while. Exercício7.7 - Modifique o program a de forma a escrever a palavra secreta caso o jogador perca. Exercício 7.8 - M odifique o jogo da força de forma a utilizar urna lista de palavras. N o inicio, pergunte u m núm ero e calcule o índice d a palavra a utilizar pela fórmula: índice - (número * 776) % len(lista_de_palavras). Exercício 7.9 - M odifique o program a para utilizar listas de strings para dese­ nliar o boneco da força. Voce pode utilizar urna lista para cada linha e organizá-las em urna lista de listas. Em vez de controlar quando im prim ir cada parte, desenhe nessas listas, substituindo o elemento a desenhar. Exemplo: » > linha = list("X .......... ") » > linha ['X ', > » linha[61 = > » linha !'X ',

>>>

T )

,jo in (lin h a )

■x— - I '

Exercício7.10 - Escreva um jogo da velha para dois jogadores. O jogo deve perguntar onde você quer jogar e alternar entre os jogadores. A cada jogada, verifique se a posiçâo está livre. Verifique tam bém quando u m jogador venceu a partida. Um jogo da velha pode ser visto como urna lista de 3 elementos, onde cada elemento é outra lista, tam bém com très elementos.

144

In tro d u jo á Programado com Python

Exemplo do jogo: X| 0 | | X I X

I

I0

O nde cada posigáo pode ser vista como u m número. C onfira abaixo um exemplo das posigoes m apeadas para a m esm a posigao de seu teclado numérico. 7 | 8 | 9 — +— +— 4 | 5 | 61 1 | 2 | 3

CAPÍTULO 8

Fungóes

Podemos definir nossas próprias fungoes em Python. Sabemos como usar várias fungóes, como len, int, float, print e input. Neste capítulo, veremos como declarar novas fungdes e utilizá-las em programas. Para definir urna nova fungao, utilizaremos a instrugao def. Vejamos como declarar urna fungao de soma que recebe dois números como parámetros e os imprime na tela (listagem 8.1). Ustagem 8.1 - D efinido de urna nova fungao def soma(a,b): O print(a+b) 0 sowa(2,9) © soma(7,8) soma(10,15)

Observe em O que usamos a instrugao def seguida pelo nome da fungao, no caso, soma.Após o nome e entre paren teses, especificamos o nome dos parámetros que a fungao receberá. Chamamos o primeiro de a e o segundo de b. Observe também que usamos : após os parámetros para indicar o inicio de um bloco. Em 0 , usamos a fungao print para exibir a+b. Observe que escrevemos 0 dentro do bloco da fungao, ou seja, mais á direita. Diferentemente do que já vimos até agora, essas linhas nao serao executadas imediatamente, exceto a definicáo da fungao em si. Na realidade, a definigao prepara o interpretador para executar a fungao quando esta fbr chamada em nutras partes do programa. Para chamar urna fungao definida no programa, ('aremos da mesma forma que as fungoes já definidas na linguagem, ou seja, nome da fungao seguido dos parámetros entre parénteses. Exemplos de como chamar a fungao soma sao apresentados a partir de 0. No primeiro exemplo, chamamos soma(2,9). Nesse caso, a fungao será chamada com a valendo 2 e b valendo 9. Os parámetros sao substituidos na mesma ordem em que foram definidos, ou seja, o primeiro valor como a e o segundo como b.

In tro d u jo á Programado com Python

146

Fungoes sao especialmente interessantes para isolar urna tarefa específica em um trecho de programa. Isso permite que a solugáo de um problema seja reu­ tilizada em outras partes do programa, sem precisar repetir as mesmas linhas. O exemplo anterior utiliza dois parámetros e imprim e sua soma. Essa fungao nao retorna valores como a fungao len ou a int. Vamos reescrever essa fungao de forma que o valor da soma seja retornado (listagem 8.2). Listagem 8.2 - D efin id o do retorno de um valor def soma(a,b): return(a+b) O print(soma(2,9))

Veja que agora utilizamos a instrugáo return O para indicar o valor a retornar. Observe tam bém que retiramos o print da fungao. Isso é interessante porqué a soma e a impressáo da soma de dois números sao dois problemas diferentes. Nem sempre vamos somar e im prim ir a soma, por isso, vamos deixar a fungao realizar apenas o cálculo. Se precisarmos imprimir o resultado, podemos utilizar a fungao print, como n o exemplo. Vejamos outro exemplo, urna fungao que retorne verdadeiro ou falso, dependendo se o núm ero é par ou impar (listagem 83). Listagem 8.3 - Retomando se valor é par ou nao def épar(x): return(x%2==0) p rint(épar(2)) p rin t(é p ar(3 )) print(épar(10))

Imagine agora que precisamos definir urna fungao para retornar á palavra par ou impar. Podemos reutilizar épar em outra fungao (listagem 8.4). Listagem 8.4 - Reutiliza$áo da fundió éparem outra funcáo def épar(x): return (x%2==0) def par_ou_ímpar(x): i f épar(x): O return "par" © else: return "impar" © print(par_ou_ímpar(4)) print(par_ou_xmpar(5))

Capítulo 8 ■Funçoes

147

Em O chamamos a funçâo épar dentro da funçâo par_ou_ímpar. Observe que nao há nada de especial nessa chamada: apenas repassamos o valor de x para a funçâo épar e utilizamos seu retorno no i f . Se a funçâo retornar verdadeiro, retornaremos “par” em 0, caso contrário, “impar” em ©. Utilizamos dois return na funçâo par_ou_ímpar. A instruçâo return faz com que a funçâo pare de executar e que o valor seja retornado imediatamente ao programa ou funçâo que a chamou. Assim, podemos entender a instruçâo return como um a interrupçâo cia execuçâo da funçâo, seguido do retorno do valor. As linhas da funçâo apôs a instruçâo return sâo ignoradas de forma similar à instruçâo break dentro de um while ou for. Exercicio 8.1 - Escreva um a funçâo que retom e o maior de dois números. Valores esperados: m áxim o (5,6) == 6 m áxim o (2,1) == 2 máximo(7,7) == 7 Exerddo 8.2 - Escreva um a funçâo que receba dois núm eros e retorne True se o prim eiro núm ero for múltiplo do segundo. Valores esperados: múltiplo (8,4) == True múltiplo(73) = ■False múltiplo(53) == True Exercicio8.3 - Escreva um a funçâo que receba o lado 0) de u m quadro e retorne sua área (A = lado2). Valores esperados: área_quadrado(4) ==16 área_quadrado(9) == 81 Exercicio8.4- Escreva um a funçâo que receba a base e a altura de um triángulo e retorne sua área (A = (base x altura)/2). Valores esperados:

In tro du jo á Programado com Python

148

área_txiángulo(6, 9) = = 2 7 área_triángu!o(5,8) == 20 Vejamos agora um exemplo de fungao de pesquisa em urna lista (listagem 8.5). Listagem 8.5 - Pesquisa em urna lista def p esq u ise(lista, valor): fo r x,e in en u raerate(lista) : i f e == valor: return x O return None © L=[10, 20, 25, 30] print(pesquise(L, 25)) print(pesquise(L, 27))

A fungao pesquise recebe dois parámetros: a lista e o valor a pesquisar. Se o valor for encontrado, retornaremos o valor de sua posigáo em O- Caso nao seja encontrado, retomaremos None em ©. Observe que se retornarmos em O, tanto for quanto o return em © sao completamente ignorados. Dizemos que return marca o fim da execugao da fungao. Usando estruturas de repetigáo e condicionáis, podemos programar onde e como as fungoes retornaráo, assim como decidir o valor a ser retornado. Vejamos outro exemplo, calculando a média dos valores de urna lista (listagem 8.6). Listagem 8.6 - Cálculo da média de urna lista def soma(L): total=0 fo r e in L: s+=e return t o t a l def media(L): return(soma(L)/len(L))

Para calcular a média, definimos outra fungao chamada soma. Dessa forma, teremos duas fungoes, urna para calcular a média e outra para calcular a soma da lista. Definir as fungoes dessa forma é mais interessante, pois urna fungao deve resolver apenas um problema. Poderíamos tam bém ter definido a fungao média como na listagem 8.7.

Capítulo 8 ■ Fungoes

149

Listagem 8.7 - Soma e cálculo da média de urna lista def média(L): total=9 fo r e in L: s+=e return to tal/le n (L )

Qua.1 das duas formas escolher depende do tipo de problema que se quer resolver. Se vocé nao precisa do valor da soma dos elementos de urna lista em nenhuma parte do programa, a segunda forma é interessante. Aprimeira (soma e média definidas em duas fungoes separadas) é mais interessante a longo prazo e é também urna boa prática de programagao. Conforme formos criando fungoes, podemos armazená-las para uso em outros programas. Com o tempo, vocé vai colecionar essas fungoes, criando urna biblioteca ou módulo. Veremos mais sobre isso quando falarmos de importagao e módulos. Por enquanto, tente fixar duas regras: urna fungao deve resolver apenas um problema e, quanto mais genérica for sua solugáo, melhor ela será a longo prazo. Para saber se sua fungao resolve apenas um problema, tente defini-la sem uti­ lizar a conjungao “e”. Se ela faz isso e aquilo, já é um sinal que efetua mais de urna tarefa e que talvez tenha que ser desmembrada em outras fungoes. Nao se preocupe agora em definir fungoes perfeitas, pois á medida que vocé for ganhando experiencia na programagao esses conceitos se tornarlo mais claros. Resolver os problemas da m aneira mais genérica possível é se preparar para reutilizar a fungao em outros programas. O fato de a fungao só poder ser utilizada no mesmo programa que a definiu nao é um grande problema, pois á medida que os programas se tornam mais complexos eles exigem solugoes próprias e detalhadas. No entanto, se todas as suas fungoes servirem apenas a um programa, considere isso como um sinal de alerta. Vejamos o que nao fazer na listagem 8.8. Listagem 8.8 - Como nao escrever urna fungao def soma(L): total=0 x =0 while xl: fat*=n n-=l return fa t

Se vocé rastrear essa fungao, verá que calculamos o fatorial multiplicando o valor de n pelo valor anterior (fat) e que comegamos do maior núm ero até chegarmos em 1. Observe que a forma que definimos a fungao satisfaz o caso especial do fatorial de zero. Poderíamos também ter definida a fungao como na listagem 8.10.

Capítulo 8 ■Fundes

151

Listagem 8.10 - Outra forma de calcular o fatorial def fa to r ia l(n ): fa t= l x=l while x L=[5,7,8] » > sum(L) 20

> » max(L) 8

» > rain(L)

8.1 Variáveis locáis e globais Quando usamos fungoes, comegamos a trabalhar com variáveis internas ou locáis e com variáveis externas ou globais. A diferenga entre elas é a visibilidade ou escopo. Urna varíavel local a urna fungao existe apenas dentro desta, sendo normalmente inicializada a cada chamada. Assim, nao podemos acessar o valor de urna varíavel local fora da fungao que a criou e, por isso, passamos parámetros e retornamos valores ñas fungoes, de forma a possibilitar a troca de dados no programa. Urna variável global é definida fora de urna fungao e pode ser vista por todos as fungoes do módulo e por todos os módulos que importam o m ódulo que a definíu.

152

In tro du jo á Programado com Python

Vejamos um exemplo dos dois casos: EMPRESA=''Unidos Venceremos Ltda" def imprime_cabe(:alho(): print(EMPRESA) printc-" * len(EMPRESA))

A fungao cabegalho nao recebe parámetros nem retom a valores. Ela simplesmente imprime o nome da empresa e tragos abaixo deste. Observe que utili­ zamos a variável EMPRESA definida fora da fungao. Nesse caso, EMPRESA é urna variável global, podendo ser acessada em qualquer fungao. Variáveis globais devem ser utilizadas o mínimo possível em seus programas, pois dificultara a leitura e violam o encapsulamento da fungao. A dificuldade da leitura é em procurar pela definigao e conteúdos fora da fungao em si, que podem m udar entre diferentes chamadas. Além disso, urna varíavel global pode ser alterada por qualquer fungao, tornando a tarefa de saber quem altera seu valor realmente mais trabalhosa. O encapsulamento é comprometido porque a fungao depende de urna variável externa, ou seja, que nao é declarada dentro da fungao nem recebida como parámetro. Embora devamos utilizar variáveis globais com cuidado, isso nao significa que estas nao tenham uso ou que possam simplesmente ser classificadas como má prática. Um bom uso de variáveis globais é guardar valores constantes e que devem ser acessíveis a todas as fungoes do programa, como, por exemplo, o nome da empresa. Elas também sao utilizadas em nosso programa principal e para inicializar o m ódulo com valores iniciáis. Tente utilizar variáveis globais apenas para configuragáo e com valores constantes. Por exemplo, se na fungao cabegalho o nome da empresa mudasse entre urna chamada e outra, este nao deveria ser armazenado em urna variável global, mas passado por parámetro. Devido á capacidade da linguagem Python de declarar variáveis á medida que precisarmos, devemos tomar cuidado quando alteramos urna variável global dentro de urna fungao. Vejamos um exemplo: a=5 O def muda_e_imprime(): a=7 0 print("A dentro da funpao: %d" % a) print("a antes de mudar: %d" % a) © muda_e_imprime() © print("a depois de mudar: %d" % a) ©

Capítulo8 ■ Fundes

153

Execute o programa e analise seu resultado. Vocé sabe por que o valor de a nao mudou? Tente responder a essa questao antes de continuar lendo. Em O, criamos a variável global a. Em Q , temos a variável local da fu n d o , também chamada a, recebendo 7. Em © e ©, imprimimos o valor da variável global a e, em ©, o valor da variável local a. Para o computador, essas variáveis sao completamente diferentes, embora tenham o mesmo nome. Em ©, pode­ mos acessar seu conteúdo porque realizamos a impressáo dentro da fun^áo. Da mesma forma, a variável a que imprimimos é a variável local, valendo 7. Essa variável local deixa de existir no final da fungáo e explica porque nao alteramos a variável global a. Se quisermos modificar urna variável global dentro de urna fu n d o , devemos informar que estamos usando urna variável global antes de inicializá-la, na primeira linha de nossa funtjáo. Essa d efinido é feita com a instrugao global. Vejamos o exemplo modificado: a=5 def muda_e_imprime(): global a © a=7 © print("A dentro da fu n d o : %d" % a) print("a antes de mudar: %d” % a) muda_e_imprime() print("a depois de mudar: %d" % a)

Agora, em Q , estamos trabalhando com a variável a global. Assim, quando fizemos a=7 em © , trocamos o valor de a. Lembre-se de limitar o uso de variáveis globais. A utilizad o da instrugao global pode sinalizar um problema de c o n stru y o no programa. Lembre-se de utilizar variáveis globais apenas para configurado e, de preferencia, como constantes. Dessa forma, voce utilizará global apenas ñas fungoes que alteram a configurado de seu programa ou módulo. A in stru y o global facilita a escolha de nomes de variáveis locáis nos programas, pois deixa claro que estamos usando urna variável preexistente e nao criando urna nova. Tente definir variáveis globais de forma a facilitar a leitura de seu programa, como, por exemplo, usar apenas letras maiúsculas em seus nomes ou um prefixo, por exemplo, empresa ou gempresa.

154

Introduçâoà Programaçâo com Python

8.2 Fun$6es recursivas Urna fungao pode chamar a si mesma. Quando isso ocorre temos urna fungáo recursiva. O problema do fatorial é interessante para demonstrar o conceito de recursividade. Podemos definir o fatorial de um número como sendo esse número multiplicado pelo fatorial de seu antecessor. Se chamarmos nosso número de n, temos urna definicáo recursiva do fatorial como:

fatorial(n) = | n .K fatorjaK n _ 1}

“

-

Em Python, definiríamos a fungao recursiva para cálculo do fatorial como o programa d a listagem 8.11. Listagem 8.11 - Fun$áo recursiva do fatorial def fa to r ia l(n ): i f n==0 o r n == 1: return 1 else: return n * fa to rial(n -l)

Vamos adicionar algumas linhas para facilitar o rastreamento, alterando o programa para imprim ir na entrada da fungao (listagem 8.12). Listagem 8.12 - Fungáo modificada para facilitar o rastreamento def f a to r ia l(n ): print("Calculando o f a to r ia l de %d" % n) i f n==0 o r n == 1: p rin t(" F a to ria l de %d = 1” % n) return 1 else: f a t = n * fa to rial(n -l) p rin t(" f a to r ia l de %d = %d" % (nj fa t) ) return fa t f a to r i a l (4)

Q ue produz como resultado a tela da listagem 8.13.

155

Capítulo 8 ■Fundes

Listagem 8.13 - Cálculo do fatorial de 4 Calculando o f a to r ia l Calculando o f a to r ia l Calculando o f a to r ia l Calculando o f a to r ia l F atorial de 1 = 1 f a to r ia l de 2 = 2 f a to r ia l de 3 = 6 fa to r ia l de 4 = 24

de de de de

4 3 2 1

A sequéncia de Fibonacci é outro problema clássico no qual podemos aplicar fungoes recursivas. A sequéncia pode ser entendida como o núm ero de casais de coelhos que teríamos após cada ciclo de reprodugao, considerando que cada ciclo dá origem a um casal. Embora matemáticamente a sequéncia de Fibonacci revele propriedades mais complexas, nos limitaremos á historia dos casais de coelhos. A sequéncia comega com dois números 0 e 1. Os números seguintes sao a soma dos dois anteriores. A sequéncia ficaria assim: 0,1,1,2,3,5, 8,13,21,... Assim, urna fungao para calcular o enésimo termo da sequéncia de Fibonacci pode ser definida como: fibonacci(n) =

n n < 1 fibonacci(n - 1) + fibonacci(n - 2)

Sendo implementada em Python como apresentado na listagem 8.14. Listagem 8 .1 4 - Fun$áo recursiva de Fibonacci def fibonacci(n): i f n b. a m d c ( a ,b ) =

Onde

b = 0

m d c ( b f a - b | ^ J ) a ,b

.£>.1 pode ser escrito em Python como: a %b.

In tro du jo á Programado com Python

156

Exercício 8.8 - Usando a fungao m dc definida no exercício anterior, defina urna fungao para calcular o m enor m últiplo com um (M.M.C.) entre dois números.

O nde |a x b | pode ser escrito em Python como: abs(a*b). Exercício 8 .9 - Rastreie o program a da listagem 8 .12 e compare o resultado com o apresentado na listagem 8.13. Exercício 8.10 - Reescreva a fungao para cálculo da sequéncia de Fibonacci, sem utilizar recursáo.

8.3 Validado Fungoes sao m uito úteis para validar a entrada de dados. Vejamos o código para 1er u m valor inteiro, limitado por um valor de mínimo e máximo (listagem 815). Esse trecho repete a entrada de dados até termos u m valor válido. Listagem 8.15 - Exemplo de validagáo sem usar urna fun$áo while True: v=int(input(“Digite um valor entre 0 e 5 :")) i f v5: print("V alor inválido.") e lse: break

Podemos transformá-lo em urna fungao que receba a pergunta e os valores de máximo e m ínimo (listagem 8.16). Listagem 8.16 - Validagáo de inteiro usando fungao def faixa_int(pergunta, mínimo, máximo): while True: v=int(input(pergunta)) i f vcminimo o r v>maximo: print("Valor inválido. Digite um valor entre %d e else: return

%d" %

(mínimo,máximo))

Capítulo8 ■ Fundes

157

Esse tipo de verificagáo é muito importante quando nosso programa só fun­ ciona com urna faixa de valores. Q uando verificamos os dados do programa, estamos realizando urna validagáo. Avalidagáo é muito importante para evitarmos erros difíceis de detectar depois de termos escrito o programa. Sempre que seu programa receber dados, seja pelo teclado ou por um arquivo, verifique se esses dados estáo na faixa e no formato adequado para o bom funcionamento. Exercído8.11 - Escreva urna fungao para validar um variável string. Essa fungao recebe como parámetro a string, o número m ínim o e máximo de caracte­ res. Retorne verdadeiro se o tam anho da string estiver entre os valores de máximo e mínimo, e falso em caso contrário. Exercído 8.12 - Escreva urna fungao que receba urna string e urna lista. A fun­ gao deve comparar a string passada com os elementos da lista, também passada como parámetro. Retorne verdadeiro se a string for encontrada dentro da lista, e falso em caso contrário.

8.4

Parámetros opcionais

Nem sempre precisaremos passar todos os parámetros para urna fungao, preferindo utilizar um valor previamente escolhido como padráo, mas deixando a possibilidade de alterá-lo caso necessário. Vejamos urna fungao que imprime urna barra na tela na listagem 8.17. Listagem 8.17 - Fungao para imprimir urna barra na tela def barraQ : print("*" * 40)

Nesse exemplo, a fungao barra nao recebe algum parámetro e pode ser chamada com barra(). Porém, tanto o asterisco (*) quanto a quantidade de caracteres a exibir na barra podem precisar ser alterados. Por exemplo, podemos utilizar urna barra de asteriscos em urna parte de nosso programa e urna barra com pontos em outra. Para resolver esse problema, podemos utilizar parámetros opcionais. Listagem 8.18 - Fungao para imprimir urna barra na tela com parámetros opcionais def barra(n=40, caractere="*“) : p rin t(c ara ctere * n)

In tro d u jo á Programado com Python

158

Essa nova definicáo (listagem 8.18) permite utilizar a fungáo barra como antes, ou seja, barraQ, onde caractere será igual a e n será igual a 40. Ao usarmos parámetros opcionais, estamos especificando que valores devem ser utilizados caso um novo valor nao seja especificado, mas aínda assim deixando a possibilidade de passarmos outro valor. Veja os exemplos da listagem 8.19. Listagem 8.19 - Passagem de parámetros opcionais » > barra( 1 0 ) # faz com que n seja » > b arra( 10 ," -" ) # n =

10

10

e caractere="-"

Parámetros opcionais sao úteis para evitar a passagem desnecessária dos mesmos valores, mas preservando a opgáo de passar valores se necessário. Podemos combinar parámetros opcionais com obrigatórios na mesma fungáo. Vejamos a fungáo soma na listagem 8.20. Listagem 8.20 - Fundió soma com parámetros obrigatórios e opcionais def soma(a, b, imprime=false): s =a + b i f imprime: p rin t(s ) return s

No exemplo, a e b sao parámetros obrigatórios e imprime é um parámetro opcional. Essa fungáo pode ser utilizada como mostra a listagem 8.21. Listagem 8.21 - Uso da fu n d o soma com parámetros obrigatórios e opcionais » > soma(2,3) 5 >>> soma(3,4, True) 7 7 >>> soma(5,8, False) 13

Embora possamos combinar parámetros opcionais e obrigatórios, estes nao podem ser m isturados entre si, e os parámetros opcionais devem sempre ser os últimos. Vejamos urna definigáo inválida na listagem 8.22.

Capítulo 8 ■Funçôes

159

Listagem 8.22 - D efinido inválida da fun serao impressas alinhadas á direita, as com Esta linha deve ser impressa alinhada a d ire ita *Esta linha deve ser centralizada Urna linha normal Outra linha normal

Listagem 9.6 - Processamento de um arquivo LARGURA=79 entrada=open("entrada.tx t " ) fo r linha in entrada.readlinesQ : i f lin h a[0]==";": continué e l i f linha[0]==”>": print(linha[l:].rjust(LARGURA)) e l i f lin h a[0]=="^": p rin t(lin h a [ 1 : ] .center(LARGURA)) else: prin t(lin h a) entrada.close()

Exercício 9 .6 - Modifique o programa da listagem 9.6 para im prim ir 40 vezes o sím bolo de = se este for o primeiro caractere da linha. Adicione também a opgáo para parar de im prim ir até que se pressione a tecla ENTER cada vez que urna linha iniciar com . como prim eiro caractere. Exercício 9.7 - Crie um program a que leia um arquivo txt e gere um arquivo de saída paginado. Cada linha nao deve conter mais de 76 caracteres. Cada página terá no máximo 60 linhas. Adicione na última linha de cada página o número da página atual e o nome do arquivo original.

176

Introduçâo à Programaçâo corn Python

Exercicio 9.8 - Modifique o programa anterior para também receber o número de caracteres por linha e o número de páginas por folha pela linha de comando. Exercicio 9 .9 - Crie um program a que receba urna lista de nomes de arquivo e os im prim a, um por um. Exercicio 9.10 - Crie um program a que receba urna lista de nomes de arquivo e que gere apenas um grande arquivo de saida. Exercicio 9.11 - Crie um program a que leia um arquivo e crie u m dicionário onde cada chave é urna palavra e cada valor é o núm ero de ocorrências no arquivo. Exercicio 9.12 - Modifique o program a anterior para tam bém registrar a linha e a colima de cada ocorrência da palavra no arquivo. Para isso, utilize listas nos valores de cada palavra, guardando a linha e a coluna de cada ocorrência. Exercicio 9.13 - Crie um programa que imprima as linhas de um arquivo. Esse program a deve receber très parámetros pela linha de comando: o nome do arquivo, a linha inicial e a últim a linha a imprimir. Exercicio 9.14 - Crie u m program a que leia um arquivo texto e elimine os espaços repetidos entre as palavras e no fim das linhas. O arquivo de saida tam bém nâo deve ter mais de um a linha em branco repetida. Exercicio 9.15 - Altere o program a da listagem 7.5, o jogo d a força. Utilize um arquivo em que um a palavra seja gravada a cada linha. Use u m editor de textos para gerar o arquivo. Ao iniciar o programa, utilize esse arquivo para carregar a lista de palavras. Experimente tam bém perguntar o nom e do jogador e gerar um arquivo com o núm ero de acertos dos cinco melhores. Usando arquivos, podemos gravar dados de forma a reutilizá-los nos programas. Até agora, tudo que inserimos ou digitamos nos programas era perdido no fim da execuçâo. Com arquivos, podemos registrar essa informaçâo e reuülizá-la. Arquivos podem ser utilizados para fornecer uma grande quantidade de dados aos programas. Vejamos um exemplo, no qual gravaremos nomes e telefones em um arquivo texto. Utilizaremos um menu pra deixar o usuário decidir quando 1er o arquivo e quando gravá-lo. Exécuté o programa da listagem 9.7 e analise-o cuidadosamente. Os exercícios a seguir modificam o programa da listagem 9.7.

Capítulo 9 ■Arquivos

177

Exercfcio 9-16 - Explique como os campos nome e telefone sao armazenados no arquivo de saída. Exercício 9.17 - Altere o programa para exibir o tam anho da agenda no menú principal. Exercício 9.18 - O que acontece se nome ou telefone contiverem o caractere usado como separador em seus conteúdos? Explique o problema e proponha urna solugao. Exercício 9.19 - Altere a fungáo lista para que exiba também a posigáo de cada elemento. Exercício 9.20 - Adicione a opgáo de ordenar a lista por nome no menú principal. Exercício 9.21 - Ñas fungoes de altera e apaga, pega que o usuário confirme a alteragáo e exclusáo do nom e antes de realizar a operagáo em si. Exercício 9.22 - Ao 1er ou gravar urna nova lista, verifique se a agenda atual já foi gravada. Vocé pode usar urna variável para controlar quando a lista foi alterada (novo, altera, apaga) e reinicializar esse valor quando ela for Iida ou gravada. Exercício 9.23 - Altere o program a para 1er a última agenda lida ou gravada ao inicializar. Diea: utilize outro arquivo para armazenar o nome. Exercício 9.24- O que acontece com a agenda se ocorrer um erro de leitura ou gravagáo? Explique. Exercício 9.25 - Altere as fungoes pede_nome e pede_telefone de forma a receberem u m parámetro opcional. Caso esse parámetro seja passado, utilize-o como retorno caso a entrada de dados seja vazia. Exercício 9.26 - Altere o programa de forma a verificar a repetigao de nomes. Gere urna mensagem de erro caso duas entradas na agenda tenham o mesmo nome. Exercício 9.27 - Modifique o programa para também controlar a data de aniversário e o e-mail de cada pessoa. Exercício 9 .2 8 - Modifique o programa de forma a poder registrar vários telefo­ nes para a mesma pessoa. Permita também cadastrar o tipo de telefone: celular, fixo, residencia, trabalho ou fax.

In tro d u jo á Programado com Python

178

Listagem 9.7 - Controle de urna agenda de telefones agenda = [] def pede_nome(): return(input("Nome: ")) def pede_telefone(): return(input("Telefone: ")) def mostra_dados(nomej telefo n e): print("Nome: %s Telefone: %s" % (nome, telefo n e)) def pede_nome_arquivo(): return(input("Nome do arquivo: ")) def pesquisa(nome): mnome = nome.lowerQ fo r p, e in enumerate(agenda): i f e[0].low er() == mnome: return p return None def novo(): global agenda nome = pede_nome() telefone = pede_telefone() agenda.append([nome, telefo n e]) def apagaQ: global agenda nome = pede_nome() p = pesquisa(nome) i f p!=None: del agenda[p] else: print("Nome nao encontrado.") def a lte r a Q : p = pesquisa(pede_nome()) i f p!=None: nome = agenda[p][0] telefone = agenda[p][l] print("Encontrado:") mostra_dados(nome, telefone) nome = pede_nome() telefone = pede_telefone() agenda[p]=[nome, telefone] else: print("Nome nao encontrado.")

Capítulo 9 ■Arquivos

179

def l i s t a (): print("\nAgenda\n\n--------") fo r e in agenda: mostra_dados(e[0 ], e [ l] ) p rin t(" .......... \n") def l é ( ) : global agenda norae_arquivo = pede_nome_arquivo() arquivo = open(nome_arquivo, "r" , encoding="utf-8") agenda = [] fo r 1 in arquivo,readlines(): nome, telefone = l .s tr i p ( ) .s p l i t( " # u) agenda.append([nome, telefone]) arquivo.close() def grava(): nome_arquivo = pede_nome_arquivo() arquivo = open(nome_arquivo, "w", encoding="utf-8") for e in agenda: arquivo.write("%s#%s\n" % (e[ 0 ] , e [ l] )) arquivo.close() def valida_faixa_inteiro(pergunta, in ic io , finí): while True: try : valor = i h t ( input(pergunta)) i f in ic io \n") pagina.write("< head >\n ") pagina.write("\n") pagina.w rite("T ítulo da Página\n") pagina. w rite("\n") pagina.w rite("\n") pagina.write("Olá!") for 1 in range(10): pagina.write("%d\n" % 1) pagina.write("\n") pagina.write("\n") pagina.close()

Simplesmente escrevemos nossa página dentro de um programa. Observe que ao escrevermos aspas dentro de aspas, como na tag html, onde o valor de lang é utf-8 e é escrito entre aspas, tivemos o cuidado de colocar urna barra antes das aspas, informando, dessa forma, que as aspas nao fazem parte do programa e que nao marcam o fim da string. Um detalhe muito importante é o pará­ metro extra que passamos em open. O parámetro encoding="utf-8" informa que queremos os arquivos com a codificagao UTF-8. Essa codificagáo tem que ser a mesma declarada no arquivo html, caso contrario, teremos problemas com caracteres acentuados. Execute o programa e abra o arquivopagina.html em seu browser. Modifique o programa para gerar 100 parágrafos em vez de 10. Execute-o novamente e veja o resultado no browser (abrindo o arquivo novamente ou dicando em recar regar).

Capítulo 9 «Arquivos

183

Em nossos primeiros testes, vimos que escrevendo várias linhas de texto no corpo da página nao alteramos o formato de saída da página. Isso porque o formato htm l ignora espatos em branco repetidos e quebras de linha. Se quisermos mostrar o texto em vários parágrafos, devemos utilizar o elemento p. Assim, as tags e marcam o inicio e o fim de um parágrafo, como no programa da listagem 9.8. Python oferece recursos mais interessantes para trabalhar com strings, como aspas triplas que permitem escrever longos textos mais fácilmente. Elas funcionam como as aspas, mas permitem digitar a mensagem em várias linhas. Vejamos o programa da listagem 9.9. Listagem 9.9 - Uso de aspas triplas para escrever as strings pagina=open("pagina.html" , “w", eneoding="u t f -8") pagina.w rite(..... < title> T ítulo da P ágina Olá!

.... ) fo r 1 in range(10): pagina.write("%d\n" % 1) pagina.writeC’""

.... ) pagina.cióse()

O utra vantagem é que nao precisamos colocar urna barra antes das aspas, pois agora o fim das aspas também é triplo (.... ), nao sendo mais necessário diferenciá-lo. Experimente agora modificar o programa retirando os \n do final das linhas. Execute-o e veja o resultado no browser. Vocé deve perceber que mesmo sem utilizar quebras de linhas no arquivo, o resultado permaneceu o mesmo. Isso porque espatos adicionáis (repetidos) e quebras de linha sao ignorados (ou quase ignorados) em HTML. No entanto, observe que a página criada é mais difícil de 1er para nós.

In tro d u jo á Programado com Python

184

O formato HTML contém múmeras tags que sao continuamente revisadas e expandidas.Além das tags q u ejé conhecemos, temos tam bém as que marcam os cabegalhos dos documentos: hl, h2, h3, h4, h5 e h6. Os números de 1 a 6 sao utilizados para indicar o nivel da segáo ou subsegao do documento, como faríamos no Microsoft W ord ou OpenOffice com estilos de cabegalho. Vejamos como gerar páginas web a partir de um dicionário. Vamos utilizar as cha­ ves como título das segoes e o valor como conteúdo do parágrafo (listagem 9.10). Listagem 9 .1 0 —Geragáo de urna página web a partir de um dicionário filmes={ "drama": ["Cidadao KaneV’O Poderoso Chefao'1], "comedia": [“Tempos Modernos","American P ie'V ’Dr. D o little "], "p o lic ia l" : ["Chuva Negra","Desejo de M atar","D ifícil de Matar"], "guerra": ["Rambo","Platoon","Tora¡Tora¡Tora!"]

> pagina=open( "filmes.html", "w", encoding="utf-8") pagina.w rite(""" < title>F ilm es

.... ) fo r c, v in iterkeys(film es): pagina.w rite(“%s" % c) fo r e in v: pagina.write("%s" % e) pagina.w rite("""

.... ) pagina. closeQ

Exercício 9.29 - M odifique o program a da listagem 9.10 para utilizar o elemento p em vez de h2 nos filmes. Exercício 9.30 - M odifique o program a da listagem 9.10 para gerar urna lista html, usando os elementos ul e l i . Todos os elementos da lista deve estar dentro d o elemento ul e cada item dentro de um elemento l i . Exemplo: < ulxli> Item l< /lixli> Item 2< /li>< li> Item 3

Capítulo 9 ■Arquivos

185

Vocé pode 1er mais sobre HTML e CSS (Cascading Style-Sheets) para gerar páginas profissionais em Python.

9.6 Arquivos e diretórios Agora que já sabemos 1er, criar e alterar arquivos, vamos aprender como listá-los, manipular diretórios, verificar o tamanho e a data de criagao de arquivos em disco. Para comegar, precisamos que os programas saibam de onde estáo sendo executados. Vamos utilizar a fungáo getcwd do módulo os para obter esse valor (listagem 9.11). Listagem 9.11 - Obtengo do diretório atual > » import os » > os.getcwd()

Também podemos trocar de diretório em Python, mas antes, precisamos criar alguns diretórios para teste. Na linha de comando, digite: mkdir a mkdir b mkdir c

Se preferir, vocé pode criar as pastas a, b e c usando o Windows Explorer, o Finder ou outro utilitário de sua preferencia. Agora, vejamos a listagem 9.12. Listagem 9.12 - Troca de diretório import os os.chdir(''a") print(os.getcw d()) os.chdir print(os.getcw d()) os.chdir("b") print(os.getcw d()) o s.c h d ir(" ../c " ) print(os.getcwdQ)

A fungao chdir muda o diretório atual, por isso a fungao getcwd apresenta valores diferentes. Vocé pode referenciar um arquivo apenas usando seu nome se ele estiver no diretório atual ou de trabalho. O que chdir faz é m udar o diretório de trabalho, permitindo que vocé acesse seus arquivos mais fácilmente.

In tro d u jo á Programado com Python

Quando passamos .. para elidir ou qualquer outra fungáo que m anipule arquivos e diretórios, estamos nos referindo ao diretório pai ou de nivel superior. Por exemplo, considere o diretório z, que contém os diretórios h, i, j. Dentro do diretório (ou pasta) j temos o diretório k (figura 9.1). Q uando um diretório está dentro de outro, dizemos que o diretório pai contém o diretório filho. No exemplo, k é filho de j e j é pai de k. Temos também que h, i, j sao todos filhos de z, ou seja, z é o pai de h, i, j.

íá h M • ■ “ü

I íJ é

fc

Figura 9 .1 - E strutura de diretórios n o W indows E xplorer do W indows 7.

Esse tipo de enderegamento é sempre relativo ao diretório corren te, por isso é tao im portante saber em que diretório estamos. Se o diretório corrente for k, .. refere-se a j. Mas se o diretório atual for i , .. refere-se a z. Podemos também combinar vários .. no mesmo enderego ou caminho (path). Por exemplo, se o diretório atual for k, . . será urna referencia a z e assim por diante. Também podemos usar o diretório pai para navegar entre os diretórios. Por exemplo, para acessar h, estando em k, podemos escrever ../ . ./h. Podemos tam bém criar diretórios nos programas utilizando a fungáo mkdir (listagem 9.13). Listagem 9.13 - C riad o de diretórios import os os.mkdir("d") os.m kdir("e") os.m kdir("f") print(os.getcw d()) os.chdir("d") p rin t (o s. getcwd ()) o s.ch d ir( " . ./e " ) pr i n t (os . get cwd()) o s .c h d ir( " ..") print(os.getcw dQ ) o s .ch d ir("f") print(os.getcw d())

Capítulo 9 ■Arquivos

187

A fungáo mkdir cria apenas um diretório de cada vez. Se precisar criar um diretório, sabendo ou nao se os superiores foram criados, use a fungao makedirs, que cria todos os diretórios intermediáríos de urna só vez. Listagem 9.14 - C riad o de intermediáríos de urna só vez import os os.makedirs( "avó/pai/filho") o s .makedirs("avó/máe/filha")

Abra o diretório atual usando o Windows Explorer ou Finder, no Mac OS X, para ver os diretórios criados (figura 9.2).

mae

i

fiíiia:

A lH pai i f f №0

Figura 9.2 —Estrutura de diretórios criada em disco no Windows Explorer do Windows Z Vocé pode m udar o nome de um diretório ou arquivo, ou seja, renomeá-lo usando a funijao rename (listagem 9.15). Listagem 9.15 - A lterado do nome de arquivos e diretórios import os os.mkdir("velho") os. rename(,,velho"J "novo") A fungao rename também pode ser utilizada para mover arquivos, bastando especificar o mesmo nome em outro diretório (listagem 9.16). Listagem 9.16 - A lterado do nome de arquivos e diretórios import os os.makedi r s (" avó/pai/filho") os.makedirs("avó/mae/filha") os. rename( "avó/pai/filho", "avó/mie/filho") Se vocé quiser apagar um diretório, utilize a fun^áo rmdir. Se quiser apagar um arquivo, use a fun^ao remove (listagem 9.17).

In trodujo á Programado com Python

Listagem 9.17 - Exdusáo de arquivos e diretórios import os # Cria um arquivo e o fecha imediatamente open("morimbundo.t x t ", "w") . clo se() os.mkdir("vago") os.rmdir("vago") os. remove("morimbundo.txt")

Podemos tam bém solicitar urna listagem de todos os arquivos e diretórios usando a f un gao listd ir. Os arquivos e diretórios serao retornados como ele­ mentos da lista (listagem 9.18). Listagem 9.18 - Listagem do nome de arquivos e diretórios import os p rin t(o s . l i s t d i r ( " . “)) p rin t(o s . listd ir(" a v ó " )) p rin t(o s . l i s t d i r ( ”avó/pai")) p rin t(os. l i s t d i r ( "avó/mae"))

Onde . significa o diretório atual. A lista contém apenas o nome de cada arquivo. Vamos ver como obter o tam anho do arquivo e as datas de criagao, acesso e m'odificagao a seguir com o m ódulo os.path. O m ódulo os.path traz várias outras fungoes que vamos utilizar para obter mais informagóes sobre os arquivos em disco. As duas primeiras sao isdir e isfile, que retornam True se o nome passado for um diretório ou um arquivo respectivamente (listagem 9.19). Listagem 9.19 - Verificado se é diretório ou arquivo import os import o s .path for a in o s .l is t d i r ( " ." ) : i f o s .p a th .is d ir(a ): print("% s/" % a) e l i f o s.p a th .isfile (a ): print("%s" % a)

Execute o programa e veja que imprimimos apenas os nomes de diretórios e arquivos, sendo que adicionamos urna barra no final dos nomes de diretório. Podemos também verificar se um diretório ou arquivo já existe com a fungao exists (listagem 9.20).

Capítulo 9 ■Arquivos

Listagem 9.20 - Verificado se um diretório ou arquivo já existe import os.path i f o s .p ath .ex ists("z"): p rin t("0 d iretó rio z ex is te ." ) else: prin t("0 d ire tó rio z nao ex is te ." )

Exercício 9.31 - Crie um program a que corrija o da listagem 9.20 de forma a verificar se z existe e é um diretório. Exercício 9.32 - Modifique o programa da listagem 9.20 de forma a receber o nome do arquivo ou diretório a verificar pela linha de comando. Imprima se existe e se é um arquivo ou um diretório. Exercício 9.33 - Crie um program a que gere urna página html com links para todos os arquivos jpg e png encontrados a partir de um diretório infor­ mado na linha de comando. Temos também outras fungóes que retornam mais informagoes sobre arqui­ vos e diretórios como seu tam anho e datas de modificagao, criagáo e acesso (listagem 921). Listagem 9.21 - Obtengo de mais in fo rm ale s sobre o arquivo import os import os.path import time import sys nome = sys.argvfl] print("Nome: %s" % nome) print("Tamanho: Xú" % os.path.getsize(nom e)) print("C riado: %s" % time.ctime(os.path.getctime(nome))) print("Modificado: %s" % time.ctime(os.path.getmtime(nome))) print("Acessado: %s" % time.ctime(os.path.getatime(nome)))

Onde getsize retorna o tamanho do arquivo em bytes, getctime retorna a data e hora de criagao, getmtime de modificagao e getatime de acesso. Observe que cha­ mamos time, ctime para transformar a data e hora retornadas por getmtime, getatime e getctime em string. Isso é necessário porque o valor retornado é expresso em segundos e precisa ser corretamente convertido para ser exibido.

Introducto á Programado com Python

190

9.7 Um pouco sobre o tempo O m ódulo time traz várias fungoes para manipular o tempo. Urna délas foi apresentada na segáo anterior: time.ctime, que converte um valor em segundos após 01/01/1970 em string. Temos também a fungáo gmtime, que retorna urna tupia com componentes do tempo separados em elementos. Vejamos alguns exemplos no interpretador (listagem 9.22). Listagem 9.22 - Obtengo das horas em Python » > import time » > agora=time.time() » > agora 1277310220.906508 » > time.ctime(agora) 'Wed 3un 23 18:23:40 2010' » > a g o ra 2 = tim e .lo c a ltim e ()

» > agora2 time.struct_time(tm_year=2010j tm_mon=6, tm_mday=23j tm_hour=18j tm_ min=23j tm_sec=40, tm_wday=2j tm_yday=174, tm _isdst=l) » > time.gmtime(agora) time.struct_time(tm_year=2010J tm_mon=6, tm_mday=23, tm_hour=16, tm_ min=23, tm_sec=40, tm_wday=2j tm_yday=174, tm_isdst=0)

A fungáo time.time retorna a hora atual em segundos, usando o horário de Greenwich ou UTC (Tempo Universal Coordenado). N a listagem 9.22, atribu­ imos seu resultado á variável agora e convertemos em string usando time.ctime. Se vocé deseja trabalhar com a hora em seu fuso horário, utilize time, localtime, como mostrado com a varíavel agora2 . Observe que time.localtime retornou urna tupia e que time.time retorna apenas um número. Podemos utilizar a fungáo gmtime para converter a variável agora em urna tupia de nove elementos, como a retornada por time.localtime (tabela 9.2). Tóbela 9.2 - Elementos da tupia de tempo retomada por gmtime Pósito

Nome

0

tm_year

ano

Describo

1

tm_mon

més

2

tm_mday

día

3

tmjiour j hora

4

tm_min

minutos

5

tm_sec

segundos

6

tm_wday

dia da semana entre0 e6, ondesegunda-feira é0

Capítulo 9 ■Arquivos

191

Posiqao

Nome

7

tm_yday

día doano, varia de 1a366.

8

tmjsdst

horáriodeverao, onde1india estar nohorariodeverao.

Describió

Podemos também acessar esses dados por nome (listagem 9.23). Listagem 9.23 - O btengo de data e hora por nome import time agora=time.localtim e() print("Ano: %d” % agora.tm_year) print("Més: %d" % agora.tmjnon) print("D ia: %d" % agora.tmjnday) print("Hora: %d" % agora.tm_hour) print("M inuto: %d" % agora.tmjnin) print("Segundo: %d" % agora.tm_sec) print("D ia da semana: %d" % agora.tm_wday) print("D ia no ano: %d" % agora.tm_yday) print("H orário de verao: %d" % agora.tm_isdst)

Afungao time, strftime permite a formatagao do tempo emstring. Voce pode passar o formato desejado para a string, seguindo os códigos de formatagao da tabela 93. I abela 93 - Códigos de formatagao de strftime Código

Describo

%a

día dasemanaabreviado

%A

nomedodiada semana

%b

nome domesabreviado

%B

nome domes completo

%c

data ehoraconformeconfiguradoregional

%d

diadomes (01-31)

%H

horanoformato24 h(00-23)

%l

horanoformato 12 h

%j

diado ano001-366

%m

més (01-12)

%M

minutos (00-59)

%p

AMouPM

%s

segundos(00-61)

%ü

númerodasemana (00-53), ondeasemana 1 cometa após oprimeirodomingo.

%w

dia dasemana (0-6) onde0 é odomingo

%W

númerodasemana (00-53), ondeasemana 1 comed 11ptlmolrasegunda-feira

192

Introduçâoà Programaçâo com Python

Código

Describo

%x

representado regional dadata

%X

representado regional dahora

%y

ano (00-99)

%Y

anocom4 dígitos

%Z

nomedofusohorário

%

símbolode%

Se precisar converter urna tupia em segundos, utilize a funçâo timegm do m ódulo calendar. Se precisa trabalhar com data e hora em seus programas, consulte a documentaçâo do Python sobre os módulos time, calendar e locale. Exerddo 9.34 - Altere o program a da iistagem 7.45, o jogo d a força. Dessa vez, utilize as funçôes de tem po para cronom etrar a duraçâo das partidas.

9.8

Uso de caminhos

Urna tarefa comum quando se trabalha com arquivos é manipular caminhos. Como essa tarefa depende do sistema operational e cada sistema tem suas próprias características como no Linux e no Mac OS X para separar o nome dos diretórios e “\ ” no Windows, a biblioteca padrâo do Python traz algumas funçôes intéressantes. Aquí veremos as mais importantes: a documentaçâo do Python traz a lista completa. Vejamos alguns exemplos dessas funçôes quando chamadas no interpretador Python na Iistagem 9.24. Listagem 9.24 - Uso de caminhos > » import o s .path > » caminho="i/j/k" >>> os.path.abspath(caminho) ' C:\\P y th o n 3 1 \\i\\j\\k 1 >>> os.path.basename(caminho) ■k1 >>> os.path.dirname(caminho) ’i / j ’ » > os.path.split(cam inho) C i / j ’ , ‘k ’) » > os. path. s p lite x t( "arquivo.txt") ('a rq u iv o ', '. t x t ') » > o s. path. s p litd riv e (" c : /Windows") ( ' c : ' , ' /Windows')

Capítulo 9 ■Arquivos

193

A fungáo abspath retorna o caminho absoluto do path passado como parámetro. Se o caminho nao comegar com /, o diretório atual é acrescentado, retornando o caminho completo a partir da raiz. N o caso do Windows, incluindo também a letra do disco (drive), no caso C:. Observe que o caminho “j/k” é apenas urna string. As fungoes de os.path nao verificam se esse caminho realmente existe. Na realidade, os.path, na maioria das vezes, oferece apenas fungóes inteligentes para manipulagáo de caminhos como strings. A fungáo basename retorna apenas a última parte do caminho, no exemplo, k. Já a fungáo dirname retorna o caminho á esquerda da última barra. Mais urna vez, essas fungoes nao verificam se k é um arquivo ou diretório. Considere que basename retorna a parte do caminho á direita da última barra e que dirname retorna o caminho á esquerda. Vocé até pode combinar o resultado dessas duas fungoes com a fungáo split, que retorna urna tupia onde os elementos sáo iguais aos resultados de dirname e basename. No Windows, vocé pode tam bém usar a fungáo splitdrive para separar a letra do drive do caminho em si. A fungáo retorna urna tupia, onde a letra do drive é o primeiro elemento, e o restante do caminho, o segundo. A fungáo join junta os componentes de um caminho, separando-os com barras se necessário. Veja o exemplo da listagem 9.25. No Windows, a fungáo verifica se o nome termina com e, nesse caso, náo insere urna barra, permitindo a criagao de um caminho relativo. Podemos combinar o resultado desta fungáo com abspath e obter um caminho a partir da raiz. Veja que a manipulagáo da letra do drive é feita automáticamente. Listagem 9.25 - Combinado dos componentes de um caminho » > import os.path » > os.path.join("c:“,"dados" programas") 'c:dadosWprogramas' » > os.path.abspath(os.path.join("c:1 1 dados ”programas")) ' C:\\Python31\\dados\\programas1

In tro du jo á Programado com Python

194

9.9 Visita a todos os subdiretórios recursivamente Afungao os.walk facilita a navegagao em urna árvore de diretórios. Imagine que deseje percorrer todos os diretórios a partir de um diretório inicial, retornando o nom e do diretório sendo visitado (raíz), os diretórios encontrados dentro do diretório sendo visitado (diretórios) e urna lista de seus arquivos (arquivos). Observe e execute o program a da listagem 9.26. Vocé deve executá-lo passando o diretório inicial a visitar na linha de comando. Listagem 9.26 - Árvore de diretórios sendo percorrida import os import sys fo r ra iz , d ire tó rio s , arquivos in o s.w a lk (sy s.a rg v [l]): print("\nCaminho:", ra iz ) fo r d in d iretó rio s: p rin t(" %s/" % d) for f in arquivos: print(" %s" % f) print("%d d ire tó rio (s ), %d arquivo(s)" % (le n (d iretó rio s), len(arquivos)))

A grande vantagem da fungao os.walk é que ela visita automáticamente todos os subdiretórios dentro do diretório passado como parámetro, fazendo-o re­ petidamente até navegar a árvore de diretórios completa. Com binando a fungió os.walk as fungoes de manipulagao de diretórios e arquivos que já conhecemos, vocé pode escrever programas para manipular árvores de diretórios completas. Exercício9.35- Utilizando a funcao os.walk, crie urna página HTML com o nome e tam anho de cada arquivo de um diretório passado e de seus subdiretórios. Exercício 9.36 - Utilizando a fungao os.walk, crie um program a que calcule o espago ocupado por cada diretório e subdiretório, gerando u m página htm l com os resultados.

CAPÍTULO

10

Classes e objetos

A programagao orientada a objetos facilita a escrita e manutengáo de nossos programas utilizando classes e objetos. Classes sao a definigao de um novo tipo de dados que associa dados e operagoes em urna só estrutura. Um objeto pode ser entendido como urna variável cujo tipo é urna classe, ou seja, um objeto é urna instancia de urna classe. Aprogramagáo orientada a objetos é urna técnica de programagao que organiza nossos programas em classes e objetos em vez de apenas fungóes, como vimos até agora. É um assunto muito importante e extenso, merecendo vários livros e muita prática para ser completamente entendido. O objetivo deste capítulo é apresentar o básico da orientagáo a objetos de forma a introduzir o conceito e estimular o aprendizado dessa técnica.

10.1 Objetos como representado do mundo real Podemos entender um objeto em Python como a representagao de um objeto do m undo real, escrita em urna linguagem de programagao. Essa representagao é limitada pela quantidade de detalhes que podemos ou queremos representar, urna abstragao. Vejamos, por exemplo, um aparelho de televisáo. Podemos dizer que urna televisáo tem urna marca e um tamanho de tela. Podemos também pensar no que podemos fazer com esse aparelho, como, por exemplo m udar de canal, ligá-lo ou desligá-lo. Vejamos como escrever isso em Python na listagem 10.1. Listagem 10.1 - Modelagem de urna televisáo » > class Televisáo: O d e f __i n it__(s e lf ): 0 self.ligada=False © s e lf .c a n a l= 2 ©

tv = Televisáo() 0

In tro du jo á Programado com Python

196

>>> tv .lig a d a © False » > tv . canal 2

>>> »> >>> >>>

tv_sala=Televisao() © tv_sala.ligada=True © tv_sala.canal=4 © tv.canal

2

>>> tv_sala.canal 4

Em O; criamos urna nova classe chamada Televisao. Utilizamos a in stru y o class para indicar a declaragáo de urna nova classe e : para iniciar seu bloco. Quando declaramos urna classe, estamos criando um novo tipo de dados. Esse novo tipo define seus próprios métodos e atributos. Lembre-se dos tipos string e list. Esses dois tipos predefinidos do Python sao classes. Quando criamos urna lista ou urna string, estamos instanciando ou criando urna instancia dessas classes, ou seja, um objeto. Quando definimos nossas próprias classes, podemos criar nossos próprios métodos e atributos. Em ©, definimos um método especial chamado _ in it_ . Métodos nada mais sao que funcoes associadas a urna classe. O m étod o _init_será chamado sempre que criarmos objetos da classe Televisao, sendo por isso chamado de construtor (constructor). Um método construtor é chamado sempre que um objeto da classe é instanciado. É o construtor que inicializa nosso novo objeto com seus valores-padráo. O m étodo_init_recebe um parámetro chamado self. Por enquanto, entenda self como o objeto televisao em si, o que ficará mais claro adiante. Em ©, dizemos que self .ligada é um valor de self, ou seja, do objeto televisao. Todo método em Python tem self como primeiro parámetro. Dizemos que self. ligada é um atributo do objeto. Como self representa o objeto em si, escreveremos self. ligada. Sempre que quisermos especificar atributos de objetos, devemos associá-los a self. Caso contrario, se escrevéssemos apenas ligada=False, ligada seria apenas urna variável local do método _ in it_ , e nao um atributo do objeto. Em ©, dizemos que canal também é um valor ou característica de nossa televisáo. Observe também que escrevemos self .canal para criar um atributo, e nao urna simples variável local.

Capítulo 10 ■Classes e objetos

197

Em O criamos um objeto tv utilizando a dasse Televisäo. Dizemos quetv é agora um objeto da dasse Televisio ou que tv é urna instáncia de Televisäo. Quando solicitamos a criaçao de um objeto, o método construtor de sua dasse é cha­ mado, em Python, _ i n i t _ _ , como declaramos em ©. Em © , exibimos o valor do atributo ligada e canal do objeto tv. Já em © criamos outra instáncia da dasse Televisäo chamada tv_sala. Em ©, mudamos o valor de ligada para True e o canal para 4 em ©. Observe que ao imprimimos o canal de cada Televisäo temos valores inde­ pendentes, pois tv e tv_sala sâo dois objetos independentes, podendo cada um ter seus próprios valores, como duas televisöes no m undo real. Quando criamos u m objeto de urna dasse, este tem todos os atributos e métodos que especificamos ao declarar a dasse e que foram inicializados em seu construtor. Essa característica simplifica o desenvolvimento dos programas, pois podemos definir o comportamento de todos os objetos de urna dasse (métodos), pre­ servando os valores individuáis de cada um (atributos). Exercício 10.1 - Adidone os atributos tam anho e marca à dasse Televisäo. Crie dois objetos Televisäo e atribua tam anhos e marcas diferentes. Depois, imprim a o valor desses atributos de forma a confirmar a independéncia dos valores de cada instáncia (objeto). Vejamos agora como associar um comportamento à dasse Televisäo, definindo dois métodos muda_canal_para_cima e muda_canal_para_baixo (listagem 10.2). Listagem 10.2 - Adiçâo de métodos para mudar o canal »> ... ... ... ... ... ... ...

d a s s Televisäo: d e f __i n i t __(s e lf) : s e l f . ligada=False self.canal=2 def muda_canal_para_baixo(self): O s e l f .canal-=l def muda_canal_para_cima(s e lf ) : 0 self.canal+ =l

»> »> >>> >>> 4 >» >» 3

tv = TelevisäoO tv.rauda_canal_para_cima() © tv.muda_canal_para_cima() tv.canal tv.muda_canal_para_baixo() © tv.canal

Introduçâo à Programaçâo corn Python

Em O , definimos o método muda_canal_para_baixo. Observe que nao utilizamos _ antes do nome do método, pois esse nom e nao é um nome especial do Python, mas apenas um nome escolhido por nós. Veja que passamos também um parámetro self, que representa o objeto em si. Observe que escrevemos diretamente self. canal-=l, utilizando o atributo canal da televisáo. Isso é possível porque criamos o atributo canal no construtor(_init_). É usando atributos que podemos armazenar valores entre as chamadas dos métodos. Em 0, fizemos a mesma coisa, mas dessa vez com muda_canal_para_cima. Em ©, chamamos o método. Observe que escrevemos o nome do método após o nome do objeto, separando-os com um ponto, bem como que o método foi chamado da mesma forma que urna fungao, mas que na chamada nao pas­ samos nenhum parámetro. Na realidade, o interpretador Python adiciona o objeto tv á chamada, utiíizando-o como o self do método em 0 . É assim que o interpretador consegue trabalhar com vários objetos de urna mesma classe. Depois, em O , fazemos a chamada do método muda_canal_para_baixo. Veja o valor retornado por tv. canal, antes e depois de chamarmos o método. A grande vantagem de usar dasses e objetos é facilitar a construyo dos progra­ mas. Embora simples, voce pode observar que nao precisamos enviar o canal atual da televisáo ao método muda_canal_para_cima, simplificando a chamada do método. Esse efeito “memoria” facilita a configurado de objetos complexos, pois armazenamos as características importantes em seus atributos, evitando repassar esses valores a cada chamada. N a verdade, esse tipo de construgáo imita o comportamento do objeto no m undo real. Quando mudamos o canal da tv para cima ou para baixo, nao informamos o canal atual para televisáo!

10.2 Passagem de parámetros Um problema com a classe televisáo é que nao controlamos os limites de nossos canais. Na realidade, podemos até obter canais negativos ou números muito grandes, como 35790. Vamos modificar o construtor de forma a receber o canal m ínimo e máximo suportado por tv (listagem 103). Execute o programa da listagem 103 e verifique se as m o d ificares deram resultado. Observe que m udamos o comportamento da classe Televisáo sem m udar quase nada no programa que a utiliza. Isso porque isolamos os detalhes

Capítulo 10 ■Classes e objetos

199

do funcionamento da classe do resto do programa. Esse efeito é chamado de encapsulamento. Dizemos que urna classe deve encapsular ou ocultar detalhes de seu funcionamento o máximo possível. No caso dos métodos para m udar o canal, incluimos a verificagáo sem alterar o resto do programa. Simplesmente solicitamos que o método realize seu trabalho, sem se preocupar com os de­ talhes internos de como ele realizará esta operagao. Listagem 10.3 - V erificado da faixa de canais de tv cla ss Televisao: d e f __i n i t __(s e lf, min, max): s e lf.lig a d a = False self.c an a l = 2 self.cm in = min self.cmax = max def muda_canal_para_baixo(self): i f ( s e l f .canal-l>= self. cmin): self.c an a l-= l def muda_canal_para_cima(self): i f ( s e l f . canal+l > > tv=Televisao(2,10) > > > tv.muda_canal_para_baixo() > > > tv.canal 10

> > > tv.muda_canal_para_ciina() > > > tv.canal 2

200

In tro d u jo á Programado com Python

Ao trabalharmos com classes e objetos, assim como fizemos ao estudar fungoes, precisamos representar em Python urna abstragáo do problema. Quando realizamos urna a b s tr a jo reduzimos os detalhes do problema ao necessário para solucioná-lo. Estamos construindo um modelo, ou seja, modelando nossas classes e objetos. Antes de continuarmos, vocé deve entender que o modelo pode variar de urna pessoa para outra, como todas as partes do programa. Um dos detalhes mais di ficéis é decidir o quanto representar e onde limitar os modelos. No exemplo da Televisáo nao escrevemos nada sobre a tomada da TY se esta tem controle remoto, em que parte da casa está localizada ou mesmo se tem controle de volume. Como regra simples, modele apenas as in fo rm a le s que vocé precisa, adicio­ nando detalhes á m edida que necessário. Com o tempo, a experiencia ensinará quando parar de detalhar seu modelo, como tam bém apontará erros comuns. Tudo que aprendemos com funches é também válido para métodos. A principal diferenga é que um método é associado a urna classe e atua sobre um objeto. O prim eiro parámetro do método é chamado self e representa a instáncia so­ bre a qual o método atuará. E por meio de self que teremos acesso aos outros métodos de urna classe, preservando todos os atributos de nossos objetos. Vocé riáo precisa passar o objeto como prim eiro parámetro ao invocar (chamar) um método: o interpretador Python faz isso automáticamente para vocé. Entretan­ to, nao esqueja de declarar self como o primeiro parámetro de seus métodos. Exercído 10.4 - Utilizando o que aprendemos com fungóes, m odifique o construtor d a classe Televisáo de forma que min e max sejam parám etros opcionais, onde min vale 2 e max vale 14, caso outro valor nao seja passado. Exerdcio 10.5 - Utilizando a classe Televisáo m odificada no exercício anterior, crie duas instancias (objetos), especificando o valor de min e max p o r nome.

10.3 0 exemplo de um banco Vejamos o exemplo de classes, mas dessa vez vamos modelar contas cor rentes de um banco. Imagine o banco Tatú, moderno e eficiente, mas precisando de um novo programa para controlar o saldo de seus correntistas. Cada conta corrente pode ter u m o u mais clientes como titular. O banco controla apenas o nome e telefone de cada cliente. A conta corrente apresenta um saldo e urna lista de o p e ra re s de saques e depósitos. Q uando o cliente faz um saque, diminuire­ mos o saldo da conta corrente. Q uando ele fizer uní depósito, aumentaremos

Capítulo 10 ■Classes e objetos

201

o saldo. Por enquanto, o banco Tatú nao oferece contas especiáis, ou seja, o cliente nao pode sacar mais dinheiro que seu saldo permite. Vamos resolver esse problema por partes. A dasse cliente é simples, tendo apenas dois atributos: nome e telefone. Digite o programa da listagem 10.4 e salve-o em um arquivo chamado cliente.py. Listagem 10.4 - Classe Clientes class Cliente: d e f __i n i t __( s e lf, nome, telefone): self.nome = nome se lf.te le fo n e = telefone

Abra o arquivo cliente.py no IDLE e execute-o (Run - F5). No interpretador, experimente criar um objeto da classe Cliente. joao=Cliente(“Joao da Silva", "777-1234") maria=Cliente("Maria S ilva", "555-4321") joao.nome joao.telefone maria.nome m aria.telefone

Como nos outros programas Python, podemos executar um definigao de classe dentro de um arquivo .py e utilizar o interpretador para experimentar nossas classes e objetos. Essa oper agao é muito importante para testarmos as classes, modificar alguns valores e repetir o teste. Como o programa do Banco Tatú vai ficar maior que os programas que já trabalhamos até aqui, vamos gravar cada classe em um arquivo .py separado. Em Python essa organizagáo nao é obrigatória, pois a linguagem permite que tenhamos todos as nossas classes em um só arquivo, se assim quisermos. Vamos agora criar o arquivo teste.py, que vai simplesmente im portar cliente.py e criar dois objetos. Listagem 10.5 - Programa teste.py que importa a classe Cliente from clie n te import Cliente joao=Cliente("3oao da Silva", "777-1234") maria=Cliente("Maria da Silva", "555-4321")

Observe que com poucas linhas de código conseguimos reutilizar a dasse Cliente. Isso é possível porque cliente.py e teste.py estáo no mesmo diretório.

In tro du jo á Programado com Python

202

Essa separagao perm ite que passemos a experimentar as novas classes no interpretador, armazenando o im port e a criagáo dos objetos em um arquivo á parte. Assim poderemos definir nossas classes separadamente dos experi­ mentos ou testes. Para resolver o problema do Banco Tatú, precisamos de outra classe, Conta, para representar urna conta do banco com seus clientes e seu saldo. Vejamos ;o programa d a listagem 10.6. A classe Conta é definida recebendo clientes, número e saldo em seu construtor (_in it_), onde em clientes esperamos urna lista de objetos da classe Cliente, núm ero é urna string com o número da conta e saldo é um parámetro opcional, tendo zero (0) como padráo. A listagem também apresenta os métodos resumo, saque e depósito. O método resumo exibe n a tela o número da conta corrente e seu saldo, saque permite retirar dinheiro da conta corrente, verificando se essa oper agao é possível (self.saldo>=valor). depósito simplesmente adiciona o valor solicitado ao saldo da conta corrente. Listagem 1 0 .6 - Classe Conta class Conta: d e f __i n i t __(s e lf , c lie n te s, numero, saldo = 0): s e lf.s a ld o = saldo s e lf.c lie n te s = clien te s self.num ero = numero def resumo(self): print("CC Número: %s Saldo: %10.2f" % (self.numero, s e lf.s a ld o )) def saque(self, valor): i f se lf.s a ld o >= valor: s e lf.s a ld o -=valor def d ep o sito (self, valor): s e lf.s a ld o += valor

Altere o program a teste.py de forma a im portar a classe Conta. Crie urna conta corrente para os clientes Joáo e Maria. Faga alguns testes no interpretador: conta. resumoQ conta. saque(1000) conta. resumoQ conta.saque(50) conta.resumo() cont a . depós i t o( 200 ) conta.resumo()

Capítulo 10 ■Classes e objetos

203

Embora nossa conta corrente comece a funcionar, aínda nao temos a lista de operagóes de cada elemento. Essa lista é, na realidade, um extrato dé conta. Vamos alterar a classe Conta de forma a adicionar um atributo que é a lista de operagoes realizadas (listagem 10.7). Considere o saldo inicial como um depósito. Vamos adicionar tam bém um método extrato para imprim ir todas as operagoes realizadas. Listagem 10.7 - Conta com registro de o p e ra re s e extrato class Conta: def __i n i t __(s e lf, c lie n te s, número, saldo = 0 ): se lf.s a ld o = 0 s e lf.c lie n te s = clientes self.número = número self.operacoes = [] s e l f .deposito(saldo) def resumo(self): print("CC №%s Saldo: %10.2f" % (self.número, s e lf.s a ld o )) def saque(self, valor): i f se lf.s a ld o >= valor: se lf.s a ld o -=valor s e l f .operacoes.append( [ "SAQUE", valo r]) def deposito(self, valor): self.sa ld o += valor s e l f .operacoes.append( [ "DEPÓSITO", v alo r]) def e x tra to (s e lf): print("E xtrato CC № %s\n" % self.numero) fo r o in self.operacoes: print("%10s %10.2 f" % (o[ 0 ] ,o [ l] ) ) p rin t(" \n Saldo: %10.2f\n" % self.sa ld o )

Modifique também o programa de testes para imprim ir o extrato de cada conta (listagem 10.8). Listagem 10.8 - Testando Cliente e Contas from clie n te import C liente from contas import Conta joao=Cliente(”3oao da S ilva", "777-1234”) maria=Cliente("Maria da S ilva", "555-4321“) contal=Conta([joáo], 1, 1000) conta2=Conta([maria, joao], 2, 500) contal.saque(50)

In trodujo á Programado com Python

204

conta2.deposito(300) contal.saque(190) conta2.deposito(95.15) conta2.saque(250) co n ta l.e x trato () conta2.extrato()

Exercício 10.6 - Altere o programa de forma que a mensagem saldo insuficiente seja exibida caso haja tentativa de sacar mais dinheiro que o saldo disponível. Exercício 10.7 - Modifique o método resumo da classe Conta para exibir o nome e o telefone de cada cliente. Exercício 10.8 - Crie urna nova conta, agora tendo Joáo e José como clientes e saldo igual a 500. Para resolver o problema do Banco Tatú precisamos de urna classe para armazenar todas as nossas contas. Como atributos do banco teríamos seu nome e a lista de contas. Como o p e ra re s, considere a abertura de urna conta corrente e a listagem de todas as contas do banco. Classe Banco (listagem 10.9). Listagem 10.9 - Classe Banco cla ss Banco: d e f __i n i t __(s e lf , nome): self.nome=nome self.c lie n tes= [] self.contas=[] def abre_conta(self, conta): s e l f . contas. append(conta) def lista _ c o n ta s (s e lf): fo r c in self.contas: c.resumo()

Agora, vamos criar os objetos (listagem 10.10). Listagem 10.10 - Criando os objetos from clien te s import Cliente from banco import Banco from contas import Conta joáo = Cliente("3oao da S ilva", "3241-5599") maria = Cliente("M aria Silva", “7231-9955") josé = Cliente("3osé Vargas","9721-3040")

Capítulo 10 ■Classes e objetos

205

contalM = Conta( [joâo, maria] , 100) contal = Conta( [jo sé], 10) ta tú = Banco(“Tatú") ta t ú .abre_conta(contaJM) ta t ú .abre_conta(contal) ta t ú . lista_contas()

Exercício10.9 - Crie classes para representar estados e cidades. Cada estado tem um nome, sigla e cidades. Cada cidade tem nome e populaçâo. Escreva um programa de testes que crie très estados com algumas cidades em cada um. Exiba a populaçâo de cada estado como a soma da populaçâo de suas cidades.

10.4 Herança A orientaçâo a objetos permite modificar nossas classes, adicionando ou modificando atributos e métodos, tendo como base outra classe. Vejamos o exemplo do Banco Tatú, em que o novo sistema foi um sucesso. Para atrair novos clientes, o Banco Tatú começou a oferecer contas especiáis aos clientes. Urna conta especial permite que possamos sacar mais dinheiro que atualmente disponível no saldo da conta, até um determinado limite. As operaçôes de depósito, extrato e resumo sáo as mesmas de urna conta normal. Vamos criar a classe ContaEspecial herdando o comportamento da classe Conta. Listagem 10.11 - Uso de herança para definir ContaEspecial c la s s ContaEspecial(Conta) :© d e f __i n i t __( s e lf, clien te s, número, saldo = 0, lim ite= 0):

Conta.__i n i t __(s e lf, c lie n te s, número, saldo) © s e l f . lim ite = lim ite © def saque(self, valor): i f s e l f . saldo + s e l f . lim ite >=valor: s e l f . saldo -= valor s e l f .operacoes.append(["SAQUE", valor])

Em O definimos a classe ContaEspecial, mas observe que escrevemos Conta entre parênteses. Este é o formato de declaraçâo de classe usando herança, ou seja, é assim que declaramos a herança de uma classe em Python. Essa linha diz: crie uma nova classe chamada ContaEspecial herdando todos os métodos e atributos da classe Conta. A partir daqui, ContaEspecial é um a subclasse de Conta. Também dizemos que Conta é a superclasse de ContaEspecial.

206

In tro d u jo á Programado com Python

Em © , chamamos o método _ i n i t _ de conta, escrevendo Conta. _ _ in it_ segui­ do dos parámetros que normalmente passaríamos. Toda vez que vocé utilizar heranga, o método construtor da superclasse, no caso Conta, deve ser chamado. Observe que, nesse caso, passamos self para Conta._in it _. É assim que reutili­ zamos as definigoes já realizadas na superclasse, evitando ter que reescrever as atribuigoes de clientes, núm ero e saldo. Cham ar a inicializagáo da superclasse tam bém tem outras vantagens, como garantir que modificagoes no construtor da superclasse nao tenham que ser duplicadas em todas as subclasses. Em 0 criamos o atributo self.lim ite. Esse atributo será criado apenas para classes do tipo ContaEspecial. Observe que criamos o novo atributo depois de chamarmos Conta.__in it_. Observe também que nao chamamos Conta.saque no método saque de ContaEspecial. Quando isso ocorre, estamos substituindo completamente a implementagáo do método por urna nova. Urna das grandes vantagens de utilizar heranga de classes é justam ente poder substituir ou complementar métodos já definidos. Para testar essa modificagáo, escreva o trecho de program a d a listagem 10.11 no mesmo arquivo em que vocé definiu a classe Conta. M odifique seu programa de teste para que se parega com o programa da listagem 10.12. Listagem 10.12 - C riad o e uso de urna ContaEspecial from c lie n te import C liente from contas import Conta, ContaEspecial O joao=Cliente("Doao da S ilva", "777-1234") maria=Cliente("Maria da S ilva", "555-4321") contal=Conta([joao], 1, 1000) conta2=ContaEspecial([maria, joao], 2, 500, 1000) © contal.saque(50) conta2.deposito(300) contal.saque(190) conta2.deposito(95.15) conta2.saque(1500) co n ta l.e x trato () conta2.extrato()

Vejamos o que m udou no program a de testes. Em O adicionamos o nom e da classe ContaEspecial ao import. Dessa forma poderemos utilizar a nova classe em nossos testes. Já em 0 criamos um objeto ContaEspecial. Veja que praticamente

Capítulo 10 ■Classes e objetos

207

nao mudamos nada, exceto o nome da classe, que agora é ContaEspecial, e nao Corita. Um detalhe im portante para o teste é que adicionamos um parámetro ao construtor, no caso 1000, como o valor de limite. Execute este programa de teste e observe que, para a conta2 , obtivemos um saldo negativo. Utilizando heranga modificamos muito pouco nosso programa, mantendo a funcionalidade anterior e adicionando novos recursos. O interessante de tudo isso é que foi possível reutilizar os métodos que já havíamos definido na classe Conta. Isso permitiu que a definigáo da classe ContaEspecial fosse bem menor, pois lá especificamos apenas o comportamento que é diferente. Quando vocé utilizar heranga, tente criar classes ñas quais o comportamento e características comuns fiquem na superclasse. Dessa forma vocé poderá definir subclasses enxutas. O utra vantagem de utilizar heranga é que, se mudarmos algo na superclasse, essas mudanzas seráo também usadas pelas subclasses. Um exemplo seria m odificam os o método de extrato. Como em ContaEspecial nao especificamos um novo método de extrato, ao m odificam os o método Conta.extrato estaremos tam bém modificando o extrato de ContaEspecial, pois as duas classes compartilham o mesmo método. E importante notar que, ao utilizarmos heranga, as subclasses devem poder substituir suas superclasses, sem perda de funcionalidade e sem gerar erros nos programas. O im portante é que vocé conhega esse novo recurso e come­ ce a utilizá-lo em seus programas. Lembre-se de que vocé nao é obrigado a definir urna hierarquia de classes em todos os seus programas. Com o tempo, necessidade de utilizar heranga ficará mais clara. Exercício 1 0 .1 0 - M odifique as classes Conta e ContaEspecial para que a operagao de saque retorne verdadeiro se o saque foi efetuado e falso em caso contrário. Exercício 10.11 - Altere a classe ContaEspecial de forma que seu extrato exiba o limite e o total disponível para saque. Exercício 10.12 - Observe o m étodo saque das classes Conta e ContaEspecial. M odifique o método saque da classe Conta de forma que a verificagao da possibilidade de saque seja feita por um novo método, substituindo a condigao atual. Esse novo método retornará verdadeiro se o saque puder ser efetuado e falso em caso contrário. M odifique a classe ContaEspecial de forma a trabalhar com esse novo método. Verifique se vocé aínda precisa trocar o método saque de ContaEspecial ou apenas o novo m étodo criado para verificar a possibilidade de saque.

CAPITULO 1 1

Próximos passos

A p rogram ado é um longo caminho que vocé comegou a percorrer. Neste livro mostramos as técnicas básicas para que vocé continué seus estudos. A program ado de computadores é urna área de conhecimento muito grande e rica. Este livro apresentou urna introdugäo ä program ado utilizando a linguagem Python. Os próximos passos dependem de sua área de interesse. Vocé nao precisa estudar todos os tópicos ou mesmo seguir a ordern em que sao apresentados neste capítulo. Vamos listar alguns tópicos.

11.1 Programado funcional A programagao funcional é um paradigma de programagao diferente do que aprendemos aqui com Python. Embora Python tenha recursos de urna linguagem funcional, perm itindo m isturar os dois paradigmas em um só programa. Para enriquecer sua experiéncia em program ado, estudar urna linguagem puramente funcional como LISP, Scheme ou F # é realmente interessante, sen­ do urna área que deve se popularizar cada vez mais. Estudar urna nova forma de organizar seus programas ajudará a entender melhor vários conceitos que vocé já aprendeu e modificar a forma que vocé encara a programagao. Atualmente, diversas linguagens sao chamadas de híbridas ou multiparadigmas, pois m isturam ou possibilitam a utilizagäo de recursos de programagao fun­ cional e imperativa. Python é urna délas. Além disso, algumas propriedades da programagao funcional sao excelentes para resolver ou abordar problemas de concorréncia, cada vez mais comuns hoje em dia. O livro SICP—Structure and Interpretation of Computer Programs, de Harold Abelson e Gerald Jay Sussman, pode ser lido on-line no site http://mitpress.mit. edu/sicp/full-text/book/book.html. O livro é usado em diversos cursos de computagäo e é considerado um dos melhores disponíveis.

Capítulo 11 ■Próximos passos

209

11.2 Algoritmos Até agora utilizamos o básico da programagao para resolver nossos problemas. A medida que vocé for ganhando experiencia, terá que estudar novos algorit­ mos e entender algoritmos que já utiliza hoje sem perceber. Um exemplo é a compreensáo de técnicas de espalhamento (hashes), que utilizamos em Python com dicionários, ou como as listas funcionam internamente. Quanto maior seus programas, mais importante entender como cada algoritmo funciona, conhecer suas aplicagoes e limitagoes. Alinguagem C também é recomendada para o estudo de algoritmos e estruturas de dados. Ao contrário de Python, em C vocé está sozinho e ela vem quase sem baterías. A vantagem de estudar e aprender a programar em C é conhecer os detalhes de cada implementagáo e controlar cada passo de seus programas. Um livro recomendado para estudos aprofundados é Algoritmos: teoria e prática, deThom as H. Cormen. Embora a leitura nao seja das mais fáceis,seu conteúdo é esclarecedor. Nao leia esse livro antes de programar em pelo menos duas linguagens de programagao. Sua leitura é recomendada para pessoas que desejem realmente se aprofundar no assunto, normalmente cursando ciencia da computagao.

11.3 Jogos A programagao de jogos é urna das mais áreas mais recompensadoras e inspira­ doras. Além disso, o que vocé aprende programando jogos serve para solucionar diversos outros problemas do dia-a-dia. Python apresenta diversas bibliotecas externas prontas para a criagao de jogos em 2D ou 3D. Essas bibliotecas incluem a manipulagao de imagens, sons, controle do tempo e mesmo de arquivos. Pygame (http://www.pygame.org): biblioteca multimídia fácil de aprender. Per­ mite a manipulagao de superficies de desenlio e a criagao de jogos com gráficos em 2D e som. Se vocé tiver curiosidade de saber como criar jogos simples, visite o projeto Invasores (http:l/www.sourceforge.net/projects/invasores). O projeto foi inteiramente desenvolvido em Python e é open source. Vocé pode baixar e estudar o código-fonte, fazer modificagoes e testar. Tudo escrito em Python. Panda 3D (http://www.panda3d.org/): biblioteca gráfica, desenvolvida pelos estudios Disney, open source e supercompleta. Com Panda 3D vocé pode criar jogos profissionais, e o melhor de laido: usando Python. A biblioteca é

210

In tro d u jo á Programado com Python

poderosa e complexa, tendo sido utilizada em jogos comerciáis. Nao esqueja de revisar álgebra linear e estudar gráficos tridimensionais antes de se aventurar na documentadlo (em inglés). PyOgre (http://www.ogre3d.org/tikiwiki/PyOgre): outra biblioteca ou k it de desenvolvimento de jogos 3D. A PyOgre é tam bém poderosa e complexa. Se vocé comegar a estudar essas bibliotecas, encare essa tarefa como u m projetb de peló menos um ano. Essas bibliotecas sao grandes e permitem a cria print(mensalidades["seguro"]) Traceback (most recent c a li la s t): File "", lin e 1 , in p rin t(mensalidades["seguro"]) KeyError: 'seguro'

Aexcegao KeyError ocorre quando acessamos ou tentamos acessar um dicionário usando urna chave que nao existe. No exemplo anterior, o dicionário mensalidades contém as chaves carro e casa. Na linha da fungáo print, tentamos acessar mensalidades["seguro"]. Nesse caso, "seguro" é a chave que causa a mensagem de erro, urna vez que ela nao pertence ao dicionário. Atengáo ao trabalhar com chaves string, pois Python diferencia letras minúsculas de maiúsculas.

A.4 NameError while x » float("maria") Traceback (most recent c a ll l a s t ) : F ile "", lin e 1, in float ("maria”) ValueError: could not convert s trin g to float: maria

Ela pode ocorrer se, por exemplo, o valor retomado pela fungáo input for inválido. Essa excegáo também ocorre quando procuramos urna string que nao existe, como m ostrado abaixo. » > s="Alo mundo" » > s.index("rei") Traceback (most recent c a ll l a s t ) : F ile "", lin e 1 , in s.index("rei") ValueError: substring not found

A.6 TypeError Essa excegáo acontece se tentamos chamar urna fungáo usando mais parámetros do que ela recebe. No exemplo abaixo, a fungáo float foi chamada com dois parámetros: 35 e 4. Lembre-se de que números em Python devem ser escritos no formato americano, separando a parte inteira da parte decimal de um número

Apéndice A ■ Mensagens de erro

217

com ponto e nao com vírgula. Esse também é um exemplo de que um erro pode ser apresentado como outro erro, exigindo que vocé sempre interprete a mensagem de forma a saber o que realmente aconteceu. > » float(35,4) Traceback (most recent c a li la s t) : F ile "", lin e 1, in float(35,4) TypeError: float() takes a t most 1 argument (2 given)

TypeError também ocorre quando trocamos o tipo de um índice. No exemplo abaixo, tentamos utilizar a string “marrom” como índice de urna lista. Lembrese de que listas só podem ser indexadas por números inteiros. Dicionários, por sua vez, permitem índices do tipo string. » > sf'am arelo", "vermelho", "verde"] » > s["marrom"] Traceback (most recent c a li la s t): F ile "", lin e 1, in s["marrom"] TypeError: strin g indices must be integers

A.7 IndexError IndexError indica que urna valor inválido de índice foi utilizado. No exemplo a seguir, a string s contém apenas cinco elementos, podendo ter índices de 0 a 4. » > S="ABCDE" » > S [1 0 ]

Traceback (most recent c a ll la s t): F ile "", lin e 1, in S[10] IndexError: strin g index out of range

Referencias

Python Foundation. Python 3.1.2 Tutorial. 2010 Disponivel em http:l/docs. python. org/py3k/tutorial. Summerfield, M. Programming in Python 3 - A Complete Introduction to the Python Language. 2 ed. Addison-Wesley, 2010. Pilgrim, M. Dive into Python 3.2 ed. Apress, 2009. Cormen, Thomas H; Leiserson, Charles E; Rivest, Ronald L; Stein, Clifford. Algoritmos: teoria e pratica. Rio de Janeiro: Elsevier, 2002

índice remissivo

A abs, 156 abspatli, 193 acumuladores, 83,85 adigáo, 38 alinhando. Consulte string, Ijust, center, rjust and, 50,51 apagando elementos. Consulte listas, del; Con­ sulte dicionários, del append. Consulte listas, append argv. Consulte sys, argv arquivos, 170 abrindo, 170 abrindo utf-8,182 apagando. Consulte remove escrevendo, 170 fechando, 172 gravando, 170 isfile, 188 lendo linhas, 172 listando. Consulte listdir modos de abertura, 170 renomeando. Consulte rename tamanho. Consulte getsize tempo de criacao. Consulte getctime tempo de modificagao. Consulte getmtime tempo do último acesso Consulte getatime verificando se existe. Consulte exists verificando se um caminho é. Consulte isdir; Consulte isfile atribuigáo, 40 B basename, 193 bloco, 70,71,79 booleano, 48 break, 85,105,147 Bubblc Sort. Consulte listas, ordenagáo

c caminho. Consulte path

219

contadores, 80 continue, 143 count. Consulte string, count crime. Consulte time, crime D datas. Consulte tempo Consulte time def, 145 del. Consulte listas, del; Consulte dicionários, del dias. Consulte tempo Consulte time dicionários, 117 com listas, 120 del, 120 keys, 119 values, 119 diretório corrente. Consulte getcwd diretórios apagando. Consulte rmdir atuaL Consulte getcwd corrente. Consulte getcwd criando. Consulte mkdir listando o conteúdo. Consulte listdir trocando. Consulte chdir verificando se um caminho é, 188 dirname, 193 disjungao. Consulte or divisáo, 38

E elevar um número. Consulte exponenciagáo elif, 76 else, 73,74,75,105,142 endswith. Consulte string, endswíth entrada de dados. Consulte input enumerate, 107,108,121 e, operador. Consulte and estruturas de repetigao. Consulte repetigócs exists, 188 exponenciagáo, 38 expressoes lógicas, 53 extend. Consulte listas, extend

caracteres. Consulte string

F

center. Consulte string, center centralizando Consulte string, center chdir, 185,186 class, 196 classes, 195,196 atributos, 197 construtor, 196,198 encapsulamento, 199 heránga, 205,207 métodos, 197 superclasse, 205,207 cióse, 170 condigoes, 69 conjungño. Consulte and

False. Consulte falso falso, 48 fatorial, 150,154 Fibonacci, 155 FIFO, 100 filas. Consulte listas, fila find. Consulte string, find float, 64,67 for, 104,105,143 forca, 141 from, 165 fungóes como parámetro, 160 criando. Consulte def

Introduçâo à Programado corn Python

220 desempacotamento de parametros, 162 lambda, 163 nomeando parSmetros, 159 parametros opcionais, 157,162 recursivas, 154 retornado valores. Consulte return

G getanme, 189 getctime, 189 getcwd, 185 getmtime, 189 getsize, 189 global, 153 gmdme, 190

H horas. ¡Consulte tempo Consulte time html body, 182 hi, 184 h2,184 h3,184 h4,184 h5,184 h6,184 head, 181 html, 181 li, 184 meta, 181 p, 183 title, 181 ul, 184 HTML, 180

I

IdentationError, 214 if, 69,74 import, 164,165 impriminda Consulte print in, 118,124,125 index. Consulte string, index IndexError, 217 init, 196 input, 64,66 instancia, 195 int,64 isabum. Consulte string, isalnum isalpha. Consulte string, isalpha isdigit. Consulte string, isdigit isdir, 188 isfile, 188 ¡slower. Consulte string, ¡slower isnumeric Consulte string, isnumeric isprintablc. Consulte string, isprintable isspace. Consulte string, isspaec ¡supper. Consulte string, isupper

J jogo da força, 141 join. Consulte os.path, join Consulte string, join juntando caminhos. Consulte os.path, join juntando strings. Consulte string, jo b

K KcyError, 118,215

L len, 55,95,96 lendo de arquivos. Consulte read Consulte readlines do tedado. Consulte input L1FQ101 list, 119,123 listas, 90 alterando, 91 append, 96,98 com strings, 110 copia, 94 dentro de listas, 110 desempacotamento, 162 elementos, 90 empacotamento, 162 extend, 97,98 fana, 94 fila, 100 índices, 90,92 índices negatívos, 95 ordenaçâo, 112,113 pesquisa, 103 pilha, 101 pop, 100,101 refcrênrias, 94 tamanho, 96 vazia, 90 listdir, 188 ljust. Consulte string, ljust localtíme. Consulte tíme, localtíme lower, 125 lstrip. Consulte string, lstrip

M maior divisor comum, 155 makcdirs, 187 média, 84 média aritmética, 84 menor múltiplo comum, 156 meses. Consulte tempo Consulte time mkdir, 186 módulos, 164 mostrando na tela. Consulte print multiplicadlo, 38

índice remissivo

N NameError, 215 nao, operador. Consulte not negagao. Consulte not not, 50,51 not in, 125 aleatórios, 165 faixas. Consulte range inteiros, 47 ponto flutuante, 47 sem sinal. Consulte abs

0 objetos, 195 open, 170 operagóes matemáticas adigao, 38 divisáo, 38 exponénciagáo, 38 multiplicagáo, 38 parenteses, 39 prioridade, 39 resto da divisáo, 38 subtragáo, 37 operadores lógicos, 53 operadores relacionáis, 48 or, 50,51,52 ordenando. Consulte listas, ordenagáo elidir, 185 getcwd, 185 listdir, 188 makedirs, 187 mkdir, 186 rename, 187 rmdir, 187 walk, 194 os.path, 188 abspath, 193 basename, 193 dirname, 193 exists, 188 getatime, 189 getetime, 189 getmtime, 189 getsize, 189 isdir, 188 isfile,188 join, 193 splitdrive, 193 ou, operador. Consulte or

P parámetro, 37 pach, 186 pillias. Consulte listas, plllui

221

pop. Consulte listas, pop print, 22,37,40,41 printend, 107 procurando. Consulte string, count, find, index, rindex, rfind; Consulte listas, pesquisa Python editando arquivos, 32 executando, 34,35 instalagao, 24 instalagao Linux, 30 instalagao Mac OS X, 30 instalagao Windows, 24 interpretador, 30 salvando arquivos, 33

R randint, 165,166 random, 166 range, 106,107 rastreamenco, 62 read, 170 readlines, 172 rename, 187 repetigoes, 78 for. Consulte for interrompendo. Consulte break while. Consulte while replace. Consulte string, replace resto da divisáo, 38 return, 146,147,148 rfind. Consulte string, rfind rindex. Consulte string, rindex rjust. Consulte suing, rjust rmdir, 187 rstrip. Consulte string, rstrip

s sample, 167 se. Consulte if segundos. ¡Consulte tempo Consulte time self, 196,200,206 senáo. Consulte else Consulte elif sequencia de caracteres. Consulte string shuffle, 167 SintaxError, 213 sistema binario, 46 split. Consulte scring, split splitdrive, 193 splitlines. Consulte string, splitlines startswith. Consulte string, starstwith strftime. Consulte dme, strfdme string, 54 alinhanda Consulte string, ljust, center, rjust center, 129 comcgando em. Consulte string, startswith

S n cSgS?

Intro dujo à Programaçâo com Python

222

convertendo em maiúsculas. Consulte string, convertendo em minúsculas. Consulte string, count, 126 endswith, 124 fatiamento, 59 find, 126,127 formatafáo, 134 índex, 127 isalnum, 132 isalpha, 132 isdigit, 132 islower, 133 isnumeric, 133 ispríntable, 134 isspace, 134 isupper, 133 justificando. Consulte string, ljust, center, rjust ljust, 129 lower, 124,142 lstrip, 131 quebrando. Consulte string, split, splitlines replace, B1 retirando espatos. Consulte string, strip, lstrip, rfind,126,127 rindex, 127 ljust, 129 rstrip, 131 se é alfanumérica. Consulte string, isalnum se é minúscula. Consulte string, islower se é numérica. Consulte string, isnumeric separando. Consulte string, split, splitlines se pode ser impressa. Consulte string, ¡sprint se tem apenas dígitos. Consulte string, isdigit se tem apenas espatos. Consulte string, isspace split, 130 splitlines, 130 startswith, 124 strip, 131,142 subsdtuíndo. Consulte string, replace trocando. Consulte string, replace upper, 124 strip. Consulte string, strip subtragáo, 37 sys, 173 argy 173

T tags, 180 tags html. Consulte html tempo formatando como string. Consulte rime, strfcimc liera local. Consulte tinte, localtime

time, 190 cdme, 190 gmtime, 190 localtime, 190 strftíme, 191 tipo lógico. Consulte variáveis, tipo lógico numérico. Consulte variáveis, numéricas string. Consulte string verificando. Consulte type trocando de diretório. Consulte chdir True. Consulte verdadeiro type, 167,169 TypeError, 216

u uniform, 166 upper, 125

V validado, 156 valor absoluto. Consulte abs ValueError, 67, 127,216 variáveis, 40,61 arquivos. Consulte arquivos dicionários. Consulte dicionários escopo, 151 globais, 151,152 locáis, 151 numéricas, 45 regras de nomenclatura, 44 tipo file, 170 tipo lista. Consulte Listas tipo lógico, 48 tipo string, 54 troca de valores, 114 verdadeiro, 48

w walk, 194 while, 79,80,85,87,105,143 write, 170

CONHECATAMBEM

PYTHON e DJANGO Autores: Osvaldo Santana Thiago Galesi ISBN: 978-85-7522-247-8 Páginas: 280 Ano: 2010

Conlleva o Site da

Acesse conteúdos adicionáis exclusivos C om pre livros diretam ente conósco D ow nloads de eBooks gratuitos C onfira os nossos langam entos Sugira novos títulos C atálogo on-line

www.novatec.com.br Cadastre seu e-mail e receba mais informagoes sobre os nossos langamentos e promogoes

INTRODUQÁO A PROGRAMAGÁO COM

PYTHON Este livro é orientado ao iniciante em programagáo. Os conceitos básicos de programagáo, como expressoes, variáveis, repetigoes, decisóes, listas, fungoes e arquivos, sao apresentados um a um com exemplos e exercícios. A obra visa explorar a programagao de computadores como ferramenta do dia a dia. Ela pode ser lida durante um curso de ¡ntrodugao á programagáo de computadores e usada como guia de estudo para autodidatas. Para aproveitamento pleno do conteúdo, conhecimentos básicos de informática, como digitar textos, abrir e salvar arquivos, sao suficientes. Todo software utilizado no livro pode ser baixado gratuitamente, sendo executado em Windows, Linux e Mac OS X. Embora a linguagem Python (versáo 3.x) seja muito poderosa e repleta de recursos modernos de programagáo, este livro náo pretende ensinar a linguagem em si, mas ensinar a programar. Alguns recursos da linguagem náo foram utilizados para privilegiar os exercícios de lógica de programagáo e oferecer urna preparagáo mais ampia ao leitor para outras linguagens. Essa escolha náo impediu a apresentagáo de recursos poderosos da linguagem, embora o livro náo seja fundamentalmente urna obra de referencia.

novatec editora

sobre o autor Nilo Ney Coutinho Menezes é p esq u isa d or n a á rea d e re d e s e sistem a s distribuidos. Coordenou equ ip es d e desenvolvim ento d e so ftw are p ara indústrias em Manaus. Trabalha h o je co m o pesqu isa d or na á rea d e sim ulagao distribuida d e sistem a s ferroviarios, na qu al iniciou s e u doutorado. É m estre em in form ática e b a ch a rel em p ro cessam en to d e d a d os pela Universidade Federal d o Amazonas. O livro foi ela borad o com b a s e em su a experiencia c om o p r o fe s s o r d e lógica d e program agáo d e s d e 1994.