Develop Reference

How to read and break down complex lambda equations in python

This question below is from a past year NUS exam paper, and im not sure how to go about solving this; how do you break down the lambda parts and figure out which bracket is for which lambda variable? I'm unable to trace the code to get 120
def combinator(y):
return (lambda x: lambda y: x(y))(lambda x:y)
combinator(lambda x:x*10)(11)(12)
Ive tried to google but the lambda tutorials are mostly basic so im not sure how to read and break down more complex lambda codes and higher order functions

The function is
def combinator(y):
return (lambda x: lambda y: x(y))(lambda x:y)
combinator(lambda x:x*10)(11)(12)
Let's try to simplify the function. First, take note that you can change the symbol for a function. For example, lambda x: x can be changed to lambda z: z.
As there are a lot of x and y, we will change the symbols to reduce the confusion.
def combinator(y):
return (lambda w: lambda z: w(z))(lambda x:y)
combinator(lambda x:x*10)(11)(12)
Let's try to define the function as mathematics function to make it easier to understand. Let's set
f represents lambda x:x*10, so f(x) = x*10
g represents lambda x:y, so g(x) = y
h represents lambda z:w(z), so h(z) = w(z) => h = w
k represents lambda w: lambda z: w(z), so k(w) = h = w
With the mathematics function defined, you can substitute them back to the function.
combinator(y)
= (lambda w: lambda z: w(z))(lambda x:y)
= k(g)
= g
Therefore, we know that combinator(y) = g
combinator(y)(x) = g(x) = y
combinator(y)(x)(z) = y(z)
Therefore
combinator(lambda x:x*10)(11)(12)
= combinator(f)(11)(12)
= f(12)
= 12*10
= 120

Python nested lambda expression still confused and couldn't understandable. please explain the following example [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 6 years ago.
Improve this question
>>> test = lambda f: f(lambda x: x + 1)(0)
>>> z = lambda f: lambda x: x
>>> test(z)
0
>>> succ = lambda n: lambda f: lambda x: f(n(f)(x))
>>> _1 = succ(z)
>>> test(_1)
1
>>> _2 = succ(_1)
>>> test(_2)
2
>>> plus = lambda m: lambda n: lambda f: lambda x: m(f)(n(f)(x))
>>> _3 = plus(_1)(_2)
>>> test(_3)
3
>>> mult = lambda m: lambda n: lambda f: lambda x: m(n(f))(x)
>>> _6 = mult(_2)(_3)
>>> test(_6)
6
>>> _5 = plus(_2)(_3)
>>> _25 = mult(_5)(_5)
>>> _4 = plus(_2)(_2)
>>> _100 = mult(_25)(_4)
>>> test(_100)
100

First avoid same name hidden (local) variables to avoid extra confusion (as if you need anymore! :)
>>> test = lambda f: f(lambda x: x + 1)(0)
>>> z = lambda g: lambda y: y
>>> test(z)
0
Go step by step replacing the variables by their value:
test(z) = z(lambda x: x + 1)(0)
Now z is a function that return the identity function lambda y: y no matter what argument is passed (g does not appear in the expression defining the lambda).
test(z) = (lambda y: y)(0) = 0

Sum of n lambda functions

I have a list of lambda functions. Lets say this one
l = [lambda x:x**i for i in range(n)]
For every n I need to be able to sum them so I'd have a function like this:
f = lambda x: x + x**2 + x**3 + ... + x**n
Is there any way?
Edit: I wasn't clear. I don't know anything about that functions.

Is this the solution you're looking for?
Python 3.x:
n = 5
g = lambda y: sum( f(y) for f in (lambda x: x**i for i in range(n)) )
print(g(5)) # 781
Python 2.x:
n = 5
g = lambda y: sum( f(y) for f in (lambda x: x**i for i in xrange(n)) )
print g(5) # 781

If you mean a finite sum, up to x**n, use the mathematical shortcut
f = lambda x: (x**(n+1) - 1) / (x - 1) if x != 1 else n

f = lambda x,n: sum( x**i for i in range(n) )
print f(3,4)
>> 40

The simplest way to do this is to avoid creating the list of lambda functions, and to instead sum over a single function. Assuming you've defined x and n, you can do:
f = lambda x, i: x**i
sum(f(x, i) for i in range(n))
In your original example, you have actually created a closure, so your lambda functions do not do what you think they do. Instead, they are all identical, since they all use the final value of i in the closure. That is certainly not what you intended.

n=5
xpower=[]
for i in range(n):
xpower.insert(i, i+1)
print(i,xpower)
f = lambda x, xpower: sum(x**xpower[i] for i in range(len(xpower)))
print("Example with n=5, x=2:"," ", f(2,xpower))

Finding the Limit of (1+1/n)^n as n->infinity using Python/Numpy

I'm trying to use Python to plot how the limit (1+1/n)^n as n->infinity will go towards e at large n.
Why is the plot going towards 1 instead of e?
n = np.arange(0,10000,1)
f = lambda x: np.power(1 + (1/x), x)
plt.plot(n,f(n))

in this line:
f = lambda x: np.power(1 + (1/x), x)
when x is an int so 1/X will always be 0, do
f = lambda x: np.power(1 + (1.0/x), x)

how to print lambda expression

I have two (many) lambdas:
myFoo = lambda x,y: x + y
mySpecFoo = lambda x: myFoo(x, 1)
I want to print resulting expression for mySpecFoo. smth like
x = var('x')
print(mySpecFoo(x))
and I want to see in output:
lambda x: x + 1
Do you know how to do this?
Thank you!

This is called "symbolic evaluation", and you need some external library to do this, for example SymPy:
>>> import sympy
>>> myFoo = lambda x,y: x + y
>>> mySpecFoo = lambda x: myFoo(x, 1)
>>> x = sympy.var("x")
>>> print mySpecFoo(x)
1 + x