Embed Size (px)
DESCRIPTION
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.
Citation preview
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 BRANCO2009
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-PR2009
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 1 – Processo de compilação e interpretação da Python..........................15Figura 2 – Algoritmo para calcular a área de um círculo....................................32Figura 3 – Algoritmo para calcular a média de duas notas................................33Figura 4 - Fluxograma da estrutura de decisão se ... então...............................35Figura 5 – Algoritmo para verificar a média de um aluno..................................35Figura 6 - Fluxograma da estrutura de decisão se ... então ... senão................36Figura 7 - Algoritmo para indicar aprovação ou reprovação..............................37Figura 8 - Algoritmo para indicar aprovação ou reprovação..............................38Figura 9 – Modelo de identação de estruturas se ... então ... senão..................39Figura 10 - Fluxograma da estrutura de decisão escolha ... caso......................40Figura 11 - Algoritmo para escrever um número por extenso...........................41Figura 12 - Fluxograma da estrutura de repetição enquanto ... faça.................42Figura 13 - Algoritmo para imprimir a tabuada de um número.........................43Figura 14 - Fluxograma da estrutura de repetição faça ... enquanto.................44Figura 15 - Algoritmo para ler números negativos............................................45Figura 16 - Fluxograma da estrutura de repetição para ... até ... faça..............46Figura 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ÁRIO1 INTRODUÇÃO..................................................................................................11
1.1 Considerações iniciais..............................................................................111.2 Objetivos .................................................................................................111.3 Justificativa .............................................................................................111.4 Organização do texto ..............................................................................12
2 LINGUAGENS DE PROGRAMAÇÃO ..................................................................132.1 Conceito de linguagem de programação ................................................132.2 Classificação das linguagens de programação .......................................172.3 Elementos fundamentais de uma linguagem de programação ..............21
2.3.1 Sintaxe e semântica de uma linguagem ..........................................242.3.2 Variáveis e constantes .....................................................................24
2.3.2.1 Variáveis ....................................................................................252.3.2.2 Constantes ................................................................................26
2.3.3 Tipos de dados simples ....................................................................262.3.4 Tipos de dados compostos ...............................................................272.3.5 Operadores ......................................................................................28
2.3.5.1 Operadores Aritméticos .............................................................282.3.5.2 Operadores Relacionais .................................................................29
2.3.5.3 Operadores Lógicos ...................................................................302.3.6 Estruturas de controle ......................................................................32
2.3.6.1 Seqüência ..................................................................................332.3.6.2 Decisão ......................................................................................34
2.3.6.2.1 se ... então ..........................................................................352.3.6.1.2 se ... então ... senão ...........................................................362.3.6.1.3 Comandos condicionais encadeados ..................................38
2.3.6.1.4 escolha ... caso .......................................................................402.3.6.2 Repetição ..................................................................................42
2.3.6.2.1 enquanto ... faça .................................................................422.3.6.2.2 faça ... enquanto .................................................................442.3.6.2.3 para ... até ... faça ..............................................................46
2.3.7 Funções ............................................................................................483 Materiais e método ........................................................................................50
3.1 Materiais .................................................................................................503.2 Método ....................................................................................................50
4 LINGUAGEM PYTHON .....................................................................................524.1. Apresentação .........................................................................................524.2 Características ........................................................................................534.3 O processo de interpretação e de compilação ........................................544.4 Edição e execução de um programa na linguagem Python.....................55
4.4.1 Editor ...............................................................................................554.4.2 Execução em linha de comando ......................................................554.4.3 Execução em arquivo .py .................................................................56
4.5 Elementos fundamentais da linguagem Python .....................................564.5.1 Variáveis ...........................................................................................574.5.2 Constantes .......................................................................................574.5.3 Tipos de dados .................................................................................574.5.4 Padrão Unicode ................................................................................604.5.5 Operadores Aritméticos ...................................................................614.5.6 Operadores relacionais ....................................................................61
4.5.7 Operadores lógicos ..........................................................................624.5.8 Estruturas de controle ......................................................................634.5.9 Funções.............................................................................................66
5 DISCUSSÕES ..................................................................................................675.1 Principais diferenças ...............................................................................675.2 Aplicabilidade prática e didática .............................................................68
CONCLUSÃO .....................................................................................................70REFERÊ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. Atualmente, há várias
classificações para as linguagens de programação. Os critérios adotados para essas
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
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 SímboloAdição +Subtração -Multiplicação *Divisão / ou DIVExponenciação ^ ou **Radiciação √Resto da divisão % 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 SímboloIgual a =Diferente < > ou != ou #Maior que >Menor que <Maior ou igual a >=Menor ou igual a <=
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 ResultadoA = B FalsoA <> B VerdadeiroA > B VerdadeiroA < B FalsoA >= B VerdadeiroA <= B 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 SignificadoE (AND)
Uma expressão E (AND) é verdadeira se todas as condições forem verdadeiras.
OU(OR)
Uma expressão OU (OR) é verdadeira se pelo menos uma condição for verdadeira
OU Exclusivo(XOR)
Uma expressão OU Exclusivo (XOR) é verdadeira quando apenas uma das condições for verdadeira.
NÃO(NOT)
Uma expressão NÃO (NOT) inverte o valor da expressão ou condição, se verdadeira inverte para falsa e vice-versa.
Exemplo:
Var1 ← 3
Condição1 Condição2 Condição1 E Condição2 Condição1 OU Condição2 NÃO-Condição1
Var1 > 2
V
Var1 > 1
V
V V F
Var1 > 2
V
Var1 = 2
F
F V F
Var1 > 5
F
Var1 > 2
V
F V V
Var1 > 5
F
Var1 < 2
F
F F 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 OU Var3 = 5F OU V
V
32
2º verificar o restante da expressão:
Var1 > 5 E (Var2 = 5 OU Var3 = 5)Var1 > 5 E V
F E VF
A mesma expressão sem parênteses:
Var1 > 5 E Var2 = 5 OU Var3 = 5
Verificar a expressão linearmente da esquerda para a direita:
Var1 > 5 E Var2 = 5 OU Var3 = 5F E F OU V
F OU VV
Por meio desse exemplo é possível verificar que o uso de parênteses pode definir
um resultado diferente para uma expressão lógica.
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 AreaFim
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 Em português estruturado
início
Ler Nota1Ler Nota2
Media <-- (Nota1 + Nota2)/2
Escrever Media
fim
Programa Média
Inicio Nota1: real Nota2: real Media: real Leia Nota1 Leia Nota2 Media = (Nota1 + Nota2)/2 Escreva MediaFim
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
condição
instruções
Sim
Não
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 seFim
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
condição
instruçõesinstruções
SimNão
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 seFim
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 seFim
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
instruções 1 instruções 2 instruções (default)
expressão
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 casoFim
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
instruções
Sim
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 enquantoFim
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
condição
instruções
Sim
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 é positivoFim
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
instruções
condição deexecução
inicialização da variável de controle
incremento da variávelde controle
sim
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 paraFim
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 podem conter dados de vários tipos e até mesmo
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.
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);
arange(): cria um arranjo a partir de um intervalo passado por parâmetro.
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 fatorial(numero):
if numero<= 1:
return 1
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
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 as comparações e tirando
conclusões da sua aplicabilidade, facilidade no processo de aprendizagem, dificuldades
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() 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-programar-
em-python>
<http://pythonologia.org/2005/03/27/se-esse-python-fosse-meu>
<http://ramgarlic.com/docs/aprendacompy>
