Combining Conditions

Multiple Conditions

A single boolean filter gets you pretty far, but real questions usually need more:

• Find employees in HR who earn over 80,000
• Show me orders from March or April
• Get everyone except the Admin department

That’s where &, |, and ~ come in. They let you combine multiple conditions into one filter.

& (AND): Both Conditions Must Be True

orders[
    (orders["order_details"] == "Coat") &
    (orders["total_order_cost"] > 100)
]

Both conditions must be true for a row to be included.

Chaining Multiple Conditions

You can chain as many & conditions as you need:

Each & adds another filter, narrowing your results.

Churro Activity Date

| (OR): Either Condition Can Be True

orders[
    (orders["total_order_cost"] > 500) |
    (orders["order_details"] == "Coat")
]

A row only needs to match one condition to be included. HR employees are in, Admin employees are in, Engineering employees are out.

Lyft Driver Wages

Matching a List of Values with .isin()

Chaining | for the same column gets ugly fast. .isin() replaces it with a single clean expression.

Instead of chaining multiple == comparisons with |, use .isin():

# Instead of this:
df[(df["dept"] == "HR") | (df["dept"] == "Admin")]

# Do this:
df[df["dept"].isin(["HR", "Admin"])]

Matching Multiple Values

# Exclude with ~
techcorp_workforce[
    ~techcorp_workforce["department"].isin(["HR", "Admin"])
]

Athletes Over 40 With Bronze or Silver

Range Filtering with .between()

orders[orders["total_order_cost"].between(50, 200)]

# .between() with dates
techcorp_workforce[techcorp_workforce["joining_date"].between("2022-01-01", "2022-12-31")]

Date Ranges

.between() works with dates too — pass date strings in YYYY-MM-DD format.

~ (NOT): Exclude Matches

Negation is surprisingly useful. Instead of listing every department you want, sometimes it’s easier to say "everything except Admin." ~ flips True to False and False to True — giving you the opposite of any condition.

~ inverts a boolean condition. It gives you everything that doesn’t match.

# Everyone except Admin
techcorp_workforce[~(techcorp_workforce["department"] == "Admin")]

This is equivalent to using !=:

techcorp_workforce[techcorp_workforce["department"] != "Admin"]

Both work. ~ is especially useful combined with .isin() and .str.contains(), as you’ve already seen.

Negating a Condition

Combining & and |

Mixing AND and OR is where most bugs happen. The issue is operator precedence: & binds tighter than |, just like multiplication before addition. If you don’t add parentheses, you’ll get silently wrong results — the query runs fine, but the logic isn’t what you intended.

Let’s say you want employees in HR or Engineering, but only those earning over 80,000. You might write:

# This doesn't do what you think!
techcorp_workforce[
    (techcorp_workforce["department"] == "HR") |
    (techcorp_workforce["department"] == "Engineering") &
    (techcorp_workforce["salary"] > 80000)
]

Because & is evaluated first, Python reads this as:

# What Python actually evaluates:
# HR (any salary) OR (Engineering AND salary > 80000)

So you get ALL HR employees (regardless of salary) plus Engineering employees earning over 80,000. Not what you wanted.

Use Parentheses to Control Order

High Earners in Support Departments

Keeping It Readable

Production code gets read far more than it gets written. A filter that takes 30 seconds to decipher costs time whenever someone revisits it. These two patterns — named variables and line breaks — make your filters self-documenting.

Break conditions into variables

is_hr = techcorp_workforce["department"] == "HR"
is_admin = techcorp_workforce["department"] == "Admin"
high_earner = techcorp_workforce["salary"] > 80000

techcorp_workforce[(is_hr | is_admin) & high_earner]

Naming your conditions makes complex filters much easier to read and debug.

Use backslash for line breaks

techcorp_workforce[
    (techcorp_workforce["department"] == "HR") &
    (techcorp_workforce["salary"] > 80000) &
    (techcorp_workforce["joining_date"] > "2022-01-01")
]

Putting each condition on its own line with consistent indentation keeps things scannable.

Common Mistakes

Missing parentheses around conditions

# Wrong: missing parentheses around conditions
techcorp_workforce[
    techcorp_workforce["department"] == "HR" &
    techcorp_workforce["salary"] > 80000
]

# Correct: each condition wrapped in parentheses
techcorp_workforce[
    (techcorp_workforce["department"] == "HR") &
    (techcorp_workforce["salary"] > 80000)
]

Without parentheses, & binds to "HR" and techcorp_workforce instead of the full conditions. This is the number one cause of errors with combined filters.

Using and/or instead of &/|

# Wrong: Python keywords don't work on Series
techcorp_workforce[
    (techcorp_workforce["department"] == "HR") and
    (techcorp_workforce["salary"] > 80000)
]

# Correct: use & and | for element-wise operations
techcorp_workforce[
    (techcorp_workforce["department"] == "HR") &
    (techcorp_workforce["salary"] > 80000)
]

Python’s and/or keywords work on single True/False values. For filtering DataFrames, you need &/|, which work element-wise across entire columns.

Key Takeaways

• & requires all conditions to be true (AND).
• | requires at least one condition to be true (OR).
• ~ inverts a condition (NOT).
• Every condition must be wrapped in parentheses when combining with & or |.
• & is evaluated before | — use extra parentheses to control the order.
• Use & and |, never Python’s and and or, when filtering DataFrames.
• .isin([list]) matches multiple values; ~ inverts any filter.
• .between(low, high) filters inclusive ranges — works with numbers and dates.

What’s Next

Missing values are one of the most common headaches in data analysis. In the next lesson, you'll learn what NaN really means, why comparisons break, and how to handle it correctly.