Keep reading as I show you how to use regular expressions inside a lambda function.

What We'll Cover

• How to use RegEx inside the Expression of a Lambda Function
  • How to use RegEx inside the Expression of a Lambda Function with the filter() Function
  • How to use RegEx inside the Expression of a Lambda Function with the map() Function
  • How to use RegEx inside the Expression of a Lambda Function with the sort() Method
• Conclusion

How to use RegEx inside the Expression of a Lambda Function

The syntax with which a lambda function can take a RegEx as its expression looks like this:

lambda x: re.method(pattern, x)

Be aware that you have to use the lambda function on something. And that’s where the likes of map(), sort(), filter(), and others come in.

How to use RegEx inside the Expression of a Lambda Function with the filter() Function

The first example I will show you use the filter() function:

import re

fruits = ['apple', 'mango', 'banana', 'cherry', 'apricot', 'raspberry', 'avocado']
filtered_fruits = filter(lambda fruit: re.match('^a', fruit), fruits)

# convert the new fruits to another list and print it
print(list(filtered_fruits)) # ['apple', 'apricot', 'avocado']

In the code above:

• the filter() takes the lambda function as the function to execute and the fruits list as the iterable
• for the expression of the lambda function, it uses the re.match() method of Python RegEx and uses the pattern ^a on the argument fruit
• the last thing I did was convert all items on the list that matches the pattern into a list

How to use RegEx inside the Expression of a Lambda Function with the map() Function

To use RegEx inside a lambda function with another function like map(), the syntax is similar:

import re

fruits2 = ['opple', 'bonono', 'cherry', 'dote', 'berry']
modified_fruits = map(lambda fruit: re.sub('o', 'a', fruit), fruits2)

# convert the new fruits to another list and print it
print(list(modified_fruits)) # ['apple', 'banana', 'cherry', 'date', 'berry']

In the code above:

• the modified_fruits is looping through the fruits2 list with a map() function
• uses the re.sub() method of Python RegEx as the expression of the lambda function.

The re.sub method lets you replace the first value with the second one. In the example, it switched all occurrences of o to a.

How to use RegEx inside the Expression of a Lambda Function with the sort() Method

The last example I will show you uses the sort() method of lists:

import re

fruits = [ 'banana', 'fig', 'grapefruit']

# sort fruits based on the number of vowels
fruits.sort(key=lambda x: len(re.findall('[aeiou]', x)))

print(fruits) #['fig', 'banana', 'grapefruit']

In the code, the lambda function sorts the list based on the number of vowels. It does it with the combination of the len() method, the findall() method of Python RegEx, and the pattern [aeiou].

The word fruit with the lowest number of vowels comes first. If you use reverse=True, it arranges the fruits based on those with the highest number of vowels – descending order:

import re

fruits = [ 'banana', 'fig', 'grapefruit']

# sort fruits based on the number of vowels
fruits.sort(key=lambda x: len(re.findall('[aeiou]', x)), reverse=True)

print(fruits) # ['grapefruit', 'banana', 'fig']

Conclusion

In this article, we looked at how you can pass in RegEx to a lambda function by showing you examples using the filter(), map() functions, and the sort() method.

I hope this article gives you the knowledge you need to use RegEx inside a lambda function.

Keep coding!

You may think that lambda functions are an intermediate or advanced feature, but here you will learn how you can easily start using them in your code.

In Python, functions are usually created like this:

def my_func(a):
  # function body

You declare them with the def keyword, give them a name, and then add the list of arguments surrounded by round parenthesis. There could be many lines of code, with as many statements and expressions as you need inside.

But sometimes you might need a function with only one expression inside, for example a function that doubles its argument:

def double(x):
  return x*2

This is a function that you can use, for example, with the map method.

def double(x):
  return x*2

my_list = [1, 2, 3, 4, 5, 6]
new_list = list(map(double, my_list))
print(new_list) # [2, 4, 6, 8, 10, 12]

This would be a good place to use a lambda function, as it can be created exactly where you need to use it. This means using fewer lines of code and and you can avoid creating a named function that is only used once (and then has to be stored in memory).

How to use lambda functions in Python

You use lambda functions when you need a small function for a short time – for example as an argument of a higher order function like [map](https://www.freecodecamp.org/news/python-map-function-how-to-map-a-list-in-python-3-0-with-example-code/) or filter.

The syntax of a lambda function is lambda args: expression. You first write the word lambda, then a single space, then a comma separated list of all the arguments, followed by a colon, and then the expression that is the body of the function.

Note that you can't give a name to lambda functions, as they are anonymous (without a name) by definition.

A lambda function can have as many arguments as you need to use, but the body must be one single expression.

Example 1

For example, you could write a lambda function that doubles its argument: lambda x: x*2, and use it with the map function to double all elements in a list:

my_list = [1, 2, 3, 4, 5, 6]
new_list = list(map(lambda x: x*2, my_list))
print(new_list) # [2, 4, 6, 8, 10, 12]

Notice the difference between this one and the function we wrote above with the double function. This one is more compact, and there is not an extra function occupying space in memory.

Example 2

Or you could write a lambda function that checks if a number is positive, like lambda x: x > 0, and use it with filter to create a list of only positive numbers.

my_list = [18, -3, 5, 0, -1, 12]
new_list = list(filter(lambda x: x > 0, my_list))
print(new_list) # [18, 5, 12]

The lambda function is defined where it is used, in this way there is not a named function in memory. If a function is used i only one place it makes sense to use a lambda function to avoid cluttering.

Example 3

You can also return a lambda function from a function.

If you ever need to create multiple functions that multiply numbers, for example doubling or tripling and so on, lambda can help.

Instead of creating multiple functions, you could create a function multiplyBy as below, and then call this function multiple times with different arguments to create the functions that double, triple, and so on.

def muliplyBy (n):
  return lambda x: x*n

double = multiplyBy(2)
triple = muliplyBy(3)
times10 = multiplyBy(10)

The lambda function takes the value n from the parent function, so that in double the value of n is 2, in triple it is 3 and in times10 it is 10. Now calling these functions with an argument will multiply that number.

double(6)
> 12
triple(5)
> 15
times10(12)
> 120

If you weren't using a lambda function here, you would need to define a different function inside multiplyBy, something like the below:

def muliplyBy (x):
  def temp (n):
    return x*n
  return temp

Using a lambda function uses half the lines and makes it more readable.

Conclusion

Lambda functions are a compact way to write functions if your function includes only one small expression. They are not usually something that beginner coders use, but here you have seen how you can easily use them at any level.

Lambda Expressions are ideally used when we need to do something simple and are more interested in getting the job done quickly rather than formally naming the function. Lambda expressions are also known as anonymous functions.

Lambda Expressions in Python are a short way to declare small and anonymous functions (it is not necessary to provide a name for lambda functions).

Lambda functions behave just like regular functions declared with the def keyword. They come in handy when you want to define a small function in a concise way. They can contain only one expression, so they are not best suited for functions with control-flow statements.

Syntax of a Lambda Function

lambda arguments: expression

Lambda functions can have any number of arguments but only one expression.

Example code

# Lambda function to calculate square of a number
square = lambda x: x ** 2
print(square(3)) # Output: 9

# Traditional function to calculate square of a number
def square1(num):
  return num ** 2
print(square(5)) # Output: 25

In the above lambda example, lambda x: x ** 2 yields an anonymous function object which can be associated with any name. So, we associated the function object with square. So from now on we can call the square object like any traditional function, for example square(10)

Examples of lambda functions

Beginner

lambda_func = lambda x: x**2 # Function that takes an integer and returns its square
lambda_func(3) # Returns 9

Intermediate

lambda_func = lambda x: True if x**2 >= 10 else False
lambda_func(3) # Returns False
lambda_func(4) # Returns True

Complex

my_dict = {"A": 1, "B": 2, "C": 3}
sorted(my_dict, key=lambda x: my_dict[x]%3) # Returns ['C', 'A', 'B']

Use-case

Let’s say you want to filter out odd numbers from a list. You could use a for loop:

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered = []

for num in my_list:
     if num % 2 != 0:
         filtered.append(num)

print(filtered)      # Python 2: print filtered
# [1, 3, 5, 7, 9]

Or you could write this as a one liner with list-comprehensions:

filtered = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] if x % 2 != 0]

But you might be tempted to use the built-in filter function. Why? The first example is a bit too verbose and the one-liner can be harder to understand. But filter offers the best of both words. What is more, the built-in functions are usually faster.

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

filtered = filter(lambda x: x % 2 != 0, my_list)

list(filtered)
# [1, 3, 5, 7, 9]

NOTE: in Python 3 built in functions return generator objects, so you have to call list. In Python 2, on the other hand, they return a list, tupleor string.

So what happened? You told filter to take each element in my_list and apply the lambda expressions. The values that return False are filtered out.

More Information:

• Official Docs

Before Lambda expressions support was added by JDK 8, I’d only used examples of them in languages like C# and C++.

Once this feature was added to Java, I started looking into them a bit closer.

The addition of lambda expressions adds syntax elements that increase the expressive power of Java. In this article, I want to focus on foundational concepts you need to get familiar with so you can start adding lambda expressions to your code today.

Quick Introduction

Lambda expressions take advantage of parallel process capabilities of multi-core environments as seen with the support of pipeline operations on data in the Stream API.

They are anonymous methods (methods without names) used to implement a method defined by a functional interface. It’s important to know what a functional interface is before getting your hands dirty with lambda expressions.

Functional interface

A functional interface is an interface that contains one and only one abstract method.

If you take a look at the definition of the Java standard Runnable interface, you will notice how it falls into the definition of functional interface because it only defines one method: run().

In the code sample below, the method computeName is implicitly abstract and is the only method defined, making MyName a functional interface.

interface MyName{
  String computeName(String str);
}

The Arrow Operator

Lambda expressions introduce the new arrow operator -> into Java. It divides the lambda expressions in two parts:

(n) -> n*n

The left side specifies the parameters required by the expression, which could also be empty if no parameters are required.

The right side is the lambda body which specifies the actions of the lambda expression. It might be helpful to think about this operator as “becomes”. For example, “n becomes n*n”, or “n becomes n squared”.

With functional interface and arrow operator concepts in mind, you can put together a simple lambda expression:

interface NumericTest {
    boolean computeTest(int n); 
}

public static void main(String args[]) {
    NumericTest isEven = (n) -> (n % 2) == 0;
    NumericTest isNegative = (n) -> (n < 0);

    // Output: false
    System.out.println(isEven.computeTest(5));

    // Output: true
    System.out.println(isNegative.computeTest(-5));
}

interface MyGreeting {
    String processName(String str);
}

public static void main(String args[]) {
    MyGreeting morningGreeting = (str) -> "Good Morning " + str + "!";
    MyGreeting eveningGreeting = (str) -> "Good Evening " + str + "!";

      // Output: Good Morning Luis! 
    System.out.println(morningGreeting.processName("Luis"));

    // Output: Good Evening Jessica!
    System.out.println(eveningGreeting.processName("Jessica"));    
}

The variables morningGreeting and eveningGreeting, lines 6 and 7 in the sample above, make a reference to MyGreeting interface and define different greeting expressions.

When writing a lambda expression, it is also possible to explicitly specify the type of the parameter in the expression like this:

MyGreeting morningGreeting = (String str) -> "Good Morning " + str + "!";
MyGreeting eveningGreeting = (String str) -> "Good Evening " + str + "!";

Block Lambda Expressions

So far, I have covered samples of single expression lambdas. There is another type of expression used when the code on the right side of the arrow operator contains more than one statement known as block lambdas:

interface MyString {
    String myStringFunction(String str);
}

public static void main (String args[]) {
    // Block lambda to reverse string
    MyString reverseStr = (str) -> {
        String result = "";

        for(int i = str.length()-1; i >= 0; i--)
            result += str.charAt(i);

        return result;
    };

    // Output: omeD adbmaL
    System.out.println(reverseStr.myStringFunction("Lambda Demo")); 
}

Generic Functional Interfaces

A lambda expression cannot be generic. But the functional interface associated with a lambda expression can. It is possible to write one generic interface and handle different return types like this:

interface MyGeneric<T> {
    T compute(T t);
}

public static void main(String args[]){

    // String version of MyGenericInteface
    MyGeneric<String> reverse = (str) -> {
        String result = "";

        for(int i = str.length()-1; i >= 0; i--)
            result += str.charAt(i);

        return result;
    };

    // Integer version of MyGeneric
    MyGeneric<Integer> factorial = (Integer n) -> {
        int result = 1;

        for(int i=1; i <= n; i++)
            result = i * result;

        return result;
    };

    // Output: omeD adbmaL
    System.out.println(reverse.compute("Lambda Demo")); 

    // Output: 120
    System.out.println(factorial.compute(5)); 

}

Lambda Expressions as arguments

One common use of lambdas is to pass them as arguments.

They can be used in any piece of code that provides a target type. I find this exciting, as it lets me pass executable code as arguments to methods.

To pass lambda expressions as parameters, just make sure the functional interface type is compatible with the required parameter.

interface MyString {
    String myStringFunction(String str);
}

public static String reverseStr(MyString reverse, String str){
  return reverse.myStringFunction(str);
}

public static void main (String args[]) {
    // Block lambda to reverse string
    MyString reverse = (str) -> {
        String result = "";

        for(int i = str.length()-1; i >= 0; i--)
            result += str.charAt(i);

        return result;
    };

    // Output: omeD adbmaL
    System.out.println(reverseStr(reverse, "Lambda Demo")); 
}

These concepts will give you a good foundation to start working with lambda expressions. Take a look at your code and see where you can increase the expressive power of Java.