Aula 10

Prévia do material em texto

for while
for while
Dentro das estruturas de comandos disponíveis nas linguagens de programação, 
existem comandos denominados comandos iterativos, ou laços de repetição. 
Também conhecidos como loops, eles são utilizados para a repetição de blocos 
de comandos ou para o processamento de coleções de dados, como linhas de 
um arquivo ou registros de um banco de dados que necessitam ser processados 
por um mesmo bloco de código, conforme aponta Borges (2010). 
Melo (2019) denomina esses comandos de cláusulas de repetição e afirma 
que as mesmas são de grande relevância para a programação, pois são utilizadas 
em situações em que é preciso executar um conjunto de instruções várias vezes. 
Essas repetições podem estar condicionadas a algum teste. Na linguagem de 
programação Python, duas cláusulas ganham destaque para essa finalidade: 
while e for. A seguir, essas duas cláusulas serão brevemente apresentadas.
for
Usa-se o comando for quando é necessário executar uma tarefa mais de uma 
conforme lecionam Mueller e Massaron (2018). O for, cuja tradução do inglês 
é “para”, é a estrutura de repetição mais utilizada na linguagem de programação 
Python. Trata-se de uma instrução que não é somente aceita em sequências 
estáticas, mas também em sequências geradas por iteradores. De forma geral, 
a sintaxe do comando for pode ser representada conforme mostra a Figura 1.
for
Conforme a ilustração de Melo (2019), o laço tem as seguintes funcio- 
nalidades:
 <objeto iterável>, que é um objeto que se pode repetir, ou seja é 
um objeto que possui diversos outros objetos e que pode ser percorrido;
 <destino> variável, que vai apontar para cada um dos objetos contidos 
no <objeto iterável>, um por vez, conforme a ordem definida 
pelo mesmo; o <destino> vai percorrer todos os valores que estão 
em <objeto iterável>. 
Desse modo, o bloco subordinado ao for <bloco de instruções 1> 
vai ser executado uma vez para cada valor no <objeto iterável> 
assumido por <destino>.
É importante ressaltar que, em Python, apenas as linhas que estão “dentro” 
do laço (indentadas com um <tab> ou quatro espaços) serão executadas 
de maneira repetida pelo for. O laço for também permite uma cláusula 
opcional else, executada após o <objeto iterável> ser percorrido 
completamente. Para o autor acima citado, o uso do else é indicado para 
programadores mais experientes.
for
for
while
Um loop também pode ser implementado a partir de uma instrução while. 
A instrução while executa um código atendendo a uma condição, quando 
esta é avaliada como verdadeira. Sua utilização é adequada para o uso quando 
não é possível determinar o número de iterações que devem ocorrer, nem 
mesmo há uma sequência a ser seguida. Observe um exemplo com sua forma 
geral na Figura 2.
while
Na instrução while, o primeiro a ser executado é <teste>; caso o 
resultado seja verdadeiro, as instruções consideradas subordinadas (<tab>) 
são executadas — esses blocos são chamados de repetição. Esse processo se 
repete por diversas vezes, até a avaliação <teste> resultar em falso; então, 
o programa vai saltar para a <primeira instrução pós-while>, ou 
seja, para a primeira linha de instruções subordinadas a while. A instrução 
while possibilita que um bloco seja repetido diversas vezes, enquanto a 
avaliação de <teste> for verdadeira.
while for continue break
break
continue
for while
Segundo os autores Mueller e Massaron (2018), aninhar é o processo de co-
locar uma expressão subordinada dentro de outra expressão, ou seja, colocar 
um determinado comando em Python dentro do bloco de execução de outro 
comando. Isso é muito útil em programação, ainda mais quando necessitamos 
resolver problemas em que as estruturas de dados possuem múltiplos níveis.
Um exemplo clássico do aninhamento de comandos iterativos para o tra-
balho com estruturas de dados multiníveis é a criação de uma calculadora 
de matrizes. Matrizes são estruturas de dados com duas dimensões; para 
realizar operações como adição e subtração de matrizes, é necessário percorrer 
suas duas dimensões (linha e coluna), elemento a elemento. Veja o exemplo 
da Figura 3.
No código apresentado, utilizamos dois comandos iterativos for aninhados 
(linhas 25 e 26), de forma a percorrer todas as posições da linha; a cada posição 
da linha, percorre-se todas as posições da coluna. São esses dois comandos 
aninhados que tornam possível que acessemos todos os elementos da matriz 
de maneira programática, ou seja, de maneira sistemática e não manual.
Observe que o algoritmo tem uma variável chamada tam (linha 6), que 
foi inicializada com o valor 4. Essa variável afeta os comandos nas linhas 11, 
15, 19, 23, 25 e 26, dizendo qual é o valor máximo de cada dimensão. Graças 
aos comandos iterativos for aninhados, podemos mudar o tamanho de tam 
para calcular a soma de matrizes 4 × 4 para matrizes de qualquer tamanho, 
sem mudar nenhuma outra linha de código.
Apesar de muito útil em muitas situações de programação, não é uma boa 
prática de programação utilizar muitos níveis de aninhamento de comandos 
iterativos, pois isso aumenta a complexidade do algoritmo, o que pode afetar 
sua eficiência. À medida que se aprende a programação em Python, percebe-se 
que podem ser utilizados comandos que otimizam o código e facilitam sua 
execução, evitando-se, assim, o uso indiscriminado de comandos iterativos e 
de outras estruturas em Python. 
Nas próximas seções deste capítulo, vamos realizar o teste de mesa e 
discutir problemas de computação que requerem o aninhamento de comandos 
iterativos com níveis superiores a 2. 
for
>>> numeros = [ i for i in range (5)]
>>> numeros 
[0,1,2,3,4]
i
for
range (5)
>>>numeros = []
>>> for i in range(5):
>>><tab>numeros.append(i)
Nesta seção, vamos abordar o teste de mesa — um passo a passo que simula 
a execução do algoritmo como se ele estivesse sendo processado em um 
computador. Nosso teste de mesa envolve a demonstração de um algoritmo 
que utiliza comandos iterativos aninhados em três níveis. O algoritmo a seguir 
é bem simples: ele tem o objetivo de contar o número de repetições em um 
conjunto de três for aninhados. Observe a Figura 4.
for
Para este teste de mesa, vamos contabilizar, a cada iteração, o valor das 
variáveis i, j e k, bem como o valor do contador que é expresso em cada 
iteração, conforme apontado abaixo.
Iteração 1:
i = 0, j = 0, k = 0
Iteração 2:
i = 0, j = 0, k = 1
Iteração 3:
i = 0, j = 0, k = 2
Iteração 4:
i = 0, j = 1, k = 0
Iteração 5:
i = 0, j = 1, k = 1
Iteração 6:
i = 0, j = 1, k = 2
Iteração 7:
i = 0, j = 2, k = 0
Iteração 8:
i = 0, j = 2, k = 1
Iteração 9:
i = 0, j = 2, k = 2
Iteração 10:
i = 1, j = 0, k = 0
Iteração 11:
i = 1, j = 0, k = 1
Iteração 12:
i = 1, j = 0, k = 2
Iteração 13:
i = 1, j = 1, k = 0
Iteração 14:
i = 1, j = 1, k = 1
Iteração 15:
i = 1, j = 1, k = 2
Iteração 16:
i = 1, j = 2, k = 0
Iteração 17:
i = 1, j = 2, k = 1
Iteração 18:
i = 1, j = 2, k = 2
Iteração 19:
i = 2, j = 0, k = 0
Iteração 20:
i = 2, j = 0, k = 1
Iteração 21:
i = 2, j = 0, k = 2
Iteração 22:
i = 2, j = 1, k = 0
Iteração 23:
i = 2, j = 1, k = 1
Iteração 24:
i = 2, j = 1, k = 2
Iteração 25:
i = 2, j = 2, k = 0
Iteração 26:
i = 2, j = 2, k = 1
Iteração 27:
i = 2, j = 2, k = 2
Número de repetições: 27
Ao analisarmos a saída do algoritmo, podemos perceber como funciona 
o aninhamento de comandos iterativos. Observe o valor da variável i, linha 
a linha — ela permanece com o mesmo valor da linha 1 até a linha 9. Isso 
ocorre porque, a cada execução do for da variável i, é executado o for da 
variável j, e, para cada repetição da variável j, é executado o for da variá-
vel k. De maneira similar, podemos perceber que os valores da variável j se 
repetem por três linhas, devido ao for da variável k. A variável k é a única 
que apresenta um valor diferente a cada linha, mas repete o padrão de 0, 1, 
2 por toda a execução.
A última linha do algoritmo traz como informação o número de repetições 
que o mesmo realizou.Esse número pode ser inferido matematicamente, por 
meio de uma simples equação: basta observar o número de iterações que cada 
for vai realizar e multiplicá-las. Assim, como todos os nossos comandos 
for utilizam a variável tam, que tem valor igual a 3, e temos três comandos 
aninhados, a nossa fórmula fica 3 × 3 × 3 = 27.
Basicamente, o que o exemplo ilustra é o padrão de repetição dos valores 
devido ao aninhamento dos comandos for. Com uma pequena alteração na 
maneira de imprimir os resultados, podemos ter outra visão do comportamento 
desse algoritmo, conforme mostra a Figura 5.
Nessa versão do algoritmo, realizamos a impressão das variáveis apenas 
na iteração em que o valor se modifica, de forma a facilitar a visualização de 
quando cada for está realizando uma nova iteração.
for
Até este momento, abordamos o tópico de comandos iterativos aninhados de 
um ponto de vista mais teórico: recapitulamos os comandos for e while, 
explicamos por que utilizamos comandos iterativos aninhados e visualizamos 
como se dá a execução desses comandos aninhados em um teste de mesa. 
A partir de agora, vamos demonstrar como alguns problemas “da vida real” 
são resolvidos com múltiplos comandos iterativos aninhados.
de execução de um programa. Quase todos os programas que conhecemos, 
após serem abertos (iniciados), encerram somente se clicamos no famoso × 
vermelho no canto superior direito da janela, ou se escolhemos a opção 
“Fechar” no menu “Arquivo”. 
Nosso primeiro exemplo (Figura 6) será um programa de entrada de da-
dos, no qual vamos inserir o nome e a idade dos 11 jogadores titulares dos 
times que estão nas quartas de final da Copa do Brasil. Esse programa não 
vai somente pedir o nome do time e, então, pedir o nome dos jogadores; ele 
terá um menu principal, em que o usuário poderá escolher se quer digitar os 
dados, salvar os dados em arquivo ou sair. Para isso, vamos utilizar, ao todo, 
três comandos iterativos aninhados.
Esse código usa um loop com comando iterativo while para controlar 
qual opção do menu foi selecionada. Todo o restante do programa está contido 
dentro desse loop. Caso o usuário selecione a opção 1, entramos em um novo 
loop com while, em que o critério de saída é que o usuário digite a pala-
vra fim. Caso não se digite a palavra fim, entraremos em uma sequência de 
11 leituras de nomes, que é armazenada em uma lista, por meio de um comando 
iterativo for.
Observe que utilizamos três níveis de aninhamento de comandos iterati-
vos para criar esse programa, que tem um controle de fluxo bem-definido. 
Agora, a partir desse simples exemplo, imagine que o seu editor de texto, sua 
planilha de cálculo, aquele jogo que você gosta, todos eles usam estruturas 
semelhantes para controlar seu funcionamento. Interessante, não? O que parecia 
um conceito simples e sem utilidade, de repente, está presente em todos os 
aplicativos que você usa.
O segundo exemplo também aborda uma atividade muito executada por 
desenvolvedores: geração de arquivos de dados baseados em informações 
coletadas da internet no formato JSON. O formato JSON (JavaScript Object 
Notation) é um formato aberto usado como alternativa ao XML, para a transfe-
rência de dados estruturados entre um servidor de Web e uma aplicação Web. 
Sua lógica de organização tem semelhanças com o XML (Extensible Markup 
Language), mas possui notação diferente. O formato ganhou popularidade em 
serviços da Web, como clientes de e-mail e sítios de compras, pois consegue 
transmitir uma grande quantidade de informações entre o cliente e o servidor, 
usando uma quantidade menor de caracteres. 
Para o nosso código de exemplo, utilizaremos um arquivo JSON que apre-
senta dados sobre filmes, como título, ano, identificador (imbdID), tipo e 
endereço da Web (link) que contém o pôster do filme, conforme mostra a 
Figura 7.
Para processar esse arquivo, extrair as informações nele contidas e trans-
formar em um arquivo no formato CSV (Comma-separated values), que pode 
ser aberto em planilhas, foi desenvolvido um programa em Python que utiliza 
três níveis de comandos iterativos aninhados for (Figura 8).
Esse código percorre os três níveis da estrutura de dados JSON, para 
chegar ao nível em que as informações dos filmes estão contidas. Então, 
transforma esses dados em uma linha de valores separados por vírgula, para, 
posteriormente, serem salvas como um arquivo no formato CSV, que pode 
ser aberto no Excel, por exemplo. Como saída, dados organizados podem ser 
facilmente visualizados (Figura 9). 
Esses casos são alguns dos muitos exemplos em que estruturas aninhadas 
são importantes para programação. Entretanto, devemos utilizar comandos 
aninhados com cautela, pois sempre devemos priorizar o código simples, a 
eficácia e a legibilidade, bem como implementar códigos que se utilizem das 
boas práticas de programação.
Algumas dessas boas práticas são descritas no Zen do Python, que consiste 
em 19 sugestões descritas por Tim Peters em 2004 e que ainda são ampla-
mente utilizadas para orientar programadores em Python, sendo encontradas, 
inclusive, na página oficial da linguagem (PETERS, 2004). Códigos baseados 
nessas sugestões são conhecidos como códigos pythonicos, e existe um grande 
incentivo da comunidade de desenvolvedores Python para que programadores 
adotem essas sugestões em seus códigos.