Você está na página 1de 200

1

2017 by Bruno Luvizotto Carli

Esta obra licenciada sob a Licena Creative Commons


AtribuioNo Comercial 2.5 Brasil. Voc pode
compartilhar e adaptar o contedo deste material desde
que os devidos crditos sejam dados ao autor do trabalho.
Para ver uma cpia desta licena, visite
http://creativecommons.org/licenses/by-ncsa/2.5/br/ ou
envie uma carta para Creative Commons, 171 Second
Street, Suite 300, San Francisco, California 94105, USA.

ndices para catlogo sistemtico:


1. Computadores: Programao;
2. Programao de computadores;
3. Algoritmos;
4. Linguagem de Programao;
1 Edio

CAPA: Bruno L. Carli.


Adaptado de: https://pixabay.com/pt/animal-a-fotografia-
animal-close-up-1853944/

Contato: brunolcarli@gmail.com

3
BRUNO LUVIZOTTO CARLI

Algoritmos e lgica de
programao com Python

1 Edio

Curitiba, PR
Edio do Autor
2017

4
5
Para meu pai, que me disse
que computao era besteira...

6
Sumrio
APRESENTAO.........................................................................................9
Capitulo 1..................................................................................................... 11
CONCEITO DE ALGORITMO............................................................. 11
ALGORITMOS PARA A LOGICA DE PROGRAMAAO.................14
TIPOS DE ALGORITMO ..................................................................... 15
PYTHON................................................................................................ 22
Capitulo 2..................................................................................................... 29
CONSTRUINDO ALGORITMOS COM PYTHON ............................29
VARIAVEIS E TIPOS DE DADOS....................................................... 33
VARIVEIS EM PYTHON................................................................... 39
CONSTANTES.......................................................................................51
EXPRESSES........................................................................................51
FUNES INTRINSECAS................................................................... 57
ENTRADA DE DADOS........................................................................ 60
EXERCICIOS ELABORADOS.............................................................62
Capitulo 3..................................................................................................... 70
COMENTRIOS................................................................................... 70
ESTRUTURA CONDICIONAL............................................................ 71
ESTRUTURA CONDICIONAL SIMPLES........................................... 72
ESTRUTURA CONDICIONAL COMPOSTA...................................... 75
ESTRUTURA CONDICIONAL ANINHADA...................................... 85
EXERCICIOS ELABORADOS.............................................................87
Capitulo 4..................................................................................................... 93
ESTRUTURAS DE REPETIO......................................................... 93
ESTRUTUTURA FOR ..........................................................................94
ESTRUTUTURA WHILE....................................................................100
ESTRUTUTURAS DE REPETIO ANINHADAS........................105
EXERCICIOS ELABORADOS...........................................................107
Capitulo 5................................................................................................... 116
ESTRUTURAS DE DADOS................................................................116
ESTRUTURAS DE DADOS UNIDIMENSIONAIS...........................117
ESTRUTURAS DE DADOS MULTIDIMENSIONAIS ....................129
TUPLAS............................................................................................... 138
DICIONRIOS.................................................................................... 140
EXERCICIOS ELABORADOS...........................................................150
Capitulo 6................................................................................................... 156
SUB-ROTINAS E PROGRAMAO COM ARQUIVOS.................156

7
SUB-ROTINAS....................................................................................156
PROCEDIMENTOS.............................................................................158
FUNES............................................................................................ 163
PARMETROS....................................................................................166
ESCOPO DAS VARIVEIS................................................................ 169
RECURSIVIDADE.............................................................................. 172
ARQUIVOS..........................................................................................173
BIBLIOTECAS E MDULOS............................................................ 191
REFERNCIAS ........................................................................................ 197
Apelo do Autor........................................................................................... 199

8
APRESENTAO

Ol amigo leitor, nesta obre pretendo elucidar conceitos


bsicos, porm fundamentais ao aprendizado da lgica de
programao e o entendimento acerca da elaborao de
algoritmos. Voc ser inicialmente apresentado alguns
exemplos de tipos de algoritmos e imerso na conceituao
implcita do que um algoritmo. Vamos ser apresentados
poderosa linguagem de programao Python, nossa principal
ferramenta para implementao de algoritmos no decorrer
deste livro.

Saliento desde j que esta obra no pretende ser mais


um livro para o ensino da linguagem de programao Python,
pretendo com este manuscrito apresentar os conceitos bsicos e
fundamentais dos algoritmos e lgica de programao como os
tipos de dados, caractersticas de um algoritmo, estruturas de
dados laos de repetio sub-rotinas e manipulao de arquivos
permanentes, ao mesmo tempo em que possa induzir voc
leitor a conhecer e utilizar o Python para implementao dos
nossos programas, e se voc caro leitor se identificar
positivamente com o Python, insisto que busque na farta

9
bibliografia literria disponvel abordando os mais diversos
conceitos tcnicos sobre Python.

Este livro objetiva orientar e colaborar no estudo dos


algoritmos e lgica de programao de iniciantes no estudo da
computao, hobbystas iniciantes e alunos de cursos tcnicos e
graduaes que estejam comeando nesta magnifica rea que
a programao de computadores. Ressalto que este no um
livro orientado ao ensino de Python e espera-se de voc leitor
que compreenda os fundamentos da lgica de programao
podendo facilmente adaptar os exemplos demonstrado nesta
obra em outras linguagens de programao sem muita
dificuldade.

- O autor.

10
Capitulo 1
...

CONCEITO DE ALGORITMO

Quando falamos em algoritmo comum pensar em algo


relacionado matemtica, o que de certa forma no est errado,
pois quando pequenos na escola primria ramos incitados a
resolver diversas contas utilizando algoritmos matemticos
necessrios resoluo dos exerccios. Puga e Rissetti (2010,
p. 9) comentam que A matemtica clssica , em grande parte
o estudo de determinados algoritmos, isso pode a uma
primeira vista assustar iniciantes no estudo da lgica de
programao, mas vale salientar que no necessariamente o
estudo de algoritmos envolve o estudo da matemtica.
Para Puga e Rissetti (Op cit.) um algoritmo nada mais
que uma sequncia lgica de instrues que devem ser
seguidas para a resoluo de um problema ou execuo de uma
tarefa. Ascencio e Campos (2010, p.2) vo ainda mais
profundamente na conceituao de algoritmos citando diversas
fontes definindo o que so algoritmos, dentre algumas pode-se
citar: sequncia de passos que visa atingir um objetivo bem

11
definido (FORBELLONE, 1999 apud ASCENCIO;
CAMPOS, 2010), sequncia finita de instrues ou operaes
cuja execuo, em tempo finito, resolve um problema
computacional, qualquer que seja sua instncia (SALVETTI,
1999 apud ASCENCIO & CAMPOS, 2010).
Etimologicamente, de acordo com Abbagnano (2007, p.
27), a palavra Algoritmo deriva do nome de Mohammed al-
Khuwarizmi que foi um astrlogo e matemtico rabe do
sculo IX, responsvel por introduzir o sistema de numerao
indiano no Ocidente, esta notao durante a Idade Mdia
tornou-se conhecida como algorsmos, sendo conhecida hoje
pelo sistema numrico decimal que utilizamos no nosso dia a
dia.
Para finalizar a conceituao de algoritmo de uma
forma, simples e entendvel, um algoritmo um passo a passo
ou ainda, uma sequncia de instrues para se chegar a um
determinado objetivo, simples assim. Para exemplificar vamos
demonstrar um algoritmo de uma tarefa corriqueira que todos
fazemos diariamente: Beber gua.

Passo a passo para beber gua:


1. Pegar um copo ou recipiente;

12
2. Coloc-lo sob a torneira ou filtro de gua;
3. Abrir a torneira/filtro;
4. Quando o copo estiver suficientemente cheio, fechar a
torneira/filtro;
5. Beber a gua do copo/recipiente;

Simples, no ? Pode-se perceber que no temos nada


de muito matemtico nisso, um simples passo a passo, ou
ainda, uma sequncia finita de instrues que so seguidas para
realizar uma tarefa (beber gua). Vale-se ressaltar que no
existe uma nica forma de beber gua, poderia-se beber gua
da fonte ou de um rio utilizando as mos ou outros
procedimentos, e isso vlido para todos os algoritmos, pois
podem haver diferentes formas de realizar uma mesma tarefa
desde que respeitem a lgica do processo, a exemplo disso
pode-se dizer que no seria coerente fechar a torneira para
depois colocar o copo abaixo da torneira para encher. Vamos
demonstrar um outro exemplo de algoritmo: Uma ligao
telefnica.

Passo a passo para realizar uma ligao:


1. Pegar o telefone;

13
2. Inserir o nmero para quem deseja-se telefonar;
3. Aguardar ser atendido;
4. Depois de realizar a conversao, colocar o telefone no
gancho (ou apertar o boto de desligar no caso de
alguns telefones);

ALGORITMOS PARA A LOGICA DE PROGRAMAAO

Certo, j sabemos o que so algoritmos e de onde essa


palavra surgiu. Mas e a relao entre os algoritmos e a
programao de computadores?
Os computadores no compreendem instrues
humanas como estas citadas anteriormente, os computadores s
conhecem um tipo de linguagem: binria (zeros e uns) ou como
define Tanenbaum (2010, p. 1) linguagem de mquina, mas se
acalme, no h necessidade de se tornar um expert em
linguagem binria para programar um computador, para isso
existem as linguagens de alto nvel ou linguagens de
programao, que de acordo com Pressman (2010, p. 677)
so veculos de comunicao entre os seres humanos e os
computadores, as quais permitem que o programador possa
elaborar um roteiro de instrues passo a passo (algoritmo)

14
para que o computador execute uma determinada tarefa, estas
linguagens de alto nvel ou popularmente conhecidas como
linguagens de programao, das quais pode-se citar o C, C++,
Java, Cobol, Fortran, Python, dentre muitas outras linguagens
existentes. Cada linguagem possui sua prpria estrutura
sinttica porm sua essncia reside na coerncia lgica em que
as instrues so fornecidas ao computador, sendo assim, o
algoritmo escrito em uma linguagem de programao recebe o
nome de programa (TANENBAUM, 2010).

TIPOS DE ALGORITMO

Os algoritmos podem ser descritos em diferentes


formas, Ascencio e Campos (2010, p.3-4) apresentam a
Descrio Narrativa, o Fluxograma e o Pseudocdigo. Cada um
desses ser analisado nesta seo:

Descrio Narrativa
A descrio narrativa j foi apresentada no incio deste
capitulo, nos exemplos de beber gua e no exemplo de realizar
uma ligao telefnica. Consiste em descrever em linguagem
natural a sequncia de eventos que se sucedero. Vamos

15
exemplificar com mais um algoritmo em descrio narrativa:
Somar dois nmeros:

1. Definir o primeiro nmero;


2. Definir o segundo nmero;
3. Realizar a operao de soma entre os dois nmeros;
4. Obter e demonstrar o resultado;

Esse tipo de algoritmo nos lembra muito de receitas de


bolo por exemplo, porm possui uma grande desvantagem, por
se tratar de uma linguagem natural, suas instrues podem ser
ambguas abrindo espao para diferentes interpretaes,
dificultando sua transcrio em programa(ASCENCIO;
CAMPOS, 2010), fazendo com que este modelo de algoritmo
no seja muito utilizado em programao.

Fluxograma
O fluxograma uma forma de representar a sequncia
de instrues atravs de figuras geomtricas, sendo elas:

Tabela 1 Smbolos utilizados no fluxograma e seus significados

16
Smbolo utilizado para indicar o incio e o
fim do algoritmo.

Permite indicar o sentido do fluxo de


dados. Serve exclusivamente para conectar
os smbolos ou blocos existentes.
Smbolo utilizado para realizar clculos e
atribuies de valores.
Smbolo utilizado para representar a
entrada de dados.

Smbolo utilizado para representar a sada


de dados.

Smbolo utilizado para indicar que deve ser


tomada uma deciso, apontando a
possibilidade de desvio.
Fonte: Ascencio & Campos (2010, p. 4)

Vamos exemplificar a utilizao do fluxograma em um


algoritmo cujo objetivo realizar a soma de dois nmeros, o
mesmo algoritmo apresentado anteriormente:

17
Figura 1. Fluxograma representando um algoritmo para soma de dois nmeros

Fonte: O autor

As desvantagens do fluxograma segundo Ascencio e


Campos(2010) so a necessidade de aprender os significados
dos smbolos do fluxograma, que muitas vezes podem diferir,
como por exemplo podemos ver na Figura 2 duas
representaes diferentes para o smbolo de sada de dados.
Outra desvantagem apresentada que o fluxograma no
apresenta muitos detalhes, o que tambm dificulta a
implementao deste algoritmo em um programa de
computador.

18
Figura 2: Representaes para a Sada de Dados

Fonte: Figura do lado esquerdo, Ascencio & Campos (2010). Figura do lado direito, Puga &
Rissetti (2010).

Pseudocdigo
O Pseudocdigo, tambm conhecido como Portugol
(ASCENCIO; CAMPOS, 2010) ou Portugus Estruturado
(PUGA; RISSETTI, 2010) um modelo de algoritmo muito
semelhante a um cdigo escrito em linguagem de programao
de alto nvel, tornando sua implementao em um programa
uma tarefa muito simples para o programador. Para Puga e
Rissetti (2010, p. 11) este uma representao de algoritmo em
uma linguagem intermediria entre linguagem de programao
e a linguagem natural humana, mais especificamente, o nosso
Portugus. De acordo com Puga & Rissetti (Op. Cit.) o nome
Pseudocdigo significa falso cdigo, justamente por ser
extremamente parecido com um algoritmo implementado em
linguagem de alto nvel. Vamos ver o mesmo exemplo anterior
(soma de dois nmeros) representado em Pseudocdigo:

19
ALGORITMO: soma
VAR
num1, num2, soma : Inteiro
INICIO
LEIA(num1)
LEIA(num2)
soma num1 + num2
ESCREVA(soma)
FIM.
Este exemplo pode ser facilmente transcrito em
qualquer linguagem de programao e executado por um
computador. Vamos analisar a estrutura do pseudocdigo:
Tabela 2 Estrutura do pseudocdigo

ALGORITMO: soma Esta primeira seo declara o nome do


algoritmo

VAR Esta seo chamada de declarao de


variveis, onde todas as variveis que sero
num1, num2, soma : inteiro
utilizadas no algoritmo devem ser fornecidas,
neste caso precisamos de trs delas, o
primeiro nmero, o segundo nmero e o
resultado da soma. Todas elas so do tipo
inteiro ento declaramos uma aps a outra,
separando-as por vrgulas. Veremos mais
sobre variveis mais adiante.

INICIO Esta seo o corpo principal do algoritmo,


onde todas as instrues sero declaradas.
LEIA(num1) Neste caso temos duas instrues, LEIA( ) e
ESCREVA( ).
LEIA(num2) A instruo LEIA( ) um comando de

20
soma num1 + num2 entrada de dados, o que significa que um
valor ser fornecido para a varivel num1 e
ESCREVA(soma) num2.
Ento temos a atribuio do resultado para a
FIM. varivel soma, esta atribuio representada
pelo simbolo .
O comando ESCREVA( ) representa uma
sada de dados, que neste caso demonstra a
exibio do valor guardado na varivel
soma.
FIM. Indica que chegamos ao fim do
algoritmo.
Fonte: O autor.

Algumas desvantagens do pseudocdigo apresentadas


por Ascencio e Campos (2010) que deve-se aprender as
regras do pseudocdigo, da mesma forma que se aprenderia os
significados dos smbolos do fluxograma ou as regras sintticas
de uma linguagem de programao, alm do mais no
possvel implementar programas reais em pseudocdigo, por
estes motivo vamos conceber a linguagem de programao
Python como forma de implementao e aprendizado dos
nossos algoritmos por sua facilidade de compreenso, ao final
deste livro voc no somente saber os princpios bsicos da
construo e interpretao de algoritmos assim como ter os
conhecimentos bsicos de uma poderosa linguagem de
programao e estar escrevendo seus prprios programas de
computador.

21
PYTHON
Python uma linguagem extremamente eficiente: seus
programas faro mais com menos linhas de cdigo, se
comparado ao que muitas outras linguagens exigiriam. A
sintaxe de Python tambm ajudar voc a escrever um cdigo
limpo. Seu cdigo ser fcil de ler, fcil de depurar, fcil de
estender e de expandir, quando comparados com outras
linguagens. (MATTHES, 2016. p. 28)

Para a metodologia deste livro, pretende-se utilizar a


Linguagem Python como forma de aprendizado de algoritmos,
visto que as formas mais populares de algoritmos apresentam
desvantagens relacionadas ao aprendizado das regras prprias
de cada modelo, utilizaremos a Linguagem de Programao
Python por sua alta legibilidade, o que quer dizer que um
programa escrito nesta linguagem facilmente compreendido,
sem haver muito esforo da parte do programador em entender
seus comandos, alm do mais, um algoritmo implementado em
Python facilmente executado em qualquer sistema
operacional com um interpretador Python instalado. Isto
possibilitar aos iniciantes na lgica de programao no
somente a compreender a implementao dos algoritmos mas
tambm a familiarizar-se com as regras de uma simples, porm
extremamente poderosa linguagem de programao de
propsito geral, permitindo que escreva programas eficientes
com poucas linhas de comando em qualquer ambiente

22
operacional. Finalizando esta justificativa, fundamental no
aprendizado de algoritmos que se pratique muito, e nada
melhor do que ver resultados instantneos atravs de atividades
prticas, logo o Python se demonstrar uma excelente
ferramenta para se iniciar no mundo da programao, ento
vamos colocar a mo na massa.
Primeiramente ser necessrio a instalao de um
Interpretador Python no seu computador, o download pode ser
feito pelo website oficial do Python:
<https://www.python.org/downloads/>.
O Python disponibilizado em duas verses, Python 2.x
e Python 3.x, no tendo grandes diferenas entre si, porm para
fins de praticidade recomenda-se que o leitor utilize a mesma
verso apresentada no livro, neste caso utilizaremos a verso
Python 3.x, mais especificamente 3.5.2. Qualquer verso do
Python 3.x poder ser utilizada para executar os algoritmos
deste livro.
Aps fazer o download e instalao do Python 3 para o
seu Sistema Operacional voc notar que um editor chamado
IDLE foi instalado juntamente com sua verso do Python.
Quando voc instala o Python 3, tambm ter o
IDLE, o ambiente simples mas surpreendentemente til de
desenvolvimento integrado do Python. O IDLE inclui um editor
de destaque da sintaxe, um depurador, o Python Shell e uma

23
cpia completa do conjunto de documentao online do Python
3. (BARRY, 2015)

Este um editor padro do Python porm voc tambm


poder escrever os programas em um editor de sua preferncia,
para este livro, por motivos didticos ser utilizado o prprio
IDLE.

Figura 3 Aparncia do IDLE no Mac Os.

Fonte: O autor.

24
Figura 4 Aparncia do IDLE no Windows.

Fonte: O autor.

As Figuras 3 e 4 apresentam a aparncia do IDLE no


Sistema Operacional Mac Os e Windows. Quando voc iniciar
o IDLE pela primeira vez, ser apresentado ao prompt com 'trs
divisas' (>>>) no qual voc insere o cdigo e imediatamente a
executa para voc, exibindo qualquer resultado produzido na

25
tela (BARRY, 2015. p. 4). Outro modo de chamar o Python
abrir seu Terminal (no Windows muito conhecido como
prompt ou cmd) e escrever o comando python e se as trs
divisas aparecerem significa que o Python est corretamente
instalado no seu computador e voc est pronto para escrever
programas de verdade.
Figura 5 Chamar o Python pelo terminal no Mac Os

Fonte: O autor

26
Figura 6 Chamando Python no terminal Windows

Fonte: O autor.

Uma observao importante que, caso sua mquina j


possua outras verses do Python instalada (como no MacOs e
Linux onde o Python 2 j vem instalado por padro) o
comando necessrio para chamar o Python pelo Terminal pode
vir a ser diferente, dentre alguns exemplos esto python,
python3, py, python3.3, python3.5 (ou a verso especfica
que voc instalou). Agora que voc j sabe o que so
algoritmos e j tem o Python 3 instalado no seu computador
podemos dar continuidade ao nosso estudo da Lgica de
Programao.

27
Os algoritmos em Python apresentados nesta obra
podero ser encontrados atravs deste link:
<https://github.com/brunolcarli/AlgoritmosELogicaDeProgram
acaoComPython>

28
Capitulo 2
...

CONSTRUINDO ALGORITMOS COM PYTHON

Antes de efetivamente construir nossos algoritmos


importante sabermos como elaborar um algoritmo. Ascencio e
Campos (2010, p. 3) definem um mtodo para construo de
algoritmos, sendo estruturado a partir de alguns elementos
bsicos, dentre eles:

a) Compreender o problema a ser resolvido;


b) Definir os dados de entrada que devero ser
fornecidos;
c) Definir o processamento, quais operaes devero ser
executadas sobre os dados;
d) Definir a sada final, exibindo o resultado obtido
atravs do processamento dos dados;
e) Construir o algoritmo;
f) Testar o algoritmo atravs de simulaes;

Vamos realizar cada uma destas etapas e comparar o

29
ltimo exemplo de algoritmo fornecido (soma de dois
nmeros) em Pseudocdigo e Python para ter uma boa viso de
como seria um algoritmo implementado em Python 3:
a) Problema a ser resolvido: Somar dois nmeros;
b) Dados de entrada: numero1 e numero2;
c) Processamento: Somar o numero1 com o numero2;
d) Sada: Exibir o resultado da soma;
e) Construo do algoritmo:
Pseudocdigo Python 3
ALGORITMO: soma num1 = input(Insira o primeiro numero )
num2 = input(Insira o segundo numero )
VAR soma = int(num1) + int(num2)
print(O resultado da soma e , soma)
num1, num2, soma :
inteiro
INICIO
LEIA(num1)
LEIA(num2)
soma num1 + num2
ESCREVA(soma)
FIM.
Para testar o algoritmo abra seu IDLE e selecione na
parte superior a opo File ento New File, uma nova janela se
abrir para que voc possa escrever o algoritmo, escreva o
algoritmo Python apresentado (recomenda-se fortemente que

30
voc escreva os comandos ao invs de copiar e colar) ento
selecione a opo Run e ento Run Module na caixa de
ferramentas na parte superior da tela, ao executar o algoritmo
no IDLE ser solicitado que voc salve seu programa, ento
selecione um diretrio de sua preferncia e salve o arquivo com
a extenso .py (uma sugesto que salve este primeiro
algoritmo como soma.py). Aps salvar o arquivo, o Python ir
executar seu algoritmo e se tudo ocorrer bem sua sada deve ser
parecida com a da Figura 5:

Figura 7 Sada do algoritmo soma.py

Fonte: O autor

Agora vamos entender os comandos utilizados nesse


algoritmo Python, primeiro criamos uma varivel num1 (vamos
ver mais sobre variveis adiante) e atribumos a ela o valor de
entrada recebido em input( ). O comando input( ) em Python 3
permite que o usurio entre com um valor que ser tratado

31
como string (veremos mais sobre tipos de dados adiante), este
comando tambm permite que um texto seja passado como
argumento e exibido na tela, neste caso passamos o texto
Insira o primeiro numero como argumento. Quando o
interpretador Python ler esta instruo ele vai primeiro exibir o
texto ao usurio e ficar aguardando uma entrada, logo que o
usurio do sistema fornecer um valor de entrada e confirmar, o
interpretador executar a prxima instruo do algoritmo, que
ser, neste caso, a atribuio de mais um valor de entrada para
a varivel num2, da mesma forma como fizemos na primeira
instruo.
A terceira instruo do algoritmo soma.py ir realizar a
operao de processamento que soma num1 e num2 e
armazena seu resultado em uma varivel chamada soma, para
isto utilizamos um mtodo chamado int( ) que ir dizer ao
interpretador Python que durante este processamento as
variveis num1 e num2 devem ser tratadas como nmeros
inteiros1.

1 Uma observao importante que, em Python 3 o comando input( ) vai receber sempre os
dados em formato de cadeia de caracteres (string), sendo tratada como um texto, por este
motivo a necessidade de converter para nmeros os valores isneridos atravs da instruco
int( ), em Python 2 o comando input( ) receberia apenas valores numricos e caso o
usurio entrasse com uma letra ou simbolo o Python retornaria um erro. Em python 2 h
um comando especfico para receber entradas de texto chamado raw_input( ). No se
preocupe com isso por enquanto, mais para frente quando voc estiver mais familiarizado
com os tipos de dados isto se tornar mais simples de compreender.

32
Por fim a instruo print( ) diz ao Python para escrever
na tela, este um comando de sada de dados, e exibir na tela
os argumentos que forem fornecido instruo print( ). Neste
caso fornecemos um argumento em forma de texto dizendo O
resultado da soma e e adicionamos uma vrgula (,) para
separar o prximo argumento que foi a varivel soma, desta
forma o comando de sada exibir o texto fornecido e o valor
guardado na varivel soma.

VARIAVEIS E TIPOS DE DADOS

Variveis em Algoritmos e Lgica de Programao so


valores que podem sofrer alteraes no decorrer do algoritmo.
Ascencio e Campos (2010, p. 7) afirma que Um algoritmo e,
posteriormente, um programa, recebem dados, que precisam
ser armazenados no computador para serem posteriormente
utilizados no processamento. Esse armazenamento feito na
memria, logo, sempre que declaramos uma varivel em
nosso algoritmo o computador ir separar um espao na
memria para que um dado possa ser armazenado ali. Segundo
Ascencio e Campos(Op. Cit) uma varivel possui nome e tipo,
e seu contedo pode variar ao longo do tempo, durante a

33
execuo de um programa. Embora uma varivel possa assumir
diferentes valores, ela s pode armazenar um valor a cada
instante.
Agora vamos fazer uma pequena abstrao, imagine um
garoto chamado Pedrinho. Pedrinho possui uma varivel
chamada idade que neste exato momento possui o valor 7,
representando que Pedrinho tem 7 anos. No seu prximo
aniversrio Pedrinho completar mais um ano de vida ento o
valor da sua varivel idade ser incrementado em um, passando
agora a representar o valor 8. Esta pequena analogia demonstra
a mutabilidade dos valores guardados em uma varivel, que
recebe este nome justamente por seus valores variarem ao
longo de um algoritmo.
As variveis sempre guardam valores de um respectivo
tipo de dado, que de acordo com Ascencio e Campos (2010, p.
8) os mais comuns so numricos, lgicos e literais.

Numricos
Os dados do tipo numrico so divididos em duas
categorias: Inteiros e Reais. Os nmeros inteiros podem ser
positivos ou negativos e no possuem parte
fracionria(ASCENCIO; CAMPOS, 2010), como exemplo de

34
nmeros inteiros temos:
12
-7
154
0
-98

Os nmeros Reais so aqueles que possuem uma parte


fracionria e podem ser positivos ou negativos, como por
exemplo:
3.14
2.9876
-1.98
0.765

Uma observao importante deixada por Ascencio e


Campos (2010) que os nmeros reais seguem a notao da
lngua inglesa, ou seja, a parte decimal separada da parte
inteira por um . (ponto) e no por uma , (vrgula) importante
compreender isso desde o incio pois poder evitar
complicaes futuras quando implementar seu algoritmo.

Lgicos

35
Os valores lgicos, tambm chamados de booleanos
(ASCENCIO; CAMPOS, 2010), somente podem assumir dois
valores: verdadeiro ou falso. Estes so utilizados muitas vezes
em comparaes lgicas e verificaes condicionais (veremos
mais sobre isto nos prximos captulos).

Literais
Os dados do tipo literal so formados por sequncias de
caracteres (letras maisculas, minsculas e smbolos) ou por
um nico caractere(ASCENCIO; CAMPOS, 2010). Este tipo
de dado popularmente chamado de string, sendo representado
pelo texto envolto por aspas, como no exemplo a seguir:
aluno
Carro
Minha casa azul
fulano@email.com
12 x 10 =
F$0c!3^y
Perceba que mesmo os numerais que estiverem entre
aspas sero identificados como dados literais, e Puga e Rissetti
(2010, p. 37) afirmam que Os nmeros armazenados em uma
varivel cujo tipo de dado literal no podero ser utilizadas
para clculo, somente sendo possvel realizar operaes

36
matemticas com as variveis do tipo numrico, desta forma
importante conhecer os tipos de dados que estamos
trabalhando.

Definir o tipo de dado mais adequado para ser armazenado em


uma varivel uma questo de grande importncia para garantir
a resoluo do problema. Ao desenvolver um algoritmo,
necessrio que se tenha conhecimento prvio do tipo de
informao (dado) que ser utilizado para resolver o problema
proposto. Da, escolhe-se o tipo adequado para a varivel que
representa esse valor. (PUGA; RISSETTI, 2010, p. 36)

As variveis tambm possuem identificadores, que nada


mais so do que o seu prprio nome. Sempre que definimos
uma varivel a declaramos com um nome, este nome chama-se
identificador, praticamente todos os comandos possuem
identificadores, o print( ) um identificador para uma rotina
de exibio de dados por exemplo.
importante saber que existem algumas regras para
formao dos identificadores, segundo Ascencio e
Campos(2010, p. 9), sendo elas:

Somente podem ser utilizadas letras maisculas,


minsculas, nmeros e o caracter sublinhado ( _ ) no
nome das variveis;
O caractere inicial deve obrigatoriamente ser uma letra

37
ou o caractere sublinhado, no se deve comear o nome
da varivel por nmeros;
No so permitidos espaos em branco nem caracteres
especiais (!@#$%^&*+-<>=...) com exceo do
sublinhado ( _ );
No podemos utilizar palavras reservadas, estas so
nomes iguais a outros identificadores como comandos
da linguagem de programao que voc estiver
utilizando, nomes de variveis j declaradas no escopo,
etc.

Tabela 3 Identificadores vlidos e invlidos

Forma Vlida Forma Invlida


Joao12 Ok 8C No pode comear com
nmeros
cpf Ok nome usuario No pode conter espaos em
branco
_nome Ok True No pode ser nome de
palavra reservada (True
uma palavra reservada do
python)
registro_usuario Ok id-paciente No pode conter caractere
especial
NOTA Ok bot@o No pode conter caractere
especial
x5 Ok print No pode ser igual a nomes
de outros identificadores.
Fonte: O autor.

38
VARIVEIS EM PYTHON

As variveis em Python so bem flexveis, se adaptando


ao tipo de dado e alocando espao dinamicamente na memria.
Para atribuir um valor uma varivel utilizamos o sinal de =
desta forma:

Diferentemente do pseudocdigo e de algumas


linguagens de programao no precisamos declarar o tipo de
varivel para que o Python a reconhea. Vamos a um exemplo,
abra seu IDLE e crie um novo arquivo (File ento New File),
insira o pequeno trecho a seguir:

Salve seu arquivo e execute, sua sada deve ser parecida


com esta:

39
Tome cuidado ao escrever o identificador da varivel,
pois o Python diferencia letras maisculas e minsculas, assim
a varivel Carro diferente de carro. Da mesma forma, caso o
identificador esteja escrito incorretamente, nosso interpretador
retornar um erro. Tente reescrever o programa anterior
omitindo uma letra da varivel mensagem na instruo print( ),
desta forma:

Perceba que criamos uma varivel chamada mensagem,


mas passamos para a instruo print( ) um identificador
chamado mesagem. O interpretador Python ir retornar um erro
parecido com este:

No se preocupe com os erros, eles iro aparecer muitas


vezes nas suas simulaes de algoritmo. O Python muito
eficiente ao informar para o programador onde est o erro e

40
que tipo de erro foi encontrado. Veja, na primeira linha temos
um Traceback, que segundo Matthes(2016, p. 52) um
traceback um registro do ponto em que o interpretador se
deparou com problemas quando tentou executar seu cdigo.
Na prxima linha, o interpretador indica qual foi o arquivo e a
linha do arquivo em que o programa parou. Neste caso vemos
que o arquivo exemplo1.py possui um erro na linha 2. A
terceira linha tenta nos mostrar aproximadamente a instruo
onde o Python encontrou o erro, que foi na instruo
print(mesage). Por fim, na quarta linha da mensagem de erro
temos o tipo de erro encontrado, que neste caso um
NameError que um erro comum gerado quando tentamos
operar um identificador no existente. Como no declaramos
nenhuma varivel chamada mesagem o interpretador retornou
um erro avisando (em trocadilhos) Olha Sr. Programador, o sr.
me pediu para escrever o contedo identificado por 'mesagem'
mas eu no encontrei nada na memria com esse identificador,
tem certeza que isso mesmo?. Se o Python pudesse falar ele
diria algo como isto, mas as informaes que ele mostra j so
suficientes pra nos informar onde foi que erramos 2.
Ao declarar uma varivel em Python, tambm devemos
2 No Python voc ver que os erros so chamados de exceptions, todos eles esto listados na
documentao oficial do Python: <https://docs.python.org/2/library/exceptions.html>

41
respeitar as palavras reservadas da linguagem, ou seja os
identificadores j existentes. Segundo a documentao do
Python temos dispostos alguns exemplos de palavras
reservadas (keywords):

Figura 8 Palavras reservadas em Python:

False class finally is return


None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else import pass
break except in raise

Fonte: <https://docs.python.org/3.5/reference/lexical_analysis.html#identifiers>

Vamos exercitar mais um pouco e criar uma varivel


para cada tipo de dado que acabamos de conhecer:

A sada seria:

42
Os dados do tipo literal em Python podem ser
declarados entre 'aspas simples' ou aspas duplas, desde que
se abra e feche as mesmas aspas, no sendo possvel abrir um
aspa simples e fechar com uma dupla ('exemplo) e nem ao
contrrio (exemplo'), mas pode-se abrir uma aspa simples
dentro de uma aspa dupla e vice-versa (Assim 'por exemplo'
ou 'Assim por exemplo '). Python chama qualquer nmero
com um ponto decimal de nmero de ponto flutuante (float).
Esse termo usado na maioria das linguagens de programao
e refere-se ao fato de um ponto decimal poder aparecer em
qualquer posio de um nmero (MATTHES, 2016, p. 63),
ressalta-se aqui a importncia de declarar os nmeros reais
(float) utilizando-se o ponto ( . ) para representar a parte
fracionria e no a virgula ( , ) do contrrio o Python ir
retornar um erro.
Os dados lgicos ou booleanos devem ser declarados
com a primeira letra maiscula (True ou False), se voc inserir
o valor true, ou inserir o valor false, o Python no ir

43
reconhecer e ir enviar um traceback indicando um
NameError como vimos anteriormente, sua desculpa que
nenhum identificador com o nome 'true' ou 'false' foi definido,
isto porque assim como muitas outras linguagens, o Python
Case Sensitive, o que significa que ele diferencia letras
maisculas e minsculas, logo, True e true so duas coisas
completamente distintas para nosso interpretador, sempre que
escrevermos um algoritmo devemos ser muito claros e
especficos.
Podemos passar as variveis separadas por vrgula para
a instruo print( ) como no exemplo anterior, ou podemos
fazer uma instruo para cada varivel:

E a sada seria:

H outras formas de imprimir na tela pulando linhas, e

44
formas mais eficientes de se trabalhar com os dados de forma
que o desempenho do algoritmo seja superior, porm em nvel
de aprendizado estas instrues demonstram muito bem o
comportamento do interpretador Python.
Vimos no inicio deste captulo que uma varivel
somente pode guardar um valor por vez, isso quer dizer que se
eu declarar uma varivel chamada surpresa e atribuir diferentes
valores para ela, cada vez que um novo valor for atribudo, o
anterior ser esquecido, veja:

Atribumos inicialmente o o valor inteiro 9 para a


varivel surpresa, ento logo em seguida atribumos o valor
real 16.78, ento a prxima instruo diz ao Python para
atribuir uma string mesma varivel, e em seguida pede para
atribuir outra string. No final dizemos ao Python para escrever
o valor da varivel surpresa.

45
O valor exibido na tela foi o ltimo valor a ser atribudo
varivel, todos os outros valores foram desconsiderados, isso
porque uma varivel somente pode guardar um valor de cada
vez. Esta sequncia de instrues tambm demonstra como o
Python consegue atribuir diferentes tipos de dados em uma
mesma varivel, o que no aconteceria em muitas outras
linguagens de programao.
Lembra-se do algoritmo soma.py que construmos no
incio do captulo? Neste algoritmo o a instruo input( ) ir
esperar o usurio entrar com um tipo de dado, porm
independente do tipo de dado fornecido, o Python ir
armazenar a entrada como uma string (dado do tipo literal),
ento para realizar a soma tivemos que fazer uma converso
utilizando uma instruo int( ). Quando passamos um tipo de
dado para a instruo int( ) o Python tentar realizar uma
converso do tipo de dado fornecido para um tipo inteiro.
Vamos ver um exemplo:

46
Primeiro declaramos uma varivel chamada numero e
pedimos para mostr-la na tela, ento realizamos a converso
para inteiro e pedimos para mostrar na tela. Na sada no
conseguimos identificar a diferena, observe o resultado:

Mas se tentarmos realizar uma operao matemtica,


como a soma, em variveis do tipo literal o que acontece um
evento chamado concatenao, e no a adio em si, veja o
exemplo:

47
Primeiro declaramos duas strings e tentamos exibir a
soma de ambas, depois convertemos as strings para inteiro e
exibimos a soma das variveis:

Observe os resultados, na primeira linha obtivemos o


resultado da concatenao, que nada mais do que juntar a
segunda string ao final da primeira, resultando no na soma,
mas na juno das duas variveis literais em um nico texto. Ja
no segundo resultado pudemos obter o resultado da operao
de adio, pois a instruo int( ) converteu os dados literais
para numricos e o Python compreendeu que deveria realizar
uma operao aritmtica com estes dados.
Mas o que aconteceria se voc tentasse converter uma
letra para nmero?

48
Ao criarmos uma varivel literal com caracteres no
numricos e forarmos uma converso, o Python logo retornar
um erro, pois no possvel converter letras para nmeros, o
mesmo aconteceria se tentssemos converter um dado do tipo
real ou lgico.

O erro retornado um ValueError, dizendo que


os valores expressados na tentativa de execuo no so
vlidos, por isto devemos tomar muito cuidado ao trabalhar
com os tipos de dados para no levantar erros inesperados.
Caso voc tenha dvida quanto ao tipo de dado que
voc est lidando, o Python tem a instruo type( ). Quando
voc passar uma varivel para a instruo type(variavel) ele ira

49
informar o tipo de dado dessa varivel, como no exemplo a
seguir:

Sada:

Vemos que que cada tipo de dado pertence a uma classe


que representa um tipo de dado especfico: Literal (str), Inteiro
(int), Lgico (bool) e Real (float).3

3 O Python tambm tem o tipos de dados complex, mas no ser abordado


nesta obra, voc pode conferir o modelo de dados do Python em
<https://docs.python.org/3/reference/datamodel.html#>.

50
CONSTANTES
Da mesma forma que possumos valores variveis,
tambm temos valores constantes, ou seja, que no se
modificam ao longo do seu algoritmo. No Python, por questes
de boas prticas, sempre definimos uma constante com todas
as letras do identificador em CAIXA ALTA, ou seja, letras
maisculas, dessa forma:

EXPRESSES

Quando estivermos elaborando nossos algoritmos,


muitas vezes teremos que utilizar expresses aritmticas para
processar os dados, as expresses so formadas por operadores
aritmticos e possuem, assim como na matemtica, uma
prioridade de execuo, denominada precedncia. Segue um
quadro com os operadores em Python:

Tabela 4 Operadores aritmticos mais comuns em Python e sua


precedncia

51
OPERADOR OPERAO PRECEDNCIA DESCRIO

+ Adio 0 Realiza a soma dos


operandos. Ex: a +
b
- Subtrao 0 Realiza a subtrao
dos operandos. Ex:
total desconto
/ Diviso 1 Realiza a diviso
do operando a
esquerda pelo
operando a direita.
Ex: 12 / 2
// Diviso inteira 1 Retorna a parte
inteira da diviso
Ex: 3 // 3 (resulta
em 1)
* Multiplicao 1 Multiplica os
operandos. Ex: 2 *
a
** Exponenciao 2 Eleva o operando a
esquerda potncia
do operando a
direita.
Ex: 5**2
% Mdulo 2 Obtm o resto da
diviso dos
operandos.
Ex: 7%2
Fonte: O autor.

As operaes com menor precedncia so executadas


por ltimo, neste caso ao observar a expresso 2 + 3 * 5, assim
como na matemtica, a primeira operao a ser realizada a
multiplicao (3 * 5), somente ento a adio ser realizada (2

52
+ 15). Estas precedncias podem ser alteradas fazendo uso do
parntese ( ), dando precedncia para a expresso que estiver
dentro do parntese, desta forma:

Sada:

Ns tambm temos os operadores relacionais, que


permitem realizar comparaes entre valores:
Tabela 5 Operadores relacionais em Python
OPERADOR COMPARAO DESCRIO
== Igualdade Dois sinais de = compara
se dois valores so
idnticos. Ex: a == b
!= Diferena Compara se dois valores
so diferentes. Ex: a != b
> Maior Compara se o primeiro
valor maior que
segundo. Ex: a > b

53
< Menor Compara se o primeiro
valor menor que o
segundo. Ex: a < b
>= Maior ou Igual Compara se o primeiro
valor maior ou igual ao
segundo valor. Ex: a >= b
<= Menor ou Igual Compara se o primeiro
valor menor ou igual ao
segundo. Ex: a <= b
Fonte: O autor.

As expresses relacionais sempre retornaro um valor


lgico (True ou False), veja no exemplo a seguir:

Sada:

54
Existem mais operadores que no cobriremos aqui, mas
voc pode conferir a lista completa na documentao do
Python4.
Uma aplicao interessante em Python a
multiplicao de strings, algo que no possvel em outras

linguagens, veja:
Sada:

Temos tambm os operadores lgicos que podem ser


utilizados juntamente com os relacionais fazendo comparaes,
a seguir os operadores lgicos:

Tabela 6 Operadores lgicos em Python


OPERADOR OPERAO PRIORIDADE DESCRIO
or Disjuno 1 A disjuno entre
duas operaes
resultara
verdadeiro se um
dos valores for
verdadeiro.

4 Disponvel em:
<https://docs.python.org/3.5/reference/lexical_analysis.html#operators>

55
and Conjuno 2 A conjuno
resultar em
verdadeiro se, e
somente se, todos
os valores
examinados forem
verdadeiros
not Negao 3 A negao inverte
o valor lgico da
varivel
examinada. Se o
valor for
verdadeiro ele se
tornar falso, e
vice-versa.
Fonte: O autor.

Vamos examinar estas operaes com o Python:

Sada:

Veja que definimos as variveis a = 2, b = 3 e c =4.

56
Ento fizemos um pergunta ao Python como que Python, a
maior que b OU a maior que c? ento na primeira linha da
sada temos a resposta False, pois a no nem maior que b e
nem maior que c, a na disjuno somente obtemos uma sada
verdadeira se pelo menos uma expresso resultar em
verdadeiro, como nossas duas expresses resultaram falso, a
disjuno resultou falso.
Ento perguntamos ao Python: a menor que b E a
menor que c?, o Python responde: True, pois na conjuno
obtemos resultado verdadeiro se todas as expresses resultarem
verdadeiro, como 2 menor que 3 e tambm menor que 4,
nossa avaliao lgica retornou verdadeiro.
Por fim perguntamos ao Python se a e b so idnticos e
informar o valor lgico inverso (como assim? voc pergunta),
temos que 2 no igual a 5, ento o resultado da avaliao
seria Falso, mas como dissemos ao Python para nos informar o
inverso ele respondeu Verdadeiro (True). Um detalhe
interessante que sempre que uma varivel estiver inicializada
com o valor 0 ela retornar Falso.

FUNES INTRINSECAS

57
Funes intrnsecas so funes (instrues) pr-
definidas em uma linguagem de programao. Estas funes
auxiliam o programador para no ter que reinventar a roda em
seus algoritmos. Por exemplo, a instruo print( ) uma
funo pr-definida (built-in function de acordo com BARRY,
2015) da linguagem que permite exibir uma mensagem na tela.
No site oficial do Python encontramos uma tabela com as
funes intrnsecas existentes no Python 3:

Tabela 7 Funes intrnsecas no Python 3

Built-in Functions
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate( input( oct() staticmeth
) ) od()
bin() eval() int() open() str()
bool() exec() isinst ord() sum()
ance()
bytearray() filter() issubc pow() super()
lass()
bytes() float() iter() print() tuple()
callable() format() len() property() type()

58
Built-in Functions
chr() frozenset( list() range() vars()
)
classmethod() getattr() locals repr() zip()
()
compile() globals() map() reversed() __import__
()
complex() hasattr() max() round()

delattr() hash() memory set()


view()

Fonte: <https://docs.python.org/3/library/functions.html>

Voc no precisa decorar todas estas funes, mas a


medida que for construindo seus algoritmos vai utilizar
algumas delas, existem outras funes que no esto presentes
nesta lista mas voc poder conhece-las na documentao do
Python, outras apresentaremos no decorrer deste livro. A
descrio destas pode ser encontrada na documentao do
Python. Algumas destas voc j utilizou aqui em alguns
exemplos, como por exemplo print( ), int( ), input( ) e type( ).
Lembra-se do int( ) para converter nmeros em dados literais
para nmeros inteiros? Tambm temos as funes str( ) e
float( ) para converter dados em literais e nmeros reais
respectivamente.

59
Sada:

ENTRADA DE DADOS

Como vimos, o Python possui uma funo interna


chamada input( ) que recebe uma entrada do usurio. Nesta
instruo podemos fornecer uma string para ajudar o usurio a
saber que tipo de dado ele deve fornecer, como no exemplo a
seguir:

Sada:

60
Como vimos, a instruo input( ) recebe uma string por
padro, e caso precisemos que a entrada seja de outro tipo de
dado temos que fazer a converso com int( ) ou float( ), desta
forma:

Perceba que ao obter a idade, primeira declaramos a


varivel ento atribumos a ela a instruo int( ) pois ela deve
ser um nmero inteiro, e dentro da instruo int( ) inserimos o
input( ). Lembra quando dissemos que tudo que estiver dentro
do parntese acontece antes? exatamente isto, primeiro
ocorre a chamada da funo input( ) que ir fazer uma
solicitao de entrada ao usurio. Quando ele realizar esta
entrada o valor fornecido ser processado pela funo int( ),
convertendo o valor para um dado do tipo inteiro, que ento

61
ser armazenado na varivel idade. O mesmo acontece com a
altura, primeiro um valor solicitado, ento convertido para o
tipo de dados float e ento atribudo varivel altura. Quando
acessarmos estas variveis elas j estaro com o tipo de dado
que convertemos. A sada para o algoritmo acima seria parecida
com esta:

EXERCICIOS ELABORADOS

Primeiramente vamos mostrar alguns problemas e suas


solues em Python, vamos explicar a elaborao dos
exerccios e alguns exerccios para que voc leitor resolva
sozinho utilizando os conhecimentos aprendidos at aqui.

1) Formular um algoritmo que leia e apresente os dados de


uma pessoa: nome, idade, endereo, telefone de contato
e mostre as informaes obtidas na tela.
Problema a ser resolvido: Obter informaes de uma
pessoa e exibir as informaes na tela;

62
Dados de entrada: nome, idade, endereco, telefone;
Processamento: No h processamento, apenas entrada
e sada de informaes;
Sada: Exibir os dados da pessoa;

Figura 9 Fluxograma Atividade 1

Fonte: O autor

Primeiramente declaramos a varivel nome e atribumos


a ela uma string informada pelo usurio, em seguida a varivel

63
idade ir receber um valor de entrada do usurio que ser
convertido em um inteiro. Ento atribumos um valor de
entrada para a varivel endereco e mais uma para a varivel
telefone. Como no temos processamento as prximas
instrues so comandos de sada, exibindo as informaes
obtidas correspondentes aos dados da pessoa.

Observaes: muito comum obtermos o valor de um


telefone como string, pois o usurio pode entrar com caracteres
especiais como parntese ( ) e o trao -. Tambm recomenda-se
que nas variveis que possuem acento ou cedilha este caractere
seja substitudo ou omitido como no caso de endereo
(declaramos como endereco). Salienta-se ainda o cuidado ao
declarar instrues dentro de instrues como no caso de
int(input( )) onde abrimos dois parnteses ento precisamos
fechar dois parnteses, do contrrio voc receber um erro.

64
2) Sua professora de matemtica pediu que voc
calculasse a rea e o permetro de um quadrado e lhe
passou as frmulas para o clculo da rea sendo A = L x
L (o tamanho do lado do quadrado vezes ele mesmo) e
o permetro deve ser obtido atravs da soma dos quatro
lados do quadrado. Vamos escrever um algoritmo que
faa seu dever de casa:
Problema a ser resolvido: Calcular a rea e o
permetro de um quadrado;
Dados de entrada: area, perimetro, lado
Processamento: calcular a rea (A = lado x lado ou
lado**2) e calcular o permetro (b x 4 ou b + b + b +
b);
Sada: Exibir o resultado do clculo;

65
Figura10 Fluxograma Atividade 2

Fonte: O autor.

Primeiro precisamos do valor correspondente ao


tamanho dos lados do quadrado ento declaramos a varivel
lado e atribumos a ela o valor que for inserido pelo usurio
convertido em um nmero real, em seguida fazemos o
processamento, multiplicando o lado por ele mesmo e
atribuindo o resultado varivel area, a varivel permetro
recebe o valor de lado multiplicado por 4. Em seguida temos as
sadas exibindo os resultados.

66
Observao: Como o valor de area deveria ser lado ao
quadrado poderia-se ter utilizado lado**2 que funcionaria da
mesma forma, o operador ** eleva o valor da esquerda
potncia do valor da direita, tente fazer isto no seu IDLE.

3) Sua professora gostou tanto do seu algoritmo


computacional que lhe pediu para elaborar outro
algoritmo, dessa vez um que realize o clculo da rea
de um tringulo, sabendo que a rea do tringulo igual
a base x altura, vamos elaborar este algoritmo:
2

Problema a ser resolvido: Calcular a rea de um


tringulo;
Dados de entrada: base, altura;
Processamento: calcular a rea A = (base x altura) / 2;
Sada: Exibir o resultado do clculo;

67
Figura 11 Fluxograma atividade 3

Fonte: O autor.

Primeiro vamos receber a entrada necessria.


Declaramos uma varivel base e atribumos a ela o valor
inserido pelo usurio convertido em nmero real, depois
fazemos o mesmo com a varivel altura. Desta vez inserimos o
processamento diretamente no comando de sada atravs de
uma expresso, assim economizamos uma varivel fazendo
com que o algoritmo tenha um melhor desempenho. Em um
pequeno programa como este pode no fazer nenhuma
diferena, mas a medida que for construindo algoritmos mais
complexos o nmero de linhas e comandos pode impactar no

68
desempenho do seu programa.

Observao: Se voc andou brincando com o Python pode j


ter percebido que em alguns clculos com nmeros reais o
Python pode retornar um valor com vrias casas decimais, isso
normal no se assuste, veremos como lidar com isso no
decorrer do livro. Caso voc ainda no tenha visto isso tente
calcular 2.90 x 1.43.

Exerccios propostos
1) Elabore um algoritmo em Python que leia, calcule e
escreva a mdia aritmtica entre quatro nmeros;
2) Elabore um algoritmo em Python que receba um
nmero inteiro e escreva na tela o nmero fornecido, o
antecessor desse nmero e o sucessor desse nmero;
3) Elabora um algoritmo em Python que:
a) Primeiro exiba uma mensagem de boas vindas;
b) Pergunte o nome do usurio;
c) Exiba uma mensagem dizendo uma mensagem de ol
seguida pelo nome do usurio seguida por outra
mensagem fazendo um elogio.
4) Elabore um algoritmo em Python que calcule a rea e o
permetro de um crculo, sabendo que A = r e P=2r.

69
Capitulo 3
...

COMENTRIOS

muito comum nas linguagens de programao a


utilizao de comentrios em certas partes do algoritmo. Estes
comentrios servem para documentar o cdigo e possibilitar o
entendimento de certas sesses do algoritmo por outros
programadores que venham a ler seu cdigo posteriormente.
Em Python declaramos um comentrio ao inserir o caractere #.
Quando o Python se deparar com um comentrio durante a
interpretao do cdigo, ele ignorar a linha comentada, ou
seja, o Python no liga para os seus comentrios.

Sada:

Perceba que tudo que estava depois do # no foi

70
executado, pois o Python identificou como um comentrio e
logo passou para a prxima instruo vlida. Este o
comentrio de uma linha, porm tambm possvel inserir
comentrios de vrias linhas desde que estejam entre aspas
triplas (''' comentrio ''' ou comentrio) como no
exemplo a seguir:

Vamos comentar nosso cdigo de agora em diante para facilitar


o entendimento do contexto.

ESTRUTURA CONDICIONAL

Grande parte das vezes em nossos algoritmos, teremos


que optar por executar uma tarefa ou outra, dependendo de
uma condio especfica. As estruturas condicionais, tambm
denominadas estruturas de seleo ou deciso (PUGA;

71
RISSETI, 2010 p.56) so dos tipos simples e composta
(ASCENCIO; CAMPOS, 2010; LEAL, 2016; PUGA;
RISSETTI, 2010). Vamos ver cada um deles.

ESTRUTURA CONDICIONAL SIMPLES

Vamos exemplificar com um algoritmo bem prtico dos


nossos dias, ascender a luz. Geralmente para ascender uma
lmpada em um cmodo na sua casa, bem comum que se
aperte um interruptor. Se a lmpada estiver desligada ela se
ligar. Vamos fazer um algoritmo Python bem simplificado
para demonstrar o funcionamento da estrutura condicional
simples.

Veja que a instruo if ir analisar a varivel


ascender_luz, e se o contedo armazenado nesta varivel for
igual a string s ele executar os comandos abaixo do if. Se o
contedo da varivel for diferente da comparao o Python ir

72
pular para a prxima instruo que no estiver dentro do if.

Como assim dentro do if?

Caso o cdigo pertencente ao if no esteja tabulado


direita o Python no ir compreender e ir lhe informar algo
como isto:

Figura 11 - Erro de indentao

Fonte: O autor.

Se voc indentou direitinho seu algoritmo suas sadas


podero se parecer com estas:

Veja que caso a entrada seja diferente do que esperado

73
o Python ir ignorar o comando luz=True, e a luz permanecer
apagada:

Vamos melhorar este algoritmo para nos dizer se a luz


est acesa ou apagada:

Sada:

Caso voc no queira ascender a luz, o programa ir


terminar em branco, pois no demos mais instrues ao
Python, e ele somente executaria as que fornecemos se as
expresses avaliadas na instruo if forem verdadeiras.

74
ESTRUTURA CONDICIONAL COMPOSTA

Na estrutura condicional composta ns temos mais de


uma opo de desvio para uma condio a ser analisada. Vamos
melhorar ainda mais o algoritmo da luz:

O else um segmento do if que diz ao Python, caso a


condio anterior for falsa, faa isto aqui ok?, como uma
alternativa que ser realizada em oposio a outra. Leal
(2016b, p. 65) afirma que a estrutura de deciso composta
melhor utilizada Quando uma condio implica a execuo de
um ou outro bloco. Em situaes que h duas condies
mutuamente exclusivas, ou seja, s pode acontecer uma das
escolhas, as outras sero ignoradas pelo interpretador.

75
Figura 12 Fluxograma para ascender a luz

Fonte: O autor.

Seguindo para mais um exemplo, vamos imaginar que


seu professor comentou na aula que para que voc seja
aprovado na disciplina voc precisa ter uma mdia igual ou
superior 7.0, para descobrir a mdia voc somaria as quatro
notas de cada bimestre e dividiria por quatro e Se a mdia for
igual ou superior a 7.0 voc aprovado, Seno, voc fica de

76
recuperao.

Figura 13 Fluxograma para media do aluno

Fonte: O autor.

Vamos implementar um algoritmo em Python para


calcular sua mdia, primeiro vamos receber o nome da
disciplina ento as quatro notas e o programa deve informar
sua mdia nesta disciplina.

77
As instrues if e else em Python analisam uma
condio, no caso de if(media < 7.0) ns passamos para o
Python uma expresso relacional (media < 7.0), o Python vai
analisar se a media menor que 7.0 e verificar se verdade ou
mentira, caso seja verdade ele executar o comando logo
abaixo do if, tabulado direita, e caso a expresso se revele
falsa ele ir ignorar e pular para os comandos abaixo do else.
As sadas:

78
Seu professor gostou do programa, mas agora ele disse
que esqueceu de lhe avisar que caso a nota esteja entre 6.0 e
6.9 o aluno ficar de recuperao;

Ento s colocarmos mais um if, certo?

Bem, na verdade o Python tem mais um comando de


deciso composta para no precisarmos ficar repetindo if's toda
hora. O comando elif pode ser utilizado depois do if e antes do
eles, desta forma:

79
Tivemos que fazer algumas mudanas no nosso
programa, primeiro trocamos o primeiro if que verificava se a
media era menor que 7.0, se a media fosse menor que 7.0 o
aluno seria reprovado, mas como temos alunos que ainda
podem ficar de recuperao vamos ver somente as medias que
esto acima ou igual a 7.0, do contrario se a mdia for entre 6.0
e 6.9 ser exibido uma mensagem dizendo que o aluno est em
recuperao, e se ele no for aprovado nem estiver de
recuperao, ento ele est reprovado.

80
Mas qual a diferena entre if e elif?

A diferena est no desempenho do algoritmo. Quando


temos varias instrues do tipo if (estrutura condicional
simples), o interpretador ir checar cada uma delas. Se
tivermos uma estrutura composta por if, elif e else o
interpretador ir checar o primeiro if e caso seja verdadeiro ele
ir ignorar o resto da composio, ou seja, se a primeira
verificao for verdadeira as seguintes sero descartadas,
lembrando que voc pode inserir quantos elif's quiser. Em um
algoritmo complexo, demasiadas verificaes de if podem
comprometer o desempenho do algoritmo, tornando sua
execuo mais lenta. Ento como saber qual tipo de instruo
utilizar? Simples, como dito anteriormente, se voc tiver
diferentes situaes onde somente uma poder ocorrer, deve-se
utilizar a estrutura de deciso composta, pois as alternativas so

81
mutuamente excludentes. Caso voc precise fazer uma nica
verificao utiliza-se a estrutura simples.

preciso ficar atento um aspecto muito importante


para o funcionamento do seu cdigo, a indentao. A
indentao o recuo direita da margem pelo texto, no caso do
Python a indentao OBRIGATRIA, pois o interpretador ir
considerar como pertencente instruo if tudo o que estiver
indentado, do contrrio o comando poder ser executado em
uma hora inoportuna do programa ou pior gerar um erro.

Figura 13 Indentao do cdigo

Fonte: O autor.

Veja na figura acima que o if cercado por um


retngulo azul que representa um bloco de comandos, os
comandos pertencentes a este bloco esto indentados quatro
espaos direita da margem (basta pressionar o boto tab uma
vez), cercados por um retngulo vermelho. Os comando que

82
estiverem dentro do vermelho somente sero executadas se as
verificaes feitas no azul forem verdadeiras do contrrio o
interpretador passar para o prximo bloco de comandos.

A estrutura condicional em Python nos permite uma


gama de verificaes, inclusive verificar se determinadas letras
ou palavras existem em uma string, veja:

Sada:

Perguntamos ao Python se uma determinada palavra ou


letra existe em uma string, ele ir analisar a string e se existir
ele ir retornar verdadeiro, noutro caso ele retorna falso.
Lembra-se da instruo type( )? Vamos fazer um algoritmo que
recebe uma varivel e verifica qual o tipo da varivel
escrevendo na tela:

83
Lembra que a instruo type( ) retorna um texto
esquisito dizendo algo tipo <class 'int'>? Ento, o que fizemos
foi adicionar um valor a uma varivel, depois nessa mesma
varivel adicionamos esta mensagem esquisita atravs da
instruo type( ) convertida para string atravs da instruo
str( ), voc tambm deve se recordar que as instrues que
esto nos parnteses mais internos acontecem primeiro, certo?
Depois verificamos se a varivel contm a abreviatura
correspondente ao seu tipo no nome e escrevemos uma
mensagem um pouco mais elegante do que <class 'int'> para
informar o tipo da varivel que estamos lidando.

84
Tente mudar o tipo de varivel para testar os outros
resultados. Pesquise sobre o tipo complex em Python e
implemente o algoritmo para reconhecer este tipo de dado.

ESTRUTURA CONDICIONAL ANINHADA


Na estrutura condicional aninhada, tambm conhecida
por encadeamento (PUGA; RISSETTI, 2010) so estruturas
condicionais dentro de outras estruturas condicionais. Desta
forma ao realizar uma verificao condicional que retorne
verdadeiro, o interpretador poder encontrar com outros testes
condicionais.

Como assim?

Vamos exemplificar melhor em um algoritmo que


verifica o maior dentre 3 nmeros escolhidos:

85
Neste exemplo primeiro recebemos trs entradas que
devem ser nmeros inteiros, ento verificamos se o num1
maior que o num2, caso isso seja verdade partimos para uma
outra verificao, que analisa se o num1 maior que o num3, e
se for verdade isso significa que o primeiro nmero foi o maior,
do contrrio o terceiro nmero o maior. Se a primeira
condio for falsa, partimos para outra verificao, que analisa
se o num2 maior que o num3.

86
Existem sim formas diferentes e at mais eficazes de se
implementar este algoritmo, porm para nvel de exemplo este
algoritmo capaz de demonstrar o funcionamento da estrutura
condicional aninhada. A grande diferena entre usar as
condies aninhadas, de acordo com Leal (2016a, p. 70) que
o uso destes encadeados melhora o desempenho do algoritmo,
isto , torna o algoritmo mais rpido por realizar menos testes e
comparaes. Ou ainda, executar um menor nmero de passos
para chegar soluo do problema.

EXERCICIOS ELABORADOS

4) Elabore um algoritmo que receba o nome e a idade


de uma pessoa e informe se menor de idade, maior de idade

87
ou idoso.

Objetivo: Informar se a pessoa menor de idade, maior


de idade ou idoso;
Entrada: nome e idade;
Processamento: Verificar se a idade menor que 18
(menor de idade), maior que 18 e menor que 65 (adulto) ou
maior que 65 (idoso);
Sada: escrever se a pessoa menor, maior ou idoso;

Figura 14 Fluxograma atividade 4

Fonte: O autor.

88
Sada:

5) Elabore um algoritmo que calcule o IMC (ndice de


Massa Corporal) de uma pessoa de acordo com seu peso e
altura. O programa deve informar se a pessoa est abaixo do
peso (IMC menor que 20), normal (IMC entre 20 e 25),
excesso de peso (entre 26 e 30), obesa (IMC entre 31 e 35) ou
com obesidade mrbida (acima de 35). O clculo do IMC

peso
dado por .
altura 2

89
Objetivo: Verificar o ndice de Massa Corporal de um
indivduo;
Entrada: Valores de peso e altura;
Processamento: Calcular o IMC, verificar em que faixa o IMC
se encontra;
Sada: Mostrar o IMC e a faixa em que a pessoa se encontra;

Figura 15 Fluxograma atividade 5

Fonte: O autor.

90
Sada:

Exerccios propostos
1) Elabore um algoritmo que leia o percurso em
quilmetros, o tipo de automovel e informe o
consumo estimado de combustvel, sabendo que
um automvel do tipo A faz 26 Km com um
litro de gasolina, um automvel do tipo B faz 20

91
Km e um automvel do tipo C faz 7 Km.
2) Formule um algoritmo que leia cinco nmeros e
conte quantos deles so negativos.
3) Escreva um algoritmo que recebe uma letra e
verifica se uma vogal ou uma consoante.
4) Formule um algoritmo que leia o cdigo do
produto e a quantidade desse produto que o
cliente est adquirindo, informe os produtos que
o cliente comprou, a quantidade e o total a
pagar:
Codigo Produto Valor
1 Refrigerante R$ 4.50
2 gua Mineral R$ 3.00
3 Feijo R$ 8.00
4 Arroz R$ 7.25

92
Capitulo 4
...

ESTRUTURAS DE REPETIO

As estruturas de repetio fornecem meios para que


possamos repetir determinada parte do algoritmo sem que
tenhamos que reescrever os comandos necessrios para isso. Ja
pensou em um algoritmo que recebe cem nmeros? Ou ento
mil nmeros? Como voc acha que faria isto? Com mil
comandos de input? Neste captulo vamos conhecer as
estruturas de de repetio, tambm denominadas como lao de
repetio ou loop. Para Ascencio e Campos (2010, p.93) uma
estrutura de repetio utilizada quando um trecho do
algoritmo ou at mesmo o algoritmo inteiro precisa ser
repetido e Leal (2016b, p.82) afirma que a vantagem da
estrutura de repetio que no precisamos reescrever trechos
de cdigo idnticos, reduzindo assim o tamanho do algoritmo,
a mesma autora ainda enfatiza que as estruturas de repetio
podem ser de dois tipos: Laos contados e laos condicionais,
vamos conhecer cada um deles.

93
ESTRUTUTURA FOR

A estrutura for em Python uma instruo do tipo lao


contado, que significa que vamos repetir um determinado
conjunto de instrues um determinado nmero de vezes j
preestabelecido.
De acordo com Leal (2016a, p. 90) os laos contados so
aqueles que utilizamos quando sabemos previamente quantas
vezes o trecho do cdigo precisa ser repetido. Por exemplo,
realizar a leitura de 100 nmeros, efetuar o somatrio dos

nmeros entre 500 e 700 e outros. Vamos ver como funciona o


lao for em Python construindo um algoritmo que escreva seu
nome dez vezes na tela:
Primeiro damos a instruo for que ir analisar uma
varivel chamada contagem em um alcance (range) de 10
nmeros. Como isso funciona? Bem, a varivel contagem
somente ser utilizada para fazer a contagem do lao, essa
contagem se dar aps o comando in que avaliar quantas

94
vezes o lao se repetir atravs do comando range() que recebe
um nmero inteiro. Veja que na instruo for tambm
necessrio que se faa a indentao do cdigo que deseja-se
repetir.

Veja que o lao repete a instruo print(nome) o


nmero de vezes que pedimos que fizesse. Vamos exemplificar
novamente pedindo ao Python que escreva na tela a tabuada do
2:

Aqui ao invs de nomear a varivel contadora com o


identificador de contador, demos o nome de i, muito comum
em linguagem de programao que as variveis dos laos de
repetio assumam um identificador como este, pois ela
somente ser utilizada para contar o lao, porm voc poder

95
inserir o identificador desejar. Nosso range( ) agora 11 pois o
Python comea a contar do zero, para que o ltimo nmero a
ser calculado seja o 10 precisamos fornecer um nmero acima
para o range( ), do contrrio ele iria mostrar a tabuada do zero
ao nove (tente fazer isso, repita esse algoritmo com range(10)).
Dentro de nosso print temos uma string que diz 2 x (repare
nos espaos em branco na string, sem eles a escrita na tela
deixaria os caracteres colados uns nos outros) ento passamos
aps a vrgula o valor de i. Cada vez que o lao for executar as
instrues em seu bloco de comandos, a varivel i ser
incrementada em 1, at que chegue a 11. Ento a cada
execuo a varivel i assumir o valor do nmero de vezes em
que o lao foi repetido. Ento fornecemos outra string = e
ento uma expresso que multiplica o valor de i por 2. Veja a
sada:

Observe como o valor de i se inicia em zero e a cada

96
vez que a instruo print executada ela incrementada,
depois do sinal de = temos a multiplicao de i por 2. Tente
mudar o nmero dentro da instruo range para ver como o
algoritmo se comporta. Dizemos que a instruo for uma
estrutura do tipo lao contado porque sabemos exatamente
quantas vezes devemos repetir os comandos, neste caso
apresentado o lao deve ser percorrido o nmero de vezes que
for passado para o comando range( ). Neste comando range( )
no precisamos passar um nmero diretamente, tambm
podemos passar um valor numrico guardado em uma
varivel5. Veja este prximo exemplo:

Primeiro recebemos uma mensagem do usurio atravs


do comando input( ), esta mensagem ficar guardada na
varivel mensagem, depois recebemos um valor numrico do
usurio que armazenado na varivel repeticoes. No lao for
repetimos a mensagem do usurio o nmero de vezes que ele
informou.

5 Na instruo range() tambm possvel passar o valor mnimo e um


mximo separados por virgula assim range(10,20). Desta forma o
contador iniciar em 10 e contar at 20.

97
Em Python, a instruo for tambm pode ser utilizada
para iterar pelos caracteres de uma string. Iterar pela string
quer dizer que o Python vai passar verificando caracter por
caracter da string que voc quer analisar, veja no exemplo a
seguir:

A cada repetio do lao for o Python vai escrever a


letra que ele identificou, uma de cada vez at chegar ao fim da
string, quando o Python identificar que j no h mais
caracteres para ele verificar o loop se encerra.

Lembra quando verificamos a existncia de um


determinado caractere em uma string com a instruo if?

98
Vamos fazer um algoritmo que leia um nmero de ponto
flutuante e caso este tenha sido inserido com vrgula (,) ao
invs de ponto (.) o Python substitua os caracteres para ns:

Neste exemplo recebemos uma entrada referente a


altura do usurio, muito comum que o usurio ao inserir um
nmero fracionrio digite uma vrgula ao invs de ponto, e se
isso ocorrer durante o processamento de um clculo, ou mesmo
durante a converso para float, o Python retornar um erro.
Com este algoritmo conseguimos contornar esta situao,
recebemos a entrada em forma de string, analisamos cada um
dos caracteres da string e se algum deles for uma vrgula,
substitumos a virgula por um ponto com a instruo
replace( ). A instruo replace( ) recebe dois parmetros, o
primeiro deles o caractere que queremos remover e o segundo
o caractere que vamos inserir no lugar, desta forma:

99
variavel.replace(caracter_a_substituir,
caracter_a_inserir)

Tambm fazemos a converso de string para float


atravs da instruo float() e atribumos o resultado da
converso para a entrada. Quando o loop encerrar escrevemos
na tela o novo valor da varivel entrada que est pronto para
ser utilizado em qualquer clculo de nmeros fracionrios:

ESTRUTUTURA WHILE

A instruo while uma estrutura de repetio do tipo


condicional, o que significa que os comandos inseridos no
bloco de instrues while se repetiro at que uma determinada
condio se satisfaa. Lembra da instruo if? Ela analisa uma
condio e caso seja verdadeira executa um bloco de
instrues. A instruo while funciona de maneira similar,
porm ela ficar executando os comandos enquanto a condio
for verdadeira. Acompanhe no exemplo:

100
Sada:

Na estrutura de repetio condicional muito


importante que a varivel analisada seja modificada dentro do
bloco while, nesse caso analisamos a varivel num, e dissemos
ao Python Repita essas instrues enquanto num for menor
que 5 ok?, e dentro do bloco while, aps a instruo print,
ns temos num += 1, que equivalente a num = num + 1. Sem
esse incremento o loop ficaria repetindo infinitamente a
mensagem, pois num seria sempre menor que 5.

Outro adendo importante a se ressaltar a respeito desta


estrutura a inicializao da varivel avaliada. A inicializao
de uma varivel quer dizer que antes de avaliarmos esta
varivel devemos atribuir um valor a ela. Diferentemente da

101
estrutura for onde declaramos uma varivel contadora no
prprio comando, a instruo while precisa que a varivel
possua um valor inicial atribudo antes de chegar no loop, ou
ento nosso interpretador Python ir retornar um erro:

Veja no exemplo acima que dissemos ao Python para


repetir o contedo da varivel nome enquanto o valor de num
for menor que 5. Mas a varivel num no foi declarada em
lugar algum, ento o Python no saber o que voc quer
analisar exatamente, devolvendo este erro:

Lembra-se do Traceback? Sim exatamente, a forma


que o Python tem de dizer que houve um erro no seu algoritmo,
nesse caso ele retornou um NameError, informando que o
identificador num no foi definido. Se voc se recordar, j
vimos este erro no capitulo 2, muito comum este tipo de erro

102
quando tentamos manipular uma varivel que no foi declarada
ou quando erramos o nome de um identificador.

A estrutura de repetio condicional caracterizada por


repetir uma determinada sequncia de comandos
indefinidamente (LEAL, 2016a p. 96) , ou seja, no sabemos
quantas vezes o loop deve se repetir. Para exemplificar vamos
supor que temos que escrever um algoritmo que receba vrios
nmeros do usurio, e continuar recebendo nmeros at que
seja digitado o valor zero (0). Neste algoritmo vamos contar
quantos nmeros foram inseridos pelo usurio e mostrar na tela
depois de sair do loop. Veja:

Perceba que nesse loop while no temos um incremento


para sair do loop, mas uma condio bem especfica que
tratada dentro do loop, nesse caso, a entrada do usurio. Toda
vez que o usurio inserir uma entrada diferente de zero

103
fazemos uma verificao if num != 0 (o sinal != significa
diferente), e se for diferente de zero incrementamos o contador.
Quando o usurio inserir 0 o loop while ir realizar novamente
a anlise, nesse ponto o Python ir detectar que num igual a
zero, ento ele no executar o while. Depois do loop, temos
outra instruo informando quantos nmeros o usurio inseriu,
esta instruo est fora do loop como podemos ver pela
indentao. A sada deve ser parecida com esta:

Podemos criar um lao while diretamente com


booleanos (True ou False) e para sarmos do loop basta utilizar
a instruo break:

104
Criamos a condio True no lao que continuar sempre
a executar, dentro do loop criamos uma condio de sada que
quando satisfeita freia o loop e parte para a prxima instruo
depois do lao, neste caso uma instruo print( ) informando
que o lao acabou, veja a sada:

ESTRUTUTURAS DE REPETIO ANINHADAS

Assim como nas estruturas condicionais, podemos


aninhar ou encadear as estruturas de repetio. De acordo com
Manzano e Oliveira (1997) apud Leal (2016a) No existem
regras para o encadeamento das estruturas de repetio. De
modo que voc precisa conhecer cada uma delas para saber
quando conveniente encade-las, quais devem ser utilizadas e
como, porm com o tempo e prtica voc saber exatamente
que tipo de instruo utilizar para elaborar seus algoritmos.

Pode-se encadear qualquer tipo de estrutura de

105
repetio dentro da outra. Pode-se inserir while dentro de
while, for dentro de for, while dentro de for, for dentro de
while, da forma como seu algoritmo exigir, mas importante
ressaltar que a indentao esteja correta para cada bloco de
repetio para que voc no se depare com execues
inesperadas do seu cdigo. Vamos a um exemplo:

Neste exemplo temos dois nveis de repetio, o mais


externo o loop while, ele ser o lao principal do programa e
continuar executando at que o usurio entre com o valor
correspondente para encerrar o lao. Dentro deste lao
principal ns temos um segundo lao interno que ir repetir de
acordo com o nmero de somas que o usurio deseja realizar.
Ao completar seus ciclos o lao interno se encerrar dando

106
continuidade ao programa, porm o programa continua dentro
do lao principal que continuar a se repetir at que o valor
necessrio para interromper sua execuo seja fornecido pelo
usurio.

Voc pode aninhar quantas estruturas de repetio


forem necessrias em seu algoritmo assim como as estruturas
condicionais, assim como pode inserir estruturas de repetio
em estruturas condicionais e vice-versa. Veja que no exemplo
anterior poderia-se ter utilizado o lao while ao invs do for e
o algoritmo comportaria-se da mesma forma, experimente
modificar o algoritmo anterior e utilizar o loop while
internamente no lugar do loop for.

EXERCICIOS ELABORADOS

6) Escreva um algoritmo que apresente todos os nmeros


divisveis por 5 que sejam menores que 200.

107
Problema a ser resolvido: Calcular todos os nmeros
divisveis por 5 que sejam menores ou igual a 200;
Dados de entrada: nenhum;
Processamento: calcular de 1 a 200 dividindo por 5, os
resultados iguais a 0 devem ser mostrados na tela;
Sada: Exibir os divisveis por 5;
Figura 16 Fluxograma atividade 6

Fonte: O autor.

Cdigo-fonte:

108
Sada:

Perceba que utilizamos 201 como alcance mximo para


nosso range( ), pois se passssemos 200 como parmetro o
Python ia contar do 0 ao 199 e no dividiramos o 200 tambm.
Tente fazer isso para ver a diferena.

Observe tambm que no fluxograma no temos


exatamente um smbolo para representar o lao de repetio, o
loop se baseia nas avaliaes condicionais, estas orientam o

109
fluxo de dados do algoritmo at que sejam satisfeitas.

7) Escreva um algoritmo que receba a idade e o


estado civil de vrias pessoas e imprima a
quantidade de pessoas casadas, solteiras,
separadas e vivas. O algoritmo finaliza quando
for informado o valor zero para idade.

Problema a ser resolvido: Verificar e contabilizar o


estado civil de vrias pessoas;
Dados de entrada: idade, estado civil;
Processamento: calcular o nmero de pessoas solteiras,
casadas, separadas e vivas;
Sada: Informar a quantidade de pessoas solteiras,
casadas, separadas e vivas;

110
Figura 17- Fluxograma atividade 7

Fonte: O autor.

111
Cdigo-fonte:

112
Sada:

Perceba que neste algoritmo utilizamos alguns macetes.


Primeiro perceba a utilizao dos caracteres \n dentro da string
no input( ). Estes caracteres servem para que o interpretador
pule uma linha, toda vez que o Python se deparar com \n
dentro de uma string ele ir fazer a quebra de uma linha. Outro
apetrecho interessante o mtodo upper( ). Ao trabalhar com

113
strings podemos chamar este mtodo adicionando .upper( ) ao
final da varivel contendo a string para que as letras fiquem
maisculas, desta forma podemos garantir que, se caso o
usurio insira um 's' minsculo ele seja logo convertido para
maisculo, pois como voc deve se lembrar o Python case
sensitive o que o faz diferenciar letras maisculas e minsculas.
O Python tambm conhece os mtodos .lower( ) para deixar as
letras minsculas e o mtodo .capitalize( ) para deixar somente
a primeira letra maiscula e as outras minsculas. Vamos
conhecer mais coisas legais sobre strings no decorrer do livro.

Exerccios propostos:
1) Construa um algoritmo que leia nmeros
inteiros at que seja inserido um nmero
negativo. Ao final, informe a mdia dos
nmeros, o maior e o menor valor inserido.
2) Elabore um algoritmo que imprima todas as
tabuadas do 1 ao 10.
3) Construa um algoritmo que receba o nome de
uma pessoa e sua idade, o algoritmo deve
escrever na tela o nome da pessoa em letras
maisculas o nmero de vezes equivalente sua

114
idade.
4) Escreva um algoritmo que simule um cardpio,
cada item do cardpio tem um cdigo que vai de
1 a 6. Mostre os produtos do cardpio na tela, o
cdigo do item e o valor, o usurio poder fazer
pedidos pelo cdigo do item at que seja
inserido o valor zero. No final escreva na tela os
itens que o usurio escolheu e o valor a pagar.

115
Capitulo 5
...

ESTRUTURAS DE DADOS
As estruturas de dados em lgica de programao so
responsveis por permitir que agrupemos diversos tipos de
dados em uma nica varivel, em outras linguagens comum
que estas estruturas sejam divididas em homogneas e
heterogneas, pois h estruturas especficas para agrupar um
nico tipo de dado (como uma lista enorme de nmeros
inteiros), porm no Python possvel misturar diferentes tipos
em uma nica lista, desta forma pode-se dizer que as estruturas
de dados em Python so praticamente todas heterogneas, mas
nada lhe impede de criar listas somente de inteiros ou somente
de literais.
At agora estvamos armazenando os valores em
variveis separadas, mas existem momentos em que
precisamos armazenar muitos dados, o que nos exigiria a
declarao de inmeras variveis. Suponha, por exemplo, o
caso de um treino de classificao de uma corrida de Frmula

116
1, em que necessrio verificar os tempos obtidos por todos os
pilotos para avaliar qual ser o primeiro no grid de largada.
Para fazer essa ordenao, necessrio armazenar o tempo de
todos os pilotos e, depois, realizar a ordenao desses
tempos.(PUGA; RISSETTI, 2010 p. 83), j pensou quantas
variveis precisaramos criar? Uma para cada piloto, mais uma
para cada tempo, isso exigiria muito consumo de memria do
computador, e seria desnecessrio j que possumos as
estruturas de dados para agrupar todos estes valores. Vamos
conhecer as estruturas de dados em Python.

ESTRUTURAS DE DADOS UNIDIMENSIONAIS


Em lgica de programao, as estruturas
unidimensionais so popularmente conhecidas como vetores,
vetor uma estrutura de dados unidimensional (ASCENCIO;
CAMPOS, 2010), unidimensional porque ela possui apenas
uma dimenso linear onde os dados sero listado um aps o
outro em sequncia.
Em Python estas estruturas so denominadas listas, e
assim como uma lista comum os itens sero includos e
identificados por um ndice que corresponde sua localizao

117
na lista.
Uma lista uma coleo de itens em uma
ordem em particular. Podemos criar uma
lista que inclua as letras do alfabeto, os
dgitos de 0 a 9 ou os nomes de todas as
pessoas de sua famlia. Voc pode colocar
qualquer informao que quiser em uma
lista, e os itens de sua lista no precisam
estar relacionados de nenhum modo em
particular. (MATTHES, 2016 p. 70)

Vamos exemplificar isto com uma situao bem


comum. Suponha que sua me pediu para que voc fosse ao
mercado e comprasse bananas, queijo, trigo e uma lata de
azeite. Logo voc pega um pedao de papel e anota:
1 Banana;
2 Queijo;
3 Trigo;
4 Azeite;
Vamos fazer a mesma coisa lista em Python agora:

Sada:

A sintaxe para criar uma lista em Python :

118
identificador = [contedo]
Em Python as listas so definidas por um par de [ ], e os
itens que estiverem dentro dos colchetes pertencem a lista,
mais de um item deve ser separado por vrgula. Veja no
exemplo anterior que guardamos quatro valores literais dentro
de uma nica varivel e quando chamamos esta varivel na
instruo print( ) o Python nos diz todos os valores que
existem nessa varivel. Ns podemos verificar quantos itens
existem em uma lista com a instruo len( ).

Sada:

Desta forma ao trabalharmos com listas muito extensas


em que precisamos verificar a quantidade de itens nesta lista
basta passarmos a lista como parmetro para a instruo len( ).
Agora vamos supor que antes de voc sair para o
mercado sua me lhe diz que esqueceu de dizer que pra voc
trazer cenouras tambm, ento voc precisa adicionar mais um

119
item em sua lista, para fazer isto no Python basta utilizar o
comando .append( ) com o nome do item a ser adicionado
entre os parnteses, desta forma:

Utilizamos as instrues len( ) para verificar que a lista


aumentou de tamanho, escrevemos antes e depois de adicionar
o item para verificar que as alteraes foram feitas com
sucesso. Agora voc j pode ir ao mercado comprar as coisas
para sua me.

Ao chegar no mercado voc colocou em sua cestinha a


banana e o azeite, e resolveu riscar da sua lista os itens que
voc j pegou para no acabar se perdendo. Para remover um
item conhecido de sua lista basta escrever o item a ser
removido como parmetro na instruo .remove( ), desta
forma:

120
Sada:

No comeo deste captulo foi dito que as estruturas de


dados em Python so heterogneas, o que significa que
podemos misturar tipos de dados em uma nica lista. Nos
exemplos anteriores fizemos uma lista de literais, mas
possvel inserir dados de tipos distintos em uma mesma lista
Python. Veja neste exemplo:

121
Primeiro criamos uma lista vazia com o identificador
meus_dados, para criar uma lista vazia basta atribuir os
colchetes vazios [], ento fazemos as solicitaes de entrada de
trs tipos de dados diferentes um literal (nome) um inteiro
(idade) e um real (altura), adicionando cada um deles em nossa
lista, no final do algoritmo escrevemos o contedo da lista.

Veja como as listas em Python suportam diferentes tipos


de dados, por este motivo so caracterizadas como
heterogneas, diferentemente dos vetores em algumas
linguagens de programao que somente aceitam dados de um
nico tipo. Dissemos tambm no incio deste captulo que os
itens da lista so identificados por um ndice, assim podemos
pedir para o Python um determinado elemento da lista pelo
ndice. Se voc se lembrar bem, o Python comea a contar do
zero, isso tambm se aplica as listas, logo o primeiro ndice da
lista 0, e todos os elementos na sequncia seguem a
numerao do ndice. A nossa lista de compras dos primeiros
exemplos possui no ndice 0 o item banana, no ndice 1 o

122
item queijo, no ndice 2 o item trigo e assim por diante.
Para que o Python identifique o item pelo ndice basta escrever
o nome da lista seguido pelo ndice entre colchetes, desta
forma:

Sada:

Perceba que apesar de nossa lista possuir 5 elementos, o


ltimo elemento da lista representado pelo ndice 4, bem
comum o Python retornar um erro ao passarmos um ndice
inexistente para ele, necessitando um pouco de cuidado ao
solicitar os elementos pelo ndice. No exemplo anterior
pedimos que o Python escrevesse o item da posio 0 e da
posio 4, e caso no existisse uma posio 4, o Python
retornaria um erro:

123
Neste exemplo, ao pedirmos que o Python escreva a
posio 0 ocorre tudo bem, ele escreve banana, mas quando
o algoritmo chegar a instruo que solicita ao Python para
escrever a posio 4 ele retornar um Traceback do tipo
IndexError, pois antes desta instruo havamos removido o
item da posio 4, e como no haviam mais itens na sequncia,
a posio do ndice 4 ficou inexistente. Ao tentar analisar isto o
Python tenta nos dizer ei programador esse ndice no existe.
Quando voc no tiver certeza de quantos elementos
possui a lista, mas mesmo assim quiser verificar o ltimo
elemento da lista, basta utilizar [-1] como ndice, e o Python ir
buscar o ltimo item da lista, independente de quantos
elementos ela possua:

124
Sada:

Atravs dos ndices tambm possvel alterar o


contedo da lista fazendo uma nova atribuio ao ndice, isto
ir sobrescrever o elemento armazenado naquela posio, veja:

Sada:

Modificamos todas as posies da lista e atribumos


novos valores a cada posio do ndice, essa lista parece ter
ficado bem mais gostosa, mas infelizmente no o que sua
me pediu pra voc comprar.
Uma das formas mais comum de se trabalhar com listas
iterar atravs do lao for, assim podemos analisar item por
item da lista, veja:

125
Sada:

Com o loop percorremos cada um dos elementos e


vamos escrevendo-o na tela. O for o mais comum de se
utilizar porm perfeitamente possvel fazer o mesmo com o
loop while, voc saber quando utilizar um ou outro no
decorrer de seus algoritmos. Da mesma forma que podemos
percorrer a lista com um lao, tambm possvel verificar se
um determinado item existe na lista com uma estrutura
condicional, como no exemplo a seguir:

Sada:

126
Viu como fcil trabalhar com listas em Python?
Vamos ver mais uma funo bacana para se utilizar nas listas, o
mtodo sort( ). Com este comando podemos ordenar nossa
lista de forma organizada, no exemplo a seguir vamos
organizar a nossa lista de compras em ordem alfabtica:

Sada:

possvel fazer o inverso e organizar os itens da lista


de trs para frente com o mtodo .reverse( ), assim a lista ser
invertida ao contrrio, como neste exemplo:

Sada:

Tanto o mtodo sort( ) como o reverse( ) tambm


funcionam com listas numricas, se o contedo da sua lista for

127
composto de diversos nmeros aleatrios desordenados, basta
chamar o mtodo sort( ) para organiza-los de forma crescente,
e caso queira ordena-los em forma decrescente basta chamar o
mtodo sort( ) depois o mtodo reverse( ). Tente fazer isto!
Existe uma outra forma de criar uma lista, atravs da
instruo list( ) passando como parmetro a instruo range( )
contendo o tamanho desejado para sua lista, desta forma:

A instruo list() combinada com a instruo range( )


criam uma lista de nmeros inteiros automaticamente,
lembrando que o Python comea a contar do zero, sabendo que
nosso range 10 a lista dever conter uma sequncia de 0 a 9:

Uma outra forma peculiar, e bem eficiente de se criar


uma lista utilizando um loop for dentro da lista. Isso em
Python chamado list comprehension, muito em breve voc
estar familiarizado com estes conceitos, veja um exemplo:

O resultado seria o mesmo:

128
Voc se recorda do algoritmo de soma? Bom o Python
tem uma funo embutida chamada sum( ), que faz exatamente
a mesma cosia, soma os nmeros entre parnteses, mas uma
caracterstica interessante desta instruo que ela pode
receber uma lista de nmeros e retorna como resultado a soma
total de todos os nmeros da lista, veja:

Sada:

ESTRUTURAS DE DADOS MULTIDIMENSIONAIS


Uma matriz uma estrutura de dados
multidimensional, o que quer dizer que ela tem vrias
dimenses, ou seja uma lista que contm outras listas. At

129
agora vimos vetores unidimensionais, ou seja, listas com
elementos singulares em sequncia, j as matrizes podem
conter outras listas dando uma caracterstica multidimensional.
Para exemplificar melhor, vamos dizer que voc estabeleceu
uma lista de afazeres do seu dia:

1 Ir na padaria:
1.1 Comprar po;
1.2 - Comprar manteiga;
1.3 Comprar queijo;
2 Passar na autopeas:
2.1 Calibrar os pneus do carro;
2.2 Trocar o leo;
3 Passar na farmcia:
3.1 Comprar remdio;
3.2 - Pesar-se na balana;
4 Voltar pra casa:
4.1 Fazer caf;
4.2 - Tomar o remdio;
4.3 - Limpar a casa;
4.4 - Ler um livro

130
Muitas vezes nossas tarefas so compostas de outras
listas de tarefas, sendo assim nossa lista de atividades do dia
multidimensional. Em Python poderamos definir essa lista
desta forma:

Utilizamos um lao for para percorrer a primeira


dimenso da nossa lista, para cada elemento da lista afazeres
ser exibido na tela, como o contedo de afazeres so quatro
listas:

Para referenciar uma um item da lista interna pelo


ndice utilizamos dois pares de colchetes passando o ndice da
lista a ser verificada no primeiro e o ndice do elemento no
segundo:

131
Sada:

Voc pode aninhar quantas listas quiser desde que tenha


conhecimento da complexidade que estar lidando. Cada linha
aninhada ser uma dimenso na sua estrutura de dados. Vamos
dizer que voc tem uma lista que contm uma lista que contm
uma lista que contm uma lista...

At buguei com tantas listas dentro de listas...

132
Observe atentamente este cdigo para acessar as
camadas mais internas da matriz multidimensional. Para cada
camada mais profunda um novo ndice deve ser utilizado entre
colchetes para acessar o elemento existente. Neste exemplo
criamos listas dentro de listas onde o primeiro item de cada
lista uma string dizendo em qual dimenso da lista estamos,
este elemento pode ser verificado pelo ndice 0 desta lista. O
segundo elemento de cada lista uma nova lista. Veja a sada:

Recorda-se de como criar uma lista com list


comprehension? Podemos fazer isto para criar uma matriz
bidimensional, veja:

133
Sada:

Voc pode pensar em uma matriz multidimensional


como se fosse uma tabela com linhas e colunas, considerando a

134
matriz anterior com 3 listas de 5 inteiros, poderamos
considerar as listas como colunas e as posies dos itens nas
listas as linhas:
Figura 18 Tabela de matriz bidimensional

Fonte: O autor.

Para exemplificar vamos criar uma matriz


representando o ms de Junho de 2017, nesta matriz haver
sete listas representando os dias da semana, e nas listas internas
os dias do ms que cairo naquele dia da semana:

135
Sada:

Figura 19 Matriz representativa do ms de Junho de 2017

Fonte: O autor

Agora pense um pouco e tente responder, quais dias


seriam os dias representados por:

junho[3][3], junho[1][2], junho[6][3], junho[0][2]

136
Agora que voc conhece sobre as listas e os ndices,
vamos fazer uma rpida abordagem sobre os ndices em
strings. Os dados do tipo literal (strings) tambm podem ser

analisados por meio de ndices da mesma forma como nas


listas, veja:

Sada:

O slicing (fatiamento) uma tcnica muito prtica e


comumente utilizada em Python para trabalhar com strings,
podemos fatiar uma palavra pelo seu ndice e depois
concaten-las novamente para formar outras palavras, veja

neste prximo exemplo, vamos pedir uma palavra par ao


usurio e substituir a primeira letra pela ltima letra.

137
Comeamos pedindo uma palavra ao usurio que ficara
guardada na varivel palavra. Ento realizamos o slicing para
substituir as letras. Ns queremos a ltima letra no incio, ento
vamos peg-la pelo ndice palavra[-1] vamos concatenar
(somar as strings) com a parte da palavra que no contm nem
a primeira nem a ltima letra, ento vamos utilizar o ndice [1:-
1]. Quando utilizamos o sinal de : estamos dizendo ao Python
Ei queremos somente os caracteres que esto entre a posio 1
e -1 desta string ok?, ento concatenamos no final o primeiro
caractere identificado pelo ndice [0], como resultado obtemos
a palavra com primeira letra substituda pela ltima:

TUPLAS
As tuplas so como as listas, so estruturas de dados
onde podemos agrupar diversos tipos de dados, porm a tupla
se caracteriza por ser imutvel, o que quer dizer que, uma vez
definida, os valores da tupla no podero ser alterados. Depois
de declarada, no podemos adicionar nem remover dados
tupla. Para criar uma tupla em Python basta definirmos um

138
identificador e atribuir os valores entre parnteses e separados
por vrgula:

Sada:

Podemos acessar os valores da tupla pelo ndice


da mesma forma como acessamos nas listas. A utilizao das
tuplas est intimamente relacionada a definio de variveis
constantes, ou seja, valores que no podero ser modificados
no decorrer do algoritmo, como por exemplo a definio de
uma altura e largura fixa para uma janela em um programa de
computador.

Sada:

No podemos modificar os valores da tupla, mas


possvel sobrescrever a tupla com novos valores:

139
Sada:

DICIONRIOS
Dicionrios so semelhantes s listas, so estruturas que
nos permitem guardar diferentes tipos de dados, porm seu
ndice no ser um nmero e sim um dado definido pelo
prprio programador, este dado ser a chave de acesso para um
valor qualquer.
Entender os dicionrios permite modelar
uma diversidade de objetos do mundo real
de modo mais preciso. Voc ser capaz de
criar um dicionrio que representa uma

140
pessoa e armazenar quantas informaes
quiser sobre ela. Poder armazenar o nome,
a idade, a localizao a profisso e qualquer
outro aspecto de uma pessoa que possa ser
descrito. (MATTHES, 2016 p. 139)

Para declarar um dicionrio utilizamos a seguinte


sintaxe:

identificador = {chave : valor}

Onde identificador, como sabemos o nome da varivel


que conter o dicionrio, o dicionrio caracterizado por um
par de {}, entre as chaves temos um par de dados determinados
par chave-valor (MATTHES, 2016). Sempre que
precisarmos acessar um valor de um dicionrio iremos acessar
atravs da chave, da mesma forma que acessvamos um item
da lista pelo ndice. Vamos comear com este exemplo mesmo
dado por Matthes, e elaborar um dicionrio que guarda o nome,
a idade e localizao:

141
Sada:

Os dicionrios assim como as listas, podem ser


modificados, basta atribuir um novo valor para a chave:

Sada:

Os dicionrios podem ser percorridos por um lao for


fornecendo a chave o valor para o lao e assim podemos
verificar tanto chave quanto valor em um dicionrio
escrevendo-os na tela, veja um exemplo:

142
Atravs do mtodo .items( ) podemos fornecer duas
variveis de busca para o lao for e varrer todos os valores e
chaves de um dicionrio.

Recorda-se quando criamos aquele pequeno algoritmo


que recebe as notas de um aluno de uma disciplina e calcula
sua mdia? Para esse algoritmo precisvamos definir quatro
variveis para as notas do aluno, atravs do dicionrio basta
criarmos as chaves para os valores que desejamos obter (no
caso as notas do aluno), veja como seria obter e guardar as
notas e medias de um aluno em um dicionrio:

143
Sada:

Se voc prestou bem ateno deve ter reparado que na


ltima instruo print deste algoritmo utilizamos uma string
formatada, isso significa que utilizamos um caracter especial
(%) para substituir o valor da varivel designada para dentro da
string. Neste caso escrevemos Media: %.1f , onde % ir ser

144
substitudo pelo valor de aluno['media'], e .1f significa que
precisamos mostrar apenas uma casa aps o ponto flutuante do
nmero fracionrio. Aps fechar a string utilizamos novamente
o % para referenciar a varivel que contm o valor a ser
mostrado na string.
Agora j pensou que seu professor precisa guardar as
notas de muitos alunos, tantos que nem sabemos quantos?
Como implementar um algoritmo para ajudar nosso professor?
Vamos fazer uma pergunta ao usurio perguntando quantos
alunos possui a classe, e utilizamos esse valor para criar uma
lista com este tamanho. Para cada elemento desta lista vamos
atribuir um dicionrio contendo o nome do aluno, uma lista
com suas quatro notas, sua media e sua situao final (se
aprovado, recuperao ou reprovado), para preencher a lista
completa de alunos da turma vamos utilizar um lao de
repeties, veja:

145
Este cdigo parece um pouco complicado a uma
primeira vista mas vamos analis-lo por partes. Primeiro

146
requisitamos que o professor insira sua disciplina e a
quantidade de alunos que compem a turma. At aqui tudo bem
j estamos familiarizados com isso, ento criamos uma varivel
turma, vamos atribuir a ela uma lista de tamanho igual ao
nmero de alunos na turma. Atravs do lao de repetio
vamos iterar pela turma, e para cada posio da lista vamos
atribuir um dicionrio contendo as informaes do aluno. Ao
criar a chave no dicionrio atribumos com valor um input( ),
desta forma as informaes inseridas pelo usurio vo estar
armazenadas em nosso dicionrio. Para receber as notas
utilizamos uma list comprehension para receber 4 entradas de
nmeros inteiros. Veja que aqui ns temos uma estrutura
multidimensional, para acessar os dados das notas vamos ter
que fornecer trs ndices ao Python, o primeiro o da primeira
dimenso da lista, a lista externa que contm os dicionrios
turma[ndice]. A segunda dimenso o dicionrio que contm
as informaes do aluno, para acessar uma informao do
dicionrio devemos fornecer a chave aps fornecer o ndice da
lista acima turma[ndice][chave]. A terceira a lista dentro do
dicionrio, para acessarmos os dados precisamos fornecer o
ndice do elemento da lista aps ter fornecido a chave do
dicionrio E o ndice da lista externa turma[ndice_externo]

147
[chave][ndice]. Atravs destes ndices podemos somar as
notas do aluno e atribuir mdia e verificar se o aluno est
reprovado, aprovado ou em recuperao. Para informar a sada
utilizamos um lao de repetio encadeado, o primeiro para
mostrar o nome de cada aluno, a media e o resultado final, o
segundo somente para iterar pela lista interna do dicionrio.
Utilizamos strings formatadas onde substitumos o valor de %
por um valor indicado aps a string, o %s substitui um valor
literal, o %i substitui um valor inteiro, o %f substitui um valor
real. A sada exemplificada para trs alunos, mas pode ser
utilizada para uma turma com trinta, cem mil alunos se voc
tiver pacincia...

148
149
EXERCICIOS ELABORADOS

8) Escreva um algoritmo que leia um vetor com 30


elementos inteiros e escreva-os em ordem
contrria da leitura.

Problema a ser resolvido: ler um vetor de 30


elementos e imprimir seu inverso;
Dados de entrada: trinta inmeros inteiros;
Processamento: inverter o vetor ao mostrar o
resultado;
Sada: Informar os elementos do vetor em ordem
contrria;

Sada:

150
9) Faa um algoritmo que possua uma lista com
dez posies, e leia do usurio nmeros em
ordem aleatria at que a lista seja preenchida
completamente pelos nmeros inseridos. Sem
utilizar instrues para ordenar automaticamente
a faa com que a sada mostre todos os nmeros
da lista em forma ordenada e crescente.

151
Problema a ser resolvido: ler um vetor de 10
elementos e imprimir de forma ordenada;
Dados de entrada: dez inmeros inteiros;
Processamento: ordenar o vetor manualmente e
mostrar o resultado;
Sada: Informar os elementos do vetor em ordem
crescente;

152
Figura 20 Fluxograma bubble sort

Fonte: O autor.

153
Sada:

Obs: Este um algoritmo bem comum em computao


denominado Bubble Sort, existem muitas formas diferentes de
se ordenar os elementos em um vetor e este um exemplo
muito prtico.

154
Exerccios Propostos:
1) Armazene o nome de alguns de seus amigos em
uma lista. Exiba o nome de cada pessoa
acessando cada elemento pelo ndice da lista;
2) Faa uma lista de convidados para uma festa,
exiba uma mensagem para cada convidado
informando que ele esta convidado para a festa.
3) Crie uma lista com 500 posies, atravs de um
lao mostre quais nmeros na lista so pares e
quais so mpares.
4) Escreva uma matriz para o ms em que voc
aniversario, mostre o dia do seu aniversrio.
5) Formule um algoritmo que cadastra em um
dicionrio o registro de produtos de uma loja de
alimentos, guarde os registros em uma lista. Os
produtos devem conter nome, quantidade em
estoque e valor de compra.

155
Capitulo 6
...

SUB-ROTINAS E PROGRAMAO COM ARQUIVOS


Vamos conhecer neste captulo os conceitos de sub-
rotinas que nada mais so do que partes do nosso algoritmo que
podem ser reaproveitadas sem termos que reescreve-las
diversas vezes sempre que necessrio, facilitando a depurao,
manuteno e aumentando a legibilidade do nosso cdigo. Para
entender estes conceitos tambm ser necessrio compreender
o escopo das variveis, como variveis globais e locais, tema
que tambm ser abordado neste captulo.

Outro ponto a ser estudado neste captulo ser a


manipulao de arquivos com Python, abordando elementos de
insero, leitura e remoo de dados oriundos de um arquivo
guardado no disco rgido do seu computador, permitindo assim
que os dados que trabalhamos fiquem armazenados de forma
permanente.

SUB-ROTINAS

Uma sub-rotina uma parte do algoritmo que pode ser

156
utilizada diversas vezes sem que tenhamos que reescrever o
cdigo cada vez que seja necessrio executar uma determinada
tarefa. Ascencio e Campos (2010, p. 230) define as sub-rotinas
como blocos de instrues que realizam tarefas especficas.
Leal (2016a, p. 166) comenta que as sub-rotinas so
responsveis por diminuir a complexidade de determinados
problemas, desta forma reduzimos um grande problema em
pequenas partes, ou subproblemas, facilitando sua resoluo.
Desta forma utiliza-se as sub-rotinas para executar os
subproblemas tratando cada parte complexa individualmente.

Uma sub-rotina carregada apenas uma vez


e pode ser executada quantas vezes for
necessrio, podendo ser utilizada para
economizar espao e tempo de
programao. Em cada sub-rotina, alm de
ter acesso s variveis do programa que o
chamou (variveis globais), pode ter suas
prprias variveis (variveis locais), que
existem apenas durante sua chamada.
(LEAL, 2016a)
Na literatura encontramos as sub-rotinas em duas
formas: Procedimentos e Funes, vamos analisar ambas as
formas destacando suas caractersticas e como utiliz-las em
Python.

157
PROCEDIMENTOS

Um procedimento uma sub-rotina que contm um


bloco de instrues a serem executadas a qualquer momento
desejado. Assim como as variveis, os procedimentos devem
possuir um identificador para ser usado na hora de sua
chamada. Ao ser chamado durante a execuo de um
algoritmo, o procedimento executa seus comandos e retorna
para o fluxo normal do algoritmo logo aps sua chamada,
dando continuidade ao programa em execuo. O
procedimento caracteriza-se por no retornar nenhum valor
aps sua execuo, ele simplesmente executa suas instrues e
segue para o prximo comando do algoritmo aps ter sido
chamado. A sintaxe para declarar um procedimento em Python
a seguinte:

def identificador( ):

#bloco de instrues

A palavra-chave def utilizada para definir o


procedimento, no identificador atribumos um nome para o
procedimento, seguindo as regras para nomenclatura de
identificadores j abordado no incio deste livro, em seguida
abrimos e fechamos parnteses para caracterizar o

158
procedimento e finalizamos com dois pontos (:). Aps os dois
pontos sero declaradas as instrues do procedimento, estas
devero ser indentadas para que o Python reconhea que as
instrues pertencem ao bloco do procedimento. Veja um
exemplo em Python para um procedimento que exibe a
mensagem Ola mundo:

Definimos um procedimento chamado olamundo( ), no


seu bloco de comandos temos a instruo print( ). O
procedimento executa a instruo print( ) declarada em seu
bloco de comandos quando houver a chamada para sua
execuo. Para chamar um procedimento basta escrevermos
seu nome no programa, como no exemplo anterior. Ao
chamarmos o procedimento olamundo( ) obtemos a execuo
dos seus comandos internos, neste caso uma mensagem:

possvel no momento da definio do nosso


procedimento, especificar parmetros para execuo do

159
procedimento, estes parmetros so fornecidos dentro dos
parnteses em sua definio, e devem obrigatoriamente ser
utilizados no bloco de comandos. Ao chamar o procedimento
fornecemos um argumento para o procedimento, os argumentos
sero substitudos pelos parmetros listados na definio e as
instrues utilizaro os argumentos na execuo do
procedimento.

Veja que ao definirmos o procedimento, dentro dos


parnteses declaramos um parmetro chamado nome, este
parmetro est sendo utilizado na mensagem dentro do
procedimento. Quando chamamos o procedimento fornecemos
um argumento que substituir o parmetro nome para ser
utilizado na mensagem.

No entendi. Qual a diferena entre parmetro e argumento?

160
De acordo com Matthes (2016, p. 187),
parmetro um valor que deve ser fornecido para a sub-rotina
na hora de sua definio, j o argumento um valor passado
para a chamada da sub-rotina durante a execuo do algoritmo.
Neste caso, nome o parmetro, pois foi declarado no
procedimento durante sua definio, e a string 'Bruno' um
argumento que foi passado para o procedimento durante sua
chamada na execuo do algoritmo.

Leal(2016a) coloca uma distino entre parmetros que


apresenta os mesmos conceitos acima, como sendo os
parmetros formais aqueles declarados juntamente sub-rotina
e os parmetros reais aqueles que substituem os parmetros
formais ao chamar a sub-rotina no programa principal (os
argumentos). Na literatura estes conceitos caracterizam a
distino entre parmetro e argumento, ou parmetro formal e
parmetro real. Vamos exemplificar com mais um
procedimento que realiza a soma ou a subtrao de dois
nmeros:

161
Definimos inicialmente os procedimentos do algoritmo,
ambos recebem dois parmetros a e b, e quando chamados
exibem uma mensagem informando o resultado da operao
entre os parmetros. As primeiras instrues do algoritmo
solicitam dois nmeros ao usurio, ento pedimos para que
faa uma escolha entre soma e subtrao, e caso a escolha seja
correspondente a soma ento chamamos o procedimento de
soma e fornecemos os nmeros de entrada como argumentos,
ou se a escolha corresponder subtrao ento chamamos o

162
procedimento de subtrao fornecendo as entradas como
argumentos.

Voc j conheceu aqui algumas formas interessantes de


se construir algoritmos, implemente este ltimo exemplo
adicionando dois novos procedimentos para diviso e
multiplicao. Implemente tambm um lao que pergunta ao
usurio se gostaria de realizar outra operao ao final do
algoritmo. Implemente tambm um lao que verifica se a
entrada do usurio vlida (um valor numrico) e caso seja
invlido fique repetindo a solicitao at que um valor vlido
seja inserido.

FUNES

As funes so sub-rotinas idnticas aos procedimentos,

163
a declarao das funes exatamente igual e sua estrutura a
mesma dos procedimentos assim como tambm podem possuir
parmetros. A nica diferena entre uma funo e um
procedimento que as funes sempre retornam valores.
Uma funo nem sempre precisa exibir sua sada diretamente.
Em vez disso, ela pode processar alguns dados e ento devolver
um valor ou um conjunto de valores. O valor devolvido pela
funo chamado de valor de retorno. A instruo return toma
um valor que est em uma funo e o envia de volta linha que
a chamou. Valores de retorno permitem passar boa parte do
trabalho pesado de um programa para funes, o que pode
simplificar o corpo de seu programa. (MATTHES, 2016)

Um valor de retorno pode ser armazenado em um


varivel e ser processado ou manipulado por outras partes do
algoritmo como operaes aritmticas, lgicas, condicionais e
at mesmo ser utilizado como argumento em outra funo. Veja
um exemplo que retorna o quadrado de um nmero:

Primeiramente definimos nossa funo, da mesma


forma como o procedimento, porm damos a instruo return
para retornar o valor na hora de sua chamada. Ento pedimos
um valor inteiro ao usurio que ser passado como argumento

164
para a nossa funo. Veja que ao chamar a funo tambm
atribumos a mesma em uma varivel chamada quad. Perceba
que neste momento no estamos armazenando uma funo em
uma varivel e sim o valor retornado por esta funo. O
resultado armazenado na varivel quad exibido na primeira
instruo print( ), e tambm utilizado como argumento em
uma nova chamada funo quadrado( ) que definimos,
retornando um novo valor resultante da operao interna da
nossa funo. Quando retornamos um valor no precisamos
utilizar uma funo print( ) dentro da funo para exibir o
valor, ele poder ser exibido se chamarmos a funo dentro da
instruo print( ).

Vamos para outro exemplo, adaptado de Matthes(2016).


Vamos escrever uma funo que possui dois parmetros que
devem ser literais correspondentes ao nome e sobrenome de
uma pessoa, essa funo deve retornar o nome completo e
formatado.

165
Definimos a funo para receber dois parmetros, no
processamento fazemos a soma das strings, este processo de
unir strings denominado concatenao. Retornamos as strings
concatenadas e com a primeira letra de cada palavra com letra
maiscula. Definimos um nome e um sobrenome para ser
fornecido funo, e seu retorno atribudo varivel
nome_completo que em seguida exibida.

PARMETROS

Os parmetros como vimos, so valores abstratos


declarados em uma sub-rotina, no momento da chamada sub-
rotina fornecemos um valor real para os parmetros

166
denominados argumentos. Quando declaramos parmetros em
uma sub-rotina, obrigatoriamente devemos fornecer os
argumentos em sua chamada, do contrrio teramos um erro:

Sada:

Se no fornecermos os argumentos necessrios


obteremos um Traceback informando que na chamada funo
multiplica( ) est faltando um argumento. Isto porque os
parmetros definidos na funo so obrigatrios, porm
possvel definir parmetros optativos no Python, basta
inicializar o parmetro na definio da sub-rotina. Veja:

Declaramos a mesma funo do exemplo anterior, mas

167
desta vez inicializamos o segundo parmetro com o valor 1,
desta forma o parmetro se torna optativo, e se no
fornecermos o segundo valor a funo utilizar o valor
inicializado, retornando a multiplicao pelo valor 1:

E no caso de fornecermos um argumento para um


parmetro inicializado, a sub-rotina ir utilizar o valor
fornecido como parmetro no lugar do valor inicializado:

Sada:

168
ESCOPO DAS VARIVEIS

Quando trabalhamos com sub-rotinas devemos ficar


atentos ao escopo das variveis, se voc declarar uma varivel
dentro de uma sub-rotina no poder acess-la no programa
principal, mas poder acessar as variveis do programa
principal dentro da sub-rotina, porm no poder modificar seu
valor a no ser que declare-a como global. As variveis
declaradas dentro das sub-rotinas so denominadas variveis
locais e as variveis declaradas no programa principal so
denominadas variveis globais. Veja, vamos demonstrar com
um exemplo:

169
Definimos uma funo chamada sub( ), nela possumos
uma varivel x com valor 2, mas no programa principal
tambm temos uma varivel x com valor 12, ao chamar a sub-
rotina impresso o valor da varivel local da sub-rotina, porm
o valor de x permanece 12:

Isto se d porque no informamos ao Python na


definio da sub-rotina que x deveria ser referenciado como
uma varivel global. Veja:

Desta vez informamos que a varivel x uma varivel


global, assim podemos modificar seu valor dentro da sub-
rotina:

170
Se tentarmos modificar uma varivel declarada dentro
da sub-rotina vamos levantar um erro, pois esta varivel no
pode ser utilizada no decorrer do algoritmo principal:

A varivel x s existe dentro da sub-rotina:

Lembra-se deste erro? A varivel de nome x no foi


definida. Isto porque quando declaramos uma varivel local em
uma sub-rotina, esta somente existir durante o processamento
da sub-rotina. Ou seja, quando chamamos uma sub-rotina no
algoritmo esta ser executada e as variveis ali declaradas
sero inicializadas na memria, quando todos os comandos da
sub-rotina tiverem sido executados e ela chegar ao fim de sua
execuo, suas variveis locais sero destrudas. Isto um
mtodo eficiente para poupar o uso de memria. As variveis

171
globais permanecero ativas na memria enquanto seu
algoritmo estiver executando, sempre que possvel processe
diversas variveis em uma funo e de um retorno para o
programa principal, isto ir aumentar a eficincia do seu
cdigo.

RECURSIVIDADE

A recursividade, em linguagem de programao a


capacidade de uma sub-rotina de chamar-se a si prpria,
fundamentando este conceito, Leal(2016a) afirma que a
recursividade um mecanismo que permite uma funo
chamar a si mesma direta ou indiretamente. Chamar a si
mesma remete a funo execuo de um loop, por isto
precisamos definir em uma funo recursiva:

Uma chamada recursiva;


Uma parada;

Um exemplo clssico de chamada recursiva o clculo


do fatorial de um nmero. O fatorial calculado pelo nmero
multiplicado por todos seus antecessores. Por exemplo o

172
fatorial de 5! 5 x 4 x 3 x 2 x 1 que resulta em 120. Veja neste
exemplo de algoritmo Python para o clculo fatorial de um
nmero:

Definimos dentro da funo uma condio de parada,


neste caso quando a varivel local nmero chegar 0. At que
chegue em zero continuaremos retornando a prpria funo
subtraindo 1 do nmero em seu argumento e multiplicando
pelo prprio nmero.

Modifique este algoritmo para que ele receba uma


entrada de usurio que seja um nmero e calcule o fatorial
deste nmero, exibindo uma mensagem elegante na tela
informando o resultado do fatorial.

ARQUIVOS

Arquivos so formas de gravar dados de forma

173
permanente em seu computador. Ao criarmos um arquivo
podemos inserir dados processados atravs de um algoritmo,
ou podemos utilizar um algoritmo para buscar dados em um
arquivo escrito, tambm podemos utilizar algoritmos para
escrever novos dados em arquivos escritos, entre outras
possibilidades.

Em Python utilizamos a instruo open( ) para abrir um


arquivo, devemos fornecer um argumento literal com o nome e
extenso do arquivo. Se o arquivo estiver salvo no mesmo
diretrio do programa.py que voc estiver executando basta
fornecer o nome e extenso do arquivo como por exemplo
'lista_de_compra.txt', caso esteja em outro diretrio voc
precisar fornecer o caminho completo par ao arquivo como
por exemplo 'c:windows/desktop/pasta/lista_de_compras.txt'.

Sempre que abrirmos um arquivo com open( ),


devemos fecha-lo com close( ).

importante que o arquivo exista e que voc tenha


informado corretamente o nome ou caminho ao utilizar o
exemplo anterior, ou voc ir se deparar com um erro

174
informando que o arquivo no existe:

A instruo open( ) aceita alguns parmetros adicionais


que especificam o modo de abertura do arquivo, assim
poderemos informar se o arquivo deve ser aberto em modo de
escrita, leitura, leitura e escrita, etc. A tabela a seguir mostra os
parmetros aceitos pela instruo open( ):

Figura X Modos de abertura de arquivos em Python

Parmetro Significado
'r' Abre o arquivo em modo
leitura(default)
'w' Abre o arquivo em modo de escrita,
sobrescreve todos os dados do arquivo
anterior
'x' Abre em modo exclusivo, falha se o
arquivo j existir
'a' Abre para escrita append, adicionando
os dados ao final do arquivo existente
'b' Abre em modo binrio
't' Abre em modo texto (default)

175
Parmetro Significado
'+' Abre um arquivo de disco para
atualizao (leitura e escrita)
'U' Abre em modo universal newlines
(Descontinuado)
Fonte: <https://docs.python.org/3/library/functions.html#open>

Ao fornecer o modo de abertura devemos utilizar a


seguinte sintaxe:

variavel = open('nome_do_arquivo', 'modo_de_abertura')

Onde varivel a varivel que ir armazenar o


contedo do arquivo, nome_do_arquivo deve ser o valor literal
contendo o nome do arquivo a ser aberto e modo_de_abertura
deve ser um dos valores da tabela anterior. Veja no exemplo a
seguir vamos criar uma lista de nmeros e salv-la em um
arquivo com a instruo write( ):

Primeiro criamos uma lista com cem nmeros para


testar, ento abrimos o arquivo 'numeros.txt', este arquivo na

176
verdade no existe no computador mas como fornecemos o
modo de abertura 'w' (modo de escrita) o Python ir criar
automaticamente este arquivo no diretrio local, caso um
arquivo com este nome existisse ele seria apagado e
sobrescrito. Com um lao iteramos pela nossa lista escrevendo
cada nmero dela no arquivo, note que no podemos escrever
nmeros em um arquivo, somente dados do tipo literal podem
ser escritos em arquivos, ento convertemos cada nmero para
literal com str( ) no momento de escreve-lo no arquivo.
importante fechar o arquivo no final de seu algoritmo para que
este no permanea aberto na memria do computador, isto
poder corromper os dados do arquivo.

timo, agora vamos escrever um algoritmo para ler os


dados no arquivo que acabamos de criar:

Sada:

177
Perceba que se voc abrir o arquivo texto em um editor
de texto padro os dados estaro praticamente da mesma
forma:

Figura 21- Arquivo gerado

Fonte: O autor.

Se tentarmos abrir novamente o mesmo arquivo em


modo de escrita para tentar escrever novos dados vamos apagar
os dados existentes no arquivo atual, veja:

178
Sada:

Veja que no arquivo no diretrio os dados tambm so


modificados:
Figura 22 Arquivo sobrescrito

Fonte: O autor.

Isto ocorre quando abrimos um arquivo existente em


modo de escrita 'w', este modo cria um novo arquivo em
branco para escrita, e se algum arquivo j existir com o nome
declarado ele ser apagado e sobrescrito. Para adicionarmos
dados em um arquivo sem apagar o arquivo anterior
precisamos abrir em modo append, um modo de escrita que
permite adicionar dados um arquivo j existente, o parmetro
para este modo o 'a', veja:

179
Sada:

Desta vez adicionamos algumas letras pulando linha,


sim podemos utilizar o \n para pular linhas em arquivos,
perceba que o arquivo original no foi apagado, mas novos
dados foram adicionados a ele:
Figura 23 Arquivo com dados adicionados ao final

Fonte: O autor.

180
Existe ainda um modo seguro de abrir um arquivo,
utilizando as palavras reservadas with e as. Com with abrimos
o arquivo sem que seja necessrio fech-lo com open( ),
garantindo a segurana do arquivo, a palavra reservada as
define o identificador da varivel que conter o arquivo, veja:

Este um modo prtico e eficiente de se trabalhar com


arquivos em Python, veja a sada:

Legal, agora que sabemos ler e escrever em arquivos


permanentes vamos criar um pequeno algoritmo comercial, ele
deve possuir uma sub-rotina a ser chamada para cadastrar
produtos com seu devido valor e cdigo do produto em um
arquivo. Tambm vamos ter uma sub-rotina para mostrar os
produtos disponveis, uma para buscar um produto especfico e

181
uma que calcule a compra.

Primeiro criamos um procedimento para cadastrar


produtos em um arquivo:

Primeiro definimos o procedimento cadastro( ) e nele


abrimos o arquivo 'produtos.txt' em modo de leitura e escrita
'r+', desta forma podemos ler e escrever no arquivo, como este
ainda no existia no diretrio atual, o Python nos fez a
gentileza de cri-lo para ns. Ento solicitamos a entrada de
um produto e seu valor, tambm precisamos criar um cdigo
para cada produto, mas como isto pode vir a ser um valor
varivel que no pode se repetir vamos inicializar um cdigo
de valor zero e increment-lo em 1 para cada linha do arquivo
de produtos, desta forma cada vez que inserir-mos um novo
produto o arquivo ganhar uma nova linha, e
consequentemente o cdigo ser incrementado, assim temos
que o cdigo gerado automaticamente para cada produto,

182
legal no? Para testar adicionei dois produtos aleatrios em
minha lojinha:

Veja como o cdigo do produto fica no arquivo gerado,


podemos ver que ele inicia em 0 e na segunda linha o cdigo
1, e para cada produto que inserirmos o cdigo ir ser
incrementado. Voc pode alterar o cdigo para iniciar em
nmeros maiores como 100 e ser incrementado de 10 em 10
por exemplo, tente fazer isto.

Figura 24 Arquivo de produtos

Fonte: O autor.

No final escrevemos o cdigo seguido do produto e seu


valor de uma forma padro, e sempre que precisarmos incluir
um novo produto basta chamarmos o procedimento cadastro( ).

183
Agora vamos elaborar uma sub-rotina que mostre todos
os arquivos cadastrados:

Este simples, basta abrirmos o arquivo em modo


leitura e atravs de um lao de repetio mostrar cada linha do
arquivo, como cada produto est em uma linha do arquivo,
vamos mostrar todos os produtos da lista.

Mas e se a lista de produtos tiver cem mil produtos


cadastrados? Ja pensou ter que imprimir todos estes? Vamos
fazer uma sub-rotina que pesquise no arquivo um determinado
produto pelo nome:

184
Aqui precisamos de uma varivel que nomeamos de
achou e inicializamos ela com False pois ainda no
encontramos o produtos a ser buscado. Solicitamos o produto a
ser buscado e verificamos cada linha do arquivo, se uma delas
conter o produto atribumos True para a varivel achou e
escrevemos a linha que contm o produto na tela. Caso o
produto no seja encontrado no arquivo devemos informar que
o produto no se encontra cadastrado no arquivo. Veja no
exemplo buscamos pelo produto sabonete que foi cadastrado
sob cdigo 1, mas ao buscar a caneta o programa nos diz que
esta no foi cadastrada:

185
Vamos para agora escrever a sub-rotina que calcula o
valor da compra:

Definimos um procedimento compra( ) e inicializamos


trs variveis, uma para o valor total a pagar, uma para guardar
a lista de preos dos produtos adquiridos e uma lista que
guardar os dados do produto vindas do arquivo (cdigo, nome

186
e valor). Iniciamos um loop que inicia solicitando um produto
cadastrado, o programa pode aceitar o nome ou o cdigo do
item, caso o valor inserido seja 'fim' o loop encerra, do
contrrio ficar recebendo produtos. Quando um produto for
inserido procuramos no arquivo o produto e adicionamos seus
dados a lista de compras e somente os ltimos caracteres
contidos no arquivo (correspondentes ao preo) sero
convertidos para real e adicionados lista de valores. Quando o
loop se encerrar somamos todos os valores da lista de valores e
atribumos varivel total, fornecemos a sada final que
consiste na iterao pela lista de compras exibindo os dados
das compras na tela e a exibio do total a pagar em uma string
formatada. Veja na sada que o programa aceita tanto o nome
do produto (shampoo) como o cdigo (1 para o sabonete):

Legal agora que temos todas as sub-rotinas vamos


junt-las em um sistema til! Faa o seguinte, crie uma nova

187
pasta em seu computador chamada sistemaPython, abra um
novo arquivo no Idle e copie cada uma das sub-rotinas criadas
anteriormente:

188
189
Salve este arquivo na pasta sistemaPython com um
nome que desejar, aqui ser salvo como funcionalidades.py.
Neste mesmo diretrio copie o arquivo 'produtos.txt', de modo
que seu diretrio fique parecido com este:

Figura 25 Diretrio sistemaPython

Fonte: O autor.

Muito bem agora crie um novo arquivo em branco no


Idle e salve-o na mesma pasta com o nome main.py (ou outro
que lhe agrade), vamos utilizar o nome main por ser o
programa principal, muitas linguagens de programao
possuem um programa principal onde as outras funcionalidades
criadas so chamadas para um propsito principal, isto no
obrigatrio em Python, mas torna seu cdigo mais fcil de se
compreender, seu diretrio ir ficar parecido com este:

Figura 26 - Diretrio sistemaPython final

Fonte: O autor.

Agora podemos escrever o programa principal que une

190
todas as funcionalidades que acabamos de criar.

BIBLIOTECAS E MDULOS

A maioria das linguagens de programao possuem


bibliotecas contendo cdigos pr-existentes que realizam uma
ampla variedade de clculos e tarefas. Estas bibliotecas quando
fazem parte da linguagem so chamadas de Biblioteca Padro,
tambm temos as Bibliotecas Externas que so partes de
cdigo que baixamos de alguma fonte. No Python comum se
referir s bibliotecas como mdulos, podemos escrever nossos
prprios mdulos e importa-los para nosso algoritmo (como
vamos fazer com nosso sistemaPython) ou podemos utilizar as
pr-existentes no Python (que so muitos, Python conhecido
por ter baterias inclusas, o que quer dizer que ele j vem com
vrias bibliotecas com funcionalidades para uma ampla
variedade de tarefas.

Vamos fazer o seguinte, abra seu arquivo main.py e


escreva o seguinte:

A instruo import diz ao Python para usar neste

191
algoritmo o que estiver no modulo funcionalidades. O modulo
funcionalidades nada mais nada menos que nosso arquivo
funcionalidades.py (ou o nome que voc salvou o arquivo com
as sub-rotinas na pasta sistemaPython). Para utilizar uma das
funcionalidades do modulo importado use a sintaxe:

modulo.funcionalidade( )

Utilize o operador . para usar a funcionalidade desejada


do modulo desejado, assim a funcionalidade ser executada. H
outras formas de importar um mdulo, veja o abaixo:

Tabela 8 importao de mdulos

Declarao Traduo Descrio


import modulo Importe o modulo Importa um modulo
todo para o escopo
atual. Voc deve
referenciar a
funcionalidade pela
sintaxe
modulo.funcionalidad
e( )
from modulo import Do modulo importe Importa uma
funcionalidade essa funcionalidade funcionalidade
especfica de um
mdulo. Desta forma

192
voc pode chamar a
funcionalidade
diretamente pelo
nome
funcionalidade( )
from modulo import Do modulo importe Cria um alias
funcionalidade as nome essa funcionalidade (apelido) para a
como nome funcionalidade
importada. Desta
forma voc pode
chamar a
funcionalidade por
um nome desejado.
from modulo import * Do modulo importe Importa todas as
tudo funcionalidades do
modulo.
Fonte: O autor.

Voc pode utilizar a forma como for mais conveniente,


muitas vezes precisamos somente de uma ou algumas
funcionalidades de um mdulo, ento no precisamos importar
todas, isto aumenta a eficincia de seu algoritmo.

Agora que sabemos sobre a importao de mdulos


vamos finalizar a implementao do nosso sistemaPython:

193
Colocamos tudo dentro de um lao while para que o
programa fique rodando at que seja solicitado para encerrar,
fornecemos as opes disponveis, uma para cada
funcionalidade do sistema e caso o usurio insira uma opo
invlida o alertaremos disto.

194
195
Comeamos cadastrando um novo item no sistema, e ao
ver a lista de produtos possvel perceber que o novo item j
encontra-se cadastrado e com um cdigo vlido. Realizamos a
compra deste novo item e o programa nos revela o total da
compra, excelente no?

Python possui muitas outras bibliotecas que no foram


abordadas aqui, como por exemplo o modulo sqlite3 que
permite a manipulao de bancos de dados, este por exemplo
seria uma forma muito mais eficiente e segura de guardar
dados como em um sistema comercial. Procure em outras
fontes sobre este modulo e tente implementar este
sistemaPython com um banco de dados.

196
REFERNCIAS

ABBAGNANO, N. Dicionrio de filosofia. 5 ed. So Paulo:


Martins Fontes, 2007;

ASCENCIO, A. F; CAMPOS, E. V. A. Fundamentos da


programao de computadores. 2 ed. 4 reimpresso. So
Paulo: Pearson Prentice Hall, 2010;

BARRY, P. Use a cabea: Python. 2 reimpresso. Rio de


Janeiro: Alta Books, 2015;

LEAL, G. C. L. Algoritmos e lgica de programao I.


Centro Universitrio de Maring NEAD, Maring PR:
Unicesumar, 2016 (a);

LEAL, G. C. L. Algoritmos e lgica de programao II.


Centro Universitrio de Maring NEAD, Maring PR:
Unicesumar, 2016 (b);

MATTHES, E. Curso intensivo de python. So Paulo:


Novatec, 2016;

PRESSMAN, R. S. Engenharia de Software. So Paulo:


Pearson Makron Books, 2010;

197
PUGA, S; RISSETTI, G. Lgica de programao e
estrutura de dados, com aplicaes em Java. 2 ed. So
Paulo: Pearson Prentice Hall, 2010;

TANENBAUM, A. S. Organizao estruturada de


computadores. 5 ed. 5 reimpresso. So Paulo: Pearson
Prentice Hall, 2010;

PYTHON ORG, disponvel em: <https://www.python.org/>


Acesso em: 18/05/2017;

198
Apelo do Autor
Ol caro leitor, se voc concluiu a leitura deste livro,
deixo aqui meus parabns pois espero ter agregado um mnimo
e qualquer conhecimento a ti por meio desta obra. Se o
conhecimento repassado aqui lhe foi de alguma ajuda insisto
que repasse este conhecimento a frente pois nenhuma moeda
no mundo vale mais do que a sabedoria conquistada por meio
do esforo mental a qual nos designamos.

Fao nesta parte final, um encarecido apelo para que, se


este livro lhe foi til, e no tivestes de pagar qualquer centavo
por ele mas sente-se disposto a retribuir, que possa fazer uma
doao de qualquer quantia para ajudar o autor a publicar esta
obra em material fsico e tangvel e desta forma atingir mais e
mais pessoas de forma a propagar o conhecimento. Este livro
no possui um ISBN, pois para registro do mesmo necessrio
que se arque com alguns fundos burocrticos para fins de
oficializar esta material como Obra Literria real. Como autor
de origem humilde no posso realizar tamanha faanha sem o
incentivo monetrio para tal, desta forma se voc, caro leitor
puder contribuir para que esta obra seja oficialmente
regulamentada perante as demais obras da Biblioteca Nacional
e atribuir um ISBN para este material, ficarei, como autor

199
demasiado grato pela sua contribuio e espero um dia,
publicar oficialmente este manuscrito. Para doar qualquer
quantia voc pode acessar e doar atravs do PayPal por meio
deste link:
https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=brunolcarli%40gmail
%2ecom&lc=BR&item_name=Bruno%20Luvizotto%20Carli&currency_code=BRL&bn=PP
%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted

Doe bitcoins por aqui:

16srApTUX3McNhwxtxYLveGmhLff7wrUAA

Agradeo sua compreenso e pela leitura deste material.


Atenciosamente, o autor.

200

Você também pode gostar