FCA – Editora de Informática, Lda. Av. Praia da Vitória

Edição FCA – Editora de Informática, Lda.Av. Praia da Vitória, 14 A – 1000-247 LisboaTel: +351 213 511 [email protected]

distribuição

Lidel – Edições Técnicas, Lda.Rua D. Estefânia, 183, R/C Dto. – 1049-057 LisboaTel: +351 213 511 [email protected]

Livraria

Av. Praia da Vitória, 14 A – 1000-247 LisboaTel: +351 213 511 [email protected]

Copyright © 2021, FCA – Editora de Informática, Lda.ISBN edição impressa: 978-972-722-918-51.ª edição impressa: março de 2021

Paginação: Carlos MendesImagem de entrada de capítulo: © python by Icons Producer from the Noun ProjectImpressão e acabamento: Cafilesa – Soluções Gráficas, Lda. – Venda do PinheiroDepósito Legal n.º 481316/21Capa: 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.

III

© F

CA

Índice

Sobre a Autora ................................................................................................................ XI

Prólogo ............................................................................................................................ XIII

Capítulo 1Operações Básicas com Dados e Variáveis 1

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

IV

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 2Estruturas de Controlo de Execução 17

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

V

Índice©

FC

A

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 3Listas e NumPy 83

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

VI


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.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 4Tuplos, 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

VII

Índice©

FC

A

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 5Funçõ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

VIII


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 6Recorrê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

IX

Índice©

FC

A

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

X


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 8Erros, 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

XIII

© F

CA

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 es-truturada 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 es-truturas 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 in-glês, e significa avançar uma frase (instrução) um conjunto de espaços relativamente à mar-gem 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 especial-mente 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 decom-por-se nas cinco etapas do diagrama apresentado na Figura 1.

XIV


Desenvolvimento da solução

2. Algoritmo em pseudocódigo

Teste do algoritmo

3. Traçagem

Teste do programa

5. Execução de testes

Codificação em Python

4. Programa

Desenho de uma solução

1. Top-downProblema

Figura 1Etapas 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 dados e variáveis

25 exercícios cuja resolução demonstra a utilização de operações de leitura, atribuição a variáveis e escrita de dados.

2. Estruturas de controlo de execução

41 exercícios cuja resolução demonstra a utilização das estrutu-ras 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 compreen-sã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 tu-plos, 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 pro-gramação modular, dividindo os programas em funções que re-solvem parcialmente os problemas e se integram, formando uma solução final. A resolução destes exercícios evidencia a neces-sária correspondência de argumentos e parâmetros e foca os aspetos excecionais de parâmetros com valores por defeito, ar-gumentos 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)

XV

Prólogo©

FC

A

(continuação)

6. Recorrência18 exercícios cuja resolução demonstra a definição e a invocação de funções recorrentes. A recorrência substitui os processos ite-rativos, 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éto-dos. 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. Dedica-mos 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 con-siste 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 gra-tuito 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 profis-sionais 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 2021Adelaide Carvalho

1

© F

CA

1Operaçõ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, guar-dá-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.

Tratamento de dados

ATRIBUIÇÃO

Saída de resultados

Entrada de dados

LEITURA ESCRITA

Figura 1.1Entrada-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 jusan-te 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 va-lores 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 ope-raçõ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, ope-rações lógicas, operações alfanuméricas, expressões de computação e formatos de saída.

2


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.

17

© F

CA

2Estruturas de Controlo de Execução

Neste capítulo, apresentamos as três categorias de estruturas de controlo de execução – se-quenciais, condicionais e repetitivas – e a implementação das mesmas em Python. Estas es-truturas 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 sequenciaisAs 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, se-quencial. O excerto de código abaixo mostra a representação em pseudocódigo de estruturas sequenciais.

Instrução 1Instrução 2Instrução 3….Instrução 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 condicionaisAs 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 ins-truções que é executado se o conjunto de condições for verdadeiro, e outro se esse conjunto de condições for falso.

18


As estruturas condicionais podem ser estruturas de decisão ou estruturas de escolha múlti-pla. 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 a executar se a condição for falsa

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

verdadeira

Instruções restantes

CondiçãoVerdadeira Falsa

Instruções diversas

Figura 2.1Fluxograma 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 verdadeiroelse: Instruções do ramo falso

if condição1: Instruções do ramo verdadeiro da condição 1elif condição2: Instruções do ramo falso da condição 1 e verdadeiro da condição 2elif condição3:……..else: Instruções do ramo falso das condições anteriores

83

© F

CA

3Listas 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 con-juntos 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 ele-mentos 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 3L[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 20L[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 di-mensões.

Neste capítulo, apresentamos 26 exercícios que demonstram a inicialização, formação e ma-nipulaçã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 com-preensão.

84


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

E 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

TeresaTelmoLuís

123

© F

CA

4Tuplos, Dicionários e Conjuntos

Tuplos, dicionários e conjuntos são estruturas de dados mais complexas dotadas de funcio-nalidades 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éri-ca, 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 progra-mas. Cada um dos seus dados pode ser identificado pelo respetivo índice e podem identi-ficar-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)

124


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 conjun-tos 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 A

110 Telmo Costa B

120 Rui Velez C

130 Rosa Pais D

Salienta-se que cada número é 10 unidades superior ao do funcionário anterior e a catego-ria é 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

167

© F

CA

5Funções e Módulos

A programação modular, caraterística da programação estruturada, visa reduzir a complexi-dade 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 F1

Função G …

Figura 5.1Encadeamento 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.

168


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çõesUma 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

ResultadoFunção

Figura 5.2Uma função recebe e processa os argumentos para obter um resultado

Argumentos

Conjunto de operações

Função

Figura 5.3Uma 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 con-junto 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,

223

© F

CA

6Recorrê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.

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 1

Fat(N)5* Fat(4)

5

4

Figura 6.1Cá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 intei-ros, superiores ou iguais a 0 e inferiores ou iguais a 62.

224


Top-down de Potenciasde2

1. F(0)=1

2. F(Expoente) =2*F(Expoente-1)

Resultado e parâmetro de Potenciasde2

Resultado Tipo Significado

Potencia Inteiro Potência de base 2

Parâmetro Tipo Significado

E Inteiro 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) FimSeFimSe

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: 72 levantado a 7 = 128

255

© F

CA

7Classes, 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 atri-butos 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, pedin-do, 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 objetosUma classe é uma estrutura de dados que define, em abstrato, os atributos e as funciona-lidades 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 fun-cionalidades são as operações que esses objetos podem executar e são implementadas por funções designadas por métodos.

256


AtributosCodigoDesignacaoCursosUC…………..

MétodosCalcularPonderacao(…)……….CustoPorAluno(…)……………

100 MatemáticaGestão, Economia5……..CalcularPonderacao(…)4/16*UCCustoPorAluno(…)……….

110 Introdução ao Direito Economia4……….CalcularPonderacao(…)3/20*UCCustoPorAluno(…)……….

Classe Disciplina

Objeto 1

Objeto 2

Figura 7.1Os 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áticasOs 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. Po-ré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

311

© F

CA

8Erros, 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:

except:

else:

finally:

Instruções que durante a execução podem causar erros

Instruções que se executam sempre que ocorre um erro na execução do bloco try correspondente

Instruções que se executam quando não ocorrem erros na execução do bloco try correspondente

Instruções que se executam sempre que ocorram ou não erros durante a execução do bloco try correspondente

Figura 8.1Estrutura 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.

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

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

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

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

Novo! Novo!

Documents

FCA – Editora de Informática, Lda. Av. Praia da Vitória