Quick answer: A Python dictionary is the standard hashmap-like data structure. It maps hashable keys to values, gives average-case constant-time lookup for ordinary workloads, preserves insertion order, and handles collision details internally.
In Python, the everyday hashmap is the dict. A dictionary stores key-value pairs so code can look up a value by key without scanning every item manually. This makes dictionaries one of the most useful data structures in Python programs.
The official Python documentation for dictionary mapping types, the dictionary tutorial, and hashable objects explains the core behavior.
A hashmap uses a hash of the key to find where data belongs internally. Python handles those internals for you. You choose keys, store values, and use dictionary operations such as lookup, assignment, membership checks, and iteration.
Dictionary keys must be hashable. Strings, numbers, booleans, and tuples of hashable values work well. Lists and dictionaries do not work as keys because they can change after insertion.
Use dictionaries when data has natural labels: usernames, IDs, settings, counts, categories, cache keys, filenames, or any record that should be retrieved by a stable name.
Modern Python dictionaries preserve insertion order as part of the language behavior. That means iteration follows the order keys were first added, but lookup is still based on keys rather than positions.
Hash collisions are possible in theory, but Python dictionaries handle them internally. Application code should focus on choosing clear, stable keys and avoiding mutable key objects.
Create A Hashmap With dict
A dictionary literal uses braces with key-value pairs separated by colons.
profile = {
"name": "Ada",
"language": "Python",
"active": True,
}
print(profile["name"])
print(profile["active"])
The keys are strings, and each key maps to one value. Looking up profile["name"] returns the value stored for that key.
Use clear key names that describe the data. A readable dictionary is often easier to maintain than several separate lists that must stay aligned by index.
If each key describes one real-world entity, a dictionary can make later updates direct. Code can update one user’s status by key instead of searching through a list of records.
Add And Update Values
Assigning to a key adds a new pair when the key is missing and updates the pair when the key already exists.
settings = {}
settings["theme"] = "light"
settings["items_per_page"] = 20
settings["theme"] = "dark"
print(settings)
The final dictionary keeps the latest value for "theme". A dictionary cannot store two separate values for the same key at the same level.
If a key should hold several values, store a list or set as the value. The key itself still remains unique.
That distinction keeps the mapping simple. The dictionary maps one key to one object, and that object may itself contain several pieces of data.
Check For Keys Safely
Use in to test whether a key exists, or use get() when a fallback value is appropriate.
scores = {"Asha": 91, "Ben": 84}
print("Asha" in scores)
print(scores.get("Noah", 0))
if "Ben" in scores:
print(scores["Ben"])
This avoids a KeyError when a key is missing. Use direct indexing when a missing key means the program should fail loudly.
Use get() for optional data, but do not hide missing required data with a default that looks real.
For required configuration, direct indexing is often better because a missing key raises an immediate error. For optional settings, get() keeps the fallback near the lookup.
Count Items With A Dictionary
Dictionaries are useful for counting because each distinct item can become a key.
words = ["api", "python", "api", "data", "python", "api"]
counts = {}
for word in words:
counts[word] = counts.get(word, 0) + 1
print(counts)
print(counts["api"])
The dictionary stores one counter per word. Each loop either starts a count at zero or increments the existing count.
For production counting code, collections.Counter is often more compact, but the manual version shows the hashmap idea clearly.
The same counting pattern works for grouped totals, status summaries, word frequencies, and simple analytics dashboards.
Use Tuples As Composite Keys
A tuple can combine several pieces of data into one hashable key, as long as every item inside the tuple is hashable.
inventory = {}
inventory[("warehouse-a", "keyboard")] = 12
inventory[("warehouse-a", "mouse")] = 30
inventory[("warehouse-b", "keyboard")] = 7
print(inventory[("warehouse-a", "keyboard")])
print(sum(inventory.values()))
This is useful when a lookup depends on more than one field. The tuple key keeps the lookup simple without nesting dictionaries.
Use a small named tuple or dataclass when tuple positions become hard to remember. The key should stay readable.
Composite keys are most helpful when the combination is stable and small. If the data grows into many fields, a nested dictionary or a proper record type may be easier to maintain.
Handle Unhashable Keys
Lists are not valid dictionary keys because they are mutable. Convert list-like key data to a tuple when the contents should identify a value.
lookup = {}
try:
lookup[["red", "blue"]] = "bad key"
except TypeError as error:
print(type(error).__name__)
lookup[("red", "blue")] = "valid key"
print(lookup[("red", "blue")])
The list key raises TypeError, while the tuple key works. That is because tuples are hashable when their contents are hashable.
The practical rule is to use dictionaries when values should be found by stable keys. Keep keys hashable, use membership checks for optional data, and choose clear key names so the mapping explains itself.
How A Dictionary Works As A Hashmap
A hashmap uses a hash derived from a key to locate a storage position. Python’s dict hides that table and resize policy behind a small interface: assign a key, retrieve it, test membership, or remove it. The useful application-level decision is the key contract, not the table implementation.
profile = {
"name": "Ada",
"language": "Python",
}
profile["level"] = "advanced"
print(profile["language"])
print("name" in profile)Choose Hashable Keys
Dictionary keys must be hashable, which generally means their hash and equality behavior remain stable while they are stored. Strings, integers, booleans, and tuples containing hashable values are common. A list or dictionary is mutable and therefore cannot be used directly as a key.
cache = {
("user", 42): "profile loaded",
"timeout": 30,
}
print(cache[("user", 42)])
print(cache["timeout"])
Understand Lookup, Collisions, And Order
Dictionary lookup is average-case O(1), but that is a performance expectation rather than a guarantee for every adversarial workload. Different keys can hash to related positions; Python resolves collisions and resizes the table. Since modern Python preserves insertion order, iteration order is useful, but dictionary lookup is still key-based rather than index-based.
counts = {"python": 2, "data": 1}
counts["python"] += 1
counts["code"] = 4
for key, value in counts.items():
print(key, value)Use The Right Mapping Operation
Use direct indexing when a missing key is a programming error, get() for optional values, setdefault() for one-time initialization, and collections.defaultdict or Counter when the data model is naturally a grouped collection or a frequency table. These choices make the missing-key policy visible.
from collections import Counter
words = ["api", "python", "api", "python"]
counts = Counter(words)
print(counts["api"])
print(counts.most_common())Python’s official dict documentation defines mapping operations, and the hashable glossary entry explains which objects can be used as keys.
For related mapping patterns, compare dictionary size, key-value pairs, and OrderedDict when choosing a data structure.
Frequently Asked Questions
What is a hashmap in Python?
A Python dictionary is the standard hashmap-like mapping: it stores key-value pairs and uses a key to locate a value efficiently.
What can be a dictionary key?
A key must be hashable and stable while it is in the dictionary. Strings, numbers, and tuples containing hashable values are common choices.
Is dictionary lookup O(1) in Python?
Dictionary lookup is average-case O(1), but the exact behavior depends on hashing, collisions, and the workload; it is not a universal worst-case guarantee.
How does Python handle hash collisions?
Python handles collisions internally. Application code should use well-behaved, immutable keys instead of trying to manage the table itself.
