通过以下限制访问非局部变量[关闭]

Question

我正在尝试找出 Python 练习中的情况
问题是：

定义两个函数：

• p：打印变量的值
• q：增加变量
• 变量的初始值为0
  

限制：

• 变量不在全局环境中，唯一的方法 改变它是通过调用 q()
• 代码引入全局环境的唯一绑定是针对 p 和 q。

下面的代码将描述这种情况：

# >>> p()
# 0
# >>> q()
# >>> q()
# >>> p()
# 2
# >>> print([k for k,v in globals().items() if v==2]) 
## checks that a variable with the value ‘2’ does not exist in the global environment.
# [] 

我想得到一些建议，我应该如何解决它。
谢谢。

Answer 1

您可以在函数的局部范围内定义变量：

def p():
    i = [0]
    def p():
        return i[0]
    def q():
        i[0] += 1
    return p, q

p, q = p()

print(p())
# 0
q()
q()
print(p())
# 2
print([k for k,v in globals().items() if v==2]) 
# []

---

在 Python3 中，您可以使用 nonlocal 语句，这样您就可以将 i 设为 int 而不是列表：

def p():
    i = 0
    def p():
        return i
    def q():
        nonlocal i
        i += 1
    return p, q

Answer 2

免责声明：这不是一个非常严肃的答案。不过符合 OP 中规定的规格！

def p():
    print(p.__dict__.get('smuggled_value',0))

def q():
    p.smuggled_value = getattr(p,'smuggled_value',0) + 1

更严肃的回答：如果您允许 p 或 q 有论据，这个问题就很简单了。否则，您需要做一些非常 hacky 的事情，或者使用全局变量。

编辑：按要求解释：

在python中，一切都是对象，包括函数。具有__dict__ 属性的对象允许使用object.attribute 语法进行属性分配。通常你只对class 成员进行这种属性分配，但函数也允许这样做。所以我利用了这一点，因为你只能创建 p 和 q。

请注意，您实际上不应该这样编写代码。从您的困惑中可以看出，这种编码方式无法可读。为您的函数提供参数，以便它们可读。

Answer 3

这是一个基于闭包的版本，不会将p 和q 以外的任何符号引入全局范围：

@apply
def p():
    x = [0]
    def p():
        print x[0]
    return p

def q():
    p.func_closure[0].cell_contents[0] += 1

这绝对是“hacky”方面而不是“严肃回答”方面，但另一方面，您的要求也是如此。 ;-)

---

我还要说，严格满足这个要求是不可能的……

改变它的唯一方法是调用 q()

因为在此示例中，您可以手动执行 q 在内部执行的操作。

（或者你可以利用解释器的实现细节，声明一个ctypes 指针，甚至在内存级别上进行更糟糕的黑客攻击......）

Answer 4

也许 q 可以在每次调用时替换 p 函数：

p = lambda: 0

def q():
    global p
    value = p() + 1
    p = lambda: value

（虽然它并不完全符合规范——实际上没有任何变量被递增）

Answer 5

由于到目前为止没有人发布基于类的解决方案：

class _pq(object):
    _x = 0
    @classmethod
    def p(cls):
        print cls._x
    @classmethod
    def q(cls):
        cls._x += 1

p = _pq.p
q = _pq.q
del _pq

Answer 6

知道了，我的最终答案。仅将 p 和 q 引入命名空间，从不更改它们。该变量位于 lambda 的默认参数中，该参数仅被调用一次，没有参数，并返回函数。我们避免使用 __import__ 将运算符放入全局命名空间（对于 operator.setitem）。

p, q = (lambda i=[0]: 
    (lambda: i[0], 
     lambda: __import__('operator').setitem(i, 0, i[0]+1))
)()

我认为这个解决方案最适合这个问题，例如除了调用 q 之外，没有其他方法可以更改变量，并且它不会在全局命名空间中引入任何不必要的东西。 虽然感觉更像 Javascript 而不是 Python :-)