P. 1
Relatorio Estagio Caliane Zschornack Os Elementos Fundamentais Linguagem Programacao E Linguagem Python

Relatorio Estagio Caliane Zschornack Os Elementos Fundamentais Linguagem Programacao E Linguagem Python

|Views: 1.922|Likes:
Publicado porcaliane
Este trabalho trata dos principais elementos fundamentais de uma linguagem de programação e como Python trata esses elementos.
Python com ênfase em Fundamentos da Programação.
Este trabalho trata dos principais elementos fundamentais de uma linguagem de programação e como Python trata esses elementos.
Python com ênfase em Fundamentos da Programação.

More info:

Published by: caliane on Sep 16, 2009
Direitos Autorais:Attribution Non-commercial Share Alike

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

12/12/2012

pdf

text

original

Sections

UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ COORDENAÇÃO DE INFORMÁTICA CURSO DE TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS

CALIANE ZSCHORNACK

RELATÓRIO DE ESTÁGIO

PATO BRANCO 2009

Conteúdo licenciado pela Creative Atribuição-Uso Não-Comercial-Compartilhamento pela mesma Licença 2.5 Brasil Commons. Essa licença permite copiar, distribuir, exibir e executar a obra. Esta obra não pode ser utilizada com finalidades comerciais. As novas obras devem conter menção aos autores nos créditos e as obras derivadas precisam ser licenciadas sob os mesmos termos dessa licença. Os direitos dos autores citados neste trabalho devem ser mantidos de acordo com o licenciamento de suas obras.

CALIANE ZSCHORNACK

OS ELEMENTOS FUNDAMENTAIS DE UMA LINGUAGEM DE PROGRAMAÇÃO E A LINGUAGEM PYTHON

Relatório de estágio supervisionado. Supervisor: Profª. Beatriz Terezinha Borsoi

PATO BRANCO-PR 2009

Para minha família, minha eterna gratidão.

AGRADECIMENTOS Meus sinceros agradecimentos a todos que me ajudaram durante o

desenvolvimento deste trabalho, em especial ao meu futuro noivo, Adriano Pecenin.

EPÍGRAFE

“Free software” is a matter of liberty, not price. To understand the concept, you should think of “free” as in “free speech,” not as in “free beer.”

Richard Stallman

RESUMO Este trabalho foi desenvolvido com o intuito de conhecer os principais recursos da linguagem Python aplicada aos fundamentos da programação. Primeiramente, realizou-se um estudo do conceito de linguagem de programação e dos principais elementos que estas devem possuir e posteriormente como esses elementos são aplicados e tratados em Python. O objetivo da escolha da linguagem Python é oferecer uma alternativa livre e multiplataforma ao aprendizado da programação, vendo que os sistemas operacionais livres se fazem cada vez mais presentes no meio acadêmico e que muitas das linguagens tradicionais utilizadas no processo de aprendizagem estão presas às plataformas proprietárias. No decorrer do desenvolvimento do trabalho ficou claro que a linguagem é de fácil entendimento e aprendizagem e ao mesmo tempo elegante e robusta. Por ser uma linguagem livre é possível aprofundar o estudo da programação para além do uso dos recursos disponíveis na linguagem, passando a entender como são tratados e como funcionam através do estudo do código fonte da mesma. O próprio modelo de desenvolvimento da linguagem Python que segue o conceito de comunidade e desenvolvimento distribuído comprova a afirmação anterior permitindo também que um usuário qualquer possa participar ativamente do processo de evolução, seja através da criação e/ou aperfeiçoamento de documentações ou na codificação de novas funcionalidades para a linguagem. Para não fugir ao objetivo do trabalho, todos os exemplos e estudos foram feitos com a distribuição Ubuntu Linux.

LISTA DE FIGURAS Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura Figura 1 – Processo de compilação e interpretação da Python..........................15 2 – Algoritmo para calcular a área de um círculo....................................32 3 – Algoritmo para calcular a média de duas notas................................33 4 - Fluxograma da estrutura de decisão se ... então...............................35 5 – Algoritmo para verificar a média de um aluno..................................35 6 - Fluxograma da estrutura de decisão se ... então ... senão................36 7 - Algoritmo para indicar aprovação ou reprovação..............................37 8 - Algoritmo para indicar aprovação ou reprovação..............................38 9 – Modelo de identação de estruturas se ... então ... senão..................39 10 - Fluxograma da estrutura de decisão escolha ... caso......................40 11 - Algoritmo para escrever um número por extenso...........................41 12 - Fluxograma da estrutura de repetição enquanto ... faça.................42 13 - Algoritmo para imprimir a tabuada de um número.........................43 14 - Fluxograma da estrutura de repetição faça ... enquanto.................44 15 - Algoritmo para ler números negativos............................................45 16 - Fluxograma da estrutura de repetição para ... até ... faça..............46 17 - Algoritmo para imprimir a tabuada de um número.........................47

LISTA DE SIGLAS E ABREVIATURAS

ACM - Association for Computing Machinery ASCII - American Standard Code for Information Interchange CISC - Complex Instruction Set Computer GNU – GNU Is Not Unix GPSS - General Purpose Simulation System HTML - HyperText Markup Language IBM - International Business Machines LISP - LISt Processing NASA - National Aeronautics and Space Administration OS - Operational System PHP - Hypertext Preprocessor RISC - Reduced Instruction Set Computer ou Computador SQL - Structured Query Language UML - Unified Modeling Language

SUMÁRIO
1 INTRODUÇÃO..................................................................................................11 1.1 Considerações iniciais..............................................................................11 1.2 Objetivos .................................................................................................11 1.3 Justificativa .............................................................................................11 1.4 Organização do texto ..............................................................................12 2 LINGUAGENS DE PROGRAMAÇÃO ..................................................................13 2.1 Conceito de linguagem de programação ................................................13 2.2 Classificação das linguagens de programação .......................................17 2.3 Elementos fundamentais de uma linguagem de programação ..............21 2.3.1 Sintaxe e semântica de uma linguagem ..........................................24 2.3.2 Variáveis e constantes .....................................................................24 2.3.2.1 Variáveis ....................................................................................25 2.3.2.2 Constantes ................................................................................26 2.3.3 Tipos de dados simples ....................................................................26 2.3.4 Tipos de dados compostos ...............................................................27 2.3.5 Operadores ......................................................................................28 2.3.5.1 Operadores Aritméticos .............................................................28 2.3.5.2 Operadores Relacionais .................................................................29 2.3.5.3 Operadores Lógicos ...................................................................30 2.3.6 Estruturas de controle ......................................................................32 2.3.6.1 Seqüência ..................................................................................33 2.3.6.2 Decisão ......................................................................................34 2.3.6.2.1 se ... então ..........................................................................35 2.3.6.1.2 se ... então ... senão ...........................................................36 2.3.6.1.3 Comandos condicionais encadeados ..................................38 2.3.6.1.4 escolha ... caso .......................................................................40 2.3.6.2 Repetição ..................................................................................42 2.3.6.2.1 enquanto ... faça .................................................................42 2.3.6.2.2 faça ... enquanto .................................................................44 2.3.6.2.3 para ... até ... faça ..............................................................46 2.3.7 Funções ............................................................................................48 3 Materiais e método ........................................................................................50 3.1 Materiais .................................................................................................50 3.2 Método ....................................................................................................50 4 LINGUAGEM PYTHON .....................................................................................52 4.1. Apresentação .........................................................................................52 4.2 Características ........................................................................................53 4.3 O processo de interpretação e de compilação ........................................54 4.4 Edição e execução de um programa na linguagem Python.....................55 4.4.1 Editor ...............................................................................................55 4.4.2 Execução em linha de comando ......................................................55 4.4.3 Execução em arquivo .py .................................................................56 4.5 Elementos fundamentais da linguagem Python .....................................56 4.5.1 Variáveis ...........................................................................................57 4.5.2 Constantes .......................................................................................57 4.5.3 Tipos de dados .................................................................................57 4.5.4 Padrão Unicode ................................................................................60 4.5.5 Operadores Aritméticos ...................................................................61 4.5.6 Operadores relacionais ....................................................................61

4.5.7 Operadores lógicos ..........................................................................62 4.5.8 Estruturas de controle ......................................................................63 4.5.9 Funções.............................................................................................66 5 DISCUSSÕES ..................................................................................................67 5.1 Principais diferenças ...............................................................................67 5.2 Aplicabilidade prática e didática .............................................................68 CONCLUSÃO .....................................................................................................70 REFERÊNCIAS....................................................................................................71

11 1 INTRODUÇÃO

Este capítulo apresenta as considerações iniciais sobre o trabalho, a justificativa, os objetivos e a organização do texto.

1.1 Considerações iniciais

Sabe-se que a informática surgiu por conta de aspirações e muitos estudos matemáticos que visavam de modo geral conseguir resolver cálculos e problemas diversos com mais rapidez e eficácia fazendo o uso de máquinas. A evolução do computador e da sua utilização fez evoluir também as linguagens de programação e a forma de desenvolver programas. Exatamente por desempenhar um papel tão importante as linguagens devem ser fáceis de se trabalhar, e não menos importante, é necessário que o programador saiba as vantagens e desvantagens de utilizar determinada linguagem, o que a torna melhor que as outras e em que aspectos. Este trabalho visa mostrar a estrutura básica da linguagem Python e tirar as conclusões da utilização da mesma como ferramenta para o aprendizado dos fundamentos da programação.

1.2 Objetivos

Conhecer a linguagem Python e poder aplicá-la como uma alternativa ao ensino e aprendizado dos fundamentos da programação. Além disso, entender como deve ser o processo de aprendizagem da programação, a partir do conhecimento dos conceitos de linguagem de programação, suas classificações, elementos fundamentais como tipos de dados, estruturas de decisão e repetição.

1.3 Justificativa

A idéia deste trabalho surgiu após o conhecimento de que Python tem sido bastante utilizada por grandes empresas como, por exemplo, Google, NASA (National

12 Aeronautics and Space Administration), IBM ( International Business Machines) e também por instituições de ensino como Yorktown High School, em Arlington, Virginia, USA (Jeffrey Elkner). Os principais motivos que a difundem como uma linguagem poderosa são a simplicidade e a objetividade do código, e ainda a facilidade de aprender a linguagem. Ela é livre e multiplataforma, permitindo que o usuário escolha em qual ambiente prefere aprender e desenvolver. Também pode ser utilizada para aplicações web, móveis, científicas, matemáticas, jogos, entre outras.

1.4 Organização do texto

O texto está organizado em capítulos, dos quais este é o primeiro e apresenta as considerações iniciais, os objetivos e a justificativa do trabalho. O Capítulo 2 trata de conceitos e tipos de linguagens de programação e apresenta os itens fundamentais de uma linguagem de programação. O Capítulo 3 apresenta os materiais e o método empregado para realizar o estudo que é objeto deste trabalho. No Capítulo 4, a linguagem Python é apresentada de acordo com os elementos fundamentais de uma linguagem de programação apresentados no Capítulo 2. O Capítulo 5 apresenta as discussões sobre o trabalho. No Capítulo 6 estão as considerações finais e a conclusão.

13 2 LINGUAGENS DE PROGRAMAÇÃO

Este capítulo apresenta conceitos, classificação e os itens fundamentais de uma linguagem de programação.

2.1 Conceito de linguagem de programação

sado na arte da programação de computadores. Para os objetivos deste trabalho, esse conceito é muito abstrato, visto que o interesse é identificar os elementos fundamentais e comuns às linguagens de programação e verificar como eles são tratados na linguagem Python. Desta forma, é necessário um conceito de linguagem que esteja mais relacionado a esses elementos. Assim, para este trabalho, define-se que uma linguagem de programação fornece a sintaxe e a semântica para representar algoritmos que definem a solução de problemas que podem ser implementados computacionalmente. Essa sintaxe e semântica provêm a maneira que as instruções que compõem esse algoritmo devem ser representadas para que elas possam ser realizadas por um computador. Algoritmo não está somente relacionado à programação de computadores. De maneira geral, um algoritmo representa o procedimento para fazer algo, como um bolo, trocar um pneu de um carro, ir ao supermercado, fazer um saque em um caixa eletrônico. Contudo, algoritmo é o conceito central de programação. Ele está diretamente vinculado às referências a programas e linguagens computacionais. Programar é basicamente construir algoritmos (GUIMARÃES, LAGES, 1994). Para Wirth (1976), programação é a técnica de construir e formular algoritmos de forma sistemática. Para esse autor, programas são formulações concretas de algoritmos abstratos, baseados em representações e estruturas específicas de dados. Os algoritmos são representados em linguagens de programação. Essas podem ser mais ou menos próximas da linguagem humana. Há linguagens computacionais que objetivam aproximar-se da forma como os seres humanos se expressam de maneira falada ou escrita. No entanto, uma linguagem de máquina, ou a que é diretamente executada por um computador, é bastante distinta da linguagem falada pelos seres

14 humanos. As instruções em nível de máquina, como são definidas as compreendidas ou executadas pelo computador, são binárias ou muito próximas disso. A linguagem falada pelos seres humanos pode ser bastante ambígua. A ambigüidade ocorre porque o sentido de determinada frase pode ser interpretado de maneira distinta por pessoas distintas. Isso ocorre porque a frase pode não ser expressa de maneira clara ou porque cada pessoa possui conceitos prévios e está o conteúdo dessa frase inserido em um contexto. O contexto auxilia a determinar significados e interpretações. Para um computador, as instruções representadas com as linguagens de programação precisam ser precisas, não ambíguas, possível de ser executada pelos recursos computacionais. Na linguagem humana, por exemplo, uma frase pode ser interpretada mesmo que ela não esteja completa ou adequadamente escrita. Mesmo se faltar pronome, artigo e até palavras uma frase e/ou seu significado pode ser compreendido, ainda que essa compreensão seja limitada. Para um computador as instruções devem ser sempre completas e bem definidas. Ressalta-se, porém, que existem linguagens de programação, especialmente as voltadas para aplicações em inteligência artificial que possibilitam implementar certos tipos de ambigüidades e inconsistências. Essas linguagens, normalmente, também se utilizam de lógicas não binárias. Contudo, o tratamento das ambigüidades e inconsistências é realizado em nível de programação, isto é, é tratado no programa-fonte. Mesmo nesse tipo de programa, a máquina, o computador, continua interpretando exclusivamente instruções binárias. Como a linguagem humana e a compreendida pelo computador são muito distintas em termos de necessidade de formalismo e possibilidade de interpretações, as linguagens de programação são um intermediário entre a linguagem natural e a de máquina. Há as linguagens de programação mais próximas da linguagem de máquina ou das instruções interpretadas por um computador e outras e outras que são menos abstratas para os seres humanos. As características de determinadas linguagens de programação as tornam mais adequadas para determinadas aplicações. Essas características são recursos e funcionalidades, como, por exemplo, fornecer componentes para desenho de interface gráfica, possuir funções matemáticas avanças, permitir a interação com linguagem de marcação de hipertexto. Nem todas as linguagens se aplicam para os mesmo problemas,

15 mesmo porque suas aplicações são distintas: um joguinho para celular, um sistema de apoio à tomada de decisões, um sistema que auxilia diagnosticar um enfarto eminente, uma página Internet com notícias, um controle eletrônico de armazenamento de matéria prima em uma usina atômica. Esses são exemplos de sistemas bem distintos. É compreensível que as linguagens para implementá-los possuam características distintas. Essas características auxiliam a classificar ou categorizar as linguagens. Os recursos e as funcionalidades das linguagens auxiliam os desenvolvedores na produção de sistemas de software com maior facilidade e agilidade. É importante que todos os profissionais de tecnologias de informação e comunicação tenham conhecimento sobre os conceitos de linguagens de programação. O conhecimento que falta a esses profissionais é justamente o que faria com que as suas escolhas fossem mais conscientes sobre quais linguagens utilizar (SEBESTA, 2007). Uma linguagem de programação mais adequada ao problema a ser resolvido auxilia os programadores a definirem software mais simples e claros, uma vez que programas foram e são feitos para ser entendidos, aperfeiçoados e mantidos durante a sua existência. Há ainda a interação entre partes de um mesmo programa, que deve ser planejada cuidadosamente, para que ele não se torne muito complexo. No caso de programação em larga escala, a linguagem é uma das partes mais importantes para garantir que os programadores consigam gerenciar a interação das partes. E antes mesmo de escolher uma linguagem é importante que se faça uma análise sobre qual é melhor para implementação, testes e manutenção. O objetivo de uma linguagem de programação é expressar algoritmos de maneira que eles possam ser executados pelo computador, sob a forma de programas, também denominados sistemas, aplicativos ou genericamente software. Um algoritmo é um método para solucionar um problema. Um algoritmo manipula dados. Um programa é composto por algoritmos e dados representados de maneira a serem entendidos pelo computador. De maneira geral, programas processam dados de entrada e produzem dados de saída. A transformação das instruções definidas em uma linguagem de programação para uma linguagem de máquina, pode ocorrer por meio de dois processos básicos: compilação ou interpretação. Esses processos não são mutuamente exclusivos, isto no sentido que linguagens podem tratados de maneira hibrida ou utilizar as duas maneiras distintamente.

16 Um compilador tem o objetivo de transformar as instruções produzidas em uma linguagem de programação (programa fonte) para uma linguagem de máquina (programa objeto). O programa-objeto nem sempre está pronto para execução. Normalmente há necessidade de incluir partes de código, como bibliotecas e subprogramas. Esse processo de montagem do programa executável (agregação de bibliotecas e outros ao código escrito pelo programador) é realizado pelo link-editor ou linking-loader. O compilador normalmente chama o link-editor automaticamente. Os interpretadores simulam uma máquina virtual. Neles o programa fonte é lido, validado e as instruções são executadas à medida que são lidas e validadas. Contudo, os processos de compilação e execução podem ser híbridos, no sentido de uma mesma linguagem utilizar ambos. Assim, o compilador gera código para uma máquina virtual (pseudocódigo) e a máquina virtual é executada separadamente lendo pseudo-código e interpretando-o. A Figura 1 apresenta um esquema de como ocorre esse processo. Figura 1 – Processo de compilação e interpretação da Python

O código escrito em uma linguagem de programação, após transformado em um a linguagem de máquina, é executado por um processador. Isso pode ocorrer de três formas: a) Processadores - componentes digitais (hardware) capazes de executar programas; b) Processadores em software - componentes digitais programáveis que podem mudar seu comportamento de acordo com sua programação atual; c) Máquinas virtuais - podem ser consideradas processadores de software programados para abstrair a visão direta do hardware.

17 2.2 Classificação das linguagens de programação

Há uma quantidade bastante expressiva de linguagens de programação, com características e aplicações bastante distintas, algumas bem específicas, outras bastante genéricas. Kimmersley (2009) listou 2500 linguagens de programação, estejam atualmente sendo utilizadas ou que já estão em desuso. Considerando essa quantidade de linguagens, certamente seria muito difícil estabelecer categorias nas quais todas elas pudessem ser enquadradas. Mesmo porque essas categorias deveriam ser caracterizadas por critérios mutuamente exclusivos, no sentido de uma linguagem pertencer a apenas uma categoria. classificações são bastante distintos e nem sempre claros. A ACM (Association for Computing Machinery), por exemplo, apresenta uma classificação para as linguagens, mas não explícita o critério utilizado. Pelas categorizações apresentadas conclui-se que seja elas estejam agrupadas pela aplicabilidade dos seus resultados. As categorias propostas pela ACM incluem linguagens de aplicação, de fluxo de dados, de projetos, concorrentes, não determinísticas, procedurais, dentre outras. O paradigma que é utilizado para a sintaxe da linguagem também é um critério para classificá-las. Assim, elas podem ser categorizadas em: funcional, estruturada, orientada a objetos, natural, lógica e imperativa. Existem linguagens que utilizam mais de um desses paradigmas, no sentido, por exemplo, de não ser puramente orientada a objetos e permitir programação estrutura e orientada a objetos. Sebesta (2000) classifica as linguagens de programação em: imperativas, funcionais, lógicas e orientadas a objetos. A classificação das linguagens em gerações, de 1ª a 5ª, também é adotado. Apesar de não haver um critério efetivamente estabelecido para enquadrá-las em cada geração. Parece ser utilizado uma mescla do nível de proximidade com a linguagem humana, do tempo em que a linguagem foi lançada e das suas funcionalidades principais. Um critério de classificação bastante utilizado é ter como base a forma de escrita das instruções da linguagem. Essa forma considera o grau de compreensão pelos seres humanos e o grau de proximidade da forma como o computador interpreta as instruções em nível de máquina. A proximidade da comunicação dos seres humanos e da forma das Atualmente, há várias classificações para as linguagens de programação. Os critérios adotados para essas

18 instruções executadas pelo computador é de certa forma, inversamente proporcional. Quanto mais compreensível para os seres humanos mais distantes do formalismo necessário para uma instrução de máquina. Isso ocorre porque utilizando a linguagem humana, o mesmo conteúdo pode ser expresso de muitas maneiras distintas e ainda assim ser compreendido. Até porque uma mensagem pode estar sendo considerada de acordo com um contexto e complementada por informações e outras formas de expressão. A linguagem humana pode ser bastante ambígua, no sentido da falta de clareza e de expressividade e mesmo assim a mensagem pode ser compreendida. Devido ao formalismo que é imposto para que as instruções sejam compreendidas por um computador, o contexto e a ambigüidade não são tratados pelas linguagens de programação em geral. Esse formalismo das linguagens, de certa forma, torna mais fácil e econômico desenvolver o hardware e mesmo os compiladores e interpretadores das linguagens. Eles podem ser mais simples, tratar menos exceções ou diversidades. Ressalta-se, porém, que existem sistemas que utilizam técnicas de inteligência artificial e outras lógicas que não a bivalente que consideram, ainda que parcialmente, a forma de raciocínio, aprendizado, interpretação e comunicação dos humanos. Contudo, isso é feito em codificação, implementação do programa. Em geral as instruções realizadas pelo processador são as mesmas. Essas instruções são dependentes da arquitetura do processo, como, por exemplo, RISC (Reduced Instruction Set Computer ou Computador) e CISC (Complex Instruction Set Computer). A proximidade das instruções à linguagem da máquina é o critério adotado para classificar as linguagens neste trabalho. Contudo, ressalta-se que o uso desse critério como único é abrangente demais. Isso porque, na forma mais básica de classificação estariam: a) linguagens de baixo nível – linguagem de máquina que expressa as instruções em formato binário, um conjunto de 0s e 1s. b) linguagens de alto nível – todas as demais, como: Assembly e HTML (HyperText Markup Language ). Apesar da linguagem Assembly possuir instruções para manipulação de registradores, as suas instruções não são efetivamente como as compreendidas pelo hardware. Isso faz com que ela possa ser entendida como não sendo de baixo nível. A linguagem Assembly necessita de um montador, o Assembler, para que suas instruções sejam interpretadas pela máquina.

19 Considerando esse observação sobre a linguagem Assembly, outra forma de categorização é: a) linguagens de baixo nível – linguagem de máquina; b) linguagens de médio nível – Assembly; c) linguagens de alto nível – as demais linguagens. Essas linguagens são interpretadas e/ou compiladas por aplicativos definidos com esse objetivo. Devido a existência de classificação distinta para o critério de proximidade com a linguagem de máquina, neste trabalho, adotou-se a seguinte classificação: a) linguagens de máquina - Os processadores possuem um conjunto de códigos que eles podem executar e que é expresso em números binários. Um programa em código de máquina consiste em uma sequência de caracteres em sistema binário, hexadecimal ou octal contendo as instruções que o computador deve executar. A linguagem de máquina é especifica para cada arquitetura de processador. b) linguagem de montagem – Em uma linguagem de montagem, as instruções do código de máquina são substituídas por símbolos mnemônicos que correspondem a essas instruções. Como existe uma relação direta entre a linguagem de máquina e a linguagem de montagem, essa não é compilada e a passagem para linguagem de máquina é realizada por um montador denominado Assembler. A linguagem de montagem é especifica para cada arquitetura de processador. A linguagem Assembly é o exemplo mais clássico e característico de uma linguagem de montagem. c) linguagens de alto nível – Em uma linguagem de alto nível as instruções definidas na linguagem estão mais próximas da linguagem falada pelos humanos, ainda, que essas instruções tenham que corresponder a uma rigidez sintática e semântica estabelecidas para cada linguagem. Nessas linguagens, o próprio processo de compilação e de interpretação é complementado pela montagem e transformação em linguagem de máquina. Em uma linguagem interpretada, o interpretador traduz para a linguagem de máquina cada instrução à medida que elas são executadas. Em uma linguagem compilada, todas as instruções do programa são traduzidas para a linguagem de máquina antes da execução do programa. O conjunto das instruções que compõem um programa em linguagem de alto nível é conhecido como programa fonte e o programa em linguagem de máquina é conhecido

20 como programa objeto. Como as linguagens de alto nível abrangem tipos bastante distintos, neste trabalho elas são subdivididas em: a) Linguagens para aplicações científicas – destinadas para aplicações que requeiram uso intensivo de funções e fórmulas matemáticas. Exemplo: Fortran. b) Linguagens para aplicações comerciais – para as aplicações que enfatizam operações como armazenamento e recuperação de dados, seja para desktop ou para web, seja para as áreas de entretenimento, auxílio à tomada de decisão, controles, incluindo interação com hardware, ou outros. Exemplo: Java, Python, .Net, Delphi, PHP (Hypertext Preprocessor). c) Linguagem de marcação e scritps – utilizadas na elaboração de páginas web. Exemplo: HTML e JavaScripts. d) Linguagem de modelagem – para documentar as atividades de análise e projeto de um sistema, incluindo também interface, banco de dados, arquitetura. Exemplo: UML (Unified Modeling Language). e) Linguagens para inteligência artificial – para aplicações voltadas para inteligência artificial, como redes neurais e robótica. Exemplo: Prolog (programação lógica e inteligência artificial), GPSS (General Purpose Simulation System) (simulação), LISP (LISt Processing) (inteligência artificial). f) Linguagem de consulta – para realizar operações com dados armazenados em banco de dados. Exemplo: SQL (Structured Query Language). O critério utilizado para classificar as linguagens de alto nível é a sua aplicação principal, especialmente entre linguagens científicas e comerciais e entre as comercias e de script. Isso porque uma linguagem comercial pode implementar um sistema com aplicação científica e um sistema comercial pode ser implementado utilizando apenas linguagem de marcação e scritps. É comum que para a implementação de um mesmo sistema ou aplicativo essas seis categorias de linguagens de alto nível sejam utilizadas em conjunto. Por exemplo: um sistema para ambiente Internet (linguagem de marcação e script) que automatize operações de uma indústria (linguagem comercial) de produção de tintas (linguagem científica pelos processos científicos que definem a fórmula das tintas e permitam fazer

21 simulações com essas fórmulas) para definir tintas mais adequadas para determinados usos e que faça uso de robôs para manipular substâncias tóxicas (linguagem para inteligência artificial), utilizando uma base de dados (linguagem de consulta). Para a implementação, esse sistema foi modelado utilizando uma linguagem de modelagem. Apesar da quantidade de linguagens de programação e das distintas classificações em que elas podem enquadrar-se, de maneira geral elas possuem itens ou elementos básicos ou fundamentais que são mais ou menos comuns.

2.3 Elementos fundamentais de uma linguagem de programação Embora, de maneira geral, todas as linguagens possuam os elementos considerados fundamentais de uma linguagem de programação, ressalta-se que a sintaxe e a semântica de cada uma dessas linguagens pode ser bastante distinta. Esta seção apresenta os itens considerados básicos de uma linguagem de programação visando a representação de algoritmos e para isso é utilizado pseudocódido, português estruturado e descrição narrativa. Embora os elementos considerados neste texto como fundamentais ou básicos de uma linguagem, eles não são consenso entre os autores que publicam sobre linguagens de programação ou mesmo sobre algoritmos. A seguir, está a forma como alguns dos autores, em publicações sobre algoritmos e linguagens de programação, tratam esses elementos. Esses autores serviram de base para o exposto nas próximas subseções. Forbellone e Eberspächert (1993) denominam esses elementos de técnicas básicas de programação e os agrupam em: a) Tipos de dados e instruções primitivas – abrangendo dados; variáveis e constantes; operadores matemáticos, lógicos e relacionais; e expressões matemáticas e lógicas; b) Estruturas de controle decisão – permitem definir se um conjunto de instruções será ou não realizada em decorrência do resultado de um teste lógico. c) Estruturas de repetição – permitem a realização de um conjunto de código repetidas vezes. O número de vezes pode ser pré-determinado em tempo de programação ou ser resultado de uma instrução em tempo de execução. No livro de Guimarães e Lages (1994) é possível identificar os seguintes itens

22 fundamentais de uma linguagem: a) Declaração de variáveis e seus tipos básicos; b) Comandos básicos: atribuição; operadores aritméticos, lógicos e relacionais; c) Blocos e comandos básicos de controle – incluindo decisão e repetição; d) Estruturas de dados homogêneas – são os vetores e as matrizes; e) Estruturas de dados heterogêneas – são os registros; f) Procedimentos e funções. Farrer et al. (1993) definem os seguintes itens fundamentais de uma linguagem de programação: a) Constantes; b) Variáveis; c) Expressões aritméticas, lógicas, literais; d) Comando de atribuição – para fornecer ou atribuir um valor para uma variável ou constante; e) Comandos de entrada e saída; f) Estrutura seqüencial, condicional; de repetição – são as formas básicas nas quais as instruções são executadas. Boratti e Oliveira (2007) definem que a programação de algoritmos inclui: a) Algoritmos – tipos de valores, variáveis, expressões, comandos de entrada e saída, constantes; b) Estruturas de seleção; c) Estruturas de repetição; d) Tipos estruturados homogêneos; e) Subalgoritmos – são as funções. Mizrahi (1990) utiliza os seguintes itens fundamentais para a estrutura básica de um programa em linguagem de programação C: a) Função – pelo fato que a linguagem C é baseada em funções; b) Constantes e variáveis; c) Palavras-chave; d) Operadores – abrangendo entrada e saída e alguns funções de entrada e de saída; operadores aritméticos, de atribuição e relacionais, a precedência de operadores; e) Laços – estruturas de repetição;

23 f) Comandos de decisão – estrutura de decisão; g) Matrizes e strings – matrizes são unidimensionais (vetores) e bidimensionais, strings são matrizes unidimensionais de caracteres. A linguagem PHP é destinada ao desenvolvimento para ambiente Internet e seus elementos básicos são semelhantes aos definidos para algoritmos. Converse e Park (2001), organizam os elementos básicos da linguagem PHP da seguinte forma: a) Análise da sua sintaxe semelhante à linguagem C; b) Comentários; c) Variáveis; d) Saída; e) Tipos de dados: simples, arrays e objetos; f) Estruturas de controle decisão e repetição; g) Funções. A linguagem Java com aplicações bastante distintas, como programação para ambiente Internet e dispositivos móveis, é definida a partir dos seguintes elementos básicos (DEITEL, DEITEL, 2005): a) Saída; b) Tipos de dados; c) Operadores; d) Conceituação de orientação a objetos; e) Instruções (estruturas) de controle; f) Métodos (funções); g) Arrays; h) Classes e objetos. Como a linguagem Java é orientada a objetos, ainda que não puramente orientada a objetos como ocorre com Smalltalk, conceitos e a forma de trabalhar objetos é um aspecto bastante acentuado nas publicações para programação Java. Para este trabalho, procedimentos, funções e subalgoritmos são apenas formas de organizar o código. Assim como são as classes em programação orientada a objetos. Embora para programação orientada a objetos, classes seja um conceito primário, elas são basicamente um encapsulamento de dados e funções (operações ou métodos) relacionados à determinado tipo específico de objetos que pertencem à respectiva classe. De certa forma tipos estruturados de dados homogêneos e heterogêneos se utilizam de dados simples ou primitivos para compor essas estruturas.

24 O conteúdo e a abordagem dos autores: Forbellone e Eberspächert (1993), Guimarães e Lages (1994), Farrer et al. (1993), Boratti e Oliveira (2007), Mizrahi (1990), Converse e Park (2001) e Deitel e Deitel (2005) foram utilizados para definir os seguintes elementos fundamentais de uma linguagem de programação estruturada e não orientada a objetos: a) Variáveis e constantes; b) Tipos de dados simples; c) Tipos de dados compostos; d) Operadores: aritméticos, relacionais e lógicos; e) Estruturas de controle: sequência, decisão e repetição; f) Funções. Esses elementos são apresentados nas subseções a seguir.

2.3.1 Sintaxe e semântica de uma linguagem

Em toda linguagem de programação, as frases que são, na verdade, instruções, são definidas considerando dois aspectos: a sintaxe e a semântica. A sintaxe se refere à forma de representar essas instruções. A semântica ao seu conteúdo. Em uma analogia com a língua portuguesa, uma frase sintaticamente correta possui verbo, sujeito e objeto e as palavras que a compõem estão grafadas corretamente. Por exemplo: O aluno está desenvolvendo um programa utilizando linguagem Python. A sintaxe está correta com sujeito, verbo e predicado e as palavras estão corretas. A semântica também por indicar que o aluno está utilizando a linguagem de programação Python para desenvolver um programa.

2.3.2 Variáveis e constantes Os dados manipulados por um programa de computador sendo executado precisam estar na memória do computador. Esses dados são localizados e manipulados por meio de identificadores denominados variáveis ou constantes.

25
2.3.2.1 Variáveis

Na Matemática, as variáveis são entidades capazes de representar valores ou expressões e na programação armazenam valores, que podem ser outras variáveis. As variáveis são definidas, em termos de quais e do tipo de conteúdo que elas podem conter, são definidas em tempo de projeto, quando o código do programa está sendo definido. Em tempo de execução, quando o programa está sendo usado, o conteúdo das variáveis fica armazenado na memória do computador. Geralmente, as variáveis recebem valores de acordo com o tipo de dados que lhes for especificado, ou seja, uma variável do tipo inteiro poderá receber valores inteiros e não caractere, por exemplo. Contudo, há linguagens de programação que não há essa restrição. O tipo de dado que uma variável pode conter é denominado tipagem da variável e pode ter diferentes classificações. Uma variável por ser estática ou dinâmica. A verificação do tipo de um dado é feita de forma estática em tempo de compilação ou de forma dinâmica em tempo de execução. Tipagem estática, na declaração da variável é necessário definir o tipo de dado que ela conterá. Isso ocorre antes de a variável ser utiliza ou no momento do seu primeiro uso. Tipagem dinâmica a variável tem o seu tipo definido no momento em que ela recebe o valor. Uma variável também pode ter um tipo fraco ou forte. Linguagens implementadas com tipos de dados fortes exigem que o tipo de dado de um valor seja do mesmo tipo da variável ao qual este valor será atribuído. A tipagem forte não permite atribuir tipos de dados diferentes ao definido para a variável sem perda de informações ou mesmo o analisador léxico pode não aceitar essas atribuições. Por exemplo, para atribuir um valor real para uma variável que é do tipo inteiro, é preciso antes, transformar o valor a ser atribuído para o tipo da variável que o receberá. A tipagem fraca não possui tipos bem definidos ou então não se misturam, as variáveis não precisam ser associadas a um tipo, o compilador ou interpretador faz essa verificação sozinho. Uma variável pode conter um dado de tipo primitivo ou composto. Um tipo primitivo (também conhecido por nativo ou básico) é fornecido por uma linguagem de programação como um bloco de construção básico. Dependendo da implementação da linguagem, os tipos primitivos podem ou não possuir correspondência direta com objetos na memória. Tipos primitivos típicos, normalmente, incluem caractere, inteiro, ponto flutuante (representa o conjunto dos números reais), booleano (lógica booleana, verdadeiro ou

26 falso) e algum tipo de referência (como ponteiro ou handles). Ressalta-se que nem todas as linguagens possuem todos esses ou somente esses tipos primitivos. Um tipo composto pode ser construído em uma linguagem de programação a partir de tipos primitivos e de outros tipos compostos, em um processo chamado composição. Vetores e matrizes são exemplos comuns de tipos compostos. Embora não obrigatoriamente o seja para todas as linguagens de programação. As variáveis, como o próprio nome sugere, podem sofrer alterações durante o percurso do desenvolvimento do programa e, podem ter seu valor alterado inclusive durante a execução do mesmo.
2.3.2.2 Constantes

Constantes são criadas para armazenar um valor único durante toda a execução de um programa. Esse valor é definido em tempo de programação, ou seja, quando o programa é elaborado. O usuário do programa não pode alterar esse valor, independentemente do número de vezes que o programa é executado. Outra denominação para constante se refere a quando é utilizado um valor no lugar de uma variável. Em vez deste valor estar armazenado em uma variável, ele é colocado diretamente. Por exemplo: Soma (variável) = 3 + 2. 3 e 2 são constantes que poderiam estar armazenadas nas variáveis Num1 e Num2, respectivamente e assim ficaria Soma = Num1 + Num2.

2.3.3 Tipos de dados simples Os tipos de dados comumente encontrados nas linguagens de programação são: numérico, caractere e lógico. Não são todas as linguagens de programação que possuem todos esses tipos e a maioria das linguagens derivam tipos a partir desses. A linguagem C, por exemplo, não possui o tipo lógico. Na linguagem Java, por exemplo, String é uma classe e não um tipo primitivo da linguagem. Tipo Numérico - um dado numérico representa valores que podem ser inteiros ou fracionários, também denominados reais. Inteiro - representa números inteiros, positivos ou negativos, como a idade de uma pessoa. Exemplos:
5; +5; -7; 0

27 Real - representa números fracionários, positivos ou negativos, como o valor monetário que se refere ao salário de uma pessoa. Exemplos:
-0.5; 1.5; 2.0

Tipo Caractere - são valores de apenas um dígito, seja uma letra, um número ou um caractere especial (*, _, &). Comumente um dado do tipo caractere é representado entre aspas simples ou apóstrofos. São bastante utilizados quando é necessário informar o sexo de uma pessoa como 'F' ou 'M', por exemplo. Exemplos:
'1'; 'a'; 'B'; '*'

Tipo Lógico - representam apenas dois valores: verdadeiro e falso. São usados, por exemplo, para representar o resultado lógico de uma comparação. Exemplos:
2>4 (verdadeiro) 'A Terra é plana.' (falso).

2.3.4 Tipos de dados compostos

Os tipos de dados compostos homogêneos normalmente são denominados vetores, matrizes e strings. De certa forma esses conceitos são redundantes porque vetores e strings são matrizes de apenas uma dimensão; matrizes são compostas por vetores unidimensionais e string é uma denominação particular para um vetor de caracteres. Uma string normalmente é utilizada para armazenar palavra, frase, texto. Vetores - são matrizes unidimensionais usadas para armazenar um conjunto de valores de um mesmo tipo de dados. Cada dado armazenado em um vetor pode ser individualizado por um índice que indica a posição dentro do vetor que esse dado ocupa. Para o acesso a cada um desses dados é necessário indicar a variável que denomina o vetor e o respectivo índice. Vetores são formados por itens chamados elementos. Quando um vetor é manipulado são reservados endereços contíguos de memória e cada elemento do vetor possui um endereço para poder ser referenciado. Isso significa que o primeiro elemento possui índice 0 ou 1 (dependendo da sintaxe da linguagem), o segundo possui índice 1 ou 2 e assim por diante. Exemplo:
Vetor1[10]:

inteiro. A variável Vetor1, com os índices de 0 a 9 (Vetor1[0],

Vetor1[1] ... Vetor1[9]) pode armazenar até 10 valores inteiros, cada um deles individualizado pelo respectivo índice. Matrizes - matrizes bidimensionais são formadas por mais de uma matriz

28 unidimensional ou vetor. O objetivo é inserir vários valores de um mesmo tipo em uma mesma variável, lembrando que esses valores são individualizados pelos índices que representam cada uma das dimensões da matriz. Assim, para ter acesso aos valores armazenados é preciso fazer referência a cada elemento da matriz através de suas coordenadas linha e coluna, se ela for de duas dimensões. Exemplo:
Matriz1[10][2][2]:

inteiro. A variável Matriz1 - com os índices de 0 a 9 para a

primeira dimensão, 0 a 1 para a segunda e 0 a 1 para a terceira – pode armazenar até 40 valores inteiros, cada um deles individualizado pela combinação dos três índices. Strings - são valores representados por cadeias de caracteres, ou seja, uma sequência contínua de caracteres, que pode ser visto como um vetor de caracteres. É comum que eles sejam representados entre aspas. Exemplos:
“Rua Fernando Ferrari” “Maria” “** Algoritmos **” “1234”

2.3.5 Operadores

Os operadores são meios pelos quais dados são incrementados, decrementados, comparados e avaliados em um programa. Os operadores são classificados em: • • • Operadores Aritméticos; Operadores Relacionais; Operadores Lógicos.

2.3.5.1 Operadores Aritméticos

Os operadores aritméticos são utilizados para realizar operações matemáticas. Os símbolos para os operadores aritméticos são:

29 Operação Adição Subtração Multiplicação Divisão Exponenciação Radiciação Resto da divisão Símbolo + * / ou DIV ^ ou ** √ % ou REST

Não são todas as linguagens de programação que possuem operadores equivalentes a todos esses símbolos. Na linguagem C, por exemplo, não há operadores para exponenciação e radiciação. Isto é feito por meio de funções implementadas utilizando operações mais elementares como a adição. Uma expressão matemática é resolvida da esquerda para a direita, respeitando a ordem de prioridade das operações e o uso de parênteses. Prioridade de ordem de resolução dos operadores aritméticos em uma expressão: 1. Exponenciação e radiciação; 2. Multiplicação e divisão; 3. Soma e subtração. Essa ordem é alterada com o uso de parênteses. Se houver mais de um conjunto de parênteses, a ordem de resolução é dos parênteses mais internos para os mais externos. Se há duas ou mais operações da mesma prioridade de ordem de execução consecutivas, a resolução ocorre da esquerda para a direita. Quando o resultado de uma expressão é atribuído a uma variável, inicialmente é resolvida a expressão numérica e em seguida o valor é armazenado na variável. Por exemplo:
Media ← (Nota1 + Nota2) /2

Como tem parênteses, inicialmente o conteúdo da variável Nota1 é somando com o conteúdo da variável Nota2. Em seguida, o resultado dessa soma é dividido por 2. Por fim, o resultado dessa divisão é armazenado na variável Media.
Contador ← 10 Contador ← Contador + 1

Ao conteúdo da variável Contador, que é 10 antes de ser executada a segunda instrução, é incrementado 1. Esse resultado é armazenado na variável Contador e a mesma passa a ter 11 como valor armazenado.

30 2.3.5.2 Operadores Relacionais

Os operadores relacionais têm o objetivo de comparar tanto variáveis quanto constantes tendo como resultado um valor lógico, como, por exemplo, verdadeiro ou falso. Não são todas as linguagens de programação que possuem um tipo de dado denominado lógico. Na linguagem C, por exemplo, é convencionado que zero representa falso e qualquer valor diferente de zero representa verdadeiro. Contudo, essa convenção pode ser redefinida na codificação de um programa. Os operadores relacionais são: Descrição Igual a Diferente Maior que Menor que Maior ou igual a Menor ou igual a Símbolo = < > ou != ou # > < >= <=

Por exemplo, tendo duas variáveis A e B com as seguintes atribuições:
A ← 5 B

← 3

Os resultados das expressões são: Expressão A=B A <> B A>B A<B A >= B A <= B Resultado Falso Verdadeiro Verdadeiro Falso Verdadeiro Falso

2.3.5.3 Operadores Lógicos

Os operadores lógicos têm o objetivo de vincular resultados de testes lógicos em expressões.

31 Os operadores lógicos são: Operador E (AND) OU (OR) OU Exclusivo (XOR) NÃO (NOT) Exemplo:
Var1 ← 3
Condição1 Condição2 Condição1 E Condição2 Condição1 OU Condição2 NÃO-Condição1

Significado Uma expressão E (AND) é verdadeira se todas as condições forem verdadeiras. Uma expressão OU (OR) é verdadeira se pelo menos uma condição for verdadeira Uma expressão OU Exclusivo (XOR) é verdadeira quando apenas uma das condições for verdadeira. Uma expressão NÃO (NOT) inverte o valor da expressão ou condição, se verdadeira inverte para falsa e vice-versa.

Var1 > 2 V Var1 > 2 V Var1 > 5 F Var1 > 5 F

Var1 > 1 V Var1 = 2 F Var1 > 2 V Var1 < 2 F

V F F F

V V V F

F F V V

O uso de parênteses pode alterar a ordem de avaliação de uma expressão que contém operadores lógicos. Exemplo:
Var1 ← 2 Var2 ← 3 Var3 ← 5

Uma expressão composta com essas três variáveis, utilizando operadores lógicos e parênteses:
Var1 > 5 E (Var2 = 5 OU Var3 = 5)

1º verificar internamente aos parênteses: Var2 = 5 F OU OU V Var3 = 5 V

32 2º verificar o restante da expressão: Var1 > 5 Var1 > 5 F E E E F A mesma expressão sem parênteses:
Var1 > 5 E Var2 = 5 OU Var3 = 5

(Var2 = 5 OU Var3 = 5) V V

Verificar a expressão linearmente da esquerda para a direita: Var1 > 5 F E E F Var2 = 5 F V Por meio desse exemplo é possível verificar que o uso de parênteses pode definir um resultado diferente para uma expressão lógica. OU OU OU Var3 = 5 V V

2.3.6 Estruturas de controle

Para os interesses e entendimento deste trabalho, existem três estruturas básicas para definir e executar algoritmos: seqüência, decisão e repetição. Autores como Boratti e Oliveira (2007), Manzano e Oliveira (2000) e Forbellone e Eberspächert (1993) se referem apenas à categorização de estruturas de seleção e de repetição. Boratti e Oliveira (2007) utilizam a palavra seleção ao invés de decisão e Forbellone e Eberspächert (1993) as denominam genericamente estruturas de controle. Uma estrutura de seqüência estabelece que um conjunto de instruções seja executado sequencialmente, da primeira para a última e da esquerda para a direita. As estruturas de decisão e repetição podem ser genericamente denominadas como estruturas de controle. Elas têm o objetivo de controlar (controlar a decisão) se um determinado conjunto de instruções será executado ou repetir (controlar e repetição) um conjunto de instruções um determinado número de vezes de acordo com condições especificadas.

33
2.3.6.1 Seqüência

As instruções de uma seqüência serão executadas estritamente de acordo com essa seqüência, ou seja, de cima para baixo e da esquerda para a direita, da primeira a última instrução. A forma geral da representação de uma seqüência é a seguinte:
Instrução-1 Instrução-2 : Instrução-n

Na Figura 2, o algoritmo para calcular a área do círculo está representado em fluxograma e em português estruturado. É dessa forma que são representados os exemplos de algoritmos nessa seção. Esse exemplo mostra uma estrutura seqüencial. Figura 2 – Algoritmo para calcular a área de um círculo Em fluxograma Em português estruturado Programa Área_Circulo Inicio Raio: real Pi: real Area: real Pi ←3.14159 Leia Raio Area ← Pi * Raio * Raio Escreva Area Fim

As instruções do algoritmo representado na Figura 1 são feitas sequencialmente, da primeira para a última. O valor de Pi é uma constante e dessa forma não precisa ser informado pelo usuário. O que o define como constante é o fato de ele permanecer com um valor fixo independentemente das instruções ou do número de execuções do programa. As variáveis são declaradas do tipo real por armazenar valores com casas decimais.

34 Na Figura 3, está o algoritmo para calcular a média de duas notas representado em fluxograma e em português estruturado. Esse algoritmo também é elaborado uma estrutura seqüencial, as suas instruções são executadas sequencialmente. Figura 3 – Algoritmo para calcular a média de duas notas Em fluxograma
início

Em português estruturado Programa Média Inicio Nota1: real Nota2: real Media: real Leia Nota1 Leia Nota2 Media = (Nota1 + Nota2)/2 Escreva Media Fim

Ler Nota1 Ler Nota2

Media <-- (Nota1 + Nota2)/2

Escrever Media

fim

No algoritmo para calcular a média, primeiro é necessário somar as duas notas e depois dividir o resultado dessa soma pela quantidade de notas somadas. Isso é necessário por causa da prioridade das operações: primeiro a divisão e depois a soma. Se não fosse feito dessa forma, primeiro seria dividido o valor da segunda nota por 2 (a quantidade de notas) e o resultado dessa divisão seria somado com a primeira nota. Não haveria erro de sintaxe, as instruções estariam corretas, mas haveria erro de semântica, de contexto, porque o resultado da expressão não é a média dos valores. Uma estrutura de sequência pode ser aplicada quando todas as instruções são executadas sequencialmente. Isso ocorre quando não há necessidade de realizar determinadas instruções em decorrência do resultado de instruções anteriores ou não é necessário repetir um determinado conjunto de instruções.

2.3.6.2 Decisão

Uma estrutura de decisão também é conhecida como estrutura condicional. Nesse tipo de estrutura a execução de um conjunto de instruções está subordinada ao resultado de um teste lógico. A decisão deve ser sempre usada quando há necessidade de testar

35 alguma condição e em função de a mesma realizar determinadas instruções. Com as instruções de decisão ou de desvio é possível fazer com que o programa proceda de uma ou de outra maneira. Isso ocorre de acordo com as decisões lógicas que são tomadas em função dos dados manipulados pelo algoritmo. Esses dados podem ser informados pelo usuário ou resultantes de expressões e operações realizadas por instruções do próprio algoritmo. As principais estruturas de decisão são: se ... então, se ... então ... senão e caso ... selecione.

2.3.6.2.1 se ... então

A estrutura de decisão se ... então é utilizada quando um conjunto de instruções depende de uma condição ser verdadeira, e não há instruções a serem executadas se a condição for falsa. Forma geral de uma estrutura de decisão se ... então:
se <condição> então <conjunto de instruções> fim se

Onde: • • condição determina um teste lógico. conjunto de instruções define as instruções que serão realizadas se a condição for estabelecida. A Figura 4 apresenta o fluxograma da estrutura de decisão se ... então. Figura 4 - Fluxograma da estrutura de decisão se ... então
Sim

condição Não

instruções

36 A estrutura de decisão se ... então é equivalente ao comando if de muitas linguagens. Na Figura 5, o algoritmo para indicar se um aluno está aprovado em decorrência da sua média está representado em fluxograma e em português estruturado. Nesse algoritmo determinada instrução será realizada em decorrência do valor de uma determinada variável. Figura 5 – Algoritmo para verificar a média de um aluno Em fluxograma Em português estruturado Programa Aprovação Inicio Nota: Inteiro Leia Nota se Nota >=7 então Escreva Aprovado fim se Fim

De acordo com a representação da Figura 4, um teste é realizado para verificar se o conteúdo da variável Nota é maior ou igual a 7. Caso seja igual ou maior que 7, a mensagem aprovado é apresentada.

2.3.6.1.2 se ... então ... senão

A estrutura se ... então ... senão é utilizada para executar um conjunto de instruções se uma determinada condição é verdadeira e para executar outro conjunto de instruções se essa condição é falsa. Forma geral de uma estrutura de decisão se ... então ... senão:
se <condição> então <conjunto de instruções 1> senão <conjunto de instruções 2>

37
fim se

Onde: • • condição determina um teste lógico. conjunto de instruções 1 define as instruções que serão realizadas se a condição for estabelecida, for verdadeira. • conjunto de instruções 2 define as instruções que serão realizadas se a condição não for estabelecida, for falsa. A Figura 6 apresenta o fluxograma da estrutura de decisão se ... então ... senão. Figura 6 - Fluxograma da estrutura de decisão se ... então ... senão

Não

condição

Sim

instruções

instruções

A estrutura de decisão se ... então é equivalente ao if … else de muitas linguagens de programação. Na Figura 7 está um algoritmo para indicar se um aluno está aprovado ou reprovado em decorrência da sua média está representado em fluxograma e em português estruturado. Esse algoritmo utiliza a estrutura de decisão se ... então.

38 Figura 7 - Algoritmo para indicar aprovação ou reprovação Em fluxograma Em português estruturado Programa Aprovação_Reprovação Inicio Nota: Inteiro Leia Nota se Nota >=7 então Escreva Aprovado senão Escreva Reprovado fim se Fim

De acordo com a representação da Figura 6, um teste é realizado para verificar se o conteúdo da variável Nota é maior ou igual a 7. Caso seja igual ou maior que 7, a mensagem aprovado é apresentada. Caso não atenda essa condição, a mensagem reprovado é apresentada.

2.3.6.1.3 Comandos condicionais encadeados

Existem casos em que é necessário estabelecer verificações de condições sucessivas, em que uma determinada instrução será executada se um conjunto anterior de instruções ou condições for satisfeito. Juntamente com o conjunto de instruções executadas podem ser feitas novas verificações de condições. Este tipo de estrutura poderá possuir diversos níveis de condições, sendo chamadas de aninhamentos ou encadeamentos. Um exemplo de algoritmo utilizando estrutura de decisão se ... então ... senão encadeados é apresentado na Figura 8. O algoritmo da Figura 8 tem o objetivo de indicar se um aluno está aprovado ou reprovado em decorrência da sua média ou de sua nota de recuperação e está representado em fluxograma e em português estruturado.

39 Figura 8 - Algoritmo para indicar aprovação ou reprovação Em fluxograma Em português estruturado Programa Recuperação Inicio Nota: Inteiro Leia Nota se Nota >=7 então Escreva Aprovado senão Leia NotaRecuperacao se NotaRecuperacao > 8 Escreva Aprovado senão Escreva Reprovado fim se Fim

Quando existem vários comandos SE encadeados, ocorre um aninhamento que se refere ao fato de existir uma seleção dentro de outra. Para que o aninhamento esteja correto é necessário que a construção interna esteja completamente inserida na construção imediatamente externa. A Figura 9 apresenta um modelo de identação para estruturas se aninhadas. Esse padrão de identação pode ser utilizado para qualquer estrutura de algoritmo. Em comandos de repetição, por exemplo, os indicadores de início e fim da repetição determinam que o bloco de comandos deva ser identado.

40 Figura 9 – Modelo de identação de estruturas se ... então ... senão se condição 1 então se condição 2 então se condição 2 então senão se condição 2 então senão fim se senão se condição 3 então se condição 2 então senão se condição 2 então fim se senão se condição 4 então se condição 2 então fim se senão se condição 5 então senão fim se senão fim se

2.3.6.1.4 escolha ... caso

A estrutura de decisão escolha ... caso, também definida como caso selecione, é utilizada para testar uma única expressão ou o valor de uma variável. O resultado contido na condição é comparado com os valores fornecidos em cada cláusula “caso”. A estrutura de decisão escolha ... caso é equivalente ao switch case que muitas linguagens de programação possuem. Forma geral de uma estrutura de decisão escolha ... caso:
escolha (expressão) caso resposta1: <conjunto de instruções 1>; caso resposta2: <conjunto de instruções 2>; caso respostan: <conjunto de instruções n>; senão <conjunto de instruções z>; fim escolha

Onde:

41 • expressão é uma variável que será avaliada. De acordo com o valor contido nessa variável será escolhido um dos casos. • caso contém os possíveis conteúdos para a variável expressão. Esse conteúdo determinada qual conjunto de instruções será realizado. • senão indica o conjunto de instruções padrão (default) que é executado se o conteúdo da variável em expressão não corresponder a nenhum outro caso. • Os casos são avaliados na ordem seqüencial. Se nenhuma das respostas corresponderem ao resultado da expressão, o conjunto de instruções contido em senão será realizado. A existência de uma condição senão é opcional na estrutura de decisão escolha ... caso. A Figura 10 apresenta o fluxograma da estrutura de decisão escolha ... caso. Figura 10 - Fluxograma da estrutura de decisão escolha ... caso

expressão

instruções 1

instruções 2

instruções (default)

Na Figura 11 está um algoritmo para escrever um número por extenso. Esse algoritmo está representado em fluxograma e em português estruturado. Esse é um exemplo de algoritmo utilizando a estrutura de decisão escolha ... caso.

42 Figura 11 - Algoritmo para escrever um número por extenso Em fluxograma Em português estruturado Programa NumeroExtenso Inicio Num: Inteiro Leia Num escolha caso Num seja 0: Escreva zero caso Num seja 1: Escreva um senão Escreva Outro número fim caso Fim

Nesse exemplo se o conteúdo da variável Num for 0 ou 1, esse conteúdo será escrito por extenso. Caso contrário será escrito “outro número”.

2.3.6.2 Repetição

Uma estrutura de repetição é utilizada para que um determinado conjunto de instruções ou comandos seja executado um número definido de vezes, enquanto uma condição lógica permanece verdadeira ou até que uma condição lógica seja alcançada. As subseções a seguir apresentam as estruturas de repetição enquanto faça, faça enquanto e para até faça. Essas não são as únicas estruturas de repetição que as linguagens de programação possuem. Contudo, essas são as implementadas pela maioria das linguagens de programação.

2.3.6.2.1 enquanto ... faça

A estrutura de repetição enquanto ... faça é utilizada quando um conjunto de instruções deve ser executado repetidamente, enquanto uma determinada condição (expressão lógica) permanecer verdadeira. O número de repetições não é previamente

43 conhecido. A finalização de execução ocorrerá em decorrência de condições obtidas durante a própria execução do algoritmo. Forma geral de uma estrutura de repetição enquanto faça:
enquanto <condição> faça <conjunto de instruções> fim enquanto

Onde: • • • condição determina um teste lógico. conjunto de instruções define as instruções que serão realizadas enquanto condição for estabelecida.

Dependendo do resultado do teste da condição, o conjunto de instruções poderá não ser executado nenhuma vez (se for falsa no primeiro teste) ou ser executado várias vezes (enquanto a condição for verdadeira). Na estrutura enquanto ... faça, o conjunto de instruções será executado enquanto a condição for verdadeira. O teste da condição será sempre realizado antes de qualquer operação. Enquanto a condição for verdadeira o processo se repete. A Figura 12 apresenta o fluxograma da estrutura de repetição enquanto ... faça. Figura 12 - Fluxograma da estrutura de repetição enquanto ... faça
condição Sim instruções

Na Figura 13, está um algoritmo para imprimir a tabuada de um número está representado em fluxograma e em português estruturado. É um exemplo de algoritmo utilizando a estrutura de repetição enquanto ... faça.

44 Figura 13 - Algoritmo para imprimir a tabuada de um número Em fluxograma Em português estruturado Programa Tabuada Inicio Contador: Inteiro Num: Inteiro Leia Num enquanto Contador <=10 Escreva Contador * Num = Contador *Num Contador = Contador + 1 fim enquanto Fim

Na representação do algoritmo na Figura 12 verifica-se que logo no início do programa é atribuído o valor 0 (zero) à variável Contador. Inicialmente Contador vale 0, em seguida é realizado um teste condicional para verificar se Contador é menor ou igual a 10. Enquanto esta condição for verdadeira, a tabuada do número é mostrada. Esta seqüência de instrução será executada enquanto Contador for menor do que 10. Quando o teste condicional não for mais verdadeiro, quando Contador for igual ou maior do que 10, o programa é finalizado.

2.3.6.2.2 faça ... enquanto

Na estrutura de repetição faça ... enquanto, primeiro são executadas as instruções, e somente depois é realizado o teste da condição. Se o resultado do teste da condição for verdadeiro, as instruções são executadas novamente, caso seja falso é encerrada a repetição das instruções. Essa estrutura é utilizada quando é necessário que o conjunto de instruções seja executado pelo menos uma vez, independentemente da condição inicial da variável de controle. Isto significa que mesmo que a condição seja inicialmente falsa o conjunto de instruções será realizado. Forma geral de uma estrutura de repetição faça … enquanto:
faça <conjunto de instruções> enquanto <condição>

45 Onde: • • condição determina um teste lógico. conjunto de instruções define as instruções que serão realizadas enquanto a condição for estabelecida. Independentemente do resultado primeiro teste da condição, o conjunto de instruções será realizado pelo menos uma vez. Contudo, as execuções subseqüentes somente serão realizadas enquanto a condução for verdadeira. A Figura 14 apresenta o fluxograma da estrutura de repetição faça ... enquanto. Figura 14 - Fluxograma da estrutura de repetição faça ... enquanto
instruções

Sim

condição Não

A Figura 15 apresenta um exemplo de algoritmo utilizando a estrutura de repetição faça ... enquanto. Esse algoritmo tem o objetivo de ler números até que seja informado um número positivo. O algoritmo está representado em fluxograma e em português estruturado.

46 Figura 15 - Algoritmo para ler números negativos Em fluxograma Em português estruturado Programa NumeroPositivo Inicio Num: Inteiro faça Leia Num enquanto Num <= 0 Escreva Num é positivo Fim

Nesse exemplo, a instrução Leia Num e a comparação Num < 0 serão realizadas até que seja informado um número positivo.

2.3.6.2.3 para ... até ... faça

A estrutura de repetição para ... até ... faça é, normalmente, utilizada quando se conhece exatamente o número de vezes que a seqüência será repetida. Essa é a aplicação mais típica da estrutura de repetição para ... até ... faça, mas não é a única. As estruturas de repetição faça ... enquanto e enquanto ... faça, também podem ser utilizadas para repetições em que se conhece previamente o número de repetições a serem realizadas. Forma geral de uma estrutura de repetição para até faça:
para <inicialização da variável de controle> até <verificação da condição de repetição> faça <conjunto de instruções a ser repetido> fim faça

Onde: • inicialização da variável de controle contém o valor para a variável que irá determinar a quantidade de vezes que conjunto de instruções será repetido. • verificação da condição de repetição realiza o teste lógico para

47 determinar se o conjunto de instruções será novamente repetido ou se a estrutura de repetição será finalizada. A verificação da condição não necessariamente precisa ser um teste lógico relacionado ao número de repetições, pode estar associado a outra condição, com, por exemplo, a variável de controle ser positiva. • conjunto de instruções define as instruções que serão realizadas enquanto a condição for estabelecida. Independentemente do resultado primeiro teste da condição, o conjunto de instruções será realizado pelo menos uma vez. Contudo, as execuções subseqüentes somente serão realizadas se enquanto a condução for verdadeira. A Figura 16 apresenta o fluxograma da estrutura de repetição para ... até ... faça. Figura 16 - Fluxograma da estrutura de repetição para ... até ... faça
inicialização da variável de controle

condição de execução sim instruções incremento da variável de controle

Uma estrutura de repetição para ... até ... faça possui uma variável de controle. Essa variável é inicializada na primeira iteração dessa estrutura e é definida uma condição que determina quando a repetição para. A cada iteração essa variável é incrementada ou decrementada e é verificado se a condição de parada é alcançada. A variável de controle funciona como um contador da quantidade de repetições que a estrutura irá executar. Este tipo de estrutura inicia em um valor pré-determinado (valor inicial) e termina num valor também pré-determinado (valor final). O incremento ou decremento é realizado a cada repetição da estrutura até que seja alcançada a condição de finalização. Na Figura 17, está o algoritmo para imprimir a tabuada de determinado número. Ele está representado em fluxograma e em português estruturado. É um exemplo de algoritmo utilizando a estrutura de repetição para ... até ... faça.

48 Figura 17 - Algoritmo para imprimir a tabuada de um número Em fluxograma Em português estruturado Programa Tabuada Inicio Num: Inteiro Cont: Inteiro Leia Num para Cont=0 até Cont < 10 faça Escreva Cont * Num fim para Fim

Nesse exemplo, já está previamente definido que a instrução Escreva Num * Cont será realizada dez vezes. A variável Cont que inicia com 0 e é incrementada em cada iteração da estrutura para ... até ... faça controla a finalização das repetições.

2.3.7 Funções

Função é um conjunto de código, identificado por nome, que pode ser chamado de um outro local do programa. Por exemplo, é possível criar uma função para calcular a média aritmética entre dois números. Esta função é genérica. Toda vez, durante o programa, que for necessário fazer a média aritmética entre dois números, é possível apenas chamar essa função. Isso é reaproveitamento de código e ocupa menos tempo do programador, uma vez que ele não precise reescrever o mesmo código. As funções recebem ou não valores que são passados como parâmetros, e podem ou não retornar um valor como resultado. Se não houver passagem de parâmetro então a função é simplesmente chamada pelo seu nome. Se houver passagem de parâmetro, esses valores devem ser informados entre parênteses seguindo o nome da função. Se houver retorno, esse pode ser atribuído para uma variável. Exemplo de uma função para o cálculo da média de dois números. Essa função recebe como parâmetros os dois números e retorna a média obtida.
Real Media (Real Numero1, Real Numero2) {

49
Real Resposta; Resposta = (Numero1 + Numero2) /2; Retorno(Resposta); }

Para utilizar a função, uma variável pode receber o retorno dessa função, como em:
MediaGeral = Media (10, 8).

Nesse exemplo os parâmetros passados foram constantes (10 e 8), poderiam ser variáveis cujos valores fossem obtidos como entrada do usuário. O retorno para uma variável também é opcional, a chamada para a função poderia estar em uma instrução para impressão ou fazer parte de uma condição de controle (repetição ou decisão). Existem dois tipos de parâmetros a serem passados para uma função: a) parâmetros por valor: o valor passado pode ser modificado dentro da função, porém seu valor original é preservado. b) parâmetros por referência: se valor passado para a função for modificado pelas suas instruções, e por ser uma referência de um valor/variável já existente os valores originais também vão sendo modificados. Só é possível passagem por referência se forem usadas variáveis como parâmetro.

50 3 MATERIAIS E MÉTODO Este capítulo apresenta os materiais e o método utilizados para realizar este trabalho.

3.1 Materiais Os materiais utilizados são referências bibliográficas sobre linguagens de programação, algoritmos e da linguagem Python. Para a realização dos exemplos práticos em linha de comando na linguagem Python foi utilizada a ferramenta Gnome Terminal e, para os arquivos .py foi utilizado o editor de texto Gedit, ambos no sistema operacional Ubuntu Linux.

3.2 Método O método se refere as principais etapas ou procedimentos utilizados para a realização do trabalho. A documentação dessas etapas ocorreu à medida que elas foram realizadas. A seguir as principais etapas utilizadas: a) Levantamento bibliográfico sobre linguagens de programação e algoritmos esse levantamento bibliográfico teve como objetivo identificar as referências que poderiam ser utilizadas para o entendimento dos conceitos básicos e fundamentais de uma linguagem de programação, bem como dos seus elementos ou itens fundamentais. Esses itens fundamentais compõem um algoritmo que representa a solução de um problema a ser implementada em uma linguagem de programação. b) Documentação dos conceitos básicos de programação – com base nas referências bibliográficas - sob a forma de livros impressos, digitais e outros materiais disponibilizados na Internet – foi elaborado o conteúdo sobre os conceitos básicos referentes à programação, como conceito de linguagem, tipos e usos. c) Documentação dos elementos fundamentais de uma linguagem de programação – utilizando conceitos e representação de pseudocódigo e fluxograma foram documentados os elementos fundamentais de uma linguagem de programação. Esses elementos, em essência, estão presentes nas linguagens de programação. Nessa etapa o

51 registro dos conceitos foi realizado em pseudocódigo para representar a essência do conceito sem preocupar-se em como o mesmo seria tratado por determinada linguagem. d) Levantamento bibliográfico sobre a linguagem Python – Com certa dificuldade de localizar referências bibliográficas impressas, foram buscados materiais digitais. Livros e outros materiais foram encontrados na Internet. Além do levantamento bibliográfico foi preparado o ambiente para desenvolvimento com a instalação da ferramenta a ser utilizada. e) Estudo da linguagem Python – inicialmente houve necessidade de estudar a linguagem visando ambientar-se com sua estrutura e sintaxe básica. Esse estudo foi exploratório visando apenas obter familiaridade com o editor e a linguagem. f) Elaboração de exemplos – Nessa etapa foi estudado como os elementos fundamentais de uma linguagem são tratados pela Python. Foi verificado como a linguagem trata cada um dos elementos levantados na etapa c. Exemplos de algoritmos foram gerados visando verificar como a linguagem trata esses elementos e identificar as particularidades em relação ao conceito básico dos elementos fundamentais da linguagem.

52 4 LINGUAGEM PYTHON Este capítulo apresenta a linguagem Python na versão 2.6. Inicialmente são apresentados aspectos teóricos da mesma, como conceitos, características e o processo de execução do código fonte. Em seguida é apresentado como são tratados, por meio de exemplos, os itens fundamentais de uma linguagem de programação pela linguagem Python. O apresentado neste capítulo tem como base as referências: Hetland (2005), Oliphant (2006), Lutz (2008), Silva (2008) e Brueck e Tanner (2001). Essas referências são complementadas por informações obtidas na Internet em listas de discussão e em materiais sobre a linguagem.

4.1. Apresentação A linguagem de programação Python foi criada em 1991 por Guido Van Rossum, mestre pela Universidade de Amsterdã em 1982. O nome foi inspirado no programa Monty Python's Flying Circus, da televisão britânica. Python foi baseada na linguagem ABC, utilizada pelos laboratórios do Instituto Nacional de Pesquisa em Matemática e Ciência da Computação (Amsterdã). Python foi criada tendo como foco usuários leigos em programação como físicos, engenheiros e lingüistas. Atualmente ela é aplicada em diversas áreas, como web e computação gráfica. ABC era focada no ensino da programação para usuários que entendessem de computador, mas sem que precisassem necessariamente entender de programação. Python adotou essa mesma filosofia, e por isso ela é considerada simples e de fácil aprendizagem. Atualmente é desenvolvida comunitariamente sendo gerenciada pela organização sem fins lucrativos Python Software Foundation. Essa linguagem é distribuída sob a licença aprovada pelo OSI tornando seu uso livre, inclusive para produtos comerciais. Python executa em Linux/Unix, Windows, Mac OS (Mac Operational System) X, OS/2, Amiga, Palm Handhelds, e telefones móveis Nokia. Ela também pode ser portada para as máquinas virtuais de Java e .NET. Pode ser obtida no site www.python.org, embora a maioria das distribuições

53 GNU/Linux já venham com Python instalado. Informações diversas em português, como tutoriais e exemplos, podem ser encontradas no site http://www.pythonbrasil.com.br.

4.2 Características Algumas das principais características da linguagem Python são: • • Possui elementos que eram bem sucedidos em ABC; É interpretada. Por ser uma linguagem dinâmica, o interpretador de Python tem funções para compilar código fonte e gerar bytecodes que são executados pelo próprio interpretador em tempo de execução. Ressalta-se, porém, que códigos escritos em Python também podem ser compilados, gerando executáveis; • É interativa, ou seja, faz uso da linha de comando com execução de códigos em tempo real; • É orientada a objetos e inclui herança múltipla. Contudo, Python pode ser utilizada como uma linguagem procedural, funcional e modular; • Possui estruturas de dados inclusas: listas, dicionários, strings. Dicionários definem um tipo de dado que permite armazenar valores que tem relação com suas respectivas chaves. A localização de tais valores deve ser feita pelas chaves. Listas outras listas; • Utiliza módulos que são arquivos Python com funções e variáveis que podem ser reutilizados por outros códigos; • • • • • É dinamicamente tipada: não é preciso declarar o tipo da variável; A delimitação de blocos é feita somente por meio de identação; É multiplataforma, incluindo plataformas móveis; Possui código fonte aberto e livre; Suporta integração com outras linguagens e ferramentas, como C e Java. Pode ser implementado inclusive sobre outras máquinas virtuais como Java e NET. podem conter dados de vários tipos e até mesmo

54 4.3 O processo de interpretação e de compilação Python é uma linguagem interpretada, mas ela também pode compilar os seus programas. Utilizando o interpretador interativo não é necessário criar o arquivo de Python compilado, os comandos são executados interativamente à medida que o usuário interage com o programa. Se for utilizado o modo interpretado, ao ser chamado um programa ou um módulo, o interpretador realizará a análise léxica e sintática e irá executá-lo. Esta é a máquina virtual Python. O bytecode da linguagem também é de alto nível. Para fazer engenharia reversa de um código em linguagem binária é utilizado o módulo dis da biblioteca padrão da linguagem. Normalmente Python trabalha com dois grupos de arquivos: a) Os módulos do núcleo da linguagem, sua biblioteca padrão e os módulos independentes, criados pelo usuário. No núcleo do interpretador estão o analisador léxico e o analisador sintático que utilizam as estruturas de objetos definidas no código, o compilador que aloca memória e o avaliador de código que modifica o estado atual do programa, mostrando resultado para o usuário. Embora seja reconhecida como uma linguagem interpretada, Python emprega um estágio de compilação que traduz scripts Python em uma série de bytecodes, que são executados pela Máquina Virtual do Python. O código escrito na linguagem Python é compilado para um código intermediário, semelhante a bytecode da linguagem Java. É esse código intermediário que é interpretado, por isso esse código é multi-plataforma. b) O interpretador Python analisa o código fonte e compila para um bytecode, um formato binário de instruções para a máquina virtual do Python. O código que é executado é este bytecode. Ou seja, existe uma etapa de compilação de código fonte para bytecode, e o bytecode é que é executado. Isto é o que acontece na linguagem Java também. Em Java, arquivos .class são binários porém não são linguagem de máquina, eles precisam de um interpretador para executar e este interpretador é chamado de máquina virtual Java. Arquivos .jar são simplesmente arquivos.class compactados. A diferença é que a etapa de compilação é transparente para o programador Python. Quando um programa é executado da seguinte maneira:

55
$ python meu_programa.py

O bytecode é gerado e executado em memória e não é salvo no disco.

Contudo,

se o programa importar um módulo, a Python procura a versão compilada em bytecode deste módulo, com a extensão .pyc, e se encontrada e não estiver desatualizada em relação ao arquivo .py correspondente, o interpretador usa a versão já compilada. Caso contrário, o interpretador compila o módulo .py e salva o bytecode em um arquivo com a extensão .pyc no mesmo diretório onde está o .py, desde que tenha permissão para escrita. Na realidade, o sistema de runtime do Python é um interpretador de bytecode. É ele que executa o comando import, por exemplo, mas como Python é uma linguagem dinâmica, o interpretador tem funções para compilar código fonte e gerar bytecodes que são executados por ele mesmo em tempo de execução. Em resumo, o código fonte .py em Python é equivalente ao .java em Java e o código compilado .pyc em Python é equivalente ao .class em Java.

4.4 Edição e execução de um programa na linguagem Python

4.4.1 Editor

Para a criação de arquivos fonte .py não é preciso mais que um editor de texto com suporte a destaque de sintaxe e identação. O suporte a destaque de sintaxe serve principalmente para a melhor visualização e entendimento do código. O suporte a identação padroniza e mantém organizada a identação do código, uma vez que seja configurado para determinada quantidade de espaços. Em Python o padrão de identação adotado é de quatro espaços.

4.4.2 Execução em linha de comando

O interpretador interativo do Python facilita testar comandos sem ter que criar

56 arquivos separados e então executá-los. Para fazer uso do interpretador basta chamar o Python em um terminal de comandos digitando “python”. Quando o interpretador for carregado aparecerá algo como o texto seguinte na tela:
Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41) [GCC 4.3.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>>

O símbolo do prompt (>>>) indica que o interpretador está pronto para ser utilizado.

4.4.3 Execução em arquivo .py

Os arquivos fonte .py criados devem ser executados através do terminal com o comando:
python <caminho do arquivo.py><nome_do_arquivo.py>

Exemplo:
python /media/dados/projetos_python/arquivo.py

4.5 Elementos fundamentais da linguagem Python

Esta seção apresenta os elementos fundamentais da linguagem Python tendo como base o conteúdo apresentado na Seção 2.3. O objetivo desta seção é apresentar como os elementos fundamentais de uma linguagem de programação são tratados pela linguagem Python. Os elementos fundamentais de uma linguagem de programação procedural são, basicamente: varáveis, constantes, entrada e saída, estruturas de controle (sequência, decisão e repetição), estruturas de dados homogêneas e heterogêneas e funções.

57 4.5.1 Variáveis

Em Python não é preciso declarar o tipo da variável para que ela seja utilizada. Python trabalha com o conceito de alocação dinâmica. A principal diferença com algumas outras linguagens como Java, C, Delphi e Visual Basic é que as variáveis não são declaradas previamente e não precisam armazenar o mesmo tipo de valor durante todo o programa. Isso significa que se for necessário criar uma variável contendo valor inteiro, ela será do tipo inteiro, e se essa mesma variável tiver de armazenar um valor do tipo string, ela passará a ser do tipo string. Exemplos de criação de variáveis em Python definido por meio do interpretador e não em programa que geraria executável:
a = 3 #variável do tipo inteiro b = 3.2 #variável do tipo float c = a + b #variável do tipo float (resultado retorna float d = 'Ana' #variável do tipo string d = 3 #a variável que era do tipo string agora é do tipo inteiro nome = “Caliane” #variável do tipo string

4.5.2 Constantes

Não existem constantes em Python. A filosofia da linguagem é tentar impedir que o programador cometa erros bobos fazendo com que ele mesmo se eduque a tomar cuidado e respeitar quando uma variável não pode ter seu valor alterado.

4.5.3 Tipos de dados

Todos os exemplos de tipos de dados abaixo utilizam o prompt do interpretador Python:

58 a) Tipo numérico: Os tipos numéricos em Python são: • • • • integer (inteiros); long (inteiros longos); float (números reais, ou ponto flutuante); complex (números complexos).

Exemplo de inteiros:
>>> numero = 20 >>> print numero 20 >>> type(numero) <type 'int'>

Para números maiores que 2 bilhões utiliza-se o tipo long:
>>> numero = 10L >>> type(numero) <type 'long'>

O tipo real é representado utilizando o '.' onde começam as casas decimais do número.
>>> numero = 1.0 >>> type(numero) <type 'float'>

Os tipos complexos são os mesmos da Matemática. Portanto a linguagem fica responsável pelos atributos imagem e real do número.
>>> numero = 10 + 3j >>> type(numero) <type 'complex'> >>> numero.real 10.0 >>> numero.imag 3.0

b) Tipo Caracter: Para textos das mais variadas formas, só existe o tipo string. Não há diferença quanto a declarar um conjunto de caracteres com aspas simples ou duplas como neste

59 exemplo:
>>> variavel = 'Ola Mundo' 'Ola Mundo' >>> variavel = “Ola Mundo” 'Ola Mundo'

Pode parecer estranho, mas essa indiferença entre aspas simples e duplas é necessária e útil. Se uma variável com valor string for criada usando aspas simples e dentro desta string existe uma palavra que deve levar aspas simples, a linguagem Python não teria como determinar o final dessa string. Exemplo:
>>> 'Programando em 'Python''

Essa declaração possui aspas duplas no final, e isso gerará o seguinte erro:
File "<stdin>", line 1 'Programando em 'Python'' ^ SyntaxError: invalid syntax

Nestes casos é preciso especificar com clareza e fazer uso de aspas simples e duplas. Portanto, estas são as maneiras corretas:
>>>“Programando em 'Python'” “Programando em 'Python'” >>>'Programando em “Python”' 'Programando em “Python”'

Uma maneira de escrever strings com múltiplas linhas é fazer uso de aspas triplas, como nos exemplos:
>>> print “””Primeira linha. ...Segunda linha. ...Terceira linha. ...Linhas múltiplas”””

>>> print '''Primeira linha. ...Segunda linha. ...Terceira linha. ...Linhas múltiplas'''

Outra maneira é fazer uso de sequências de escape como o “\n”. Por exemplo:
>>> print “Primeira linha. \n Segunda linha.”

O “\t” é outra sequência de escape para um espaçamento de tabulação.
>>> print “Usando tab. \t Programando em Python”

Se ao fim da primeira linha de uma string existir apenas uma barra invertida, indica

60 que a string ainda não acabou, ou seja, que ela continua na próxima linha.
>>> “Primeira linha. \ ...Segunda linha” 'Primeira linha. Segunda linha.'

c) Tipo Vetor: Para realizar operações com vetores e matrizes é utilizado o pacote NumPy (Numerical Python) que contém vários módulos para estes fins. Os tipos de dados nativos do Python seriam ineficientes se tivessem de trabalhar com grandes quantidades de informação. O pacote NumPy não faz parte da distribuição oficial do Python, mas geralmente estão disponíveis nas distribuições GNU/Linux. Para fazer uso desse pacote é preciso importá-lo. A base do NumPy é o objeto array, um conjunto com determinada dimensão que armazena elementos de mesmo tipo. Os array podem se unidimensionais ou multidimensionais. Comandos do NumPy :
array():

cria um arranjo a partir de uma lista ou tupla (objetos iteráveis); um arranjo a partir de um intervalo passado por parâmetro.

arange(): cria

Para importar o pacote numpy no prompt do interpretador ou em arquivos com extensão .py deve-se digitar:
from numpy import *

Criar um arranjo simples unidimensional linha com elementos do tipo inteiro:
array([1, 2, 3]) #arranjo de 3 valores array([1, 2, 3])

Criar um arranjo simples unidimensionais coluna com elementos do tipo inteiro:
array( [ [1], [2], [3] ] ) array([[1], [2],[3]])

Criar um arranjo de 2 dimensões:
array([ [ 1, 2 ], [ 3, 4 ] ]) array([[ 1, 2], [ 3, 4]])

61 4.5.4 Padrão Unicode O Unicode é um padrão internacional para escrever textos com caracteres especiais como, por exemplo, os acentuados. Para conseguir fazer isso é necessário possuir um editor com suporte a Unicode. Em Python (no interpretador) é possível fazer uso de textos unicode colocando na frente da string a letra “u” ou “U”.
>>>print u”Este é um texto unicode.” 'Este é um texto unicode.'

Para textos unicode em arquivos de código Python (.py) é preciso definir a codificação que será utilizada, caso contrário o padrão será ASCII (American Standard Code for Information Interchange). Essa definição é feita com um simples comentário na primeira ou segunda linha do arquivo, como no exemplo:
# coding=utf-8 #Mostrar texto unicode na tela #Neste caso, como a codificacao já foi definida nao ha necessidade de colocar o “u” na frente do comando print 'Programação em Python!'

4.5.5 Operadores Aritméticos Exemplo dos operadores aritméticos em Python feitos no prompt do interpretador: a) Adição. Exemplo:
>>> print a + 3

b) Subtração. Exemplo:
>>> print a – 3

c) Multiplicação. Exemplo:
>>> print a * 3

d) Exponenciação. Exemplo:
>>> print a ** 2

e) Divisão inteira. Exemplo:
>>> print a / 5

f) Divisão real. Exemplo:
>>> print a / 5.0

g) Resto de uma divisão inteira. Exemplo:
>>> print a % 5

62 4.5.6 Operadores relacionais Exemplo dos operadores aritméticos em Python e seus resultados feitos no prompt do interpretador: a) Igual a. Exemplo:
>>> 1 == 1 True

b) Diferente. Exemplo:
>>> 1 <> 2 True >>> 1 != 2 True

c) Maior que. Exemplo:
>>> 5 > 4 True

d) Menor que. Exemplo:
>>> 5 < 6 True

e) Maior ou igual a. Exemplo:
>>> 5 >= 5 True

f) Menor ou igual a. Exemplo:
>>> 6 <= 6 True

Esses operadores também são válidos para listas, strings ou dicionários. Exemplo:
>>> [1,2,3] < [1,1,3] True >>> "nome" < "sobrenome" True

4.5.7 Operadores lógicos

Exemplo dos operadores lógicos em Python feitos no prompt do interpretador:
>>>nome = “Maria” >>>sobrenome = “da Silva”

63
>>>nome == “Maria” and sobrenome == “Oliveira” False

>>>nome == “Maria” and sobrenome == “da Silva” True

>>>not nome == “Maria” False

>>>not nome == “Ana” True

>>>nome == “Maria” or sobrenome == “da Silva” True

>>>not nome == “Maria” or not sobrenome == “da Silva” False

4.5.8 Estruturas de controle

A seguir algoritmos que exemplificam a forma de tratamento das estruturas de controle pela linguagem Python. Os exemplos a seguir foram todos salvos em arquivos extensão .py que devem ser executados no modo shell, ou seja, no terminal com o comando:
python <caminho do arquivo.py> <nome_do_arquivo.py>

a) Sequência
'''Programa para calcular a area de um circulo''' print '--- Calcular a area de um circulo ---' #Variavel raio recebe o valor digitado pelo usuario raio = int(raw_input("Informe o raio (somente numeros inteiros): ")) #Valor arredondado de pi pi = 3.14 #Calcular a area do circulo area = raio * (pi**2) #Mostrar na tela o resultado

64
print 'Area: ', area

b) Decisão if … else
print “--- Aprovacao de nota ---” #Variavel nota recebe valor informado pelo usuario: nota = int(raw_input("Nota: ")) #Condicao if nota >= 7: print "Aprovado"

se … então … senão
#Variavel nota recebe valor informado pelo usuario: nota = int(raw_input("Nota: ")) #Condicao if nota >= 7: print "Aprovado" else: print "Reprovado"

escolha … caso '''Programa NumeroExtenso. Equivalente ao switch case'''
#Variavel que recebe valor informado pelo usuario num = int(raw_input("Informe um numero: ")) if num == 0: print "Zero" elif num == 1: print "Um'' else: print "Outro"

Não existe switch case nativo em Python, mas existem alternativas com orientação a objetos, que fogem ao escopo do trabalho. São elas: Alternativa 1:
for value in [value]: if value == 'a': result = x * 5

65
break if value == 'b': result = x + 7 break if value == 'c': result = x - 2 break # default result = x break

Alternativa 2:
if value == 'a': result = x * 5 elif value == 'b': result = x + 7 elif value == 'c': result = x – 2

Alternativa 3:
var x = 10 ; var y = 20 ; var operator = "*" var result = { "+" : function(x, y) { return x + y } , "-" : function(x, y) { return x - y } , "*" : function(x, y) { return x * y } , "/" : function(x, y) { return x / y } }[operator](x, y) ;

c) Estruturas de Repetição enquanto … faça
'''Programa Tabuada''' #Variavel numero recebe o valor digitado pelo usuario numero = int(raw_input("Numero: ")) #Variavel contador contador = 1 #Laco de repeticao while contador <= 10: print numero, " * ", contador, " = ", numero*contador

contador += 1

66 para … até … faça
'''Programa Tabuada''' #Variavel recebe o valor inserido pelo usuario numero = int(raw_input("Numero: ")) #Laco de repeticao for contador in range (1,11): print numero, " * ", contador, " = ", numero*contador contador += 1

4.5.9 Funções

Em Python funções não são obrigadas a retornar um valor. Exemplo de função sem retorno:
'''Funcao Media''' def soma(numero1, numero2): resultado = (numero1 + numero2) / 2 print "Media:", resultado

soma(5,10) #Chamar a funcao passando dois valores por parametro

Exemplo de função com retorno:
'''Funcao Fatorial''' def if fatorial(numero): numero<= 1: return else: return (numero * fatorial(numero 1)) #retorno do calculo do fatorial do numero que sera passado por parametro print "Fatorial:", fatorial(5) #imprime o retorno do fatorial passado 1

por parametro (5)

Exemplo de função sem parâmetros e sem retorno:
'''Funcao sem parametros''' def sem_parametro(): print "Esta funcao nao possui parametros e nem retorno."

sem_parametro()

67 5 DISCUSSÕES

O trabalho começou com estudos sobre linguagens de programação, conceitos, classificação, elementos fundamentais, sintaxe e semântica. Nessa primeira etapa a maior dificuldade foi encontrar materiais na Internet sobre conceitos de linguagens de programação. Com esses estudos ficou clara a necessidade dos programadores e usuários que queiram ingressar nessa área, de conhecerem os conceitos de linguagens de programação ao invés de apenas conhecer a sintaxe da linguagem. A ideia é entender a teoria e então aplicá-la a qualquer tecnologia, fazendo existentes e outras características. O próximo passo foi estudar a linguagem Python. Todos os materiais utilizados nessa etapa foram retirados da Internet e, pelo fato de Python ser livre há uma grande quantidade e diversidade de documentação acessível, sem a necessidade de aquisição de materiais impressos e sem violar direitos autorais. Durante o percurso foram descobertas diferenças entre a versão utilizada no trabalho, 2.6, e as versões a partir da 3.0. O comando raw_input(), que recebe dados do teclado, foi renomeado para input() se tornando o padrão. O raw_input() recebe o dado do teclado e retorna por padrão uma string, a menos que seja especificado o tipo que deve retornar, como por exemplo: int(raw_input("Informe um numero inteiro: ")). O
input()

as comparações e tirando

conclusões da sua aplicabilidade, facilidade no processo de aprendizagem, dificuldades

analisa o dado do teclado e retorna o tipo “certo” que foi informado. Outra

alteração nas versões a partir de 3.0 é de que todo o texto é unicode, ou seja, não é mais preciso fazer as conversões que eram feitas nas versões anteriores.

5.1 Principais diferenças

As principais diferenças entre Python e algumas outras linguagens são: • Identação: o código não é delimitado por nenhum tipo de caracter, apenas por identação. A vantagem dessa característica é de que o programador é obrigado a manter o código organizado, elegante e consequentemente mais inteligível. • Tipagem dinâmica: o tipo ao qual a variável está associada pode variar

68 durante a execução do programa. As variáveis sempre possuem um tipo específico em um determinado momento, mas não estão presas a este tipo. • Falta de switch case: a ausência da estrutura switch case em Python pode ser um problema. Seu substituto mais simples é o if, porém essa não é a melhor solução quando as aplicações são maiores, pois as tornam mais lentas. • Biblioteca para trabalhar com vetores: a simplicidade da linguagem é quebrada quanto é preciso trabalhar com vetores, pois é preciso importar uma biblioteca.

5.2 Aplicabilidade prática e didática

“Eu precisava de uma linguagem que pudesse rodar nas máquinas em nosso laboratório Linux bem como nas plataformas Windows e Macintosh que a maioria dos alunos tinha em casa. Eu precisava que ela fosse gratuita e disponível eletronicamente, assim os alunos poderiam utilizála em casa independentemente de suas rendas. Eu queria uma linguagem que fosse utilizada por programadores profissionais, e que tivesse uma comunidade de desenvolvimento ativa em torno dela. Ela teria que suportar ambas, programação procedural e orientada a objetos. E, mais importante, deveria ser fácil de aprender e de ensinar. Quando considerei as alternativas tendo em mente aquelas metas, Python sobressaiu-se como a melhor candidata para a tarefa.” (DOWNEY, ELKNER, MEYERS, 2002, p. 8)

A citação acima mostra claramente os principais motivos pelos quais Python é uma opção de linguagem simples e eficaz para o ensino e aprendizagem de programação. O aprendizado com Python se torna mais prático porque não é preciso se preocupar em entender como funcionam os níveis mais baixos da programação. Quem está aprendendo precisa basicamente se acostumar com a ideia de comandos e conseguir escrever programas simples, apenas sendo introduzidos ao ambiente de programação. A identação do código em Python é a delimitação de bloco e torna os códigos mais elegantes e fáceis de serem lidos. Sendo interpretada, a linguagem facilita o processo de aprendizagem, pois é possível fazer testes sem que arquivos de código precisem ser

69 criados separadamente e depois testados. E o aprendiz ainda pode fazer seus testes em casa, ou em qualquer outro lugar, usando o sistema operacional que melhor lhe convier.

70 CONCLUSÃO

O mercado atual exige que mais e mais profissionais de Tecnologia da Informação, independente da área específica, “saiam do forno” mais rápido e o mais importante, com conhecimento. Pode-se considerar um desperdício de tempo ensinar a esses futuros profissionais pseudo linguagens, as quais serão estudadas e talvez nunca mais usadas e então esquecidas. Ainda segundo a visão de alguns professores citados no desenvolvimento deste trabalho, é muito mais vantajoso que o aluno aprenda uma linguagem concreta pela qual pode se interessar e continuar aprendendo e desenvolvendo. Ao mesmo tempo é muito mais simples aplicar uma linguagem sem precisar dar informações avançadas que ele pode não entender em um primeiro momento como, por exemplo, o motivo do uso de bibliotecas de algumas linguagens. Nesta realidade observa-se que Python está crescendo e conseguindo lugar nas mais variadas áreas e segmentos: desde a educação até mercado comercial. Ela é uma boa aposta por ser simples e ao mesmo tempo robusta. Além disso é livre, o que garante sua evolução e continuidade através das comunidades de desenvolvimento e todos os demais colaboradores e é multiplataforma, ou seja, qualquer pessoa em qualquer sistema operacional pode utilizá-la. Há também os motivos econômicos de Python que não discriminam as condições financeiras e escolha de sistemas operacionais utilizadas pelos alunos ou instituições. Também não é preciso gastar nada com programas específicos independente do sistema operacional onde Python será utilizada. Este estudo de Python como linguagem procedural alcançou os objetivos esperados. A linguagem se mostrou apropriada para o ensino/aprendizagem dos fundamentos da programação, uma vez que ela não exige conhecimentos avançados por parte do iniciante, e dá a oportunidade de testar comandos e obter os resultados em tempo de execução. Sua sintaxe simples permite que o foco do desenvolvimento esteja no problema e não em como escrever a solução e, por ser identada obriga que o código esteja sempre organizado.

71 REFERÊNCIAS

BORATTI, I. C., OLIVEIRA, A. B. de. Introdução à programação de algoritmos, 3ª. Florianópolis: Visual Books, 2007. BRUECK, D., TANNER, S., Python 2.1 Bible. Hungry Minds, 2001. CONVERSE, T., PARK, J. PHP 4 a bíblia, Rio de Janeiro: Campus, 2001. DEITEL, H.M.; DEITEL, P.J. JAVA: como programar, 6a ed. Porto Alegre: Bookman, 2005. FARRER, H. et al. Algoritmos estruturados. Rio de Janeiro: Guanabara, 1996. FORBELLONE, A. L. V. EBERSPÄCHERT. H. F Lógica de programação – a construção de algoritmos e estruturas de dados, São Paulo: MAKRON, 1993. GUIMARÃES, A. de M.; LAGES, Newton Alberto de Castilho. Algoritmos e estruturas de dados. Rio de Janeiro: LTC, 1994. HETLAND, M. L. Beginning Python from novice to professional, Apress, 2005. KINNERSLEY, B. The language list collected information on about 2500 computer languages, past and present. Disponível em <http://people.ku.edu/~nkinners/LangList/Extras/langlist.htm>, acesso em 12/03/2009. LUTZ, M. Learning Python, 3a ed., O’Reilly, 2008. MANZANO, J. A. N. G., OLIVEIRA, J. F. Algoritmos. Lógica para desenvolvimento de programação de computadores. São Paulo: Érica, 2000. MITCHELL J. C. Concepts in programming languages, disponível em

<http://www.google.com.br/books? id=CuNruImLiCcC&printsec=frontcover&dq=concept+programming+language#PPA12,M1 >, acesso em março de 2009. MIZRAHI, V. V. Treinamento em linguagem C: curso completo - módulo 1. São Paulo: McGraw-Hill, 2001.

72 OLIPHANT, T. E. Guide to NumPy, 2006. SEBESTA, R. W. Conceitos de linguagem de programação, 4a. ed., Porto alegre: Bookman, 2000. SILVA, J. L. Introdução à linguagem de programação Python. Com aplicações ao cálculo científico, 2008. WIRTH, N. Agortims + data structure = programs. Englewood Cliffs: Printece-Hall, 1976. DOWNEY, Allen; ELKNER, Jeffrey; MEYERS, Chris. How to Think Like a Computer Scientist - Learning with Python , 1a. ed., Massachusetts: Green Tea Press, 2002. POLLONI, Enrico G. F.; FEDELI, Ricardo Daniel; PERES, Fernando Eduardo. Introdução À Ciência da Computação, 1a. ed., 2003.

Páginas da Internet consultadas: <http://www.python.org> <http://www.python.org.br > <http://www.python.org.br/wiki/IntroPython> <http://pt.wikibooks.org/wiki/Categoria:Python> <http://pt.wikibooks.org/wiki/Python/Conceitos_b%C3%A1sicos/Compilador_de_Byte> <http://pt.wikibooks.org/wiki/Python/Conceitos_b%C3%A1sicos/Compilador_de_Byte> <http://www.async.com.br/projects/python/pnp/dynamictype.html> <http://www.profissionaisti.com.br/2009/01/10-motivos-para-voce-aprender-a-programarem-python> <http://pythonologia.org/2005/03/27/se-esse-python-fosse-meu> <http://ramgarlic.com/docs/aprendacompy>

You're Reading a Free Preview

Descarregar
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->