# Filter NumPy Array with Lambda Functions

In this tutorial, you’ll learn how to filter NumPy with lambda functions.

Lambda functions in Python are small anonymous functions defined with the keyword `lambda`.

We’ll explore various methods such as using `numpy.vectorize()` with lambda functions, list comprehension, boolean indexing, and the `filter()` function.

## Using numpy.where()

You can apply `numpy.where()` with a lambda function to filter data:

```import numpy as np
data_usage = np.array([1.5, 4.8, 3.1, 0.9, 5.7, 2.3, 3.8])
heavy_users = np.where(lambda x: x > 3, data_usage, False)
print(heavy_users)
```

Output:

```[array([4.8, 5.7, 3.8])]
```

The lambda function `lambda x: x > 3` acts as a filter criterion, selecting only those elements in `data_usage` that satisfy this condition.

## Using numpy.vectorize()

`numpy.vectorize()` transforms a Python function into a vectorized function that can operate on NumPy arrays.

When combined with lambda functions, `numpy.vectorize()` provides a way to apply operations element-wise on arrays.

Suppose you want to categorize these scores into ‘Low’, ‘Medium’, and ‘High’.

Here’s how `numpy.vectorize()` with a lambda function can be used for this purpose:

```import numpy as np
satisfaction_scores = np.array([7, 4, 9, 6, 3, 8, 5])
categorize = lambda x: 'High' if x > 6 else ('Medium' if x > 3 else 'Low')
vectorized_categorize = np.vectorize(categorize)
categories = vectorized_categorize(satisfaction_scores)
print(categories)
```

Output:

```['High' 'Medium' 'High' 'Medium' 'Low' 'High' 'Medium']
```

`numpy.vectorize(categorize)` transforms this lambda function into a vectorized function that can be applied to the entire `satisfaction_scores` array.

## List Comprehension with a Lambda Function

This method is useful in cases where you need to apply a simple function to each element in a list or array.

Here’s how you can do this using list comprehension with a lambda function:

```monthly_expenses = [50, 75, 30, 45, 60]
apply_discount = lambda x: x * 0.9
discounted_expenses = [apply_discount(expense) for expense in monthly_expenses]
print(discounted_expenses)
```

Output:

```[45.0, 67.5, 27.0, 40.5, 54.0]
```

In this example, the lambda function `apply_discount` calculates 90% of the original expense, effectively applying a 10% discount.

The list comprehension `[apply_discount(expense) for expense in monthly_expenses]` iterates over `monthly_expenses`, applying the discount to each element.

## Boolean Indexing with a Lambda Function

Boolean indexing in NumPy allows for the selection of elements based on specific conditions.

Here’s how you can use boolean indexing and a lambda function:

```import numpy as np
customer_ages = np.array([25, 67, 50, 72, 34, 58, 62])
is_senior = lambda x: x >= 60
senior_citizens = customer_ages[is_senior(customer_ages)]
print(senior_citizens)
```

Output:

```[67 72 62]
```

This code uses the lambda function `is_senior` to create a boolean array, where each element in `customer_ages` is checked against the condition `x >= 60`.

This boolean array is then used to index `customer_ages`, resulting in an array `senior_citizens` that contains only the ages of customers who are 60 years or older.

## Using filter() Function

The `filter()` function in Python is used to construct an iterator from elements of an iterable for which a function returns true.

When `filter()` function combined with a lambda function, it allows you to filter data based on custom criteria.

Here’s how you can use the `filter()` function with a lambda:

```import numpy as np
call_durations = np.array([3, 12, 1, 9, 5, 2, 8])
effective_call = lambda x: x >= 5
effective_calls = list(filter(effective_call, call_durations))
print(effective_calls)
```

Output:

```[12, 9, 5, 8]
```

In this code, the lambda function `effective_call` defines the criteria for filtering: `x >= 5`.

The `filter()` function then applies this criterion to each element in `call_durations`.

The result is an iterator, which we convert into a list `effective_calls`.