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

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]

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

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

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"]

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]

has_large = any(map(lambda x: x > 40, data))
print(f"Has element > 40: {has_large}")

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"),
]

has_marketing = any(map(lambda e: e.department == "Marketing", employees))
print(f"Has Marketing employee: {has_marketing}")

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

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.