Question

This answer explains how to create test cases dynamically.

The answer’s code:

class Tests(unittest.TestCase):
    def check(self, i, j):
        self.assertNotEquals(0, i-j)

for i in xrange(1, 4):
    for j in xrange(2, 6):
        def ch(i, j):
            return lambda self: self.check(i, j)
        setattr(Tests, "test_%r_%r" % (i, j), ch(i, j))

I’ve tested and it works, but I can’t just figure out how?

I have trouble understanding the lambda self: magic in play here, mainly:

1. Is the lambda used here to perform the exact opposite of functools.partial() (i.e. to create a wrapper function with one extra parameter that is not yet known)
2. Is self a meaningful keyword or would lambda spam would work just as well?
3. What point is that lambda evaluated?
4. How come the .check() is perfectly fine outside the classes scope?
5. How do you do this without lambda? – if I understand correctly, you should be able to do without lambda (not to mention that I agree with Guido and Alex that it is an eyesore and I want to do without 🙂

Answer 1

First of all: The lambda is returned from a function to prevent that modified values of i and j will be used later.

Compare to the following:

for i in xrange(1, 4):
    for j in xrange(2, 6):
        setattr(Tests, "test_%r_%r" % (i, j), lambda self: self.check(i, j))

This will not work as expected, as all the lambdas will share the same namespace and will use the values of i and j after the end of the loop. If we use a separate function call, we introduce a new closure every time that captures the values of i and j at the point in time where the function is called.

We could achieve the same by saving the current values of i and j as default arguments of the lambda. For good measure, let’s also use itertools.product to avoid the nested loop:

from itertools import product
from operator import methodcaller

for i, j in product(range(1, 4), range(2, 6)):
  setattr(Tests, "test_%r_%r" % (i, j),
          lambda self, i=i, j=j: self.check(i, j))

Is the lambda used here to perform the exact opposite of functools.partial() (i.e. to create a wrapper function with one extra parameter that is not yet known)

Not really. It just calls the check(i, j) method on whatever it is given as an argument. This is used here to dynamically add methods to the Tests class.

Is self a meaningful keyword or would lambda spam would work just as well?

spam would work just as well. They choose self here due to convention because the lambda represents a method.

What point is that lambda evaluated?

As soon as test_[i]_[j]() is called on an instance of Tests.

How come the .check() is perfectly fine outside the classes scope?

Because it’s inside a lambda will only be called later with an instance of Tests as the self argument.