Practice Now
Python
dictionaries
list
search
programming

Search a list of dictionaries in Python

Data Structures & Algorithms practice on Codemia

Step through 300 algorithm problems with animated visualisers that show the data structure changing as the code runs.

Practice algorithms
Data StructuresPython

Introduction

Searching a list of dictionaries is a common task when working with records, API responses, or configuration data in Python. The most Pythonic approach uses a generator expression with next() for single matches or a list comprehension for multiple matches. For frequent lookups, build an index dictionary keyed by the search field. The right approach depends on whether you need one result or many, and how often you search the same data.

Find First Match

Use next() with a generator expression to find the first dictionary matching a condition:

python
1users = [
2    {"id": 1, "name": "Alice", "role": "admin"},
3    {"id": 2, "name": "Bob", "role": "user"},
4    {"id": 3, "name": "Charlie", "role": "user"},
5]
6
7# Find user with id 2
8user = next((u for u in users if u["id"] == 2), None)
9print(user)  # {"id": 2, "name": "Bob", "role": "user"}
10
11# Not found → returns None (the default)
12user = next((u for u in users if u["id"] == 99), None)
13print(user)  # None
14
15# Without default, raises StopIteration if not found
16user = next(u for u in users if u["id"] == 1)

next() stops as soon as the first match is found — it does not scan the entire list.

Find All Matches

Use a list comprehension to find all matching dictionaries:

python
1users = [
2    {"id": 1, "name": "Alice", "role": "admin"},
3    {"id": 2, "name": "Bob", "role": "user"},
4    {"id": 3, "name": "Charlie", "role": "user"},
5]
6
7# Find all users with role "user"
8regular_users = [u for u in users if u["role"] == "user"]
9print(regular_users)
10# [{"id": 2, "name": "Bob", ...}, {"id": 3, "name": "Charlie", ...}]
11
12# Multiple conditions
13admins_named_alice = [u for u in users if u["role"] == "admin" and u["name"] == "Alice"]

Search by Partial Match

python
1# Case-insensitive name search
2def search_by_name(users, query):
3    query = query.lower()
4    return [u for u in users if query in u["name"].lower()]
5
6results = search_by_name(users, "ali")
7print(results)  # [{"id": 1, "name": "Alice", ...}]
8
9# Search across multiple fields
10def search_any_field(users, query):
11    query = query.lower()
12    return [
13        u for u in users
14        if any(query in str(v).lower() for v in u.values())
15    ]
16
17results = search_any_field(users, "bob")

Build an Index for Fast Lookups

When searching the same list repeatedly, build a dictionary index:

python
1users = [
2    {"id": 1, "name": "Alice", "role": "admin"},
3    {"id": 2, "name": "Bob", "role": "user"},
4    {"id": 3, "name": "Charlie", "role": "user"},
5]
6
7# Index by id (unique key)
8users_by_id = {u["id"]: u for u in users}
9
10# O(1) lookup instead of O(n)
11print(users_by_id[2])  # {"id": 2, "name": "Bob", ...}
12print(users_by_id.get(99))  # None
13
14# Index by role (non-unique key) → dict of lists
15from collections import defaultdict
16users_by_role = defaultdict(list)
17for u in users:
18    users_by_role[u["role"]].append(u)
19
20print(users_by_role["user"])  # [Bob, Charlie]

Using filter()

python
1# filter returns an iterator
2admins = filter(lambda u: u["role"] == "admin", users)
3print(list(admins))  # [{"id": 1, "name": "Alice", ...}]
4
5# filter with a custom function
6def is_active_admin(user):
7    return user["role"] == "admin" and user.get("active", False)
8
9active_admins = list(filter(is_active_admin, users))

List comprehensions are generally preferred over filter() in Python for readability.

Using operator.itemgetter

python
1from operator import itemgetter
2
3users = [
4    {"id": 1, "name": "Alice", "score": 95},
5    {"id": 2, "name": "Bob", "score": 80},
6    {"id": 3, "name": "Charlie", "score": 90},
7]
8
9# Sort by score
10sorted_users = sorted(users, key=itemgetter("score"), reverse=True)
11print([u["name"] for u in sorted_users])  # ["Alice", "Charlie", "Bob"]
12
13# Find max/min by a field
14best = max(users, key=itemgetter("score"))
15print(best["name"])  # Alice

Handling Missing Keys

python
1users = [
2    {"id": 1, "name": "Alice", "email": "[email protected]"},
3    {"id": 2, "name": "Bob"},  # no email key
4]
5
6# Using .get() to avoid KeyError
7with_email = [u for u in users if u.get("email")]
8print(with_email)  # [Alice]
9
10# Safe search with default
11def find_by_field(users, field, value):
12    return [u for u in users if u.get(field) == value]
13
14results = find_by_field(users, "email", "[email protected]")

Common Pitfalls

  • Using a loop when next() suffices: Writing a for loop with break to find the first match is verbose. next(x for x in items if condition, default) is the idiomatic Python pattern.
  • Linear search on repeated lookups: Searching a list of 10,000 dictionaries 1,000 times is O(n*m). Build an index dictionary once (O(n)) and use O(1) lookups for each query.
  • KeyError on missing fields: Not all dictionaries may have the same keys. Use u.get("key") instead of u["key"] to safely handle missing fields, or filter with "key" in u first.
  • Mutating dictionaries during search: Modifying a dictionary while iterating over the list can cause unexpected behavior. Create a new list of results rather than modifying in place.
  • Forgetting that next() without a default raises StopIteration: If no match is found and no default is provided, next() raises StopIteration, which can be confusing inside generators or loops. Always provide a default value like None.

Summary

  • Use next(x for x in items if cond, None) to find the first matching dictionary
  • Use list comprehensions [x for x in items if cond] to find all matches
  • Build a dictionary index {d["key"]: d for d in items} for O(1) repeated lookups
  • Use .get() instead of [] to safely handle missing keys
  • Use sorted() with key=itemgetter("field") for sorting by a specific key
  • Prefer list comprehensions over filter() for readability
Related reading
Course
Intermediate
27 lessons
15 hours
DSA Fundamentals

Master algorithmic patterns and data structures through hands-on LeetCode-style problems - from arrays and hashing to dynamic programming and advanced graphs.

View the course
Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

Data Structures & Algorithms practice on Codemia

Step through 300 algorithm problems with animated visualisers that show the data structure changing as the code runs.

Practice algorithms
Codemia
© 2026 Codemia
Resources
Legal
Social
All Rights Reserved.