在python中生成没有闭包的函数

Question

right now I'm using closures to generate functions like in this simplified example:

def constant_function(constant):
    def dummyfunction(t):
        return constant
    return dummyfunction

These generated functions are then passed to the init-method of a custom class which stores them as instance attributes. The disadvantage is that that makes the class-instances unpickleable. So I'm wondering if there is a way to create function generators avoiding closures.

Answer 1

You could use a callable class:

class ConstantFunction(object):
    def __init__(self, constant):
        self.constant = constant
    def __call__(self, t):
        return self.constant

def constant_function(constant):
    return ConstantFunction(constant)

The closure state of your function is then transferred to an instance attribute instead.

Answer 2

Not that I'd recommend this for general use… but there's an alternate approach of compiling and exec 'ing the code. It's generating a function w/oa closure.

>>> def doit(constant): 
...   constant = "def constant(t):\n  return %s" % constant
...   return compile(constant, '<string>', 'exec')
... 
>>> exec doit(1)
>>> constant(4)
1
>>> constant

Note that to do this inside an enclosing function or class (ie not in the global namespace) you have to also pass in the appropriate namespace to exec . See: https://docs.python.org/2/reference/simple_stmts.html#the-exec-statement

There's also the double lambda approach, which is not really a closure, well, sort of…

>>> f = lambda x: lambda y:x
>>> g = f(1)
>>> g(4)
1
>>> import dill
>>> _g = dill.dumps(g)
>>> g_ = dill.loads(_g) 
>>> g_(5)
1

You seemed worried about the ability to pickle closure-like objects, so you can see even the double lambdas are pickleable if you use dill . The same for class instances.