Python Data Types & Structures

Start Here: The Mental Model

Think of Python's data structures like containers at a hardware store.

• A list is like a shopping cart — ordered, you can add or remove items, and things can repeat.
• A tuple is like a locked display case — ordered, but nobody's changing what's inside.
• A set is like a bag where duplicates automatically fall out — unordered, unique items only.
• A dictionary is like a filing cabinet — every item has a label (key) so you can find it instantly.

That mental model alone will carry you pretty far. Now let's go deeper.

Lists — Your Everyday Workhorse

A list is an ordered, mutable sequence. "Mutable" means you can change it after creation.

When to use a list:

• You care about order.
• You need to add, remove, or modify items.
• Duplicates are fine or even expected.

Common pitfall: Lists are slow for membership checks. If you're writing if item in my_list in a tight loop with thousands of items, switch to a set. Checking membership in a list is O(n) — it scans every element. A set does it in O(1).

Tuples — Lightweight and Immutable

A tuple looks like a list but uses parentheses and cannot be changed after creation.

When to use a tuple:

• The data shouldn't change — like coordinates, RGB values, or database records.
• You need to use it as a dictionary key (lists can't be keys because they're mutable).
• You want a small performance edge — tuples use slightly less memory than lists.

Common confusion: Some devs avoid tuples entirely and just use lists everywhere. That works, but it misses a signal. When you use a tuple, you're saying "this data is fixed." It communicates intent, and Python also enforces it.

Sets — When Uniqueness Is the Point

A set stores only unique values and doesn't preserve insertion order.

When to use a set:

• You need to eliminate duplicates.
• You want fast membership testing (in checks).
• You're doing set operations: union, intersection, difference.

Common pitfall: You can't index a set (my_set[0] raises an error). If you need both uniqueness and order, consider a list that you deduplicate, or look into dict.fromkeys() which preserves insertion order.

Dictionaries — Key-Value Lookup, Fast

A dictionary maps keys to values. Lookups by key are O(1) — essentially instant regardless of size.

When to use a dictionary:

• You need to look something up by name or ID.
• You're counting things (word_count["hello"] += 1).
• You're grouping data by a category.
• You want structured data without defining a class.

Common pitfall: Accessing a key that doesn't exist raises a KeyError. Use .get() instead for safe access:

List Comprehensions and Dict Comprehensions

These are one-liners for building collections. They're faster than loops and, once you're used to them, more readable.

List comprehension:

Dict comprehension:

When to use them: When you're transforming or filtering a collection in one step. If the logic gets complex (nested ifs, nested loops), a regular for loop is clearer. Comprehensions aren't always better — just often more concise.

Mutable vs Immutable — Why It Matters

Mutable objects can be changed after creation: lists, dicts, sets.

Immutable objects cannot: integers, floats, strings, tuples.

This distinction has practical consequences.

The bigger trap is with mutable default arguments in functions:

This trips up almost every Python developer at least once. The default list is created once when the function is defined, not each time it's called.

Time and Space Complexity — The Practical Summary

You don't need to memorize every operation, but these are the ones that matter most in practice.

The one to internalize first: membership testing in a list is slow. If you're checking if x in collection frequently, use a set or dict instead.

Space-wise, sets and dicts consume more memory than lists because they maintain hash tables internally. For small datasets this doesn't matter. For millions of records, it might.

Takeaway

• List when order matters and data changes.
• Tuple when data is fixed and order matters.
• Set when you need uniqueness and fast lookups.
• Dict when you need to find things by a key.

Use comprehensions to build collections cleanly, but keep them readable. Understand mutability so you don't get surprised by shared state. And know that in checks on a list are linear — if you're doing many of them, reach for a set.

These aren't just syntax rules. Each choice communicates intent to the next person reading your code — including future you.