4

我有以下 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 这样的类有好处吗？只是想更好地理解闭包。

4

2 回答 2

5

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

另一方面，如果您的想法更像是一个对象、一个事物（它恰好具有一些属性、方法、指令、功能等），那么您应该将它编程为一个对象、一个类。

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

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

incr = incrX(10)
print incr.next()
print incr.next()
于 2013-09-30T09:07:00.203 回答
0

With a closure, one can save the self variable. In particular, when there are many variables to be passed, a closure could be more readable.

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
于 2020-06-05T23:55:31.210 回答