Introdução à Algoritmia e Programação com Python by Grupo Lidel

9cm x 24cm

16,9cm x 24cm

Este livro foi pensado para todas as pessoas que desejem adquirir uma compreensão sólida das bases da programação (algoritmia) e dar os primeiros passos numa das linguagens mais amplamente utilizadas, o Python.

Obra com conceitos, exemplos e exercícios que ajuda estudantes e profissionais a compreenderem os SGBDR e suas características. 2.ª edição com secções novas e novo capítulo sobre outros modelos.

CMY

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

Livro essencial e prático que aborda os princípios, conceitos e bases algorítmicas da computação gráfica, ligando-os a situações de aplicação concreta. Para alunos do ensino superior e profissionais.

Através dos vários exemplos resolvidos, sumários da matéria abordada e exercícios teóricos e práticos, construa e desenvolva os seus programas em Python. Para estudantes e profissionais.

O objetivo desta obra é facilitar a compreensão de problemas complexos e auxiliar na criação de soluções eficazes através da programação. Para atingir este propósito, o livro está dividido em quatro partes distintas: Contextualização, Algoritmia, Python e Informações, Exercícios e Projetos. Na parte sobre algoritmia, são abordados de forma abrangente todos os termos e conceitos fundamentais necessários para compreender um problema e conceber soluções potenciais. Já a parte dedicada ao Python apresenta a linguagem de programação e demonstra de que maneira os princípios previamente explorados na algoritmia podem ser aplicados de forma prática utilizando o Python. Para fortalecer e solidificar a aprendizagem, esta obra incorpora uma variedade de exercícios que permitem aos leitores colocar em prática os conceitos apresentados. Além disso, oferece dois projetos abrangentes que podem ser desenvolvidos utilizando a linguagem Python, permitindo que os leitores apliquem de forma tangível o conhecimento adquirido até ao momento. Este livro destina-se a alunos de cursos/disciplinas de Informática, Sistemas de Informação, Ciências de Computadores e restantes engenharias, a profissionais tecnológicos, como programadores e analistas de dados, que necessitam de se atualizar e revisitar conteúdos, bem como a autodidatas que pretendam aprender a programar ou a quem queira perceber ou iniciar-se na programação produzida pela Inteligência Artificial (por exemplo, ChatGPT, Bard).

ISBN 978-972-722-931-4

9 789727 229314

23,6 cm

Compreenda as bases da algoritmia e aprenda a programar com uma das linguagens mais utilizadas no mundo, o Python. O que pode encontrar no livro: Uma metodologia para resolução de problemas; 29 exercícios de algoritmia e 34 exercícios de Python; Capítulos organizados para uma leitura sequencial ou ordenada; Dois projetos práticos; Linguagem simples e acessível. Principais temas abordados: Fundamentos e conceitos Pensamento computacional Resolução de problemas Variáveis e operadores Análise de requisitos Prototipagem e implementação Edição de código Do desenho ao desenvolvimento Instruções e estruturas (controlo e dados) Bibliotecas Subprogramas Python e Pandas Boas práticas Ferramentas Utilização da IA na programação Apresentação do método TD2CE

Código dos projetos, resoluções de alguns exercícios (Python e Flowgorithm) e outros materiais disponíveis em www.fca.pt, até o livro se esgotar ou ser publicada nova edição atualizada ou com alterações.

16,9cm x 24cm

9cm x 24cm

Filipe Portela Professor auxiliar convidado da Escola de Engenharia da Universidade do Minho. Investigador integrado do Centro ALGORITMI da Universidade do Minho. CEO e fundador da empresa IOTech – Innovation on Technology. Coautor de dois livros sobre tecnologias web publicados pela FCA.

Tiago C. Pereira Professor auxiliar convidado da Escola de Engenharia da Universidade do Minho. Investigador convidado do Centro ALGORITMI da Universidade do Minho. Professor adjunto do Instituto Europeu de Estudos Superiores, onde é coordenador da Licenciatura em Tecnologias e Gestão de Sistemas de Informação. CEO e fundador da empresa BDKD – Big Data and Knowledge Discovery.

Edição FCA – Editora de Informática Av. Praia da Vitória, 14 A – 1000-247 Lisboa Tel: +351 213 511 448 fca@fca.pt www.fca.pt

Distribuição Lidel – Edições Técnicas, Lda. Rua D. Estefânia, 183, R/C Dto. – 1049-057 Lisboa Tel: +351 213 511 448 lidel@lidel.pt www.lidel.pt

Livraria Av. Praia da Vitória, 14 A – 1000-247 Lisboa Tel: +351 213 541 418 livraria@lidel.pt Copyright © 2023, FCA – Editora de Informática ® Marca registada da FCA PACTOR Editores, Lda. ISBN edição impressa: 978-972-722-931-4 1.ª edição impressa: novembro de 2023 Paginação: Carlos Mendes Impressão e acabamento: Tipografia Lousanense, Lda. – Lousã Depósito Legal n.º 524020/23 Capa: José Manuel Reis Todos os nossos livros passam por um rigoroso controlo de qualidade, no entanto aconselhamos a consulta periódica do nosso site (www.fca.pt) para fazer o download de eventuais correções. Não nos responsabilizamos por desatualizações das hiperligações presentes nesta obra, que foram verificadas à data de publicação da mesma. Os nomes comerciais referenciados neste livro têm patente registada. Reservados todos os direitos. Esta publicação não pode ser reproduzida, nem transmitida, no todo ou em parte, por qualquer processo eletrónico, mecânico, fotocópia, digitalização, gravação, sistema de armazenamento e disponibilização de informação, sítio Web, blogue ou outros, sem prévia autorização escrita da Editora, exceto o permitido pelo CDADC, em termos de cópia privada pela AGECOP – – Associação para a Gestão da Cópia Privada, através do pagamento das respetivas taxas.

ÍNDICE GERAL

AGRADECIMENTOS

XIII

SOBRE O LIVRO

SIGLAS E ACRÓNIMOS

XIX

PARTE I – CONTEXTUALIZAÇÃO.................................................................................................

DA ALGORITMIA À PROGRAMAÇÃO

1.1

FUNDAMENTAÇÃO E CONCEITOS.............................................................................................................................

1.2

SISTEMAS DE COMPUTAÇÃO.....................................................................................................................................

1.2.1

SISTEMA BINÁRIO..............................................................................................................................................

1.2.2

ASCII.........................................................................................................................................................................

1.2.3

UNIDADES DE MEDIDA.....................................................................................................................................

1.3

LIMITAÇÕES DA COMPUTAÇÃO.................................................................................................................................

1.4

PENSAMENTO COMPUTACIONAL.............................................................................................................................

1.5

O QUE É A ALGORITMIA?.............................................................................................................................................

1.5.1

FORMALIZAÇÃO.................................................................................................................................................

1.5.2

REPRESENTAÇÕES DE ALGORITMOS.......................................................................................................

1.6

1.7

PROGRAMAÇÃO...............................................................................................................................................................

1.6.1

PARA QUE SERVE A PROGRAMAÇÃO?..................................................................................................

1.6.2

EVOLUÇÃO DA PROGRAMAÇÃO................................................................................................................

1.6.3

PARADIGMAS DE PROGRAMAÇÃO...........................................................................................................

1.6.3.1

TIPOS DE PARADIGMAS...............................................................................................................

1.6.3.2

PROGRAMAÇÃO IMPERATIVA...................................................................................................

LINGUAGENS DE PROGRAMAÇÃO...........................................................................................................................

1.7.1

1.7.2

1.7.3

LINGUAGENS DE PROGRAMAÇÃO DE BAIXO NÍVEL......................................................................... LINGUAGENS DE PROGRAMAÇÃO DE ALTO NÍVEL...........................................................................

1.7.2.1

LINGUAGENS IMPERATIVAS OU PROCEDIMENTAIS........................................................

1.7.2.2

LINGUAGENS ORIENTADAS AOS OBJETOS........................................................................

1.7.2.3

LINGUAGENS FUNCIONAIS..........................................................................................................

1.7.2.4

LINGUAGENS DECLARATIVAS OU RELACIONAIS.............................................................

DIFERENÇAS.........................................................................................................................................................

APRESENTAÇÃO DOS PROJETOS

2.1

“GOALON”............................................................................................................................................................................

2.1.1

ANÁLISE DE REQUISITOS...............................................................................................................................

2.1.2

PROTOTIPAGEM..................................................................................................................................................

2.2

“QUIZ DA SABEDORIA”.................................................................................................................................................

2.3

EDIÇÃO DE CÓDIGO.........................................................................................................................................................

VII

INTRODUÇÃO À ALGORITMIA E PROGRAMAÇÃO COM PYTHON

2.4

CONTROLO DE VERSÕES DE CÓDIGO.................................................................................................................... 2.4.1

GIT..............................................................................................................................................................................

2.4.2 CRIAÇÃO DE REPOSITÓRIO NO GITHUB..................................................................................................

PARTE II – ALGORITMIA................................................................................................................. 47 3

SOLUÇÃO ALGORÍTMICA

3.1

INTRODUÇÃO......................................................................................................................................................................

3.1.1

DO DESENHO AO DESENVOLVIMENTO...................................................................................................

3.1.2

IMPLEMENTAÇÃO...............................................................................................................................................

PROBLEMA..........................................................................................................................................................................

3.2.1

3.2

3.3

REQUISITOS DO PROBLEMA ALGORÍTMICO.........................................................................................

3.2.2 SOLUÇÃO ALGORÍTMICA................................................................................................................................

3.2.3 TIPOS DE PROBLEMAS....................................................................................................................................

ABORDAGENS DE RESOLUÇÃO DE PROBLEMAS............................................................................................

TOP-DOWN.............................................................................................................................................................

3.3.1

3.3.2 BOTTOM-UP..........................................................................................................................................................

3.4 EXPRESSÕES ALGÉBRICAS.........................................................................................................................................

3.4.1

EXPRESSÕES LITERAIS...................................................................................................................................

3.4.2 VARIÁVEIS E CONSTANTES...........................................................................................................................

3.4.3 OPERADORES DE ATRIBUIÇÃO....................................................................................................................

3.4.4 OPERADORES ARITMÉTICOS.......................................................................................................................

3.4.5 OPERADORES RELACIONAIS........................................................................................................................

3.4.6 OPERADORES LÓGICOS..................................................................................................................................

3.4.7 AVALIAÇÃO DE EXPRESSÕES E PRECEDÊNCIA DOS OPERADORES........................................

3.5 REPRESENTAÇÃO DA SOLUÇÃO...............................................................................................................................

3.5.1

3.6

3.7

LINGUAGEM NATURAL.....................................................................................................................................

3.5.2 FLUXOGRAMA......................................................................................................................................................

3.5.3 PSEUDOCÓDIGO..................................................................................................................................................

3.5.4 ANÁLISE COMPARATIVA................................................................................................................................

3.5.5 FORMALISMO DE BACKUS-NAUR...............................................................................................................

IMPRESSÃO DA SOLUÇÃO...........................................................................................................................................

3.6.1

CONSOLA...............................................................................................................................................................

3.6.2 LOGGING (LOGS)..................................................................................................................................................

3.6.3 FICHEIRO.................................................................................................................................................................

SOLUÇÕES – MÉTODO TD2CE...................................................................................................................................

THINK (PENSAR)..................................................................................................................................................

3.7.1

3.7.2 DEFINE (DEFINIR)................................................................................................................................................

3.7.3 DESIGN (DESENHAR).........................................................................................................................................

3.7.4 CODIFY (CODIFICAR).........................................................................................................................................

3.7.5 EVALUATE (AVALIAR)......................................................................................................................................

3.8 ALGORITMOS.....................................................................................................................................................................

3.8.1

VIII

OTIMIZAÇÃO.........................................................................................................................................................

3.8.1.1

RECURSIVO.........................................................................................................................................

3.8.1.2

DIVIDIR E CONQUISTAR................................................................................................................

3.8.1.3

PROGRAMAÇÃO DINÂMICA........................................................................................................

ÍNDICE GERAL 3.8.1.4

GREEDY................................................................................................................................................

3.8.1.5

FORÇA BRUTA...................................................................................................................................

3.8.1.6

RETROCESSO.....................................................................................................................................

3.8.2 PROCURA................................................................................................................................................................

3.8.2.1

PROCURA LINEAR............................................................................................................................ 100

3.8.2.2 PROCURA BINÁRIA.........................................................................................................................

101

3.8.2.3 PROCURA BINÁRIA RECURSIVA...............................................................................................

103

3.8.3 ORDENAÇÃO.........................................................................................................................................................

103

3.8.3.1

ALGORITMO DE ORDENAÇÃO POR SELEÇÃO................................................................... 105

3.8.3.2 ALGORITMO DE ORDENAÇÃO POR TROCA......................................................................... 106 3.8.3.3 ALGORITMO DE ORDENAÇÃO POR INSERÇÃO.................................................................

107

3.8.3.4 ALGORITMO DE ORDENAÇÃO POR FUSÃO......................................................................... 108 3.8.3.5 ALGORITMO DE ORDENAÇÃO POR PARTIÇÃO................................................................. 109 3.9

3.8.4 INSTRUÇÕES ALGORÍTMICAS.......................................................................................................................

111

RESUMO................................................................................................................................................................................

112

INSTRUÇÕES E ESTRUTURAS

115

4.1

INTRODUÇÃO......................................................................................................................................................................

115

4.2

DECISÃO...............................................................................................................................................................................

119

4.2.1

120

VALIDAÇÃO DAS CONDIÇÕES......................................................................................................................

4.2.2 IF-THEN-ELSE INDENTADOS......................................................................................................................

122

4.2.3 SELEÇÃO MÚLTIPLA (SWITCH).....................................................................................................................

123

4.2.4 EXEMPLO................................................................................................................................................................

124

4.3 REPETIÇÃO..........................................................................................................................................................................

125

4.3.1

REPETIÇÃO COM TESTE À CABEÇA (WHILE)........................................................................................

126

4.3.2 REPETIÇÃO COM TESTE À CAUDA (DO-WHILE)...................................................................................

127

4.3.3 REPETIÇÃO COM NÚMERO PREDEFINIDO DE CICLOS (FOR)..........................................................

128

4.3.4 COMPARAÇÃO.....................................................................................................................................................

130

4.4 ESTRUTURA DE DADOS................................................................................................................................................

131

4.4.1 ESTRUTURAS PRIMITIVAS............................................................................................................................. 134 4.4.1.1

TIPO BOOLEANO..............................................................................................................................

135

4.4.1.2

TIPO NUMÉRICO................................................................................................................................

135

4.4.1.3

TIPO ALFANUMÉRICO....................................................................................................................

136

4.4.1.4

REPRESENTAÇÃO DOS DADOS.................................................................................................

137

4.4.2 ESTRUTURAS DE DADOS COMPLEXAS...................................................................................................

139

ARRAY....................................................................................................................................................

139

4.4.2.1

4.4.2.2 ÁRVORE................................................................................................................................................ 144 4.4.2.3 GRAFOS................................................................................................................................................ 145 4.4.2.4 LISTAS................................................................................................................................................... 146 4.4.2.5 TABELA DE DISPERSÃO...............................................................................................................

149

4.5 EXEMPLO DE INSTRUÇÕES.......................................................................................................................................... 150 4.5.1 EXEMPLO 1............................................................................................................................................................. 150 4.5.2 EXEMPLO 2............................................................................................................................................................ 154 4.5.3 EXEMPLO 3............................................................................................................................................................ 156

INTRODUÇÃO À ALGORITMIA E PROGRAMAÇÃO COM PYTHON

SUBPROGRAMAS

157

5.1

INTRODUÇÃO......................................................................................................................................................................

157

5.2

FUNÇÕES.............................................................................................................................................................................. 158

5.3 PROCEDIMENTOS............................................................................................................................................................. 158 5.4 DIFERENÇAS....................................................................................................................................................................... 159 5.5 MÓDULOS............................................................................................................................................................................

160

5.6 CONTEXTO...........................................................................................................................................................................

161

5.6.1

PARÂMETROS E ARGUMENTOS.................................................................................................................

161

5.6.2 ÂMBITO DAS VARIÁVEIS................................................................................................................................ 164 5.6.3 IDENTIFICADORES.............................................................................................................................................. 165 5.7

TERMINOLOGIAS..............................................................................................................................................................

166

5.8 PROGRAMA COMPLETO DE ALGORITMIA...........................................................................................................

167

PARTE III – PYTHON......................................................................................................................... 177 6

INTRODUÇÃO AO PYTHON

179

6.1

PYTHON – O QUE É E PARA QUE SERVE.............................................................................................................

179

6.2

ALGORITMO VERSUS PROGRAMA.......................................................................................................................... 180

6.3 DIFERENTES PARADIGMAS, A MESMA LINGUAGEM.....................................................................................

181

6.4 COMO COMEÇAR?............................................................................................................................................................

182

6.5 VARIÁVEIS........................................................................................................................................................................... 6.5.1

6.6

182

IDENTIFICADORES DE VARIÁVEIS..............................................................................................................

183

6.5.1.1

ENTRADA – LEITURA DE VALORES DO TECLADO PARA UMA VARIÁVEL..........

183

6.5.1.2

SAÍDA – IMPRIMIR NO TERMINAL OS VALORES DAS VARIÁVEIS, ENTRE OUTROS................................................................................................................................

183

OPERADORES.................................................................................................................................................................... 185 6.6.1

ARITMÉTICOS.......................................................................................................................................................

186

6.6.2 RELACIONAIS.......................................................................................................................................................

187

6.6.3 LÓGICOS.................................................................................................................................................................. 188

6.6.4 BINÁRIOS................................................................................................................................................................

189

6.6.5 PRIORIDADE DE OPERADORES...................................................................................................................

191

INSTRUÇÕES, ESTRUTURAS E BIBLIOTECAS

193

7.1

193

7.2

ESTRUTURAS DE DADOS............................................................................................................................................. 7.1.1

TUPLOS.................................................................................................................................................................... 194

7.1.2

LISTAS......................................................................................................................................................................

7.1.3

DICIONÁRIOS........................................................................................................................................................ 202

197

INSTRUÇÕES....................................................................................................................................................................... 206 7.2.1

INSTRUÇÕES DE DECISÃO.............................................................................................................................. 206

7.2.2 INSTRUÇÕES DE REPETIÇÃO........................................................................................................................ 209 7.3 SUBPROGRAMAS............................................................................................................................................................. 7.3.1 7.4

212

FUNÇÕES DEFINIDAS PELO UTILIZADOR................................................................................................

212

7.3.2 PROCEDIMENTOS DEFINIDOS PELO UTILIZADOR..............................................................................

213

FICHEIROS............................................................................................................................................................................

214

7.4.1

FICHEIROS DE TEXTO.......................................................................................................................................

215

7.4.1.1

215

LEITURA DE FICHEIROS DE TEXTO..........................................................................................

ÍNDICE GERAL 7.4.1.2

7.5

ESCRITA EM FICHEIROS DE TEXTO.........................................................................................

216

7.4.2 FICHEIROS DE BINÁRIOS.................................................................................................................................

216

7.4.2.1

LEITURA DE FICHEIROS DE BINÁRIOS...................................................................................

7.4.2.2

ESCRITA EM FICHEIROS DE BINÁRIOS...................................................................................

217

7.4.3 TRATAMENTO DE EXCEÇÕES........................................................................................................................

218

BIBLIOTECAS......................................................................................................................................................................

218

NUMPY......................................................................................................................................................................

219

7.5.1

217

7.5.2 PANDAS.................................................................................................................................................................... 220

PARTE IV – INFORMAÇÕES, EXERCÍCIOS E PROJETOS................................................... 225 I

INFORMAÇÃO COMPLEMENTAR I.1

I.2

I.3

227

BOAS PRÁTICAS............................................................................................................................................................... 227 I.1.1

REUTILIZAÇÃO DE CÓDIGO............................................................................................................................ 229

I.1.2

SOLID........................................................................................................................................................................ 229

I.1.3

DRY – DON’T REPEAT YOURSELF..............................................................................................................

I.1.4

KISS – KEEP IT SIMPLE, STUPID!................................................................................................................. 232

231

I.1.5

YAGNI – YOU AREN’T GONNA NEED IT.................................................................................................... 233

I.1.6

REFACTORING...................................................................................................................................................... 235

FERRAMENTAS................................................................................................................................................................. 236 I.2.1

FLOWGORITHM.................................................................................................................................................... 237

I.2.2

ANACONDA........................................................................................................................................................... 240

I.2.3

JUPYTER NOTEBOK...........................................................................................................................................

241

I.2.4

GOOGLE COLAB.................................................................................................................................................. 242

I.2.5

DEEPNOTE............................................................................................................................................................. 242

I.2.6

GIT.............................................................................................................................................................................. 243

I.2.7

UTILIZAÇÃO DA INTELIGÊNCIA ARTIFICIAL........................................................................................... 243

RESUMO DOS CONCEITOS........................................................................................................................................... 246

EXERCÍCIOS

255

E.1

INTRODUÇÃO...................................................................................................................................................................... 255

E.2

EXERCÍCIOS DE ALGORITMIA..................................................................................................................................... 256 E.2.1

VARIÁVEIS E OPERADORES......................................................................................................................... 256

E.2.2 INSTRUÇÕES DE DECISÃO.............................................................................................................................. 257 E.2.3 INSTRUÇÕES DE REPETIÇÃO........................................................................................................................ 259 E.2.4 SUBPROGRAMAS............................................................................................................................................... 262 E.2.5 ESTRUTURAS DE DADOS................................................................................................................................ 262 E.3

SOLUÇÕES........................................................................................................................................................................... 264 E.3.1

VARIÁVEIS E OPERADORES......................................................................................................................... 264

E.3.2 INSTRUÇÕES DE DECISÃO.............................................................................................................................. 278 E.3.3 INSTRUÇÕES DE REPETIÇÃO........................................................................................................................ 294 E.3.4 SUBPROGRAMAS............................................................................................................................................... 307 E.4

E.3.5 ESTRUTURAS DE DADOS................................................................................................................................

311

EXERCÍCIOS DE PYTHON...............................................................................................................................................

319

E.4.1

319

EXPRESSÕES........................................................................................................................................................

E.4.2 FUNÇÕES................................................................................................................................................................ 322 © FCA – EDITORA DE INFORMÁTICA

INTRODUÇÃO À ALGORITMIA E PROGRAMAÇÃO COM PYTHON

E.4.3 FUNÇÕES RECURSIVAS................................................................................................................................... 324 E.4.4 TUPLOS.................................................................................................................................................................... 326 E.4.5 LISTAS...................................................................................................................................................................... 329 E.4.6 DICIONÁRIOS........................................................................................................................................................

331

E.4.7 FICHEIROS.............................................................................................................................................................. 337

PROJETOS PYTHON P.1

PROJETO “GOALON”...................................................................................................................................................... 345 P.1.1

P.2

345

FICHEIROS DE DADOS...................................................................................................................................... 345

P.1.2

FICHEIRO “EQUIPAS”......................................................................................................................................... 345

P.1.3

APURAMENTO DAS EQUIPAS...................................................................................................................... 346

P.1.4

CALENDARIZAÇÃO DE JOGOS..................................................................................................................... 348

P.1.5

SIMULAÇÃO DE RESULTADOS..................................................................................................................... 350

“QUIZ DA SABEDORIA”................................................................................................................................................. 352 P.2.1

APRESENTAÇÃO GERAL................................................................................................................................. 352

P.2.2 COMO COMEÇAR................................................................................................................................................ 354 P.2.3 CARÁCTER EDUCATIVO DO PROJETO...................................................................................................... 357

REFERÊNCIAS BIBLIOGRÁFICAS

359

ÍNDICE REMISSIVO

361

XII

SOBRE O LIVRO Cada vez mais se fala de transição digital e das necessidades que as empresas têm para desenvolver todo um processo de digitalização. Para tal, o mercado necessita de ter profissionais que sejam capazes de olhar para um problema e desenhar uma solução capaz de ajudar a mitigar o problema. Este conhecimento é adquirido através da compreensão de um conjunto de conteúdo fundamental a nível da algoritmia e da estrutura de dados e aplicado através de uma linguagem de programação. Neste campo, é de destacar o Python como sendo uma linguagem completa que consegue ajudar a responder a diversas tipologias de problemas. Este livro pretende ajudar a criar novos programadores capazes de, perante um problema, definir uma estrutura e implementá-la em Python.

O QUE POSSO ENCONTRAR NESTE LIVRO? Este livro tem como principal objetivo introduzir os leitores na área das ciências da computação, sendo que descreve os princípios básicos associados à algoritmia e à programação. Em primeiro lugar, apresenta-se um conjunto de conceitos básicos essenciais à compreensão da área. No capítulo da algoritmia, são abordados todos os termos e conteúdos essenciais para compreender um problema e desenhar uma possível solução. O capítulo de Python introduz a linguagem e explica de que forma os conceitos descritos em algoritmia podem ser utilizados e aplicados. De modo a consolidar todos os conceitos teóricos apresentados, descreve-se, ao longo da obra, a implementação de um projeto prático completo e de um projeto extra que permite demonstrar a aplicabilidade do Python noutras áreas, como a gamificação. O leitor poderá ainda testar o seu conhecimento através da realização de mais de 50 exercícios distribuídos entre algoritmia e Python. Este livro introduz também a temática da Inteligência Artificial e ajuda os leitores a entrar no mundo da algoritmia e da programação com a ajuda de ferramentas como o ChatGPT.

PÚBLICO-ALVO Este livro destina-se a professores e alunos de cursos/disciplinas de Informática, Sistemas de Informação, Ciências de Computadores e restantes engenharias, a profissionais tecnológicos, como programadores e analistas de dados, que necessitam de se atualizar e revisitar conteúdos, bem como a autodidatas que pretendam aprender a programar ou a quem queira perceber ou iniciar-se na programação produzida pela Inteligência Artificial (por exemplo, ChatGPT, Bard). Esta é também uma obra fundamental para quem pretende aprender a programar e compreender a base da algoritmia e da programação. Este livro é adequado a dois tipos de © FCA – EDITORA DE INFORMÁTICA

INTRODUÇÃO À ALGORITMIA E PROGRAMAÇÃO COM PYTHON públicos: quem já tem algumas noções de programação e pretende aprofundar esse conhecimento; e quem está a iniciar e pretende ter uma base sólida em programação.

CONVENÇÕES Ao longo deste livro, optou-se por seguir um conjunto de convenções que facilitam a interpretação do texto e do código apresentados. Assim, todos os excertos de código são apresentados no formato seguinte: name = "Phyton" print("Olá" + name)

Por sua vez, as notas ou observações importantes poderão ser encontradas no interior de uma secção semelhante à seguinte: Nota importante Esta é uma nota ou observação importante.

ORGANIZAÇÃO DO LIVRO Este livro está organizado em quatro partes: ■

Parte I (“Contextualização”) – explicação do contexto do livro e da relação entre algoritmia e programação e apresentação do projeto “GoalOn”;

■

Parte II (“Algoritmia”) – apresentação da algoritmia e da estrutura de dados;

■

Parte III (“Python”) – introdução ao Python e apresentação de exemplos práticos como forma de aplicar os conceitos de algoritmia;

■

Parte IV (“Informações, exercícios e projetos”) – informações complementares, boas práticas e aplicação do conhecimento de algoritmia e programação para o desenvolvimento de um projeto prático completo.

Após a exposição dos conceitos do livro na Parte I, surgem duas partes dedicadas às temáticas principais do livro: algoritmia (Parte II); e programação (Parte III). As Partes II e III são complementadas por uma quarta parte, na qual é aplicado, em exercícios e num projeto prático, todo o conhecimento ao nível da algoritmia e da programação assimilado nos capítulos anteriores. A Parte IV inclui ainda um conjunto de informações complementares e um projeto, de modo que o leitor crie um sistema gamificado em Python para testar o conhecimento aprendido. Este livro contém 10 capítulos: os primeiros sete abordam as diversas matérias do livro e podem ser lidos sequencialmente ou, se o leitor preferir, alternadamente (isto é, sem respeitar a ordem de capítulos apresentadas); e os últimos três capítulos apresentam informações complementares, dicas e boas práticas de programação (Capítulo I), exercícios de algoritmia e Python (Capítulo E) e a realização de dois projetos práticos (Capítulo P). XVI

SOBRE O LIVRO A leitura não sequencial dos capítulos é possível, estando as poucas dependências entre capítulos devidamente identificadas. Por exemplo, o leitor poderá ler apenas uma parte da obra (por exemplo, a dedicada à algoritmia) ou até ler apenas um capítulo específico (por exemplo, o Capítulo E, com os exercícios de Python). Toda a informação abordada neste livro encontra-se resumida no Capítulo I, no qual se compila um conjunto de boas práticas, terminologias e conceitos fundamentais à compreensão desta temática. Este livro disponibiliza, então, dois projetos: uma aplicação completa para gerir uma competição desportiva; e um código bónus que ajuda a implementar um sistema básico de gamificação recorrendo à linguagem Python. Contextualização Da algoritmia à programação (Capítulo 1)

Apresentação dos projetos (Capítulo 2) Parte I

Algoritmia Solução algorítmica (Capítulo 3)

Python Instruções e estruturas (Capítulo 4)

Subprogramas (Capítulo 5)

Introdução ao Python (Capítulo 6)

Instruções, estruturas e bibliotecas (Capítulo 7)

Parte II

Parte III

Informações, exercícios e projetos Informação complementar (Capítulo I)

Exercícios (Capítulo E)

Projetos Python (Capítulo P) Parte IV

ESTRUTURA DAS PARTES I, II, III E IV DA OBRA

SUPORTE Caso o leitor encontre informação que lhe pareça incorreta ou tenha sugestões em relação ao conteúdo de alguma secção do livro, não hesite e envie um email com as suas questões para Filipe Portela (cfp@filipeportela.com) ou Tiago C. Pereira (tiagocarvalhopereira@ gmail.com). Eventuais alterações e erratas serão publicadas no site da editora, em http:// www.fca.pt. Poderá aceder a todo o código-fonte deste projeto na página do livro no site da editora FCA, em http://www.fca.pt.

XVII

1 DA ALGORITMIA À PROGRAMAÇÃO Um programa começa na algoritmia e vai até à programação e envolve um conjunto de termos-base que ajudam a compreender todo o fluxo. Este capítulo apresenta os diversos conceitos associados à área da ciência dos computadores.

1.1 FUNDAMENTAÇÃO E CONCEITOS Um computador é formado por componentes físicos, como a Unidade Central de Processamento (CPU, do inglês Central Processing Unit), o rato, a memória, entre outros pelos quais os sinais elétricos podem ser convertidos em dados e, posteriormente, em informações. Estes componentes são chamados hardware e utilizam a linguagem binária, que é a linguagem de máquina composta apenas por bits, que são zeros e uns. No entanto, e para facilitar a interpretação da linguagem binária por parte do ser humano, foi criado o conceito de software: o meio pelo qual a linguagem de máquina pode ser compilada ou interpretada, através de códigos criados em uma linguagem intermédia, para idiomas que conhecemos, como o português, de modo que os dados trabalhados pela máquina possam ser interpretados como informação. O primeiro conceito a clarificar neste livro é a diferença entre o que é informática e informação. ■

Informática: ■

■

Informática = informação + automática; Engloba toda a atividade relacionada com o desenvolvimento e o uso dos computadores que permita aprimorar e automatizar tarefas em qualquer área de atuação da sociedade; Pode ser definida como a ciência do tratamento automático das informações.

Informação: ■

Conjunto de dados que, quando fornecido adequada e atempadamente, melhora o conhecimento da pessoa que o recebe, que fica mais habilitada a desenvolver determinada atividade; © FCA – EDITORA DE INFORMÁTICA

INTRODUÇÃO À ALGORITMIA E PROGRAMAÇÃO COM PYTHON Facto ou dado que valoriza o conhecimento (que dá mais conhecimento) e é suscetível de ser representado, a fim de ser arquivado, tratado ou comunicado;

■

Caracterizada pela intangibilidade – não se pode “tocar”:

■

– Não tem existência física. – A informação necessita de um suporte (de forma física) para ser percebida pelo recetor; – Suporte de informação é qualquer meio físico que sofre alterações, temporária ou permanentemente. Codificação própria – para perceber a informação, o recetor tem de conhecer o código. Se for um jornal, o código é o das regras da escrita da língua do país.

■

Para processar e converter os dados em informação, é necessário ter um computador, ou seja, uma máquina capaz de receber, armazenar, tratar e produzir informações de forma automática, com grande rapidez e precisão. Os dados são organizados e tratados de modo a ser possível obter conhecimento que potencia (ou promove) a sabedoria, como mostra a pirâmide da Figura 1.1. + valor Sabedoria

+ significado

+ contexto

Conhecimento

Informação

Dados

Compreensão, integração, aplicabilidade, reflexão, ação, padrões, apoio à decisão Ideia, aprendizagem, noção, conceito, comparação, discussão, pensamento Organização, estruturação, utilidade, calculada Factos individuais, figuras, sinais, medidas

FIGURA 1.1 – PIRÂMIDE DO CONHECIMENTO

A pirâmide do conhecimento é processada por um ser humano após a interpretação das tarefas realizadas por um programa de computador que envolve a definição de um algoritmo para a resolução de um problema. Um algoritmo é representado através de expressões simbólicas para descrever e encontrar a solução de problemas do mundo real. Deste modo, as estruturas de dados representam, de forma simbólica, entidades e objetos do mundo real e definem a parte estática de um algoritmo. A manipulação das estruturas de dados através de declarações e instruções precisas de controlo define a parte dinâmica de um algoritmo. Este conjunto de estruturas de dados e de instruções de controlo constitui formalmente um algoritmo para a resolução de problemas. Programa (ou software) é um conjunto de instruções a serem executadas pelo computador, já instrução corresponde a uma operação que o processador executa (por exemplo, soma, carregamento, etc.). Para que o processador possa executar as instruções, estas 4

6 INTRODUÇÃO AO PYTHON Qualquer linguagem de programação permite implementar os problemas que têm uma solução algorítmica; contudo, o Python continua a ser a mais preferida segundo a sondagem do IEEE Spectrum.

6.1 PYTHON – O QUE É E PARA QUE SERVE O Python é uma popular linguagem de programação geral que foi lançada pela primeira vez em 1991 por Guido van Rossum. Ao longo dos anos, a linguagem sofreu mudanças significativas, resultando em várias versões com diferentes recursos e melhorias. Eis uma breve história e visão geral das principais diferenças das versões do Python: ■

Série Python 1.x (1994-2000) – o primeiro grande lançamento do Python, com versões variando de 1.0 a 1.6. Incluiu recursos básicos, como funções, módulos, classes e exceções;

■

Série Python 2.x (2000-2020) – atualização significativa que introduziu vários novos recursos, como as compreensões de lista, os iteradores, os geradores e muito mais. Também incluiu compatibilidade com versões anteriores do Python 1.x. A versão mais amplamente utilizada do Python 2.x é o Python 2.7, que foi lançado em 2010 e atingiu o seu fim de vida em 2020;

■

Série Python 3.x (2008-presente) – grande revisão da linguagem, com mudanças significativas na sintaxe e na funcionalidade, tornando-a incompatível com versões anteriores. O objetivo desta versão era limpar e simplificar a linguagem. O Python 3.x introduziu vários recursos novos, incluindo o suporte Unicode, o melhor tratamento de exceções e a melhor concorrência. A versão mais recente do Python 3.x é o Python 3.10, que foi lançado em 2021.

O Python é uma linguagem de programação geral que é usada em muitas áreas diferentes, desde a ciência de dados e a aprendizagem de máquina, até ao desenvolvimento web e à automação de tarefas. Algumas das principais áreas em que o Python é usado são: © FCA – EDITORA DE INFORMÁTICA

179

INTRODUÇÃO À ALGORITMIA E PROGRAMAÇÃO COM PYTHON

■

Ciência de dados – o Python é uma das principais linguagens usadas na ciência de dados, graças às suas bibliotecas poderosas, como NumPy, Pandas e Matplotlib;

■

Aprendizagem de máquina – o Python é amplamente utilizado na aprendizagem de máquina e na Inteligência Artificial (IA), devido às suas bibliotecas, como Scikit-learn, TensorFlow e PyTorch;

■

Desenvolvimento web – o Python é usado em muitos frameworks web populares, como Django, Flask e Pyramid;

■

Automação de tarefas – o Python é uma ótima escolha para automação de tarefas, como scripts de shell e tarefas de processamento em lote;

■

Jogos – o Python é usado em jogos, graças a bibliotecas como Pygame;

■

Internet das Coisas (IoT, do inglês Internet of Things) – o Python é frequentemente utilizado em projetos de IoT, devido à sua facilidade de uso e suporte para várias plataformas;

■

Finanças – o Python é amplamente utilizado em finanças para análise de dados, modelagem de risco e previsão financeira;

■

Educação – o Python é uma linguagem de programação popular em programas de ciência da computação e é frequentemente usado para ensinar conceitos de programação.

Em resumo, o Python passou por mudanças significativas ao longo dos anos, com cada versão a introduzir novos recursos e melhorias. O Python 2.x foi a versão mais amplamente utilizada durante muitos anos, mas agora atingiu o seu fim de vida, e o Python 3.x é a versão atual e recomendada.

6.2 ALGORITMO VERSUS PROGRAMA O algoritmo permite descrever o tipo de operações, funções e raciocínio lógico na resolução de problemas. No entanto, não é possível executar essas mesmas instruções num computador. Para compreender o que é algoritmia, as suas características e representação, aconselha-se a leitura da Secção 1.5.

Um programa consiste em instruções especificadas numa linguagem de programação passível de ser compilada/interpretada para uma linguagem muito próxima da linguagem de máquina inteligível pelo computador, permitindo, desta forma, a execução de instruções ou bloco de instruções. Trata-se do “correr do programa”, ou seja, a execução do programa. A explicação do que é programação, para que serve e dos paradigmas existentes encontra-se na Secção 1.6.3. 180

I INFORMAÇÃO COMPLEMENTAR Este capítulo apresenta um conjunto de boas práticas transversais a algoritmia e programação (que inclui o Python), o resumo dos principais conceitos explanados nos Capítulos 3 a 7 e algumas das principais ferramentas a utilizar neste contexto.

I.1 BOAS PRÁTICAS A adoção de boas práticas de programação é vital para ajudar os programadores a criarem o melhor código possível: ■

O mundo é ágil e move-se muito rápido;

■

Os clientes exigem mais recursos de forma rápida e com poucos custos.

Como exemplo de boas práticas recomenda-se a leitura do artigo “15 Best Practices to follow” (Kaur, 2021).

De entre as várias dicas, regras e melhores práticas para aumentar a qualidade do código, destacam-se: ■

Aderir a um guia de estilo próprio (por exemplo, indentação constante, nome de variáveis, entre outros aspetos);

■

Não “inventar a roda”;

■

Ter a certeza de que o código é legível;

■

Comentar e documentar tudo o que é produzido, evitando comentários óbvios;

■

Aplicar os princípios DRY (Don’t Repeat Yourself) e KISS (Keep It Simple, Stupid!);

■

Testar o código, escrever casos de teste e não esquecer dos casos extremos – zeros, strings/listas vazias, nulos, etc.;

■

Ter mensagens amigáveis e explicativas dos erros;

■

Limitar o tamanho da linha de código;

■

227

INTRODUÇÃO À ALGORITMIA E PROGRAMAÇÃO COM PYTHON

Subprogramas

Consola

Código-fonte

Executar

Variáveis

Fluxograma Zona de edição

FIGURA I.6 – AMBIENTE DE TRABALHO NO FLOWGORITHM

No Flowgorithm, a consola (Figura I.7) é uma ferramenta que permite exibir as informações de saída de um programa num ambiente de linha de comando. Esta ferramenta é útil para depurar um programa, testar resultados e interagir com o programa através da entrada de comandos ou dados.

FIGURA I.7 – CONSOLA FLOWGORITHM 238

EXERCÍCIOS E.3.5

ESTRUTURAS DE DADOS

E.3.5.1

EXERCÍCIO 24

311

INTRODUÇÃO À ALGORITMIA E PROGRAMAÇÃO COM PYTHON Escreva um programa em Python para ler o dicionário de jogadores em observação e listar para cada jogador as informações do seu registo (item) e a sua avaliação. No fim da listagem, dar: ■

O nome e a avaliação do jogador com o maior valor;

■

O nome do jogador com menos golos marcados;

■

A média de idades;

■

O total dos tempos de penalização;

■

A percentagem de jogadores com idades entre os 18 e os 20 anos. #Resposta Problema 28 #dicJogadores={'1': ['João', 18, 170, 70, 12, 20, 4, 3.5], '2': ['Quim', 20, 180, 81, 20, 30, 0, 4.6],\ #'3': ['Beto', 25, 160, 65, 2, 12, 12, 1.1], '4': ['Pedro', 17, 180, 82, 20, 29, 4, 4.8]} # Para experimentar # Carregamento do dicionário dicJogadores={} num=input("Número do jogador: ") while num!="": nome=input("Nome: ") idade=int(input("Idade: ")) altura=int(input("Altura (cm): ")) peso=int(input("Peso (kg): ")) golos=int(input("Número de golos no último campeonato: ")) presencas=int(input("Número de presenças no último campeonato: ")) penalidades=int(input("Penalidades (em minutos) no último campeonato: ")) fator=float(input("Fator da Federação (entre 0 e 5): ")) dicJogadores[num]=[nome,idade,altura,peso,golos,presencas, penalidades,fator] num=input("Número do jogador: ") print(dicJogadores) # Cabeçalho print("---------------------------------------------------------------------------------------------------------------------------") #imprimir cabeçalho print('{:10}{:20}{:10}{:10}{:10}{:10}{:15}{:15}{:10}{:10}'.format("número","nome","idade", "Altura", "Peso", "Golos",\ "Presenças","Penalidades","Fator","Avaliação")) print("---------------------------------------------------------------------------------------------------------------------------") max=-1 min=9999 sIdade=0 sTempos=0 contEntre18e20=0

336

P PROJETOS PYTHON Este capítulo tem como principal propósito apresentar dois projetos Python: “GoalOn”; e “Quiz da Sabedoria”. O primeiro projeto apresenta um simulador da fase final de um mundial, aplicável a qualquer desporto, que começa por selecionar as equipas apuradas para os oitavos de final e simula os golos e os resultados finais de cada etapa (quartos de final, meias-finais e final). O segundo projeto tem por base o desenvolvimento de um quiz para testar o conhecimento de um livro.

P.1 PROJETO “GOALON” O código do projeto foi desenvolvido segundo o método TD2CE, apresentado na Secção 3.7, correspondendo à etapa quatro, codificação, e à etapa cinco, traçagem ou seguimento. Além deste método, foram implementadas as boas práticas enunciadas no Capítulo I, como a modularização, a reutilização de código e a documentação do código, além das especificações da linguagem Python, no que toca a acesso de ficheiros e a manipulação de estruturas de dados e de instruções.

P.1.1

FICHEIROS DE DADOS

A implementação do projeto implica o uso de ficheiros de dados, para armazenamento de informação após a execução do programa simulador ou como suporte dos inputs do programa. Caso estes não estejam definidos, é necessário definir a sua estrutura de campos de informação. Passamos a analisar, nas Secções P.1.2 a P.1.5, cada um destes ficheiros e respetivos campos.

P.1.2

FICHEIRO “EQUIPAS”

O ficheiro fornecido com o nome “equipas.csv” é um ficheiro de dados do tipo de ficheiro de texto separado por vírgulas (.csv). Na verdade, a informação do ficheiro está separada por ponto e vírgula (;), o que se deve à formatação e às configurações regionais dos sistemas operativos que diferem do europeu, como o americano, nomeadamente no que diz respeito à separação de milhares e de casas decimais. © FCA – EDITORA DE INFORMÁTICA

345

INTRODUÇÃO À ALGORITMIA E PROGRAMAÇÃO COM PYTHON

■

Gerar aleatoriamente uma sequência de jogos: equipas_por_atribuir=random.sample(range(1, len(equipas_apuradas)), len(equipas_apuradas)-1)

■

Percorrer a estrutura equipas duas a duas para determinar a equipa que joga em casa e a que joga fora: eq_atual=0 Procurar a eliminatória nas chaves do dicionário calendário for jg in calendario.keys(): if eliminatoria in jg:

■

Atribuir cada equipa a jogar em casa e fora: calendario[jg] [2]= equipas_por_atribuir[eq_atual] calendario[jg] [3]=equipas_por_atribuir[eq_atual+1]

■

E, finalmente, prosseguir na estrutura para as próximas duas equipas, até se chegar ao fim de todas as equipas: eq_atual+=2

O programa principal irá invocar as funções e os procedimentos necessários para poder obter o calendário: ■

Chamar o procedimento apura_equipas: apura_equipas()

■

Gerar o calendário: criar_calendario()

■

Alocar as equipas de acordo com a eliminatória: atribuir_jogos("oitavos")

■

Obter o calendário: print(calendario)

P.1.5

SIMULAÇÃO DE RESULTADOS

De acordo com a especificação, os resultados são gerados de forma aleatória e permitirão eliminar as equipas nas várias eliminatórias até à fase final. Serão utilizadas as estruturas de dicionário calendario para armazenar o resultado e a atribuição das equipas para a eliminatória seguinte. 350