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
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 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
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 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
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 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
Práticas de Python: Algoritmia e Programação
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
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.
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
Práticas de Python: Algoritmia e Programação
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
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 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
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 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
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çõ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
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 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
Práticas de Python: Algoritmia e Programação
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!
Top Related