Question

我有以下Python类：

class class A:
    """a class that increments internal variable"""
    def __init__(self, x):
        self._x = x
    def incr(self):
        self._x = (self._x + 1) % 10
        return self._x

我听到一个讲话，建议只有一个构造函数和另一个方法的类应该被一个函数替换。

所以这是我的尝试（对于Python 2.7）：

def incrX(x): 
    """closure that increments internal variable"""
    d = {'x' : x}
    def incr():
        d['x'] = (d['x'] + 1) % 10
        return d['x'] 
    return incr

运行它：

def test1():
    """testing closure vs. class"""
    print 'class...'
    a = A(10)
    print a.incr()
    print a.incr()

    print 'closure...'
    incr = incrX(10)
    print incr()
    print incr()

$ python closure.py 
running closure experiments
class...
1
2
closure...
1
2

所以我的问题是：

使用闭包替换像A这样的类有什么好处？只是想更好地理解闭包。

Answer 1

闭包和高阶函数的真正好处在于它们可以代表程序员有时会想到的内容。如果你作为程序员发现你所想的是一段代码，一个函数，一个关于如何计算某事（或做某事）的指令，那么你应该使用一个闭包。

另一方面，如果你的想法更像是一个对象，一个东西（碰巧有一些属性，方法，指令，功能等），那么你应该把它编程为一个对象，一堂课。

在你的情况下，我认为实现这一点的最佳方式既不是;-)我会用生成器做到这一点：

def incrX(i):
  while True:
    i += 1
    i %= 10
    yield i

incr = incrX(10)
print incr.next()
print incr.next()

Answer 2

使用闭包，可以保存self变量。特别是，当要传递的变量很多时，闭包可能更具可读性。

class Incr:
    """a class that increments internal variable"""
    def __init__(self, i):
        self._i = i
    def __call__(self):
        self._i = (self._i + 1) % 10
        return self._i

def incr(i): 
    """closure that increments internal variable"""
    def incr():
        nonlocal i
        i = (i + 1) % 10
        return i
    return incr

print('class...')
a = Incr(10)
print(a())   # 1
print(a())   # 2

print('closure...')
b = incr(10)
print(b())   # 1
print(b())   # 2

用闭包替换一个简单的Python类是否有益？

2 个答案: