How to replace Loops in Python
List Comprehension, Lambda function, Map function, Filter function, Reduce function
One of the most enjoyable aspects of programming with Python one-liners is the opportunity to read and write code that accomplishes a lot in just a few lines. In fact, there’s an entire subculture centered around the challenge of writing the most concise code possible to solve a given problem.
In this blog, we will explore different ways of replacing multi-line Python loops with one-liner functions. Let’s keep the concentration levels high for the next 3 minutes!
We need to know the following 5 concepts to be able to convert most of our multi-line loops with one-liners:
- List Comprehension
- Lambda Function
- Map Function
- Filter Function
- Reduce Function
1. List Comprehensions
List comprehensions are a concise way of creating a new list from an existing list. They can be used to replace “for” loops that are used to iterate over a list and perform some operation. The basic syntax of list comprehension is:
[expression for item in iterable if condition]
Here, “item” represents an element of the iterable, “condition” is an optional filter that determines whether the item should be included in the resulting list, and “expression” is a function or operation that is applied to each item to generate the corresponding output element of the list.
Here are a few examples where list comprehension is replacing loops in python:
# Example 1: Finding the square of numbers
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
## Finding square of numbers
## Traditional Loop
squares = []
for num in nums:
squares.append(num**2)
## One liners - list comprehension
squares = [num**2 for num in nums]
### Whatever we write after the 1st square backet '['
### gets written in the output list - "num**2" in the above exmaple
print(squares)# Example 2: Suppose we have a list of lists, where each inner list contains students' grades in different subjects. We want to calculate the average grade of each student across all subjects, and then the overall average of all students.
grades = [[90, 85, 95], [80, 90, 85], [95, 85, 90], [75, 80, 70]]
### Traditional loop
student_avgs = []
for student in grades:
avg = sum(student) / len(student)
student_avgs.append(avg)
overall_avg = sum(student_avgs) / len(student_avgs)
## one liner - List comprehension
student_avgs = [sum(student) / len(student) for student in grades]
overall_avg = sum(student_avgs) / len(student_avgs)
print("Average grades per student:", student_avgs)
print("Overall average grade:", overall_avg)2. Lambda Function
The Lambda function is a one-liner alternative to the regular functions. It can be defined in a single line of code and thus takes less time and space in our code. For example, in the below code, we can see multiple examples of replacing a regular function with a lambda function.
Function with one argument
##Regular function
def multiply_by_2(x):
return x*2
Function with 2 or more arguments
##Regular function
def multiple_three_numbers(x,y,z):
`return x*y*z `
##lambda function
lambda x, y, z: x*y*z
Note: The lambda function cannot replace loop in python but we help us to convert a muli-line functionality into one-liner.
3. Map Function
Map is a built-in function that takes a function and an iterable as arguments and applies the function to each element in the iterable.
map(function, iterable)
An iterable could be an object which can be iterated, such as — a list, tuple, etc.
The map function can be used to replace loops that are used to perform some operation on each element in a list. Here’s an example:
## Example 1: Finding the square of numbers
## Traditional Loop
nums = (1, 3, 4, 5, 6, 7)
def square_numbers(nums):
squares = []
for num in nums:
squares.append(num**2)
## One-liner
squares = list(map(lambda x: x**2, nums))
print("Example 1: ", squares)
## Example 2: Consider the scenario where we have a list of sentences and want to count the number of words in each sentence. We can use a multi-line loop to achieve this as follows:
## Traditional Loop
sentences = ['This is the first sentence.',
'And this is the second sentence.',
'Finally, the third sentence.']
word_counts = []
for sentence in sentences:
words = sentence.split()
word_count = len(words)
word_counts.append(word_count)
### line liner
word_counts = list(map(lambda sentence: len(sentence.split()), sentences))
print('Example 2: ', word_counts)
4. Filter
The filter is a built-in function that takes a function and an iterable as arguments and returns a new iterable containing only the elements for which the function returns True.
filter(function, iterable)
It can be used to replace “for” loops that are used to filter out elements from an iterable. Here’s an example:
## Example 1: Finding the even numbers.
## Traditional Loop
nums = [1, 4, 5, 6, 7, 8, 9]
even_nums = []
for num in nums:
if num % 2 == 0:
even_nums.append(num)
## One-liner
even_nums = list(filter(lambda x: x % 2 == 0, nums))
print('Example 1: ', even_nums)
## Example 2: Filter out all the numbers that are divisible by both 3 and 5.
numbers = [10, 15, 20, 30, 45, 50, 60]
## Traditional Function
def div_by_3_5(nums):
result = []
for num in nums:
if num % 3 == 0 and num % 5 == 0:
result.append(num)
## One liner
result = list(filter(lambda num: num % 3 == 0 and num % 5 == 0, numbers))
print("Example 2: ", result)5. Reduce
The reduce() function in Python is a built-in function in the functools module. It applies a rolling computation to sequential pairs of elements(taking 2 elements at a time) in a list and returns a single output.
reduce(func, iterable)
nums = [1, 2, 3, 4, 5]
## Traditional function
def sum_nums(nums):
result = 0
for num in nums:
result += num
return result
print(sum_nums(nums)) # Output: 15
from functools import reduce
## One liner - with reduce
sum_nums = reduce(lambda x, y: x + y, nums)
print(sum_nums) # Output: 15## Example 2: Find the product of all the even numbers in the list
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def product_of_even(my_list):
product = 1
for num in my_list:
if num % 2 == 0:
product *= num
## One liner - with Reduce and filter
product = reduce(lambda x, y: x * y, filter(lambda x: x % 2 == 0, my_list))
print(product)Conclusion
In conclusion, replacing loops with one-liner functions can make your code more concise, readable, and maintainable. We can perform complex operations in a single line of code by using built-in functions like list comprehensions, map, and filter. However, it’s essential to use these functions judiciously and not sacrifice clarity for concision. Always remember that readability is key to writing good code.
https://medium.com/codex/its-time-to-replace-loops-in-python-let-s-do-it-now-35804d828f5e