IntermediatePython · 36 min

Loops: Intermediate

Airbnb's pricing engine uses zip to pair availability calendars with pricing calendars for millions of listings simultaneously, iterating both sequences in lockstep to compute dynamic rates without a single index variable. When engineers process two related data streams at the same time, zip turns a nested loop into a single clean iteration that is both faster and easier to read. The intermediate loop patterns in this lesson, including enumerate, zip, and break/continue, are the toolkit that separates readable production code from amateur scripts.

enumerate() for Index

Daily Life
Interviews

Track position and value together

The enumerate() function adds a counter to an iterable. It returns pairs of (index, value) on each iteration, giving you access to both the position and the item without manually managing an index variable.

Basic enumerate Usage

enumerate(iterable) returns an enumerate object that yields (index, item) tuples. You typically unpack these in the for statement:

fruits = ["apple", "banana", "cherry"]
print("Manual approach:")
i = 0
for fruit in fruits:
print(str(i) + ": " + fruit)
i += 1
print()
print("With enumerate:")
for index, fruit in enumerate(fruits):
print(str(index) + ": " + fruit)
>>>Output
Manual approach:
0: apple
1: banana
2: cherry
With enumerate:
0: apple
1: banana
2: cherry

The index, fruit syntax unpacks the tuple returned by enumerate. The first value is the index, the second is the item from the list.

Starting at Any Index

By default, enumerate starts counting at 0. Use the start parameter to begin at a different number:

tasks = ["Wake up", "Eat breakfast", "Go to work"]
# Start counting from 1 (more natural for display)
print("Daily tasks:")
for num, task in enumerate(tasks, start=1):
print(str(num) + ". " + task)
print()
# Start from any number
print("Continue from 10:")
for i, task in enumerate(tasks, start=10):
print("Task #" + str(i) + ": " + task)
>>>Output
Daily tasks:
1. Wake up
2. Eat breakfast
3. Go to work
Continue from 10:
Task #10: Wake up
Task #11: Eat breakfast
Task #12: Go to work

enumerate() Patterns

enumerate is essential when you need to modify a list in place or when position matters:

# Modify list in place
numbers = [1, 2, 3, 4, 5]
for i, num in enumerate(numbers):
numbers[i] = num * 2
print("Doubled:", numbers)
# Find index of first match
names = ["Alice", "Bob", "Charlie", "Bob"]
for i, name in enumerate(names):
if name == "Bob":
print("First Bob at index:", i)
break
# Track progress in processing
data = ["row1", "row2", "row3", "row4", "row5"]
for i, row in enumerate(data, start=1):
print("Processing " + str(i) + "/" + str(len(data)) + ": " + row)
>>>Output
Doubled: [2, 4, 6, 8, 10]
First Bob at index: 1
Processing 1/5: row1
Processing 2/5: row2
Processing 3/5: row3
Processing 4/5: row4
Processing 5/5: row5
TIP
Always prefer enumerate() over range(len(list)) when you need both index and value. It's more Pythonic, more readable, and less error-prone.

Try changing the start parameter to see how enumerate adjusts the counter. Each option produces a different numbering scheme:

Fill in the Blank

> The enumerate function pairs each item with an index. Pick a start value to see how the numbering changes.

colors = ["red", "green", "blue"]
for i, c in enumerate(colors, start=):
    print(i, c)

enumerate() for Strings

Enumerate works with any iterable, including strings. This is useful for finding character positions or processing text with position awareness:
text = "Hello World"
# Find all positions of a character
letter = "o"
positions = []
for i, char in enumerate(text):
if char == letter:
positions.append(i)
print("'" + letter + "' found at positions:", positions)
# Show character positions
print()
print("Character positions:")
for i, char in enumerate(text):
if char != " ":
print("Position " + str(i) + ": '" + char + "'")
>>>Output
'o' found at positions: [4, 7]
Character positions:
Position 0: 'H'
Position 1: 'e'
Position 2: 'l'
Position 3: 'l'
Position 4: 'o'
Position 6: 'W'
Position 7: 'o'
Position 8: 'r'
Position 9: 'l'
Position 10: 'd'

enumerate() for Progress

When processing large datasets or files, enumerate helps display progress to users:
# Simulate processing records
records = ["record_1", "record_2", "record_3", "record_4", "record_5"]
total = len(records)
for i, record in enumerate(records, start=1):
percent = int((i / total) * 100)
print("Processing " + str(i) + "/" + str(total) + " (" + str(percent) + "%): " + record)
print()
print("All records processed!")
>>>Output
Processing 1/5 (20%): record_1
Processing 2/5 (40%): record_2
Processing 3/5 (60%): record_3
Processing 4/5 (80%): record_4
Processing 5/5 (100%): record_5
All records processed!

Here are the most common scenarios where enumerate() saves you from manual index tracking:

Modify list elements in place
Modify list elements in place
Use the index from enumerate to update items at their original position
Find indices of matches
Find indices of matches
Locate where specific values appear without a separate counter variable
Display progress indicators
Display progress indicators
Show the user how far along processing has reached in a large dataset
Create position-based mappings
Create position-based mappings
Build dictionaries that map indices to values using enumerate pairs

zip() Parallel Iteration

Daily Life
Interviews

Iterate multiple lists in lockstep

The zip() function combines multiple iterables element-by-element. On each iteration, it yields a tuple containing one item from each input sequence. This lets you iterate over related data in parallel.

Basic zip Usage

zip(iterable1, iterable2, ...) pairs up items from each iterable by position:

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
# Iterate over both lists in parallel
for name, age in zip(names, ages):
print(name + " is " + str(age) + " years old")
>>>Output
Alice is 25 years old
Bob is 30 years old
Charlie is 35 years old
On the first iteration, you get ("Alice", 25). On the second, ("Bob", 30). The items are paired by their position in each list.

zip() with Unequal Lengths

When sequences have different lengths, zip stops at the shortest one:
names = ["Alice", "Bob", "Charlie", "Diana"]
scores = [85, 92, 78]
# Only 3 pairs - stops at shortest sequence
for name, score in zip(names, scores):
print(name + ":", score)
print()
# Extra items in longer list are ignored
letters = ["a", "b"]
numbers = [1, 2, 3, 4, 5]
for letter, num in zip(letters, numbers):
print(letter, num)
>>>Output
Alice: 85
Bob: 92
Charlie: 78
a 1
b 2
Knowing when to reach for enumerate versus zip versus plain iteration saves you from writing unnecessary boilerplate. Here is a concise guide.
Choosing the Right Iteration Tool
  • Need just values: plain for loop over the sequence.
  • Need index and value: enumerate() with tuple unpacking.
  • Need values from two or more lists in lockstep: zip().
  • Need index plus multiple lists: enumerate(zip(a, b)).

zip() with Multiple Lists

You can zip together any number of sequences:
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
cities = ["NYC", "LA", "Chicago"]
for name, age, city in zip(names, ages, cities):
print(name + ", " + str(age) + ", lives in " + city)
print()
# Four lists
ids = [1, 2, 3]
first = ["Alice", "Bob", "Charlie"]
last = ["Smith", "Jones", "Brown"]
scores = [85, 92, 78]
for id, f, l, s in zip(ids, first, last, scores):
print("ID " + str(id) + ": " + f + " " + l + " scored " + str(s))
>>>Output
Alice, 25, lives in NYC
Bob, 30, lives in LA
Charlie, 35, lives in Chicago
ID 1: Alice Smith scored 85
ID 2: Bob Jones scored 92
ID 3: Charlie Brown scored 78

Dicts from zip()

A common pattern is using zip to create dictionaries from two lists:
keys = ["name", "age", "city"]
values = ["Alice", 25, "NYC"]
# Create dict from parallel lists
person = dict(zip(keys, values))
print(person)
# Useful for configuration
settings_names = ["debug", "timeout", "retries"]
settings_values = [True, 30, 3]
config = dict(zip(settings_names, settings_values))
print(config)
>>>Output
{'name': 'Alice', 'age': 25, 'city': 'NYC'}
{'debug': True, 'timeout': 30, 'retries': 3}

Combining zip and enumerate

You can combine zip and enumerate when you need index information while iterating over multiple sequences in parallel:
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
# Get index while zipping
print("Ranked results:")
for i, (name, score) in enumerate(zip(names, scores), start=1):
print(str(i) + ". " + name + ": " + str(score))
print()
# Compare adjacent pairs in a list
values = [10, 20, 15, 25, 30]
print("Consecutive differences:")
for i, (a, b) in enumerate(zip(values, values[1:])):
diff = b - a
direction = "up" if diff > 0 else "down"
print("Position " + str(i) + " to " + str(i+1) + ": " + direction + " " + str(abs(diff)))
>>>Output
Ranked results:
1. Alice: 85
2. Bob: 92
3. Charlie: 78
Consecutive differences:
Position 0 to 1: up 10
Position 1 to 2: down 5
Position 2 to 3: up 10
Position 3 to 4: up 5

Transposing with zip

A clever use of zip with the * unpacking operator transposes rows and columns in a matrix:

# Original matrix (3 rows, 4 columns)
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]
]
print("Original:")
for row in matrix:
print(row)
# Transpose using zip(*matrix)
transposed = list(zip(*matrix))
print()
print("Transposed (4 rows, 3 columns):")
for row in transposed:
print(list(row))
>>>Output
Original:
[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]
Transposed (4 rows, 3 columns):
[1, 5, 9]
[2, 6, 10]
[3, 7, 11]
[4, 8, 12]
Python Quiz

> Pair names with their scores so each element is a tuple. Pick the built-in that combines two sequences element-by-element, and the one that counts the resulting pairs.

names = ["Alice", "Bob"]
scores = [85, 92]
pairs = list((names, scores))
print(pairs[0])
print((pairs))
zip
map
enumerate
len
sum

zip() is lazy: it does not build a list in memory until you ask for it. Wrap it in list() to materialize all pairs, or iterate directly in a for loop to process one pair at a time.

enumerate() and zip() cover the two most common iteration patterns: working with a single sequence with positional context, or working with multiple parallel sequences together.

When zipping sequences of different lengths, zip() stops at the shortest one. Use itertools.zip_longest() if you need to process all elements and fill missing values with a default.

Iterating Dict Items

Daily Life
Interviews

Loop through dict keys, values, or both

Dictionaries provide several methods for iteration: you can loop over just keys, just values, or key-value pairs together. Each approach is useful in different situations.

Iterating Over Keys

By default, iterating over a dictionary yields its keys:
person = {"name": "Alice", "age": 25, "city": "NYC"}
# Default iteration gives keys
print("Keys:")
for key in person:
print(key)
print()
# Explicitly using .keys() - same result
print("Using .keys():")
for key in person.keys():
print(key)
>>>Output
Keys:
name
age
city
Using .keys():
name
age
city

Iterating Over Values

Use .values() to iterate over just the values:

scores = {"Alice": 85, "Bob": 92, "Charlie": 78}
# Iterate over values only
print("Scores:")
for score in scores.values():
print(score)
print()
# Calculate total
total = 0
for score in scores.values():
total += score
print("Total:", total)
print("Average:", total / len(scores))
>>>Output
Scores:
85
92
78
Total: 255
Average: 85.0

Iterating Key-Value Pairs

Use .items() to get both key and value together. This is the most commonly used pattern:

person = {"name": "Alice", "age": 25, "city": "NYC"}
# Key-value pairs
for key, value in person.items():
print(key + ": " + str(value))
print()
# Practical: format configuration
config = {"debug": True, "timeout": 30, "max_retries": 3}
print("Current settings:")
for setting, value in config.items():
print(" " + setting + " = " + str(value))
>>>Output
name: Alice
age: 25
city: NYC
Current settings:
debug = True
timeout = 30
max_retries = 3
•Dictionary Iteration
  • for key in dict: - iterate keys
  • for val in dict.values(): - iterate values
  • for k, v in dict.items(): - key-value pairs
•When to Use Each
  • Keys only: checking membership
  • Values only: aggregations
  • Items: most common, need both

Filtering Dict Entries

Common patterns when working with dictionary iteration:
scores = {"Alice": 85, "Bob": 92, "Charlie": 78, "Diana": 95}
# Filter to passing scores (>= 80)
passing = {}
for name, score in scores.items():
if score >= 80:
passing[name] = score
print("Passing:", passing)
# Transform values
curved = {}
for name, score in scores.items():
curved[name] = min(score + 5, 100)
print("Curved:", curved)
# Find key with max value
max_name = None
max_score = -1
for name, score in scores.items():
if score > max_score:
max_score = score
max_name = name
print("Top scorer:", max_name, "with", max_score)
>>>Output
Passing: {'Alice': 85, 'Bob': 92, 'Diana': 95}
Curved: {'Alice': 90, 'Bob': 97, 'Charlie': 83, 'Diana': 100}
Top scorer: Diana with 95

Iterating Nested Dicts

Real-world data often involves dictionaries containing other dictionaries. You can use nested loops to access all levels:
# Nested dictionary structure
company = {
"engineering": {
"Alice": 95000,
"Bob": 85000,
},
"marketing": {
"Charlie": 75000,
"Diana": 80000,
}
}
# Iterate through nested structure
print("Company salaries:")
for department, employees in company.items():
print()
print(department.upper() + ":")
for name, salary in employees.items():
print(" " + name + ": " + str(salary))
# Calculate totals per department
print()
print("Department totals:")
for department, employees in company.items():
total = sum(employees.values())
print(department + ": " + str(total))
>>>Output
Company salaries:
ENGINEERING:
Alice: 95000
Bob: 85000
MARKETING:
Charlie: 75000
Diana: 80000
Department totals:
engineering: 180000
marketing: 155000

Building Dicts from Loops

You can construct dictionaries dynamically while iterating:
# Build a frequency counter
text = "hello world"
frequency = {}
for char in text:
if char in frequency:
frequency[char] += 1
else:
frequency[char] = 1
print("Character frequencies:", frequency)
# Group items by property
users = [
{"name": "Alice", "role": "admin"},
{"name": "Bob", "role": "user"},
{"name": "Charlie", "role": "admin"},
{"name": "Diana", "role": "user"},
]
by_role = {}
for user in users:
role = user["role"]
if role not in by_role:
by_role[role] = []
by_role[role].append(user["name"])
print()
print("Users by role:", by_role)
>>>Output
Character frequencies: {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}
Users by role: {'admin': ['Alice', 'Charlie'], 'user': ['Bob', 'Diana']}
TIP
The pattern of checking if a key exists before updating is common. Python's collections.defaultdict and dict.setdefault() methods can simplify this, which you'll learn in more advanced lessons.
When iterating over dictionaries, follow these practices to keep your code safe and readable:
✓Do
  • Use .items() when you need both key and value
  • Use dict comprehension for filtering
  • Iterate over list(dict.keys()) to modify
  • Use descriptive names for k, v
✗Don't
  • Add or delete keys while iterating directly
  • Use dict[key] inside a for-key loop when .items() works
  • Assume insertion order in Python < 3.7
  • Modify values through a values() view
Python Quiz

> Sum the numeric values and collect the key names from a dictionary. Pick the accessor that returns just the numbers, and the one that returns just the names.

data = {"x": 10, "y": 20, "z": 30}
total = sum(data.())
names = list(data.())
print(total)
print(names[0])
values
keys
items
keys
values

Choosing the right dictionary view method keeps your intent clear. Use .keys() when only the labels matter, .values() when only the data matters, and .items() when you need both together.

Dictionary views are live: if you add or remove keys after creating a view, the view reflects those changes immediately. Convert to a list if you need a stable snapshot of the keys or values.
The grouping pattern, where you check if a key exists before appending to its list, is one of the most common dictionary-building idioms in Python and appears frequently in data aggregation tasks.

Nested Loops

Daily Life
Interviews

Process grids and generate combinations

A nested loop is a loop inside another loop. The inner loop runs completely for each iteration of the outer loop. This pattern is essential for working with multi-dimensional data structures and generating combinations.

Basic Nested Loop

The inner loop completes all its iterations before the outer loop moves to the next item:
for i in range(1, 4):
print("Outer:", i)
for j in range(1, 3):
print(" Inner:", j)
print()
>>>Output
Outer: 1
Inner: 1
Inner: 2
Outer: 2
Inner: 1
Inner: 2
Outer: 3
Inner: 1
Inner: 2
The outer loop runs 3 times. For each outer iteration, the inner loop runs 2 times. Total iterations: 3 x 2 = 6.

Working with 2D Data

Nested loops are natural for processing matrices (lists of lists):
# 2D grid (list of lists)
grid = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Process each cell
print("Grid contents:")
for row in grid:
for cell in row:
print(cell, end=" ")
print()
print()
# Sum all values
total = 0
for row in grid:
for cell in row:
total += cell
print("Sum:", total)
# Access with indices
print()
print("Using indices:")
for i in range(len(grid)):
for j in range(len(grid[i])):
print("grid[" + str(i) + "][" + str(j) + "] =", grid[i][j])
>>>Output
Grid contents:
1 2 3
4 5 6
7 8 9
Sum: 45
Using indices:
grid[0][0] = 1
grid[0][1] = 2
grid[0][2] = 3
grid[1][0] = 4
grid[1][1] = 5
grid[1][2] = 6
grid[2][0] = 7
grid[2][1] = 8
grid[2][2] = 9

Generating Combinations

Nested loops naturally generate all combinations of elements:
colors = ["red", "blue"]
sizes = ["S", "M", "L"]
# All color-size combinations
print("Products:")
for color in colors:
for size in sizes:
print(color + "-" + size)
print()
# Multiplication table
print("Multiplication table (1-3):")
for i in range(1, 4):
row = ""
for j in range(1, 4):
row += str(i * j) + " "
print(row)
>>>Output
Products:
red-S
red-M
red-L
blue-S
blue-M
blue-L
Multiplication table (1-3):
1 2 3
2 4 6
3 6 9
TIP
Nested loops multiply iterations. A loop of 1000 inside a loop of 1000 runs 1,000,000 times. Be mindful of performance with deeply nested loops over large datasets.

Triangle and Pyramid

Nested loops where the inner loop depends on the outer loop create triangle patterns. This is common for comparisons and hierarchical displays:
print("Triangle:")
for i in range(1, 6):
row = ""
for j in range(i):
row += "* "
print(row)
print()
# Pairs without repetition
items = ["A", "B", "C", "D"]
print("Unique pairs:")
for i in range(len(items)):
for j in range(i + 1, len(items)):
print(items[i] + "-" + items[j])
>>>Output
Triangle:
*
* *
* * *
* * * *
* * * * *
Unique pairs:
A-B
A-C
A-D
B-C
B-D
C-D
In the unique pairs example, starting the inner loop at i+1 ensures each pair is only counted once (A-B but not B-A).
This nested loop has a bug that causes incorrect output. Can you find and remove the extra tile?
Debug Challenge

> This nested loop should print a multiplication table, but the formula is wrong. Remove the extra tile to fix it.

LogicError: printing i*i*j instead of i*j. The table values are wrong.

Searching in 2D Structures

Nested loops are essential for searching through two-dimensional data structures:
# Find target in 2D grid
grid = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
target = 5
found_at = None
for row_idx, row in enumerate(grid):
for col_idx, value in enumerate(row):
if value == target:
found_at = (row_idx, col_idx)
break
if found_at:
break
print("Found", target, "at position:", found_at)
# Find all positions matching condition
positions = []
for row_idx, row in enumerate(grid):
for col_idx, value in enumerate(row):
if value % 2 == 0:
positions.append((row_idx, col_idx, value))
print()
print("Even numbers found:")
for row, col, val in positions:
print(" grid[" + str(row) + "][" + str(col) + "] = " + str(val))
>>>Output
Found 5 at position: (1, 1)
Even numbers found:
grid[0][1] = 2
grid[1][0] = 4
grid[1][2] = 6
grid[2][1] = 8
Nested loops unlock a wide range of algorithmic patterns. Each pattern pairs an outer traversal with an inner operation:
01
Grid operations
Process every cell in a 2D matrix using row and column loops
02
Combinations
Generate all pairs from two or more sets of values
03
Pattern printing
Build triangle, pyramid, and diamond shapes row by row
04
Multi-dim search
Find a target value by scanning rows then columns
05
Pair comparisons
Check every pair of items for duplicates or relationships

Loop else Clauses

Daily Life
Interviews

Detect when a search finds nothing

Python has a unique feature: you can attach an else clause to loops. The else block executes when the loop completes normally (without hitting a break). If break terminates the loop, the else block is skipped.

The for-else Pattern

The else block runs only if the loop completed without breaking:
# Search with for-else
numbers = [1, 3, 5, 7, 9]
# Looking for an even number
for num in numbers:
if num % 2 == 0:
print("Found even:", num)
break
else:
print("No even numbers found")
print()
numbers2 = [1, 3, 4, 7, 9]
for num in numbers2:
if num % 2 == 0:
print("Found even:", num)
break
else:
print("No even numbers found")
>>>Output
No even numbers found
Found even: 4

Think of for-else as "for...else if no break". In the first loop, no even number exists, so the loop completes normally and else runs. In the second loop, break executes, so else is skipped.

The while-else Pattern

The else clause works identically with while loops:
# Try to find a value
target = 42
attempts = 0
max_attempts = 3
current = 10
result = None
while attempts < max_attempts:
attempts += 1
current += 10
print("Attempt", attempts, "- current value:", current)
if current == target:
print("Found target!")
break
else:
print("Target not found after", max_attempts, "attempts")
print()
# Version where we find it
target = 30
attempts = 0
current = 10
while attempts < max_attempts:
attempts += 1
current += 10
print("Attempt", attempts, "- current value:", current)
if current == target:
print("Found target!")
break
else:
print("Target not found")
>>>Output
Attempt 1 - current value: 20
Attempt 2 - current value: 30
Attempt 3 - current value: 40
Target not found after 3 attempts
Attempt 1 - current value: 20
Attempt 2 - current value: 30
Found target!

Practical Use Cases

Loop-else is ideal for search patterns where you need to know if the search succeeded:
searchvalidateprimeretry
search
Find an item
else runs if not found
validate
Check all items
else confirms all passed
prime
Divisor search
else means no divisors
retry
Attempt loops
else means all retries failed
The prime number check is a classic example. The loop searches for a divisor. If it finds one, it breaks. If the loop finishes without breaking, the else clause confirms the number is prime:
# Check if number is prime
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
# Using loop-else for same logic
n = 17
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
print(n, "is not prime")
break
else:
print(n, "is prime")
>>>Output
17 is prime
Mastering loop patterns helps you write more efficient and expressive code. Put these techniques to the test with hands-on challenges in the Python Builder.
❯❯❯PUTTING IT ALL TOGETHER

> You are a data engineer at Salesforce processing multi-dimensional user activity logs, pairing each user with their corresponding event sequence to calculate weekly engagement scores across product lines.

enumerate() pairs each user record with its position index so you can track progress and log which record triggered an anomaly.
zip() links the user list with the parallel event-sequence list so each engagement calculation draws from both in a single loop.
Nested loops iterate over each user's individual events within the outer pass over all users to accumulate weekly scores.
The loop else clause signals cleanly when a full user scan completes without finding an expected anchor event to score against.
KEY TAKEAWAYS
enumerate(sequence) yields (index, value) pairs; use start=1 to begin at 1
zip(seq1, seq2, ...) pairs items from multiple sequences; stops at shortest
Dictionary iteration: .keys(), .values(), .items() for key-value pairs
Nested loops multiply iterations; inner loop completes fully per outer iteration
Loop else runs only if loop completes without break; great for searches
Use dict(zip(keys, values)) to create dictionaries from parallel lists
Prefer enumerate() over range(len()) for cleaner code
Be mindful of performance with nested loops over large datasets

Powerful iteration techniques

Category
Python
Difficulty
intermediate
Duration
36 minutes
Challenges
0 hands-on challenges

Topics covered: enumerate() for Index, zip() Parallel Iteration, Iterating Dict Items, Nested Loops, Loop else Clauses

Lesson Sections

  1. enumerate() for Index (concepts: pyEnumerate)

    Basic enumerate Usage Starting at Any Index enumerate() Patterns enumerate() for Strings Enumerate works with any iterable, including strings. This is useful for finding character positions or processing text with position awareness: enumerate() for Progress When processing large datasets or files, enumerate helps display progress to users:

  2. zip() Parallel Iteration (concepts: pyZip)

    Basic zip Usage On the first iteration, you get ("Alice", 25). On the second, ("Bob", 30). The items are paired by their position in each list. zip() with Unequal Lengths When sequences have different lengths, zip stops at the shortest one: Knowing when to reach for enumerate versus zip versus plain iteration saves you from writing unnecessary boilerplate. Here is a concise guide. zip() with Multiple Lists You can zip together any number of sequences: Dicts from zip() A common pattern is using z

  3. Iterating Dict Items (concepts: pyDictIterate)

    Dictionaries provide several methods for iteration: you can loop over just keys, just values, or key-value pairs together. Each approach is useful in different situations. Iterating Over Keys By default, iterating over a dictionary yields its keys: Iterating Over Values Iterating Key-Value Pairs Filtering Dict Entries Common patterns when working with dictionary iteration: Iterating Nested Dicts Real-world data often involves dictionaries containing other dictionaries. You can use nested loops t

  4. Nested Loops (concepts: pyNestedLoops)

    A nested loop is a loop inside another loop. The inner loop runs completely for each iteration of the outer loop. This pattern is essential for working with multi-dimensional data structures and generating combinations. Basic Nested Loop The inner loop completes all its iterations before the outer loop moves to the next item: The outer loop runs 3 times. For each outer iteration, the inner loop runs 2 times. Total iterations: 3 x 2 = 6. Working with 2D Data Nested loops are natural for processin

  5. Loop else Clauses (concepts: pyLoopElse)

    The for-else Pattern The else block runs only if the loop completed without breaking: The while-else Pattern The else clause works identically with while loops: Practical Use Cases Loop-else is ideal for search patterns where you need to know if the search succeeded: The prime number check is a classic example. The loop searches for a divisor. If it finds one, it breaks. If the loop finishes without breaking, the else clause confirms the number is prime: Mastering loop patterns helps you write m