Python Data Structures & Comprehensions

This module covers Python’s core data structures (Lists, Tuples, Dictionaries, Sets), queue operations using deque, and the powerful comprehension syntax used to create and transform them.

Topics Covered

In this module, you’ll learn:

Lists: CRUD Operations and Sorting
Tuples: Operations, Indexing, and Slicing
Dictionaries: CRUD Operations and Sorting
Sets: CRUD Operations and Sorting
Queues: Using collections.deque
Why Comprehensions?
List Comprehensions
Dictionary Comprehensions
Set Comprehensions
Generator Expressions
Comprehensions vs Loops & Best Practices

Try Yourself: 💻 VS Code | 🚀 Colab | 📥 Download
Verify Solutions: 💻 VS Code | 🚀 Colab | 📥 Download

1. Lists: CRUD Operations and Sorting

A List in Python is an ordered, mutable sequence of elements. It is one of the most widely used data structures.

Create (C)

You can create a list by enclosing comma-separated values in square brackets [] or by using the list() constructor.

# Creating lists
languages = ["Python", "JavaScript"]
empty_list = []
numbers = list(range(1, 4))

print(languages)
print(numbers)

Output ?

Show Output

['Python', 'JavaScript']
[1, 2, 3]

Read (R) - Indexing & Slicing

Elements in a list are accessed using zero-based indexing, negative indexing (from the end), or slicing (list[start:stop:step]).

fruits = ["Apple", "Banana", "Cherry", "Date", "Elderberry"]

# Accessing single elements (indexing)
print(fruits[0])    # First element: "Apple"
print(fruits[-1])   # Last element: "Elderberry"

# Extracting a sub-list (slicing)
print(fruits[1:4])  # Indices 1 to 3: ["Banana", "Cherry", "Date"]
print(fruits[:3])   # First 3 elements: ["Apple", "Banana", "Cherry"]
print(fruits[2:])   # Elements from index 2 to end: ["Cherry", "Date", "Elderberry"]
print(fruits[::2])  # Alternate elements: ["Apple", "Cherry", "Elderberry"]
print(fruits[::-1]) # Reversed list: ["Elderberry", "Date", "Cherry", "Banana", "Apple"]

Output ?

Show Output

Apple
Elderberry
['Banana', 'Cherry', 'Date']
['Apple', 'Banana', 'Cherry']
['Cherry', 'Date', 'Elderberry']
['Apple', 'Cherry', 'Elderberry']
['Elderberry', 'Date', 'Cherry', 'Banana', 'Apple']

Update (U)

Since lists are mutable, you can modify elements in-place, append new elements, insert at specific positions, or extend with another list.

colors = ["red", "green"]

# Modify in-place
colors[1] = "blue"

# Append (add to end)
colors.append("yellow")

# Insert at index 1
colors.insert(1, "orange")

# Extend (add multiple items)
colors.extend(["purple", "pink"])

print(colors)

Output ?

Show Output

['red', 'orange', 'blue', 'yellow', 'purple', 'pink']

Delete (D)

You can remove elements from a list using .remove(), .pop(), .clear(), or the del statement.

tasks = ["code", "test", "deploy", "debug"]

# Remove by value
tasks.remove("test")

# Remove by index (returns the removed value)
removed = tasks.pop(1)
print(f"Removed item: {removed}")

# Delete via index
del tasks[0]

print(tasks)

Output ?

Show Output

Removed item: deploy
['debug']

Sorting

Python lists can be sorted in-place using .sort() or out-of-place using the global sorted() function.

nums = [42, 7, 19, 88, 3]

# Out-of-place (returns a new sorted list)
new_nums = sorted(nums)
print("Original:", nums)
print("Sorted copy:", new_nums)

# In-place sorting
nums.sort()
print("Sorted in-place:", nums)

# Reverse sorting
nums.sort(reverse=True)
print("Reverse sorted in-place:", nums)

Output ?

Show Output

Original: [42, 7, 19, 88, 3]
Sorted copy: [3, 7, 19, 42, 88]
Sorted in-place: [3, 7, 19, 42, 88]
Reverse sorted in-place: [88, 42, 19, 7, 3]

Exercise 1

Write a program to create a list of numbers, append 10, insert 5 at index 0, and then sort it in-place in descending order.

Solution

nums = [12, 3, 45]
nums.append(10)
nums.insert(0, 5)
nums.sort(reverse=True)
print(nums)

Exercise 2

Given a list arr = ["apple", "cherry", "banana"], remove the element "cherry" and print the sorted list.

Solution

arr = ["apple", "cherry", "banana"]
arr.remove("cherry")
print(sorted(arr))

2. Tuples: Operations, Indexing, and Slicing

A Tuple is an ordered, immutable sequence of elements. Once created, a tuple’s elements cannot be modified, added, or removed.

Create (C)

Tuples are defined using parentheses () or the tuple() constructor. To define a tuple with a single element, you must include a trailing comma.

# Creating tuples
tup1 = (10, 20, 30)
empty_tup = ()
single_tup = (5,)  # Note the trailing comma
tup_from_list = tuple([1, 2, 3])

print(tup1)
print(single_tup)

Output ?

Show Output

(10, 20, 30)
(5,)

Read (R) - Indexing & Slicing

Tuples support the exact same indexing and slicing syntax as lists (zero-based indexing, negative indexing, and slicing with [start:stop:step]).

values = ("A", "B", "C", "D", "E")

# Indexing & Slicing
print(values[0])     # First element: "A"
print(values[-1])    # Last element: "E"
print(values[1:4])   # Slice: ("B", "C", "D")
print(values[::-1])  # Reversed tuple: ("E", "D", "C", "B", "A")

Output ?

Show Output

A
E
('B', 'C', 'D')
('E', 'D', 'C', 'B', 'A')

Operations

Although immutable, tuples support common operations such as concatenation, repetition, membership testing, and element counting.

t1 = (1, 2)
t2 = (3, 4)

# Concatenation
t3 = t1 + t2
print("Concatenation:", t3)

# Repetition
t4 = t1 * 3
print("Repetition:", t4)

# Index and Count
chars = ("a", "b", "a", "c")
print("Count of 'a':", chars.count("a"))
print("First index of 'b':", chars.index("b"))

# Membership
print("a" in chars)

Output ?

Show Output

Concatenation: (1, 2, 3, 4)
Repetition: (1, 2, 1, 2, 1, 2)
Count of 'a': 2
First index of 'b': 1
True

Sorting

Because tuples are immutable, you cannot sort them in-place. You must use the sorted() function, which returns a new sorted list. You can convert this list back to a tuple if needed.

tup = (42, 7, 19, 3)
sorted_list = sorted(tup)
sorted_tup = tuple(sorted_list)

print("Original Tuple:", tup)
print("Sorted Tuple:", sorted_tup)

Output ?

Show Output

Original Tuple: (42, 7, 19, 3)
Sorted Tuple: (3, 7, 19, 42)

Exercise 1

Create a tuple containing elements 10, 20, 30, 40, 50. Extract the middle three elements using slicing.

Solution

tup = (10, 20, 30, 40, 50)
print(tup[1:4])

Exercise 2

Given the tuple data = (5, 2, 9, 1), write a program to sort it in ascending order and print the result as a tuple.

Solution

data = (5, 2, 9, 1)
sorted_data = tuple(sorted(data))
print(sorted_data)

3. Dictionaries: CRUD Operations and Sorting

A Dictionary in Python is a mutable, key-value collection. Keys must be unique and immutable.

Create (C)

Create dictionaries using curly braces {} containing key-value pairs or the dict() constructor.

# Creating dictionaries
student = {"name": "Alice", "age": 25}
empty_dict = {}
colors = dict(red="#FF0000", green="#00FF00")

print(student)
print(colors)

Output ?

Show Output

{'name': 'Alice', 'age': 25}
{'red': '#FF0000', 'green': '#00FF00'}

Read (R)

Values are retrieved using key indexing or the safer .get() method.

profile = {"username": "coder1", "email": "coder1@test.com"}

# Key lookup
print(profile["username"])

# Safe lookup using get() (returns None or default value if missing)
print(profile.get("age"))
print(profile.get("age", 18))

# Accessing keys, values, and items
print(list(profile.keys()))
print(list(profile.values()))
print(list(profile.items()))

Output ?

Show Output

coder1
None
18
['username', 'email']
['coder1', 'coder1@test.com']
[('username', 'coder1'), ('email', 'coder1@test.com')]

Update (U)

You can add new key-value pairs or modify existing ones simply by assigning to a key, or by using .update().

car = {"brand": "Tesla", "model": "Model 3"}

# Add/Modify key-value pairs
car["year"] = 2021
car["model"] = "Model Y"

# Batch update
car.update({"color": "red", "battery": "Long Range"})

print(car)

Output ?

Show Output

{'brand': 'Tesla', 'model': 'Model Y', 'year': 2021, 'color': 'red', 'battery': 'Long Range'}

Delete (D)

Items can be removed using del, .pop() (returns value), .popitem() (removes last inserted pair), or .clear().

inventory = {"apples": 10, "bananas": 5, "peaches": 2}

# Remove by key using pop
popped_val = inventory.pop("bananas")
print(f"Removed bananas value: {popped_val}")

# Remove last inserted item
last_item = inventory.popitem()
print(f"Removed last item: {last_item}")

# Delete keyword
del inventory["apples"]

print(inventory)

Output ?

Show Output

Removed bananas value: 5
Removed last item: ('peaches', 2)
{}

Sorting

Dictionaries can be sorted by keys or values using the sorted() function on their items.

scores = {"Charlie": 90, "Alice": 95, "Bob": 85}

# Sort by Keys (alphabetical)
sorted_by_keys = dict(sorted(scores.items()))
print("Sorted by keys:", sorted_by_keys)

# Sort by Values (ascending scores)
sorted_by_values = dict(sorted(scores.items(), key=lambda item: item[1]))
print("Sorted by values:", sorted_by_values)

Output ?

Show Output

Sorted by keys: {'Alice': 95, 'Bob': 85, 'Charlie': 90}
Sorted by values: {'Bob': 85, 'Charlie': 90, 'Alice': 95}

Exercise 1

Create a dictionary representing a book with key-value pairs for title, author, and price. Update the price to 499, add a new key year as 2024, and print all keys in the dictionary.

Solution

book = {"title": "Python Basics", "author": "John Doe", "price": 399}
book["price"] = 499
book["year"] = 2024
print(list(book.keys()))

Exercise 2

Given d = {"z": 1, "y": 2, "x": 3}, sort the dictionary by keys in ascending order and print the resulting dictionary.

Solution

d = {"z": 1, "y": 2, "x": 3}
sorted_d = dict(sorted(d.items()))
print(sorted_d)

4. Sets: CRUD Operations and Sorting

A Set in Python is an unordered collection of unique, immutable elements. Sets do not allow duplicate values.

Create (C)

Sets are created using curly braces {} containing elements or the set() constructor. Note that an empty set must be created using set(), as {} creates an empty dictionary.

# Creating sets
numbers = {1, 2, 3, 3}  # Duplicates are automatically removed
print(numbers)

empty_set = set()
names = set(["Alice", "Bob"])
print(names)

Output ?

Show Output

{1, 2, 3}
{'Alice', 'Bob'}

Read (R)

Since sets are unordered, they do not support indexing or slicing. You read elements by checking membership (in) or by iterating over the set.

chars = {"a", "b", "c"}

# Membership test
print("a" in chars)
print("z" in chars)

# Iteration
for char in chars:
    print(char)

Output ?

Show Output

True
False
b
c
a

Update (U)

You can add elements using .add() (for a single element) or .update() (for multiple elements).

countries = {"India", "USA"}

# Add single item
countries.add("UK")

# Add multiple items (can pass list, tuple, set, etc.)
countries.update(["Canada", "Germany"])

print(countries)

Output ?

Show Output

{'Germany', 'India', 'UK', 'Canada', 'USA'}

Delete (D)

Remove elements using .remove() (raises KeyError if not found), .discard() (safe, does not raise error), .pop() (removes and returns an arbitrary element), or .clear().

brands = {"Nike", "Adidas", "Puma"}

# Remove element (raises error if missing)
brands.remove("Adidas")

# Discard element safely (no error if missing)
brands.discard("Reebok")

# Pop arbitrary element
popped = brands.pop()
print(f"Popped brand: {popped}")

print(brands)

Output ?

Show Output

Popped brand: Nike
{'Puma'}

Sorting

Since sets are inherently unordered, they cannot be sorted in-place. However, you can use the sorted() function, which returns a sorted list of the set’s elements.

values = {42, 3, 17, 8}

# Sorting a set returns a list
sorted_values = sorted(values)
print("Sorted values list:", sorted_values)

Output ?

Show Output

Sorted values list: [3, 8, 17, 42]

Exercise 1

Create an empty set, add elements 10, 20, and 30 to it, remove 20, and verify if 20 is still in the set.

Solution

s = set()
s.add(10)
s.add(20)
s.add(30)
s.remove(20)
print(20 in s)

Exercise 2

Given a set my_set = {15, 5, 25, 10}, sort the elements of the set and print the result.

Solution

my_set = {15, 5, 25, 10}
print(sorted(my_set))

5. Queues: Using `collections.deque`

A queue is a linear data structure that follows the FIFO (First-In, First-Out) principle. Although you can use a Python list as a queue by calling list.pop(0), this operation is inefficient. Shifting elements at index 0 requires $O(n)$ time complexity. Python’s collections.deque (double-ended queue) is specifically designed to allow fast appends and pops from both ends in $O(1)$ time complexity.

Creating and Enqueuing Elements

Import deque from collections, and use .append() to enqueue items to the right side of the queue.

from collections import deque

# Create a queue
queue = deque()

# Enqueue (adding elements)
queue.append("Alice")
queue.append("Bob")
queue.append("Charlie")

print("Queue status:", queue)

Output ?

Show Output

Queue status: deque(['Alice', 'Bob', 'Charlie'])

Dequeuing Elements

Use .popleft() to remove and return elements from the left side (front of the queue), preserving the FIFO order.

# Dequeue (removing elements)
first = queue.popleft()
print(f"Served: {first}")

second = queue.popleft()
print(f"Served: {second}")

print("Remaining Queue:", queue)

Output ?

Show Output

Served: Alice
Served: Bob
Remaining Queue: deque(['Charlie'])

Add to Front / Remove from Back

Because deque is double-ended, you can also perform LIFO operations or add to the front:

appendleft(item): Add an element to the front.
pop(): Remove and return an element from the back.

q = deque(["Job1", "Job2"])
q.appendleft("UrgentJob")  # Added to front
print(q)

Output ?

Show Output

deque(['UrgentJob', 'Job1', 'Job2'])

Exercise 1

Create a queue using deque containing ["user1", "user2"]. Enqueue "user3", dequeue the first user in line, and print the remaining queue.

Solution

from collections import deque

q = deque(["user1", "user2"])
q.append("user3")
served = q.popleft()
print("Served:", served)
print("Queue:", q)

Exercise 2

Write a program to demonstrate how to use deque as a stack (Last-In, First-Out) using .append() and .pop().

Solution

from collections import deque

stack = deque()
stack.append("plate1")
stack.append("plate2")
print(stack.pop())  # returns "plate2"

6. Why Comprehensions?

Suppose we want to create a list containing the squares of numbers from 1 to 5. A common approach is to use a for loop.

squares = []
for number in range(1, 6):
    squares.append(number ** 2)
print(squares)

Show Output

[1, 4, 9, 16, 25]

Python provides comprehensions to perform the same task in a cleaner, single-line expression:

squares = [number ** 2 for number in range(1, 6)]
print(squares)

Output ?

Show Output

[1, 4, 9, 16, 25]

General Syntax

[expression for item in iterable]

Output ?

Show Output

Error executing code: name 'iterable' is not defined

expression → Value to be added to the collection.
item → Current element from the iterable.
iterable → Any iterable object such as a string, list, tuple, range, or set.

7. List Comprehensions

A list comprehension creates a new list by applying an expression to each element of an iterable.

Basic List Comprehension

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

Output ?

Show Output

[1, 4, 9, 16, 25]

Filtering with `if`

You can filter elements by adding an if clause at the end.

numbers = range(1, 11)
evens = [num for num in numbers if num % 2 == 0]
print(evens)

Output ?

Show Output

[2, 4, 6, 8, 10]

Using `if-else` (Transformation)

To transform values differently based on a condition, place the if-else clause before the for loop.

numbers = range(1, 6)
labels = ["Even" if num % 2 == 0 else "Odd" for num in numbers]
print(labels)

Output ?

Show Output

['Odd', 'Even', 'Odd', 'Even', 'Odd']

Nested List Comprehensions (Flattening)

You can nest comprehensions to work with multi-dimensional lists (e.g., flattening a matrix).

matrix = [[1, 2], [3, 4], [5, 6]]
flat = [num for row in matrix for num in row]
print(flat)

Output ?

Show Output

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

Exercise 1

Create a list containing the lengths of each word in the list ["Python", "FastAPI", "API"] using a list comprehension.

Solution

words = ["Python", "FastAPI", "API"]
lengths = [len(word) for word in words]
print(lengths)

8. Dictionary Comprehensions

A dictionary comprehension provides a concise way to create dictionaries from iterables.

Basic Dictionary Comprehension

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

Output ?

Show Output

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Filtering in Dictionary Comprehensions

scores = {"Alice": 85, "Bob": 72, "Charlie": 90}
passed = {name: score for name, score in scores.items() if score >= 80}
print(passed)

Output ?

Show Output

{'Alice': 85, 'Charlie': 90}

Exercise 1

Given the list ["a", "b", "c"], create a dictionary where each character is a key, and its ASCII code (ord(char)) is the value.

Solution

chars = ["a", "b", "c"]
ascii_dict = {char: ord(char) for char in chars}
print(ascii_dict)

9. Set Comprehensions

A set comprehension creates a set. Since sets store unique values, duplicates are automatically removed.

Basic Set Comprehension

numbers = [1, 2, 2, 3, 4, 4, 5]
unique_squares = {num ** 2 for num in numbers}
print(unique_squares)

Output ?

Show Output

{1, 4, 9, 16, 25}

Exercise 1

Extract all unique vowels from the string "Artificial Intelligence" in lowercase using a set comprehension.

Solution

text = "Artificial Intelligence"
vowels = {char.lower() for char in text if char.lower() in "aeiou"}
print(vowels)

10. Generator Expressions

A generator expression is similar to a list comprehension, but instead of creating the entire list in memory, it produces values one at a time (lazy evaluation) using iterators.

Syntax

Replace square brackets [] with parentheses ().

# This is a generator expression
squares_gen = (num ** 2 for num in range(1, 6))

print(squares_gen)
# Retrieve values using next() or a loop
print(next(squares_gen))
print(next(squares_gen))

Output

Show Output

<generator object <genexpr> at ...>
1
4

11. Comprehensions vs Loops & Best Practices

Feature	Traditional Loop	Comprehension	Generator Expression
Readability	Better for complex logic	Better for simple transformations	Ideal for streaming data
Memory Usage	Moderate	Higher (stores entire collection)	Minimal ( $O(1)$ memory)
Performance	Good	Fast	Fast (lazy computation)

Best Practices

Use comprehensions for simple, readable mappings or filter operations.
Avoid nesting comprehensions more than 2 levels deep to keep code readable.
Use generator expressions when working with large or infinite datasets.
If the loop body contains complex conditional logic, prefer a standard for loop.

Practice

To reinforce what you’ve learned in this section, practice with the interactive follow-along notebook:

Follow-Along Practice

Practice lists, tuples, dictionaries, sets operations, deque queues, list/dict/set comprehensions, and generator expressions.💻 VS Code | 🚀 Colab | 📥 Download

Summary

In this module, you learned how to manipulate Python’s core data structures (Lists, Tuples, Dictionaries, Sets), use double-ended queues, and write clean, memory-efficient comprehensions.

​Python Data Structures & Comprehensions

​Topics Covered

​1. Lists: CRUD Operations and Sorting

​Create (C)

​Read (R) - Indexing & Slicing

​Update (U)

​Delete (D)

​Sorting

​Exercise 1

​Exercise 2

​2. Tuples: Operations, Indexing, and Slicing

​Create (C)

​Read (R) - Indexing & Slicing

​Operations

​Sorting

​Exercise 1

​Exercise 2

​3. Dictionaries: CRUD Operations and Sorting

​Create (C)

​Read (R)

​Update (U)

​Delete (D)

​Sorting

​Exercise 1

​Exercise 2

​4. Sets: CRUD Operations and Sorting

​Create (C)

​Read (R)

​Update (U)

​Delete (D)

​Sorting

​Exercise 1

​Exercise 2

​5. Queues: Using collections.deque

​Creating and Enqueuing Elements

​Dequeuing Elements

​Add to Front / Remove from Back

​Exercise 1

​Exercise 2

​6. Why Comprehensions?

​General Syntax

​7. List Comprehensions

​Basic List Comprehension

​Filtering with if

​Using if-else (Transformation)

​Nested List Comprehensions (Flattening)

​Exercise 1

​8. Dictionary Comprehensions

​Basic Dictionary Comprehension

​Filtering in Dictionary Comprehensions

​Exercise 1

​9. Set Comprehensions

​Basic Set Comprehension

​Exercise 1

​10. Generator Expressions

​Syntax

​11. Comprehensions vs Loops & Best Practices

​Best Practices

​Practice

Follow-Along Practice

​Summary

Python Data Structures & Comprehensions

Topics Covered

1. Lists: CRUD Operations and Sorting

Create (C)

Read (R) - Indexing & Slicing

Update (U)

Delete (D)

Sorting

Exercise 1

Exercise 2

2. Tuples: Operations, Indexing, and Slicing

Create (C)

Read (R) - Indexing & Slicing

Operations

Sorting

Exercise 1

Exercise 2

3. Dictionaries: CRUD Operations and Sorting

Create (C)

Read (R)

Update (U)

Delete (D)

Sorting

Exercise 1

Exercise 2

4. Sets: CRUD Operations and Sorting

Create (C)

Read (R)

Update (U)

Delete (D)

Sorting

Exercise 1

Exercise 2

5. Queues: Using `collections.deque`

Creating and Enqueuing Elements

Dequeuing Elements

Add to Front / Remove from Back

Exercise 1

Exercise 2

6. Why Comprehensions?

General Syntax

7. List Comprehensions

Basic List Comprehension

Filtering with `if`

Using `if-else` (Transformation)

Nested List Comprehensions (Flattening)

Exercise 1

8. Dictionary Comprehensions

Basic Dictionary Comprehension

Filtering in Dictionary Comprehensions

Exercise 1

9. Set Comprehensions

Basic Set Comprehension

Exercise 1

10. Generator Expressions

Syntax

11. Comprehensions vs Loops & Best Practices

Best Practices

Practice

Summary