Laço for em Python: percorra qualquer coisa, com exemplos

Q: Como percorrer strings e dicionários?

O laço for funciona com qualquer coisa iterável em Python, não só com listas e ranges. Strings e dicionários são dois dos iteráveis mais comuns que você vai percorrer.

Iniciante25 min7 exercícios95 XP

Este tutorial foi traduzido do original em inglês.Read in English Leer en español Читать на русском อ่านภาษาไทย Avisar sobre um erro de tradução

Antes de começar

If-else em Python: condições, elif, if aninhado e ternário

0/7 exercícios

Imagine que você é professor e tem 30 alunos. Você precisa imprimir um boletim para cada um. Escreveria 30 comandos print separados? Claro que não. Você diria ao computador: "para cada aluno, imprima o boletim dele". É exatamente isso que um laço for faz.

Neste tutorial, você vai aprender a usar o laço for do Python para repetir ações sobre listas, strings, sequências de números e dicionários. Também vai conhecer ferramentas poderosas como enumerate() e zip(), que deixam os laços ainda mais práticos.

Ao final, você vai conseguir processar coleções de dados de forma eficiente, em vez de escrever código repetitivo. Essa é uma das habilidades mais importantes da programação.

Como funciona o laço for em Python?

Um laço for recebe uma coleção de itens e executa o mesmo código uma vez para cada item. A cada passagem pelo laço, uma variável guarda o item atual. O Python chama cada passagem de iteração.

Pense em distribuir cartas. Você pega o baralho e, para cada carta, coloca a carta virada para cima na mesa. A carta muda a cada vez, mas a ação continua a mesma.

Seu primeiro laço for

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:

print(fruit)

# Output:

# apple

# banana

# cherry

Saída

apple
banana
cherry

Esta é a estrutura: a palavra-chave for, um nome de variável (fruit), a palavra-chave in e a coleção (fruits), seguidos de dois-pontos. O código indentado logo abaixo roda uma vez para cada item da lista.

Na primeira iteração, fruit vale "apple". Na segunda, vale "banana". Na terceira, "cherry". Depois do último item, o laço termina e o Python segue para o que vier a seguir.

Acumulando um total com um laço for

# The loop variable can be anything you want

numbers = [10, 20, 30, 40]

total = 0

for num in numbers:

total = total + num

print(f"Added {num}, total is now {total}")

print(f"\nFinal total: {total}")

# Output:

# Added 10, total is now 10

# Added 20, total is now 30

# Added 30, total is now 60

# Added 40, total is now 100

# Final total: 100

Saída

Added 10, total is now 10
Added 20, total is now 30
Added 30, total is now 60
Added 40, total is now 100

Final total: 100

Esse padrão de começar com um valor e atualizá-lo a cada iteração se chama acumulação. Você vai usá-lo o tempo todo: para somar números, montar strings, juntar resultados e muito mais.

O que range() faz em Python?

Às vezes você não tem uma lista para percorrer: quer apenas repetir algo um número específico de vezes ou passar por uma sequência de números. É para isso que serve range().

range() gera uma sequência de números. Ele não cria uma lista na memória: produz os números um de cada vez, conforme o laço precisa deles. Isso o torna eficiente mesmo para intervalos grandes.

range() com um argumento: stop

# range(5) gives you 0, 1, 2, 3, 4

for i in range(5):

print(i)

# Output:

# 0

# 1

# 2

# 3

# 4

Saída

Repare que range(5) começa em 0 e para antes do 5. Ele gera exatamente 5 números: de 0 a 4. Esse padrão de "começar no zero e parar antes do fim" se repete em todo o Python.

range() com dois argumentos: start e stop

# range(start, stop) - starts at start, stops before stop

for i in range(1, 6):

print(i)

# Output:

# 1

# 2

# 3

# 4

# 5

Saída

Com dois argumentos, o primeiro indica onde começar e o segundo onde parar (sem incluí-lo). Então range(1, 6) gera 1, 2, 3, 4, 5.

range() com três argumentos: start, stop e step

# range(start, stop, step) - count by a custom step

print("Count by 2s:")

for i in range(0, 11, 2):

print(i, end=" ")

print() # newline

print("\nCountdown:")

for i in range(5, 0, -1):

print(i, end=" ")

print("\nBlastoff!")

# Output:

# Count by 2s:

# 0 2 4 6 8 10

# Countdown:

# 5 4 3 2 1

# Blastoff!

Saída

Count by 2s:
0 2 4 6 8 10 

Countdown:
5 4 3 2 1 
Blastoff!

O terceiro argumento é o passo (step): quanto somar a cada vez. Um passo de 2 pula um número sim, outro não. Um passo negativo conta de trás para frente. Você pode usar qualquer passo inteiro, positivo ou negativo.

Como percorrer strings e dicionários?

O laço for funciona com qualquer coisa iterável em Python, não só com listas e ranges. Strings e dicionários são dois dos iteráveis mais comuns que você vai percorrer.

Percorrendo uma string

Quando você percorre uma string, recebe um caractere de cada vez. Isso é útil para contar letras, conferir a grafia ou processar um texto caractere por caractere.

Percorrendo uma string

word = "Python"

for char in word:

print(char, end=" ")

# Output:

# P y t h o n

Saída

P y t h o n

Cada iteração entrega o próximo caractere. O end=" " na função print troca a quebra de linha padrão por um espaço, então todos os caracteres aparecem na mesma linha.

Contando vogais com um laço for

# Count vowels in a word

word = "programming"

vowel_count = 0

for char in word:

if char in "aeiou":

vowel_count += 1

print(f"\"{word}\" has {vowel_count} vowels")

# Output:

# "programming" has 3 vowels

Saída

"programming" has 3 vowels

Este exemplo combina um laço for com um if. Para cada caractere, verificamos se ele é uma vogal. Se for, aumentamos a contagem. É o tipo de padrão que você vai escrever o tempo todo.

Percorrendo um dicionário

Quando você percorre um dicionário, recebe as chaves por padrão. Para obter chaves e valores juntos, use o método .items().

Percorrendo um dicionário

scores = {"Alice": 92, "Bob": 85, "Charlie": 78}

# Looping over keys (default)

print("Students:")

for name in scores:

print(f" {name}")

print()

# Looping over keys and values with .items()

print("Report card:")

for name, score in scores.items():

print(f" {name}: {score}")

# Output:

# Students:

# Alice

# Bob

# Charlie

# Report card:

# Alice: 92

# Bob: 85

# Charlie: 78

Saída

Students:
  Alice
  Bob
  Charlie

Report card:
  Alice: 92
  Bob: 85
  Charlie: 78

O método .items() devolve cada entrada como um par (chave, valor). Ao escrever for name, score in scores.items(), você desempacota cada par em duas variáveis separadas. Isso fica mais limpo do que acessar scores[name] dentro do laço.

O que enumerate() faz em Python?

Às vezes você precisa do item E da posição dele na lista. Daria para usar range(len(list)) e acessar a lista pelo índice manualmente, mas o Python tem um jeito mais limpo: enumerate().

Sem enumerate() (feio)

colors = ["red", "green", "blue"]

for i in range(len(colors)):
    print(f"{i}: {colors[i]}")

Com enumerate() (limpo)

colors = ["red", "green", "blue"]

for i, color in enumerate(colors):
    print(f"{i}: {color}")

enumerate() envolve um iterável e entrega pares (índice, item). Você desempacota cada par em duas variáveis. Os dois exemplos produzem a mesma saída, mas a versão com enumerate() é mais legível e mais pythônica.

enumerate() com start=1 para listas numeradas

tasks = ["Buy groceries", "Clean house", "Walk dog", "Cook dinner"]

print("Today's to-do list:")

for i, task in enumerate(tasks, start=1):

print(f" {i}. {task}")

# Output:

# Today's to-do list:

# 1. Buy groceries

# 2. Clean house

# 3. Walk dog

# 4. Cook dinner

Saída

Today's to-do list:
  1. Buy groceries
  2. Clean house
  3. Walk dog
  4. Cook dinner

O argumento start=1 faz enumerate() começar a contar do 1 em vez do 0. É perfeito para criar listas numeradas, em que um "item 0" não faria sentido para o usuário.

Como zip() permite percorrer várias listas?

E se você tiver duas listas relacionadas e quiser processá-las juntas? Por exemplo, uma lista com nomes de alunos e outra com as notas deles. zip() forma pares entre elas para que você percorra as duas ao mesmo tempo.

Percorrendo duas listas com zip()

names = ["Alice", "Bob", "Charlie"]

scores = [92, 85, 78]

for name, score in zip(names, scores):

result = "Pass" if score >= 80 else "Needs improvement"

print(f"{name}: {score} ({result})")

# Output:

# Alice: 92 (Pass)

# Bob: 85 (Pass)

# Charlie: 78 (Needs improvement)

Saída

Alice: 92 (Pass)
Bob: 85 (Pass)
Charlie: 78 (Needs improvement)

zip() recebe dois ou mais iteráveis e os combina elemento por elemento. Na primeira iteração, você recebe o primeiro item de cada lista. Na segunda, o segundo item de cada uma, e assim por diante.

Combinando três listas com zip()

# zip() works with more than two lists

first_names = ["Alice", "Bob", "Charlie"]

last_names = ["Smith", "Jones", "Brown"]

ages = [25, 30, 22]

for first, last, age in zip(first_names, last_names, ages):

print(f"{first} {last}, age {age}")

# Output:

# Alice Smith, age 25

# Bob Jones, age 30

# Charlie Brown, age 22

Saída

Alice Smith, age 25
Bob Jones, age 30
Charlie Brown, age 22

O que são laços for aninhados?

Você pode colocar um laço for dentro de outro. O laço interno roda por completo a cada iteração do laço externo. Isso se chama aninhamento, e é assim que se trabalha com grades, tabelas e combinações.

Laços aninhados: tabuada

# Multiplication table (1-3)

for row in range(1, 4):

for col in range(1, 4):

result = row * col

print(f"{row} x {col} = {result}")

print() # blank line between rows

# Output:

# 1 x 1 = 1

# 1 x 2 = 2

# 1 x 3 = 3

# 2 x 1 = 2

# 2 x 2 = 4

# 2 x 3 = 6

# 3 x 1 = 3

# 3 x 2 = 6

# 3 x 3 = 9

Saída

Quando row vale 1, o laço interno roda com col passando por 1, 2, 3. Depois row passa a valer 2, e o laço interno roda de novo com col passando por 1, 2, 3. O laço interno recomeça do início sempre que o externo avança.

Exercícios práticos

Hora de colocar em prática o que você aprendeu sobre o laço for! Estes exercícios vão da iteração básica até a combinação de laços com as ferramentas que você acabou de ver.

Tente resolver cada exercício sozinho antes de olhar as dicas. Ficar travado e encontrar a solução por conta própria é como você desenvolve habilidades de verdade.

Exercício 1: exiba a lista de compras

Escreva o código

Você recebe uma lista de itens de mercado. Use um laço for para exibir cada item em sua própria linha.

Saída esperada:

milk
eggs
bread
butter

groceries = ["milk", "eggs", "bread", "butter"]

# Use a for loop to print each item

Exercício 2: some os números de 1 a 10

Escreva o código

Use range() e um laço for para calcular a soma de todos os números de 1 a 10 (incluindo o 10). Exiba o resultado.

Saída esperada:

Sum: 55

# Calculate the sum of numbers 1 through 10 using range()

total = 0

# Write your for loop here

print(f"Sum: {total}")

Exercício 3: preveja a saída

Preveja a saída

Sem executar o código, preveja exatamente o que ele vai exibir. Preste muita atenção aos argumentos de range() e à condição do if.

Depois, execute o código para conferir sua resposta.

for num in range(1, 8, 2):

if num > 4:

print(f"{num} is big")

else:

print(f"{num} is small")

Exercício 4: corrija o bug no contador de letras

Corrija o erro

Este código deveria contar quantas vezes a letra "l" aparece no texto "hello world", mas ele tem bugs. Corrija o código para que ele exiba:

The letter "l" appears 3 times

Não altere a variável word nem o print final: corrija apenas a lógica do laço.

word = "hello world"

count = 0

for char in word:

if char == "L":

count = 1

print(f'The letter "l" appears {count} times')

Exercício 5: cardápio numerado

Escreva o código

Use enumerate() com start=1 para exibir um cardápio de restaurante numerado.

Saída esperada:

1. Burger - $8.99
2. Pizza - $12.50
3. Salad - $7.25
4. Pasta - $10.00

items = ["Burger", "Pizza", "Salad", "Pasta"]

prices = [8.99, 12.50, 7.25, 10.00]

# Use enumerate() and zip() to print the numbered menu

Exercício 6: inverta uma string

Escreva o código

Use um laço for para inverter a string "Python", montando uma nova string caractere por caractere. NÃO use fatiamento ([::-1]) nem a função reversed().

Saída esperada:

nohtyP

original = "Python"

reversed_str = ""

# Use a for loop to build the reversed string

print(reversed_str)

Exercício 7: boletim de notas dos alunos

Escreva o código

Percorra o dicionário grades e exiba o nome de cada aluno e o conceito dele. Uma nota de 90 ou mais é "A", de 80 ou mais é "B", de 70 ou mais é "C", e abaixo de 70 é "F".

Saída esperada:

Alice: 95 (A)
Bob: 82 (B)
Charlie: 67 (F)
Diana: 73 (C)

grades = {"Alice": 95, "Bob": 82, "Charlie": 67, "Diana": 73}

# Loop over the dictionary and print each student's grade

Resumo: laço for em Python

Aqui está tudo o que você aprendeu sobre o laço for:

Padrão	O que faz	Exemplo
`for x in list`	Percorre cada item	`for fruit in fruits:`
`for i in range(n)`	Repete n vezes (de 0 a n-1)	`for i in range(5):`
`range(start, stop, step)`	Sequência de números personalizada	`range(1, 11, 2)`
`for char in string`	Percorre os caracteres	`for c in "hello":`
`for k, v in dict.items()`	Percorre pares chave-valor	`for name, score in grades.items():`
`enumerate(iterable)`	Obtém índice + item	`for i, x in enumerate(list):`
`zip(a, b)`	Junta em pares os itens de duas listas	`for x, y in zip(names, scores):`

Regras principais para lembrar:

A linha do for termina com dois-pontos (:)

O corpo do laço precisa estar indentado

range() para ANTES do número final

enumerate() é melhor que range(len(...))

zip() para na lista mais curta

Use nomes no singular para as variáveis do laço (for student in students)

O que vem a seguir?

O laço for é ótimo quando você sabe exatamente o que está percorrendo. Mas e se você quiser continuar repetindo até que alguma condição mude? É aí que entra o laço while. No próximo tutorial, Laço while em Python, você vai aprender a repetir com base em condições em vez de coleções.

Como funciona o laço for em Python?

O que range() faz em Python?

Como percorrer strings e dicionários?

Percorrendo uma string

Percorrendo um dicionário

O que enumerate() faz em Python?

Como zip() permite percorrer várias listas?

O que são laços for aninhados?

Exercícios práticos

Resumo: laço for em Python

O que vem a seguir?

Tutoriais relacionados