Python Looping Through Arrays (Lists) Tutorial with Examples

In Python, arrays (more commonly referred to as lists) are sequences that can store a collection of items.

Looping through arrays (lists) is a fundamental operation when you need to process, manipulate, or access individual elements of the list.

Python provides several ways to loop through arrays efficiently.

In this tutorial, we will cover:

1. What is an Array (List) in Python?
2. Basic Looping Through Arrays with for Loops
3. Looping Through Arrays with while Loops
4. Using enumerate() to Loop with Index and Value
5. Looping Through Arrays with List Comprehensions
6. Looping Through Arrays Using range() and len()
7. Common Use Cases of Looping Through Arrays
8. Examples and Practice with Array Looping

Let’s explore each topic with examples and explanations.

1. What is an Array (List) in Python?

In Python, arrays are typically implemented using lists. Lists are mutable sequences, meaning their elements can be modified. Lists can hold elements of different data types, including numbers, strings, and other lists.

Example of a List (Array):

my_list = [1, 2, 3, 4, 5]
print(my_list)  # Output: [1, 2, 3, 4, 5]

2. Basic Looping Through Arrays with for Loops

The most common way to loop through an array in Python is by using a for loop. This method allows you to access each element in the list, one by one.

Example 1: Looping Through a List of Numbers

numbers = [10, 20, 30, 40, 50]

for num in numbers:
    print(num)

Output:

10
20
30
40
50

• In this example, the for loop iterates through the list numbers, printing each element.

Example 2: Looping Through a List of Strings

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

for fruit in fruits:
    print(fruit)

Output:

apple
banana
cherry

• In this example, each string element in the list is printed by the for loop.

3. Looping Through Arrays with while Loops

You can also use a while loop to iterate through an array by using an index to access elements. You need to manually manage the loop counter and ensure it does not exceed the array’s length.

Example: Looping with a while Loop

numbers = [1, 2, 3, 4, 5]
i = 0  # Initialize index

while i < len(numbers):
    print(numbers[i])
    i += 1

Output:

1
2
3
4
5

• In this example, the while loop iterates through the list using an index variable i, which is manually incremented.

4. Using enumerate() to Loop with Index and Value

The enumerate() function allows you to loop through a list while accessing both the index and the value of each element. This is useful when you need to keep track of the element’s position in the list.

Example: Looping with enumerate()

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

for index, fruit in enumerate(fruits):
    print(f"Index {index}: {fruit}")

Output:

Index 0: apple
Index 1: banana
Index 2: cherry

• In this example, enumerate() returns both the index and the value, allowing you to display both during iteration.

5. Looping Through Arrays with List Comprehensions

List comprehensions provide a concise way to loop through lists and create new lists based on the original list. They are a one-liner alternative to traditional for loops.

Example: List Comprehension to Double Each Element

numbers = [1, 2, 3, 4, 5]

# Create a new list with each number doubled
doubled_numbers = [num * 2 for num in numbers]

print(doubled_numbers)  # Output: [2, 4, 6, 8, 10]

• In this example, a new list doubled_numbers is created by looping through numbers and multiplying each element by 2.

Example: List Comprehension with Conditional Logic

numbers = [1, 2, 3, 4, 5, 6]

# Create a new list with only the even numbers
even_numbers = [num for num in numbers if num % 2 == 0]

print(even_numbers)  # Output: [2, 4, 6]

• In this example, list comprehension is used to filter the list and include only the even numbers.

6. Looping Through Arrays Using range() and len()

You can use the range() function along with len() to generate a sequence of indices, which can be used to access elements in a list by their position.

Example: Looping with range() and len()

numbers = [100, 200, 300, 400]

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

Output:

Index 0: 100
Index 1: 200
Index 2: 300
Index 3: 400

• In this example, range(len(numbers)) generates a sequence of indices, allowing us to access both the index and the value of each element in the list.

7. Common Use Cases of Looping Through Arrays

Looping through arrays is useful in many real-world scenarios, such as:

• Processing lists of data: For example, processing a list of numbers or strings.
• Modifying elements: Looping through arrays to modify each element or perform calculations.
• Filtering data: Creating new arrays based on conditions (e.g., selecting only even numbers).
• Performing operations: Aggregating values, such as finding the sum or maximum of the list.

Example 1: Finding the Sum of a List

numbers = [10, 20, 30, 40]

total_sum = 0
for num in numbers:
    total_sum += num

print(f"Total sum: {total_sum}")  # Output: Total sum: 100

• In this example, we loop through the numbers list and calculate the sum of all elements.

Example 2: Finding the Maximum Value in a List

numbers = [5, 10, 15, 20]

max_num = numbers[0]
for num in numbers:
    if num > max_num:
        max_num = num

print(f"Maximum number: {max_num}")  # Output: Maximum number: 20

• In this example, we loop through the list to find the maximum value by comparing each element to the current maximum.

8. Examples and Practice with Array Looping

Example 1: Looping Through a List of Names

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

for name in names:
    print(f"Hello, {name}!")

Output:

Hello, Alice!
Hello, Bob!
Hello, Charlie!

• In this example, we loop through a list of names and print a greeting for each name.

Example 2: Modifying Elements in a List

numbers = [1, 2, 3, 4, 5]

# Double each element in the list
for i in range(len(numbers)):
    numbers[i] = numbers[i] * 2

print(numbers)  # Output: [2, 4, 6, 8, 10]

• In this example, we loop through the list and modify each element by doubling its value.

Example 3: Filtering a List with a for Loop

numbers = [10, 15, 20, 25, 30]

# Create a new list with numbers greater than 20
filtered_numbers = []
for num in numbers:
    if num > 20:
        filtered_numbers.append(num)

print(filtered_numbers)  # Output: [25, 30]

• In this example, we filter out numbers greater than 20 and store them in a new list.

Summary of Python Array Looping Methods:

Conclusion

Looping through arrays (or lists) in Python is essential for processing and manipulating data. In this tutorial, we covered:

• Basic and advanced methods for looping through arrays, such as for loops, while loops, enumerate(), and list comprehensions.
• Examples of common use cases, such as finding sums, modifying elements, and filtering data.
• Various techniques for accessing and iterating through lists efficiently.