这个例子背后的逻辑是什么？

Question

def myfunc(n):
  return lambda a : a * n

mytripler = myfunc(3)

print(mytripler(11))

I am trying to learn about the lambda function in python. I understand the other examples given inside w3schools about the Lambda function. This example, however, I could not wrap my head around. How is it that mytripler(11) multiplies 3 by 11?

Answer 1

Note that there is nothing particularly special about lambda. It's just a convenient method of creating an anonymous function.

If the code had instead been written:

def myfunc(n):
    def inner(a):
        return a * n
    return inner

It would be the exact same thing. Except now we've given anonymous function a name inner . But you'd discover that you can still write mytripler = myfunc(3) and it works the same way.

Python understands closures. If a variable is used (but not modified) inside an inner function, and there is an identically named variable defined in a containing function, then Python realizes that the inner variable refers to whatever value that outer variable has.

Answer 2

Let's take a step back: What is a function?

One definition could be that's a construct where you give it arguments, it does something and it returns a value (Let's ignore for now the cases where you don't give any arguments or where you don't receive any return value)

In Python, since everything is an object, this kind of construct is a value that can be assigned a name. For example:

>>> def example_function(argument):
...     result = argument * 42
...     return result
... 
>>> other_name_for_example_function = example_function
>>> example_function(3)
126
>>> other_name_for_example_function(3)
126
>>> example_function == other_name_for_example_function
True
>>> example_function is other_name_for_example_function
True

Note that in the comparison made at the end, I do not call these functions, I just compare the value of example_function and other_name_for_example_function which in this case is the same "function mechanism".

Now, lambdas are another way to define a function but it's more restricted and the function isn't assigned a name automatically. Let's take the same example but with lambdas:

>>> example_lambda = lambda argument: argument * 42
>>> other_name_for_example_lambda = example_lambda
>>> example_lambda(3)
126
>>> other_name_for_example_lambda(3)
126
>>> example_lambda == other_name_for_example_lambda
True
>>> example_lambda is other_name_for_example_lambda
True

Now if we replace the function call of your example with its content, it would look like this:

>>> n = 3   # just you see where that value will be used
>>> mytripler = lambda a: a * n
>>> a = 11  # also to see where that value will be used
>>> mytripler(a)
33

So, in your example,

1. myfunc() provide a "function mechanism" as a return value. In the definition of that "function mechanism", you have inserted the value 3 which is an argument of myfunc()
2. You assign the name mytripler to that function returned
3. You call it like you would with any function

Does that help you understand?