You cannot use assignments in a expression, and a lambda only takes an expression.

You can store lambdas in dictionaries just fine otherwise:

dict = {'Applied_poison_rating_bonus' : (lambda target, magnitude: target.equipmentPoisonRatingBonus + magnitude)}

The above lambda of course only returns the result, it won't alter target.equimentPoisonRatingBonus in-place.

You don't iterate with lambda. There are following ways to iterate an iterable object in Python:

1. for statement (your answer)
2. Comprehension, including list [x for x in y], dictionary {key: value for key, value in x} and set {x for x in y}
3. Generator expression: (x for x in y)
4. Pass to function that will iterate it (map, all, itertools module)
5. Manually call next function until StopIteration happens.

Note: 3 will not iterate it unless you iterate over that generator later. In case of 4 it depends on function.

For iterating specific collections like dict or list there can be more techniques like while col: remove element or with index slicing tricks.

Now lambda comes into the picture. You can use lambdas in some of those functions, for example: map(lambda x: x*2, [1, 2, 3]). But lambda here has nothing to do with iteration process itself, you can pass a regular function map(func, [1, 2, 3]).

The fix:

def make_closure(number):
    return lambda x: myfct(x, number)

used as

{'add_{}'.format(number): make_closure(number) for number in range(10)}

The reason for this behaviour is, that the variable number (think: named memory location here) is the same during all iterations of the loop (though its actual value changes in each iteration). "Loop" here refers to the dictionary comprehension, which internally is based on a loop. All lambda instances created in the loop will close over the same "location", which retains the value last assigned to it (in the last iteration of the loop).

The following code is not what actually happens underneath. It is merely provided to shed light on the concepts:

# Think of a closure variable (like number) as being an instance
# of the following class

class Cell:
    def __init__(self, init=None):
        self.value = None

# Pretend, the compiler "desugars" the dictionary comprehension into
# something like this:

hidden_result_dict = {}
hidden_cell_number = Cell()

for number in range(10):
    hidden_cell_number.value = number
    hidden_result_dictionary['add_{}'.format(number)] = create_lambda_closure(hidden_cell_number)

All lambda closures created by the create_lambda_closure operation share the very same Cell instance and will grab the value attribute at run-time (i.e., when the closure is actually called). By that time, value will refer to last value ever assigned to it.

The value of hidden_result_dict is then answered as the result of the dict comprehension. (Again: this is only meant as be read on a "conceptual" level; it has no relation to the actual code executed by the Python VM).

These are equivalent versions of your two functions without lambdas.

mapping = lambda k, v: (v, k)

mapReduce = lambda k, v: final_output.setdefault(k, []).append(v)

I'll mention in passing that naming lambdas is apparently somewhat discouraged, and, according to PEP 8:

The use of the assignment statement eliminates the sole benefit a lambda expression can offer over an explicit def statement (i.e. that it can be embedded inside a larger expression)

If there's a reason you're doing this besides an assignment's requirement, that would be interesting to share, as the consensus seems to be that there is no benefit to named lambdas over normal functions (and some downsides, such as tracebacks for debugging).

The reason it doesn't work has to do with late-binding closures in Python.

Python’s closures are late binding. This means that the values of variables used in closures are looked up at the time the inner function is called.

Adapting the source explanation, whenever the return function is called, the value of key is looked up in the surrounding scope at call time. By then, the loop has completed and key is left with its final value of 'foo'.

You can resolve this by creating a closure that binds immediately to its arguments by using a default arg like so:

a = {'bar': 0, 'foo': 1}  # a reference dictionary 

dic1 = {'bar': lambda x: x['bar'], 'foo': lambda x: x['foo']}
dic2 = {key: lambda x, key=key: x[key] for key in a}

print(dic1'bar', dic1'foo')
print(dic2'bar', dic2'foo')

Result:

0 1
0 1