使函数在Python中变得懒惰

Question

I want to write a wrapper function for eternity that will make it behave as if it's being lazily evaluated. In other words, its functionality should be made identical to that of the function lazyeternity below. I have this function packageN that takes a function and packages it into a lambda--or at least I think it does. (Packaging lazyeternity inside a lambda delayed its evaluation in the call of etest .) How can I modify packageN so that eternity = packageN(eternity) can mirror the behavior of lazyeternity ?

    def eternity():
        return eternity()

    # How can I create a wrapper function for eternity...
    # that will make it behave identical to this function?
    def lazyeternity():
        return lambda: lazyeternity()

    def packageN(f):
        return lambda *x: f(*x)

    def etest(x, y):
        return x

    eternity = packageN(eternity)

    # I want these both to return 4.
    # Currently only the first one returns 4,...
    # because the second one evaluates the eternity()...
    # parameter forever. I want to delay the evaluation...
    # of the parameter.
    print etest(4, lazyeternity())
    print etest(4, eternity())

Answer 1

The difference between lazyeternity and eternity as returned by packageN is that calling lazyeternity returns a lambda, whereas eternity is a lambda which, when called, runs forever.

To make packageN return something that acts like lazyeternity , make it

def packageN(f):
    return lambda: lambda *x: f(*x)

Answer 2

To make both eternity work, simply remove the () . You want to return a function, not the evaluation of a function (infinite loop).