Python - Type conversion in Nested and Mixed List

Python lists are heterogeneous and can contain nested structures, making type conversion a crucial skill. When working with nested lists (lists within lists) or mixed lists (containing different data types), we need special techniques to convert elements while preserving the original structure.

In this article, we will explore three effective methods for type conversion in nested and mixed lists using list comprehension, recursion, and the map() function.

Understanding Nested and Mixed Lists

A nested list contains other lists as elements, creating a hierarchical structure. A mixed list contains elements of different data types like integers, strings, lists, and tuples.

# Nested list
nested = [1, [2, 3], [4, [5, 6]]]

# Mixed list  
mixed = ['1', 2, ('3', ['4', '5']), [6, '7']]
print("Nested list:", nested)
print("Mixed list:", mixed)

Nested list: [1, [2, 3], [4, [5, 6]]]
Mixed list: ['1', 2, ('3', ['4', '5']), [6, '7']]

Method 1: Using List Comprehension

List comprehension provides an elegant way to convert elements while checking their type ?

data = [6, 5, [1, 2], 3]
print("Original list:", data)

# Convert all elements to strings, preserving nested structure
result = [[str(ele) for ele in sublist] if isinstance(sublist, list) else str(sublist) for sublist in data]
print("After conversion:", result)

Original list: [6, 5, [1, 2], 3]
After conversion: ['6', '5', ['1', '2'], '3']

Method 2: Using Recursion

Recursion handles deeply nested structures by calling itself for each nested element ?

def convert_to_string(element):
    if isinstance(element, list):
        return [convert_to_string(item) for item in element]
    else:
        return str(element)

data = [6, 5, [1, 2], 3]
print("Original list:", data)

result = convert_to_string(data)
print("After conversion:", result)

Original list: [6, 5, [1, 2], 3]
After conversion: ['6', '5', ['1', '2'], '3']

Handling Mixed Data Types

For mixed lists containing tuples and other types ?

def convert_to_int(element):
    if isinstance(element, list):
        return [convert_to_int(item) for item in element]
    elif isinstance(element, tuple):
        return tuple(convert_to_int(item) for item in element)
    else:
        return int(element)

mixed_data = ['1', '2', ('3', ['4', '5']), ['6', '7']]
print("Original mixed list:", mixed_data)

result = convert_to_int(mixed_data)
print("After conversion:", result)

Original mixed list: ['1', '2', ('3', ['4', '5']), ['6', '7']]
After conversion: [1, 2, (3, [4, 5]), [6, 7]]

Method 3: Using map() and lambda

The map() function applies a lambda function to each element efficiently ?

def convert_with_map(data):
    return list(map(lambda x: convert_with_map(x) if isinstance(x, (list, tuple)) else int(x), data))

mixed_data = ['1', '2', ('3', ['4', '5']), ['6', '7']]
print("Original list:", mixed_data)

result = convert_with_map(mixed_data)
print("After conversion:", result)

Original list: ['1', '2', ('3', ['4', '5']), ['6', '7']]
After conversion: [1, 2, (3, [4, 5]), [6, 7]]

Comparison

Conclusion

Type conversion in nested and mixed lists requires careful handling to preserve structure while converting elements. Use list comprehension for simple cases, recursion for complex nested structures, and map() for functional programming approaches.