1.4 Advanced Data Collections

Advanced Data Collections in Python

Python provides powerful built-in data collections for storing and organizing multiple values. The four fundamental collection types are List, Tuple, Dictionary, and Set.

Choosing the correct collection is important because each one has different characteristics, such as ordering, mutability, indexing, uniqueness, and key-based access.

1. What Are Data Collections?

A collection is an object that can contain multiple values.

Instead of creating separate variables for every value, related values can be stored together in a collection.

Without a Collection

student1 = "Alex"
student2 = "Jordan"
student3 = "Taylor"

Using a List

students = ["Alex", "Jordan", "Taylor"]

Collections make programs easier to organize, process, and scale.

2. Python Collection Types

3. Lists in Python

A list is an ordered and mutable collection that can contain multiple values.

Lists are created using square brackets [].

numbers = [10, 20, 30, 40]

names = ["Alex", "Jordan", "Taylor"]

mixed = [10, "Python", 3.14, True]

A list can contain values of different data types.

4. List Indexing

Each element in a list has an index. Python uses zero-based indexing.

colors = ["Red", "Green", "Blue", "Yellow"]

Accessing Elements

print(colors[0])
print(colors[2])
print(colors[-1])

Output:

Red
Blue
Yellow

5. List Slicing

Slicing extracts a portion of a sequence.

Syntax

list[start:stop:step]

The stop index is excluded.

numbers = [10, 20, 30, 40, 50, 60]

print(numbers[1:4])

Output:

[20, 30, 40]

Other Examples

print(numbers[:3])    # First three
print(numbers[3:])    # From index 3 onward
print(numbers[::2])   # Every second element
print(numbers[::-1])  # Reverse list

6. Modifying Lists

Lists are mutable, meaning their contents can be changed after creation.

Changing an Element

scores = [75, 82, 91]

scores[1] = 88

print(scores)

Output:

[75, 88, 91]

Changing Multiple Elements

scores[0:2] = [80, 85]

print(scores)

7. Important List Methods

8. append() vs extend()

These two methods are frequently confused.

append()

numbers = [1, 2]

numbers.append([3, 4])

print(numbers)

Output:

[1, 2, [3, 4]]

extend()

numbers = [1, 2]

numbers.extend([3, 4])

print(numbers)

Output:

[1, 2, 3, 4]

9. Copying Lists

Assigning a list to another variable does not create an independent copy.

original = [10, 20, 30]

copy_list = original

copy_list[0] = 100

print(original)

Output:

[100, 20, 30]

Both variables refer to the same list object.

Creating a Shallow Copy

original = [10, 20, 30]

copy_list = original.copy()

copy_list[0] = 100

print(original)
print(copy_list)

The original list remains unchanged in this example.

10. List Comprehension

A list comprehension provides a concise way to create a list from an iterable.

Traditional Approach

squares = []

for number in range(1, 6):
    squares.append(number ** 2)

print(squares)

List Comprehension

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

print(squares)

Output:

[1, 4, 9, 16, 25]

With a Condition

even_numbers = [
    number
    for number in range(1, 11)
    if number % 2 == 0
]

print(even_numbers)

11. Tuples in Python

A tuple is an ordered, immutable collection.

Tuples are generally written using parentheses ().

coordinates = (28.6139, 77.2090)

student = ("Alex", 18, "Computer Science")

A tuple can contain different data types.

12. Single-Element Tuple

A comma is required to create a tuple containing a single item.

value = (10,)

print(type(value))

Without the comma:

value = (10)

print(type(value))

The second example creates an integer, not a tuple.

13. Accessing Tuple Elements

Tuples support indexing and slicing just like lists.

data = ("Python", "NumPy", "Pandas", "Matplotlib")

print(data[0])
print(data[-1])
print(data[1:3])

Output:

Python
Matplotlib
('NumPy', 'Pandas')

14. Tuple Immutability

Once a tuple is created, its elements cannot be reassigned.

coordinates = (10, 20)

coordinates[0] = 100

This raises a TypeError.

15. Important Tuple Methods

values = (10, 20, 10, 30)

print(values.count(10))
print(values.index(30))

16. Tuple Unpacking

Tuple unpacking assigns tuple elements to multiple variables.

student = ("Alex", 18, "Physics")

name, age, subject = student

print(name)
print(age)
print(subject)

Output:

Alex
18
Physics

Practical Example

coordinates = (28.61, 77.20)

latitude, longitude = coordinates

print(latitude)
print(longitude)

17. Extended Iterable Unpacking

The * operator can collect multiple remaining values during unpacking.

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

first, *middle, last = numbers

print(first)
print(middle)
print(last)

Output:

10
[20, 30, 40]
50

18. Dictionaries in Python

A dictionary stores data as key-value pairs.

Dictionaries are created using curly braces {}.

student = {
    "name": "Alex",
    "age": 18,
    "course": "Data Science"
}

Each key identifies a corresponding value.

19. Accessing Dictionary Values

Using Square Brackets

student = {
    "name": "Alex",
    "age": 18
}

print(student["name"])

Using get()

print(student.get("name"))
print(student.get("city"))

get() returns None when the requested key does not exist, unless a default value is supplied.

print(student.get("city", "Unknown"))

20. Adding, Updating and Removing Dictionary Items

Add an Item

student["city"] = "London"

Update an Item

student["age"] = 19

Remove an Item

student.pop("city")

Remove the Last Inserted Item

student.popitem()

Clear the Dictionary

student.clear()

21. Important Dictionary Methods

22. Iterating Through a Dictionary

Iterating Over Keys

student = {
    "name": "Alex",
    "age": 18,
    "course": "Data Science"
}

for key in student:
    print(key)

Iterating Over Values

for value in student.values():
    print(value)

Iterating Over Key-Value Pairs

for key, value in student.items():
    print(f"{key}: {value}")

23. Dictionary Keys

Dictionary keys must be hashable. Common examples include strings, integers, and tuples containing hashable values.

data = {
    "name": "Alex",
    101: "Student",
    (10, 20): "Coordinate"
}

24. Sets in Python

A set is a mutable collection of unique elements.

Sets are useful when duplicate values need to be removed or when mathematical set operations are required.

numbers = {10, 20, 30, 20, 10}

print(numbers)

Duplicate values are automatically eliminated.

25. Creating an Empty Set

An empty set must be created using set().

items = set()

print(type(items))

Using {} creates an empty dictionary, not an empty set.

items = {}

print(type(items))

26. Important Set Methods

27. Mathematical Set Operations

Python sets support common mathematical operations such as union, intersection, difference, and symmetric difference.

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

Union

print(A | B)

Combines elements from both sets.

Intersection

print(A & B)

Returns elements common to both sets.

Difference

print(A - B)

Returns elements present in A but not B.

Symmetric Difference

print(A ^ B)

Returns elements present in either set but not both.

28. Set Operations Quick Reference

29. Membership Testing

The in and not in operators test whether an item belongs to a collection.

languages = ["Python", "Java", "C++"]

print("Python" in languages)
print("Ruby" not in languages)

Membership testing is particularly useful with sets and dictionaries.

Dictionary Membership

student = {
    "name": "Alex",
    "age": 18
}

print("name" in student)

For a dictionary, in checks keys by default.

30. Mutable vs Immutable Collections

Mutability refers to whether an object can be changed after it has been created.

Mutable Example

numbers = [10, 20, 30]

numbers[0] = 100

print(numbers)

Immutable Example

numbers = (10, 20, 30)

# numbers[0] = 100  # TypeError

31. Nested Collections

Collections can contain other collections. This is called a nested collection.

List of Lists

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

print(matrix[1][2])

Output:

6

Dictionary Containing a List

student = {
    "name": "Alex",
    "subjects": ["Python", "Statistics", "AI"]
}

print(student["subjects"][0])

32. List of Dictionaries

A list of dictionaries is a common way to represent structured records before loading data into tools such as pandas.

students = [

    {
        "name": "Alex",
        "score": 88
    },

    {
        "name": "Jordan",
        "score": 94
    },

    {
        "name": "Taylor",
        "score": 79
    }

]

for student in students:
    print(student["name"], student["score"])

33. Dictionary Comprehension

Dictionary comprehensions provide a concise way to create dictionaries.

squares = {
    number: number ** 2
    for number in range(1, 6)
}

print(squares)

Output:

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

34. Set Comprehension

Sets can also be created using comprehensions.

unique_lengths = {
    len(word)
    for word in ["Python", "Data", "Science", "AI"]
}

print(unique_lengths)

The resulting set contains only unique lengths.

35. sorted() vs sort()

Python provides both the sort() method and the sorted() function.

sort()

numbers = [40, 10, 30, 20]

numbers.sort()

print(numbers)

sort() changes the original list.

sorted()

numbers = [40, 10, 30, 20]

result = sorted(numbers)

print(numbers)
print(result)

sorted() creates and returns a new sorted list.

36. Sorting with key=

The key parameter allows sorting according to a specific property.

students = [
    {"name": "Alex", "score": 82},
    {"name": "Jordan", "score": 95},
    {"name": "Taylor", "score": 76}
]

students.sort(key=lambda student: student["score"])

print(students)

This sorts the records according to their scores.

37. Data Science Example — Unique Categories

Sets are useful for identifying unique categories in a dataset.

departments = [
    "Sales",
    "IT",
    "HR",
    "Sales",
    "Finance",
    "IT",
    "HR"
]

unique_departments = set(departments)

print(unique_departments)

Duplicate department names are automatically removed.

38. Data Science Example — Frequency Counting

A dictionary can be used to count the frequency of values.

subjects = [
    "Python",
    "AI",
    "Python",
    "Data Science",
    "AI",
    "Python"
]

frequency = {}

for subject in subjects:

    frequency[subject] = frequency.get(subject, 0) + 1

print(frequency)

Output:

{
    "Python": 3,
    "AI": 2,
    "Data Science": 1
}

39. Automation Example — File Extensions

Dictionaries and loops can be combined to count file types.

files = [
    "report.pdf",
    "sales.xlsx",
    "data.csv",
    "summary.pdf",
    "students.csv"
]

extensions = {}

for filename in files:

    extension = filename.split(".")[-1]

    extensions[extension] = extensions.get(extension, 0) + 1

print(extensions)

This basic pattern can later be combined with pathlib for real file-system automation.

40. Which Collection Should You Use?

41. Python Interview Questions

42. Examination Questions

Multiple Choice Questions

values = [10, 20, 30, 40]

print(values[1:3])

Short Answer Questions

1. Define a list and state two of its characteristics.
2. Differentiate between a list and a tuple.
3. Explain the purpose of dictionaries with an example.
4. What is a set? State two applications of sets.
5. Explain list slicing with an example.
6. Differentiate between append() and extend().
7. Explain dictionary keys and values.
8. What is tuple unpacking?

43. Practical Challenge

44. Advanced Data Collections Quick Reference