Just in case, if someone is looking for a similar problem...
Most solutions given here are one line and are quite readable and simple. Just wanted to add one more that does not need the use of lambda(I am assuming that you are trying to use lambda just for the sake of making it a one line code). Instead, you can use a simple list comprehension.
[print(i) for i in x]
BTW, the return values will be a list of Nones.
python - loop for inside lambda - Stack Overflow
python - How do I create a list of lambdas (in a list comprehension/for loop)? - Stack Overflow
How to create a list of different lambda functions.
Issue with creating lambda functions using for loop
Just in case, if someone is looking for a similar problem...
Most solutions given here are one line and are quite readable and simple. Just wanted to add one more that does not need the use of lambda(I am assuming that you are trying to use lambda just for the sake of making it a one line code). Instead, you can use a simple list comprehension.
[print(i) for i in x]
BTW, the return values will be a list of Nones.
Since a for loop is a statement (as is print, in Python 2.x), you cannot include it in a lambda expression. Instead, you need to use the write method on sys.stdout along with the join method.
x = lambda x: sys.stdout.write("\n".join(x) + "\n")
You have:
listOfLambdas = [lambda: i*i for i in range(6)]
for f in listOfLambdas:
print f()
Output:
25
25
25
25
25
25
You need currying! Aside from being delicious, use this default value "hack".
listOfLambdas = [lambda i=i: i*i for i in range(6)]
for f in listOfLambdas:
print f()
Output:
0
1
4
9
16
25
Note the i=i. That's where the magic happens.
I'm guessing that the lambda you're creating in the list comprehension is bound to the variable i which eventually ends up at 5. Thus, when you evaluate the lambdas after the fact, they're all bound to 5 and end up calculating 25. The same thing is happening with num in your second example. When you evaluate the lambda inside the loop it's num hasn't changed so you get the right value. After the loop, num is 5...
I'm not quite sure what you're going for, so I'm not sure how to suggest a solution. How about this?
def square(x): return lambda : x*x
listOfLambdas = [square(i) for i in [1,2,3,4,5]]
for f in listOfLambdas: print f()
This gives me the expected output:
1
4
9
16
25
Another way to think of this is that a lambda "captures" its lexical environment at the point where it is created. So, if you give it num it doesn't actually resolve that value until its invoked. This is both confusing and powerful.
Hi! Just a simple question, I was wondering how to create a list of different lambda functions like so:
[(lambda x: x*i) for i in range(3)]
Ideally, this should return an output like this:
[lambda x: x*0, lambda x: x*1, lambda x: x*2]
However, the actual output is like so:
[lambda x: x*2, lambda x: x*2, lambda x: x*2]
How would I go about producing the desired output? Thanks!
Hey all,
Can someone explain why when I run the below code:
arr = []
for n in range(1,5):
arr.append(lambda n: 5+n)
I can't run one of the functions in the array by simply calling arr[0]()with empty parenthesis?
it throws an error saying I need to pass one positional argument, n - but I'm passing it using for loop, am I not?
There is evidently something I'm missing.
What makes it worse to me is that ok, if I pass an argument, say I will call art[0](7) - that makes the n in my lambda and in for loop useless, because the value (of n) didn't get passed at all to that lambda n: definition...
Any help would be appreciated!
You need to bind d for each function created. One way to do that is to pass it as a parameter with a default value:
lambda d=d: self.root.change_directory(d)
Now the d inside the function uses the parameter, even though it has the same name, and the default value for that is evaluated when the function is created. To help you see this:
lambda bound_d=d: self.root.change_directory(bound_d)
Remember how default values work, such as for mutable objects like lists and dicts, because you are binding an object.
This idiom of parameters with default values is common enough, but may fail if you introspect function parameters and determine what to do based on their presence. You can avoid the parameter with another closure:
(lambda d=d: lambda: self.root.change_directory(d))()
# or
(lambda d: lambda: self.root.change_directory(d))(d)
This is due to the point at which d is being bound. The lambda functions all point at the variable d rather than the current value of it, so when you update d in the next iteration, this update is seen across all your functions.
For a simpler example:
funcs = []
for x in [1,2,3]:
funcs.append(lambda: x)
for f in funcs:
print f()
# output:
3
3
3
You can get around this by adding an additional function, like so:
def makeFunc(x):
return lambda: x
funcs = []
for x in [1,2,3]:
funcs.append(makeFunc(x))
for f in funcs:
print f()
# output:
1
2
3
You can also fix the scoping inside the lambda expression
lambda bound_x=x: bound_x
However in general this is not good practice as you have changed the signature of your function.