How to Use a Lambda Function to Check if a Value Is in a List in Python

Checking whether a value exists in a list is one of the most common operations in Python. While the in keyword handles this directly, there are scenarios where wrapping this check in a lambda function is useful, such as when passing a condition to filter(), map(), or other higher-order functions, or when you need a reusable inline check.

In this guide, you'll learn how to use lambda functions to check for value existence in a list, understand when this approach is appropriate, and see practical use cases.

Using in with a Lambda Function (Recommended)

The most straightforward approach uses Python's in keyword inside a lambda to create a concise membership test:

numbers = [1, 2, 3, 4, 5]

check = lambda value: value in numbers

print(check(4))
print(check(8))

Output:

True
False

How it works:

1. The lambda takes a value as its argument.
2. value in numbers performs a membership test against the list.
3. The expression returns True if the value exists, False otherwise.

You can make the lambda more flexible by accepting both the list and the value as parameters:

check = lambda lst, val: val in lst

numbers = [1, 2, 3, 4, 5]

print(check(numbers, 4))
print(check(numbers, 8))

Output:

True
False

When to use a lambda for this

A plain value in list is usually sufficient. Lambda functions become valuable when you need to pass the check as an argument to another function, such as filter(), map(), or custom functions that accept callables.

Practical Use Case: Filtering with Lambda

The real power of using lambda for membership checks appears when combined with higher-order functions like filter():

allowed = [2, 4, 6, 8, 10]
data = [1, 2, 3, 4, 5, 6, 7, 8]

# Keep only values that are in the allowed list
filtered = list(filter(lambda x: x in allowed, data))

print(filtered)

Output:

[2, 4, 6, 8]

Finding Elements NOT in a List

You can invert the check to find elements that are absent:

required = [1, 2, 3, 4, 5]
provided = [2, 4, 5]

missing = list(filter(lambda x: x not in provided, required))

print(f"Missing items: {missing}")

Output:

Missing items: [1, 3]

Using Lambda with count()

Another approach uses list.count() inside a lambda to check for existence. Since count() returns 0 for absent values (which is falsy) and a positive number for present values (which is truthy), it works as a boolean check:

numbers = [1, 2, 3, 4, 5]

check = lambda lst, val: lst.count(val) > 0

print(check(numbers, 3))
print(check(numbers, 8))

Output:

True
False

Performance difference: in vs count()

• in stops as soon as it finds the first match: O(n) worst case, but often faster.
• count() always scans the entire list to count all occurrences: always O(n).

For simple existence checks, in is more efficient and should be preferred.

Common Mistake: Unnecessary Lambda Wrapping

A common anti-pattern is wrapping a simple in check in a lambda when it's not needed:

Unnecessary lambda:

numbers = [1, 2, 3, 4, 5]
element = 4

# This lambda adds no value; just use `in` directly
check = lambda v: v in numbers
if check(element):
    print("Element is present")

Simpler and clearer:

numbers = [1, 2, 3, 4, 5]
element = 4

if element in numbers:
    print("Element is present")

Output:

Element is present

Only use a lambda when you genuinely need to pass the check as a callable or defer its execution.

Using Lambda to Check Multiple Values

Lambda functions are useful when you need to check the presence of multiple values against a list:

inventory = ["apple", "banana", "cherry", "date", "elderberry"]

shopping_list = ["banana", "fig", "cherry", "grape"]

# Check each item in the shopping list
availability = list(map(lambda item: (item, item in inventory), shopping_list))

for item, available in availability:
    status = "✅ Available" if available else "❌ Not available"
    print(f"  {item}: {status}")

Output:

  banana: ✅ Available
  fig: ❌ Not available
  cherry: ✅ Available
  grape: ❌ Not available

Using Lambda with any() and all()

Combine lambda with any() or all() for more complex checks:

data = [10, 25, 30, 45, 50]

# Check if ANY element satisfies a condition
has_large = any(map(lambda x: x > 40, data))
print(f"Has element > 40: {has_large}")

# Check if ALL elements satisfy a condition
all_positive = all(map(lambda x: x > 0, data))
print(f"All elements positive: {all_positive}")

Output:

Has element > 40: True
All elements positive: True

Checking Existence in a List of Objects

Lambda functions are particularly useful when checking if an object with a specific attribute value exists in a list:

class Employee:
    def __init__(self, name, department):
        self.name = name
        self.department = department

employees = [
    Employee("Alice", "Engineering"),
    Employee("Bob", "Marketing"),
    Employee("Charlie", "Engineering"),
    Employee("Diana", "Sales"),
]

# Check if any employee is in the "Marketing" department
has_marketing = any(map(lambda e: e.department == "Marketing", employees))
print(f"Has Marketing employee: {has_marketing}")

# Find all engineers
engineers = list(filter(lambda e: e.department == "Engineering", employees))
print(f"Engineers: {[e.name for e in engineers]}")

Output:

Has Marketing employee: True
Engineers: ['Alice', 'Charlie']

Quick Reference

Pattern	Use Case	Example
lambda v: v in lst	Simple membership check	check(4) -> True
filter(lambda x: x in allowed, data)	Keep matching elements	Returns filtered list
filter(lambda x: x not in excluded, data)	Remove matching elements	Returns non-matching items
any(map(lambda x: condition, data))	Check if any element matches	Returns True/False
all(map(lambda x: condition, data))	Check if all elements match	Returns True/False

Conclusion

Using lambda functions to check if a value exists in a list is straightforward in Python:

• lambda val: val in lst is the cleanest approach for creating a reusable membership check.
• Lambda functions are most valuable when passed to higher-order functions like filter(), map(), any(), and all().
• Prefer in over count() inside lambdas for better performance, since in short-circuits on the first match.
• Avoid unnecessary lambdas: if you're just checking element in list directly in your code, the plain in keyword is simpler and more readable.
• For large lists where membership checks are frequent, consider converting the list to a set for O(1) lookups: lambda val: val in my_set.