PENSAMENTO

COMPUTACIONAL

Patrícia Fernanda da Silva

Aplicações utilizando
comandos iterativos
aninhados (nível médio de
aninhamento — Python)
Objetivos de aprendizagem
Ao final deste texto, você deve apresentar os seguintes aprendizados:

„„ Discutir a utilização dos comandos iterativos for e while em es-

truturas aninhadas em problemas de nível intermediário.
„„ Desenvolver testes de mesa em programas que utilizem comandos
iterativos aninhados.
„„ Resolver problemas computacionais utilizando comandos iterativos
aninhados.

Introdução
Quando um problema computacional requer a manipulação de estru-
turas de dados compostas de várias dimensões, o programador pode
utilizar o recurso de aninhar comandos em múltiplos níveis para conseguir
endereçar o problema apropriadamente. Ao lidar com situações como
processamento de polígonos 3D em jogos, ou para processar estruturas
de dados que têm conteúdo hierárquico com múltiplos níveis, faz-se
necessário construir algoritmos que percorram todos os níveis/dimensões
da estrutura em questão para realizar cálculos ou extrair informação.
Neste capítulo, você vai estudar sobre o uso de comandos iterativos
aninhados. Você vai verificar como realizar testes de mesa em problemas
que utilizam comandos iterativos aninhados e, por fim, vai analisar a
aplicação desses comandos em problemas computacionais.
2 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python)

Os comandos iterativos for e 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.

O comando for
Usa-se o comando for quando é necessário executar uma tarefa mais de uma
vez, um número específico de vezes, tendo um início e um fim bem definidos,
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.

Figura 1. Apresentação geral da cláusula for.

Fonte: Melo (2019, p. 55).
 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python) 3

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.

Segundo Barry (2012), loops for em Python existem principalmente para processar
estruturas de dados, como listas de qualquer tamanho, e realizar outras iterações.
Por isso, quando você precisar percorrer uma lista, não esqueça de que você deve
utilizar o for.

O comando 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.
4 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python)

Figura 2. Apresentação geral da cláusula while.

Fonte: Melo (2019, p. 51).

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.

Tanto o comando while quanto o for suportam os comandos continue e break,

que alteram o fluxo do comando iterativo, ou seja, alteram a parada do laço de repetição
(iteração). O comando break finaliza toda a iteração, sendo que o restante do código
continua sua execução. Já o comando continue finaliza somente o laço que está
em execução naquele momento (um loop); ou seja, ele volta para o início da execução
da estrutura de repetição que está sendo executada.

Aninhamento dos comandos for e 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.
 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python) 5

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.

Figura 3. Código em Python para gerar duas matrizes e realizar a sua soma.

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.
6 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python)

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.

Uma forma de otimizar a execução de um código é utilizar list comprehension. Conforme

relata Cruz (2015), sua sintaxe mistura a declaração de uma lista com o comando for
dentro dela:

>>> numeros = [ i for i in range (5)]

>>> numeros
[0,1,2,3,4]

Podemos observar que o bloco que seria executado para cada valor de i virou uma
expressão, que é retornada o número de vezes que a expressão do for — nesse
caso, range (5) — retornar um elemento. Dessa forma, é possível criar uma lista
de números com apenas uma linha, ao contrário do exemplo apresentado no código
abaixo, que teria uma performance menor:

>>>numeros = []
>>> for i in range(5):
>>><tab>numeros.append(i)
 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python) 7

Testes de mesa com os comandos iterativos

aninhados
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.

Figura 4. Algoritmo de contagem de elementos em um conjunto de três for aninhados.

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
8 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python)

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
 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python) 9

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.
10 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python)

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.

Figura 5. Alternativa para imprimir o resultado.

 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python) 11

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.

No site Program Arcade Games With Python And Pygame, você pode conferir exemplos
e códigos animados para entender a execução de programas. Acesse o link a seguir
e acompanhe a criação de uma imagem em formato de diamante, feita a partir de
números e criada a partir de comandos iterativos for aninhados.

https://qrgo.page.link/8N8eb

Resolvendo problemas com comandos

iterativos aninhados
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.

Controlando o fluxo de execução de um programa

Muitas vezes, os comandos iterativos podem nos ajudar a controlar o fluxo
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”.
12 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python)

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.

Figura 6. Programa de entrada de dados para cadastro de jogadores.

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.
 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python) 13

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.

Figura 7. Arquivo JSON com dados a serem processados.

14 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python)

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).

Figura 8. Programa em Python para extrair dados de um arquivo JSON e salvar em um

arquivo no formato CSV.

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).
 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python) 15

Figura 9. Arquivo resultante do processamento do arquivo JSON.

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.
16 Aplicações utilizando comandos iterativos aninhados (nível médio de aninhamento — Python)

BARRY, P. Use a cabeça! Python. Rio de Janeiro: Alta Books, 2012. 492 p.
BORGES, L. E. Python para desenvolvedores. 2. ed. Rio de Janeiro: Edição do Autor, 2010.
360 p. Disponível em: https://ark4n.wordpress.com/python/. Acesso em: 24 jul. 2019.
CRUZ, F. Python: escreva seus primeiros programas. São Paulo: Casa do Código, 2015.
269 p.
MELO, W. IUP —­Introdução ao universo da programação com Python: um livro aberto para
aprender programação. Uberlândia: Faculdade de Computação, Universidade Federal
de Uberlândia, 2019. 139 p. Disponível em: http://www.facom.ufu.br/~wendelmelo/
meu_material/introducao_programacao_python_wendel_melo.pdf. Acesso em: 24
jul. 2019.
MUELLER, J.; MASSARON, L. Algoritmos para leigos. Rio de Janeiro: Alta Books, 2018. 432 p.
PETERS, T. PEP 20 -- The Zen of Python. Python Software Foundation, Wilmington, 2004.
Disponível em: https://www.python.org/dev/peps/pep-0020/. Acesso em: 24 jul. 2019.

Leituras recomendadas
CRAVEN, P. V. Program arcade games: with Python and Pygame. 4. ed. New York: Apress,
2016. 392 p. Disponível em: http://programarcadegames.com/. Acesso em: 24 jul. 2019.
MENEZES, N. N. C. Introdução à programação com Python: algoritmos e lógica de pro-
gramação para iniciantes. 3. ed. São Paulo: Novatec, 2019. 328 p.
SLATKIN, B. Python eficaz: 59 maneiras de programar melhor em Python. São Paulo:
Novatec, 2016. 296 p.