Welcome to a an advanced topic in Python! I'm Brahma 👋, a passionate software developer. I am documenting my learning journey through a series of blog posts. Stay tuned!!
Introduction
Python is renowned for its simplicity and readability, and part of what makes Python code elegant is the use of functional programming concepts. List comprehensions, lambda functions, the map, reduce and filter functions are powerful tools that can simplify complex operations, making your code more concise and expressive.
List Comprehensions
List comprehensions provide a concise way to create lists. The basic syntax is [expression for item in iterable if condition].
Example:
squares = [x**2 for x in range(10)]
This creates a list of squares of numbers from 0 to 9.
With a Condition:
even_squares = [x**2 for x in range(10) if x % 2 == 0]
This creates a list of squares of even numbers from 0 to 9.
Now you may ask 🤔 Brahma, why is this important? The simple answer is its fast and furious 😂!!! Let me explain:
Speed Comparison with Loops
List comprehensions are generally faster than traditional for-loops because they are optimized for the specific task of generating lists. The Python interpreter can execute a list comprehension in C language speed, whereas a for-loop involves more overhead with Python bytecode instructions.
Example Comparison:
result = []
for i in range(1000000):
result.append(i * 2)
result = [i * 2 for i in range(1000000)]
For-loop: This involves multiple method calls (append), which adds overhead.
List comprehension: This is more direct and faster due to its optimization.
Lambda Functions
Lambda functions are anonymous functions defined using the lambda keyword. They are used for creating small, one-time, and inline functions.
Example:
add = lambda x, y: x + y
print(add(2, 3))
If you still have a question for me, why lambda? Then this time you might be correct as lambda functions on its own have no significant performance improvement but in conjuction with some things discussed later in this blog will have significant impact on performance. So take a chill pill and wait for the mentos zindagi😁.
Map Function
The map function applies a given function to all items in an input list (or any iterable) and returns a map object (an iterator).
Syntax: map(<function>, <iterable-object>)
Example:
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, numbers)
print(list(squared))
Now, let me answer how exactly map function helps, coz I know you waiting for this 😁.
Speed Comparison with Loops
The map function can be faster than a for-loop because it applies the function to each item in a list in C speed. However, this speed gain is not always substantial for small datasets.
Example Comparison:
result = []
for i in range(1000000):
result.append(i * 2)
result = list(map(lambda x: x * 2, range(1000000)))
Lazy Evaluation
The map function returns a map object, which is an iterator. This means it doesn't generate the list until it's explicitly converted to a list or iterated over. This can be more memory efficient for large datasets as it processes items one by one.
Example:
result = map(lambda x: x * 2, range(100000000))
Reduce Function
The reduce function is part of the functools module, so you need to import it before using it. The basic syntax is:
from functools import reduce
reduce(function, iterable)
function: A function that takes two arguments.
iterable: An iterable (e.g., list, tuple) whose elements will be processed by the function.
The reduce function applies the specified function to the first two items of the iterable, then applies it to the result and the next item, and so on. This process continues until only a single cumulative value remains.
Example: Summing a List
from functools import reduce
def add(x, y):
return x + y
numbers = [1, 2, 3, 4, 5]
result = reduce(add, numbers)
print(result)
In this example, reduce works as follows:
add(1, 2) -> 3
add(3, 3) -> 6
add(6, 4) -> 10
add(10, 5) -> 15
The final result is 15.
Using lambda with reduce
You can use a lambda function to make the code more concise.
Example: Summing a List with lambda
from functools import reduce
numbers = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, numbers)
print(result)
Filter Function
The filter function constructs an iterator from elements of an iterable for which a function returns true.
Example:
numbers = [1, 2, 3, 4, 5]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))
Ofc!! Why Filter? 🫠
Speed Comparison with Loops
Like map, the filter function can be faster than a traditional for-loop for filtering items because it's implemented in C. However, for very simple conditions, the speed difference might not be significant.
Example Comparison:
result = []
for i in range(1000000):
if i % 2 == 0:
result.append(i)
result = list(filter(lambda x: x % 2 == 0, range(1000000)))
Lazy Evaluation
Similar to map, filter returns an iterator and does not create the entire list in memory. This lazy evaluation can be more memory efficient.
Example:
result = filter(lambda x: x % 2 == 0, range(100000000))
Conclusion
Now I bet you are well equipped to be a better Python Developer😂.
Keep coding, keep learning, and enjoy the endless possibilities that Python has to offer!
That's all folks. Leave a like and some lovely critics in the comments😁.
Signing off!!!👋
