Python Filter, Map and Reduce Functions

mfr

Hello,
The default functions in Python make it easier for us to write code, as well as speed up the work done. When writing code, The most important thing we need is to process values in a list, change some of them, and filter some of them. The map, filter and reduce concepts exist to make this work much faster. Then let me start with the examples.;

Map

It is a great function that we can use instead of returning for to do any of the operations on the list. Taking 2 parameters, 1.to-do operation, 2.si the variable to which the operation will be performed. When doing a transaction, the more we add Python’s default function structure to the transaction, the more optimized it is, so we have fast-running code. Let me put it an example;

Problem:

We have a list of 10000 data, we need to multiply this list by 2. We will do this in 3 different ways,

The standard method for
using lambda and map function
using map function but using method

# Author: Sezer Yavuzer Bozkir;
import random
from time import time
def multiply(x):
return x * 2
ornek = random.sample(range(1, 10000000), 10000000)
start_time = time()
for order, value in enumerate(ornek):
ornek[order] = value * 2
end_time = time()
print("Totally time: {}".format(end_time — start_time))
start_time = time()
ornek = list(map(lambda x: x * 2, ornek))
end_time = time()
print("Totally time: {}".format(end_time — start_time))
start_time = time()
ornek = list(map(lambda x: multiply(x), ornek))
end_time = time()
print("Totally time: {}".format(end_time — start_time))

# Author: Sezer Yavuzer Bozkir;

import random

from time import time

def multiply(x):

return x * 2

ornek = random.sample(range(1, 10000000), 10000000)

start_time = time()

for order, value in enumerate(ornek):

ornek[order] = value * 2

end_time = time()

print("Totally time: {}".format(end_time - start_time))

start_time = time()

ornek = list(map(lambda x: x * 2, ornek))

end_time = time()

print("Totally time: {}".format(end_time - start_time))

start_time = time()

ornek = list(map(lambda x: multiply(x), ornek))

end_time = time()

print("Totally time: {}".format(end_time - start_time))

When we run this code, we observe that the result with lambda and map is 2 times more efficient than for, and we see that the result is between these two in making it with the help of the method.;

Totally time: 4.464943170547485
Totally time: 2.3204081058502197
Totally time: 2.580265998840332

Totally time: 4.464943170547485

Totally time: 2.3204081058502197

Totally time: 2.580265998840332

Filter:

As you can imagine, filter is used to get the appropriate ones in any sequence. The function takes 2 variables for this operation, the first is the desired condition, and the second is the list where the operation will be performed. This is an example of the process again, let us observe through it.;

Problem:

We have a list of the same length again, assuming that the number of pairs in this list;

# Author: Sezer Yavuzer Bozkir ;
import random
from time import time
ornek = random.sample(range(1, 10000000), 10000000)
tmp_result_list = []
start_time = time()
for value in ornek:
if not value % 2:
tmp_result_list.append(value)
end_time = time()
print("Totally time: {}".format(end_time — start_time))
other_start_time = time()
new_list = list(filter(lambda x: not x % 2, ornek))
other_end_time = time()
print("Totally time: {}".format(other_end_time — other_start_time))

# Author: Sezer Yavuzer Bozkir ;

import random

from time import time

ornek = random.sample(range(1, 10000000), 10000000)

tmp_result_list = []

start_time = time()

for value in ornek:

if not value % 2:

tmp_result_list.append(value)

end_time = time()

print("Totally time: {}".format(end_time - start_time))

other_start_time = time()

new_list = list(filter(lambda x: not x % 2, ornek))

other_end_time = time()

print("Totally time: {}".format(other_end_time - other_start_time))

Lets check;

Totally time: 3.430934190750122
Totally time: 3.3554718494415283

1 2	Totally time: 3.430934190750122 Totally time: 3.3554718494415283

Rather than being close to each other, another beauty here is the importance of the operation done with a few lines of code. We had to define the number of lines and many variables in one line while processing one line.

Reduce:

This is a function that we can use when we want to obtain a final value from the data in a list. Again, taking 2 variables, the first variable to be done in the process, 2. we also give the list to be processed in value. Let us say this with an example;

Problem:

If we have a list of 10,000 data, let’s find the sum of the numbers in this list.;

# Author: Sezer Yavuzer Bozkir ;
import random
from time import time
from functools import reduce
ornek = random.sample(range(0, 10000000), 10000000)
sum_total = 0
start_time = time()
for value in ornek:
sum_total += value
end_time = time()
print("Totally time: {}".format(end_time — start_time))
other_start_time = time()
other_sum_total = reduce(lambda x, y: x + y, ornek)
other_end_time = time()
print("Totally time: {}".format(other_end_time — other_start_time))

# Author: Sezer Yavuzer Bozkir ;

import random

from time import time

from functools import reduce

ornek = random.sample(range(0, 10000000), 10000000)

sum_total = 0

start_time = time()

for value in ornek:

sum_total += value

end_time = time()

print("Totally time: {}".format(end_time - start_time))

other_start_time = time()

other_sum_total = reduce(lambda x, y: x + y, ornek)

other_end_time = time()

print("Totally time: {}".format(other_end_time - other_start_time))

Lets Check;

Totally time: 2.584547758102417
Totally time: 2.8353359699249268

1 2	Totally time: 2.584547758102417 Totally time: 2.8353359699249268

It is interesting to note that the reduce function is slow, which is because it has a 2-way collection by writing extra methods in lambda and keeping it in 3 variables. I hope it will be more performance in more complex transactions.