# Map() vs Filter() Function in Python Built-in functions are used to solve many complex problems easily. Let’s see the details of the map() vs filter() functions.

Programming languages are used in solving very complex mathematical problems. We always need some functions to solve them. There are pre-defined functions available to solve this issue. These functions are referred to as built-in functions. Map() and filter() functions are both built-in functions.

Map() in Python is used when we want to apply the same function repeatedly on a different set of elements. It is beneficial in solving mathematical problems where we apply the same formula to a different set of values. On the other hand, the filter() function is used when we want to exclude the elements from the given list, tuple, or set. This type of function is mainly used in problems based on sorting techniques. We can sort the elements quickly based on the condition using this filter() function.

## Higher-Order Function: Map() and Filter() Function

Map() and filter() functions are higher-order functions in Python. A higher-order function is referred to a function whose attributes or parameters are in the form of a function, and it returns output in the form of a function only. These higher-order function in Python helps to solve mathematical and complex analytical problems quickly. The detailed explanation and working of both function with example is given below.

Both map() and filter() functions are built-in and higher-order functions, but their working is different. The area of application of both functions is different because of their functionality. To understand the functionality of both functions, first, we should know the difference between them. Let’s understand the difference between them in detail.

## Map() Function in Python

The` map ()` function is considered a replacement for the python for loop. We can apply the same function to all the items which are passed as an argument to the map() function. This is mapping in python.

After applying this map() function on any item, it’ll convert into a new set of items known as an iterator. The items which are passed as arguments are called iterable. Syntax of map() function is very easy

```map(function name, iterable(list of items))
```

In the syntax of the map() function, the ‘function_name’ is a transform function, and ‘iterable’ is a list of items on which this transform function will be applied. Example 1, demonstrates the detailed implementation of the map() function.

### Example 1: Implementation of map() function

Now let’s see one simple example to understand the working of the map() function. We’ll do a simple addition program.

```def Add_num(y):
return y+y
Num = (2,4,6,8,10)
print(Result)
Output = list(Result)
print(Output)
```

For example, the Add_num() is a transform function applied to the iterable.

Here, Add_num is a transform function, and Num is a list of items to which this transform function will be applied.

### Output:

The` map()` function also takes multiple sets of items as an argument. Let’s see a simple example to understand the implementation.

### Map() Function Over ‘for loop’

Using “for loop” may make the problem harder to solve in some situations. For example, if we want to use the same function on two different lists of items, we need to use “for loop” twice. On the other hand, this problem can be solved with just one line of code using the map() method. We can give the map() method many different things in Python. Let’s see the syntax and example.

```map(function_name,iterable_1,iterable_2,iterable_3)
```

In this syntax, the map ()’ function needs four parts to work. The first is “function_name,” which is called the transform function in this case. Iterable_1, iterable_2, and iterable_3 are three sets of items on which the transform function is being used.

```def Add_num(a,b,c):
return a+b+c
Num1= (2,4,6,8,10)
Num2= (3,6,9,12,15)
Num3= (4,8,12,16,20)
print(Result)
Output = list(Result)
print(Output)
```

Here, Add_num is a transform function applied to the three lists of elements i.e., Num1, Num2, and Num3.

## Filter() Function

While solving problems based on sorting and searching, we need to do some operations on the things like arrays, lists, and tuples. Sometimes we need to refine the sequences using some functions. The use of simple functions may consume a lot of time for implementation. So, some built-in functions in python are continuously used in python to save time and ease the complexity of the problem. filtering of the sequences is done by using the filter() function.

The working of the filter() function is a way of implementing the if-else condition in python. Filter() function is mainly used for filtering function. The main function for this filter() function will check the condition in the form of Boolean values and then print all the elements which are identified as true element in the sequence.

### Syntax of Filter() Function

```filter(function name, iterable(list of items))
```

Here, the filter() function takes arguments as function_name, which comes with the condition filtration, and iterable is the list of items on which this condition of a function will be applied.

### Example 2: How to implement the filter() function

In this example 2, we’ll see the simple implementation of the `filter()` function for filtering of odd numbers from the sequence.

```def fun(numbers):
num = [1,3,5,7,9]
if (numbers in num):
return True
else:
return False
sequence = [1,2,3,4,5,6,7,8,9,10]
filtered = filter(fun, sequence)

print('The filtered numbers are: ')
for s in filtered:
print(s)

```

In this example 2, the ‘fun’ is used as a condition for the list of elements. ‘sequence’ is a list of elements provided. filter() function is applied to the sequence.

### Output:

The `filter()` function is mostly used with the lambda function. Now we’ll implement the same example using the lambda function.

### Example 3: How to use filter() and lambda function together?

```# list of numbers.
sequence = [1,2,3,4,5,6,7,8,9,10]

# filtering odd numbers
result = filter(lambda x: x % 2 != 0, sequence)
print(list(result))
```

Here, the ‘sequence’ is a list of elements, and the ‘filter()’ function takes lambda as an argument.