When we pass in a function, there are times when we don't need to explicitly define a function, and it's easier to pass in an anonymous function directly.
In Python, there is a limited amount of support for anonymous functions. As an example of a map()
function, when calculating f (x) =x2, in addition to defining a f(x)
function, you can also pass in an anonymous function directly:
>>> map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])[1, 4, 9, 16, 25, 36, 49, 64, 81]
By contrast, the anonymous function lambda x: x * x
is actually:
def f(x): return x * x
The keyword lambda
represents an anonymous function, preceded by a colon, that x
represents a function parameter.
The anonymous function has a restriction that there can be only one expression, without writing return
, and the return value is the result of that expression.
There is a benefit to using anonymous functions because the function does not have a name and does not have to worry about function name collisions. In addition, the anonymous function is also a function object, you can assign the anonymous function to a variable, and then use the variable to invoke the function:
>>> f = lambda x: x * x>>> f<function <lambda> at 0x10453d7d0>>>> f(5)25
Similarly, anonymous functions can be returned as return values, such as:
def build(x, y): return lambda: x * x + y * y
Summary
Python's support for anonymous functions is limited, and anonymous functions can be used only in some simple cases.
Python anonymous functions