Exploring Python's Built-in Data Structures

If you’ve followed along with our Python 101: A Beginner’s Guide to Programming, you’ve already learned the basics of Python: how to write simple programs, work with variables, and use control structures. Now, it’s time to dive deeper into one of the most important parts of programming—data structures.

Data structures are ways of organizing and storing data so that you can access and modify it efficiently. In Python, there are several built-in data structures that can help you handle data in different ways. These include lists, tuples, sets, and dictionaries. Each of these data structures has its own unique features, and knowing when and how to use them is crucial for writing clean, efficient code.

In this article, we’ll explore these four fundamental Python data structures in detail, with practical examples to help you understand how they work and when to use them.

1. Lists: Ordered and Mutable

What is a List?

A list in Python is a collection of ordered items that can be of any data type (integers, strings, objects, etc.). Lists are mutable, which means you can change their contents after they’ve been created. Lists are defined by enclosing the items in square brackets [ ], and the items are separated by commas.

Example:

# Creating a list of numbers
numbers = [1, 2, 3, 4, 5]

# Adding an item to the list
numbers.append(6)

# Accessing items in the list (indexing starts from 0)
print(numbers[0])  # Output: 1

# Changing an item in the list
numbers[0] = 10

print(numbers)  # Output: [10, 2, 3, 4, 5, 6]

Key Features of Lists:

• Ordered: The order of elements in a list is preserved.
• Mutable: You can add, remove, or change elements.
• Indexed: You can access elements by their position using an index.
• Versatile: Lists can hold items of different data types.

When to Use Lists:

• Use lists when you need to store a collection of items that may change over time (e.g., a list of tasks or user input).
• Lists are also great for maintaining the order of elements and when you need to access elements using their index.

2. Tuples: Ordered and Immutable

What is a Tuple?

A tuple is very similar to a list, but it has one key difference: tuples are immutable, meaning you cannot modify them after they are created. Tuples are defined by enclosing the items in parentheses ( ).

Example:

# Creating a tuple
coordinates = (10, 20, 30)

# Accessing items in the tuple (indexing starts from 0)
print(coordinates[1])  # Output: 20

# Trying to change an item will result in an error
# coordinates[0] = 15  # This will raise a TypeError

Key Features of Tuples:

• Ordered: Like lists, tuples maintain the order of their elements.
• Immutable: Once created, you cannot add, remove, or change items in a tuple.
• Indexed: You can access elements by their index.

When to Use Tuples:

• Use tuples when you want to store a collection of items that should not change. For example, coordinates or fixed data such as configuration values.
• Tuples are also slightly more memory-efficient than lists, making them a good choice when you don’t need to modify the collection.

3. Sets: Unordered and Unique

What is a Set?

A set is an unordered collection of unique items. This means that a set cannot have duplicate values. Sets are defined using curly braces { }, and they are useful when you need to store a collection of items and don’t care about the order but want to ensure there are no duplicates.

Example:

# Creating a set
fruits = {"apple", "banana", "cherry"}

# Adding an item to the set
fruits.add("orange")

# Sets automatically remove duplicates
fruits.add("apple")  # Duplicate, will not be added

print(fruits)  # Output: {'banana', 'cherry', 'apple', 'orange'}

# Checking for membership
print("banana" in fruits)  # Output: True

Key Features of Sets:

• Unordered: The elements in a set do not have a specific order.
• Unique: A set cannot have duplicate values.
• Mutable: You can add or remove items, but you can’t modify the existing elements directly.

When to Use Sets:

• Use sets when you need to store unique items and care about the existence of elements, but not the order.
• Sets are great for operations like removing duplicates from a list, checking membership, or performing mathematical operations like intersections and unions.

4. Dictionaries: Key-Value Pairs

What is a Dictionary?

A dictionary in Python is a collection of key-value pairs. Each key in a dictionary maps to a specific value. Dictionaries are mutable and unordered, meaning you can add, remove, or change values, but the order of the items is not guaranteed. Dictionaries are defined using curly braces { }, with each key-value pair separated by a colon :.

Example:

# Creating a dictionary
person = {"name": "Alice", "age": 25, "city": "New York"}

# Accessing values using keys
print(person["name"])  # Output: Alice

# Adding a new key-value pair
person["job"] = "Engineer"

# Updating an existing value
person["age"] = 26

# Removing a key-value pair
del person["city"]

print(person)  # Output: {'name': 'Alice', 'age': 26, 'job': 'Engineer'}

Key Features of Dictionaries:

• Unordered: The items in a dictionary do not have a specific order.
• Key-Value Pairs: Each item is a key-value pair, where the key must be unique.
• Mutable: You can add, remove, or update items in a dictionary.
• Efficient Lookup: Dictionaries are optimized for quick lookups by key.

When to Use Dictionaries:

• Use dictionaries when you need to store related data in pairs, such as a person’s name and age, or a product’s ID and price.
• They are particularly useful for fast lookups when you know the key.

Summary of Python’s Built-in Data Structures

Conclusion

In this article, we’ve explored four of Python’s most commonly used built-in data structures: lists, tuples, sets, and dictionaries. Understanding these structures and knowing when to use them will help you write better, more efficient Python code.

• Lists are great for ordered collections where items can change.
• Tuples are perfect for fixed, ordered collections.
• Sets are ideal for unique, unordered collections.
• Dictionaries are invaluable when you need to associate keys with values.

As you continue learning Python, you’ll get more comfortable with these structures and discover how they can help you solve problems more effectively. Happy coding!

By mastering Python’s built-in data structures, you’ll be well on your way to writing more powerful and efficient code. If you haven’t already, check out our Python 101: A Beginner’s Guide to Programming to get started with the basics.