Introduction to Python's For Loop
Imagine you're walking through a garden, stopping to examine each flower along a path. You don't need to count steps or keep track of where you are - you simply move from one flower to the next until you've seen them all. This is exactly how Python's for loop works: it naturally moves through a sequence of items, one at a time, until it's visited them all.
Unlike JavaScript, which offers multiple types of for loops, Python embraces simplicity with a single, powerful for loop design. This simplicity doesn't limit what we can do - instead, it makes our code clearer and more intuitive.
Basic For Loop Structure: Your First Steps
Let's start with understanding the fundamental structure of a Python for loop. Think of it as writing instructions for someone to process items in a box, one at a time:
# Simple for loop with a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(f"I like {fruit}s")
# Using range for counting
for number in range(5):
print(f"Count: {number}")
# The range function is like creating a sequence of numbers
# range(5) creates: 0, 1, 2, 3, 4
# Compare with a similar task in JavaScript:
# for (let i = 0; i < 5; i++) {
# console.log(`Count: ${i}`);
# }
# Python's version is much cleaner and more readable!
Notice how Python's syntax reads almost like English: "for each fruit in fruits, print something about that fruit." This natural language-like syntax is one of Python's great strengths.
The Range Function: Your Counting Companion
While Python doesn't have a counting-style for loop like JavaScript's for(;;), it provides the elegant range() function. Think of range() as a number generator that creates a sequence of numbers on demand:
# range with one argument - creates sequence from 0 to (n-1)
for i in range(5):
print(i) # Prints: 0, 1, 2, 3, 4
# range with two arguments - creates sequence from start to (end-1)
for i in range(2, 6):
print(i) # Prints: 2, 3, 4, 5
# range with three arguments - includes a step value
for i in range(0, 10, 2):
print(i) # Prints: 0, 2, 4, 6, 8
# Counting backwards
for i in range(5, -1, -1):
print(i) # Prints: 5, 4, 3, 2, 1, 0
# Real-world example: Creating a simple timer
def countdown(seconds):
for remaining in range(seconds, -1, -1):
print(f"Time remaining: {remaining} seconds")
# In a real application, you'd add a time.sleep(1) here
Iterating Over Different Types of Sequences
Python's for loop can work with any iterable object. This flexibility makes it incredibly versatile:
# Iterating over a string
for char in "Python":
print(f"Letter: {char}")
# Iterating over a list
colors = ["red", "green", "blue"]
for color in colors:
print(f"Color: {color}")
# Iterating over a dictionary
person = {
"name": "Alice",
"age": 30,
"city": "New York"
}
# Iterating over keys (default)
for key in person:
print(f"Key: {key}")
# Iterating over key-value pairs
for key, value in person.items():
print(f"{key}: {value}")
# Iterating over multiple sequences simultaneously using zip
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
cities = ["New York", "London", "Paris"]
for name, age, city in zip(names, ages, cities):
print(f"{name} is {age} years old and lives in {city}")
Control Flow: Break, Continue, and Else
Python provides several ways to control the flow of your loops. These tools help you handle special cases and create more sophisticated loop behavior:
# Using break to exit the loop early
for number in range(1, 101):
if number * number > 200:
print(f"First number whose square exceeds 200: {number}")
break
# Using continue to skip iterations
for number in range(1, 6):
if number % 2 == 0:
continue # Skip even numbers
print(f"Odd number: {number}")
# Using else with for loops (runs if loop completes normally)
def find_divisible(numbers, divisor):
for num in numbers:
if num % divisor == 0:
print(f"Found number divisible by {divisor}: {num}")
break
else:
print(f"No number divisible by {divisor} found")
numbers = [1, 3, 5, 7, 9]
find_divisible(numbers, 2) # No number divisible by 2 found
find_divisible(numbers, 3) # Found number divisible by 3: 3
Common Patterns and Best Practices
Let's explore some common patterns that you'll frequently use with for loops:
# Enumerate: Getting both index and value
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")
# List comprehension: A more concise way to transform lists
numbers = [1, 2, 3, 4, 5]
squares = [num * num for num in numbers]
print(squares) # [1, 4, 9, 16, 25]
# Processing pairs of items
points = [(1, 2), (3, 4), (5, 6)]
for x, y in points:
print(f"Point: ({x}, {y})")
# Finding maximum with a for loop
def find_max(numbers):
if not numbers:
return None
current_max = numbers[0]
for num in numbers[1:]:
if num > current_max:
current_max = num
return current_max
# Building a dictionary with a for loop
words = ["cat", "dog", "bird"]
word_lengths = {}
for word in words:
word_lengths[word] = len(word)
Advanced Techniques
Once you're comfortable with basic for loops, you can use more sophisticated patterns:
# Nested loops with control flow
def find_pairs(numbers, target):
for i, num1 in enumerate(numbers):
for j, num2 in enumerate(numbers[i+1:], i+1):
if num1 + num2 == target:
print(f"Found pair: {num1}, {num2}")
return # Exit after finding first pair
print("No pairs found")
# Generator expression for memory efficiency
def process_large_file(filename):
# Using a generator expression instead of loading whole file
line_lengths = (len(line.strip()) for line in open(filename))
for length in line_lengths:
print(f"Line length: {length}")
# Custom iteration with classes
class Countdown:
def __init__(self, start):
self.start = start
def __iter__(self):
return self
def __next__(self):
if self.start < 0:
raise StopIteration
current = self.start
self.start -= 1
return current
# Using the custom iterator
for num in Countdown(5):
print(num) # Prints: 5, 4, 3, 2, 1, 0
Practice Exercises
Let's reinforce our understanding with some practical exercises:
Create a word frequency counter:
def count_word_frequency(text):
"""
Count the frequency of each word in a text.
Handle case-insensitivity and punctuation.
Return a dictionary of word frequencies.
"""
# Your code here
pass
Implement a matrix transposition:
def transpose_matrix(matrix):
"""
Transpose a matrix using nested for loops.
Example:
[[1, 2, 3], --> [[1, 4, 7],
[4, 5, 6], [2, 5, 8],
[7, 8, 9]] [3, 6, 9]]
"""
# Your code here
pass