The dict in Python is a built-in mapping type that stores items as key-value pairs. This structure supports fast lookups, dynamic sizing, and flexible keys such as strings or numbers.
As a core data type, dict organizes data in an associative way, which makes it suitable for configuration, caches, counters, and many domain-specific models.
| Characteristic | Detail | Typical Use Case | Notes |
|---|---|---|---|
| Mutability | Mutable after creation | Updating counters or settings at runtime | Keys must be hashable and immutable |
| Ordering | Preserves insertion order (Python 3.7+) | Serialization and predictable iteration | Order is an official language guarantee since 3.7 |
| Key Requirements | Hashable and unique | String keys, integer IDs, tuples with immutables | Avoid lists or other dicts as keys |
| Performance | Average O(1) lookup and insert | Cache layers and indexing | Collision handling keeps operations efficient |
Dict Creation and Initialization
Literal Syntax and Constructors
You can create a dict using curly braces with colon-separated pairs or the dict() constructor. The literal form is concise, while the constructor supports conversion from sequences of pairs and keyword arguments.
Core Operations and Methods
Accessing, Adding, and Removing Items
Standard operations include reading by key, assigning new key-value pairs, using get() for safe access, and employing del or pop() for removal. Methods such as keys(), values(), and items() provide dynamic views for iteration.
Dict Internals and Performance
Hashing, Probing, and Memory Behavior
Under the hood, dict uses a hash table with open addressing. Hash values guide slot placement, and probing resolves collisions, which delivers consistent average-time performance even as the container grows.
Common Patterns and Optimization
Iteration, Merging, and Idiomatic Usage
Preferred patterns include dictionary comprehensions for transformations, the get method for counting, and the use of defaultdict or Counter from collections for specialized workflows. Merging with the unpacking operator promotes readable and expressive code.
Best Practices with Dict
- Prefer literal syntax for static mappings for readability
- Use get() or setdefault() to handle missing keys safely
- Choose the right key type to ensure hashability and uniqueness
- Leverage comprehensions for transformations and filtering
- Consider collections.Counter or defaultdict for counting and grouping
FAQ
Reader questions
Can a dict in Python use a list as a key?
No, a dict cannot use a list as a key because lists are mutable and not hashable. Keys must be hashable types such as strings, numbers, or tuples containing only hashable elements.
What happens when I assign a new value to an existing key?
Assigning a new value to an existing key replaces the previous value in place. The key retains its position in insertion order, and the old object becomes eligible for garbage collection if no other references exist.
How do dict views behave when the underlying dict changes?
Views returned by keys(), values(), and items() reflect live updates to the dict. Adding or removing items modifies the view automatically, and converting a view to a list captures a snapshot at that moment.
What is the best way to merge two dicts efficiently?
Use the unpacking operator {**d1, **d2} in Python 3.9+, the dict constructor with an iterable of pairs, or the | operator for a concise and efficient merge without mutating the originals.