Loops e Estruturas de Repetição no Python

✅ Atualizado para Python 3.13 (Dezembro 2025) Loops com casos práticos, enumerate, break/continue e quando usar for vs while.

Salve salve Pythonista!

Loops repetem código automaticamente! Essenciais para processar listas, arquivos e repetições.

Neste guia:

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

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

Vamos ver também sobre as funções range() e enumerate() e como construir loops com elas!

Loops ou estruturas de repetição são blocos básicos de qualquer linguagem de programação e são muito importantes!

Cada linguagem de programação possui uma sintaxe específica para loops.

Vamos ver nesse post como podemos fazer loops em Python, pois isso é muito importante no dia a dia do verdadeiro Pythonista!

Então… Bora pro post!

Vá Direto ao Assunto…

• Introdução
• Loops utilizando for
• Loops utilizando while
• Auxiliadores
• A função range()
• Função enumerate()
• for vs while

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.

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

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

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.

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.

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
4

  File "<stdin>", line 2

    ^
IndentationError: expected an indented block

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.

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!

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

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)

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

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: