5 Best Ways to Iterate Through a Nested List in Python

💡 Problem Formulation: Python developers often encounter the need to traverse nested lists to perform various operations, whether it’s summing numbers, flattening the structure, or applying functions to each element. A nested list is a list that contains other lists as its elements, creating a multi-dimensional array-like structure. The goal is to iterate over all the inner lists and process the individual values, considering an input like [[1, 2], [3, 4], [5, 6]] and aiming for a flattened or processed output depending on the task.

Method 1: Using a Nested For Loop

The most straightforward approach to iterate over a nested list is using a nested for loop. This method explicitly specifies loops for each level of the list structure, offering clear and easy-to-understand code. It is most effective for lists with known and fixed levels of nesting.

Here’s an example:

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

for sub_list in nested_list:
    for item in sub_list:
        print(item)

Output:

This code snippet features two loops: the outer loop takes each sublist from the nested list, and the inner loop goes through each element in the current sublist. It’s a comprehensible way to access each element but can become cumbersome with deeper nesting.

Method 2: Using the itertools.chain() Function

The itertools.chain() function is a part of the itertools module, which is specifically designed for efficient looping. This function can be used to iterate through concatenated elements of the nested list in a single for loop. It’s especially useful when the depth of the nested list does not matter.

Here’s an example:

import itertools

nested_list = [[1, 2], [3, 4], [5, 6]]
flattened = list(itertools.chain(*nested_list))

for item in flattened:
    print(item)

Output:

The itertools.chain(*nested_list) function takes each sublist from the nested list and chains them into an iterator. The elements are then accessed in a flat structure using a single loop. This is efficient but doesn’t allow easy identification of which original sublist an item came from.

Method 3: Using List Comprehensions

List comprehensions in Python provide a concise way to create lists. A nested list comprehension can be used to flatten a nested list and iterate over its elements in a single line of code, integrating both creation and iteration in a clear and concise syntax.

Here’s an example:

nested_list = [[1, 2], [3, 4], [5, 6]]
flattened = [item for sublist in nested_list for item in sublist]

for item in flattened:
    print(item)

Output:

The code uses a nested list comprehension to create a new list, flattened, by iterating over each element of each sublist. It then iterates over the flattened list to print each item. This method is very Pythonic and efficient but can be hard to read for more complex operations.

Method 4: Using Recursive Function

For deeply nested lists with varying levels of depth, a recursive function can be written to iterate through all the elements regardless of nesting. The function calls itself with the nested elements until it reaches non-list items, making it very powerful but also potentially complex for deeper nesting.

Here’s an example:

def iterate_nested_list(nested_list):
    for element in nested_list:
        if isinstance(element, list):
            iterate_nested_list(element)
        else:
            print(element)

nested_list = [[1, 2], [3, 4, [5, 6]]]
iterate_nested_list(nested_list)

Output:

The recursive function iterate_nested_list() checks if an element is a list; if so, it calls itself with that sublist. Otherwise, it prints the element. It is comprehensive but care must be taken to avoid maximum recursion depth errors in Python.

Bonus One-Liner Method 5: Using the sum() Function

The built-in sum() function can be cleverly used to flatten a list by initiating the sum with an empty list. This method is quick and straightforward for lists with only one level of nesting.

Here’s an example:

nested_list = [[1, 2], [3, 4], [5, 6]]
flattened = sum(nested_list, [])

for item in flattened:
    print(item)

Output:

By using sum(nested_list, []), we concatenate the sublists in the nested_list starting with an empty list. Then, each element is printed out. Note that this method is not suitable for deeply nested or very large lists due to its potential inefficiency.

Summary/Discussion

Method 1: Nested For Loop. Simple to understand and implement. Best for lists with a fixed nesting level. May become unwieldy with deep nesting.
Method 2: itertools.chain(). Efficient for any depth. Useful for flattening a nested list into an iterator. Does not retain information about sublist origins.
Method 3: List Comprehensions. Pythonic and concise. Suitable for simple flattening tasks. May become less readable with added complexity.
Method 4: Recursive Function. Versatile for variable-depth nesting. Allows comprehensive control over iteration. Can be complex and risk hitting recursion limits for very deep lists.
Bonus Method 5: sum() Function. Quick and easy for one-level nesting. Not recommended for deep nesting or very large lists due to inefficiency.