Introduction

In Python, a dictionary maps one key to one value, but that value can itself be a collection. So when people ask for "one key, many values", the normal solution is a dictionary whose values are lists, sets, or another container type.

That pattern is common for grouping records, building indexes, and collecting repeated events under the same label. The main design choice is not whether Python allows it, but which collection type best matches the behavior you want.

Using Lists as the Value

If you want to preserve insertion order and allow duplicates, store a list for each key.

1groups = {
2    "python": ["decorators", "typing"],
3    "sql": ["joins"],
4}
5
6groups["python"].append("context managers")
7print(groups)

This is the simplest solution when repeated values are meaningful.

Building the Dictionary Incrementally

When the keys are not known in advance, defaultdict(list) is a clean option.

1from collections import defaultdict
2
3words_by_letter = defaultdict(list)
4
5for word in ["apple", "ant", "banana", "boat"]:
6    words_by_letter[word[0]].append(word)
7
8print(dict(words_by_letter))

defaultdict creates the list automatically the first time a key is used, so you do not need an explicit existence check.

setdefault as a Built-In Alternative

If you do not want defaultdict, use setdefault.

1groups = {}
2
3for tag, article in [
4    ("python", "Generators"),
5    ("python", "Dataclasses"),
6    ("git", "Rebase"),
7]:
8    groups.setdefault(tag, []).append(article)
9
10print(groups)

This is convenient for small scripts, though defaultdict is often cleaner for repeated grouping logic.

Use a Set When Duplicates Should Be Ignored

If each key should contain unique values only, use a set instead of a list.

1from collections import defaultdict
2
3skills = defaultdict(set)
4
5skills["alice"].add("python")
6skills["alice"].add("python")
7skills["alice"].add("sql")
8
9print(skills["alice"])

The second "python" is ignored automatically because sets keep unique values.

Choosing the Right Collection

Use a list when:

• Order matters
• Duplicate values are meaningful
• You may need indexing or stable output order

Use a set when:

• Uniqueness matters more than order
• Membership checks should be fast
• Duplicate inserts should collapse automatically

You can also use tuples, counters, nested dictionaries, or custom objects if the grouped value has more structure than a simple collection.

A Real Grouping Example

Grouping rows by key is one of the most common uses of this pattern.

1from collections import defaultdict
2
3orders = [
4    ("north", 120),
5    ("south", 90),
6    ("north", 75),
7]
8
9sales_by_region = defaultdict(list)
10
11for region, amount in orders:
12    sales_by_region[region].append(amount)
13
14totals = {region: sum(amounts) for region, amounts in sales_by_region.items()}
15print(totals)

Here, one dictionary key collects many numeric values, and a later step reduces them into totals.

Common Pitfalls

The classic mistake is reusing the same mutable list for multiple keys by accident. Each key should get its own list or set.

Another issue is choosing a list when the real requirement is uniqueness. That leads to manual duplicate checks that a set would have handled automatically.

Be careful when exposing the stored collections to other parts of the program. Lists and sets are mutable, so callers can modify them unless you copy or wrap the values.

Finally, remember that dictionary keys are still unique. "One key, many values" means one key maps to one collection object, not that the dictionary itself stores duplicate keys.

Summary

• Python handles "one key, many values" by storing a collection as the dictionary value.
• Use lists when order and duplicates matter.
• Use sets when uniqueness matters.
• 'defaultdict and setdefault are the standard tools for building these mappings incrementally.'
• Pick the value type based on how the grouped data will be queried and updated.