PYTHON
Flatten a Nested Python List Efficiently
Learn Pythonic methods, including list comprehensions and recursive functions, to flatten a list containing other lists into a single, cohesive list.
nested_list = [1, [2, 3], 4, [5, [6, 7], 8], 9]
list_of_lists = [[1, 2], [3, 4, 5], [6]]
# Method 1: Flatten a list of lists (single level) using list comprehension
flat_list_comprehension = [item for sublist in list_of_lists for item in sublist]
print(f"Flattened single level (comprehension): {flat_list_comprehension}")
# Method 2: Flatten a list of lists (single level) using sum()
# Note: sum() can be slower for large lists as it creates new lists repeatedly
flat_list_sum = sum(list_of_lists, [])
print(f"Flattened single level (sum): {flat_list_sum}")
# Method 3: Flatten a deeply nested list using a recursive function
def flatten_deep_list(nested):
flat = []
for item in nested:
if isinstance(item, list):
flat.extend(flatten_deep_list(item))
else:
flat.append(item)
return flat
deeply_flat_list = flatten_deep_list(nested_list)
print(f"Flattened deeply nested (recursive): {deeply_flat_list}")
# Method 4: Flatten deeply nested using a generator (more memory efficient for large lists)
def flatten_deep_generator(nested):
for item in nested:
if isinstance(item, list):
yield from flatten_deep_generator(item)
else:
yield item
deeply_flat_generator = list(flatten_deep_generator(nested_list))
print(f"Flattened deeply nested (generator): {deeply_flat_generator}")
How it works: Flattening nested lists is a common task in data processing. For single-level nesting (a list of lists), list comprehensions provide a concise and efficient solution. For deeply nested lists, a recursive function is effective, iterating through items and recursively calling itself for sublists, appending non-list items directly. A generator-based approach offers better memory efficiency for very large nested structures by yielding items one by one instead of building an entire list in memory.