Lógica para Laços de Repetição

Os computadores servem para automatizar tarefas, principalmente, as repetitivas. Por exemplo, para
que você possa jogar um jogo 3D, a placa de vídeo do seu computador executa muitas tarefas
repetidas. Essas placas são equipamentos específicos para fazer tarefas repetitivas com elementos
visuais. Já uma tabela de suíte de escritório automatiza o processo repetitivo de anotar diversos dados.

Repetição é uma palavra chave aqui, então compreenda como isso pode se aplicar a programas que
você irá desenvolver em Python. Para começar a discussão, pense em um problema simples: você
deve implementar um programa que vai imprimir em tela os números 0, 1, 2, 3, 4, 5, 6 até o 99. Já
pensou em como desenvolver esse código? Descubra como fazer isso a seguir!

A partir do que você estudou até o momento, o único jeito possível de desenvolver esse programa é
escrever um código-fonte contendo 100 linhas, onde a primeira linha de código é responsável por
imprimir o número 0, a segunda linha o número 1 e assim por diante até a centésima linha imprimir o
número 99. Fazer isso seria cansativo e muito propenso a erros. Então, para facilitar esse processo,
você pode começar a fazer uso de laços de repetição nesse tipo de tarefa.

Laços ou estruturas de repetição são elementos de controle que possibilitam a execução de blocos de
código de forma repetida a partir de um teste lógico. Em outras palavras, a execução ou não de um
bloco de código depende do resultado desse teste. Você já deve saber, mas vale relembrar, que um
bloco é literalmente um trecho de código bem definido que executa uma sequência de operações. Em
Python definimos um bloco através da indentação do mesmo.

O primeiro tipo de laço de repetição que você irá conhecer é o enquanto-faça. Este laço de repetição
pode ser definido conforme o trecho a seguir, que está escrito em portugol, ou português estruturado,
apenas para que você possa entender o funcionamento desse tipo de laço:

Verificando cuidadosamente cada linha do trecho, você pode perceber que a linha 1 mostra a
definição do laço apresentado: enquanto a condição lógica for verdadeira, execute todas as operações
definidas no bloco a seguir, ou seja, aquelas operações listadas entre as linhas 2 e 4.

Mas como um fluxograma poderia representar essa sequência de operações para facilitar a
compreensão desse laço de repetição? O fluxograma para o laço de repetição enquanto-faça pode
ser representado pela imagem abaixo:
Figura 1 – Fluxograma do laço de repetição enquanto-faça

Perceba que, através do fluxograma, fica mais fácil entender como se dá o laço de repetição. Partindo
do bloco anterior ao laço, a execução do algoritmo chega ao teste da condição lógica. Caso ela seja
verdadeira, o bloco interno ao laço de repetição é executado, ou seja, todas as operações lá contidas
são executadas sequencialmente. Após a finalização desse bloco, o fluxo do programa retorna ao teste
da condição lógica. Se ela for novamente verdadeira, o bloco é executado. Se for falsa, aí o programa
segue para a execução do bloco posterior ao laço de repetição.

Agora que você entendeu mais profundamente o funcionamento do laço enquanto-faça, confira como
desenvolver o algoritmo para resolver o problema de escrever todos os números de 0 a 99.

Para isso, é preciso definir todos os elementos apresentados no fluxograma: o bloco anterior ao laço,
a condição lógica, o bloco interno ao laço e o bloco posterior ao laço. Para facilitar, você pode construir
uma variável chamada numero e o bloco interno ao laço deve conter o comando imprima(numero),
ou print(numero), e 1 operação soma e atribuição. Não se preocupe com a sintaxe Python, no
momento, preste atenção apenas à lógica de programação.

Partindo dessas dicas, você consegue completar os demais elementos para construir esse laço de
repetição? Reflita sobre esse problema e entenda como resolvê-lo a seguir!

Para completar o algoritmo, é necessário definir os demais elementos. Como foi dada a dica da
existência da variável numero, você pode utilizá-la como um contador. Um contador é uma variável
que vai controlar quantas vezes o laço de repetição será executado. Para que esse contador funcione,
defina seu valor inicial, a condição de incremento (aumento) ou de decremento (diminuição) desse
contador e a condição lógica que define se o laço ainda deve ser repetido.

No problema proposto, você precisará imprimir de 0 até 99, pulando de 1 em 1 (0, 1, 2, até 99). Assim,
é possível perceber que o contador deve ter seu valor inicial em 0, ou seja, no bloco anterior ao laço
você deve definir numero = 0. Como deseja “pular de 1 em 1”, é possível mapear que, depois de
imprimir um número, o valor da variável numero deve ser aumentado em 1, ou seja, numero += 1. Por
fim, se pergunte qual é a condição para que o programa continue imprimindo os valores de numero.
Nesse caso, a condição é que numero seja menor que 100, ou seja, numero < 100. Portanto,
conectando todos esses elementos, você terá pronto um algoritmo compacto para imprimir de 0 a 99
usando o laço de repetição enquanto-faça, conforme o trecho a seguir:
Nesse trecho, as linhas 1, 4 e 7 apresentam comentários definindo cada um dos blocos listados
anteriormente, os blocos anterior, interno e posterior ao laço. Além disso, na linha 3, foi definido o
laço enquanto-faça e apresentada a condição lógica que deve ser testada para que o laço seja
executado.

Agora você já pode começar a utilizar esse tipo de laço de repetição, o enquanto-faça. Descubra, a
seguir, qual é o próximo tipo de laço que o divertido mundo da lógica de programação te oferece.

O segundo tipo de laço de repetição que você conhecerá é o para-de-até. Este laço de repetição pode
ser definido conforme o trecho a seguir:

Agora que você já conhece o conceito de contador, é possível entender como esse laço funciona. De
forma bastante compacta, na linha 1, você define um contator e os valores de início e fim desse
contador e o laço automaticamente já define a operação de incremento (ou decremento) desse
contador. Assim, se você quiser utilizar o laço de repetição para-de-até para desenvolver o algoritmo
que imprime de 0 a 99, utilize o trecho a seguir:

Assim, na linha 1 do trecho do laço para-de-até, é indicado o contador e a sequência de valores para
que seja executado o bloco interno ao laço, no caso, a linha 2. Entenda que, apesar de mais compacto,
todos os elementos do bloco anterior ao laço, condição lógica, bloco interno ao laço e bloco posterior
ao laço estão presentes no para-de-até. Essa é uma constante em TODOS os laços de repetição.

Para esse problema que acabamos de resolver, o laço para-de-até é o mais adequado, mas não se
engane: existem situações em que ele é melhor e outras em que ele é pior. Por exemplo, esse laço é
mais adequado quando for preciso contadores, porém será mais indicado utilizar um laço do tipo
enquanto-faça caso a condição lógica que controla a repetição seja mais complexa que um
incremento ou decremento. Por isso, entender as características de cada laço de repetição vai lhe
ajudar a saber ainda mais quando utilizá-los da forma mais adequada possível.

O próximo laço de repetição que você conhecerá é o faça-até-que. Na imagem a seguir, analise,
primeiro, o fluxograma que representa esse tipo de laço:

Figura 2 – Fluxograma do laço faça-até-que

Novamente, a condição lógica e todos os 3 blocos estão presentes. Então, qual a diferença para os
demais laços de repetição? Aqui no faça-até-que, o bloco interno é executado primeiro e somente
após isso a condição lógica é testada. Se ela for verdadeira, o laço é terminado. Se ela for falsa, o laço
continua sua execução. Ou seja, o caminho tomado a partir do teste lógico é o contrário do laço
enquanto-faça. Entendido isso, fica fácil perceber como construir esse laço, conforme o trecho a
seguir:

Assim, novamente foi mapeado o bloco anterior ao laço, presente na linha 1, o bloco interno ao laço,
na linha 3, a condição lógica, na linha 4, e o bloco posterior ao laço que vem na linha 5. Você agora
pode estar se perguntando “Como posso usar o laço faça-até-que para imprimir de 0 a 99?”

Novamente foi usado um contador para controlar quantas vezes o laço se repete. Na linha 1
apresentamos o bloco anterior ao laço, que faz a inicialização do mesmo. Já no bloco interno ao laço,
as linhas 3 e 4, o valor de numero é impresso e depois o contador é incrementado. Por fim, na linha
5, a condição lógica é testada. Caso numero seja igual a 100, a condição numero == 100 se torna
verdadeira e assim o laço é interrompido, seguindo para o bloco posterior ao laço, apresentado na
linha 6.

Aqui é importante você comparar a condição lógica numero < 100 do laço enquanto-faça e a condição
lógica numero == 100 do laço faça-até-que. Elas são diferentes pois cada um dos laços tem um
comportamento também diferente. Enquanto o enquanto-faça repete mais uma vez o bloco interno
quando a condição é verdadeira, o faça-até-que repete mais uma vez o bloco interno quando a
condição é falsa.

Para conhecer o laço de repetição para-cada-em, é necessário compreender primeiro o conceito de

coleção. Uma coleção é uma estrutura que armazena itens quaisquer. Por exemplo, um chaveiro
armazena a coleção de todas as chaves que você tem. Uma carteira armazena a coleção de todas as
cédulas de dinheiro que você possui. Dessa forma, o laço para-cada-em funciona conforme o código
apresentado abaixo:

Esse laço de repetição faz com que a variável elemento receba um item da coleção conjunto e execute
o bloco interno ao laço, depois receba o próximo item da coleção e execute novamente o bloco interno
ao laço, repetindo isso até que todos os itens da coleção tenham sido atribuídos uma única vez a
elemento.

Mas você ainda não sabe como representar uma coleção, portanto guarde na memória a descrição do
laço para-cada-em e espere um pouco mais para entender como representar coleções, pois você
poderá conferir isso em um tópico mais à frente. Depois de entender isso, aí sim você poderá fazer
algoritmos com ele!

Primeiro, lembre que laços de repetição sempre têm 4 elementos:

• bloco anterior ao laço;

• condição lógica;
• bloco interno ao laço; e
• bloco posterior ao laço.

Cada tipo de laço de repetição se diferencia em como conectar esses elementos e como avaliar a
condição lógica. Os laços enquanto-faça, para-de-até e faça-até-que são os mais comuns, mas ainda
existem o faça-enquanto e o até-que-faça. As linguagens de programação decidem quais deles
implementar, seguindo a sua filosofia - lembre-se que para Python existe o Zen of Python. Assim, vale
pesquisar as diferentes Estruturas de Controle apresentadas na Wikipedia através deste link. Se o
inglês estiver afiado, a versão nessa língua é muito boa. Para conferir, basta acessar o link Wikipedia
em inglês.

Sintaxe dos Laços de Repetição em Python

Agora você sabe como construir e representar os diferentes tipos de laços de repetição, entenda como
implementá-los em Python. Nem todos os tipos de laços de repetição estudados anteriormente são
possíveis de ser escritos em Python. Essa é uma decisão sua e da linguagem. Como programador, você
precisa adaptar seus algoritmos para serem escritos conforme a linguagem define.
O primeiro tipo de laço de repetição existente em Python que você estudará é o enquanto-faça. Já
deve ter notado que muitas das palavras reservadas de Python são traduções dos termos de lógica de
programação para o inglês. Por isso, a tradução de enquanto é while e ela é a palavra que define este
bloco, conforme apresentado a seguir:

Dessa forma, na linha 1, você só precisa escrever a palavra reservada while e a condição lógica do
laço. Assim como foi feito com os desvios condicionais, utilize os dois pontos (:) e a indentação à direita
para definir o bloco interno ao laço. Ah, e na linha 3 você também pode ler a palavra reservada pass,
que, como diz o comentário, é uma palavra que não faz nada. Ela está lá simplesmente para não deixar
o bloco vazio, visto que não podem existir blocos vazios em Python. Se você tentar construir um bloco
vazio, seu programa não será interpretado corretamente e o interpretador Python irá lhe informar
sobre o problema.

Então, você pode sofisticar um pouco os problemas discutidos e começar a implementar laços de
repetição em Python. Pense em um programa Python que lê um valor numérico digitado pelo usuário
e imprima esse valor em tela, repetindo esse processo enquanto o valor digitado for par, ou seja, o
laço de repetição é finalizado caso o usuário digite um valor ímpar. É possível resolver o problema com
um laço while. Reflita um pouco sobre esse problema e, após isso, siga para a próxima página e
entenda melhor sua resolução.

Para resolver o problema proposto, você pode construir o seguinte trecho de código:

Perceba que agora está sendo implementando o algoritmo em Python, mas nada mudou na lógica de
programação: continuamos tendo todos os 4 elementos vitais de um laço de repetição presentes! Na
linha 1, ainda no bloco anterior ao laço, é pedido que o usuário digite um número qualquer via teclado
e o valor digitado é convertido para inteiro e armazenado na variável numero. Já na linha 2, temos a
definição do laço de repetição e a condição lógica numero % 2 == 0. Você consegue compreender essa
expressão?

Ela testa se o valor do resto da divisão da variável numero por 2 é igual a 0, ou seja, testa se um
número é par ou ímpar. O número é par quando o valor do resto é 0, e ímpar quando o valor é 1.

Após isso, nas linhas 3 e 4, há o bloco interno ao laço e nele há dois comandos apenas, um na linha 3,
que apresenta ao usuário uma mensagem, e na linha 4 onde é feita a mesma leitura também definida
na linha 1, para que o valor armazenado em numero possa ser atualizado e o novo número digitado
possa ser avaliado pela condição lógica, que é testada novamente depois da execução desses dois
comandos.

Por fim, já fora do laço de repetição, há um comando na linha 5 para apresentar ao usuário uma
mensagem informando que, como o usuário digitou um número ímpar, o laço de repetição parou de
ser executado e o programa vai seguir sua execução. Tudo certo até aqui? Caso ainda tenha dúvidas,
leia novamente a explicação com calma relacionando-a com cada parte do código apresentado.

Será que pode dar algo errado na execução desse trecho de código? Siga para conferir o que pode dar
errado nessa estrutura.

O segundo tipo de laço de repetição implementado em Python que você irá estudar é o para-cada-
em, cuja sintaxe é idêntica ao para-de-até, por isso você será apresentado aos dois em conjunto.
Ambos utilizam a tradução de para, que é for em inglês, e são construídos conforme sintaxe a seguir:

Para esse laço, há duas palavras reservadas, for e in, que é a tradução de “em” na língua portuguesa.
Logo de cara, você pode perceber que a sintaxe Python está mais parecida com para-cada-em do que
com para-de-até. Então, entenda primeiro o para-cada-em e depois saiba como usar a mesma
estrutura para implementar um para-de-até.

Dessa forma, é preciso definir como representar uma coleção em Python. Comece pela coleção mais
comum de Python, a lista. Você conhecerá a lista de forma muito profunda mais à frente. Entretanto,
agora basta que você entenda uma lista como sendo uma coleção de valores ou variáveis separados
através de vírgulas (,) e inscritos em um par de colchetes, assim como o trecho a seguir:

Nesse exemplo, foi atribuído à variável frutas_em_promocao uma lista contendo as strings "banana",
"maçã", "laranja", "acerola", respectivamente. Digamos então que você é dono de um supermercado
e deve fazer um programa para apresentar todas as frutas em promoção. Pense em um código Python
que faça isso utilizando a coleção frutas_em_promocao e o laço for. Entenda como resolver isso, a
seguir.

Agora que você sabe como mapear o para-cada-em facilmente para o for do Python, fica bem mais
tranquilo desenvolver o que foi pedido anteriormente, conforme o código abaixo:

Bonito, não é mesmo? Na linha 1 atribuímos a lista à variável frutas_em_promocao, depois definimos
o laço for, fazendo com que seja atribuído à variável fruta cada um dos valores na lista. Assim, o
resultado da execução desse trecho é apresentado a seguir:
Hoje a fruta banana está em promoção! Aproveite!

Hoje a fruta maçã está em promoção! Aproveite!

Hoje a fruta laranja está em promoção! Aproveite!

Hoje a fruta acerola está em promoção! Aproveite!

Dessa forma, é perceptível que o laço for consegue implementar o para-cada-em de forma muito
natural. Na sequência, descubra como adaptar isso para o para-de-até.

Como discutido anteriormente, normalmente utilizamos o para-de-até quando queremos fazer uso
de um contador. Em Python, quando você precisar utilizar um contador, deverá fazer a chamada da
função range(). Esta função recebe como parâmetro um valor numérico e constrói uma lista que vai
de 0 até o número passado menos 1. Assim, se você escrever range(5), será criada uma lista contendo
os valores de 0 a 4, ou seja, [0, 1, 2 , 3, 4]. Logo, caso você execute o seguinte trecho,

que contém o laço for e um comando print apenas no bloco interno ao laço, o resultado gerado será:

O valor de x nesta iteração é: 0

O valor de x nesta iteração é: 1

O valor de x nesta iteração é: 2

O valor de x nesta iteração é: 3

O valor de x nesta iteração é: 4

Porque range(5) criou a lista [0, 1, 2 , 3, 4] e cada um dos itens existentes nessa lista foi atribuído a x
uma única vez e em sequência. Esse é o modo básico de utilização da função range() dentro de um
laço for em Python.

Conhecer profundamente cada um dos elementos de uma linguagem de programação é um passo

importante para você ter facilidade ao expressar suas ideias nessa linguagem. Por isso, saiba mais
sobre como adaptar a chamada de range() para suas necessidades. Quando você passar apenas um
parâmetro, tal como em range(n), será criada uma lista contendo 0 até o n - 1. Já quando passar dois
parâmetros, como em range(inicio, fim), será gerada uma lista com valores de inicio até fim - 1. Assim,
se você chamar o comando range(2, 10), será gerada a lista [2, 3, 4, 5, 6, 7, 8, 9].

Também é possível ter três parâmetros, tal como range(inicio, fim, intervalo), que gera uma lista
partindo de inicio até o mais próximo possível de fim com incrementos ou decrementos de intervalo
em intervalo. Assim, o comando range(2, 10, 2) gera a lista [2, 4, 6, 8], ou seja, de 2 até o mais próximo
de 10 (sem chegar a 10), incrementando o valor de 2 em 2. Por fim, se você utilizar um intervalo
negativo, pode construir uma sequência em que “inicio > fim”. Então, range(10, 2, -1) gera a lista [10,
9, 8, 7, 6, 5, 4, 3]. Lembre-se de que o range(n) nunca chega até o exato valor de fim, pois ele fica
sempre o mais próximo possível. Ah, e ele também só funciona com parâmetros do tipo int!
A utilização de range() pode ocorrer de forma bem mais profunda do que aqui apresentado, por
exemplo, você pode utilizá-la com intervalos de incremento diferentes de 1 e pode utilizá-la para
decrementos também. O post “A função range() do Python”, no site excript.com explica e apresenta
muitas dessas possibilidades! Você pode acessar o link caso tenha interesse em aprofundar seus
conhecimentos sobre o assunto.

Normalmente, os laços for e while são utilizados em cenários diferentes.

• Primeiro, os laços do tipo for são mais adequados quando existe um conjunto fixo ou pré-
definido de valores que serão atribuídos a uma variável.
• Já os laços do tipo while são mais adequados quando não há no programa nenhuma
informação prévia acerca de quantas vezes o laço deverá ser executado, ou seja, o número de
vezes que ele será executado depende da condição lógica testada.

Essa diferença é importante e vale a pena entendê-la desde já para que você utilize esses dois tipos
de laço de repetição de forma correta.

Python implementa os laços for e while, mas implementa o conceito de list comprehension
(traduzindo para o português, compreensão de lista), que é o processo de criar uma lista a partir de
outra lista. Para isso, você tem que iterar todos os elementos de uma lista inicial usando os conceitos
de laços de repetição dentro da estrutura de uma lista. Interessante, não acha?

Agora que você compreendeu a lógica de programação para laços de repetição e a sintaxe dos laços
de repetição em Python, já é possível exercitar sua utilização em diferentes cenários e identificar
elementos acessórios que aumentam as possibilidades de uso desses laços. Você pode, por exemplo,
executar apenas um pedaço de um bloco dentro de um laço de repetição ou parar um laço antes que
todos os valores inicialmente previstos sejam visitados. Entenda melhor esses cenários a seguir.

Suponha que seu programa é responsável por uma pesquisa de opinião. Existem N pessoas em uma
sala e você vai perguntar para cada uma delas se elas já visitaram o “Novo Shopping”, um shopping
que foi feito pela sua construtora. Caso a pessoa já tenha visitado, você precisa saber se ela gostou da
visita ou não. É preciso algumas linhas de código para resolver isso em Python. Acompanhe, a seguir,
o código apresentado e observe como ele resolve o problema. Mas perceba que há um elemento
novo, a palavra continue. Examine o trecho abaixo por completo:
A palavra continue define que a iteração atual do laço deve parar, passando para a próxima. Por
exemplo, se a 1ª pessoa responder o questionário informando que não visitou o “Novo Shopping”,
não há nenhuma pergunta extra e o código segue para questionar a 2ª pessoa. Assim, o trecho em
que “continue” aparece, localizado nas linhas 7 e 8 do código apresentado anteriormente, é:

Ou seja, deve-se entender esse trecho como, “se o usuário respondeu negativamente, passe para a
próxima pessoa na sala”.

O resto do código é simples de entender, as variáveis “foram” e “gostaram” armazenam o número de

pessoas que foram e gostaram da visita ao “Novo Shopping” respectivamente e todos os demais
comandos já foram discutidos anteriormente.

Conforme o que foi apresentado, o “continue” interrompe a iteração, mas mantém o funcionamento
do laço. Agora se você quiser que, ao haver uma condição qualquer, não só a iteração seja
interrompida, como fazer com que o laço todo pare de executar? Bom, nesse caso, você pode utilizar
a palavra reservada “break”, pois ela interrompe um laço de repetição mesmo que a condição do laço
ainda seja verdadeira. Analise, por exemplo, o trecho a seguir:
O comando print ocorre apenas 5 vezes. Você pensou em uma resposta diferente? Não se preocupe,
pois você vai entender melhor essa resposta. Ele ocorre 5 vezes porque dentro do bloco definido pelo
laço while há um teste lógico “contador == 5”. Assim, quando teste é verdadeiro, o comando break é
executado e o laço de repetição para de ser executado, mesmo com a condição “contador < 11”, que
controla o laço de repetição ainda sendo válida.

Dessa forma, o comando print ocorre apenas 5 vezes e o resultado final da execução do bloco é o
seguinte:

Esses exemplos apresentam o funcionamento dos comandos continue e break. Tais comandos são
bastante comuns e você vai, provavelmente, utilizá-los com bastante frequência em seus códigos.

Bom, dando continuidade, chegou o momento de você conhecer um novo comando muito utilizado
em Python. Existe alguma outra variação relacionada ao laço for que deva ser discutida?

Normalmente, Python sempre nos dá uma solução elegante para executarmos algo quando uma
condição é satisfeita. Descubra mais sobre o que pode fazer quando um laço de repetição é terminado.

Python também define um bloco que deve ser executado quando um laço de repetição termina. Esse
bloco é definido pela palavra “else”. Sim, é a mesma palavra utilizada no desvio condicional, mas ela
tem outro sentido quando utilizada após um laço de repetição. Essa variação faz com que fique
explícito no seu código o que é executado após o fim de um laço de repetição, deixando bem claro a
quem for ler, o que faz parte dessa finalização do laço e o que é apenas código, que por um acaso está
após o laço. Descubra mais sobre estrutura de repetição While em Python no site excript.com.
Até aqui, você aprendeu a lógica de programação para diferentes tipos de laços de repetição e a
sintaxe daqueles laços de repetição implementados em Python. Foram discutidos os laços do tipo for
e while, além dos cenários onde cada um deles é mais adequado.

No mais, você descobriu outros mecanismos que modificam o funcionamento padrão dos laços de
repetição, como os comandos continue e break, entendendo também possíveis cenários para suas
aplicações. Por fim, compreendeu as diversas variações do comando range(), importantes para que
você possa aplicar cada uma delas corretamente em seus códigos.

Laços de repetição são elementos básicos em qualquer linguagem de programação e saber utilizá-los
é muito importante para seus estudos. Então, aprofunde seus conhecimentos no assunto revisando
todo o conteúdo abordado, resolvendo os exercícios propostos e pesquisando ainda mais sobre o
tema. Você vai encontrar laços em qualquer programa que for utilizar ou desenvolver no futuro. Logo,
entender todas as pequenas variações e possibilidades que os diferentes laços possuem vão te ajudar
bastante a se tornar um bom desenvolvedor Python!

Referências
• https://www.w3schools.com/python/python_while_loops.asp - Acessado em maio/2020
• https://www.w3schools.com/python/python_for_loops.asp - Acessado em maio/2020
• https://pt.wikipedia.org/wiki/Estrutura_de_repeti%C3%A7%C3%A3o - Acessado em
maio/2021
• https://en.wikipedia.org/wiki/Control_flow#Loops - Acessado em maio/2021
• http://excript.com/python/funcao-range-python.html - Acessado em maio/2021
• https://www.w3schools.com/python/ref_func_range.asp - Acessado em mai