Python - Algoritmia e Programação Web by Grupo Lidel

Arte -Python.pdf

CMY

17/04/15

16:14

Distribuição

Lidel – edições técnicas, lda

Sede R. D. Estefânia, 183, R/C Dto. – 1049-057 LISBOA Tel: +351 213 511 448 * Fax: +351 213 522 684 Revenda: revenda@lidel.pt Exportação: depinternacional@lidel.pt Venda online: livraria@lidel.pt Marketing: marketing@lidel.pt Livraria Av. Praia da Vitória, 14 – 1000-247 LISBOA Tel: +351 213 511 448 * Fax: +351 213 173 259 livraria@lidel.pt Edição

FCA – Editora de Informática

Av. Praia da Vitória, 14 – 1000-247 LISBOA Tel: +351 213 511 448 Email: fca@fca.pt Copyright © abril 2015 FCA – Editora de Informática, Lda. ISBN: 978-972-722-813-3 Capa: José M. Ferrão – Look-Ahead Pré-impressão: Alice Simões Impressão e acabamento: Tipografia Lousanense, Lda. – Lousã Depósito Legal N.º 391603/15 Livro segundo o Novo Acordo Ortográfico 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. Os nomes comerciais referenciados neste livro têm patente registada.

Marcas Registadas de FCA – Editora de Informática, Lda. – ®

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 0. SOBRE O LIVRO ................................................................................................ 1 0.1. A linguagem Python........................................................................................................................... 1 0.2. Organização do livro .......................................................................................................................... 1 0.3. O público-alvo ..................................................................................................................................... 2 0.4. Complementos no site da editora...................................................................................................... 3 0.5. Convenções utilizadas ........................................................................................................................ 3 0.6. Suporte ................................................................................................................................................. 4 1. INTRODUÇÃO ................................................................................................... 5 1.1. Desenvolvimento de software para a web ......................................................................................... 5 1.2. Algoritmia e estruturas de dados ..................................................................................................... 8 1.3. Engenharia de software ..................................................................................................................... 11 1.4. Engenharia web .................................................................................................................................. 15 1.4.1. Concorrência ........................................................................................................................... 17 1.4.2. Número de transações na rede ............................................................................................. 17 1.4.3. Desempenho............................................................................................................................ 17 1.4.4. Disponibilidade permanente ................................................................................................ 18 1.4.5. Orientação aos dados ............................................................................................................. 18 1.4.6. Sensibilidade estética ............................................................................................................. 18 1.4.7. Usabilidade.............................................................................................................................. 19 1.4.8. Evolução contínua do software .............................................................................................. 19 1.4.9. Segurança informática ........................................................................................................... 19 1.5. A web semântica (web 3.0) ................................................................................................................ 20 1.6. Desenvolvimento de software em Python....................................................................................... 23 2. LINGUAGEM DE PROGRAMAÇÃO PYTHON ............................................................... 25 2.1. A evolução da linguagem Python................................................................................................... 26 2.2. Os diferentes paradigmas da programação................................................................................... 26 2.3. Elementos da linguagem de programação Python....................................................................... 29 2.4. Instalação e configuração do ambiente de programação ............................................................. 31 2.5. Utilização de um editor Python ...................................................................................................... 34 2.6. Variáveis, valores e tipos de dados................................................................................................. 41 2.7. Instruções de leitura e escrita .......................................................................................................... 43 2.8. Expressões matemáticas simples .................................................................................................... 44 2.9. Ciclos e estruturas condicionais ...................................................................................................... 45 2.9.1. Estrutura if ............................................................................................................................. 45 2.9.2. Ciclo for .................................................................................................................................. 46 2.10. Módulos e funções .......................................................................................................................... 47 2.11. Vetores e matrizes (arrays) ............................................................................................................. 50 3. ALGORITMOS E ESTRUTURAS DE DADOS EM PYTHON ................................................ 57 3.1. Tipos e estruturas de dados ............................................................................................................. 57 3.2. Processamento de strings ................................................................................................................. 59 © FCA – Editora de Informática

VIII

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

3.3. Pilhas (stacks) ..................................................................................................................................... 64 3.3.1. Representação de uma pilha ................................................................................................. 65 3.3.2. Operação de inserção (push) .................................................................................................. 66 3.3.3. Operação de eliminação (pop) ............................................................................................... 67 3.3.4. Implementação em Python.................................................................................................... 68 3.4. Filas (queues) ...................................................................................................................................... 70 3.4.1. Representação de uma fila .................................................................................................... 72 3.4.2. Inserção numa fila .................................................................................................................. 73 3.4.3. Eliminação numa fila ............................................................................................................. 74 3.4.4. Implementação em Python.................................................................................................... 75 3.5. Listas encadeadas.............................................................................................................................. 76 3.5.1. Estruturas de dados encadeadas .......................................................................................... 77 3.5.2. Listas em Python .................................................................................................................... 78 3.6 . Estruturas de dados não lineares ................................................................................................... 81 3.6.1. Terminologia e definições para a representação de árvores ............................................. 81 3.6.2. Representação encadeada...................................................................................................... 84 3.6.3. Algoritmos de travessia ......................................................................................................... 86 3.6.4. Inserção ordenada numa árvore binária.............................................................................. 88 3.6.5. Implementação em Python de uma árvore de pesquisa ................................................... 90 3.7. Grafos ................................................................................................................................................. 93 3.7.1. Características de um grafo ................................................................................................... 93 3.7.1.1. Grafo completo .......................................................................................................... 94 3.7.1.2. Grafo conexo .............................................................................................................. 95 3.7.1.3. Grafo não conexo ....................................................................................................... 95 3.7.2. Representação de um grafo ................................................................................................... 96 3.7.2.1. Representação matricial ............................................................................................ 96 3.7.2.2. Representação encadeada ......................................................................................... 96 3.7.3. Algoritmos para travessia de um grafo ............................................................................... 99 3.7.3.1. Travessia (ou percurso) em profundidade (Depth-First-Search – DFS) ............... 99 3.7.3.2. Travessia em largura (Breath-First-Search – BFS) ................................................. 102 3.8. Conjuntos e dicionários em Python .............................................................................................. 105 3.8.1. Manipulação de dicionários em Python ............................................................................ 105 3.8.2. Representação de grafos com dicionários ......................................................................... 109 4. PROGRAMAÇÃO ORIENTADA AOS OBJETOS EM PYTHON ........................................... 113 4.1. Abstração dos dados e a orientação aos objetos ......................................................................... 113 4.2. Design de software com orientação aos objetos ............................................................................ 116 4.2.1. Conceitos e mecanismos orientados aos objetos .............................................................. 117 4.2.2. Análise orientada aos objetos.............................................................................................. 120 4.3. Programação orientada aos objetos .............................................................................................. 122 4.3.1. Classes e objetos em Python ................................................................................................ 123 4.3.1.1. Estrutura de uma classe em Python ...................................................................... 125 4.3.1.2. Especificação de atributos ...................................................................................... 127 4.3.1.3. Comportamentos dos objetos................................................................................. 128 4.3.1.4. Método construtor init ......................................................................................... 130 4.3.1.5. Atributos de classe................................................................................................... 132 © FCA – Editora de Informática

ÍNDICE GERAL

4.3.1.6. Encapsulamento....................................................................................................... 134 4.3.2. Mecanismo de herança ........................................................................................................ 135 4.3.2.1. Herança simples....................................................................................................... 136 4.3.2.2. Herança múltipla ..................................................................................................... 141 4.3.2.3. Polimorfismo ............................................................................................................ 142 4.4. Resumo dos elementos principais da linguagem ....................................................................... 145 4.4.1. Módulos e funções................................................................................................................ 146 4.4.2. Tipagem dinâmica ................................................................................................................ 147 4.4.3. Classes e objetos.................................................................................................................... 147 5. ARQUITETURA DE APLICAÇÕES WEB .................................................................. 151 5.1. Componentes de uma aplicação web ............................................................................................ 151 5.2. Arquitetura em três camadas ........................................................................................................ 152 5.3. Desenvolvimento de bases de dados............................................................................................ 154 5.4. Componentes e ferramentas de desenvolvimento ..................................................................... 154 5.4.1. Ambiente de desenvolvimento de software ....................................................................... 156 5.4.1.1. IDE NetBeans ........................................................................................................... 156 5.4.1.2. IDE Eclipse ............................................................................................................... 157 5.4.1.3. IDE Wingware.......................................................................................................... 159 5.4.1.4. Ferramentas Microsoft para a programação em Python .................................... 160 5.4.2. Servidores web ....................................................................................................................... 161 5.4.3. Linguagens de programação do lado do servidor ........................................................... 165 5.4.3.1. Python ....................................................................................................................... 166 5.4.3.2. Java ............................................................................................................................ 167 5.4.3.3. Ruby .......................................................................................................................... 167 5.4.3.4. ASP.NET e C# .......................................................................................................... 168 5.4.3.5. PHP............................................................................................................................ 169 5.4.4. Linguagens e bibliotecas do lado do cliente ..................................................................... 169 5.4.4.1. HTML5 ...................................................................................................................... 170 5.4.4.2. JavaScript .................................................................................................................. 172 5.4.4.3. Cascading Style Sheets (CSS) .................................................................................... 173 5.4.4.4. jQuery........................................................................................................................ 174 5.4.4.5. AngularJS.................................................................................................................. 176 5.4.5. Gestor de bases de dados .................................................................................................... 177 6. TECNOLOGIAS DE PROGRAMAÇÃO WEB EM PYTHON ............................................... 181 6.1. Programação Python para a web ................................................................................................... 181 6.2. Desenvolvimento de aplicações web ............................................................................................. 183 6.2.1. Instalação da biblioteca CherryPy ...................................................................................... 184 6.2.2. Primeira aplicação web em Python ..................................................................................... 185 6.2.3. Integração de HTML, JavaScript e CSS.............................................................................. 189 6.2.4. Sistema de gestão de ficheiros ............................................................................................ 190 6.2.5. Exemplo de um conversor de unidades de medida......................................................... 192 6.2.6. Exemplo de um sistema de autenticação com login ......................................................... 195 6.3. Persistência e bases de dados ........................................................................................................ 200 6.3.1. Gestão e armazenamento de ficheiros ............................................................................... 201 6.3.2. Motor de base de dados SQLite .......................................................................................... 204 © FCA – Editora de Informática

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

6.4. Processamento de ficheiros XML em Python .............................................................................. 205 6.4.1. Sintaxe XML .......................................................................................................................... 205 6.4.2. XML parser interfaces ........................................................................................................... 206 6.4.3. Parser XML com a API SAX................................................................................................. 208 6.4.4. Parser XML com a API DOM .............................................................................................. 211 7. PYTHON WEB FRAMEWORKS ........................................................................... 215 7.1. Frameworks Python para o desenvolvimento web ....................................................................... 215 7.2. Django web framework ..................................................................................................................... 216 7.3. Instalação da framework Django..................................................................................................... 218 7.4. Criar um projeto Django ................................................................................................................ 220 7.5. Configuração de um gestor de bases de dados ........................................................................... 223 7.6. Servidor de desenvolvimento ....................................................................................................... 224 7.7. Modelos Django e interação com bases de dados ....................................................................... 226 7.7.1. Projetos e aplicações Django ............................................................................................... 227 7.7.2. Criação de uma aplicação (Django app) ............................................................................. 227 7.7.3. Ativação de modelos Django .............................................................................................. 230 7.7.4. Django API ............................................................................................................................ 234 7.7.5. Administração e desenvolvimento web ............................................................................. 236 7.7.5.1. Criação da conta de administrador ....................................................................... 237 7.7.5.2. Servidor web de desenvolvimento ......................................................................... 237 7.7.5.3. Gestão de aplicações (site admin) ........................................................................... 239 7.7.5.4. Desenvolvimento de uma aplicação web .............................................................. 242 7.7.5.5. Django views ............................................................................................................. 245 7.7.5.6. Django templates ....................................................................................................... 249 7.8. Web2py enterprise framework ........................................................................................................ 253 7.8.1. Instalação da framework web2py ......................................................................................... 255 7.8.2. Servidor de desenvolvimento web2py .............................................................................. 257 7.8.3. Interface de administração web2py ................................................................................... 259 7.8.4. Desenvolvimento de aplicações web2py ........................................................................... 262 7.8.4.1. Primeira aplicação web2py .................................................................................... 262 7.8.5. Python in the cloud ................................................................................................................ 270 8. PROJETO DE SOFTWARE WEB .......................................................................... 279 8.1. Especificação dos requisitos do domínio ..................................................................................... 279 8.1.1. Descrição do domínio .......................................................................................................... 279 8.1.2. Requisitos funcionais ........................................................................................................... 280 8.1.3. Requisitos não funcionais .................................................................................................... 281 8.2. Software design e modelo de dados................................................................................................ 283 8.3. Desenvolvimento da aplicação web .............................................................................................. 284 8.3.1. Implementação do software em Django .............................................................................. 284 8.3.1.1. Projeto Django .......................................................................................................... 284 8.3.1.2. Aplicação Django e desenvolvimento dos modelos............................................ 285 8.3.1.3. Django admin site ..................................................................................................... 288 8.3.1.4. Ativação dos modelos Django ............................................................................... 291 8.3.2. Testes à aplicação (protótipo) web ...................................................................................... 293 8.4. Conclusões e considerações finais ................................................................................................ 298 © FCA – Editora de Informática

ÍNDICE GERAL

BIBLIOGRAFIA ................................................................................................. 303 GLOSSÁRIO DE TERMOS – PORTUGUÊS EUROPEU/PORTUGUÊS DO BRASIL ...................... 307 ÍNDICE REMISSIVO ........................................................................................... 309

0 0.1

SOBRE O LIVRO

A LINGUAGEM PYTHON

O desenvolvimento de software está atualmente focado na programação e integração de aplicações para a World Wide Web (web). Este livro tem como principal objetivo apresentar as principais tecnologias e tendências de programação de aplicações web com a linguagem Python. Neste sentido, são apresentadas as principais características da linguagem de programação, incluindo um conjunto de algoritmos e estruturas de dados e os mecanismos de programação orientada aos objetos. A influência e aplicação da linguagem Python tem vindo a crescer em diferentes áreas académicas e empresariais. Globalmente, um número significativo de universidades, incluindo universidades portuguesas, tem vindo a aplicar esta linguagem para introduzir as ciências da computação, a algoritmia, a engenharia de software e a programação de computadores. No contexto empresarial, o Python tem sido aplicado no desenvolvimento de jogos digitais, na construção de aplicações para a gestão de dados científicos e no desenvolvimento de aplicações web.

0.2

ORGANIZAÇÃO DO LIVRO

O primeiro capítulo (“Introdução”) apresenta os fundamentos para a construção de aplicações web, incluindo a arquitetura em camadas para o desenvolvimento e programação de aplicações web com bases de dados, e a área relacionada das tecnologias de programação do lado do servidor. O objetivo principal da introdução é a compreensão dos requisitos e arquitetura de software para o desenvolvimento de aplicações web. Independentemente das linguagens de programação a aplicar, é necessário compreender a integração dos componentes de software para o desenvolvimento de uma aplicação web com ligação a uma ou mais bases de dados. Neste capítulo é também abordada a importância da algoritmia na área das ciências da computação, a evolução da engenharia de software conducente à engenharia web e a nova geração da web: a web Semântica. Nos capítulos seguintes (Capítulo 2 – “Linguagem de Programação Python”, Capítulo 3 – “Algoritmos e Estruturas de Dados em Python”, e Capítulo 4 – “Programação Orientada aos Objetos em Python”) são analisados os principais mecanismos para o desenvolvimento de software com esta linguagem, incluindo algoritmos e estruturas de © FCA – Editora de Informática

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

dados especificados em Python. Dado que a linguagem Python incorpora o paradigma de programação com orientação aos objetos, alguns exemplos (programas) com classes Python são implementados. Em síntese, o segundo, o terceiro e o quarto capítulos focam-se na linguagem de programação Python e nas principais características e técnicas de programação para o desenvolvimento de aplicações. Neste sentido, a linguagem Python é inicialmente apresentada na sua vertente de programação procedimental com um conjunto de algoritmos e estruturas de dados. O Capítulo 4 – “Programação Orientada aos Objetos em Python” – introduz o paradigma de programação com orientação aos objetos. A segunda parte do livro foca-se no desenvolvimento e implementação de aplicações web. O leitor no final do livro será capaz de desenvolver aplicações web em Python com recurso a frameworks existentes e com ligação a bases de dados, incluindo o gestor SQLite. Adicionalmente, poderá desenvolver competências para aplicar boas práticas de construção de software para a web, assim como compreender a arquitetura de software subjacente ao desenvolvimento de aplicações web. O Capítulo 5 – “Arquitetura de Aplicações Web” – apresenta os principais componentes de uma aplicação web com base na arquitetura de software em três camadas. O Capítulo 6 – “Tecnologias de Programação Web em Python” –, por sua vez, dá a conhecer um conjunto de tecnologias de programação para o desenvolvimento de aplicações web em Python. No mesmo sentido,os Capítulos 7 e 8, respetivamente intitulados “Python Web Frameworks” e “Projeto de Software para a Web”, descrevem as principais abordagens e tecnologias para a construção de aplicações web, envolvendo um dos ambientes (web framework) mais aplicados no desenvolvimento de aplicações web com base na linguagem Python: a framework Django.

0.3

O PÚBLICO-ALVO

O público-alvo preferencial são os profissionais e alunos das áreas das tecnologias de informação, da gestão e da engenharia que pretendem desenvolver competências na área do desenvolvimento de software e da programação de aplicações web com a linguagem Python. É desejável que o leitor possua noções de algoritmia e programação de computadores. Contudo, o livro também poderá ser aplicado à introdução das ciências da computação, à algoritmia e estruturas de dados, bem como à referente programação de computadores. Este livro apresenta e aplica as principais técnicas algorítmicas e de programação, e pretende desenvolver novas capacidades para a construção de aplicações web. Com base nas linguagens de programação referidas e nas frameworks associadas, tem também por objetivo incentivar alunos, docentes universitários, profissionais e gestores de sistemas e tecnologias de informaçãoem relação à importância da programação e da engenharia de software para a web, e no desenvolvimento de novas ideias e projetos inovadores nas organizações. © FCA – Editora de Informática

SOBRE O LIVRO

0.4

COMPLEMENTOS NO SITE DA EDITORA

Todos os exemplos contidos no livro podem ser descarregados gratuitamente no site da editora em www.fca.pt.

0.5

CONVENÇÕES UTILIZADAS

Ao longo do livro, optou-se por seguir um conjunto de convenções que devem facilitar a interpretação do código. Assim, todos os excertos de código são apresentados no seguinte formato: >>>texto = 'Python Web Programming' >>> texto2 = "Algorithms and Data Structures in 'Python 3.3.5'" >>>print (texto,texto2)

Para além do código, há também comentários ao mesmo, assinalados a cinzento, como ilustrado no exemplo abaixo: EXEMPLO 3.5 Function Pop (ST,TOP) FUNÇÃO QUE ELIMINA (DESEMPILHA) O ELEMENTO DO TOPO DE UMA PILHA QUE É REPRESENTADA PELO VETOR ST. TOP INDICA A POSIÇÃO DO ÚLTIMO ELEMENTO INSERIDO. O ELEMENTO ELIMINADO É DEVOLVIDO AO PROGRAMA (ALGORITMO) PRINCIPAL. 1 [PILHA VAZIA?]

If TOP = 0 Then Write (‘Não existem elementos (stack underflow)’) Return 2 [DECREMENTAR O TOP]

TOP  TOP - 1 3 [DEVOLVER O ELEMENTO ELIMINADO AO PROGRAMA PRINCIPAL]

Return(ST[TOP+1])

E todas as notas e observações importantes poderão ser encontradas no interior de uma secção semelhante à seguinte: Nota importante sobre um tópico.

0.6

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

SUPORTE

Este livro foi escrito durante o ano de 2014 e início de 2015 com a versão 3.3.5 da linguagem Python e com a versão 1.8 (última versão de desenvolvimento referente a março de 2015) da framework web Django. No âmbito da sintaxe e dos construtores aplicados, a linguagem Python apresentada neste livro não sofrerá qualquer alteração. Se, por acaso, o leitor encontrar informação que lhe pareça incorreta ou incoerente por algum motivo, ou se tiver sugestões em relação ao conteúdo, então, poderá enviar um e-mail com as suas questões para jbraga@acm.org. Eventuais atualizações serão publicadas no site da editora, em www.fca.pt.

INTRODUÇÃO

A fundamentação deste livro tem por base a importância das aplicações web no contexto da indústria de desenvolvimento de software. As aplicações na web estão em crescimento exponencial. Para facilitar o seu desenvolvimento, têm surgido diferentes abordagens, frameworks e ambientes de desenvolvimento entre as linguagens de programação existentes para o desenvolvimento de software. Neste livro focamos uma das linguagens que teve mais crescimento nos últimos anos: a linguagem Python. A grande versatilidade do Python e das frameworks associadas permitem o desenvolvimento de aplicações web mais complexas e de grande dimensão, tendo em conta os requisitos atuais de transações na web.

1.1

DESENVOLVIMENTO DE SOFTWARE PARA A WEB

Uma aplicação web envolve um conjunto de recursos que necessitam de ter uma perspetiva holística, distribuída por diferentes camadas. Uma aplicação web não é um simples artefacto de software. A arquitetura tem subjacente diferentes camadas (Figura 1.2) de forma a integrar diferentes visões e requisitos do servidor, da lógica da aplicação, da base de dados e do cliente, através do seu browser. Uma parte dos componentes de software reside no servidor e outra parte reside no computador (cliente) do utilizador. Existe uma camada intermédia, designada por middleware (Figura 1.1), que reflete os componentes entre o servidor e o cliente que permitem a comunicação entre ambos.

FIGURA 1.1 – Arquitetura geral de uma aplicação web

Com base na figura (simplificada) anterior podemos concluir que uma aplicação web é uma infraestrutura de componentes de software. Consiste de partes (software) que residem no servidor e de outras partes que residem no computador do utilizador, normalmente designado por cliente (web browser). Neste sentido, existem linguagens de programação do lado do cliente (client-side), como é o caso do JavaScript, e linguagens do lado do servidor (server-side), como é o caso das linguagens Python, Java e C#. Ambas as partes (cliente e servidor) são importantes. Por um lado, o servidor assegura a gestão (pedidos do cliente e respostas do servidor) dos dados e implementa a lógica da aplicação

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

web. Por outro lado, os dados são visualizados através da aplicação web executada através do browser do cliente e das respetivas interfaces e controlos (user controls) do utilizador. O desenvolvimento de software para a web e consequente programação e integração de recursos tem sistematicamente presente a gestão da interação entre as diferentes camadas (layers) de aplicação web. Temos a programação do código do cliente, a programação do código do servidor que determina a lógica da aplicação, e temos ainda a programação do código que estabelece a ligação (middleware) às bases de dados. Deste modo, a conceção e desenvolvimento para a web efetua a integração de diferentes linguagens, de modo a manipular os diferentes requisitos de programação das diferentes camadas da aplicação. Em síntese, o desenvolvimento de software para a web envolve a manipulação e interação de recursos entre a base de dados, a lógica da aplicação, o servidor web e o cliente (browser). Como abordagem para o processo de construção da aplicação web, podemos focar-nos nas diferentes camadas no sentido de efetuar as escolhas (tecnologias de programação) adequadas com base nos requisitos definidos. Quando nos focarmos no cliente e pretendermos uma interface web mais sofisticada (design), podemos aplicar a linguagem JavaScript com a biblioteca jQuery em conjunto com a linguagem de marcação HTML5. Quando nos focarmos no lado do servidor, um aspeto essencial é a definição da linguagem de programação, a qual irá refletir outras escolhas, como é o caso do ambiente de desenvolvimento e do motor de base de dados. Neste livro aplicamos a linguagem Python para representar a lógica da aplicação e efetuar a gestão e interação (Figura 1.2) entre as diferentes camadas (layers) referidas anteriormente. Após enfoque nas partes cliente e servidor, é necessário definir a arquitetura dos componentes de modo a tomar decisões relativas às tecnologias de programação e gestão de bases de dados. Os principais componentes (Figura 1.2) do lado do servidor asseguram os dados (gestor de bases de dados e ficheiros); o código-fonte da aplicação; e os serviços web para a comunicação com o cliente. O navegador (browser) executa e visualiza a aplicação no lado do cliente. Este processo é composto por um conjunto sistemático de tarefas: Aceder a dados do servidor e estruturar o conteúdo através de ficheiros HTML; Executar código (por exemplo, JavaScript) do lado do cliente para melhorar a interface (design) com o utilizador e a apresentação de informação, assim como efetuar validações aos dados (client-side) para evitar desnecessárias chamadas ao servidor.

INTRODUÇÃO

Servidor Servidor Web

Lógica da Aplicação

Base de Dados

Cliente (browser) Extração (information retrieval) Apresentação da informação Interface com o utilizador

FIGURA 1.2 – Interação entre o cliente e o servidor

Uma vantagem visível do facto de nos focarmos nas diferentes camadas é a manutenção do sistema de software. Se porventura for necessário alterar a linguagem do lado do servidor para, por exemplo, Java, não necessitamos de alterar a arquitetura e as linguagens implementadas no lado do cliente. A próxima figura apresenta a arquitetura geral e resume os principais componentes e tarefas de uma aplicação web. Cada camada de software define um conjunto de funcionalidades. No âmbito do hardware, o qual não é objeto de análise específica neste livro, também existem diferentes configurações para a implementação de uma aplicação web. Outro aspeto importante nesta arquitetura são os componentes de rede (computer networking), os quais não são objeto de análise neste livro, que se foca essencialmente no desenvolvimento de software para a web. No caso de uma aplicação de grande dimensão, normalmente existem diferentes servidores (computadores e dispositivos de memória secundária) para acomodar as diferentes camadas. É usual existir uma máquina dedicada ao servidor web e aplicação e outra máquina para o servidor de bases de dados. Nos próximos exemplos, por se tratar de aplicações simples, as diferentes camadas serão suportadas pelo mesmo computador. Em muitos casos, incluindo aplicações de médio porte, o código referente à lógica da aplicação faz parte da infraestrutura (Figura 1.3) de software do servidor web.

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

FIGURA 1.3 – Diferentes camadas (layers) de uma aplicação web

1.2

ALGORITMIA E ESTRUTURAS DE DADOS

A especificação de algoritmos para a resolução de problemas do mundo real é uma atividade intelectual subjacente ao processo de desenvolvimento de software. Com base no conhecimento e requisitos de um determinado domínio, a abordagem algorítmica tem fundamentalmente três passos e dimensões: 1)

Descrever de forma estruturada o problema. Este passo envolve capacidades cognitivas de aquisição (e eliciação) de conhecimento, formação de conceitos, assim como tarefas de explicitação. Desenvolver e especificar um esquema mental (modelo) para a resolução do problema. Este passo envolve essencialmente tarefas de modelação, representação de dados e raciocínio. Especificar (pseudocódigo e/ou linguagem de programação) a solução. Este passo envolve competências de raciocínio lógico (matemático) e representação (e manipulação) de estruturas de dados.

No âmbito do processo de design e construção de software, a algoritmia e a engenharia de software são disciplinas relacionadas. A algoritmia é uma disciplina basilar na área das ciências da computação (Tremblay & Sorenson, 1984; Cormen et al., 2003; Braga de Vasconcelos & Carvalho, 2005) e o seu entendimento poderá ser muito relevante no desenvolvimento de competências noutras áreas do conhecimento. Um programa de computador não existe sem um algoritmo associado e especificado. As aplicações de © FCA – Editora de Informática

LINGUAGEM DE PROGRAMAÇÃO PYTHON

2.3

ELEMENTOS DA LINGUAGEM DE PROGRAMAÇÃO PYTHON

O Python é uma linguagem multiparadigma e tem uma sintaxe simples e de alto nível, muito próxima da linguagem natural. Neste sentido, tem uma componente sintática clara e de fácil leitura e interpretação. Adicionalmente, assegura um conjunto de mecanismos de programação avançados para a implementação de algoritmos e consequente resolução de problemas, razão pela qual várias empresas multinacionais aplicam esta linguagem no desenvolvimento dos seus produtos e serviços, tais como a Google, a NASA e a Yahoo. O Python é uma linguagem não “tipada”, ou seja, aplica uma “tipagem” dinâmica (dynamic typing) na manipulação de variáveis. A tipagem dinâmica é uma característica de algumas linguagens de programação que não necessitam de declarações explícitas de tipos de dados. Deste modo, estas linguagens aplicam tipos de dados dinamicamente para cada variável, sendo possível alterar os tipos durante a especificação e execução dos programas. Por outro lado, temos as linguagens de programação com tipagem estática (static typing), as quais exigem a declaração explícita das variáveis, como é o caso das linguagens C, C++, Java e VBasic. A linguagem Python tem associado vários ambientes de desenvolvimento de software (IDE). Os IDE Python (ver próxima secção) contêm um conjunto integrado de ferramentas de software para facilitar o desenvolvimento, teste e execução dos programas. Um IDE Python contém um editor para criar e atualizar o código-fonte, um interpretador para executar os programas (código) e um corretor de erros (debugger) para auxiliar no desenvolvimento e correção de erros de sintaxe e de execução (run time). Um IDE Python contém também uma linha de comando designada por Python shell para o desenvolvimento interativo de código e funções Python. A linguagem Python foi criada e desenvolvida por Guido Van Rossum (investigador e professor na área das ciências da computação). Python é uma linguagem de altíssimo nível (Very High Level Language), orientada a objetos e com tipagem forte e dinâmica, isto é, não existe declaração explícita de variáveis e pode conter diferentes objetos. O Python é uma linguagem modular, multiplataforma, e de fácil aprendizagem. A sua implementação não está sujeita a licenças de software.

Os próximos pontos resumem a linguagem Python no sentido de iniciar a escrita de programas simples. Em primeiro lugar, a noção de variável (variable) de modo a permitir a entrada (input), o processamento de dados e a saída (output) de resultados e, posteriormente, a forma simples de processamento (cálculo) numérico de dados. Neste contexto, a variável é um dos principais conceitos de algoritmia e programação. Uma variável tem uma designação (nome) e tem atribuído um valor, conforme apresenta o próximo exemplo (Exemplo 2.1).

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB EXEMPLO 2.1 >> num = 15 # a variavel num toma o valor 15 >> num = num * 34 >> print (num)

O símbolo ‘#’ permite especificar comentários no código-fonte. À variável num é atribuído o valor 15 e posteriormente é efetuado um cálculo aritmético e visualizado (print) o resultado 170 (conteúdo final da variável num). Conforme qualquer outra linguagem de programação, o Python contém os operadores aritméticos básicos: adição (+), subtração (-), multiplicação (*), divisão (/) e exponenciação (**). Com exceção da exponenciação, os operadores computacionais Python têm a mesma sintaxe dos correspondentes operadores matemáticos. Uma forma simples de efetuar a leitura de dados de entrada é através da instrução input, conforme indica o próximo exemplo (código e resultados). EXEMPLO 2.2 >>> pnome = input('Insira o seu primeiro nome: ') Insira o seu primeiro nome: António

>>> print (pnome) António

>>> unome = input('Insira o seu último nome: ') Insira o seu último nome: Alves

>>> nome = pnome + " " + unome >>> print (nome) António Alves >>>

Os carateres entre plicas representam strings. Neste caso o operador ‘+’ tem o significado de concatenação de strings. Outras operações de processamento de strings serão efetuadas posteriormente noutros exemplos e código-fonte. Para visualizar dados (output, saída de resultados), podemos utilizar a instrução print. Para finalizar este resumo dos elementos essenciais da linguagem e ambiente Python, temos um componente (Figura 2.4) fundamental para a programação e integração de recursos: a biblioteca de módulos predefinidos (Python Standard Library) que contêm um conjunto de funcionalidades essenciais ao desenvolvimento (programação) de software, tais como o módulo de matemática (math), que contém as funções matemáticas (lógicas, trigonométricas, algébricas e aritméticas), ou o módulo random, que contém funções para a geração de valores aleatórios. © FCA – Editora de Informática

LINGUAGEM DE PROGRAMAÇÃO PYTHON

FIGURA 2.4 – Biblioteca de software (Python Standard Library)

Outros módulos mais específicos permitem o desenvolvimento de software em determinadas áreas de aplicação, como é o caso do módulo Pygame para a programação de jogos. A instrução import é utilizada no início (cabeçalho) dos programas Python, de modo a referenciar os módulos de funções aplicados durante o processo de codificação. Como vamos ver e aplicar posteriormente, também podemos criar os nossos módulos de funções, de forma a reutilizar código e funcionalidades ao longo do repositório de software e referente processo de construção e programação. Python é uma linguagem de aplicação geral utilizada em diversos tipos de problemas e áreas de conhecimento. Ultimamente tem sido aplicada no desenvolvimento de aplicações web. A biblioteca padrão (Python Standard Library) inclui módulos para processamento de texto (strings) e expressões regulares, protocolos de rede (HTTP, FTP, SMTP, POP, IMAP), acesso a serviços do sistema operativo, segurança, criptografia, interfaces gráficas, entre outras bibliotecas de módulos Python.

2.4

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE PROGRAMAÇÃO

A instalação do ambiente Python é muito simples. O editor e interpretador Python pode ser instalado nos sistemas operativos mais utilizados: Windows, Linux e Mac OS. Neste sentido, é necessário selecionar, efetuar o download e executar o ficheiro de instalação (software) adequado do sítio oficial www.python.org (Figura 2.5). Depois de instalado, o interpretador é um programa que entende e executa as instruções Python especificadas pelo programador. © FCA – Editora de Informática

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

FIGURA 2.5 – Sítio web oficial da linguagem Python

Os próximos passos dizem respeito à instalação do ambiente Python para o sistema operativo Windows. Contudo, para os restantes sistemas, o processo é idêntico e igualmente simples. O primeiro passo deverá ter em conta a seleção da última versão de instalação, de modo a utilizar a versão mais atual e estável. Os próximos pontos resumem o processo de instalação do ambiente (Python IDE) designado por Integrated DeveLopment Environment (IDLE):

Download do ficheiro de instalação (Figura 2.6).

Executar ficheiro e instalar o ambiente.

Abrir o ambiente IDLE (Python 3.3.5 -> IDLE (Python GUI)).

Efetuar um teste de modo a verificar o sucesso da instalação.

A comunidade (organização) de programação Python é muito dinâmica. Diferentes versões do ambiente Python foram lançadas desde a sua criação e primeira versão oficial em 1991:       …

Python 0.9.0 - fevereiro 1991 Python 1.0 - janeiro 1994 Python 1.5 - dezembro 1997 Python 1.6 - setembro 2000 Python 2.0 - outubro 2000 Python 2.1 - abril 2001

      

Python 2.7 - julho 2010 Python 3.0 - dezembro 2008 Python 3.1 - junho 2009 Python 3.2 - fevereiro 2011 Python 3.3 - setembro 2012 Python 3.3.5 - março 2014 Python 3.4 - março 2014

ALGORITMOS E ESTRUTURAS DE DADOS EM PYTHON 3

A linguagem Python contém um conjunto de instruções para a manipulação de estruturas de dados simples e compostas (lineares e não lineares), tais como vetores e matrizes (arrays), pilhas (stacks), filas (queues), listas (lists), árvores binárias (binary trees) e grafos (graphs). Incluem-se também neste capítulo as strings como exemplo de um array de carateres alfanuméricos. As próximas secções contêm um conjunto de algoritmos e respetivos programas em Python, com aplicação destas importantes estruturas de dados, fundamentais para o desenvolvimento de software e resolução de problemas. Algumas destas estruturas de dados também serão representadas no próximo capítulo, através de classes com base na utilização da linguagem Python, sob o paradigma de programação com orientação aos objetos.

3.1

TIPOS E ESTRUTURAS DE DADOS

O Python é uma linguagem não tipada, na medida em que podemos utilizar variáveis sem uma declaração prévia do respetivo tipo de dados. Contudo, a compreensão e aplicação de tipos e estruturas de dados é igualmente importante na linguagem Python como em qualquer outra linguagem de programação (tipada). Uma estrutura de dados define a forma como os dados de um algoritmo são relacionados e agrupados de modo coerente (Braga de Vasconcelos & Carvalho, 2005). Estruturas de dados primitivas definem dados como uma ou mais instâncias de tipos de dados atómicos. Estruturas mais complexas (não primitivas) apresentam organizações mais complexas de dados, como por exemplo estruturas de dados que referenciam outras estruturas. Os tipos de dados primitivos permitem manipular valores atómicos, como valores booleanos, numéricos e alfanuméricos. As próximas secções apresentam um resumo dos tipos de estruturas de dados primitivos: tipo booleano (ou binário), tipo numérico (inteiros e reais) e tipo alfanumérico para o tratamento de cadeias de carateres (strings) e respetivo tratamento de texto. A Figura 3.1 ilustra as principais estruturas de dados.

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

FIGURA 3.1 – Estruturas de dados (Braga de Vasconcelos & Carvalho, 2005)

A algoritmia centra-se na forma como representamos entidades e objetos reais através de estruturas de dados e não na forma como os armazenamos fisicamente na memória do computador. A definição das estruturas de dados a utilizar por um algoritmo também deverá ter em atenção as operações a executar sobre os dados. Diferentes operações podem ser executadas, tais como operações para criar, alterar e eliminar estruturas de dados; operações para inserir, alterar e eliminar elementos das estruturas de dados; e operações para aceder a elementos da estrutura de dados. Em síntese, uma eficiente manipulação das estruturas de dados associadas à resolução de um problema e consequente construção de um algoritmo envolve uma análise das seguintes questões: Compreender a relação entre os dados; Compreender a gestão das estruturas dos dados e dos dados em memória (primária e secundária); Decidir operações a executar nos dados logicamente relacionados; Representar os elementos dos dados; Manter as relações lógicas entre os dados; Executar de forma eficiente as operações sobre os dados;

ALGORITMOS E ESTRUTURAS DE DADOS EM PYTHON

De um modo geral, especificar os algoritmos e as estruturas de dados e implementar numa linguagem de programação da forma mais natural e expressiva possível. As estruturas de dados primitivas definem dados como uma ou mais instâncias de tipos de dados atómicos. As estruturas complexas (não primitivas) apresentam organizações mais complexas de dados, como por exemplo estruturas de dados que referenciam outras estruturas. Assim, temos os seguintes tipos de dados (primitivos) para a manipulação de estruturas de dados: Tipo de dados booleano – Este tipo é aplicado em situações reais que unicamente denotam dois estados possíveis: verdadeiro (true) ou falso (false). Estes dois estados também podem ser representados através dos valores 0 (false) ou 1 (true); Tipo de dados numérico – Este tipo é representativo de valores numéricos no domínio dos números inteiros e reais. De uma forma simples, os tipos de dados numéricos dividem-se em tipos inteiros e tipos reais; Tipo de dados alfanumérico – O tipo de dados alfanumérico é constituído por uma sequência de carateres contendo letras, dígitos e símbolos especiais. A próxima secção apresenta um conjunto de instruções, funções, operações e algoritmos para o processamento de cadeias de carateres (strings) em Python.

Os tipos de dados numéricos dividem-se em tipos inteiros e reais. Os tipos de dados reais são normalmente designados por números de vírgula flutuante (float point numbers). Estes três tipos de dados (lógicos ou booleanos, numéricos e alfanuméricos) são considerados primitivos porque estão incorporados nas linguagens de programação. Atualmente, uma parte significativa dos tipos de dados não primitivos (complexos ou compostos), como um array, lista ou pilha, está também incorporada no núcleo das linguagens de programação. Ainda temos os tipos de dados definidos pelo utilizador que serão alvo de análise e aplicação no capítulo referente à programação orientada aos objetos, e subsequentes.

3.2

PROCESSAMENTO DE STRINGS

No âmbito da representação e manipulação de strings em Python são utilizadas várias instruções e funções que se inserem no seguinte conjunto de operações de tratamento de texto (strings): Criar uma string; Determinar o comprimento de uma string; © FCA – Editora de Informática

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB Concatenar strings; Determinar a posição de uma substring numa string; Obter (extrair) uma substring de uma string; Comparar strings.

Criar uma string na linguagem Python é uma tarefa simples. Uma string é expressa por uma qualquer sequência de carateres entre plicas ou entre aspas. A criação de uma string pode ser efetuada pela atribuição a uma variável, exatamente da mesma forma como criamos e inicializamos uma variável do tipo numérico (Exemplo 3.1). EXEMPLO 3.1 >>> texto = 'Python Web Programming' >>> texto2 = "Algorithms and Data Structures in 'Python 3.3.5'" >>> print (texto,texto2)

A concatenação de strings em Python é também uma operação muito simples. Para concatenar strings aplicamos o operador ‘+’, o qual, neste caso, tem a função de concatenar (juntar) o conteúdo dos operandos (strings). Esta operação permite juntar duas strings para formar uma outra, como indica o seguinte exemplo (Exemplo 3.2) na shell Python. EXEMPLO 3.2 >>> text1 = 'String processing' >>> text2 = 'using Python' >>> pvers = '3.3.5' >>> text = text1 + ' ' + text2 + ' ' + pvers >>> print (text) String processing using Python 3.3.5

A pesquisa de uma substring dentro de uma string determina a posição da substring dentro da string. No caso de a substring (padrão) não existir, a função find() devolve o valor -1 (Figura 3.2).

TECNOLOGIAS DE PROGRAMAÇÃO WEB EM PYTHON 1

Este capítulo concretiza a construção de software para a web com a linguagem Python e os respetivos recursos e bibliotecas anteriormente analisados. O objetivo principal é integrar de modo coerente as camadas de software a fim de programar e construir uma aplicação web. Neste sentido, alguns exemplos e programas em Python são especificados com base numa arquitetura web de simples configuração e manutenção, na qual aplicamos o servidor web (framework http) CherryPy e o motor de base de dados SQLite incorporado no ambiente de desenvolvimento Python. Este capítulo apresenta também outras formas de programar para a web em Python e os mecanismos de interação entre o ambiente de programação e as bases de dados. Resumindo, este capítulo descreve alguns métodos que aplicam a linguagem Python em conjunto com um determinado servidor web e motor de base de dados, de modo a construir aplicações de software interativas com interface web. No final, apresenta-se também o processamento de ficheiros XML em Python.

6.1

PROGRAMAÇÃO PYTHON PARA A WEB

Tendo em conta o incremento da complexidade dos sistemas de software e a evolução da Internet no sentido da web semântica (web 3.0), assim como, por um lado, as questões de performance, segurança, manutenção e escalabilidade e, por outro, as questões estéticas e de interface, torna-se necessário a integração de tecnologias e linguagens de programação adequadas às novas necessidades de desenvolvimento desses sistemas de software para a web, cada vez mais exigentes e solicitados. A programação web tornou-se um tópico em ascensão desde o final da década de 90 do século passado, com a transição para a web 2.0 (Kubica, 2014). A linguagem e o ambiente de desenvolvimento Python têm associado um conjunto de tecnologias e frameworks que permitem a programação de aplicações web com um nível de complexidade e sofisticação adequado às necessidades atuais do mercado. Desde o início da década do século XXI, mais concretamente desde o ano 2000 que o Python contém um conjunto de recursos adequados ao desenvolvimento web. Contudo, mais recentemente, surgiram ferramentas e tecnologias de apoio focadas na programação, integração e manutenção de aplicações web de maior dimensão e com superior robustez.

182

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

Neste sentido, existem determinadas bibliotecas Python que facilitam o processo de construção de aplicações web. Conforme foi analisado em capítulos anteriores, os diferentes componentes de software entre o servidor e o cliente são programados e agregados de forma a criar uma aplicação web, a qual pode ser interpretada como uma pilha (stack) de camadas (layers) de software (Figura 6.1).

FIGURA 6.1 – Diferentes camadas e tecnologias de uma aplicação web

No momento que um utilizador (cliente) entra na aplicação web, o seu navegador (browser) efetua uma conexão (pedido / request) ao servidor web da aplicação. O servidor analisa o ficheiro (pedido) através do sistema de ficheiros e envia uma resposta para o cliente (browser), e este apresenta a informação. Este processo entre o pedido do cliente (request) e a resposta do servidor (response) é gerido através do protocolo HyperText Transfer Protocol (HTTP). Os sítios e aplicações web mais recentes e dinâmicos (interativos) substituem o sistema de ficheiros do servidor por programas estruturados (software), que são executados no servidor, no momento em que um pedido do cliente é efetuado. Estes programas especificados em linguagens de programação do lado do servidor manipulam a gestão e a lógica (business logic) da aplicação, e gerem o resultado e informação estruturada para o cliente. A maior parte dos servidores web suportam a linguagem Python, no entanto, dado que os respetivos serviços HTTP são geralmente especificados nas linguagens C e C++, os servidores não executam diretamente código Python. Para resolver esta situação, foram criadas interfaces (bridges) específicas (algumas descritas neste capítulo) para gerir a comunicação entre os programas em Python e o servidor HTTP. Para cada camada, temos um conjunto de tecnologias e linguagens. Os próximos programas especificados em Python utilizam o servidor web CherryPy e o motor de base de dados SQLite. Contudo, a abordagem de desenvolvimento e o código-fonte seriam idênticos a outros servidores web mais robustos (Microsoft IIS ou o Apache), assim como com outros motores de bases de dados de maior dimensão (SQL Server, MySQL ou PostgreSQL).

TECNOLOGIAS DE PROGRAMAÇÃO WEB EM PYTHON

6.2

183

DESENVOLVIMENTO DE APLICAÇÕES WEB

Conforme foi referido no capítulo anterior, o CherryPy é um servidor web selecionado neste livro para o desenvolvimento e testes de programas web em Python. O CherryPy é uma biblioteca Python de software com capacidade para o desenvolvimento de aplicações web (http server). O CherryPy é uma framework (Figura 6.2) para o desenvolvimento de aplicações web com base na linguagem Python. O CherryPy também é interpretado como uma biblioteca de software (framework http) para a programação Python na web com orientação aos objetos.

FIGURA 6.2 – CherryPy web framework (cherrypy.org)

A biblioteca CherryPy é baseada em Python (pythonic) e tem associado o paradigma de desenvolvimento de software orientado aos objetos. O CherryPy é aplicado como um servidor web (http) de leve e simples dimensão. Como podemos verificar nos próximos exemplos, o CherryPy permite o desenvolvimento de aplicações web da mesma forma que construímos um programa orientado aos objetos. O CherryPy inclui um conjunto de objetivos determinantes para o desenvolvimento de software sem utilização de grandes (e pesados) recursos, razão fundamental para a escolha desta solução como servidor web. Assim, temos um servidor web leve e de simples configuração e manutenção. O CherryPy permite uma integração simples entre conteúdos estáticos e dinâmicos, característica fundamental para o desenvolvimento web e é composto por componentes de software reutilizáveis, de modo a facilitar o processo de desenvolvimento de software e aplicações web.

216

7.2

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB

DJANGO WEB FRAMEWORK

Django é um ambiente (framework) de desenvolvimento de software que simplifica significativamente o processo de construção de uma aplicação web. A framework Django foi concebida para facilitar o design, programação e integração de recursos de software para a web. A abordagem principal é minimizar os detalhes de implementação no âmbito da programação web, reduzindo os aspetos técnicos e os detalhes de integração com uma base de dados, assim como a gestão das diferentes sessões (e URL) de uma aplicação web.

FIGURA 7.1 – Sítio web da framework Django

A framework Django foi construída com base na linguagem de programação Python. Como vimos anteriormente, o Python possui muitos recursos avançados, além de uma biblioteca padrão de software poderosa, o que faz com que esta linguagem, em conjunto com o ambiente de software Django, possam ser usados em aplicações complexas em servidores web, assim como em dispositivos móveis. A conceção deste ambiente (framework) assim como o desenvolvimento subja‐ cente de aplicações web rege‐se pela metáfora e princípio designado por Don´t Repeat Yourself (DRY, Figura 7.2), o qual enfatiza a redução de erros de implementação com base na eliminação de repetições (duplicações) de funções e procedimentos e respetivo código‐ ‐fonte. No âmbito da programação e integração de componentes de software, ou seja, numa abordagem à engenharia de software, a metáfora DRY pretende representar que uma determinada função, procedimento, processo, entidade ou área de conhecimento do sistema em análise tem associado um artefacto (componente) de software reutilizável. Esta

PYTHON WEB FRAMEWORKS

217

abordagem tem também por objetivo minimizar aspetos do processo de manutenção de software.

FIGURA 7.2 – Metáfora Don´t Repeat Yourself

A framework Django assegura um ambiente de desenvolvimento de software de alto nível de abstração, o que permite construir aplicações web, de dimensão considerável, com um número reduzido de linhas de código‐fonte. O Django é considerado uma ferramenta simples, robusta e flexível no sentido de conceber e desenvolver aplicações web com o mínimo possível de tarefas de programação intensiva. O Django foi construído em Python e combina a capacidade das linguagens orientadas aos objetos com as linguagens de scripting (ex.: Ruby). Esta característica integradora permite aos programadores web a criação de aplicações para a resolução de um leque mais alargado de problemas do mundo real e das empresas. O Django é uma framework escrita em Python para o desenvolvimento de aplica‐ ções web. Dois conceitos estão subjacentes à conceção da framework Django, o padrão (design pattern) Model‐Template‐View (MTV) e o princípio DRY (Don’t Repeat Yourself) referido anteriormente. O padrão MTV tem as seguintes características principais que definem um padrão de desenvolvimento que separa o processo de desenvolvimento em três camadas: Model – Definição do modelo concetual de base de dados no modelo (lógico) relacional. Um modelo em Django é uma classe Python que representa uma

218

PYTHON - ALGORITMIA E PROGRAMAÇÃO WEB tabela de uma base de dados relacional. O processo de codificação SQL para a criação e manipulação da base de dados é automatizado; View – Componente (view) Django que contém o código‐fonte referente à lógica da aplicação (business logic); Template – Define a interface do sistema através de um conjunto de páginas HTML que, por sua vez, definem a interação web com o utilizador. O Django tem um sistema de templates (Django templating system) com capacidades muito interessantes de interface (e interação) web.

O Django foi criado por Jacob Kaplan‐Moss, Adrian Holovaty e Simon Willison em 2003 no contexto do desenvolvimento de um gestor de conteúdos (content management system) para dar suporte ao departamento de tecnologias web de um jornal da região do Kansas nos Estados Unidos da América. O Django surgiu na Cidade de Lawrence, no Kansas. A sua evolução tornou a framework opensource, e foi publicada e lançada sob licença em 2005. O nome Django foi inspirado no músico de jazz Django Reinhardt.

7.3

INSTALAÇÃO DA FRAMEWORK DJANGO

O processo de instalação da framework Django deverá ser efetuado com base nas instruções do sítio web (Figura 7.3). Existem diferentes formas de instalar a framework, assim como diferentes versões de instalação. Por um lado temos a última versão em desenvolvimento (Django development version) que inclui as mais recentes funcionalidades da framework. Por outro lado, mais conservador, temos uma versão estável da plataforma (latest oficial version, Figura 7.4). Assim, inicialmente é necessário definir a versão do Django a instalar, posteriormente efetuar o download do ficheiro de instalação, e finalmente descompactar e efetivamente instalar o ambiente Django. O processo de instalação descrito tem por base o sistema operativo Windows 8.1 da Microsoft.

PROJETO DE SOFTWARE WEB

8.2

283

SOFTWARE DESIGN E MODELO DE DADOS

A construção do modelo de dados é uma tarefa fundamental na fase de design do software logo após a definição dos requisitos de software. A estrutura de dados seguinte, assim como os relacionamentos estruturais entre as classes (entidades do sistema) será refletida nos modelos (classes), atributos e funções definidas no programa (ficheiro Python) models.py. Cada modelo é interpretado como uma classe Python. No caso da aplicação Django bauthors desenvolvida, existe apenas um ficheiro com a especificação dos modelos (classes Python) especificado no ficheiro models.py (Figuras 8.6 e 8.7). O modelo de dados (models.py) especificado em Django tem por base o diagrama de classes abaixo especificado em UML (Figura 8.2).

FIGURA 8.2 – Diagrama de classes especificado com a ferramenta StarUML

Posteriormente, o ambiente (software framework) Django encarrega‐se de auto‐ matizar o processo de conversão das classes (modelo orientado aos objetos) num conjunto de tabelas de um modelo relacional. Conforme referido anteriormente, este processo de conversão é efetuado através da ferramenta Django ORM.

Arte -Python.pdf

CMY

17/04/15

16:14