Python Data Structure Exercises (List, Set,

Dictionary, and Tuple)

As you delve into these Python data structure exercises, consider the
context behind each problem. Embrace the beauty of Pythonic syntax,
the simplicity that conceals powerful operations, and the joy of
creating expressive code. With each exercise, you’re not just solving a
problem; you’re composing a piece of code that tells a story.
List Operations:
The one Python data structure that you’ll use the most in your code is
the Python list. So, it is essential to practice problems that require
using it.
Exercise #1
Problem: Create a list of numbers and find the sum of all elements.
Context: This exercise helps you practice basic list creation and
element-wise addition.
Solution:

numbers = [1, 2, 3, 4, 5]
sum_of_elements = sum(numbers)
print(sum_of_elements)

Copy
Exercise #2
Problem: Remove duplicates from a list and make a unique Python
list.

Context: This exercise focuses on utilizing sets to eliminate duplicate

elements.

Solution:

original_list = [1, 2, 2, 3, 4, 4, 5]
unique_list = list(set(original_list))
print(unique_list)

Copy
Exercise #3
Problem: Check if a list is empty.

Context: Understanding how to verify if a list has no elements.

Solution:
my_list = []
is_empty = not bool(my_list)
print(is_empty)

Copy
Exercise #4
Problem: Reverse a list.

Context: Practice reversing the order of elements in a list.

Solution:

my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]
print(reversed_list)

Copy
Exercise #5
Problem: Find the index of a specific element in a list.

Context: Learn how to locate the position of an element in a list.

Solution:

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

element_to_find = 30
index = my_list.index(element_to_find)
print(index)

Copy
Set Operations:
It is a data structure that has its concept borrowed from the
mathematical term called the set. Python set has similar properties as
they are in Maths. So, we can confidently say this about the sets in
Python:

Sets in mathematics are collections of distinct elements without any

specific order. Similarly, in Python, a set is an unordered collection of
unique elements.

The Coding Mind

Exercise #6
Problem: Perform union and intersection of two sets.
Context: Understand the concepts of union and intersection in sets.
Solution:

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
union_set = set1.union(set2)
intersection_set = set1.intersection(set2)
print(union_set, intersection_set)

Copy
Exercise #7
Problem: Check if a set is a subset of another set.
Context: Practice checking whether one set is contained within
another.
Solution:

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}
is_subset = set1.issubset(set2)
print(is_subset)

Copy
Exercise #8
Problem: Remove an element from a set.
Context: Learn how to eliminate a specific element from a set.
Solution:

my_set = {1, 2, 3, 4, 5}
element_to_remove = 3
my_set.remove(element_to_remove)
print(my_set)

Copy
Exercise #9
Problem: Find the difference between two sets.
Context: Understand how to find elements that exist in one set but
not in another.
Solution:

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
difference_set = set1.difference(set2)
print(difference_set)

Copy
Exercise #10
Problem: Check if the two sets have any elements in common.
Context: Determine if there is an intersection between two sets.
Solution:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
have_common_elements = bool(set1.intersection(set2))
print(have_common_elements)

Copy
Dictionary Operations:
Learning dictionaries in Python is crucial because they help you quickly
find information using keys, handle different types of data, and mimic
real-life connections. Dictionaries are widely used in Python, making
them an essential tool for problem-solving in various applications.
Dictionaries in Python act like real-world dictionaries. They store
information as key-value pairs, allowing quick and efficient access to
data. Think of a dictionary as a dynamic tool for organizing and
managing information in Python. It’s a versatile and essential feature,
making tasks like retrieval, insertion, and deletion of data a breeze.
Exercise #11
Problem: Create a dictionary and access its values using keys.

Context: Practice dictionary creation and key-based value retrieval.

Solution:

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}

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

Copy
Exercise #12
Problem: Check if a key exists in a dictionary.
Context: Learn how to verify if a specific key is present in a dictionary.
Solution:

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}

key_to_check = 'age'
key_exists = key_to_check in my_dict
print(key_exists)

Copy
Exercise #13
Problem: Merge two dictionaries.

Context: Understand how to combine the contents of two dictionaries.

Solution:

dict1 = {'name': 'John', 'age': 25}

dict2 = {'city': 'New York', 'gender': 'Male'}
merged_dict = {**dict1, **dict2}
print(merged_dict)

Copy
Exercise #14
Problem: Remove a key-value pair from a dictionary.

Context: Practice deleting a specific entry from a dictionary.

Solution:

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}

key_to_remove = 'age'
my_dict.pop(key_to_remove, None)
print(my_dict)

Copy
Exercise #15
Problem: Extract all keys from a dictionary.

Context: Learn how to obtain a list of all keys in a dictionary.

Solution:
my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
keys_list = list(my_dict.keys())
print(keys_list)

Copy
Tuple Operations:
Tuples in Python are like unchangeable lists. They allow you to store a
collection of items, and once created, their values cannot be modified.
Tuples are handy for situations where you want to ensure data
integrity or create a set of values that should stay constant throughout
your program. They’re lightweight, easy to use, and offer a
straightforward way to structure data in Python.

Learning Python tuples is helpful because they keep data safe from
accidental changes, can be faster in some cases, and work well with
functions that provide multiple results. They’re handy when you want
stability in your data or when dealing with functions that use tuples.
Exercise #16
Problem: Create a tuple and perform concatenation.
Context: Practice tuple creation and combining multiple tuples.

Solution:

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
concatenated_tuple = tuple1 + tuple2
print(concatenated_tuple)

Copy
Exercise #17
Problem: Access elements in a tuple using negative indexing.
Context: Learn how to retrieve elements from a tuple using negative
indices.

Solution:

my_tuple = (10, 20, 30, 40, 50)

last_element = my_tuple[-1]
print(last_element)

Copy
Exercise #18
Problem: Find the length of a tuple.
Context: Practice obtaining the number of elements in a tuple.

Solution:

my_tuple = (10, 20, 30, 40, 50)

length_of_tuple = len(my_tuple)
print(length_of_tuple)

Copy
Exercise #19
Problem: Check if an element exists in a tuple.
Context: Determine if a specific element is present in a tuple.

Solution:

my_tuple = (10, 20, 30, 40, 50)

element_to_check = 30
element_exists = element_to_check in my_tuple
print(element_exists)

Copy
Exercise #20
Problem: Convert a tuple to a list.
Context: Understand the process of converting a tuple to

a list.
Solution:

my_tuple = (1, 2, 3, 4, 5)
my_list = list(my_tuple)
print(my_list)

Copy
These exercises cover a range of operations on Python data structures,
providing a solid foundation for working with lists, sets, dictionaries,
and tuples. Feel free to explore and modify them to deepen your
understanding of Python’s data manipulation capabilities.

Here is the next set of exercises continuing from Exercise #21 to

Exercise #50:
Tuple Operations (Continued):
Exercise #21
Problem: Count the occurrences of an element in a tuple.
Context: Learn how to count the number of times a specific element
appears in a tuple.

Solution:

my_tuple = (1, 2, 2, 3, 2, 4, 5)
element_to_count = 2
count_occurrences = my_tuple.count(element_to_count)
print(count_occurrences)

Copy
Exercise #22
Problem: Create a tuple and find the minimum and maximum values.
Context: Practice finding the smallest and largest values in a tuple.

Solution:

my_tuple = (10, 5, 20, 8, 15)

min_value = min(my_tuple)
max_value = max(my_tuple)
print(min_value, max_value)

Copy
Exercise #23
Problem: Check if all elements in a tuple are the same.
Context: Determine whether all elements in a tuple are equal.

Solution:

my_tuple = (3, 3, 3, 3, 3)
are_all_same = all(x == my_tuple[0] for x in my_tuple)
print(are_all_same)

Copy
Exercise #24
Problem: Multiply all elements in a tuple.
Context: Practice performing a multiplication operation on all
elements of a tuple.
Solution:

my_tuple = (2, 3, 4, 5)
product_of_elements = 1
for element in my_tuple:
product_of_elements *= element
print(product_of_elements)

Copy
Exercise #25
Problem: Create a tuple of strings and concatenate them.
Context: Explore the concatenation of string elements in a tuple.

Solution:

string_tuple = ('Hello', ' ', 'World', '!')

concatenated_string = ''.join(string_tuple)
print(concatenated_string)

Copy
List Comprehension:
Sure, here’s a simple description of list comprehension in Python:
List comprehension in Python is a concise and expressive way to
create lists. It allows you to generate a new list by applying an
expression to each item in an existing iterable (like a list or range).
This powerful feature enhances code readability and simplifies the
process of creating lists, making it a valuable skill for efficient and
clean Python programming.

Learning list comprehension in Python is important because it helps

you write shorter, clearer, and more efficient code for creating and
modifying lists. It’s like a shortcut that makes your Python programs
neater and easier to understand.
Exercise #26
Problem: Generate a list of squares for numbers 1 to 10 using list
comprehension.
Context: Practice using list comprehension to generate a new list.

Solution:

squares = [x**2 for x in range(1, 11)]

print(squares)

Copy
Exercise #27
Problem: Extract odd numbers from a list using list comprehension.
Context: Learn how to filter elements using list comprehension.
Solution:

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

odd_numbers = [x for x in numbers if x % 2 != 0]
print(odd_numbers)

Copy
Exercise #28
Problem: Create a list of tuples with elements and their squares.
Context: Practice creating tuples and combining them in a list using
list comprehension.
Solution:

numbers = [1, 2, 3, 4, 5]
squares_tuples = [(x, x**2) for x in numbers]
print(squares_tuples)

Copy
Exercise #29
Problem: Flatten a nested list using list comprehension.
Context: Understand how to flatten a list containing nested lists.
Solution:

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

flat_list = [element for sublist in nested_list for element in sublist]
print(flat_list)

Copy
Exercise #30
Problem: Create a list excluding even numbers using list
comprehension.
Context: Practice list comprehension with a condition to exclude
certain elements.
Solution:
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
odd_numbers = [x for x in numbers if x % 2 != 0]
print(odd_numbers)

Copy
Dictionary Comprehension:
Dictionary comprehension in Python is a quick and neat way to create
dictionaries. It lets you build a new dictionary by specifying key-value
pairs using a simple expression applied to each item in an existing
collection. It’s like a shortcut to make your Python code for creating
dictionaries shorter and easier to understand.
Learning dictionary comprehension in Python is important because it
also helps you write shorter and clearer code for creating dictionaries.
It makes your Python programs more efficient and follows the way
Python likes things to be done. It’s like a handy tool to make your code
neater and smarter.
Exercise #31
Problem: Create a dictionary with keys as numbers and values as
their squares using dictionary comprehension.
Context: Practice creating dictionaries using dictionary
comprehension.
Solution:

numbers = [1, 2, 3, 4, 5]
squares_dict = {x: x**2 for x in numbers}
print(squares_dict)

Copy
Exercise #32
Problem: Filter a dictionary to exclude keys divisible by 3 using
dictionary comprehension.
Context: Understand how to filter keys in a dictionary using
comprehension.
Solution:

original_dict = {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}

filtered_dict = {key: value for key, value in original_dict.items() if key
% 3 != 0}
print(filtered_dict)

Copy
Exercise #33
Problem: Swap keys and values in a dictionary using dictionary
comprehension.
Context: Learn how to exchange keys and values in a dictionary.
Solution:

original_dict = {'a': 1, 'b': 2, 'c': 3}

swapped_dict = {value: key for key, value in original_dict.items()}
print(swapped_dict)

Copy
Exercise #34
Problem: Merge two dictionaries using dictionary comprehension.
Context: Practice combining the contents of two dictionaries using
comprehension.
Solution:

dict1 = {'a': 1, 'b': 2}

dict2 = {'c': 3, 'd': 4}
merged_dict = {key: value for d in [dict1, dict2] for key, value in
d.items()}
print(merged_dict)

Copy
Exercise #35
Problem: Create a dictionary excluding keys with values less than 3
using dictionary comprehension.
Context: Practice filtering dictionaries based on values using
comprehension.
Solution:

original_dict = {'a': 2, 'b': 1, 'c': 4, 'd': 3}

filtered_dict = {key: value for key, value in original_dict.items() if
value >= 3}
print(filtered_dict)

Copy
Set Comprehension:
Set comprehension in Python is a quick way to create sets. It lets you
make a new set by using a simple expression for each item in an
existing collection. It’s like a shortcut to create sets easily and neatly in
Python.
Doing exercises on set comprehension in Python is good because it
helps you write code that’s short and easy to understand. It’s like a
handy tool to create unique sets clearly and practically, making your
Python programming experience smoother.
Exercise #36
Problem: Create a set of squares for numbers 1 to 5 using set
comprehension.
Context: Practice using set comprehension to generate a new set.
Solution:

squares_set = {x**2 for x in range(1, 6)}

print(squares_set)

Copy
Exercise #37
Problem: Create a set excluding multiples of 3 using set
comprehension.
Context: Understand how to filter elements using set comprehension.
Solution:

numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

non_multiples_of_three = {x for x in numbers if x % 3 != 0}
print(non_multiples_of_three)

Copy
Exercise #38
Problem: Create a set of common elements between two sets using
set comprehension.
Context:
Learn how to find the intersection of two sets using set comprehension.
Solution:

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
common_elements = {x for x in set1 if x in set2}
print(common_elements)

Copy
Exercise #39
Problem: Create a set of lengths of words in a list using set
comprehension.
Context: Practice extracting lengths of words and creating a set using
comprehension.
Solution:

words = ['apple', 'banana', 'orange', 'grape']

word_lengths = {len(word) for word in words}
print(word_lengths)

Copy
Exercise #40
Problem: Create a set of vowels from a given string using set
comprehension.
Context: Understand how to extract specific characters from a string
using comprehension.
Solution:

my_string = 'hello world'

vowels = {char for char in my_string if char in 'aeiou'}
print(vowels)

Copy
Advanced Python Data Structure (List) Exercises:
Doing advanced data structure exercises in Python is great because it
helps your coding to get better by solving trickier problems. It’s like
adding cool tools to your coding toolbox, making your programming
skills stronger and more useful for real-life situations.
Exercise #41
Problem: Implement a matrix transposition using list comprehension.
Context: Practice transposing a matrix using nested list
comprehension.
Solution:

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

transpose_matrix = [[row[i] for row in matrix] for i in
range(len(matrix[0]))]
print(transpose_matrix)

Copy
Exercise #42
Problem: Implement a zip operation on two lists using list
comprehension.
Context: Understand how to pair elements from two lists using zip and
list comprehension.
Solution:

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped_lists = [(a, b) for a, b in zip(list1, list2)]
print(zipped_lists)

Copy
Exercise #43
Problem: Implement a running sum for a list using list comprehension.
Context: Practice creating a new list with cumulative sums using list
comprehension.
Solution:

original_list = [1, 2, 3, 4, 5]
running_sum = [sum(original_list[:i+1]) for i in
range(len(original_list))]
print(running_sum)

Copy
Exercise #44
Problem: Implement a nested list flattening using list comprehension.
Context: Learn how to flatten a nested list using nested list
comprehension.
Solution:

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

flattened_list = [element for sublist in nested_list for element in
sublist]
print(flattened_list)

Copy
Exercise #45
Problem: Implement a filter to exclude negative numbers from a list
using list comprehension.
Context: Practice filtering elements based on a condition using list
comprehension.
Solution:

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

positive_numbers = [x for x in numbers if x >= 0]
print(positive_numbers)

Copy
Advanced Python Data Structure (Dictionary) Exercises:
Solving exercises on advanced dictionary operations in Python is useful
because it makes your code work better, improves your problem-
solving skills, and helps you handle real-world data situations more
effectively. It’s like adding powerful tools to your coding skills.
Exercise #46
Problem: Merge two dictionaries and sum values for common keys.
Context: Practice merging dictionaries and performing operations on
common keys.
Solution:

dict1 = {'a': 1, 'b': 2, 'c': 3}

dict2 = {'b': 4, 'c': 5, 'd': 6}
merged_dict = {key: dict1.get(key, 0) + dict2.get(key, 0) for key in
set(dict1) | set(dict2)}
print(merged_dict)

Copy
Exercise #47
Problem: Group a list of tuples by the first element using dictionary
comprehension.
Context: Understand how to group elements in a list of tuples using
dictionary comprehension.
Solution:

pairs = [('a', 1), ('b', 2), ('a', 3), ('b', 4)]

grouped_dict = {key: [value for k, value in pairs if k == key] for key in
set(k for k, v in pairs)}
print(grouped_dict)

Copy
Exercise #48
Problem: Extract unique elements and their counts from a list using
dictionary comprehension.
Context: Practice creating a dictionary with unique elements and their
counts using comprehension.
Solution:

my_list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique_counts = {element: my_list.count(element) for element in
set(my_list)}
print(unique_counts)

Copy
Exercise #49
Problem: Find common keys in two dictionaries using dictionary
comprehension.
Context: Learn how to find common keys in two dictionaries using
comprehension.
Solution:

dict1 = {'a': 1, 'b': 2, 'c': 3}

dict2 = {'b': 4, 'c': 5, 'd': 6}
common_keys = {key for key in dict1 if key in dict2}
print(common_keys)

Copy
Exercise #50
Problem: Create a dictionary from two lists using dictionary
comprehension.
Context: Practice creating a dictionary from two parallel lists using
comprehension.
Solution:

keys = ['a', 'b', 'c']

values = [1, 2, 3]
result_dict = {k: v for k, v in zip(keys, values)}
print(result_dict)

Copy
These Python data structure exercises cover a wide range of
operations, including basic manipulations, comprehensions, and more
advanced techniques. Feel free to explore and modify them to enhance
your understanding and proficiency in Python programming.