HashSet Hashtable Python: Choose the Right Types

An inventory often needs a quick way to find the quantity attached to a product name. Python dicts map keys to values, while sets hold distinct values for membership checks.

I’ll explain how to choose between them and demonstrate dictionary lookups and set operations.

TL;DR: Python Sets and Dictionaries

In Python, use a set for distinct values and membership checks, and a dict for keys that point to values. Those built-ins cover the jobs commonly called a hash set and a hash table.

• Choose a set when a value either belongs in a collection or does not.
• Choose a dict when you need to retrieve information by a unique key.
• Both require hashable members or keys, and equal values occupy one slot.

What Are Python Sets and Dictionaries?

A Python set holds distinct hashable objects, while a dict maps each hashable key to a value. The stored data answers a different question: “Is this value present?” or “What value belongs to this key?”

A dict_keys view reflects later changes to its dictionary instead of copying the current keys. Its set-like operators help compare two mappings by key when their associated values are irrelevant.

HashSet and Hashtable describe collection roles in other languages. Python’s built-in names are set and dict, so I use the required lookup job rather than searching for a class with the translated name. The Python set documentation defines sets as unordered collections of distinct hashable objects, and the dict documentation defines the key-to-value mapping.

Hashing narrows a lookup to candidate entries, then equality determines whether a candidate matches. Python requires equal objects to have equal hash values, but unequal objects may share one. See the Python data model’s hash rules.

How to Use Sets and Dictionaries in Python

I sort set results for display so readers see stable examples without relying on a set’s iteration order.

Step 1: Remove duplicate values with a set

This demo verifies that a set keeps one copy of each produce name and reports whether oak appears.

values = ["oak", "pine", "oak", "birch"]
unique_values = set(values)
print(f"Unique values: {sorted(unique_values)}")
print(f"'oak' present: {'oak' in unique_values}")

Unique values: ['birch', 'oak', 'pine']
'oak' present: True

The sorted display contains three labels, while the membership check confirms oak.

Set conversion removes duplicate values but discards their original positions. If first-occurrence order matters, dict.fromkeys(values) creates a mapping that keeps the keys in insertion order.

Convert that mapping’s keys to a list only when later code needs list behavior. Sorting has a different purpose: it arranges values for presentation, as in the screenshot above.

Step 2: Look up and update a dictionary value

The dictionary demo updates oak’s quantity and requests a fallback for a missing maple key.

inventory = {"oak": 12, "pine": 7}
inventory["oak"] += 3
print(f"Oak stock: {inventory['oak']}")
print(f"Keys in insertion order: {list(inventory)}")
print(f"Missing stock default: {inventory.get('maple', 0)}")

Oak stock: 15
Keys in insertion order: ['oak', 'pine']
Missing stock default: 0

The bracket expression adds three to oak’s value, while get returns 0 for absent maple. Use get when the fallback is meaningful and bracket lookup when a missing key should raise KeyError.

The get call reads the mapping without inserting an absent key.

The in operator tests dictionary keys rather than stored values. Use inventory.values() to test whether a value appears. If None is a valid value, dict.get(key) returning None cannot distinguish an absent key from one mapped to None, so test key membership when that distinction matters.

Assigning to an existing equal key replaces its stored value rather than creating a second mapping entry. When source records repeat a key, ordinary assignment keeps the last value.

Step 3: Compare values with set operations

The set operation demo finds shared values and a value present only in the store group.

allowed = {"oak", "pine", "birch"}
in_store = {"pine", "maple"}
shared = allowed & in_store
print(f"Shared values: {sorted(shared)}")
print(f"Only in store: {sorted(in_store - allowed)}")

Shared values: ['pine']
Only in store: ['maple']

The overlap is pine, and maple appears only in the store group. I chose the operator forms because they keep two-set expressions compact. The named methods express the same operations.

The named union() and intersection() methods accept an iterable as input. Their corresponding | and & operators use set operands, so I keep the examples’ inputs as sets. The ^ operation gives the values present in exactly one group.

Common Set and Dictionary Edge Cases

The demo contrasts an unhashable list with an integer tuple that works as a set member.

I ran python3 hashability_demo.py to capture the list-member error, check an immutable tuple, and compare equal numeric values.

try:
    members = {[1, 2]}
except TypeError as error:
    print(f"List member: {error}")

fixed_pair = (1, 2)
print(f"Tuple member: {fixed_pair in {fixed_pair}}")
numeric_values = {1, 1.0}
print(f"Equal numeric values: {len(numeric_values)}")

List member: cannot use 'list' as a set element (unhashable type: 'list')
Tuple member: True
Equal numeric values: 1

A list cannot be a set member, while an integer tuple works. A tuple containing a list also raises TypeError because the nested list is unhashable.

Python treats 1 and 1.0 as numerically equal, so the output shows a set size of one. Keep custom equality and hash fields stable while their objects are stored.

For a set that must itself appear inside another set, use frozenset, the immutable set type, with hashable values. A dictionary value can be a list because values are retrieved after a key lookup and do not determine that key’s hash.

Conclusion: Choose by the Lookup You Need

Before choosing, write down the item you will search for and the information you need back. That gives you the input shape to compare with the examples above and the Python documentation below.

FAQ

In Python, the built-in set covers unique membership and dict covers key-to-value lookup. These answers distinguish those names from HashSet and Hashtable terminology.