Python Dictionary Comprehension Multiple Conditions

When you need to build a dictionary from an iterable while applying one or more conditions, Python's dictionary comprehension provides a concise syntax. The expression {key: value for item in iterable if condition} is the basic form, but real-world code often requires multiple conditions. This article explains how to use python dictionary comprehension multiple conditions effectively, covering if/else expressions, logical operators, and multiple filtering clauses.

Basic Dictionary Comprehension with a Single Condition

Start with the simplest case: filtering items before adding them to the dictionary. For example, create a dictionary of squares for even numbers:

numbers = [1, 2, 3, 4, 5]
even_squares = {n: n**2 for n in numbers if n % 2 == 0}
# {2: 4, 4: 16}

The if clause at the end filters the iterable. Only items that satisfy the condition are processed. This is the foundation for adding more conditions. n

Using if/else to Transform Values Conditionally

Sometimes you need to apply different transformations based on a condition. In that case, place the conditional expression in the value part of the comprehension:

numbers = [1, 2, 3, 4, 5]
label = {n: ("even" if n % 2 == 0 else "odd") for n in numbers}
# {1: 'odd', 2: 'even', 3: 'odd', 4: 'even', 5: 'odd'}

Here, the if/else is a Python expression, not a statement. It evaluates for every item. You can also use it on the key side, though that may cause collisions if the condition produces duplicate keys.

Combining Conditions with Logical Operators

When multiple conditions must be true simultaneously, use and, or, or not inside the if clause. For instance, select numbers that are both even and greater than 2:

numbers = [1, 2, 3, 4, 5, 6]
result = {n: n**2 for n in numbers if n % 2 == 0 and n > 2}
# {4: 16, 6: 36}

You can also use or to include items that satisfy at least one condition. The same logical operators work in the value expression when combined with if/else.

Using Multiple if Clauses

Python allows more than one if clause in a comprehension. Each if is evaluated in order, and all must pass for the item to be included. This is equivalent to chaining and conditions, but it can improve readability when the conditions are conceptually separate.

data = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 17}, {"name": "Carol", "age": 25}]
adults = {item["name"]:: item["age"] for item in data if item["age"] >= 18 if item["name"].startswith("A")}
# {'Alice': 30}

The order matters: the first if filters, then the second filters the remaining items. This can be useful when the second condition is expensive and should only run on items that already passed the first.

Applying Conditions to Keys and Values Independently

You can filter or transform keys and values separately. For example, build a dictionary where keys are filtered and values are transformed:

words = ["apple", "banana", "cherry", "date"]
short_words = {word: len(word) for word in words if len(word) <= 5}
# {'apple': 5, 'date': 4}

Or apply a condition on the value after transformation:

numbers = [1, 2, 3, 4, 5]
squares = {n: n**2 for n in numbers if n**2 > 10}
# {4: 16, 5: 25}

Note that the condition can reference the original item or the computed value, but the comprehension evaluates the expression only if the if passes. If you need to compute a value and then filter on it, you may need a helper function or a loop.

Performance and Readability Considerations

Dictionary comprehensions are generally faster than an explicit for loop with a conditional append, because they avoid repeated method calls and attribute lookups. However, when conditions become complex, readability suffers. A comprehension with three if clauses and a nested conditional expression can be hard to debug.

In such cases, consider a helper function that returns the key-value pair or None if the item should be skipped. For example:

def process(item):
    if not item.get("active"):
        return None
    if item["score"] < 0:
        return None
    return item["id"], item["score"]

result = {}
for item in data:
    pair = process(item)
    if pair is not None:
        key, value = pair
        result[key] = value

This is more maintainable than a deeply nested comprehension. The comprehension is best when the logic fits on one or two lines and the conditions are simple.

Common Mistakes and Edge Cases

One frequent error is using if/else in the filter position. The if at the end must be a boolean expression, not a conditional expression. For example, {n: n for n in numbers if n % 2 == 0 else n} is invalid syntax. The else belongs only in the value or key expression.

Another edge case is duplicate keys. If the condition produces the same key multiple times, the last value overwrites earlier ones. This is not an error but can lead to unexpected results. Ensure your key expression is unique for the filtered set.

Also, consider the order of conditions: if you have multiple if clauses, they are evaluated left to right. If the first condition is cheap and the second is expensive, put the cheap one first to short-circuit.

When a Loop Is Better Than a Comprehension

While comprehensions are concise, they are not always the best choice. If you need to update an existing dictionary, or if the logic involves side effects, a regular loop is clearer. For example, building a dictionary from two lists with complex matching logic is often easier with a loop.

keys = ["a", "b", "c"]
values = [1, 2, 3]
result = {}
for k, v in zip(keys, values):
    if k not in result and v > 0:
        result[k] = v

A comprehension cannot easily handle this kind of conditional insertion without extra checks. Use a loop when the condition depends on the state of the dictionary being built.