Programação em Python: Fundamentos e Resolução de Problemas by Grupo Lidel

9cm x 24cm

16,7cm x 24cm

33,5mm

16,7cm x 24cm

9cm x 24cm

Ernesto Costa

Apresenta os processos de desenvolvimento, a gestão, os requisitos, a análise, o desenho, os testes e a manutenção do produto de software. Para alunos do Ensino Superior e técnicos. Com casos práticos.

CMY

Conheça a organização e os mecanismos mais sofisticados de um sistema operativo e perceba como este gere e coordena o seu computador. Com exemplos em Unix (e variantes, Linux e Mac OS) e Windows.

Uma obra que ajuda estudantes e profissionais a compreenderem os sistemas de gestão de bases de dados relacionais. Com apresentação dos conceitos fundamentais, inclui variados exemplos e exercícios. Aprenda as regras e boas práticas na análise, conceção e desenvolvimento de aplicações orientadas pelos objetos, através de vários projetos de software e exercícios analisados e implementados em Java.

Este é um livro que apresenta os fundamentos da programação em Python, linguagem de programação de alto nível, estruturado em duas partes. Numa primeira parte, aprofunda-se a programação procedimental, fazendo-se, numa segunda parte, uma breve introdução à programação orientada aos objetos (POO).

O livro inclui vários exemplos já resolvidos, sumários da matéria abordada e exercícios teóricos e práticos.

Assim, o livro apresenta não só uma panorâmica do essencial da programação, como também aprofunda os conceitos básicos da programação e os aspetos complementares, mais avançados, da linguagem Python, discutindo-se vários aspetos do desenvolvimento de programas.

Principais temas abordados no livro:

O leitor pode encontrar, ainda, outros temas, como as estruturas de dados e tipos de dados abstratos, os conceitos essenciais da POO, as noções básicas de desenho de soluções e de diagramas de classes, e a programação guiada por eventos. A abordagem adotada permite que se possam começar a escrever os primeiros programas após o primeiro capítulo, e a organização e conteúdo do texto possibilitam que este seja usado por vários tipos de leitores, seja num contexto de formação ou autoformação – estudantes dos ensinos profissional e superior –, seja em contexto profissional – programadores de aplicações e profissionais de informática. “Tendo lido e revisto a obra Programação em Python: Fundamentos e Resolução de Problemas, do Professor Ernesto Costa, é minha opinião que a mesma é extremamente relevante para empresas que usem a plataforma Python de forma avançada e, simultaneamente, tenham a necessidade de treinar recursos humanos nesta tecnologia.” Paulo Marques Cofundador e Chief Technology Officer da Feedzai

ISBN 978-972-722-816-4

9 789727 228164

Programação procedimental e orientada aos objetos; Objetos – simples e estruturados; Instruções destrutivas e de controlo; Ficheiros; Recursividade; Visualização e tratamento de imagens; Complementos; Tipos e classes; Interfaces gráficas com o utilizador.

Soluções dos exercícios e outros materiais adicionais disponíveis em www.fca.pt, até o livro se esgotar ou ser publicada nova edição atualizada ou com alterações.

Professor Catedrático do Departamento de Engenharia Informática da Universidade de Coimbra (UC). Foi o fundador e o responsável pela área de Inteligência Artificial na UC durante vários anos, e docente coordenador de diversas disciplinas nessa área e na área de Programação. Atualmente, os seus interesses estão concentrados no ensino da programação e no desenvolvimento de modelos computacionais de inspiração biológica. Recebeu, em 2009, o Prémio Europeu de Excelência pelos seus contributos para o desenvolvimento da computação evolucionária. Autor de vários trabalhos de natureza pedagógica e científica, de entre os quais se destaca o livro Inteligência Artificial: Fundamentos e Aplicações, publicado pela FCA.

EDIÇÃO FCA – Editora de Informática, Lda. Av. Praia da Vitória, 14 A – 1000-247 Lisboa Tel: +351 213 511 448 fca@fca.pt www.fca.pt DISTRIBUIÇÃO Lidel – Edições Técnicas, Lda. Rua D. Estefânia, 183, R/C Dto. – 1049-057 Lisboa Tel: +351 213 511 448 lidel@lidel.pt www.lidel.pt LIVRARIA Av. Praia da Vitória, 14 A – 1000-247 Lisboa Tel: +351 213 511 448 * Fax: +351 213 173 259 livraria@lidel.pt Copyright © 2015, FCA – Editora de Informática, Lda. ISBN edição impressa: 978-972-722-816-4 1.ª edição impressa: novembro 2015 Paginação: Tipografia Lousanense, Lda. - Lousã Impressão e acabamento: Tipografia Lousanense, Lda. - Lousã Depósito Legal n.º 401418/15 Capa: José Manuel Reis Ilustração de capa: Miguel Montenegro Marcas Registadas de FCA – Editora de Informática,

Todos os nossos livros passam por um rigoroso controlo de qualidade, no entanto aconselhamos a consulta periódica do nosso site (www.fca.pt) para fazer o download de eventuais correções. Não nos responsabilizamos por desatualizações das hiperligações presentes nesta obra, que foram verificadas à data de publicação da mesma. Os nomes comerciais referenciados neste livro têm patente registada. Reservados todos os direitos. Esta publicação não pode ser reproduzida, nem transmitida, no todo ou em parte, por qualquer processo eletrónico, mecânico, fotocópia, digitalização, gravação, sistema de armazenamento e disponibilização de informação, sítio Web, blogue ou outros, sem prévia autorização escrita da Editora, exceto o permitido pelo CDADC, em termos de cópia privada pela AGECOP – Associação para a Gestão da Cópia Privada, através do pagamento das respetivas taxas.

ÍNDICE GERAL

AGRADECIMENTOS............................................................................................................................................. VII EXTRATEXTO: FIGURAS A CORES................................................................................................................. XVII ÍNDICE DE FIGURAS............................................................................................................................................ XXV ÍNDICE DE TABELAS E QUADROS................................................................................................................ XXXIII ÍNDICE DE CÓDIGO............................................................................................................................................. XXXV SOBRE O LIVRO.................................................................................................................................................XXXIX PARTE I – PROGRAMAÇÃO PROCEDIMENTAL.......................................................................................... 1 1

INTRODUÇÃO

OBJETIVOS................................................................................................................................................................................................ 3 1.1 COMPUTADORES......................................................................................................................................................................... 3 1.1.1 ARQUITETURA................................................................................................................................................................. 3 1.1.2 FUNCIONAMENTO......................................................................................................................................................... 4 1.2 LINGUAGENS................................................................................................................................................................................. 6 1.2.1 DA MÁQUINA AO UTILIZADOR............................................................................................................................... 7 1.2.2 DIFERENTES PARADIGMAS..................................................................................................................................... 9 1.2.2.1 LINGUAGENS DECLARATIVAS OU RELACIONAIS.......................................................................... 10 1.2.2.2 LINGUAGENS FUNCIONAIS....................................................................................................................... 11 1.2.2.3 LINGUAGENS IMPERATIVAS OU PROCEDIMENTAIS..................................................................... 12 1.2.2.4 LINGUAGENS ORIENTADAS AOS OBJETOS..................................................................................... 13 1.2.3 MODELO PCAP............................................................................................................................................................... 15 1.3 A LINGUAGEM PYTHON........................................................................................................................................................... 16 1.4 PROGRAMAS................................................................................................................................................................................ 17 1.4.1 EXEMPLO MUITO SIMPLES....................................................................................................................................... 18 1.5 O MEU PRIMEIRO PROGRAMA............................................................................................................................................. 19 1.5.1 FUNÇÕES........................................................................................................................................................................... 21 1.6 FAZER ESCOLHAS...................................................................................................................................................................... 23 1.7 REPETIR........................................................................................................................................................................................... 24 1.8 INTERMEZZO................................................................................................................................................................................. 25 1.9 MÓDULOS....................................................................................................................................................................................... 26 1.10 ADIVINHAR.................................................................................................................................................................................... 29 1.11 MODO NÃO INTERATIVO......................................................................................................................................................... 32 SUMÁRIO................................................................................................................................................................................................... 33 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 34 EXERCÍCIOS............................................................................................................................................................................................... 34

2 VISÕES (I

PROGRAMAÇÃO EM PYTHON

2.2.2 POLÍGONOS REGULARES.......................................................................................................................................... 44 2.3 INTERMEZZO................................................................................................................................................................................. 45 2.4 GRÁFICOS DE FUNÇÕES.......................................................................................................................................................... 50 SUMÁRIO................................................................................................................................................................................................... 54 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 54 EXERCÍCIOS............................................................................................................................................................................................... 55

3 OBJETOS (I

OBJETIVOS................................................................................................................................................................................................ 61 3.1 GENERALIDADES........................................................................................................................................................................ 61 3.2 NÚMEROS....................................................................................................................................................................................... 64 3.2.1 OPERAÇÕES.................................................................................................................................................................... 66 3.2.2 COERÇÃO E CONSTRUTORES................................................................................................................................. 70 3.2.3 PRECEDÊNCIA................................................................................................................................................................. 71 3.2.4 OUTROS CASOS............................................................................................................................................................. 72 3.2.5 EXEMPLOS........................................................................................................................................................................ 73 3.3 BOOLEANOS................................................................................................................................................................................. 74 3.4 CADEIA DE CARATERES.......................................................................................................................................................... 77 3.4.1 CARATERES DE CONTROLO..................................................................................................................................... 78 3.4.2 OPERAÇÕES DE CONVERSÃO................................................................................................................................ 79 3.4.3 COMPARAR CADEIAS DE CARATERES............................................................................................................... 79 3.4.4 OPERADORES................................................................................................................................................................. 80 3.4.5 INDEXAÇÃO...................................................................................................................................................................... 81 3.4.6 FATIAMENTO................................................................................................................................................................... 81 3.4.7 CADEIAS DE CARATERES, PRINT E FORMATAÇÃO...................................................................................... 82 3.4.8 MAIS OPERAÇÕES........................................................................................................................................................ 84 3.4.9 MÉTODOS ESPECÍFICOS............................................................................................................................................ 84 3.4.10 CONSTRUTOR.................................................................................................................................................................. 86 3.4.10.1 EXEMPLOS....................................................................................................................................................... 86 3.5 RANGE.............................................................................................................................................................................................. 90 3.6 TUPLOS............................................................................................................................................................................................ 93 3.6.1 OPERAÇÕES.................................................................................................................................................................... 94 3.6.2 EMPACOTAMENTO........................................................................................................................................................ 95 3.6.3 CONSTRUTOR.................................................................................................................................................................. 95 3.6.4 REPRESENTAÇÃO......................................................................................................................................................... 96 3.6.5 EMBRICAMENTO............................................................................................................................................................ 98 3.6.6 TUPLOS COM NOME.................................................................................................................................................... 98 3.7 INTERMEZZO................................................................................................................................................................................. 101 3.8 IMUTABILIDADE............................................................................................................................................................................ 103 3.8.1 MUTABILIDADE E MEMÓRIA.................................................................................................................................... 106 3.8.2 NONETYPE........................................................................................................................................................................ 107 SUMÁRIO................................................................................................................................................................................................... 108 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 108 EXERCÍCIOS............................................................................................................................................................................................... 109

4 INSTRUÇÕES DESTRUTIVAS

115

ÍNDICE GERAL 4.2 ATRIBUIÇÃO................................................................................................................................................................................... 118 4.2.1 ATRIBUIÇÃO IMPLÍCITA............................................................................................................................................... 119 4.2.2 ATRIBUIÇÃO AUMENTADA........................................................................................................................................ 122 4.2.3 OUTRAS FORMAS DE ATRIBUIÇÃO...................................................................................................................... 123 4.3 LEITURA........................................................................................................................................................................................... 125 4.4 ESCRITA........................................................................................................................................................................................... 127 4.4.1 EXPRESSÕES DE FORMATAÇÃO........................................................................................................................... 128 4.4.2 MÉTODO DE FORMATAÇÃO..................................................................................................................................... 129 SUMÁRIO................................................................................................................................................................................................... 130 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 130 EXERCÍCIOS............................................................................................................................................................................................... 130

5 INSTRUÇÕES DE CONTROLO

137

OBJETIVOS................................................................................................................................................................................................ 137 5.1 INTRODUÇÃO................................................................................................................................................................................ 137 5.1.1 INDENTAÇÃO E BLOCOS............................................................................................................................................ 138 5.1.2 EXPRESSÕES BOOLEANAS..................................................................................................................................... 139 5.2 SEQUÊNCIAS................................................................................................................................................................................. 140 5.3 CONDICIONAIS.............................................................................................................................................................................. 142 5.3.1 CONDICIONAL SIMPLES.............................................................................................................................................. 142 5.3.2 CONDICIONAL NORMAL ............................................................................................................................................ 143 5.3.3 CONDICIONAL GERAL.................................................................................................................................................. 145 5.3.4 EXEMPLO CLÁSSICO: RAÍZES DE UM POLINÓMIO........................................................................................ 146 5.4 CICLOS.............................................................................................................................................................................................. 149 5.4.1 FOR....................................................................................................................................................................................... 150 5.4.2 WHILE.................................................................................................................................................................................. 151 5.4.2.1 EXEMPLOS SIMPLES................................................................................................................................... 152 5.5 INTERMEZZO................................................................................................................................................................................. 153 5.6 QUAL É O VALOR DE Π ?......................................................................................................................................................... 155 5.6.1 MÉTODO DE MONTE CARLO.................................................................................................................................... 157 5.6.2 SIMULAÇÕES................................................................................................................................................................... 160 5.7 OUTRAS INSTRUÇÕES DE CONTROLO............................................................................................................................ 162 5.7.1 BREAK................................................................................................................................................................................. 162 5.7.2 CONTINUE.......................................................................................................................................................................... 163 5.7.3 ELSE..................................................................................................................................................................................... 164 5.7.4 PASS.................................................................................................................................................................................... 165 5.8 EXCEÇÕES...................................................................................................................................................................................... 165 5.8.1 ASSERÇÕES..................................................................................................................................................................... 170 SUMÁRIO................................................................................................................................................................................................... 170 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 171 EXERCÍCIOS............................................................................................................................................................................................... 171

6 OBJETOS (II

177

PROGRAMAÇÃO EM PYTHON

6.2.4 MUTABILIDADE E PASSAGEM DE PARÂMETROS.......................................................................................... 187 6.2.5 MÉTODOS.......................................................................................................................................................................... 188 6.2.6 LISTAS E CADEIAS DE CARATERES..................................................................................................................... 190 6.2.7 LISTAS POR COMPREENSÃO................................................................................................................................... 190 6.2.8 BALEIAS............................................................................................................................................................................. 192 6.3 DICIONÁRIOS................................................................................................................................................................................. 195 6.3.1 CONSTRUTOR.................................................................................................................................................................. 198 6.3.1.1 EXEMPLOS DE UTILIZAÇÃO.................................................................................................................... 200 6.3.2 MÉTODOS.......................................................................................................................................................................... 201 6.3.3 EXEMPLO DE CONTAGEM DE BASES.................................................................................................................. 204 6.3.4 EXPRESSÃO GENÉTICA.............................................................................................................................................. 206 6.3.5 SEGURANÇA.................................................................................................................................................................... 207 6.3.6 BALEIAS............................................................................................................................................................................. 207 6.3.7 DICIONÁRIOS POR COMPREENSÃO..................................................................................................................... 208 6.4 MAIS EXEMPLOS......................................................................................................................................................................... 209 6.4.1 CONSTRUIR DICIONÁRIOS......................................................................................................................................... 209 6.4.2 EQUÍVOCOS...................................................................................................................................................................... 210 6.4.3 ÁRVORES GENEALÓGICAS....................................................................................................................................... 211 6.5 CONJUNTOS................................................................................................................................................................................... 212 6.5.1 LITERAIS E CONSTRUTOR ........................................................................................................................................ 212 6.5.2 OPERAÇÕES BÁSICAS................................................................................................................................................ 213 6.5.3 MÉTODOS ........................................................................................................................................................................ 213 6.5.4 EXEMPLOS ...................................................................................................................................................................... 215 SUMÁRIO................................................................................................................................................................................................... 216 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 216 EXERCÍCIOS............................................................................................................................................................................................... 217

7 FICHEIROS

223

XII

ÍNDICE GERAL 8 VISÕES (II

261

OBJETIVOS................................................................................................................................................................................................ 261 8.1 INTRODUÇÃO................................................................................................................................................................................ 261 8.2 REPRESENTAÇÃO DE IMAGENS.......................................................................................................................................... 263 8.3 O MÓDULO cIMAGE................................................................................................................................................................... 266 8.3.1 JANELAS........................................................................................................................................................................... 267 8.3.2 IMAGENS........................................................................................................................................................................... 267 8.3.3 PÍXEIS.................................................................................................................................................................................. 267 8.4 EXEMPLOS BÁSICOS................................................................................................................................................................. 267 8.5 MANIPULAÇÕES SIMPLES...................................................................................................................................................... 273 8.5.1 NEGATIVO......................................................................................................................................................................... 273 8.5.2 CINZENTOS....................................................................................................................................................................... 275 8.5.3 SÉPIA................................................................................................................................................................................... 277 8.6 INTERMEZZO : ABSTRAÇÃO.................................................................................................................................................. 278 8.6.1 BRILHO................................................................................................................................................................................ 279 8.7 EXEMPLOS COMPLEMENTARES.......................................................................................................................................... 280 8.7.1 COLORIR O CHÃO.......................................................................................................................................................... 280 8.7.2 DISTORCER UMA IMAGEM........................................................................................................................................ 283 8.7.3 ESPELHO............................................................................................................................................................................ 286 8.8 FILTROS............................................................................................................................................................................................ 287 8.8.1 CONVOLUÇÃO................................................................................................................................................................. 290 8.8.2 EXTRAIR CARACTERÍSTICAS................................................................................................................................... 293 8.9 O FORMATO DE IMAGEM PPM............................................................................................................................................. 295 8.9.1 DE PPM PARA JPG........................................................................................................................................................ 296 8.9.2 DE JPG PARA PPM........................................................................................................................................................ 297 SUMÁRIO................................................................................................................................................................................................... 298 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 299 EXERCÍCIOS............................................................................................................................................................................................... 299

9 RECURSIVIDADE

305

10 COMPLEMENTOS

343

XIII

PROGRAMAÇÃO EM PYTHON

10.2.3 DECLARAÇÃO GLOBAL.............................................................................................................................................. 356 10.2.4 VARIÁVEIS NÃO LOCAIS........................................................................................................................................... 357 10.2.5 AS REGRAS ATUALIZADAS...................................................................................................................................... 361 10.2.5.1 DECORADORES............................................................................................................................................. 363 10.3 MÓDULOS....................................................................................................................................................................................... 364 10.3.1 USO E EXECUÇÃO......................................................................................................................................................... 367 10.4 DEFINIÇÕES E ARGUMENTOS............................................................................................................................................... 368 10.4.1 MUTABILIDADE............................................................................................................................................................... 373 10.4.2 PARÂMETROS COM VALORES POR DEFEITO................................................................................................. 376 10.4.3 NÚMERO VARIÁVEL DE ARGUMENTOS............................................................................................................. 379 10.5 ITERADORES E GERADORES................................................................................................................................................ 382 10.5.1 ITERADORES................................................................................................................................................................... 382 10.5.1.1 ITERÁVEIS, ITERADORES E O CICLO FOR........................................................................................ 386 10.5.1.2 MÓDULO ITERTOOLS ................................................................................................................................ 387 10.5.2 GERADORES.................................................................................................................................................................... 389 10.5.3 CRIVO DE ERATÓSTENES ........................................................................................................................................ 391 10.6 FUNÇÕES DE ORDEM SUPERIOR........................................................................................................................................ 394 10.6.1 FUNÇÕES ANÓNIMAS................................................................................................................................................. 394 10.6.2 MAP, FILTER E REDUCE .............................................................................................................................................. 396 SUMÁRIO................................................................................................................................................................................................... 403 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 403 EXERCÍCIOS............................................................................................................................................................................................... 404

11 DESENVOLVIMENTO

409

PARTE II – PROGRAMAÇÃO ORIENTADA AOS OBJETOS..................................................................... 453 12 TIPOS E CLASSES

455

ÍNDICE GERAL 12.2 CRIAÇÃO DE NOVOS TIPOS................................................................................................................................................... 457 12.3 TIPOS DE DADOS ABSTRATOS............................................................................................................................................ 465 12.3.1 PILHAS................................................................................................................................................................................ 466 12.3.1.1 APLICAÇÃO..................................................................................................................................................... 469 12.3.2 FILAS................................................................................................................................................................................... 471 12.3.2.1 APLICAÇÃO..................................................................................................................................................... 473 12.4 INTERMEZZO................................................................................................................................................................................. 474 12.5 ÁRVORES........................................................................................................................................................................................ 479 12.5.1 EXEMPLOS SIMPLES................................................................................................................................................... 483 12.5.2 APLICAÇÃO: TRAVESSIA DE ÁRVORES............................................................................................ 484 SUMÁRIO................................................................................................................................................................................................... 486 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 486 EXERCÍCIOS............................................................................................................................................................................................... 487

13 PROGRAMAÇÃO ORIENTADA AOS OBJETOS

489

14 INTERFACES GRÁFICAS COM O UTILIZADOR

535

PROGRAMAÇÃO EM PYTHON

14.8 EXEMPLO: CALCULADORA..................................................................................................................................................... 563 14.9 EXEMPLO: JOGO DO GALO.................................................................................................................................................... 565 SUMÁRIO................................................................................................................................................................................................... 572 TESTE OS SEUS CONHECIMENTOS............................................................................................................................................... 572 EXERCÍCIOS............................................................................................................................................................................................... 573

A INSTALAR PYTHON

579

A.1 VERIFICAR...................................................................................................................................................................................... 579 A.2 INSTALAR PYTHON 3................................................................................................................................................................ 580 A.2.1 ANACONDA........................................................................................................................................................................ 580 A.3 WingIDE............................................................................................................................................................................................. 581

BIBLIOGRAFIA...................................................................................................................................................... 583 ÍNDICE REMISSIVO............................................................................................................................................. 585

XVI

EXTRATEXTO: FIGURAS A CORES

FIGURA 2.16 – UMA CASA PORTUGUESA

FIGURA 2.20 – O SÍMBOLO DOS JOGOS OLÍMPICOS

FIGURA 2.21 – RADIOATIVIDADE

FIGURA 2.23 – JOGO DO GALO

XVII

PROGRAMAÇÃO EM PYTHON

FIGURA 5.10 – MONTE CARLO ANIMADO

FIGURA 6.12 – CODIFICAÇÃO DAS BASES

FIGURA 8.1 – MAPEAMENTO RGB DE CORES XVIII

SOBRE O LIVRO And now for something completely different... Monty Python

Esta obra aborda o uso de computadores para resolver problemas com recurso a programas escritos numa linguagem de programação de alto nível, neste caso, o Python. A elaboração deste livro teve dois objetivos principais. Em primeiro lugar, introduzir os conceitos centrais, os blocos construtores presentes genericamente em todas as linguagens de programação. Em segundo lugar, explicitar boas práticas de programação, entendidas como os princípios que nos guiam do problema à sua solução informática. Mas, em que tipo de problemas estamos interessados? Todos sabemos que os computadores estão presentes numa grande parte das atividades humanas. De um telemóvel ao controlo de tráfego aéreo, passando pela definição de escalas de tripulações de comboios, os computadores estão em todo o lado. De um modo mais direto, os computadores estão presentes na nossa vida diária pois fazemos uso deles para enviar e receber correio, trocar mensagens curtas, jogar, escrever documentos ou navegar na Internet. Como utilizadores comuns, apreciamos o facto de não termos de nos preocupar com a forma como os programas que usamos para essas atividades foram desenvolvidos ou como funcionam. Podemos dizer que alguém (um programador ou um grupo de programadores) tornou simples o que é complexo, escondendo os detalhes. Utilizamos esses programas através de uma interface que disponibiliza um conjunto de funções e um modo de interação, que usamos com mais ou menos à vontade. Neste manual pretendemos iniciar o leitor nesta atividade conhecida por programação, uma mistura de arte e de ciência, de intuição e de princípios sólidos de projeto. Tratando-se de um texto introdutório, os problemas que nos interessam são necessariamente pequenos, mas não forçosamente simples. Caminhamos do elementar para o mais elaborado, introduzindo as características da linguagem escolhida à medida que seja necessário. Muitos dos conceitos são retomados mais do que uma vez, em contextos diversos, uma decisão pedagógica que a experiência tem validado.

OPÇÕES Discute-se, muitas vezes, se o primeiro curso de programação se deve basear numa abordagem procedimental, orientada aos objetos ou outra. A nossa opção foi clara, privilegiando a programação procedimental. As razões são múltiplas, mas, essencialmente, a nossa decisão radica no facto de pretendermos focar-nos, em primeiro lugar, nos aspetos mais básicos da programação e fazê-lo com pequenos exemplos. Um outro ponto de controvérsia é se se deve optar entre uma abordagem em largura ou em profundidade. Se a escolha recair numa abordagem em largura, podem-se cobrir muitos tópicos, pagando o preço da superficialidade. Optando pela profundidade, estaremos na situação inversa. No nosso caso, decidimos ir por um caminho híbrido. Assim, no primeiro capítulo damos uma visão geral do essencial da programação, minimizando a dependência da linguagem concreta © FCA – EDITORA DE INFORMÁTICA

XXXIX

PROGRAMAÇÃO EM PYTHON que iremos usar. De seguida (Capítulos 2 a 8), aprofundamos esses conceitos básicos da programação no contexto de linguagem Python. Mais à frente, Capítulo 9, discutiremos um tema central da programação, a recursividade. No Capítulo 10, serão abordados aspetos mais avançados da linguagem Python, enquanto que no Capítulo 11 serão tratados aspetos relevantes de metodologia da programação. Apesar de termos optado por introduzir a programação procedimental em primeiro lugar, a programação orientada aos objetos (POO) não foi esquecida. Assim, a segunda parte do livro é dedicada a uma introdução breve da POO, para que o leitor interessado possa avançar na sua formação. Num capítulo (Capítulo 12) discutimos os aspetos de sintaxe da POO, baseando-nos no facto de, em Python, os tipos, conceito já longamente discutido nos capítulos anteriores, estarem implementados como classes. Aproveitamos ainda para falar um pouco sobre estruturas de dados e tipos de dados abstratos. O Capítulo 13 discute os conceitos essenciais da POO, isto é: encapsulamento, herança e polimorfismo. Também são introduzidas noções básicas de desenho de soluções e de diagramas de classe. Finalmente, no Capítulo 14, afloramos a questão da programação guiada por eventos e discutimos a construção de aplicações suportadas por uma interface gráfica. Programar significa resolver problemas concretos escrevendo programas. Muitos dos exemplos que aparecem ao longo do texto são exemplos clássicos que o leitor pode encontrar em qualquer outro livro sobre programação. Outros exemplos foram por nós desenhados, com o objetivo de alargar o leque do material de estudo.

PÚBLICO-ALVO O modo como o livro está organizado faz-nos acreditar que pode ser usado por diferentes tipos de leitores. Desde logo, os capítulos sobre programação procedimental adequam-se ao ambiente académico, em disciplinas de nível inicial sobre programação. Pode ainda ser útil a disciplinas de nível intermédio de programação, que envolvam a análise e desenvolvimento de programas, estruturas de dados elementares e uma introdução à programação orientada aos objetos. Optámos por logo no início do livro dar uma panorâmica geral da linguagem Python, deixando para os capítulos posteriores o aprofundamento dos conceitos e os aspetos complementares, mais avançados, da linguagem. Isto torna possível que o leitor, apenas com um esforço mínimo, consiga escrever os seus próprios programas. Por outro lado, foi nossa opção deliberada apresentar muitos exemplos práticos detalhados, incluindo, nos casos em que se justifica, diferentes soluções. A conjugação de todos estes aspetos leva-nos a afirmar que o livro pode ser utilizado também de modo vantajoso por profissionais que se dediquem ao desenvolvimento de aplicações nesta linguagem de programação moderna, que um número crescente de empresas de relevo tem vindo a adotar. Para quem já programa, pode servir para tomar conhecimento com a linguagem Python, que oferece um conjunto muito significativo de vantagens, a menor das quais não é seguramente ter uma sintaxe simples que facilita a aprendizagem. A forma como a obra está organizada e escrita torna ainda este texto adaptado a situações de autoestudo e/ou de autoaprendizagem, quer se trate de um público estudantil ou profissional. XL

SOBRE O LIVRO

UTILIZAÇÃO O texto foi pensado para uma leitura sequencial, podendo, no entanto, em função dos conhecimentos prévios do leitor, ter um percurso diferente. Caso a sua utilização seja feita em ambiente académico, a nossa experiência diz-nos que pode ser usado, sem problemas, num curso introdutório de programação procedimental, de duração semestral, usando os Capítulos 1 a 8. Se os alunos tiverem já conhecimentos de programação procedimental noutra linguagem, pode-se passar muito rapidamente pelos capítulos iniciais e basear o curso nos Capítulos 9 a 14. Ao longo do documento aparecem caixas como a que se apresenta a seguir. EXEMPLO DE CAIXA Estas caixas contêm informação complementar.

Numa primeira leitura, estas caixas podem ser ignoradas sem perda de continuidade. Algumas destas caixas têm uma natureza informativa, enquanto outras apresentam conceitos mais avançados.

EXERCÍCIOS E MATERIAL COMPLEMENTAR Acreditamos que se aprende a programar programando, mas também olhando para as soluções de outros programadores. Por isso, o livro apresenta muitos exemplos já resolvidos, e propõe muitos mais no final de cada capítulo. Associados aos exercícios propostos vai encontrar siglas que dão uma indicação do grau de dificuldade dos problemas. Assim, usamos a seguinte forma de notação: ■■

MF para problemas triviais;

■■

F para fáceis;

■■

M para problemas de dificuldade média;

■■

D para problemas que exigem reflexão e tempo;

■■

MD para problemas de elevada complexidade.

O grau de dificuldade que indicamos não é absoluto, sendo antes relativo ao nível de conhe cimentos que é suposto o leitor ter no momento em que resolve os exercícios. Igualmente, caso o problema envolva o uso de um módulo especial, o nome do mesmo será indicado, através do seguinte grafismo: Módulo nome . Se visitar o blogue http://programacaocompython.blogspot.com, encontra muita informação adicional, incluindo muitos mais exemplos resolvidos e discussão de alguns problemas da programação e a forma de os resolver. Este blogue tem sido construído a partir da minha experiência de ensino na cadeira de Introdução à Programação e Resolução de Problemas da Universidade de Coimbra.

XLI

PROGRAMAÇÃO EM PYTHON O leitor pode também consultar a página do livro em www.fca.pt, onde encontrará as soluções dos exercícios e exemplos de exames.

VERSÃO DE PYTHON Ao longo dos anos, a linguagem Python foi sendo modificada. Até à versão 2.7.5, os novos desenvolvimentos eram compatíveis com as versões anteriores. Com o aparecimento da versão 3, essa compatibilidade deixou de existir, tornando difícil a atualização em tempo útil e a adaptação de módulos da linguagem necessários em muitas aplicações. Por isso, esta versão demorou algum tempo a ser adotada pela generalidade da comunidade. Hoje, esse problema está ultrapassado e, no final do livro, no Anexo A, explicamos como pode descarregar e instalar um ambiente que lhe permite ter à sua disposição o interpretador e todos os módulos de referência. Esta nossa preferência pela versão 3 radica também nas alterações francamente positivas que foram introduzidas na linguagem. Ao leitor que já programa em Python e tem as suas aplicações escritas na versão 2, aconselhamos a usar a aplicação de conversão para a versão 3 que vem com as novas distribuições.

XLII

1 INTRODUÇÃO Qualquer começo é difícil – Tal é válido em qualquer ciência. Karl Marx

OBJETIVOS ■■

Identificar as principais componentes de um computador baseado na arquitetura de Von Neumann.

■■

Perceber o modo como um computador funciona.

■■

Introduzir ideias básicas sobre linguagens e paradigmas de programação.

■■

Introduzir, usando exemplos simples, aspetos básicos da linguagem Python.

1.1 COMPUTADORES Um computador não é mais do que a associação de uma máquina com um conjunto de programas que permitem a construção e a execução de outros programas escritos numa dada linguagem de programação. O fim último é a resolução de problemas. O computador tanto pode estar instalado comodamente na nossa secretária, como estar embebido noutros equipamentos, desde uma máquina de lavar roupa a um controlador de uma central nuclear, passando pelo nosso telemóvel. Nas secções seguintes vamos abordar de modo muito sumário estes aspetos.

1.1.1 ARQUITETURA O ser humano tem uma característica fundamental: é um construtor de artefactos. Ao longo dos séculos, foi inventando objetos que ampliaram as suas capacidades mecânicas (e. g., um martelo) ou os seus sentidos (e. g., um telescópio). Com o aparecimento do computador, o desafio passou a ser maior, traduzindo-se por criar uma extensão às suas capacidades mentais1. Será esse o papel dos computadores! O debate sobre a possibilidade de identificar o ser humano com as máquinas tem contornos filosóficos e é anterior mesmo à construção do primeiro computador2. Há quem defenda (e. g., Herbert Simon) que o ser 1 2

O sociólogo Daniel Bell chama ao computador uma “tecnologia intelectual”. Um relógio ou um mapa são outros exemplos. Basta pensar em Leonardo Da Vinci, Charles Babbage ou Alan Turing. © FCA – EDITORA DE INFORMÁTICA

PROGRAMAÇÃO EM PYTHON humano e os computadores são apenas duas instâncias de algo mais abstrato a que chamaram sistema físico de símbolos. Outros (e. g., Rodney Brooks) falam de algo mais ousado, que designam por Robot Sapiens, um novo ser simbiótico que resulta da associação homem-máquina. Independentemente deste debate, é certo que, a um determinado nível de abstração, podemos associar a arquitetura funcional de um computador dos nosso dias a algumas das nossas capacidades. Muito superficialmente, o ser humano possui órgãos de captura de informação (e.g., os olhos), órgãos de atuação (e. g., os braços) e órgãos de processamento e de armazenamento da informação (e. g., o cérebro). Esta decomposição, quando transposta para o computador, dá lugar à arquitetura simplificada (por exemplo, não incluímos as componentes de rede, essenciais nos computadores de hoje) de um computador, que podemos observar na Figura 1.1.

CPU

Dispositivos de saída

Memória interna

Memória externa

Dispositivos de entrada

FIGURA 1.1 – ARQUITETURA DE UM COMPUTADOR

Do ponto de vista da sua dinâmica, um computador executa programas que foram previamente armazenados na sua memória externa (e. g., um disco duro). Esses programas são formados por instruções, que são transferidas para a memória interna (e. g., RAM) e executadas pela máquina graças à unidade central de processamento (CPU). Eventualmente, pode haver recurso à entrada de dados através de dispositivos apropriados (e. g., teclado) e visualização de resultados graças aos dispositivos de saída (e. g., o monitor). Esta é a arquitetura dita de Von Neumann, que ainda hoje é predominante3.

1.1.2 FUNCIONAMENTO Quando recebemos o nosso novo computador, ele vem equipado com um programa fundamental, o sistema operativo (SO)4. Tanto pode ser Windows, como Linux, Mac OS, ou outro qualquer. Um sistema operativo é constituído por um núcleo mais um conjunto de programas que permitem, entre outros aspetos, uma interação amigável com o utilizador (e. g., um sistema de janelas, controlo por meio de um rato, etc.5). Os programas são A entrada em cena de vários processadores, cada um com vários núcleos, veio alterar um pouco a visão simples da arquitetura convencional, embora as diferenças tenham mais que ver com o modo como o programa é executado do que com a filosofia subjacente à arquitetura descrita. 4 Se fomos nós a fabricar o computador, vamos ter de resolver a questão de instalar o SO adequado ao hardware escolhido. Pode ser uma tarefa divertida! 5 Atualmente, existem os ecrãs sensíveis ao toque que faz das mãos de novo um instrumento central na interação do ser humano com o computador. 3

VISÕES (I)

(cont.) 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

def grafico(tartaruga,funcao, inicio,fim, n): """ Desenha o gráfico da função f entre inf e sup usando n segmentos.""" # Tamanho dos segmentos tam_seg = (fim - inicio)/n x = inicio # Posiciona-se tartaruga.up() tartaruga.goto(x, funcao(x)) tartaruga.dot(6) tartaruga.down() # Desenha for conta in range(n): x = x + tam_seg tartaruga.goto(x, funcao(x)) tartaruga.dot(6) if

name == ' main ': # Inicializa turtle.setworldcoordinates(-math.pi, -2, math.pi,2) linha(-math.pi,0,math.pi,0) linha(0,-2,0,2) # Seno toto = turtle.Turtle() toto.pen(pensize=3, pencolor='gray') grafico(toto,math.sin, -math.pi,math.pi,50) toto.up() toto.goto(0.5,1) toto.write('SENO(X)', font=('ARIAL', 14,'bold')) toto.hideturtle() # Cosseno titi = turtle.Turtle() titi.pen(pensize=3) grafico(titi,math.cos, -math.pi,math.pi,50) titi.up() titi.goto(-0.7,1) titi.write('COSSENO(X)', font=('ARIAL', 14,'bold')) titi.hideturtle() # Termina turtle.exitonclick() LISTAGEM 2.4 – SENO E COSSENO

Ao executar o programa, veremos o resultado retratado na Figura 2.8.

PROGRAMAÇÃO EM PYTHON

COSSENO(X)

SENO(X)

FIGURA 2.8 – SENO E COSSENO

Atente-se no recurso a dot (linhas 21 e 27) para marcar o ponto sobre a curva. Veja-se, ainda, como se escreve o nome da função (linhas 38, 39 e 40 para o seno, e linhas 46, 47 e 48, para o cosseno). SUMÁRIO Neste capítulo introduzimos o módulo turtle e algumas das operações que podem ser feitas sobre objetos do tipo Turtle. Introduzimos o conceito de construtor de um tipo e clarificámos a diferença entre os conceitos de função e de método. Exemplificámos o uso do módulo para resolver problemas de geometria e para o gráfico de funções.

TESTE OS SEUS CONHECIMENTOS

Tente responder às seguintes questões que foram tratadas neste capítulo: 1. O que entende por construtor? 2. Quais são as operações básicas sobre tartarugas? 3. De que modo se definem novas formas de tartarugas? 4. Quais são as operações básicas sobre a caneta? 54

OBJETOS (I)

(cont.) 4 5 6 7 8 9 10 11

>>> decimal.Decimal('0.1') + decimal.Decimal('0.2') Decimal('0.3') >>> decimalz.Decimal(1953) + decimal.Decimal(' 1234.5678901234567890123456') Decimal('3187.5678901234567890123456') >>> 1953 * decimal.Decimal('0.1234') Decimal('241.0002') >>> math.sin(decimal.Decimal('1.234567')) 0.9440054313672885

Este pequeno exemplo mostra como se pode ter precisão ilimitada. Exemplifica ainda o facto de as operações usuais com números poderem ser aplicadas com números decimais.

3.2.5 EXEMPLOS Vejamos dois exemplos simples de programas envolvendo cálculos com números. EXEMPLO 3.1 Suponhamos que queremos calcular o declive de uma reta dados 2 pontos. A fórmula para o fazer é conhecida:

declive ( x1 , y1 , x2 , y2 ) =

( y2 − y1 ) ( x2 − x1 )

Daqui decorre um programa muito simples. 1 2 3

def declive(x1,y1,x2,y2):

""" Usa a forma habitual para calcular o declive, dados dois pontos.""" return (y2 - y1)/(x2 - x1)

O único problema com este programa é que não prevê o caso de os pontos terem a mesma abcissa, isto é, estarmos na presença de uma reta perpendicular ao eixo dos x. Mas tal pode ser remediado facilmente efetuando um teste a essa situação e tomando a ação apropriada. 1 2 3 6 7 8

def declive(x1,y1,x2,y2):

""" Usa a forma habitual para calcular o declive, dados dois pontos.""" if x1 != x2: return (y2 - y1)/(x2 - x1) else:

return float('Inf')

Note-se como em Python podemos introduzir uma constante que simboliza o infinito (linha 6). Caso pretendamos menos infinito usamos float('-Inf').

PROGRAMAÇÃO EM PYTHON

EXEMPLO 3.2 Passemos ao caso do cálculo das raízes de um polinómio do segundo grau. Também aqui a fórmula é conhecida:

x1,2 =

−b ± b 2 − 4 × a × c 2× a

O código é direto. 1 2 3 4 5 6 7 8

import cmath def poli_2(a,b,c):

""" Calcula as raízes de um delta = cmath.sqrt(b**2 - 4 raiz_1 = (- b + delta) / (2 raiz_2 = (- b - delta) / (2 return raiz_1, raiz_2

polinómio do segundo grau. """ * a * c) * a) * a)

Neste exemplo fomos obrigados a usar o módulo cmath, semelhante ao módulo math, mas que disponibiliza operações para números complexos. Note-se ainda que é possível uma função devolver mais do que um valor, neste caso, as duas raízes do polinómioa. a

Na realidade, o que é devolvido é um tuplo, objeto de um tipo de que trataremos na secção 3.6.

3.3 BOOLEANOS Os booleanos foram representados, durante muito tempo, por números, mais concretamente, o 1 para verdadeiro e o 0 para falso. Atualmente, têm o seu próprio tipo, bool, e os seus próprios valores (as constantes True e False). Existem três operações com objetos do tipo booleano, como se indica no Quadro 3.5. QUADRO 3.5 – OPERADORES BOOLEANOS Operadores x and y

Descrição O e lógico

x or y

O ou lógico

not x

A negação lógica

Em termos de implementação, convém referir que estas operações seguem o princípio dito de curto circuito: no caso do and, a operação termina mal um dos operandos tenha valor False; no caso do or, termina mal um dos operandos seja True. A existência de booleanos é fundamental em programação, pois é o que necessitamos de usar nas instruções de controlo condicionais ou nos ciclos de execução condicional. Eis alguns exemplos simples de utilização.

INSTRUÇÕES DESTRUTIVAS

4.3 LEITURA Sabemos desde o Capítulo 1 que existem diferentes maneiras de um programa comunicar com o ambiente com que interage. No caso de uma definição, podemos introduzir dados através dos parâmetros formais ou da instrução input, e podemos comunicar resultados recorrendo à instrução return ou à instrução print (ver Figura 4.4). No caso da instrução input, existe um argumento opcional que, quando presente, é uma cadeia de carateres que funciona como uma mensagem. 1 2 3

>>> idade = input('A sua idade por favor : ') A sua idade por favor : 59 >>>

Precisamos de ter cuidado com o uso da instrução de entrada, pois o que ela devolve é sempre uma cadeia de carateres. Sabendo isto, é sem surpresa que observamos o que acontece na listagem seguinte. 1 2 3 4 5 6 7 8 9

>>> idade = input('A sua idade por favor : ') A sua idade por favor : 59 >>> idade '59' >>> idade + 1 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: Can't convert 'int' object to str implicitly >>> parâmetros formais

input print

return

FIGURA 4.4 – ENTRADA E SAÍDA DE DADOS

125

PROGRAMAÇÃO EM PYTHON Já sabemos que podemos usar o construtor dos diferentes tipos de dados para forçar um objeto a ser convertido, quando tal é possível, para outro tipo de objeto. No caso presente, recorreríamos a int. 1 2 3 4 5 6 7

>>> idade = int(input('A sua idade por favor : ')) A sua idade por favor : 59 >>> idade 59 >>> idade + 1 60 >>>

Podemos generalizar esta abordagem usando, não o construtor, mas a função eval. 1 2 3 4 5 6 7 8 9 10 11

>>> idade = A sua idade >>> idade 59 >>> idade = A sua idade >>> idade 59.5 >>> idade + 60.5 >>>

eval(input('A sua idade por favor : ')) por favor : 59 eval(input('A sua idade por favor : ')) por favor : 59.5

CHAMADA DE FUNÇÕES A função eval tem como argumento uma cadeia de carateres que é interpretada como sendo uma expressão. Daí ser possível algo como: 1 2 3 4 5 6 7 8 9 10 11

>>> entrada = eval(input('Introduza uma expressão >>> Introduza uma expressão >>> 4 + 5 >>> entrada 9 >>> def duplo(x): ... return 2 * x ... >>> entrada = eval(input('Introduza uma expressão >>> Introduza uma expressão >>> duplo(4) >>> entrada 8

'))

A chamada de uma função é sintaticamente uma expressão, explicando o que acontece na última situação.

126

INSTRUÇÕES DE CONTROLO

TESTE OS SEUS CONHECIMENTOS

Determine se conhece os conceitos indicados e se consegue responder às questões abaixo colocadas: 1. O que entende por bloco e como é que este se relaciona com a indentação do código? 2. De que maneira pode representar os valores booleanos True e False? 3. Que tipos de instruções condicionais existem e como se distinguem? 4. Qual é a diferença fundamental entre um ciclo for e um ciclo while? 5. De que modo pode percorrer um ciclo? 6. Que formas tem de interromper/quebrar um ciclo? 7. Em que princípios se baseia o método de Monte Carlo? 8. Que diferenças existem entre exceções e asserções?

EXERCÍCIOS 5.1. F Escreva um programa que apresente, por ordem crescente, três números inteiros positivos dados como entrada. Em que medida a sua solução minimiza o número de comparações necessárias? Nota: não pode usar nenhuma função/método de ordenamento predefinido de Python. 5.2. F Para realizar a viagem entre o Porto e Coimbra (120 km de distância), existem várias estradas como alternativa. A Tabela 5.1 ilustra as diferentes alternativas em termos de trajeto considerando o custo de combustível por quilómetro e o custo das portagens. Escreva um programa que, dada a designação da estrada, retorne o custo total da viagem para essa alternativa. TABELA 5.1 – O QUE ESCOLHER? Estradas

Custo combustível/km

Custo portagens

0.15

6.52

A20

0.12

15.2

A21

0.10

5.75

5.3. F O vencimento bruto de um trabalhador está sujeito a descontos: 25% para o IRS, 5% para a Segurança Social e 10% para a Caixa Nacional de Aposentações. O vencimento líquido é o que resulta da subtração destes descontos ao vencimento bruto. Desenvolva um programa que, dado o vencimento bruto, devolva o correspondente vencimento líquido. © FCA – EDITORA DE INFORMÁTICA

171

PROGRAMAÇÃO EM PYTHON

5.4. F A avaliação nesta cadeira resulta de cinco provas: quatro testes (ti , i = 1, 2, 3, 4) e um exame (e). Cada teste vale 7.5% da nota final, enquanto o exame vale 70%. Tal significa que a nota é dada pela expressão: nota = 0.075 ∗ ( t1 + t2 + t3 + t4 ) + 0.7 ∗ e Escreva um programa que, dadas as cinco notas parciais, calcule a nota final e, como resultado, devolva a cadeia de carateres “Aprovado”, se a média for maior ou igual a 14; “Reprovado”, se a média for inferior a 7; “Oral”, se a média for maior ou igual a 7 e inferior a 14. Admita que as notas são números reais entre 0 e 20. 5.5. F Considere o seguinte pedaço de código Python. 1 2 3 4

i = 20 while (i >= 0): print("i= ",i) i = i - 2 LISTAGEM 5.31 – CICLO WHILE

Escreva um excerto de código equivalente em que o ciclo while seja substituído por um ciclo for. 5.6. M Considere o seguinte pedaço de código Python. 1 2 3 4 5 6

>>> for i in range(3): ... for j in range(1,3): ... print(i/j) ... ? >>>

Indique, justificando, o que vai aparecer no lugar do ponto de interrogação quando o código for executado no interpretador. 5.7. M Duas palavras de igual comprimento dizem-se amigas se o número de posições em que os respetivos carateres diferem for inferior a 10%. Escreva um programa que, dadas duas palavras, indique se são ou não amigas. 5.8. M Escreva um programa que calcule o divisor mais pequeno de um número inteiro maior do que 1. Use esse programa como auxiliar para determinar se um dado inteiro maior do que um é um número primo. 5.9. Módulo random M Suponha um dado em que cada uma das faces está numerada com os inteiros de 1 a 6. Desenvolva um programa que simule o lançamento repetido do dado um certo número de vezes e calcule a percentagem de vezes em que saiu um número par.

172

OBJETOS (II)

QUADRO 6.1 – LITERAIS PARA LISTAS Interpretação

Literal [733, −15, 0]

Lista de números

[“praxe",′ sporting′,′ abracadabra′]

Lista de cadeias de carateres

[]

A lista . . . vazia!

[1, [2, 3], 4]

Lista de listas

[1,′ a′,′ b′, 3.0 + 4j]

Lista heterogénea

[x ∗ ∗2 for x in range(1, 4)]

Listas por compreensão2

As listas são coleções ordenadas de objetos, de comprimento variável, acedidas por posição, heterogéneas e mutáveis. Como no caso das cadeias de carateres, existe uma ordem nas listas, sendo também, por isso, sequências. Os elementos no interior das listas podem ser de qualquer tipo, incluindo listas, o que justifica a característica de serem heterogéneas. Uma segunda característica que as diferencia das cadeias de carateres e dos tuplos é o facto de serem objetos mutáveis: podemos alterar o seu valor sem alterar a sua identidade. Este aspeto tem consequências muito relevantes, como iremos ver ao longo deste texto. 2 São várias as operações associadas às listas, algumas das quais partilhadas com as sequências, como se pode confirmar na Tabela 6.1. TABELA 6.1 – OPERAÇÕES SOBRE LISTAS Nome

Operador

Significado

Indexação

[< n >]

Acede

Concatenação

L1 + L2

Junta

Repetição

L ∗ n, n ∗ L

Replica

Pertença

in, not in

Testa

Comprimento

len

Quantifica

Fatiamento

[::]

Parte

A Listagem 6.3 mostra alguns exemplos de uso destas operações. 1 2 3 4 5 6 7 8 9 10

>>> [1,2,3][1] 2 >>> [1,2,3] + [4,5,6] [1, 2, 3, 4, 5, 6] >>> ['Ai!'] * 4 ['Ai!', 'Ai!', 'Ai!', 'Ai!'] >>> len([1,2,3]) 3 >>> 2 in [1,2,3] True

(cont.)

As listas por compreensão serão objeto de tratamento mais à frente. © FCA – EDITORA DE INFORMÁTICA

179

PROGRAMAÇÃO EM PYTHON

1 2 3 4

def aplana_lc(lista): """Transforma uma lista de listas numa lista simples.""" res = [val for elem in lista for val in elem] return res

Mais alguns exemplos de utilização: 1 2 3 4 5

>>> [ i * j for i in [1,2,3] for j in ['a','b','c']] ['a', 'b', 'c', 'aa', 'bb', 'cc', 'aaa', 'bbb', 'ccc'] >>> [i for elem in [[1,-2,3],[-4,5,-6]] for i in elem if i > 0] [1, 3, 5] >>>

Podemos usar as listas por compreensão para determinar a transposta de uma matriz6 de um modo muito elegante7. 1 2 3

def transposta_c(matriz): """ Transposta de uma matriz.""" return [[matriz[j][i] for j in range(len(matriz))] for i in range(len(matriz[0]))]

ENUMERATE Quando usada num ciclo for, uma lista pode ser percorrida, seja pelo seu conteúdo, seja pela posição dos seus elementos. A opção depende do problema. Existem, no entanto, situa ções em que nos interessa ter acesso ao elemento e à sua posição. Quando isso acontece, podemos usar a função predefinida enumerate. Vejamos o que acontece quando o fazemos. 1 2 3 4 5 6 7 8

>>> lista = ['a','b','c'] >>> for i,v in enumerate(lista): ... print(i,v) ... 0 a 1 b 2 c >>>

Se usarmos como segundo argumento um inteiro positivo, a enumeração começa nesse valor. Por defeito, esse valor é 0.

6.2.8 BALEIAS Regressemos ao problema das baleias e vejamos como poderíamos resolver o nosso problema de análise de dados. Relembremos que temos guardado numa lista, ordenada por dias, o número de baleias vistas numa certa zona. Um primeiro problema consiste em 6 7

A transposta de uma matriz é o que se obtém quando o elemento na posição (i,j) vai para a posição (j,i). Existe um modo de implementar a transposta de uma matriz que usa outras construções da linguagem. Será apresentado mais à frente.

192

FICHEIROS

FIGURA 7.6 – TEMPERATURA E PLUVIOSIDADE

7.8 DE UM FICHEIRO DE PALAVRAS A UM DICIONÁRIO DE FREQUÊNCIAS Suponhamos que temos um dicionário com palavras e queremos construir um dicionário cujas chaves são inteiros que traduzem o tamanho das palavras e cujos valores são listas de palavras com esse tamanho. Apresentemos primeiro uma solução simples: 1 2 3 4 5 6 7 8

def fich_dic_a(ficheiro): f_in = open(ficheiro, 'r') lista_pal = f_in.read().split() dic = {} for palavra in lista_pal: comp = len(palavra) dic[comp] = dic.get(comp,[]) + [palavra] return dic

Agora uma solução que prevê o uso de símbolos especiais. 1 2 3 4 5 6 7

def fich_dic_b(ficheiro): f_in = open(ficheiro, 'r') lista_pal = f_in.read().split() dic = {} especiais = ['\n','.',',','!','?'] for palavra in lista_pal: if palavra[ ‑1] in especiais:

(cont.)

245

PROGRAMAÇÃO EM PYTHON

(cont.)

palavra = palavra[: ‑1] comp = len(palavra) if comp: dic[comp] = dic.get(comp,[]) + [palavra] return dic

8 9 10 11 12

Note‑se o uso de uma lista na qual guardamos carateres especiais que não devem fazer parte da palavra. Veja‑se ainda o teste ao comprimento: se um símbolo estiver isolado, ao ser retirado passa a ser uma cadeia sem carateres e não deve ser incluída. Finalmente, uma solução em que as palavras repetidas só são incluídas uma vez. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

def fich_dic_c(ficheiro): especiais = ['\n','.',',','!','?'] f_in = open(ficheiro, 'r') lista_pal = f_in.read().split() # Filtra lista_final = [] for palavra in lista_pal: # Símbolos especiais fora if palavra in especiais: continue elif palavra[ ‑1] in especiais: palavra = palavra[: ‑1] # Repetições fora if palavra not in lista_final: lista_final.append(palavra) # Constrói dicionário dic = {} for palavra in lista_final: comp = len(palavra) dic[comp] = dic.get(comp,[]) + [palavra] return dic

7.9 OUTROS TIPOS DE FICHEIROS Em Python é possível manipular de modo simples informação guardada em ficheiros or‑ ganizados de modo específico. Vamos analisar dois módulos que permitem aumentar as capacidades da linguagem no que se refere a certos tipos de ficheiros.

7.9.1 CSV Como sabe, existem muitos módulos adicionais em Python.Um deles é o módulo csv, que permite a manipulação de ficheiros organizados por linhas e em que cada linha tem 246

VISÕES (II)

8.5.2 CINZENTOS Esta ideia de abstração pode ser ilustrada se agora pretendermos que uma imagem de colorida passe a estar em escala de cinzentos. Basta substituir, no programa principal, a função de transformação por uma que forma o valor na escala de cinzentos. A forma mais simples de o fazer é usar como valor de todos os canais a média dos valores na imagem original: cinza = 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

red + green + blue 3

import cImage def main_cinzento(imagem_ficheiro): """Constrói e visualiza a escala de cinzentos de uma imagem.""" # Obtém imagem imagem = cImage.FileImage(imagem_ficheiro) # Fabrica a escala de cinzentos imagem_nova = cinzento_imagem(imagem) # Define janela largura = imagem.getWidth() altura = imagem.getHeight() janela = cImage.ImageWin('Cinzento',2*largura, altura) # Visualiza imagem.draw(janela) imagem_nova.setPosition(largura+1,0) imagem_nova.draw(janela) # Termina janela.exitOnClick() def cinzento_imagem(imagem): """ Escala de cinzentos de uma imagem.""" largura = imagem.getWidth() altura = imagem.getHeight() imagem_nova = cImage.EmptyImage(largura,altura) # Percorre píxel a píxel for coluna in range(largura): for linha in range(altura): # Transforma pixel_original = imagem.getPixel(coluna,linha) novo_pixel = cinzento_pixel(pixel_original) imagem_nova.setPixel(coluna,linha,novo_pixel) return imagem_nova def cinzento_pixel(pixel):

(cont.)

275

PROGRAMAÇÃO EM PYTHON

(cont.)

""" Converte um píxel para escala de cinzentos.""" vermelho = pixel.getRed() verde = pixel.getGreen() azul = pixel.getBlue() int_media = (vermelho + verde + azul) // 3 novo_pixel = cImage.Pixel(int_media,int_media, int_media) return novo_pixel

35 36 37 38 39 40 41

Executando o código para a imagem da Figura 8.8 obtemos o resultado da Figura 8.10.

FIGURA 8.10 – ESCALA DE CINZENTOS (ver figura a cores no extratexto)

Esta solução simplifica um pouco o problema da escala de cinzentos, pois a visão humana tem uma perceção da luminância diferente e dependente do canal considerado (vermelho, verde e azul). O código que se segue calcula a média ponderada dos três canais. 1 2 3 4 5 6

def cinzento_pixel(pixel): """ Converte um píxel para escala de cinzentos tendo em atenção a diferença dos canais.""" vermelho = pixel.getRed() verde = pixel.getGreen() azul = pixel.getBlue()

7 8 9

int_media = int(0.299*vermelho + 0.587*verde + 0.114*azul)// 3 novo_pixel = cImage.Pixel(int_media,int_media, int_media) return novo_pixel

Usando esta versão obtemos uma imagem em escala de cinzento, como se pode ver na Figura 8.11.

276

RECURSIVIDADE

9.2 EXEMPLOS 9.2.1 NÚMEROS Um exemplo clássico de recursividade é a função fatorial. Por definição, temos: n=0 1 n! =  × − n ( n 1)! n>0  A partir dela construímos o programa da Listagem 9.3. 1 2 3 4 5 6

# Fatorial def fact(n): if n == 0: return 1 else: return n * fact(n -1) LISTAGEM 9.3 – FATORIAL

Não pensamos haver muito mais a dizer sobre esta tradução da definição no programa que calcula o fatorial de qualquer número natural. Também aqui admitimos que somos capazes de resolver o subproblema semelhante mais simples para o argumento (n − 1). No entanto, importa clarificar como e porque é que funciona. Os programas recursivos desdobram-se em duas fases. Vejamos com um exemplo concreto. Admitamos que queríamos calcular o fatorial de 4. Chamada a função fact, com n = 4, e porque 4 é diferente de 0, o resultado vai ser o que for devolvido pela chamada recursiva de fact(n − 1) = fact(3), depois de multiplicado por 4. Este processo repete-se até que se chega ao caso de base, quando pretendemos saber o valor do fatorial de 0 e este é dado diretamente. Assim termina a primeira fase, denominada desenrolar6. A Figura 9.6 pretende dar uma ideia do processo. 4*

fact(4)

fact(3)

fact(2)

fact(1)

fact(0)

FIGURA 9.6 – FATORIAL: FASE DE DESENROLAR 6

Do inglês unfold. © FCA – EDITORA DE INFORMÁTICA

309

PROGRAMAÇÃO EM PYTHON Como já foi referido, e a Figura 9.6 ilustra, há um conjunto de cálculos que ficaram em suspenso e agora precisam de ser concluídos. Entramos na segunda fase do processo, denominada enrolar7. Nesta fase, os resultados parciais vão sendo passados para cima, i. e., a quem pediu o resultado, e os valores calculados. Assim, o valor do fatorial de 0, calculado diretamente, é transmitido à chamada fact(1), que esperava por esse valor para o multiplicar por 1. Esse resultado é, por sua vez, transmitido para fact(2), que estava à sua espera para multiplicar por 2, e assim sucessivamente. No final, obtemos o valor pretendido, ou seja, 24. A Figura 9.7 tenta ilustrar o processo. 24

fact(4)

4*6

fact(3)

3*2

fact(2)

fact(1)

fact(0)

2*1

1*1

FIGURA 9.7 – FATORIAL: FASE DE ENROLAR

Antes de prosseguir, podemos já fazer uma pequena síntese. A recursividade caracteriza-se por:

■■

Decompor o problema em subproblemas;

■■

Um (ou mais) dos subproblemas poderem ser resolvidos diretamente (caso(s) de base);

■■

Um (ou mais) dos subproblemas serem semelhantes ao problema inicial (caso(s) recursivo(s));

■■

Os problemas semelhantes deverem ser tais que nos façam aproximar do(s) caso(s) de base;

■■

Um processo de desenrolar, seguido por um de enrolar.

Do inglês fold.

310

COMPLEMENTOS

CADEIAS DE CARATERES DE COMENTÁRIOS Todas as cadeias de carateres que aparecem associadas a um objeto antes de qualquer códigoa executável são conhecidas por cadeias de carateres de documentação e são tratadas automaticamente pelos sistemas de documentaçãoa, como o PyDoc. Por exemplo, imaginemos que temos o seguinte ficheiro: 1 2 3 4 5 6 7 8 9 10 11 12

""" Para testar a documentação. minha_doc.py """ ̶̶author̶̶= 'Ernesto Costa' ̶̶version̶̶= 'June 2013' def toto(n):

""" Imprime o dobro de n.""" print(2 * n)

13 14 15 16 17

if ̶̶name̶̶ == '̶̶main̶̶':

toto(5)

Suponhamos que lançamos o interpretador de Python e importamos o módulo. Veja-se o que acontece. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

>>> import minha_doc >>> print(minha_doc.

doc

)

Para testar a documentação. minha_doc.py >>> help(minha_doc) Help on module minha_doc: NAME

minha_doc - Para testar a documentação.

DESCRIPTION minha_doc.py FUNCTIONS toto(n)

(cont.)

345

PROGRAMAÇÃO EM PYTHON

(cont.)

Imprime o dobro de n.

19 20 21 22 23 24 25 26

AUTHOR Ernesto Costa FILE

/Users/ernestojfcosta/minha_doc.py

27 28 29

>>> print(minha_doc.toto.̶̶doc̶̶) Imprime o dobro de n.

O comentário associado ao ficheiro está guardado no atributo ̶̶doc̶̶. Ao usarmos o comando help(), chamamos automaticamente a ferramenta PyDoc, que lê o ficheiro, extrai dele informação relevante e apresenta-a de modo organizado. Podemos obter também a documentação de outros objetos existentes num ficheiro e que tenham uma cadeia de carateres de documentação, como se exemplifica para o caso da função toto. a

Em inglês docstrings.

10.2 AMBIENTE E ALCANCE DAS VARIÁVEIS Se há tema que já referimos muitas vezes é o de, em Python, tudo serem objetos: números, cadeias de carateres, tuplos, listas e dicionários. Mas também ficheiros, módulos e definições. Tudo. Em geral, esses objetos têm um ou mais nomes associados, que nos permitem aceder ao objeto e aos seus atributos. Acontece que, quando corremos um programa a partir do terminal ou através de um IDE (Ambiente Integrado de Desenvolvimento), ou quando interagimos com o interpretador, pode ser criada, alterada ou mesmo destruída uma associação entre os nomes e os objetos. Assim, é preciso saber, sempre que encontramos um nome, a que objeto se refere e quais os seus atributos. Os nomes existentes encontram-se agrupados em espaços de nomes. Existe um espaço de nomes no qual se encontram os nomes dos objetos predefinidos pelo sistema, denominado builtins. São também criados espaços de nomes quando importamos um módulo ou quando chamamos uma definição. Existe uma relação hierárquica entre estas três categorias de espaços de nomes, como a Figura 10.2 pretende ilustrar.

346

11 DESENVOLVIMENTO Um programador é também um arquiteto, um compositor ou um escritor. São pessoas criativas que começam com ideias nas suas cabeças e folhas de papel em branco. Mathias Felleises

OBJETIVOS ■■

Rever diferentes aspetos da linguagem Python.

■■

Introduzir noções básicas de complexidade algorítmica.

■■

Discutir diferentes maneiras de abordar o problema da correção dos programas.

■■

Apresentar princípios de construção de programas.

11.1 INTRODUÇÃO A atividade de programação está a meio caminho entre a ciência e a arte. Ciência, porque exige disciplina e rigor; arte, porque motiva para (e potencia) a atividade criativa. Para uns, um programador é como um escultor que, passo a passo, transforma uma pedra numa estátua esbelta. Para outros, o programador é alguém que brinca com blocos de diferentes formas e funcionalidades como se fossem peças de Lego®. Realmente, programar não é fácil. Temos de aplicar simultaneamente conhecimentos sobre o domínio do problema, a linguagem de programação a usar e o processo de construção da solução. Mas toda esta complexidade pode ser dominada. Neste capítulo vamos estar concentrados na forma como se pode usar este conhecimento diverso para desenvolver programas com qualidade, que pode ser medida através da verificação de um conjunto preciso de características. No final do processo de desenvolvimento de um programa queremos que estes estejam corretos, sejam de fácil leitura, fáceis de manter perante a mudança, simples e que exijam poucos recursos (espaço de memória, tempo de computação). Grande parte das vezes, estes objetivos são contraditórios entre si. Por exemplo, acontece com frequência que a legibilidade do código tenha de ser sacrificada em detrimento da eficiência. A única coisa de que não se pode abdicar é da… correção. Iremos ilustrar boas práticas de programação partindo de um ponto de vista pragmático, ou seja, através de exemplos. Começaremos por questões de análise, primeiro de complexidade e depois de correção, para de seguida nos preocuparmos com os aspetos de síntese dos programas, tendo em vista a clareza, a simplicidade e aspetos de manutenção. © FCA – EDITORA DE INFORMÁTICA

409

PROGRAMAÇÃO EM PYTHON

11.2 COMPLEXIDADE Todos sabemos que os computadores estão cada vez mais potentes, no número de processadores que utilizam, no número de núcleos por processador, na velocidade dos processadores, no recurso às placas gráficas, na memória externa disponível. Mas se isso é verdade, também é verdade que continuam a existir problemas que não têm solução algorítmica, ou seja, para os quais não existe um programa de computador que forneça sempre a resposta correta para todas as entradas possíveis, mesmo quando pode utilizar tempo e espaço potencialmente infinitos. Um exemplo clássico de um problema dito não computável é conhecido pelo problema da paragem de uma máquina de Turing. Uma máquina de Turing é um modelo abstrato de computador que serviu para definir o conjunto das funções computáveis, isto é, em termos práticos, serve para identificar os problemas que podem ser resolvidos por um computador. O problema referido consiste em saber se, dada uma máquina de Turing arbitrária e uma entrada, também ela arbitrária, a máquina para para essa entrada. Existem também problemas que, sendo em teoria computáveis, na prática, no entanto, não o são. Os programas que hoje existem para jogar xadrez baseados em técnicas de inteligência artificial baseiam-se na ideia de construir uma árvore de decisão em que em cada nó está uma configuração do tabuleiro num dado momento do jogo. Como em cada instante o número de jogadas alternativas é finito, em teoria, é possível conceber um programa perfeito para jogar xadrez1. No entanto, esse programa demoraria milhares de anos a tomar a sua primeira decisão. Mesmo quando nos concentramos em problemas cuja solução algorítmica pode ser implementada através de programas que usam recursos aceitáveis e respondem em tempo razoável, importa saber qual é o melhor. Vejamos um exemplo muito simples. O problema consiste em determinar se numa lista de inteiros positivos existe, pelo menos, um deles que aparece repetido. Apresentamos de seguida duas soluções alternativas. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def duplicados_1(lista): """ Procura a existência de pelo menos um par de números duplicados numa lista de inteiros positivos. """ tamanho = len(lista) for i in range(tamanho-1): for j in range(i+1,tamanho): if lista[i] == lista[j]: return True return False def duplicados_2(lista): """ Procura a existência de pelo menos um par de números duplicados

(cont.)

Lembre-se de que na definição de computável se admite que o programa dispõe de tempo e de espaço potencialmente infinitos.

410

TIPOS E CLASSES

pop

push

top

FIGURA 12.1 – UMA PILHA

PILHA VAZIA As exceções levantadas devido ao modo como tratamos os erros no acesso à pilha podem ser resolvidas de um modo semelhante através, precisamente, da definição de uma exceção. Desta forma, a mensagem enviada ao utilizador fica mais personalizada. Para tal, definimos a exceção para o caso específico de a pilha estar vazia. 1 2 3

class EmptyStack(Exception):

"""Tentativa de aceder a um contentor vazio...""" pass

Definida a exceção, só precisamos de alterar, dentro da classe pilha, os métodos que fazem o teste de pilha vazia. 1 2 3 4 5 6 7 8 9 10

def pop(self):

if self.is_empty():

raise EmptyStack('ERRO: acesso e modificação de uma pilha

vazia!')

return self.stack.pop() def top(self):

if self.is_empty():

raise EmptyStack('ERRO: Consulta de uma pilha

else: vazia!')

return self.stack[-1]

467

PROGRAMAÇÃO EM PYTHON

TDA Os tipos de dados abstratos podem ser definidos de modo formal, definindo os objetos primitivos, a assinatura das operações e as propriedades verificadas por objetos e operações recorrendo a equações. Por exemplo, podemos usar as equações: pop(empty) = error pop(push(s, x)) = s A primeira equação axiomatiza o facto de não se poder retirar um elemento de uma pilha vazia, enquanto que a segunda define o significado de introduzir (push) e retirar (pop) um elemento de uma pilha não vazia. O tratamento formal dos tipos de dados abstratos é um assunto que está fora do âmbito deste livro de introdução à programação.

Nem sempre é trivial saber que operações associar à classe. Por exemplo, uma operação sobre pilhas que podemos considerar é a que determina o seu tamanho. Podemos defini-la fora da classe: 1 2 3 4 5 6 7

def size(pilha): aux = deepcopy(pilha) if aux.is_empty(): return 0 else: aux.pop() return 1 + size(aux)

Optámos por uma definição recursiva. Mas também a podemos definir dentro da classe: def len(self): return self.stack.̶̶len̶̶()

1 2

Como se verifica, usámos o método especial ̶̶len̶̶. Estes dois modos de proceder ilustram a diferença entre conhecer ou não conhecer a representação. Se quisermos visualizar uma pilha podemos usar print. Acontece, porém, que o resultado não é muito agradável. Vamos supor que criamos uma pilha e nela introduzimos dois elementos. Quando mandamos imprimir, o que vemos é um descritor do objeto e não o seu conteúdo: 1 2 3 4 5

if ̶̶name̶̶ == '̶̶main̶̶': p_1 = Stack() p_1.push('A') p_1.push('B') print(p_1) # Resultado ---- > 0x104ff5200>

< main .Stack instance at

Podemos alterar isso usando, mais uma vez, métodos especiais para acrescentar à classe o modo como queremos visualizar o conteúdo.

468

PROGRAMAÇÃO ORIENTADA AOS OBJETOS

13.6.1.2 MÁQUINA MULTIBANCO Um outro exemplo simples envolve o modelo de uma máquina multibanco (Figura 13.9). Uma máquina multibanco é formada por várias componentes que interagem diretamente com o utilizador. A máquina usa um banco e conta bancárias, que, por sua vez, podem ser de vários tipos. Trata-se de um digrama ultrassimplificado, pois esquece as funcionalidades das máquinas multibanco e também não detalha o que é um banco e o comportamento das conta bancárias. Painel utilizador

Visualizador

Abertura dinheiro

Leitor cartões

1 Banco

Máquina multibanco

* Conta

Poupança

Ordem

FIGURA 13.9 – MÁQUINA MULTIBANCO

13.7 EXEMPLO: MUNDOS E ROBÔS Suponhamos um mundo com a forma de uma grelha quadrada. Nesse mundo podem habitar robôs que deambulam pelo mundo. Pretendemos desenvolver uma aplicação que nos permita simular este universo. Uma análise simples mostra-nos que existem dois tipos de objetos, mundos e robôs, cada um deles originando uma classe. O mundo pode então ser habitado por zero ou mais rôbos, pelo que podemos descrever a situação através de um diagrama de classes bastante simples (Figura 13.10). Mundo

0..*

Robô

FIGURA 13.10 – RELAÇÃO ENTRE O MUNDO E O ROBÔ

Passemos a uma análise mais fina para ambas as classes e a sua relação. O mundo vai ter um tamanho e será composto por células, cada uma delas eventualmente ocupada por © FCA – EDITORA DE INFORMÁTICA

517

PROGRAMAÇÃO EM PYTHON um robô. Os robôs, por seu turno, vão ter um nome e vão habitar o mundo, mantendo-se numa das suas células. Os robôs têm apenas uma visão local do mundo, um subconjunto das células à sua volta que define a sua vizinhança (Figura 13.11). Coloca-se aqui a questão de saber onde guardar a informação sobre a posição. Várias opções existem, pois essa informação pode estar definida no robô, no mundo ou em ambos. É claro que o robô precisa de saber qual é a sua posição no mundo, e este precisa de saber quem o habita e onde. A decisão que tomarmos tem influência na implementação. Vamos optar por manter essa informação explícita no robô e implícita no mundo. Assim, sempre que um robô é criado, a sua posição é dada explicitamente e ele é associado a uma posição do mundo através de uma operação de registo. Chegamos, assim, a uma primeira aproximação à nossa solução, que a Figura 13.12 ilustra.

FIGURA 13.11 – O MUNDO, UM ROBÔ E A SUA VIZINHANÇA

A partir desta descrição podemos avançar para uma primeira implementação. 1 2

class Mundo: def ̶̶init̶̶(self, tamanho): self._tamanho = tamanho self._grelha = [['*'] * tamanho for i in range(tamanho)]

3 4 5 6

def mostra_mundo(self): for i in range(self._tamanho): linha = self._grelha[i] for j in range(self._tamanho): print('%-6s'% linha[j] + ' print() print()

7 8 9 10 11 12 13 14

def regista(self, robo): x,y = robo.obtem_posicao()

15 16

518

', end='')

(cont.)

INTERFACES GRÁFICAS COM O UTILIZADOR

Inicialização

Eventos

Ações Gestor de eventos

Processamento

Terminação

FIGURA 14.2 – PROGRAMAÇÃO GUIADA POR EVENTOS

No exemplo do livro de endereços podíamos construir uma interface como a da Figura 14.3.

FIGURA 14.3 – INTERFACE PARA LIVRO DE ENDEREÇOS

Sempre que é introduzida informação num dos campos, é desencadeada uma ação5. Desde logo, uma vantagem deste tipo de programação está na liberdade de introduzir os dados pela ordem que se quiser, mas são muito mais os lados positivos, como veremos de seguida, quando confrontados com exemplos mais complexos. Não se pense que a programação guiada por eventos apenas se manifesta na construção de interfaces gráficas. Muito longe disso. Por exemplo, sempre que lidamos com o sistema operativo do nosso computador (Linux, Mac OS X, Windows), estamos a basear-nos em PGE: quando movemos uma janela para cima de uma parte de outra, é preciso redesenhar tudo. Também poderíamos ter referido exemplos de programação para a Internet ou de computação distribuída. A computação guiada por eventos tem uma presença ubíqua em programação. Neste capítulo estaremos concentrados na construção de GUI usando o módulo tkinter, que vem pré-instalado com a linguagem. Existem outras ferramentas de desenvolvimento 5

537

PROGRAMAÇÃO EM PYTHON de GUI em Python, como o wxPython, o PyQt ou o pyGTK. No momento em que escrevemos, apenas tkinter e PyQt estão disponíveis para Python 3. A apresentação não será exaustiva, devendo o leitor interessado consultar a documentação sobre o módulo ou uma obra como a de Grayson (2000).

14.2 TKINTER O módulo tkinter funciona com base em princípios simples: o utilizador começa por definir uma janela principal, na qual vão ser colocados um conjunto de elementos ou widgets 6. Esses elementos são colocados de acordo com uma certa disposição7, definindo globalmente o que o utilizador vê. Alguns desses elementos são contentores para outros elementos, definido-se assim uma estrutura hierárquica, em árvore. Existem elementos sensíveis a eventos, que estão ligados8 a determinadas ações a executar. Construída a interface, é por fim chamado o ciclo de gestão de eventos. A nossa aplicação termina quando é desencadeado um evento que “mata”9 a janela principal. Vejamos algumas situações simples. O caso mais simples em que conseguimos pensar é o seguinte: 1 2 3 4

from tkinter import *

# Importa o módulo

raiz = Tk() # Cria a janela principal raiz.mainloop() # Chama o ciclo de gestão de eventos

Como se pode observar, depois de importar o módulo, criamos a janela principal, um objeto da classe Tk, e chamamos o ciclo de gestão de eventos, mainloop. Não são colocadas nenhumas componentes na janela principal, pelo que, quando o código é executado, limitamo-nos a ver uma janela como a da Figura 14.4. Note-se o modo como importámos o módulo. Esta forma não é, em geral, a melhor opção, como já foi explicado anteriormente. No entanto, quando se trata de desenvolver uma GUI com alguma complexidade, justifica-se o uso desta forma.

FIGURA 14.4 – UMA SIMPLES JANELA...

Há quem diga que o nome widget deriva da compressão das palavras windows gadget. Do inglês layout. 8 Do inglês bind. 9 Usamos o termo “matar” para significar o fim do processo que está associado à janela. 6 7

538

A INSTALAR PYTHON

A.1 VERIFICAR Se tem um computador com o sistema operativo Mac OS X ou com Linux, é possível que já tenha uma versão de Python instalada. Por exemplo, se tiver um computador com Linux instalado, abra uma janela da aplicação Terminal, escreva which python seguido da tecla return1 e veja o resultado. Pode também ficar a saber qual é a versão instalada com o comando python -V. O que vai ver depende do que tem instalado. Neste caso, ficamos a saber que está instalado e que se trata da versão 2.7.6 (Figura A.1).

FIGURA A.1 – TENHO PYTHON

O mesmo procedimento pode ser usado num ambiente Mac OS X. Já no que diz respeito ao ambiente Windows, o normal é que não tenha um interpretador da linguagem instalado. Vamos então ver como podemos instalar, para qualquer ambiente, uma versão atual de Python.

Daqui em diante omitiremos a referência à necessidade de terminar os comandos com o uso desta tecla. © FCA – EDITORA DE INFORMÁTICA

579

9cm x 24cm

16,7cm x 24cm

33,5mm

16,7cm x 24cm

9cm x 24cm

Ernesto Costa

CMY

Conheça a organização e os mecanismos mais sofisticados de um sistema operativo e perceba como este gere e coordena o seu computador. Com exemplos em Unix (e variantes, Linux e Mac OS) e Windows.

O livro inclui vários exemplos já resolvidos, sumários da matéria abordada e exercícios teóricos e práticos.

Principais temas abordados no livro:

ISBN 978-972-722-816-4

9 789727 228164

Soluções dos exercícios e outros materiais adicionais disponíveis em www.fca.pt, até o livro se esgotar ou ser publicada nova edição atualizada ou com alterações.