How to Use Lambda Functions in Python

But the main reason that the name is used in Python is because the term lambda is used to describe anonymous functions in calculus. Now that we’ve cleared that up, you can use this info to spark enthralling conversation at office parties.

The minimal syntax for defining a lambda expression (with no name) with Python is:

Lambda arguments : expression

• Replace arguments with data being passed into the expression.
• Replace expression with an expression (formula) that defines what you want the lambda to return.

Adams, Ma, diMeola, Zandusky

names = ['Adams', 'Ma', 'diMeola', 'Zandusky']
names.sort()
print(names)

['Adams', 'Ma', 'Zandusky', 'diMeola']

All the lowercase letters have numbers that are higher than uppercase numbers. So, when sorting, all the words starting with lowercase letters come after the words that start with an uppercase letter. If nothing else, it at least warrants a minor hmm.

To help with these matters, the Python sort() method lets you include a key= expression inside the parentheses, where you can tell it how to sort. The syntax is:

.sort(key = transform)

names.sort(key=len)

['Ma', 'Adams', 'diMeola', 'Zandusky']

You can’t write key=lower or key=upper to base the sort on all lowercase or all uppercase letters either, because lower and upper aren't built-in functions (which you can verify pretty quickly by googling python 3.7 built-in functions).

In lieu of a built-in function, you can use a custom function that you define yourself using def. For example, you can create a function named lower() that accepts a string and returns that string with all of its letters converted to lowercase. Here is the function:

def lower(anystring):
""" Converts string to all lowercase """
return anystring.lower()

You can't use key=lower in the sort() parentheses because lower() isn't a built-in function. It’s a method … not the same. Kind of annoying with all these buzzwords.

Suppose you write this function in a Jupyter cell or .py file. Then you call the function with something like print(lowercaseof('Zandusky')). What you get as output is that string converted to all lowercase, as you see below.

Putting a custom function named lower() to the test.

Okay, so now you have a custom function to convert any string to all lowercase letters. How do you use that as a sort key? Easy, use key=transform the same as before, but replace transform with your custom function name. The function is named lowercaseof, so you'd use .sort(key= lowercaseof), as shown in the following:

def lowercaseof(anystring):
""" Converts string to all lowercase """
return anystring.lower()
 
names = ['Adams', 'Ma', 'diMeola', 'Zandusky']
names.sort(key=lowercaseof)

'Adams', 'diMeola', 'Ma', 'Zandusky'

But this is a perfect example of where you could use a lambda function, because the Python function you’re calling, lowercaseof(), does all of its work with just one line of code: return anystring.lower().

When your function can do its thing with a simple one-line expression like that, you can skip the def and the function name and just use this syntax:

lambda parameters : expression

lambda anystring : anystring.lower()

The image below shows the complete code and the result of running it. You get the proper sort order without the need for a customer external function like lowercaseof(). You just use anystring : anystring.lower() (after the word lambda) as the sort key.

Using a lambda expression as a sort key.

Let’s also add that anystring is a longer parameter name than most Pythonistas would use. Python folks are fond of short names, even single-letter names. For example, you could replace anystring with s (or any other letter), as in the following, and the code will work exactly the same:

names = ['Adams', 'Ma', 'diMeola', 'Zandusky']
names.sort(key=lambda s: s.lower())
print(names)

For example, here is a lambda function named currency that takes any number and returns a string in currency format (that is, with a leading dollar sign, commas between thousands, and two digits for pennies):

currency = lambda n : f"${n:,.2f}"

percent = lambda n : f"{n:.2%}"

Two functions for formatting numbers.

The reason you can define those as single-line lambdas is because you can do all the work in one line, f"${n:,.2f}" for the first one and f"{n:.2%}" for the second one. But just because you can do it that way, doesn't mean you must. You could use regular functions too, as follows:

# Show number in currency format.
def currency(n):
return f"${n:,.2f}"
 
def percent(n):
# Show number in percent format.
return f"{n:.2%}"

Two functions for formatting numbers with fixed width.

In the image above, the second parameter is optional and defaults to 15 if omitted. So if you call it like this:

print(currency(9999))

print(currency(9999,20)

The .ljust() used above is a Python built-in string method that pads the left side of a string with sufficient spaces to make it the specified width. There’s also an rjust() method to pad the right side. You can also specify a character other than a space. Google python 3 ljust rjust if you need more info.

So there you have it, the ability to create your own custom functions in Python. In real life, what you want to do is, any time you find that you need access to the same chunk of code — the same bit of login — over and over again in your app, don’t simply copy/paste that chunk of code over and over again. Instead, put all that code in a function that you can call by name.

That way, if you decide to change the Python stringcode, you don’t have to go digging through your app to find all the places that need changing. Just change it in the function where it’s all defined in one place.