For e While em Python: Loops e Estruturas de Repetição

✅ Artigo atualizado em Setembro 2026 Novas seções sobre for i in range (como percorrer de 1 a 5), do while, loops aninhados, erros comuns com traceback e 8 exercícios resolvidos.

1
2
3
4
5
6
7

for i in range(1, 6):
    print(i)  # 1, 2, 3, 4, 5 (um por linha)

contador = 3
while contador > 0:
    print(contador)  # 3, 2, 1
    contador -= 1

Salve salve Pythonista!

Nesse post vamos falar sobre as famosas Estruturas de Repetição (ou loops) do Python: for, while, for com else, for com range(), break, continue, enumerate(), loops aninhados e muito mais!

Loops são blocos básicos de qualquer linguagem de programação e aparecem no dia a dia do verdadeiro Pythonista o tempo todo: processar listas, ler arquivos, validar entradas. No final, você ainda encontra os erros mais comuns e exercícios resolvidos para fixar.

Então… Bora pro post!

Vá Direto ao Assunto…

• Introdução
• Loops utilizando for
• Loops utilizando while
• Auxiliadores
• Existe do while em Python?
• A função range()
• for i in range em Python: como percorrer de 1 a 5
• Função enumerate()
• Loops aninhados em Python (for dentro de for)
• for vs while
• Erros comuns
• Exercícios resolvidos

Introdução

O que são estruturas de repetição (loops) em Python? Estruturas de repetição, ou loops, são recursos da linguagem que executam um mesmo bloco de código várias vezes, sem que você precise reescrevê-lo. O Python tem dois tipos: o for, que percorre item a item um iterável (lista, string, range()), e o while, que repete enquanto uma condição for verdadeira. São a base de tarefas como processar listas, ler arquivos e validar entradas.

As estruturas de repetição são recursos das linguagens de programação responsáveis por executar um bloco de código repetidamente através de determinadas condições específicas.

O Python contém dois tipos de estruturas de repetição: for e while. Este é o nosso guia-pilar sobre o assunto: se você quiser se aprofundar, temos posts dedicados a loops com while e à função range().

Vamos ver ambos nesse post!

Loops utilizando for

O for em Python percorre um iterável (lista, tupla, string, dicionário) e executa um bloco de código uma vez para cada item dele. Use-o quando quiser passar por todos os elementos de uma sequência. A referência oficial está no tutorial do Python sobre o comando for, e temos um post dedicado com mais exemplos de loops com for no Python.

Vamos iniciar pelos detalhes das estruturas de repetição, ou melhor dizendo, os loops utilizando o for.

O for é utilizado para percorrer ou iterar sobre uma sequência de dados (seja esse uma lista, uma tupla, uma string), executando um conjunto de instruções em cada item.

Como você já sabe, o Python utiliza indentação para separar blocos de código: nos loops utilizando for não é diferente.

Sua sintaxe básica é: for <nome variável> in <iterável>. Vamos entender:

• <nome variável> é o nome da variável que vai receber os elementos de <iterável>.
• <iterável> é o container de dados sobre o qual vamos iterar, podendo ser: uma lista, uma tupla, uma string, um dicionário, entre outros.

Vamos ver um exemplo, para facilitar nossa vida!

1
2
3
4

lista = [1, 2, 3, 4, 5]

for item in lista:
    print(item)

Vamos entender passo a passo:

• Na primeira iteração, item vai receber o valor do primeiro elemento da lista lista, que é 1. Portanto print(item) vai mostrar o valor 1.
• Na segunda iteração, item vai receber o valor do segundo elemento da lista lista, que é 2. Portanto print(item) vai mostrar o valor 2.
• E assim por diante até o último valor, que é 5 (você já entendeu )

Existe outra forma de se utilizar o for que é utilizando a estrutura for/else.

Adicionar o else ao final do for nos possibilita executar um bloco de código após o iterável ter sido completamente percorrido.

Vamos ao exemplo!

1
2
3
4
5
6

sequencia = ['a', 'b', 'c']

for item in sequencia:
    print(item)
else:
    print('Todos os items foram exibidos com sucesso')

Saída:

1
2
3
4

a
b
c
Todos os items foram exibidos com sucesso

Atenção a um detalhe que cai muito em prova: se o loop for interrompido por um break (que veremos mais abaixo), o bloco else não é executado. Ele só roda quando o for termina de percorrer tudo normalmente.

Exemplos de loops com for

Agora vamos ver alguns exemplo de como podemos percorrer tipos de dados diferentes utilizando o for.

Para iterar sobre Listas e imprimir cada item da lista:

1
2
3
4

computador = ['Processador', 'Teclado', 'Mouse']

for item in computador:
    print(item)

A saída será:

1
2
3

Processador
Teclado
Mouse

Quer saber TUDO sobre Listas e DOMINAR essa estrutura de dado tão importante do Python? Então já clica aqui e deixa esse post completo sobre Listas na espera!

Podemos também percorrer os dicionários do Python (que são uma estrutura de dados muito importante).

Para isso, podemos fazer da seguinte maneira:

1
2
3
4
5
6
7
8
9

notas = {
    'Português': 7,
    'Matemática': 9,
    'Lógica': 7,
    'Algoritmo': 7
}

for chave, valor in notas.items():
    print(f"{chave}: {valor}")

O resultado será:

1
2
3
4

Português: 7
Matemática: 9
Lógica: 7
Algoritmo: 7

Quer ficar craque TAMBÉM em Dicionários e saber TUDO? Então também deixa de lado esse post completo sobre os Dicionários do Python

Também podemos percorrer strings, pois elas também são um tipo iterável:

1
2

for caractere in 'Python':
    print(caractere)

O Python vai dividir a string 'Python' nos caracteres que a compõem e o resultado do loop for será o seguinte:

1
2
3
4
5
6

P
y
t
h
o
n

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Loops utilizando while

O while repete um bloco de código enquanto uma condição for verdadeira, parando assim que ela se torna falsa. Use-o quando não sabe de antemão quantas iterações vai precisar. Para um mergulho mais fundo, veja nosso post sobre loops com while no Python e a referência oficial do comando while.

O while é uma estrutura de repetição utilizada quando queremos que determinado bloco de código seja executado ENQUANTO (do inglês while) determinada condição for satisfeita.

Em outras palavras: só saia da estrutura de repetição quando a condição não for mais satisfeita.

Sua sintaxe básica é:

1
2

while <condição>:
    # Bloco a ser executado

Aqui, <condição> é uma expressão que pode ser reduzida à True ou False, podendo ser:

• A verificação do valor de uma variável;
• Determinada estrutura de dados alcançar um tamanho;
• O retorno de uma função se igualar a determinado valor;
• Algum valor externo ser alterado (por exemplo um valor armazenado em Banco de Dados).

Vamos entender melhor com um exemplo:

1
2
3
4
5

contador = 0

while contador < 10:
    print(f'Valor do contador é {contador}')
    contador += 1

Não entendeu essa notação no print print(f'Valor do contador é {contador}')? Essas são as chamadas f-strings e são formas muito Pythônicas de se formatar strings no Python! Quer saber mais, então adivinha… Claro que sim! Clique aqui para acessar nosso post completo sobre f-strings.

Resultando em:

1
2
3
4
5
6
7
8
9
10

Valor do contador é 0
Valor do contador é 1
Valor do contador é 2
Valor do contador é 3
Valor do contador é 4
Valor do contador é 5
Valor do contador é 6
Valor do contador é 7
Valor do contador é 8
Valor do contador é 9

Repare que a impressão começa em 0: como o print() vem antes do contador += 1, o valor exibido é sempre o de antes do incremento.

Ou seja, a variável contador está sendo incrementada a cada vez que o while executa seu código.

Quando ele alcançar o valor 10, a condição contador < 10 não será mais satisfeita, finalizando o bloco while!

Assim como no for, podemos utilizar o else também nos loops while.

Vamos usar o mesmo código do exemplo acima para você entender a diferença:

1
2
3
4
5
6
7

contador = 0

while contador < 10:
    contador += 1
    print(f'Valor do contador é {contador}')
else:
    print(f'Fim do while e o valor do contador é {contador}')

O que resultará em:

1
2
3
4
5
6
7
8
9
10
11

Valor do contador é 1
Valor do contador é 2
Valor do contador é 3
Valor do contador é 4
Valor do contador é 5
Valor do contador é 6
Valor do contador é 7
Valor do contador é 8
Valor do contador é 9
Valor do contador é 10
Fim do while e o valor do contador é 10

Estou desenvolvendo o Ebookr.ai, uma plataforma que transforma suas ideias em ebooks profissionais usando IA - com geração de capa, infográficos e exportação em PDF. Te convido a conhecer!

Auxiliadores

Para alterar o fluxo de um loop, o Python oferece três comandos: break para encerrar o loop, continue para pular para a próxima iteração e pass para não fazer nada. Eles funcionam normalmente tanto em for quanto em while.

Existem 3 comandos que nos auxiliam quando queremos alterar o fluxo de uma estrutura de repetição.

São eles: break, continue e pass.

Todos os três funcionam normalmente tanto com for quanto com while - não há nenhuma restrição. A tabela abaixo resume o que cada um faz:

Auxiliador break

É usado para finalizar um loop, isto é, é usado para parar sua execução.

Geralmente vem acompanhado de alguma condição para isso, com um if (se precisar revisar, veja nosso post sobre estruturas condicionais if, elif e else). A documentação oficial descreve o comportamento em break e continue.

Veja um exemplo:

1
2
3
4
5
6
7

for num in range(10):
    # Se o número for igual a = 5, devemos parar o loop
    if num == 5:
        # Break faz o loop finalizar
        break
    else:
        print(num)

Saída do código acima:

1
2
3
4
5

0
1
2
3
4

Percebeu que o loop não chegou ao final?! Para isso utilizamos o break!

Já com while, também podemos utilizar o break em uma condição utilizando if, assim:

1
2
3
4
5
6
7
8

num = 0
while num < 5:
    num += 1

    if num == 3:
        break

    print(num)

Quando num recebe o valor 3, o if dispara o break antes do print(num), encerrando o loop. Por isso o 3 nunca chega a ser impresso. Resultando em:

1
2

1
2

Auxiliador continue

Funciona de maneira similar ao break, contudo ao invés de encerrar o loop ele pula todo código que estiver abaixo dele (dentro do loop) partindo para a próxima iteração.

Vamos ao exemplo:

1
2
3
4
5
6
7
8
9

for num in range(5):
    if num == 3:
        print("Encontrei o 3")
        # Executa o continue, pulando para o próximo laço
        continue
    else:
        print(num)

    print("Estou abaixo do IF")

Repare na saída abaixo. Repare que quando a condição num == 3 for satisfeita, a string "Estou abaixo do IF" não será exibida:

1
2
3
4
5
6
7
8
9

0
Estou abaixo do IF
1
Estou abaixo do IF
2
Estou abaixo do IF
Encontrei o 3
4
Estou abaixo do IF

Em loops com while a lógica é a mesma. O continue irá finalizar o loop atual, iniciando novamente no início do while.

Veja o exemplo:

1
2
3
4
5
6
7
8

num = 0
while num < 5:
    num += 1

    if num == 3:
        continue

    print(num)

O resultado desse código é que o 3 não apareça, pois o print() que imprime os números está abaixo do continue.

Portanto a saída será:

1
2
3
4

1
2
4
5

Auxiliador pass

O pass nada mais é que uma forma de fazer um código que não realiza operação nenhuma.

Tipo o Magikarp do Pokemon

Mas calma, ele tem uma razão de existir no Python!

Como os escopos de Classes, Funções, If/Else e loops for/while são definidos pela indentação do código (e não por chaves {} como geralmente se vê em outras linguagens de programação), usamos o pass para dizer ao Python que o bloco de código está vazio.

Veja alguns exemplos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

for item in range(5000):
    pass

while False:
    pass

class Classe:
    pass

if True:
    pass
else:
    pass

def funcao():
    pass

Caso não utilizemos o pass, veja o que acontece:

1
2
3
4

class Classe:

def funcao():
    pass

1
2
3

  File "main.py", line 3
    def funcao():
IndentationError: expected an indented block after class definition on line 1

Isso acontece pois o Python entende que as próximas linhas de código fazem parte do mesmo escopo, mas como não estão indentadas um erro IndentationError é lançado.

Existe do while em Python?

Não. O Python não tem o comando do while que existe em C, Java e JavaScript (aquele que executa o bloco pelo menos uma vez e só depois testa a condição). A proposta de adicionar algo parecido à linguagem, a PEP 315, foi rejeitada.

O equivalente Pythônico é um while True com a condição de saída no final do bloco, usando break:

1
2
3
4
5
6
7

while True:
    numero = int(input("Digite um número positivo: "))
    if numero > 0:
        break
    print("Número inválido, tente de novo.")

print(f"Você digitou {numero}")

Digitando -3, depois 0 e depois 7, a execução fica assim:

1
2
3
4
5
6

Digite um número positivo: -3
Número inválido, tente de novo.
Digite um número positivo: 0
Número inválido, tente de novo.
Digite um número positivo: 7
Você digitou 7

Repare que o input() roda antes de qualquer teste, exatamente como no do while: o bloco sempre executa pelo menos uma vez. Esse padrão é o mais usado para validar entrada do usuário (veja mais sobre input() e print() no Python).

A função range()

A função range() gera uma sequência de números inteiros sob demanda, perfeita para controlar quantas vezes um for vai rodar. Você define início, passo e fim, e o Python entrega os números um a um.

A função range é de grande ajuda quando o tema é repetição, laços, for etc…

Ela gera uma sequência de números pela qual podemos iterar!

Com ela, conseguimos especificar:

• O início de uma sequência;
• O passo (ou pulo); e
• O valor final da sequência.

Com isso o Python nos entrega uma sequência de números para utilizarmos!

De tão importante que é, temos um post COMPLETO sobre essa função tão importante na vida do verdadeiro Pythonista!

Então já clica aqui e acessa nosso post sobre a função range agora mesmo!

for i in range em Python: como percorrer de 1 a 5

for i in range(...) é a forma mais comum de repetir um bloco um número fixo de vezes. A regra de ouro: o range() inclui o início e exclui o fim. Por isso, para percorrer os números de 1 a 5, a sintaxe correta é range(1, 6):

1
2

for i in range(1, 6):
    print(i)

Saída:

1
2
3
4
5

1
2
3
4
5

O range() aceita até três argumentos: range(fim), range(início, fim) e range(início, fim, passo). Veja o que cada chamada gera (detalhes na documentação oficial de range):

Questão clássica de prova: “Pensando no laço for que percorre os números de 1 a 5, qual sintaxe está correta?” A resposta é for i in range(1, 6):. As alternativas range(5) e range(0, 5) começam em 0, e range(1, 5) para no 4. Resolvemos essa questão passo a passo nos exercícios no fim do post.

O nome i é só uma convenção (vem de “índice”). Você pode usar qualquer nome, e quando não vai usar o valor dentro do loop, a convenção é _: for _ in range(3):.

Loops bem escritos são a base de praticamente todo programa Python. Se quiser sair da teoria e aplicar isso em exercícios e projetos reais, dá uma olhada na Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Função enumerate()

A função enumerate() é a forma Pythônica de obter o índice e o valor de cada item ao mesmo tempo dentro de um for, sem precisar de um contador manual. É a opção recomendada sempre que você precisa do índice junto com o elemento.

Uma dica bem bacana para se usar com o for, é a função enumerate().

Ela nos entrega um contador embutido no próprio for!

Ao invés de fazer isso:

1
2
3
4
5
6

contador = 0
computador = ['Processador', 'Teclado', 'Mouse']

for elemento in computador:
    print(f"Índice={contador} | Valor={elemento}")
    contador += 1

Jogue esse contador fora e faça isso:

1
2
3

computador = ['Processador', 'Teclado', 'Mouse']
for indice, valor in enumerate(computador):
    print(f"Índice={indice} | Valor={valor}")

Saída:

1
2
3

Índice=0 | Valor=Processador
Índice=1 | Valor=Teclado
Índice=2 | Valor=Mouse

Esse código é o que chamamos de Pythônico (que segue as melhores práticas da linguagem)!

Você ainda vai encontrar muito código que itera pelos índices combinando range() e len().

A função len() retorna o tamanho de um iterável (lista, tupla, set), e range(len(...)) gera os índices de 0 ao tamanho menos 1:

1
2
3

computador = ['Processador', 'Teclado', 'Mouse']
for indice in range(len(computador)):
    print(f"Índice={indice} | valor={computador[indice]}")

A saída é a mesma:

1
2
3

Índice=0 | valor=Processador
Índice=1 | valor=Teclado
Índice=2 | valor=Mouse

⚠️ Antipadrão: quando você precisa do índice e do valor, prefira enumerate(). Usar range(len(lista)) só para depois acessar lista[indice] é mais verboso, mais sujeito a erros e menos legível. Reserve range(len(...)) para os poucos casos em que você realmente só quer os índices (por exemplo, ao percorrer duas listas em paralelo pela posição).

Loops aninhados em Python (for dentro de for)

Um loop aninhado é um loop dentro de outro: para cada iteração do loop de fora, o loop de dentro roda inteiro. É assim que se percorre tabelas, matrizes e combinações:

1
2
3

for linha in range(1, 3):
    for coluna in range(1, 4):
        print(f"{linha} x {coluna} = {linha * coluna}")

Saída:

1
2
3
4
5
6

1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6

O loop de fora roda 2 vezes e o de dentro roda 3 vezes para cada uma delas: 2 x 3 = 6 execuções do print().

Um detalhe importante: o break só encerra o loop mais interno em que ele está. O de fora continua:

1
2
3
4
5

for i in range(3):
    for j in range(3):
        if j == 1:
            break
        print(f"i={i}, j={j}")

Saída:

1
2
3

i=0, j=0
i=1, j=0
i=2, j=0

Quando o loop aninhado só serve para montar uma nova lista, muitas vezes dá para escrever a mesma coisa em uma linha com list comprehensions.

for vs while

A escolha entre for e while se resume a uma pergunta: você sabe quantas vezes vai repetir? Se sim, use for; se não, use while. A tabela e os exemplos abaixo mostram quando cada um brilha.

1
2
3
4
5
6
7
8

# ✅ Use for quando sabe QUANTAS vezes
for i in range(5):
    print(i)

# ✅ Use while quando NÃO sabe quantas vezes
senha = ''
while senha != '1234':
    senha = input("Digite a senha: ")

Quando usar cada um?

✅ Use for quando:

• Iterar sobre sequências (listas, strings, dicts)
• Sabe o número de iterações
• Processar todos os itens
• Usar range() com número fixo

✅ Use while quando:

• Não sabe quantas iterações
• Repetir até condição mudar
• Aguardar input do usuário
• Loop infinito (servidor, game loop)

Erros comuns

Estes são os erros que mais aparecem com quem está começando com for e while, com a mensagem real que o Python mostra.

Esquecer os dois-pontos (SyntaxError)

1
2

for i in range(3)
    print(i)

1

SyntaxError: expected ':'

Correção: toda linha de for, while, if e else termina com :. Escreva for i in range(3):.

Esquecer a indentação do bloco (IndentationError)

1
2

for i in range(3):
print(i)

1

IndentationError: expected an indented block after 'for' statement on line 1

Correção: o corpo do loop precisa estar recuado (4 espaços é o padrão). Escreva ` print(i)` na segunda linha.

Tentar percorrer um número (TypeError)

1
2

for i in 5:
    print(i)

1

TypeError: 'int' object is not iterable

Correção: um inteiro não é iterável. Para repetir 5 vezes, use for i in range(5):.

Passar do fim da lista com range(len()) (IndexError)

1
2
3

frutas = ["maçã", "banana", "uva"]
for i in range(1, len(frutas) + 1):
    print(frutas[i])

1

IndexError: list index out of range

O código imprime banana e uva e quebra no índice 3, que não existe: os índices de uma lista com 3 itens vão de 0 a 2. Correção: percorra os itens direto com for fruta in frutas: (ou use enumerate() se precisar do índice).

Loop infinito no while (KeyboardInterrupt)

1
2
3

contador = 0
while contador < 5:
    print(contador)

O programa imprime 0 sem parar, porque contador nunca muda e a condição nunca vira False. Você só consegue sair com Ctrl+C, que encerra com:

1

KeyboardInterrupt

Correção: atualize dentro do loop a variável que a condição testa, adicionando contador += 1 depois do print().

Exercícios resolvidos

Tente resolver cada exercício antes de abrir a solução. Todos os códigos foram executados e as saídas conferidas.

Exercício 1. Usando for e range(), calcule a soma de todos os números de 1 a 100.

1
2
3
4
5

soma = 0
for numero in range(1, 101):
    soma += numero

print(soma)

Exercício 2. Você investe R$ 1000 com rendimento de 10% ao ano. Usando while, descubra quantos anos são necessários para o saldo chegar a pelo menos R$ 2000.

1
2
3
4
5
6
7
8

saldo = 1000
anos = 0

while saldo < 2000:
    saldo *= 1.10
    anos += 1

print(f"{anos} anos")

Exercício 3. Dada a lista [3, -1, 8, 0, 5, 7], some os números ignorando os negativos e parando de ler quando encontrar um 0.

1
2
3
4
5
6
7
8
9
10
11

numeros = [3, -1, 8, 0, 5, 7]
soma = 0

for n in numeros:
    if n < 0:
        continue  # ignora negativos
    if n == 0:
        break     # zero encerra a leitura
    soma += n

print(soma)

Exercício 4. Usando for com else, verifique se o número 29 é primo.

1
2
3
4
5
6
7
8

numero = 29

for divisor in range(2, numero):
    if numero % divisor == 0:
        print(f"{numero} não é primo (divisível por {divisor})")
        break
else:
    print(f"{numero} é primo")

Exercício 5. Dada a lista ranking = ["Ana", "Bruno", "Carla"], imprima a posição de cada pessoa começando em 1 (ex.: 1º lugar: Ana), sem criar um contador manual.

1
2
3
4

ranking = ["Ana", "Bruno", "Carla"]

for posicao, nome in enumerate(ranking, start=1):
    print(f"{posicao}º lugar: {nome}")

1
2
3

1º lugar: Ana
2º lugar: Bruno
3º lugar: Carla

Exercício 6. Usando loops aninhados, imprima um triângulo de asteriscos com 4 linhas (1 asterisco na primeira, 4 na última).

1
2
3
4

for linha in range(1, 5):
    for _ in range(linha):
        print("*", end="")
    print()

1
2
3
4

*
**
***
****

Exercício 7 (questão de prova). O for é uma estrutura de repetição utilizada para percorrer sequências. Pensando na estrutura do laço for que percorre os números de 1 a 5, qual sintaxe representa corretamente essa repetição?

a) for i in range(5):
b) for i in range(1, 5):
c) for i in range(1, 6):
d) for i in range(0, 5, 1):

1
2
3
4

print(list(range(5)))        # a)
print(list(range(1, 5)))     # b)
print(list(range(1, 6)))     # c)
print(list(range(0, 5, 1)))  # d)

1
2
3
4

[0, 1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[0, 1, 2, 3, 4]

Exercício 8 (questão de prova). Qual valor é exibido ao executar o código abaixo?

1
2
3
4

x = 10
while x > 0:
    x -= 3
print(x)

a) 0
b) 1
c) -2
d) O código entra em loop infinito

Quer praticar isso com projetos guiados, do básico ao avançado? Conheça o nosso curso de Python completo, a Jornada Python.

Conclusão

Neste guia de Loops, você aprendeu:

✅ for - Iterar sequências
✅ while - Repetir enquanto condição
✅ enumerate - Índice + valor
✅ break/continue - Controlar fluxo
✅ for vs while - Quando usar cada um

Principais lições:

• for para número conhecido de iterações
• while para número desconhecido
• break sai do loop
• continue pula iteração
• enumerate() retorna índice + valor
• range(1, 6) vai de 1 a 5 (o fim é exclusivo)
• Não existe do while: use while True + break

Próximos passos:

• Aprenda List Comprehensions
• Explore range()
• Pratique loops aninhados
• Estude generators para loops eficientes

Aprendê-los bem é básico para todo desenvolvedor Python.

Se ficou com alguma dúvida, fique à vontade para deixar um comentário no box aqui embaixo! Será um prazer te responder!

Por Erickson Lopes em 08/07/2021

O infinito é o limite

Bora se conectar no LinkedIn! ericksonlopes

Minhas redes:

• 
•