Choosing the right data structure

Why Choosing the Right Data Structure Matters

In many programs, the choice of data structure affects:

• How easy your code is to write and understand
• How fast your program runs
• How simple it is to add new features later

Python gives you several built-in data collections:

• list
• tuple
• dict (dictionary)
• set

Here you’ll focus on how to decide which one to use, not on their basic syntax.

Think of data structures like different containers:

• A backpack
• A toolbox with labeled drawers
• A safe with a locked combination
• A basket that ignores duplicates

They all hold “stuff,” but each is better for different situations.

Key Questions to Help You Choose

When deciding which data structure to use, ask yourself:

1. Do I care about order?
2. Will the data change (add/remove items)?
3. Do I need to look things up by a number position or by a name/key?
4. Can there be duplicates, or must all items be unique?
5. Do I need a fixed “record” that represents one thing (like a user or product)?
6. Do I want to prevent accidental modification?

Your answers will guide you to lists, tuples, dictionaries, or sets.

When to Use a List

Use a list when you think: “I have a sequence of items, in order, that might change.”

Typical situations:

• A to-do list of tasks:
• Order matters (task 1, task 2, …)
• You might add or remove tasks
• A list of scores in a game:
• You may sort them, append new scores
• A list of user inputs:
• You gather values over time

Good signs you want a list:

• You say “the first, second, third…” item
• You want to loop in order: for item in items:
• You want to add/remove items often: append, pop, remove, insert
• You often use indexes: items[0], items[1]

Example use cases:

• Shopping cart items in an online store:

  cart_items = ["apple", "banana", "chocolate"]

• Recent search queries:

  recent_searches = ["python list tutorial", "best laptop", "weather today"]

If your main question is “What’s the item at position N?”, a list is usually the first choice.

When to Use a Tuple

Use a tuple when you think: “I have a small fixed collection of values that belong together and should not change.”

Tuples are good for records: one thing with several fields.

Typical situations:

• Representing a 2D coordinate:

  point = (10, 20)   # x, y

• Representing a date as (year, month, day):

  birthday = (1995, 7, 30)

• Returning multiple values from a function

Good signs you want a tuple:

• The number of items is fixed and meaningful together
• You don’t want code elsewhere to accidentally change them
• You use them as keys in a dictionary (requires immutability)

Compare:

• List (changeable collection): colors = ["red", "green", "blue"]
• Tuple (fixed record): rgb = (255, 200, 150)

If your main thought is “These values form one unchanging thing”, consider a tuple.

When to Use a Dictionary

Use a dict when you think: “I want to look up values by a name or key, not by position.”

Dictionaries are like labeled drawers: each value has a label (key).

Typical situations:

• Storing a user profile:

  user = {
      "username": "alice",
      "age": 30,
      "email": "alice@example.com"
  }

• Counting how many times each word appears:

  word_counts = {"python": 3, "code": 5}

• Storing settings:

  settings = {
      "volume": 80,
      "theme": "dark",
      "notifications": True
  }

Good signs you want a dictionary:

• You care about meaningful names for each value
• You say “look up X by its name or id”
• You don’t want to remember a position number; you want to use a key:
• user["email"] is clearer than user[2]
• You might add new fields later without breaking code

If your main question is “What is the value for this key?”, choose a dictionary.

When to Use a Set

Use a set when you think: “I want a collection that automatically ignores duplicates and cares only about membership, not order.”

Sets are like bags where:

• Each item can appear at most once
• Order is not guaranteed

Typical situations:

• Keeping track of unique items:
• Unique visitors to a website
• Unique tags on a blog
• Checking membership quickly:
• “Is this item in the allowed list?”
• Doing set operations:
• Union, intersection, difference

Example:

visited_pages = {"home", "about", "contact"}
if "blog" not in visited_pages:
    print("User has not visited the blog page yet")

Good signs you want a set:

• You say “unique list of …”
• Order doesn’t matter
• You often ask: “Is X in this collection?” (in checks)

If your main question is “Is this item present, and I don’t care about duplicates or order?”, use a set.

Comparing Data Structures by Common Needs

Here’s a quick comparison based on typical needs:

1. Do you need to keep the order?

• Yes, order matters:
• Use list (usually)
• tuple for fixed ordered records
• No, order doesn’t matter:
• Use set (for unique items)
• Use dict when you care about key-value pairs (modern Python keeps insertion order, but dicts are mainly for key lookups)

2. Will the contents change?

• Will change (add/remove/edit):
• list, dict, set
• Should stay the same (fixed):
• tuple (good for constants or records that shouldn’t change)

3. Do you need named fields?

• Yes, named fields:
• Use dict:
• user["age"] instead of user[1]
• No, just a sequence:
• list (if changeable or long)
• tuple (if fixed-size record)

4. Are duplicates allowed?

• Duplicates allowed:
• list, tuple
• No duplicates:
• set (for just values)
• Keys in a dict are also unique (values don’t have to be)

5. What’s the main operation?

• Access by position (items[0], items[1]):
• list or tuple
• Access by key/name (profile["email"]):
• dict
• Check if something exists (if x in collection:) without worrying about order:
• set (best), or dict keys

Real-World Scenario Examples

Example 1: Students in a class

You’re storing information about students.

You might use:

• A list of student names (order maybe doesn’t matter, but duplicates might be ok):

  students = ["Alice", "Bob", "Charlie"]

• A dict for a single student’s details:

  student = {
      "name": "Alice",
      "age": 20,
      "id": "S123",
      "grade": "A"
  }

• A set of student IDs to quickly check uniqueness:

  student_ids = {"S123", "S456", "S789"}

• A tuple for a fixed record like (name, age, id):

  alice = ("Alice", 20, "S123")

Here you might combine several structures:

• A list of dictionaries:

  students = [
      {"name": "Alice", "age": 20, "id": "S123"},
      {"name": "Bob", "age": 21, "id": "S124"},
  ]

Example 2: Settings for an application

You’re storing app settings that can be changed during runtime:

• Use a dict:

  settings = {
      "theme": "dark",
      "volume": 70,
      "language": "en"
  }

Why dict?

• You want to look up by setting name ("theme", "volume")
• You may add new settings later

A list like ["dark", 70, "en"] is less clear: what does each position mean?

Example 3: Tags on blog posts

You have tags such as "python", "learning", "beginner".

• Use a set for tags per post:

  tags = {"python", "learning", "beginner"}

• If a user adds "python" again, the set still has only one "python"

If you need to store posts with their tags:

post = {
    "title": "Learning Python",
    "tags": {"python", "learning", "beginner"}
}

Here you combine a dict (for named fields) and a set (for unique tags).

Example 4: Ordered steps in a recipe

A recipe has steps that must be followed in order:

• Use a list:

  steps = [
      "Preheat the oven to 180°C",
      "Mix flour and sugar",
      "Add eggs",
      "Bake for 25 minutes"
  ]

You might insert a new step or change one, so a list is more flexible than a tuple here.

Simple Decision Guide

You can use this as a quick mental checklist:

1. Is this a sequence of items, possibly with duplicates, where order matters?
   → Use a list.
2. Is this a small, fixed-size “record” that forms one unit and should not change?
   → Use a tuple.
3. Do I need to map names/keys to values (like a mini-database of properties)?
   → Use a dict.
4. Do I only care about unique items and quick membership tests, not order?
   → Use a set.
5. Do I need a combination?
• Lists of dictionaries
• Dictionaries with sets inside
• Lists of tuples
  Often, real programs use several data structures together.

Practicing Choosing Data Structures

To get better at this, practice by:

• Taking a real-world object (book, user, product, event) and deciding:
• Should it be a dict, a tuple, or something else?
• Looking at a problem and asking:
• Do I care about order, uniqueness, quick lookup, or fixed records?

Example practice questions (you don’t have to code them now, just think about the choice):

1. A playlist of songs where order matters and songs can repeat
2. A product with a name, price, and stock count
3. A list of all unique countries users are from
4. Store each user’s username and their list of favorite movies

Your job is to decide:

• Which data structure (or combination) makes the most sense?
• Why that choice fits the needs (order, mutability, duplicates, lookup method)?

The more you think this way, the more natural choosing the right data structure will become.