DEV Community is a community of 603,444 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

30 Days of Python π¨βπ» - Day 12 - Lambda Expressions & Comprehensions

Arindam Dawn Originally published at tabandspace.com γ»3 min read

Functional Programming in itself is a big topic and there are a lot of concepts in it to understand and master. However, I have a defined goal to learn Python in 30 days, so I rather prefer to understand the key concepts and learn the most commonly used techniques that would come in handy in building practical projects.

I explored the fundamentals of functional programming and how it is implemented in Python yesterday. Today, I explored the missing pieces and I came across quite interesting findings while doing so which I will be sharing in this post.

Lamba Expressions

Lambda is actually a term in computer science which means an anonymous function which is used only once while the expression is being executed.
Lambda expressions are quite useful to simplify code and make functions more concise and compact. However, overusing them in complicated evaluations can make the code less readable. Every cool thing has their trade-off as well!

Upon exploring their syntax and use cases, it immediately made me think of arrow functions syntax from the JavaScript universe although they are not exactly similar.

``````names = ['John', 'Peter', 'Elon', 'Joseph']

# make all names upper cased
uppercased = list(map(lambda name: str.upper(name), names))

print(uppercased)
``````

`lambda` takes any number of arguments (here name) and expression involving the arguments (here str.upper(name)).

``````users = [('Mary', 23), ('Emilie', 10), ('Katie', 30)]

sorted_by_name = sorted(users)
print(sorted_by_name)
# [('Emilie', 10), ('Katie', 30), ('Mary', 23)]

sorted_by_age = sorted(users, key = lambda item: item[1])
# using age as key for sorting

print(sorted_by_age)
# [('Emilie', 10), ('Mary', 23), ('Katie', 30)]
``````
``````scores = [23, 55, 20, 90, 34, 53]

scores_under50 = list(filter(lambda x: x < 50, scores))
print(scores_under50) # [23, 20, 34]
``````

Comprehensions

Comprehensions are another cool feature of Python which I found really useful. They are used to quickly build data structures such as `list`, `set`, `dict` in a compact syntax and is said to be faster as compared to creating the same data structures using loops.

It can often be tempting to replace loops with comprehensions. However, a cleverly written code is not always good in terms of readability. So lengthy one-liner comprehensions should be avoided as it may look very compact but might hurt someone's brain π

Comprehensions are of the following kind in Python - List comprehension, Set Comprehension and Dict Comprehension.

List Comprehension

Suppose we have to create a list of characters from a string, the simple way would be something like this

``````name = 'python'

new_list = []
for character in name:
new_list.append(character)

print(new_list)
# ['p', 'y', 't', 'h', 'o', 'n']
``````

However, using list comprehension it can be more concise

``````name = 'python'
new_list = [item for item in name] # here item can be any name

print(new_list)
``````
``````# Quickly generates a list of 10 items with their values squared
new_list = [item**2 for item in range(10)]
print(new_list) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

``````

It is also possible to add a condition to the comprehension

``````numbers = [2,34,23,53,34,12,22,89]

even_numbers = [num for num in numbers if num % 2 == 0]
print(even_numbers) # [2, 34, 34, 12, 22]
``````
``````brands = [
{'name': 'Nike', 'category': 'shoes'},
{'name': 'Reebok', 'category': 'shoes'},
{'name': 'Tesla', 'category': 'cars'},
]

car_brands = [item for item in brands if item['category'] =='shoes']
print(car_brands) # filters out Tesla
``````

Set Comprehension

``````names = ['Rick', 'Alan', 'Rick', 'Mike']
new_set = {item for item in names}

print(new_set) # {'Mike', 'Alan', 'Rick'}
``````

Dictionary Comprehension

``````attendance = {
'John': True,
'David': False,
'Nick': True,
'Tom': False,
'Marie': False,
'Nancy': True
}

students_present = {key:value for key,value in attendance.items() if value}
print(students_present)
# {'John': True, 'Nick': True, 'Nancy': True}
``````

Quick Coding Exercise

From a list of names, filter out the duplicate names and store in a list.

I solved this before while exploring loops and functions. Today will try to recreate the solution using comprehensions

``````names = [
'Harry', 'Johnny', 'Lewis', 'Harry', 'Buck', 'Nick', 'David', 'Harry',
'Lewis', 'Michael'
]

duplicate_names = list(set([name for name in names if names.count(name) > 1]))

print(duplicate_names) # ['Lewis', 'Harry']
``````

The solution is a one-liner and looks very clever but one can argue against it being less readable.

Anyways it good to know alternatives. I prefer to be more verbose while writing in practical projects so it's less clever code and more readable code.

That's all for today's exploration of functional programming. I think I have pretty much covered most of the essentials.

Tomorrow, I plan to dig into decorators in python. I am sure that will be exciting and fun.

Have a great one!

Discussion (6)

AirDavo!!

Wow!

Arindam Dawn

Let me see if I can complie them all together once I am able to finish off. My intention was to post it like a journal which can be followed along.
However suggestions are most welcome π

hippohood

That's a great log book, keep going! π