Práticas de Python: Algoritmia e Programação by Grupo Lidel

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

D istribuiçã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 livraria@lidel.pt Copyright © 2021, FCA – Editora de Informática, Lda. ISBN edição impressa: 978-972-722-918-5 1.ª edição impressa: março de 2021 Paginação: Carlos Mendes Imagem de entrada de capítulo: © python by Icons Producer from the Noun Project Impressão e acabamento: Cafilesa – Soluções Gráficas, Lda. – Venda do Pinheiro Depósito Legal n.º 481316/21 Capa: José M. Ferrão – Look-Ahead 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 Sobre a Autora................................................................................................................. XI Prólogo............................................................................................................................. XIII Capítulo 1

Operações Básicas com Dados e Variáveis

Exercício 1.1 – Escrita de mensagem.................................................................... 2 Exercício 1.2 – Escrita de mensagem com carateres acentuados ........................ 2 Exercício 1.3 – Atribuição de mensagem a variável............................................... 2 Exercício 1.4 – Atribuição múltipla......................................................................... 3 Exercício 1.5 – Mensagem com intercalação de variáveis..................................... 3 Exercício 1.6 – Alinhamentos de mensagem.......................................................... 4 Exercício 1.7 – Mais alinhamentos......................................................................... 4 Exercício 1.8 – Operações aritméticas................................................................... 5 Exercício 1.9 – Funções matemáticas.................................................................... 6 Exercício 1.10 – Operações lógicas....................................................................... 6 Exercício 1.11 – Operações com alfanuméricos.................................................... 7 Exercício 1.12 – Operadores de atribuição compostos (1).................................... 8 Exercício 1.13 – Operadores de atribuição compostos (2).................................... 9 Exercício 1.14 – Conversões de inteiros, reais, alfanuméricos e datas................. 9 Exercício 1.15 – Conversão de alfanuméricos e inteiros........................................ 10 Exercício 1.16 – Enumerações............................................................................... 11 Exercício 1.17 – Formatos para arredondamentos................................................ 11

Exercício 1.18 – Formatos para percentagens....................................................... 12 Exercício 1.19 – Formatos parametrizados para arredondamentos...................... 13 Exercício 1.20 – Formatos para data e hora correntes.......................................... 13 III

Práticas de Python: Algoritmia e Programação

Exercício 1.21 – Mais formatos.............................................................................. 14 Exercício 1.22 – Leitura de dados alfanuméricos................................................... 15 Exercício 1.23 – Leitura de dados numéricos........................................................ 15 Exercício 1.24 – Leitura de datas cronológicas...................................................... 15 Exercício 1.25 – Leitura de dados lógicos.............................................................. 16 Capítulo 2

Estruturas de Controlo de Execução

2.1. Estruturas sequenciais................................................................................... 17 2.2. Estruturas condicionais.................................................................................. 17 2.2.1. Estruturas de decisão........................................................................ 18 2.2.2. Estruturas de escolha múltipla.......................................................... 19 2.3. Estruturas repetitivas..................................................................................... 19 2.3.1. Estruturas repetitivas controladas por contador automático............ 20 2.3.2. Estruturas repetitivas condicionais.................................................... 21 Exercício 2.1 – Autor, título e ano de publicação................................................... 22 Exercício 2.2 – Capital acumulado......................................................................... 23 Exercício 2.3 – Função matemática....................................................................... 24 Exercício 2.4 – Despesa diária média..................................................................... 25 Exercício 2.5 – Salário de vendedor....................................................................... 26 Exercício 2.6 – Datas da Páscoa............................................................................ 27 Exercício 2.7 – Maior de dois................................................................................. 29 Exercício 2.8 – Bom dia ou boa tarde.................................................................... 30 Exercício 2.9 – Maior de dois porventura iguais..................................................... 31 Exercício 2.10 – Raízes de uma equação de 2.º grau............................................ 32 Exercício 2.11 – Maior de três................................................................................ 33 Exercício 2.12 – Expressão condicional................................................................. 35 Exercício 2.13 – Reprovações, aprovações e distinções....................................... 36 Exercício 2.14 – Número de dias de cada mês...................................................... 37 Exercício 2.15 – Salário-base................................................................................. 38 Exercício 2.16 – Descontos para classes de produtos.......................................... 40 Exercício 2.17 – Mensagem repetida..................................................................... 41 Exercício 2.18 – Soma de N inteiros....................................................................... 42 Exercício 2.19 – Números ímpares......................................................................... 43 Exercício 2.20 – Retângulo..................................................................................... 44 IV

Índice

Exercício 2.21 – Quadrado..................................................................................... 46 Exercício 2.22 – Xis................................................................................................. 48 Exercício 2.23 – Árvore........................................................................................... 49 Exercício 2.24 – Série numérica............................................................................. 51 Exercício 2.25 – Fatorial......................................................................................... 53 Exercício 2.26 – Cubos de Nicomachus................................................................. 54 Exercício 2.27 – Números de Fibonacci................................................................. 55 Exercício 2.28 – Números perfeitos........................................................................ 57 Exercício 2.29 – Número primo.............................................................................. 58 Exercício 2.30 – Números maior e menor.............................................................. 60 Exercício 2.31 – Traçagem dos números maior e menor....................................... 62 Exercício 2.32 – Multiplicação russa...................................................................... 62 Exercício 2.33 – Máximo divisor comum................................................................ 64 Exercício 2.34 – Tabelamento de uma função para uma sequência de valores.... 66 Exercício 2.35 – Tabelamento de duas funções..................................................... 67 Exercício 2.36 – Capital acumulado....................................................................... 69 Exercício 2.37 – Anos de capitalização.................................................................. 71 Exercício 2.38 – Aumentos salariais....................................................................... 73 Exercício 2.39 – Pré-seleção de candidatos.......................................................... 76 Exercício 2.40 – Contagem de palavras................................................................. 78 Exercício 2.41 – Palíndromo................................................................................... 80 Capítulo 3

Listas e NumPy

Exercício 3.1 – Lista ordenada da equipa de um projeto....................................... 84 Exercício 3.2 – Lista ordenada por ordem decrescente de tamanho..................... 85 Exercício 3.3 – Várias operações com listas.......................................................... 86 Exercício 3.4 – Trocar cidade por Lisboa............................................................... 87 Exercício 3.5 – Lista de carateres........................................................................... 88 Exercício 3.6 – Leitura e escrita de lista com N elementos.................................... 89 Exercício 3.7 – Leitura e escrita de uma lista de vários elementos........................ 90 Exercício 3.8 – Média aritmética de uma lista de números reais........................... 92

Exercício 3.9 – Contagem de elementos e elementos maior e menor................... 93 Exercício 3.10 – Número de elementos da lista de um dado intervalo.................. 95 Exercício 3.11 – Equipas de três jogadores........................................................... 96 V

Práticas de Python: Algoritmia e Programação

Exercício 3.12 – Listas de vendedores sem repetidos........................................... 97 Exercício 3.13 – Equipas de jogadores com suplente............................................ 99 Exercício 3.14 – Remoção de elementos............................................................... 101 Exercício 3.15 – Pesquisa binária........................................................................... 102 Exercício 3.16 – Traçagem de pesquisa binária..................................................... 104 Exercício 3.17 – Listas em compreensão (1).......................................................... 105 Exercício 3.18 – Listas em compreensão (2).......................................................... 106 Exercício 3.19 – Listas em compreensão (3).......................................................... 106 Exercício 3.20 – Listas em compreensão (4).......................................................... 107 Exercício 3.21 – Listas em compreensão (5).......................................................... 108 Exercício 3.22 – Listas em compreensão (6).......................................................... 109 Exercício 3.23 – Listas de sublistas como matriz................................................... 110 Exercício 3.24 – Somatório de sublistas................................................................ 111 Exercício 3.25 – Formação de uma lista de sublistas............................................ 113 Exercício 3.26 – Lista única.................................................................................... 114 Exercício 3.27 – Operações com vetores e matrizes............................................. 115 Exercício 3.28 – Sistema de três equações lineares a três incógnitas................... 116 Exercício 3.29 – Alisar as linhas de uma matriz..................................................... 118 Exercício 3.30 – Fatias de matrizes........................................................................ 119 Exercício 3.31 – Aprovados em Informática........................................................... 120 Exercício 3.32 – Broadcasting de matrizes............................................................ 121 Capítulo 4

Tuplos, Dicionários e Conjuntos

123

Exercício 4.1 – Tuplo de funcionários com três campos ....................................... 124 Exercício 4.2 – Impressão de registos dos funcionários ....................................... 125 Exercício 4.3 – Contagem de funcionários de certas categorias........................... 127 Exercício 4.4 – Empacotamento e desempacotamento de tuplos de clientes...... 128 Exercício 4.5 – Criar lista de tuplos de funcionários.............................................. 130 Exercício 4.6 – Escrita de lista de tuplos de clientes............................................. 132 Exercício 4.7 – Tuplo dos nomes, categorias e anos de antiguidade.................... 133 Exercício 4.8 – Tuplo com descrição e tamanho de peças de roupa..................... 135 Exercício 4.9 – Decomposição de volume de vendas............................................ 136 Exercício 4.10 – Somatório condicional do volume de vendas.............................. 137 Exercício 4.11 – Totais acumulados de compras................................................... 138 VI

Índice

Exercício 4.12 – Menus de pequeno-almoço......................................................... 140 Exercício 4.13 – Impressão dos menus de pequeno‑almoço................................ 141 Exercício 4.14 – Cafetaria....................................................................................... 141 Exercício 4.15 – Atualização de stocks.................................................................. 144 Exercício 4.16 – Produto de maior valor................................................................. 146 Exercício 4.17 – Três produtos com maior quantidade.......................................... 148 Exercício 4.18 – Valores dos produtos do dicionário............................................. 150 Exercício 4.19 – Dicionário de versos..................................................................... 151 Exercício 4.20 – Dicionário com as palavras usadas e as respetivas frequências. 153 Exercício 4.21 – Histograma de dicionário de contador de letras.......................... 157 Exercício 4.22 – Dicionário de produtos com tuplos.............................................. 159 Exercício 4.23 – Dicionário em compreensão........................................................ 160 Exercício 4.24 – Dicionário de pontuações............................................................ 161 Exercício 4.25 – Operações com conjuntos........................................................... 162 Exercício 4.26 – Conjuntos em compreensão........................................................ 163 Exercício 4.27 – Conjunto de letras distintas......................................................... 164 Exercício 4.28 – Possíveis outfits........................................................................... 165 Capítulo 5

Funções e Módulos

167

5.1. Funções......................................................................................................... 168 5.2. Estrutura de dados mutáveis e imutáveis e variáveis globais....................... 169 5.3. Argumentos por defeito, em número variável e nominais............................. 169 5.4. Módulos......................................................................................................... 170 5.5. Âmbito das funções....................................................................................... 170 Exercício 5.1 – Somatório de três números............................................................ 171 Exercício 5.2 – Maior e menor de três números..................................................... 172 Exercício 5.3 – Horas, minutos e segundos........................................................... 173 Exercício 5.4 – Raízes quadradas.......................................................................... 175 Exercício 5.5 – Escrita de listas de cidades........................................................... 176 Exercício 5.6 – Contagem de elementos................................................................ 177 Exercício 5.7 – Passagem de dados mutáveis e imutáveis.................................... 179

Exercício 5.8 – Efeitos indesejados........................................................................ 180 Exercício 5.9 – Correção dos efeitos indesejados................................................. 181 Exercício 5.10 – Ordenação de listas..................................................................... 182 VII

Práticas de Python: Algoritmia e Programação

Exercício 5.11 – Ordenação de matrizes................................................................ 184 Exercício 5.12 – Equipas de N jogadores............................................................... 186 Exercício 5.13 – Triângulo de Pascal...................................................................... 189 Exercício 5.14 – Quadrado mágico........................................................................ 191 Exercício 5.15 – Totais de linhas, colunas e diagonais........................................... 194 Exercício 5.16 – Totais com função anónima......................................................... 197 Exercício 5.17 – Valores das vendas...................................................................... 199 Exercício 5.18 – Teste de escolha múltipla (1)........................................................ 201 Exercício 5.19 – Teste de escolha múltipla (2)........................................................ 204 Exercício 5.20 – Jogo de Sudoku........................................................................... 205 Exercício 5.21 – Parâmetros com valores por defeito............................................ 212 Exercício 5.22 – Número variável de parâmetros................................................... 213 Exercício 5.23 – Desempacotamento de registos de pessoas.............................. 214 Exercício 5.24 – Argumentos com nomes.............................................................. 215 Exercício 5.25 – Ordem dos argumentos............................................................... 216 Exercício 5.26 – Execução de lista de funções...................................................... 218 Exercício 5.27 – Quadrados dos elementos de intervalo....................................... 219 Exercício 5.28 – Somatórios públicos.................................................................... 220 Exercício 5.29 – Somatório privado........................................................................ 221 Capítulo 6

Recorrência 223 Exercício 6.1 – Potências de 2............................................................................... 223 Exercício 6.2 – Contagem decrescente.................................................................. 225 Exercício 6.3 – Adição de N inteiros....................................................................... 226 Exercício 6.4 – Fatorial........................................................................................... 227 Exercício 6.5 – Números de Fibonacci................................................................... 228 Exercício 6.6 – Máximo divisor comum.................................................................. 229 Exercício 6.7 – Capitalização composta................................................................ 230 Exercício 6.8 – Somatório de termos de série........................................................ 231 Exercício 6.9 – Impressão de um quadrado........................................................... 233 Exercício 6.10 – Número primo.............................................................................. 234 Exercício 6.11 – Maior número de uma lista.......................................................... 236 Exercício 6.12 – Pesquisa linear............................................................................. 237 Exercício 6.13 – Pesquisa binária........................................................................... 238 VIII

Índice

Exercício 6.14 – Função de Ackermann................................................................. 240 Exercício 6.15 – Quadros de números................................................................... 241 Exercício 6.16 – Torres de Hanói............................................................................ 244 Exercício 6.17 – Palíndromo................................................................................... 246 Exercício 6.18 – Labirinto....................................................................................... 249 Capítulo 7

Classes, Subclasses e Objetos

255

7.1. Classes e objetos........................................................................................... 255 7.2. Variáveis de instante e variáveis estáticas..................................................... 256 7.3. Visibilidade das variáveis .............................................................................. 256 7.4. Métodos......................................................................................................... 257 7.4.1. Métodos de instante e métodos estáticos........................................ 257 7.5. Construtores.................................................................................................. 258 7.6. Acessos e propriedades................................................................................ 258 7.7. Herança.......................................................................................................... 259 7.8. Polimorfismo.................................................................................................. 260 Exercício 7.1 – Estudante de Informática............................................................... 261 Exercício 7.2 – Estudante de Informática com getters........................................... 262 Exercício 7.3 – Estudante de Informática com getters e setters............................ 263 Exercício 7.4 – Estudante de Informática com propriedades de acesso............... 264 Exercício 7.5 – Estudante de Informática com método de impressão................... 266 Exercício 7.6 – Estudante de Informática em módulo separado............................ 267 Exercício 7.7 – Pauta de alunos de Informática..................................................... 269 Exercício 7.8 – Situação dos alunos....................................................................... 269 Exercício 7.9 – Contagem do número de alunos................................................... 271 Exercício 7.10 – Temperaturas em Celsius e Fahrenheit........................................ 274 Exercício 7.11 – Aumento de preço unitário........................................................... 275 Exercício 7.12 – Hierarquia de classes................................................................... 277 Exercício 7.13 – Métodos de impressão para as três classes............................... 278 Exercício 7.14 – Hierarquia de propriedades......................................................... 280 Exercício 7.15 – Mais métodos para a hierarquia de propriedades....................... 282

Exercício 7.16 – Moradias com categorias............................................................ 285 Exercício 7.17 – Lista de moradias e apartamentos.............................................. 286 Exercício 7.18 – Hierarquia de quadrado e retângulo............................................ 287 IX

Práticas de Python: Algoritmia e Programação

Exercício 7.19 – Sobreposição dos métodos area................................................. 289 Exercício 7.20 – Diferentes regimes de avaliação.................................................. 290 Exercício 7.21 – Classe avo e subclasses filhos e netos......................................... 291 Exercício 7.22 – Aeroportos, companhias aéreas e voos...................................... 293 Exercício 7.23 – Classe de funções........................................................................ 295 Exercício 7.24 – Bolsa para formação e boa forma física...................................... 296 Exercício 7.25 – Atividades dos estudantes........................................................... 298 Exercício 7.26 – Equipas e jogadores.................................................................... 300 Exercício 7.27 – Menus de opções......................................................................... 302 Exercício 7.28 – Método abstrato para calcular valor............................................ 305 Exercício 7.29 – SNS e seguro de saúde............................................................... 307 Exercício 7.30 – Mais SNS e seguro de saúde....................................................... 309 Capítulo 8

Erros, Validações e Correções

311

Exercício 8.1 – Divisão por zero............................................................................. 312 Exercício 8.2 – Multiplicação com operadores numéricos..................................... 313 Exercício 8.3 – Cálculo do inverso de um inteiro................................................... 314 Exercício 8.4 – Cálculo de fatorial.......................................................................... 316 Exercício 8.5 – Validação de idades....................................................................... 317 Exercício 8.6 – Validação de categorias................................................................. 318 Exercício 8.7 – Impressão de lista.......................................................................... 320 Exercício 8.8 – Índice fora do limite superior......................................................... 321 Exercício 8.9 – Validação do mês de nascimento.................................................. 323 Exercício 8.10 – Validações encaixadas................................................................. 323 Exercício 8.11 – Validação de método de classe................................................... 325 Exercício 8.12 – Validação de lista de números..................................................... 327 Exercício 8.13 – Adivinhar um número................................................................... 328 Bibliografia....................................................................................................................... 331 Índice Remissivo............................................................................................................. 333

Prólogo A linguagem de programação Python, cujo nome foi inspirado pela série cómica Monty Python’s Flying Circus (BBC, 1969-1974), foi lançada em 1991 por Guido van Rossum do Stichting Mathematisch Centrum, Holanda, e tem, hoje, desenvolvimento em código-fonte aberto (open source) supervisionado pela Python Software Foundation. O Python é uma linguagem de programação imperativa, de alto nível e interpretada que serve adequadamente os dois paradigmas mais populares de programação: a programação estruturada e a programação orientada por objetos. Devido a estas caraterísticas, o Python é atualmente uma das linguagens mais utilizadas no ensino e aprendizagem de programação, constituindo o suporte das disciplinas de Introdução à Programação de vários cursos de licenciatura e mestrado. O Python não só permite a implementação dos princípios e das figuras algorítmicas e das estruturas de dados principais, mas também traz para o primeiro plano a indentação dos blocos de instruções, simplificando a sua sintaxe e tornando os programas mais legíveis. Enquanto noutras linguagens de programação a indentação é apenas aconselhada pela algoritmia, em Python ela é obrigatória para delimitar os blocos de instrução e impor a ordem de execução dos programas. Indentação é um vocábulo em português que deriva de indentation, em inglês, e significa avançar uma frase (instrução) um conjunto de espaços relativamente à margem esquerda do texto (programa). No exemplo seguinte, demonstra-se a instrução print, que começa quatro espaços depois da margem esquerda do programa. if __name__ == '__main__': print ("\n Bem-vindos ao Python!")

Esta obra, Exercícios de Python: Algoritmia e Programação, promove o estudo da linguagem de programação Python através da resolução algorítmica de diversos exercícios especialmente concebidos para ilustrar os princípios e as regras da programação estruturada e de iniciação à programação orientada por objetos.

A metodologia de resolução dos exercícios que adotámos – aproximação descendente ou top-down – para especificação do problema e implementação de uma solução pode decompor-se nas cinco etapas do diagrama apresentado na Figura 1.

XIII

Práticas de Python: Algoritmia e Programação

Desenho de uma solução

Problema

1. Top-down

Teste do programa

Desenvolvimento da solução

5. Execução de testes

2. Algoritmo em pseudocódigo

Codificação em Python

Teste do algoritmo

4. Programa

3. Traçagem

Figura 1 Etapas da especificação e implementação de um programa

A obra compõe-se de oito capítulos com os seguintes sumários (Quadro 1): Quadro 1 Sumário dos capítulos do livro 1. Operações básicas com 25 exercícios cuja resolução demonstra a utilização de operações de leitura, atribuição a variáveis e escrita de dados. dados e variáveis 2. Estruturas de controlo de execução

41 exercícios cuja resolução demonstra a utilização das estruturas sequenciais, condicionais e repetitivas.

3. Listas e NumPy

32 exercícios que demonstram as operações principais com listas de uma ou duas dimensões, assim como a utilização de índices para posicionar os elementos nas respetivas listas. Salienta-se a possibilidade de definirmos listas em extensão e em compreensão. Os restantes seis exercícios deste capítulo ilustram a utilização da biblioteca NumPy para realização de operações algébricas com vetores e matrizes.

4. Tuplos, dicionários e conjuntos

28 exercícios que demonstram as operações principais com tuplos, listas de tuplos, tuplos de tuplos, dicionários e dicionários com listas e tuplos. Os quatro últimos exercícios respeitam as operações comuns com conjuntos de dados.

5. Funções e módulos

29 exercícios que ilustram a implementação em Python da programação modular, dividindo os programas em funções que resolvem parcialmente os problemas e se integram, formando uma solução final. A resolução destes exercícios evidencia a necessária correspondência de argumentos e parâmetros e foca os aspetos excecionais de parâmetros com valores por defeito, argumentos em número variável e argumentos nominais. Trata-se também a execução de listas de funções, a passagem de funções e as funções anónimas. (continua)

XIV

Prólogo (continuação)

6. Recorrência

18 exercícios cuja resolução demonstra a definição e a invocação de funções recorrentes. A recorrência substitui os processos iterativos, evidenciando a simplicidade dos respetivos algoritmos.

7. Classes, subclasses e objetos

30 exercícios, cuja resolução demonstra a definição de classes, a instanciação de objetos, a definição de variáveis de instante e o desenvolvimento de construtores, de acessores e de outros métodos. Estes exercícios evidenciam a encapsulação e a herança da programação orientada por objetos.

8. Erros, validações e correções

13 exercícios que ilustram a deteção e correção de erros que ocorrem durante a introdução e o tratamento de dados. Dedicamos também atenção aos erros lançados pelo programador para implementar a validação dos dados.

O livro é dedicado à algoritmia e programação estruturada e faz uma introdução à programação orientada por objetos. Os exercícios apresentados são de dificuldade crescente e foram classificados segundo os tópicos fundamentais das disciplinas de Introdução à Programação e Programação I de cursos de licenciatura e de especialização em Engenharia, Economia, Gestão e Ciências. A resolução de cada exercício baseia-se na metodologia top-down e consiste na definição das estruturas de dados, na elaboração de um algoritmo apropriado, na elaboração do respetivo programa em Python e na sua verificação através da execução para dados apropriados. A resolução dos exercícios que ora propomos exige a instalação do interpretador Python 3.9.2 ou superior para o sistema operativo Windows, que está disponível para download gratuito em https://www.python.org/. E, para tornar mais agradável a digitação dos programas, precisamos de um Interface Development Environment (IDE) para o Python, por exemplo, o Pyzo, que está disponível gratuitamente em https://pyzo.org. Crê-se, e a minha experiência como professora confirma-o, que este livro poderá constituir um elemento de ensino/aprendizagem útil para docentes, estudantes, investigadores e profissionais de diversas áreas científicas, onde a programação seja uma disciplina nuclear ou um auxiliar essencial para a automatização de sistemas de tratamento de dados.

fevereiro de 2021 Adelaide Carvalho

1 Operações Básicas com Dados e Variáveis A leitura, a atribuição e a escrita de dados são as operações que permitem ler dados, guardá-los, processá-los e mostrar os resultados do processamento. A Figura 1.1 esquematiza as três componentes fundamentais de um programa de entrada-tratamento-saída de dados, fazendo-as corresponder às operações de leitura, atribuição a variáveis e escrita de dados. Saída de resultados

Entrada de dados Tratamento de dados ATRIBUIÇÃO

ESCRITA

LEITURA

Figura 1.1 Entrada-tratamento-saída de dados e respetivas operações de leitura, atribuição a variáveis e escrita de dados

As operações de leitura e de escrita de dados operam, respetivamente, a montante e a jusante do processamento de dados e, por conseguinte, envolvem os periféricos de entrada e de saída dos sistemas de computação. As operações de leitura referem-se à introdução de dados durante a execução do programa, fazendo com que os dados de entrada – inputs – sejam guardados em variáveis. As operações de atribuição permitem dar valores às variáveis e mudar-lhes, portanto, os valores correntes. Não podem ser confundidas com a igualdade.

As operações de escrita permitem escrever, no ecrã, na impressora ou noutro periférico de saída, os dados que resultam do processamento – outputs. Neste capítulo, apresentamos 25 exercícios, cuja resolução demonstra a utilização de operações de leitura, atribuição a variáveis e escrita de dados. Estes exercícios evidenciam a relevância de tipos de dados e de variáveis, conversão de tipos, operações aritméticas, operações lógicas, operações alfanuméricas, expressões de computação e formatos de saída.

Práticas de Python: Algoritmia e Programação

Exercício 1.1 Escrita de mensagem Elabore um programa que imprima a mensagem “Bem-vindos ao Python!”, precedida por uma linha em branco.

Programa principal if __name__ == '__main__': print ("\n Bem-vindos ao Python!")

EXECUÇÃO Bem-vindos ao Python!

Exercício 1.2 Escrita de mensagem com carateres acentuados Elabore um programa que imprima a mensagem “José, bem-vindo ao Python!”, precedida por uma linha em branco.

Programa principal #!/usr/bin/env python # -*- coding: UTF-8 -* if __name__ == '__main__': print ("\n José, bem-vindo ao Python!")

EXECUÇÃO José, bem-vindo ao Python!

Exercício 1.3 Atribuição de mensagem a variável Elabore um programa que atribua a mensagem a uma variável e, em seguida, imprima o valor da variável.

2 Estruturas de Controlo de Execução Neste capítulo, apresentamos as três categorias de estruturas de controlo de execução – sequenciais, condicionais e repetitivas – e a implementação das mesmas em Python. Estas estruturas permitem-nos aceitar a execução sequencial das instruções que é supletiva ou definir outra ordem de execução, impondo a satisfação de condições ou definindo ciclos repetitivos.

2.1. Estruturas sequenciais As estruturas sequenciais são conjuntos de instruções que são executadas desde a primeira até à última, pela ordem em que se apresentam no programa. A execução é, portanto, sequencial. O excerto de código abaixo mostra a representação em pseudocódigo de estruturas sequenciais. Instrução Instrução Instrução …. Instrução

1 2 3 n

Os programas mais simples usam apenas estruturas sequenciais para implementar as três componentes em que se decompõem: • Entrada de dados – instruções de leitura de dados em Python; • Tratamento de dados – instruções de atribuição de dados em Python; • Saída de dados – instruções de escrita de dados em Python.

2.2. Estruturas condicionais

As estruturas condicionais consistem, genericamente, em dois grupos de instruções cuja execução depende da avaliação de um conjunto de condições. Assim, há um grupo de instruções que é executado se o conjunto de condições for verdadeiro, e outro se esse conjunto de condições for falso.

Práticas de Python: Algoritmia e Programação

As estruturas condicionais podem ser estruturas de decisão ou estruturas de escolha múltipla. Ambas podem apresentar-se encaixadas noutras estruturas condicionais.

2.2.1. Estruturas de decisão As estruturas de decisão permitem escolher um de dois conjuntos de instruções alternativos, mediante a avaliação de uma expressão lógica. O fluxograma da Figura 2.1 mostra os dois conjuntos de instruções alternativos das estruturas de decisão. Instruções diversas

Verdadeira

Falsa

Condição

Instruções a executar se a condição for verdadeira

Instruções a executar se a condição for falsa

Instruções restantes

Figura 2.1 Fluxograma da estrutura de decisão

Salienta-se o caso particular em que o conjunto de instruções a executar, se a condição for falsa, é vazio. Em Pyhton, a estrutura de decisão tem as seguintes sintaxes: if condição1: Instruções do ramo verdadeiro else: Instruções do ramo falso if condição1: Instruções do ramo verdadeiro da condição 1 elif condição2: Instruções do ramo falso da condição 1 e verdadeiro da condição 2 elif condição3: …….. else: Instruções do ramo falso das condições anteriores

3 Listas e NumPy Os diversos tipos de dados primitivos podem agregar-se em estruturas mais complexas para simplificar o processamento algorítmico e facilitar a compreensão das soluções escolhidas para os problemas. Entre essas estruturas, destacam-se, em Python, as listas que são conjuntos lineares de dados. Os elementos das listas podem ser tratados individualmente ou como coleções de dados. As listas são identificadas pelos respetivos nomes e os seus elementos são identificados individualmente através do nome da lista seguido do índice, ou seja, a posição que o elemento ocupa no conjunto. Subconjuntos de elementos podem também ser identificados pelo nome da lista a que pertencem, seguidos de intervalos de índices. O primeiro elemento de uma lista tem índice zero. O excerto de código seguinte exemplifica a identificação de listas e seus elementos em Python. L=[4,6,9,11,12,34,89,120] L[3] identifica o 4.º elemento de L, isto é, o elemento com índice 3 L[3:7] identifica os elementos de L com índices 3, 4, 5 e 6

Os elementos das listas podem ser outras listas. Estas são sublistas daquelas. As sublistas podem ainda conter outras sublistas. O excerto de código seguinte mostra listas que contêm sublistas. L=[[4,[6,9],20],11,12,[34,89],120] L[0] identifica a sublista [4,[6,9],20] L[0][2] identifica o elemento 20 L[0][1][1] identifica o elemento 9

As listas são, também, mutáveis, isto é, os seus elementos podem ser alterados por operações de atribuição, por exemplo, L[0][1][1]=90.

O Python disponibiliza a biblioteca NumPy com um conjunto de classes, variáveis de instante e métodos e funções que facilitam o cálculo algébrico com vetores e matrizes de várias dimensões. Neste capítulo, apresentamos 26 exercícios que demonstram a inicialização, formação e manipulação de listas. A resolução destes exercícios ilustra as operações principais com listas de uma ou duas dimensões, assim como a utilização de índices para posicionar os elementos nas respetivas listas. Salienta-se a possibilidade de definirmos listas em extensão e em compreensão. 83

Práticas de Python: Algoritmia e Programação

Os restantes seis exercícios deste capítulo ilustram a utilização da biblioteca NumPy para realização de operações algébricas com vetores e matrizes.

Exercício 3.1 Lista ordenada da equipa de um projeto Elabore um programa que imprima os nomes da equipa de um projeto, ordenados por ordem inversa à alfabética.

Top-down 1. Formar uma lista com os nomes dos membros da equipa de um projeto 2. Ordenar a lista por ordem inversa à alfabética 3. Imprimir cada elemento da lista

Variáveis Variável

Tipo

Significado

Alfanumérica

Nome de cada membro da equipa

Equipa

Lista

Lista dos nomes dos membros da equipa

Algoritmo ListaOrdemInversa Equipa=["António", "Ana", "Teresa", "Telmo", "João", "Guilherme", "Luís"] Equipa.ordenar(ordem=inversa) Para cada E da Equipa Escrever(E) FimPara

Programa principal # -*- coding: utf-8 -* if __name__ == '__main__': Equipa = ["António", "Ana", "Teresa", "Telmo", "João", "Guilherme", "Luís"] Equipa.sort(reverse=True) for E in Equipa: print (E)

EXECUÇÃO Teresa Telmo Luís

4 Tuplos, Dicionários e Conjuntos Tuplos, dicionários e conjuntos são estruturas de dados mais complexas dotadas de funcionalidades predefinidas que facilitam a implementação em Python de soluções algorítmicas que implicam agrupamento e organização de dados. Os tuplos agrupam vários dados que se relacionam, nomeadamente dados que se referem a uma entidade. Os dados podem ser heterogéneos quanto ao tipo. Por exemplo, um tuplo de produto pode agrupar o código numérico inteiro de um produto, a sua descrição alfanumérica, o seu preço unitário, que é um número real com duas casas decimais, a taxa de IVA que recai sobre as suas vendas, a data da última atualização do stock, etc. Prod=(100, “Lápis Viarco n.º 2”, 1.20, 0.23, 12/03/2020)

Os tuplos podem também ser vazios T=( ). A manipulação dos tuplos é muito parecida à das listas com a grande diferença de aqueles serem imutáveis e estas mutáveis, isto é, os tuplos não são alteráveis ao longo dos programas. Cada um dos seus dados pode ser identificado pelo respetivo índice e podem identificar-se, tal como nas listas, fatias de tuplos através de intervalos de índices. Podem ainda definir-se tuplos em que os seus dados são outros tuplos. No excerto de código seguinte, exemplifica-se a identificação de tuplos em Python. Prod=(100, "Lápis Viarco n.º 2", (1.2, "ABC"), 0.23) print(Prod[3]) print(Prod[0:2]) print(Prod[1:3])

Os dicionários são também coleções de pares de dados, mas não são ordenados. Cada par é composto pela chave e o valor da entrada. As chaves têm de ser únicas para garantirem o acesso a um só valor de entrada.

De seguida, ilustram-se várias operações com dicionários em Python. Dic={} Prod={1: "Pla", 2: "Plb",4: "Pld",5: "Ple", 10} print(Prod) print(Prod[4]) Prod[3]="Plc" Prod.get(2)

123

Práticas de Python: Algoritmia e Programação

As chaves são vulgarmente dados numéricos, alfanuméricos ou tuplos. Os valores de entrada dos dicionários são mutáveis, isto é, podem ser alterados ao longo do programa por operações de atribuição. Os conjuntos em Python implementam os conceitos e operações da Teoria de Conjuntos. Convém, no entanto, lembrar que os conjuntos não têm elementos repetidos nem a ordenação dos seus elementos é garantida, pois os seus elementos não são indexáveis. Os conjuntos também não são mutáveis. Veja-se, a seguir, várias operações com conjuntos em Python. conj={1,2,7,8,12,20, 2,2} print(len(conj)) print (5 in conj) conj={i for i in range(16) if i%2==0} print(conj)

Neste capítulo, apresentamos 28 exercícios que demonstram a formação e manipulação de tuplos, dicionários e conjuntos. A resolução destes exercícios ilustra as operações principais com tuplos, listas de tuplos, tuplos de tuplos, dicionários e dicionários com listas e tuplos. Os quatro últimos exercícios respeitam a operações comuns com conjuntos de dados.

Exercício 4.1 Tuplo de funcionários com três campos Crie um tuplo de três dados – número, nome e categoria – sobre os seguintes funcionários: Número

Nome

Categoria

100

Joana Silva

110

Telmo Costa

120

Rui Velez

130

Rosa Pais

Salienta-se que cada número é 10 unidades superior ao do funcionário anterior e a categoria é a letra maiúscula seguinte à categoria do funcionário anterior.

Top-down 1. Inicializar o tuplo 2. Gerar o número e a categoria do primeiro funcionário 3. Para cada funcionário 3.1. Ler o nome do funcionário 3.2. Acrescentar o número, nome e categoria do funcionário ao tuplo

124

5 Funções e Módulos A programação modular, caraterística da programação estruturada, visa reduzir a complexidade dos programas grandes, dividindo-os em vários subprogramas, mais fáceis de elaborar, compreender, alterar, testar e corrigir. Por um lado, a programação modular associa-se ao desenho top-down, em que a solução geral vai sendo aperfeiçoada com a introdução progressiva de subsoluções que resolvam determinados aspetos do problema. Por outro lado, deriva da aplicação do princípio “dividir para conquistar”, que subjaz à decomposição de um problema complexo em subproblemas, que possam ser resolvidos separadamente e cujas subsoluções possam juntar-se para formar uma solução global. Em Python, um programa pode ser composto por uma parte principal – programa principal – e várias funções. De um modo geral, uma função efetua uma tarefa específica que permite alcançar um subobjetivo do programa principal. As funções podem, por exemplo, calcular o valor de uma expressão de computação. O encadeamento das diversas funções forma, com o programa principal, uma estrutura em árvore. A Figura 5.1 ilustra a estrutura em árvore de um programa dividido em funções. Programa principal

Função F

Função G

…

Função F1

Figura 5.1 Encadeamento em árvore de funções e programa principal

A certa altura, surge no programa principal uma instrução de chamada da função F – invocação da função. O controlo de execução passa, então, para a função F: 1. A função F, por sua vez, invoca a função F1. O controlo de execução é passado para F1.

167

Práticas de Python: Algoritmia e Programação

2. Após a conclusão da função F1, o controlo de execução é devolvido a F. 3. Após a conclusão da execução da função F, o controlo de execução é devolvido ao programa principal. A execução das funções obedece à ordem por que são invocadas e aos argumentos que lhe são passados. A invocação de uma função consiste em ordenar a sua execução para um determinado conjunto de argumentos. Os argumentos passados durante a invocação da função têm de corresponder em número e tipo aos parâmetros da função invocada e ainda têm de seguir a mesma ordem para que o primeiro parâmetro receba o primeiro argumento, o segundo parâmetro receba o segundo argumento e assim sucessivamente.

5.1. Funções Uma função transforma um conjunto de argumentos num resultado que pode ser um único valor, um conjunto ordenado de valores (Figura 5.2) ou pode efetuar um conjunto de operações de leitura, escrita ou atribuição (Figura 5.3). Argumentos

Resultado Função

Figura 5.2 Uma função recebe e processa os argumentos para obter um resultado Argumentos Conjunto de operações Função

Figura 5.3 Uma função recebe argumentos para realizar um conjunto de operações

A invocação de uma função consiste em ordenar a sua execução para um determinado conjunto de argumentos. Os argumentos e o resultado de uma função podem ser de qualquer tipo de dados (ver Capítulo 1). Em Python, não é obrigatório concluir uma função com a instrução return, isto é, uma função pode não devolver nenhum resultado ao programa que a invocou. No entanto, 168

6 Recorrência Uma função recorrente refere-se a si própria, ou seja, chama-se a si própria. A Figura 6.1 ilustra o cálculo por recorrência do fatorial de 5. 5

5* Fat(4) Fat(N)

4 Fat(5)=5*Fact(4)

5*24=120

Fat(4)=4*Fact(3)

4*6=24

Fat(3)=3*Fact(2)

3*2=6

Fat(2)=2*Fact(1)

2*1=2

Fat(1)=1*Fact(0)

1*1=1

Fat(0)=1

Figura 6.1 Cálculo do fatorial de 5 por recorrência

Em termos gerais, podemos dizer que, para definir uma função recorrente, há que: 1. Definir F(0). 2. Expressar F(n) em termos de F(n-1). Neste capítulo, apresentamos 18 exercícios cuja resolução demonstra a definição e a invocação de funções recorrentes. A recorrência substitui os processos iterativos, evidenciando a simplicidade dos respetivos algoritmos.

Exercício 6.1 Potências de 2 Elabore uma função que calcule por recorrência potências de 2. Considere expoentes inteiros, superiores ou iguais a 0 e inferiores ou iguais a 62. 223

Práticas de Python: Algoritmia e Programação

Top-down de Potenciasde2 1. F(0)=1 2. F(Expoente) =2*F(Expoente-1)

Resultado e parâmetro de Potenciasde2 Resultado Potencia

Parâmetro E

Tipo Inteiro

Significado Potência de base 2

Tipo Inteiro

Significado Expoente da potência de 2

Algoritmo de PotenciasDe2(E) Se E<0 ou E>62 Então PotenciaDe2:="Expoente deve ser maior ou igual a 0 e menor ou igual a 62." Senão Se E=0 Então PotenciaDe2:=1 Senão Potenciade2:=2*PotenciaDe2(E-1) FimSe FimSe

Programa principal com invocação de funções def PotenciaDe2 ( E ): if E<0 or E>62: return "Expoente fora do intervalo de valores admissíveis" elif E==0: return 1 else: return 2*PotenciaDe2(E-1) if __name__ == '__main__': Expo=int(input("Digite um inteiro entre 0 e 62: ")) Pot=PotenciaDe2(Expo) if type(Pot)== str: print(Pot) else: print(f"2 levantado a {Expo} = {Pot}")

EXECUÇÃO Digite um inteiro entre 0 e 62: 7 2 levantado a 7 = 128

224

7 Classes, Subclasses e Objetos Os fundamentos dos tipos de dados primitivos que são intrínsecos ao Python, tais como inteiros, reais, lógicos, etc., e que sustentam a programação estruturada, estenderam-se e permitiram aos programadores definirem os seus próprios tipos de dados, criando-se a essência da programação orientada por objetos (POO). Os programadores podem, portanto, definir tipos de dados – classes –, que encapsulam atributos e funcionalidades e dão origem a novos tipos de variáveis. As classes são instanciáveis em objetos que são representados por variáveis do tipo das respetivas classes. Os programas orientados por objetos são conjuntos de classes. Os objetos interagem, pedindo, uns aos outros, para executarem as respetivas funcionalidades. As classes escondem a implementação dos seus atributos e funcionalidades, mas expõem a informação necessária para que terceiros possam invocar a execução das suas funcionalidades.

7.1. Classes e objetos Uma classe é uma estrutura de dados que define, em abstrato, os atributos e as funcionalidades de uma família de objetos. Por exemplo, “Disciplina” é uma classe que representa genericamente todas as disciplinas académicas e tem atributos, tais como o “código”, a “designação”, o “curso a que pertence”, o “número de unidades de crédito”, a “sinopse” e o “conteúdo programático”, bem como funcionalidades que permitem determinar a ponderação da disciplina na classificação final de curso, a taxa de crescimento de inscrições face ao ano anterior, o rácio do custo da disciplina por cada aluno inscrito, etc. “Matemática”, pode ser uma concretização da classe “Disciplina”, contendo, portanto, todos os atributos e funcionalidades definidos naquela classe (Figura 7.1).

Os atributos (ou propriedades) são dados de diversos tipos primitivos, estruturas de dados ou tipos definidos pelo utilizador que caraterizam todos os objetos de uma classe. As funcionalidades são as operações que esses objetos podem executar e são implementadas por funções designadas por métodos.

255

Práticas de Python: Algoritmia e Programação

Classe Disciplina Atributos Codigo Designacao Cursos UC ………….. Métodos CalcularPonderacao(…) ………. CustoPorAluno(…) ……………

Objeto 1

Objeto 2

100 Matemática Gestão, Economia 5 …….. CalcularPonderacao(…) 4/16*UC CustoPorAluno(…) ……….

110 Introdução ao Direito Economia 4 ………. CalcularPonderacao(…) 3/20*UC CustoPorAluno(…) ……….

Figura 7.1 Os dois objetos – “Matemática” e “Introdução ao Direito” – são instantes da classe “Disciplina”

7.2. Variáveis de instante e variáveis estáticas Os atributos dos objetos são guardados em variáveis de instante. Estas variáveis são sempre atributos do objeto corrente daí que o seu nome seja precedido de self. Porém, as classes podem também conter variáveis estáticas, isto é, variáveis que fazem parte da classe, mas que não são atributos dos objetos. Por exemplo, uma classe pode conter uma variável inteira que conte o número das suas instanciações. As variáveis estáticas, tal como as de instante, podem ser de tipos primitivos, estruturas de dados ou tipos definidos pelo utilizador.

7.3. Visibilidade das variáveis Em Python, tanto as variáveis de instante como as variáveis estáticas são públicas, isto é, os seus valores podem ser lidos ou manipulados fora das classes que as encapsulam. Porém, para evitar erros de programação, o Python permite esconder as variáveis, fazendo com que elas não sejam diretamente visíveis por outras classes ou módulos. Assim, as variáveis cujo nome é precedido por duplo sublinhado não são visíveis por outras classes ou módulos terceiros. Há ainda a possibilidade de esconder menos as variáveis, fazendo preceder o seu nome por um só sublinhado. Contudo, estas variáveis forte ou fracamente escondidas podem ser sempre manipuladas por terceiros. Veja-se, a seguir, como a classe EstudanteInf define três variáveis de instante – Nome, Teste1 e Teste2 – que estão fortemente escondidas. class EstudanteInf(): def __init__(self, N, T1,T2): self.__Nome = N

256

8 Erros, Validações e Correções A introdução e o processamento de dados podem gerar erros que alteram a execução dos programas. Estes erros são causados pelo ambiente de programação ou pela semântica do programa que estamos a executar. Se a introdução de dados e o seu processamento não se adequam às especificações do programa, por exemplo, quando o utilizador introduz uma letra em vez do número inteiro que lhe é pedido, o software reage e para a sua execução. Um programa robusto deteta estes erros e trata-os, isto é, contém procedimentos de deteção e resposta aos erros – mecanismos de error handling – para que não seja interrompido sem, pelo menos, informar o utilizador sobre as caraterísticas dos erros que ocorreram. Um programa é tão mais robusto quantos mais erros detetar, permitir a sua correção e continuar a sua execução. O Python designa estes erros por exceções, uma vez que resultam de situações extraordinárias que alteram a execução geral do programa, e procura dar-lhes resposta, apresentando a estrutura de tratamento de exceções que se mostra na Figura 8.1. try: Instruções que durante a execução podem causar erros except: Instruções que se executam sempre que ocorre um erro na execução do bloco try correspondente else: Instruções que se executam quando não ocorrem erros na execução do bloco try correspondente finally: Instruções que se executam sempre que ocorram ou não erros durante a execução do bloco try correspondente

Figura 8.1 Estrutura de deteção e recuperação de erros

É de salientar que a um bloco try podem corresponder vários blocos except, um para cada tipo de erro. Por outro lado, as estruturas de erros podem encaixar-se umas nas outras, sendo resolvidas do exterior para o interior. 311

www.fca.pt Acompanhe a FCA de perto e conheça as Nossas Coleções Novo!

Novo!

Nova coleção que serve os referenciais dos cursos de educação e formação profissional da indústria metalomecânica. Com livros profusamente ilustrados, escrita simples e exercícios para autoaprendizagem

Nova coleção sobre os grandes temas da Ciência dos Dados: Data Science, Big Data, Analytics e Internet das Coisas. Com uma abordagem muito prática e demonstração de exemplos e projetos, estes são os livros essenciais aos profissionais do futuro!

Em época de regulamentação europeia para a proteção de dados, surge uma nova coleção FCA! Livros práticos e esclarecedores que apresentam os temas, conceitos, tecnologias e toda a informação sobre Cibersegurança, Privacidade e Proteção de Dados

Coleção sobre um tema bastante importante no panorama atual, onde apresentamos livros dedicados aos utilizadores, aos profissionais e aos estudantes

Dedicada a todos os envolvidos com as Tecnologias de Informação, é indispensável para todos aqueles que pretendam desenvolver as suas aplicações de acordo com as tecnologias mais recentes

Dedicada não só aos profissionais de Sistemas de Informação, mas também a Gestores e outros profissionais de Informática, assim como aos estudantes de licenciaturas e mestrados

Destinada aos alunos dos diversos Cursos de Educação e Formação para Jovens (3.º Ciclo do EB e cursos profissionais do ES) e para Adultos, de acordo com os respetivos programas. Útil também para autoformação

A coleção da FCA para os estudantes do Ensino Superior. Aborda as principais temáticas de um curso TI. Útil também para profissionais que pretendam atualizar os seus conhecimentos

Dedicada aos amantes do digital, coloca à disposição de amadores e profissionais conhecimentos anteriormente apenas acessíveis através de obras estrangeiras

Esta coleção mostra-lhe, com uma linguagem simples e acessível, como tirar partido das últimas versões dos programas para utilizadores e sistemas operativos mais utilizados, através de exemplos e exercícios resolvidos para praticar

Esta coleção, única em Portugal, é dedicada à Gestão de Projetos segundo as melhores e mais atuais práticas

Os livros desta coleção, simples e objetivos, profusamente ilustrados com exemplos passo a passo, levam-no a dominar com rapidez e facilidade as matérias apresentadas