Lambda fuctions in Python as compared to Java Lambda function

[Stephan van Hulst]

Why don't you show us an example of the two alternatives, and then tell us what you think the pros and cons of the two approaches are?

[Monica Shiralkar]

Stephan van Hulst wrote:Why don't you show us an example of the two alternatives, and then tell us what you think the pros and cons of the two approaches are?

Sure, below are the examples of lambda to add two numbers in Java and Python and also the code of doing it in way other than lambda.

Java :

public interface SumLambda {
    int sum(int a,int b);
}


public class SumLambdaExample {

    public static void main(String[] args) {
        System.out.println("Sum using lambda");
        SumLambda sumLambda = (a, b) -> (a + b);
        int sum = sumLambda.sum(1,2);
        System.out.println(sum);

        System.out.println("Sum using annonymous class");
        sum = new SumLambda() {
            @Override
            public int sum(int a, int b) {
                return a+b;
            }
        }.sum(1,2);
        System.out.println(sum);

    }
}

Python

sumLambda = lambda a, b : a + b
print('sum using lambda ' + str(sumLambda(1,2)))


def sum(a,b):
    return a + b
print('sum without lambda ' + str(sum(1,2)))

What I can see is:


Advantage of lambda in Java over doing the same thing without lambda :

Without lambda for this we required anonymous class implementation code, which made the code less readable. With lambda it is more readable.


Advantage of lambda in Python over way of doing it without lambda :

Only that one does not have to create a function.

Can one say that using lambda gives more advantage over not using it in Java as compared to what it gives in Python ?

[Stephan van Hulst]

You're not really using the lambda expressions correctly though. The point of a lambda expression is to pass the function it evaluates to to a higher order function, not to call it directly. Here is a better example:

Without lambda expressions, Python:
def is_even(x):    return x % 2 == 0 numbers = [1, 2, 3, 4, 5] even_numbers = list(filter(is_even, numbers))
With lambda expressions, Python:
numbers = [1, 2, 3, 4, 5] even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
As you can see, lambda expressions in Python allow you to define a function inline with the higher order function call. This makes the code slightly less verbose, but the tradeoff is that your code becomes slightly more difficult to read.

Personally, I find that lambda expressions are rarely worth it. I prefer the more readable version where you declare a named function.

In Java, I would declare an isEven() method explicitly, and then pass it as a predicate function to the filter() call by using a method reference:

final class Numbers {

  private static boolean isEven(int x) {
    return x % 2 == 0;
  }

  public static void main(String... args) {
    var numbers = List.of(1, 2, 3, 4, 5);

    var evenNumbers = numbers.stream().filter(Numbers::isEven).toList();

    System.out.println(evenNumbers);
  }
}