C-Sharp | Java | Python | Swift | GO | WPF | Ruby | Scala | F# | JavaScript | SQL | PHP | Angular | HTML
Part 1: Here 2 lambdas are created. The first is called "square" and it receives one argument "n" and returns "n * n".
Part 2: We pass the lambdas as an argument to our apply() function. Our lambda expressions are objects.
Part 3: In apply, we call the lambda argument like a function. The logic in the lambda expressions is executed.
Python program that uses lambda argument
def apply(f, n):
# Part 3: invoke the lambda.
result = f(n)
print("RESULT:", result)
# Part 1: create 2 similar lambdas.
square = lambda n: n * n
cube = lambda n: n * n * n
# Part 2: pass lambdas to apply method.
apply(square, 4)
apply(cube, 3)
Output
RESULT: 16
RESULT: 27
Variable: We can assign a variable to a lambda expression and then invoke the lambda with parentheses. We call it like any other function.
Here: To get the value 6 in this program, we invoke x. We then print the value it returns (stored in y).
So: Lambdas can be passed to other methods. They can be stored in variables. And those variables can be called like methods.
Python program that uses lambda, no arguments
# Assign variable to lambda expression.
x = lambda: sum(range(1, 4))
# Invoke lambda expression.
y = x()
print(y)
Output
6
Python program that uses None, lambda
# This lambda has a side effect.
# ... Print returns None.
p = lambda x: print(x)
p("Hello")
p("World")
Output
Hello
World
With nested lambdas: Recursion can occur. This may result in a RuntimeError: maximum recursion depth exceeded error.
Python program that uses lambda in lambda
add_two = lambda n: n + 2
multiply_add_two = lambda n: add_two(n * 2) # Call lambda in lambda.
print(multiply_add_two(3))
print(multiply_add_two(5))
Output
8
12
Here: We use a lambda X to combine two string method calls. This is like a macro for those invocations. Typing is reduced.
Python program that uses lambda as macro
line1 = "A cat, a dog "
line2 = " a bird, a mountain"
# Use X as an alias for two methods.
x = lambda s: s.strip().upper()
# Call the lambda to shorten the program's source.
line1b = x(line1)
line2b = x(line2)
print(line1b)
print(line2b)
Output
A CAT, A DOG
A BIRD, A MOUNTAIN
And: When we avoid the lambda, the code becomes clearer and shorter. The lambda does not add much in this case.
Note: Sometimes a program can benefit from lambda when the lambda increases the "symmetry" of the program—other places also use lambda.
Python program that avoids lambda when possible
import math
values = [10, 20, 30]
# Apply sqrt to all elements in the list with map.
result1 = map(math.sqrt, values)
# We can use a lambda, but it is not needed.
result2 = map(lambda x: math.sqrt(x), values)
print("values:", values)
print("math.sqrt:", list(result1))
print("lambda:", list(result2))
Output
values: [10, 20, 30]
math.sqrt: [3.1622776601683795, 4.47213595499958, 5.477225575051661]
lambda: [3.1622776601683795, 4.47213595499958, 5.477225575051661]
Version 1: The program tests the performance of the def method call. We call it ten million times.
Version 2: The program times the lambda expression method call. We also call it ten million times.
Result: We find that methods written with the def keyword and with the lambda keyword are close in performance.
Python program that times lambda expressions
import time
# Method.
def square1(n):
return n ** 2
# Lambda method.
square2 = lambda n: n ** 2
print(time.time())
# Version 1: use def method.
i = 0
while i < 10000000:
square1(1)
i += 1
print(time.time())
# Version 2: use lambda method.
i = 0
while i < 10000000:
square2(1)
i += 1
print(time.time())
Output
1346613154.399
1346613158.919 (Def = 4.52 s)
1346613163.397 (Lambda = 4.48 s)
Tip: If you want many statements, please instead use a def. For complex or involved methods, def is a better option.
DefAnd: Lambda supplements, but does not replace, the def method syntax. It should be used when it improves clarity.
Greek letter: The word "lambda" is simply the name of a letter in the Greek alphabet. It is similar to the letter "L."
Quote: The expression lambda yields a function object. The unnamed object behaves like a function object defined with [def].
Expressions: python.org