Python Loops

Python loops are control flow statements that enable you to execute a block of code multiple times. Python provides two primary types of loops: for loops and while loops. Each Python loop type serves different purposes and is suited for specific scenarios in your programming journey.

Python loops follow the principle of DRY (Don’t Repeat Yourself), allowing you to write concise code that performs repetitive tasks efficiently. The beauty of Python loops lies in their simplicity and readability, making them accessible to beginners while remaining powerful enough for advanced applications.

Python For Loop: Iterating Through Sequences

The for loop in Python is designed to iterate over sequences like lists, tuples, strings, and dictionaries. Python for loops are particularly useful when you know the number of iterations beforehand or when working with iterable objects.

Basic For Loop Syntax

for variable in sequence:
# code to execute

For Loop with Lists

Python for loops excel at processing list elements:

programming_languages = ["Python", "Java", "JavaScript", "C++"]
for language in programming_languages:
print(f"Learning {language}")

This Python for loop iterates through each element in the list, making it easy to process collections of data.

For Loop with Strings

Python for loops can iterate through individual characters in strings:

message = "Python"
for character in message:
print(f"Character: {character}")

For Loop with Range Function

The range() function is commonly used with Python for loops to generate number sequences:

for number in range(5):
print(f"Number: {number}")

The range() function in Python loops can take up to three parameters: start, stop, and step:

for i in range(2, 10, 2):
print(f"Even number: {i}")

For Loop with Dictionaries

Python for loops can iterate through dictionary keys, values, or both:

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

# Iterate through keys
for student in student_grades:
print(f"Student: {student}")

# Iterate through values
for grade in student_grades.values():
print(f"Grade: {grade}")

# Iterate through key-value pairs
for student, grade in student_grades.items():
print(f"{student}: {grade}")

Python While Loop: Condition-Based Iteration

The while loop in Python executes code as long as a specified condition remains true. Python while loops are perfect for situations where you don’t know the exact number of iterations needed.

Basic While Loop Syntax

while condition:
# code to execute

Simple While Loop Example

counter = 0
while counter < 5:
print(f"Counter value: {counter}")
counter += 1

While Loop with User Input

Python while loops are excellent for handling user input validation:

user_input = ""
while user_input.lower() != "quit":
user_input = input("Enter a command (or 'quit' to exit): ")
print(f"You entered: {user_input}")

While Loop with Boolean Conditions

is_running = True
attempts = 0
while is_running and attempts < 3:
print(f"Attempt {attempts + 1}")
attempts += 1
if attempts == 2:
is_running = False

Python Nested Loops: Loops Within Loops

Nested loops in Python involve placing one loop inside another loop. Python nested loops are powerful for working with multi-dimensional data structures and complex iterations.

Nested For Loops

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

Nested Loops with Lists

Python nested loops are particularly useful for processing 2D lists:

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in matrix:
for element in row:
print(element, end=" ")
print() # New line after each row

Mixing For and While Loops

You can combine different types of Python loops in nested structures:

for i in range(3):
j = 0
while j < 2:
print(f"Outer loop: {i}, Inner loop: {j}")
j += 1

Loop Control Statements in Python

Python provides several control statements to modify loop behavior:

Break Statement

The break statement in Python loops immediately terminates the loop:

for i in range(10):
if i == 5:
break
print(i)

Continue Statement

The continue statement skips the current iteration and moves to the next:

for i in range(10):
if i % 2 == 0:
continue
print(f"Odd number: {i}")

Pass Statement

The pass statement is a null operation in Python loops:

for i in range(5):
if i == 3:
pass # Placeholder for future code
print(i)

Loop Else Clause in Python

Python loops support an else clause that executes when the loop completes normally (not terminated by break):

for i in range(5):
print(i)
else:
print("Loop completed successfully")

Enumerate Function with Python Loops

The enumerate() function adds a counter to Python for loops:

fruits = ["apple", "banana", "orange"]
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")

Zip Function with Python Loops

The zip() function allows you to iterate over multiple sequences simultaneously:

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
print(f"{name} is {age} years old")

List Comprehensions: Concise Python Loops

List comprehensions provide a concise way to create lists using Python loop logic:

squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]

Dictionary Comprehensions with Python Loops

Similar to list comprehensions, dictionary comprehensions use Python loop concepts:

square_dict = {x: x**2 for x in range(5)}
filtered_dict = {k: v for k, v in square_dict.items() if v > 5}

Complete Python Loops Example

Here’s a comprehensive example demonstrating various Python loop concepts:

# Import necessary modules
import random
import time

# Sample data for demonstration
students = ["Alice", "Bob", "Charlie", "Diana", "Eve"]
subjects = ["Math", "Science", "English", "History"]
grades = {}

# Initialize grades dictionary using nested loops
print("=== Initializing Student Grades ===")
for student in students:
grades[student] = {}
for subject in subjects:
# Generate random grades between 60-100
grade = random.randint(60, 100)
grades[student][subject] = grade
print(f"{student} - {subject}: {grade}")

print("\n=== Calculating Average Grades ===")
# Calculate average grade for each student using for loops
student_averages = {}
for student in students:
total = 0
count = 0
for subject in subjects:
total += grades[student][subject]
count += 1
average = total / count
student_averages[student] = round(average, 2)
print(f"{student}'s average: {average:.2f}")

print("\n=== Finding Top Performers ===")
# Find students with average > 80 using while loop
top_performers = []
student_index = 0
while student_index < len(students):
student = students[student_index]
if student_averages[student] > 80:
top_performers.append(student)
print(f"Top performer: {student} ({student_averages[student]})")
student_index += 1

print("\n=== Grade Distribution Analysis ===")
# Analyze grade distribution using nested loops and control statements
grade_ranges = {"A (90-100)": 0, "B (80-89)": 0, "C (70-79)": 0, "D (60-69)": 0}

for student in students:
for subject in subjects:
grade = grades[student][subject]

# Skip if grade is invalid (shouldn't happen in this example)
if grade < 0 or grade > 100:
continue

# Categorize grades
if grade >= 90:
grade_ranges["A (90-100)"] += 1
elif grade >= 80:
grade_ranges["B (80-89)"] += 1
elif grade >= 70:
grade_ranges["C (70-79)"] += 1
else:
grade_ranges["D (60-69)"] += 1

# Display grade distribution
for grade_range, count in grade_ranges.items():
print(f"{grade_range}: {count} students")

print("\n=== Subject-wise Analysis ===")
# Calculate subject averages using enumerate
subject_averages = {}
for index, subject in enumerate(subjects):
total = 0
count = 0

for student in students:
total += grades[student][subject]
count += 1

average = total / count
subject_averages[subject] = round(average, 2)
print(f"Subject {index + 1} - {subject}: {average:.2f} average")

print("\n=== Interactive Grade Lookup ===")
# Interactive loop for grade lookup
lookup_active = True
attempts = 0
max_attempts = 3

while lookup_active and attempts < max_attempts:
try:
print(f"\nAttempt {attempts + 1} of {max_attempts}")
print("Available students:", ", ".join(students))
student_name = input("Enter student name (or 'quit' to exit): ").strip()

if student_name.lower() == 'quit':
break

if student_name in students:
print(f"\n{student_name}'s grades:")
for subject, grade in grades[student_name].items():
print(f" {subject}: {grade}")
print(f" Average: {student_averages[student_name]}")

# Reset attempts on successful lookup
attempts = 0
else:
print("Student not found!")
attempts += 1

except KeyboardInterrupt:
print("\nProgram interrupted by user.")
break
except Exception as e:
print(f"An error occurred: {e}")
attempts += 1

print("\n=== Final Statistics ===")
# Final summary using various loop techniques
total_students = len(students)
total_subjects = len(subjects)
overall_average = sum(student_averages.values()) / total_students

print(f"Total students processed: {total_students}")
print(f"Total subjects: {total_subjects}")
print(f"Overall class average: {overall_average:.2f}")
print(f"Top performers: {', '.join(top_performers) if top_performers else 'None'}")

# Demonstrate loop else clause
print("\n=== Searching for Perfect Scores ===")
perfect_scores_found = False
for student in students:
for subject in subjects:
if grades[student][subject] == 100:
print(f"Perfect score found: {student} in {subject}")
perfect_scores_found = True
break
if perfect_scores_found:
break
else:
print("No perfect scores found in the class.")

print("\nProgram completed successfully!")

Expected Output:

=== Initializing Student Grades ===
Alice - Math: 87
Alice - Science: 92
Alice - English: 78
Alice - History: 85
Bob - Math: 94
Bob - Science: 88
Bob - English: 91
Bob - History: 76
[... continues with all students and subjects ...]

=== Calculating Average Grades ===
Alice's average: 85.50
Bob's average: 87.25
[... continues with all students ...]

=== Finding Top Performers ===
Top performer: Alice (85.50)
Top performer: Bob (87.25)
[... continues based on generated grades ...]

=== Grade Distribution Analysis ===
A (90-100): 8 students
B (80-89): 7 students
C (70-79): 3 students
D (60-69): 2 students

[... continues with remaining sections ...]

This comprehensive example demonstrates the power and versatility of Python loops in real-world applications. From basic iteration to complex nested structures, Python loops provide the foundation for efficient and readable code that can handle various programming challenges.