Python Data Structures

1. How Python Thinks About Data

Before diving into specific data structures, it's crucial to understand Python's underlying model of data and variables. As a computer science student, you're familiar with concepts like memory addresses and data types. In Python, these concepts are very explicit. Every piece of data is an object that lives at a specific memory address, and a variable is simply a name or a "label" that points to that object.

Understanding this model is key to grasping the important distinction between mutable (changeable) and immutable (unchangeable) data types, which is a central theme of today's lesson.

To build this fundamental mental model, let's watch a few key segments from the video "Python under the Hood" by Lucas Layman. This will provide a more rigorous view than a typical introductory tutorial.

Key Takeaways from the Video:

• Everything is an object: Every value (a number, a string, a list) is an object stored in memory.
• Variables are labels: A variable is a name that points to the memory address of an object.
• Assignment points the label: The assignment operator (=) makes a variable label point to an object. When you write y = x, you are making the label y point to the same object that x points to.
• Immutability: For immutable types (like integers, floats, strings), you cannot change the object itself. Any operation that seems to "modify" it actually creates a new object and reassigns the variable label to point to it.
• Mutability: For mutable types (like lists and dictionaries), you can change the object's contents in-place without creating a new object. This means if two variables point to the same list, modifying the list through one variable will be visible through the other.

2. The Four Core Data Structures

With that foundation, let's explore Python's four fundamental built-in data structures. They are the primary tools for collecting and organizing data.

We will use the video "Python: Data Structures" as our main guide. It provides a clear, practical walkthrough of how to use each one.

Now, let's break them down one by one.

2.1. Sequences: Lists and Tuples

Lists and tuples are both sequence types, meaning their elements are stored in a specific order and can be accessed using a numerical index. Many operations, like indexing and slicing, work identically for both.

Lists: Mutable, Ordered Collections

Lists are the most common and versatile data structure in Python. They are ordered collections that are mutable, meaning you can add, remove, and change elements after the list has been created.

• Syntax: Defined with square brackets []. Example: my_list = [1, "hello", 3.14]
• Best for: Collections of items that need to be modified, or when you don't know the number of items in advance.

Now, let's see how to work with them in practice.

Key List Operations:

• my_list.append(item): Adds an item to the end of the list. This is a very fast, constant-time O(1) operation.
• my_list.insert(index, item): Inserts an item at a specific index. This is a slow, linear-time O(n) operation, as subsequent elements must be shifted.
• my_list.pop(): Removes and returns the last item. Fast O(1).
• my_list.remove(item): Removes the first occurrence of a specific value. Slow O(n).
• my_list.sort(): Sorts the list in place.

List Comprehensions provide a concise syntax to create lists. They are both readable and more performant than using a for loop with .append().

# Standard for loop
squares = []
for x in range(10):
    if x % 2 == 0:
        squares.append(x**2)
print(squares) # Output: [0, 4, 16, 36, 64]

# List comprehension (preferred)
squares_comp = [x**2 for x in range(10) if x % 2 == 0]
print(squares_comp) # Output: [0, 4, 16, 36, 64]

words = ["hello", "world", "in", "a", "frame"]
lengths = [len(word) for word in words if len(word) > 3]
print(lengths) # Output: [5, 5, 5]

Tuples: Immutable, Ordered Collections

Tuples are just like lists, but with one crucial difference: they are immutable. Once you create a tuple, you cannot change its contents.

• Syntax: Defined with parentheses (). Example: my_tuple = (1, "hello", 3.14)
• Best for: Fixed data that should not change, such as coordinates (x, y), RGB color values, or database records. Their immutability also allows them to be used as keys in dictionaries, unlike lists.

A common and useful feature associated with tuples is packing and unpacking:

# Packing: grouping values into a tuple
point = (10, 20, 5) 

# Unpacking: assigning tuple elements to individual variables
x, y, z = point

print(f"The x-coordinate is {x}") # Output: The x-coordinate is 10

2.2. Unordered Collections: Sets and Dictionaries

Unlike lists and tuples, sets and dictionaries are collections that are optimized for fast lookups. They achieve this by using a hash table implementation, a concept you are likely familiar with from your data structures courses.

Sets: Mutable, Unordered, Unique Elements

A set is an unordered collection of unique elements. It is highly optimized for membership testing (checking if an element is present).

• Syntax: Defined with curly braces {} or the set() constructor. Example: my_set = {1, 2, 3}
• Best for:
  1. Removing duplicates from a collection.
  2. Fast membership testing (item in my_set). This is a constant-time O(1) operation on average.
  3. Mathematical set operations (union, intersection, difference). This will feel natural given your math background.

Example of Set Operations:

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# Union: Elements in either set
print(set_a | set_b)  # Output: {1, 2, 3, 4, 5, 6}

# Intersection: Elements in both sets
print(set_a & set_b)  # Output: {3, 4}

# Difference: Elements in set_a but not in set_b
print(set_a - set_b)  # Output: {1, 2}

Dictionaries: Mutable, Key-Value Pairs

A dictionary is a collection of key-value pairs. It maps unique, immutable keys to values. Like sets, they are implemented using hash tables, which means looking up a value by its key is extremely fast (O(1) on average).

• Syntax: Defined with curly braces {}, with key-value pairs. Example: {'name': 'Alice', 'age': 30}
• Best for: Storing structured data where you need to look up values based on a unique identifier. Examples include mapping user IDs to user objects, or storing configuration settings.

A note on ordering: Historically, dictionaries were unordered. However, since Python 3.7, standard dictionaries remember the order in which items were inserted.

Key Dictionary Operations:

• Accessing: value = my_dict['key'] (raises an error if the key doesn't exist).
• Safer Accessing: value = my_dict.get('key', 'default_value') (returns None or a default value if the key is not found).
• Adding/Updating: my_dict['new_key'] = 'new_value'
• Iterating:

  for key, value in my_dict.items():
      print(f"Key: {key}, Value: {value}")
  

s = "the quick brown fox jumps over the lazy dog"
words = s.split() # Split the string into a list of words
word_counts = {}

for word in words:
    word_counts[word] = word_counts.get(word, 0) + 1

print(word_counts)
# Output: {'the': 2, 'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}

Conclusion

In this lesson, you've been introduced to the four fundamental data structures in Python, moving from the conceptual model of how Python handles data in memory to the practical syntax for using them.

Key Takeaways:

• Lists: Ordered, mutable sequences. Your go-to for flexible collections of items.
• Tuples: Ordered, immutable sequences. Use them for fixed data to ensure data integrity.
• Sets: Unordered, unique collections. Perfect for membership testing and removing duplicates.
• Dictionaries: Key-value pairs. The best choice for fast lookups based on a key.

Choosing the right data structure is a foundational skill that impacts not only the readability of your code but also its performance—a concept that will become increasingly important as we work with the large datasets common in AI.

In our next lesson, we will build directly on this foundation. Now that you know how to store data, we will learn how to write Python functions that use control flow (if/else), loops (for/while), and list comprehensions to process and manipulate that data.