Meta Description: Want to become a Python 3 expert? Learn how to handle complex nested lists and dictionaries in Python 3 with our code examples and tips.

Introduction:

Python 3 is a popular programming language used for various applications, from web development to machine learning. Its simplicity, versatility, and easy-to-read syntax make it a favorite among developers.

However, when dealing with large datasets, handling nested lists and dictionaries can become a daunting task. If you’re struggling with these advanced data structures, don’t worry. In this article, we’ll provide you with the tools and techniques you need to handle advanced nested list and dictionary in Python 3.

What are Nested Lists and Dictionaries?

Before diving into the intricacies of advanced nested list and dictionary handling, let’s review what these data structures are.

Nested Lists: A list is a collection of items that are ordered and changeable. A nested list is a list that contains one or more lists as its elements.

For example:

my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Dictionaries: A dictionary is an unordered collection of items that are stored as key-value pairs. A nested dictionary is a dictionary that contains one or more dictionaries as its values.

For example:

my_dict = {'first': {'name': 'John', 'age': 25}, 'second': {'name': 'Jane', 'age': 30}}

Accessing Elements in Nested Lists and Dictionaries

Accessing elements in nested lists and dictionaries can be tricky, especially if you’re dealing with multiple layers of nesting.

To access an element in a nested list, you need to use multiple index operators. For example, to access the element “5” in the following nested list:

my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

You would use the following code:

print(my_list[1][1])

Output: 5

To access an element in a nested dictionary, you also need to use multiple keys. For example, to access the value “25” in the following nested dictionary:

my_dict = {'first': {'name': 'John', 'age': 25}, 'second': {'name': 'Jane', 'age': 30}}

You would use the following code:

print(my_dict['first']['age'])

Output: 25

Adding Elements to Nested Lists and Dictionaries

To add elements to a nested list, you can use the append() method or the extend() method. The append() method adds a single element to the end of the list, while the extend() method adds multiple elements to the end of the list.

For example, to add the list [10, 11, 12] to the end of the following nested list:

my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

You can use the extend() method:

my_list.extend([[10, 11, 12]])
print(my_list)

Output: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

To add elements to a nested dictionary, you can simply assign a new key-value pair to the dictionary.

For example, to add the key-value pair {‘third’: {‘name’: ‘Bob’, ‘age’: 35}} to the following nested dictionary:

my_dict = {'first': {'name': 'John', 'age': 25}, 'second': {'name': 'Jane', 'age': 30}}

You can use the following code:

my_dict['third'] = {'name': 'Bob', 'age': 35}
print(my_dict)

Output: {'first': {'name': 'John', 'age': 25}, 'second': {'name': 'Jane', 'age': 30}, 'third': {'name': 'Bob', 'age': 35}}

Removing Elements from Nested Lists and Dictionaries

To remove elements from a nested list, you can use the remove() method or the pop() method. The remove() method removes the first occurrence of a specified element in the list, while the pop() method removes the element at the specified index.

For example, to remove the list [4, 5, 6] from the following nested list:

my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

You can use the remove() method:

my_list.remove([4, 5, 6])
print(my_list)

Output: [[1, 2, 3], [7, 8, 9]]

To remove elements from a nested dictionary, you can use the del keyword or the pop() method. The del keyword removes the key-value pair with the specified key, while the pop() method removes the key-value pair at the specified key and returns its value.

For example, to remove the key-value pair with the key ‘second’ from the following nested dictionary:

my_dict = {'first': {'name': 'John', 'age': 25}, 'second': {'name': 'Jane', 'age': 30}}

You can use the del keyword:

del my_dict['second']
print(my_dict)

Output: {'first': {'name': 'John', 'age': 25}}

Modifying Elements in Nested Lists and Dictionaries

To modify an element in a nested list, you can simply assign a new value to the element using its index.

For example, to modify the element “5” to “50” in the following nested list:

my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

You can use the following code:

my_list[1][1] = 50
print(my_list)

Output: [[1, 2, 3], [4, 50, 6], [7, 8, 9]]

To modify an element in a nested dictionary, you can simply assign a new value to the key using its key.

For example, to modify the value “30” to “35” in the following nested dictionary:

my_dict = {'first': {'name': 'John', 'age': 25}, 'second': {'name': 'Jane', 'age': 30}}

You can use the following code:

my_dict['second']['age'] = 35
print(my_dict)

Output: {'first': {'name': 'John', 'age': 25}, 'second': {'name': 'Jane', 'age': 35}}

Handling Advanced Nested List and Dictionary Operations

Now that we’ve covered the basics of accessing, adding, removing, and modifying elements in nested lists and dictionaries, let’s dive into some more advanced operations.

Flattening Nested Lists

Flattening a nested list means converting it to a single-level list. This is useful when you want to perform operations on all the elements in the list without having to worry about their nested structure.

To flatten a nested list, you can use a recursive function that checks whether each element is a list or not. If it is a list, the function calls itself on the element. If it is not a list, the function adds the element to a new list.

Here’s an example of a flatten function that flattens a nested list:

def flatten(nested_list):
flattened_list = []
for element in nested_list:
if type(element) == list:
flattened_list.extend(flatten(element))
else:
flattened_list.append(element)
return flattened_list

For example, to flatten the following nested list:

my_list = [[1, 2, [3]], [4, [5, 6]], 7]

You can use the flatten function:

flattened_list = flatten(my_list)
print(flattened_list)

Merging Nested Dictionaries

Merging nested dictionaries means combining two or more dictionaries into a single dictionary. This is useful when you want to aggregate data from multiple sources or perform operations on all the values in the dictionaries.

To merge nested dictionaries, you can use the update() method. The update() method updates the dictionary with the key-value pairs from another dictionary. If the key already exists in the dictionary, the update() method overwrites the existing value with the new value.

Here’s an example of a merge_dicts function that merges two dictionaries:

def merge_dicts(dict1, dict2):
merged_dict = dict1.copy()
for key, value in dict2.items():
if key in merged_dict and isinstance(merged_dict[key], dict) and isinstance(value, dict):
merged_dict[key] = merge_dicts(merged_dict[key], value)
else:
merged_dict[key] = value
return merged_dict

For example, to merge the following nested dictionaries:

dict1 = {'a': {'b': 1, 'c': 2}, 'd': {'e': {'f': 3}}}
dict2 = {'a': {'b': 10, 'c': 20}, 'd': {'e': {'g': 4}}}

You can use the merge_dicts function:

merged_dict = merge_dicts(dict1, dict2)
print(merged_dict)

Output: {'a': {'b': 10, 'c': 20}, 'd': {'e': {'f': 3, 'g': 4}}}

Sorting Nested Lists and Dictionaries

Sorting a nested list or dictionary means arranging its elements or key-value pairs in a particular order. This is useful when you want to organize the data or perform operations that require the elements to be in a specific order.

To sort a nested list, you can use the sort() method or the sorted() function. The sort() method sorts the list in place, while the sorted() function returns a new sorted list.

For example, to sort the following nested list in descending order:

my_list = [[3, 4, 1, [2, 5, 6], [9, 7, 8]]

sorted_list = sorted(my_list, key=lambda x: x[0], reverse=True) print(sorted_list)

my_dict = {'first': {'name': 'John', 'age': 25}, 'second': {'name': 'Jane', 'age': 30}, 'third': {'name': 'Bob', 'age': 20}}

sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[1]['age'])) print(sorted_dict)

Output: `{'third': {'name': 'Bob', 'age': 20}, 'first': {'name': 'John', 'age': 25}, 'second': {'name': 'Jane', 'age': 30}}` 

Sanjay Yadav

Optical Networking Engineer & Architect • Founder, MapYourTech

Optical networking engineer with nearly two decades of experience across DWDM, OTN, coherent optics, submarine systems, and cloud infrastructure. Founder of MapYourTech. Read full bio →

Follow on LinkedIn

Related Articles on MapYourTech

Analysis · Apr 20, 2026

Design your link, learn the Shannon limit

Coherent Optics · Apr 19, 2026

Multi-Rail Line Systems:Architectural Response to the AI-Driven Fiber Density Problem

Analysis · Apr 18, 2026

Optical Network Architects Reference Guide

Free · Apr 17, 2026

The 5-Microsecond Rule: Fiber Propagation Latency per Kilometer