在调用高阶函数时存储变量

Question

如果我想调用带有参数的函数，而不使用像声明非局部变量或创建列表这样的花哨的东西，我如何在每次调用我的函数时存储我的参数，以便它 'remembers'我之前调用过的先前参数？我的想法是：

# stac(x) is a function that returns another function (nested) or itself. 
>>> stac(4)(5)(6)(4)(6)(7)(8)(3)(0) 
# if 0, prints the previous numbers that was called most recently to first call 
3
8
7
.
.
4

我想到的一些类似的事情是检测 stac(x) 中是否有重复的参数，这样每次它打印出 x 如果 x 匹配前面的参数之一。

# stac(x) is a function that returns another function (nested) or itself. 
>>> stac(1)(2)(3)(4)(1)(3)(5)(7)
1
3
# since 1 and 3 is repeated

我对如何实现这个想法的想法是，我们 return 在当前帧中定义一个函数，这样，如果我们在新帧中的参数满足（或不满足）条件，它就会检查之前的帧直到我们第一次调用参数时的框架。虽然我不确定这是否有效。如果有人知道如何实现它，我将不胜感激！

Answer 1

您需要您 return 每个对象的名称空间都可以访问的内容，否则您将无法打印所有先前的参数。所以是的，您可能需要一个列表或双端队列或其他一些可变容器。但是您可以将其设为第一个函数调用的本地：

def stac1(n):
    s = []
    def k(n):
        if n == 0:
            print(*s, sep='\n')
            return s
        s.append(n)
        return k
    return k(n)

您的第二个示例可以以类似的方式实现，但使用集合而不是序列：

def stac2(n):
    s = set()
    def k(n):
        if n in s:
            print(n)
        else:
            s.add(n)
        return k
    return k(n)

虽然这在技术上使用了共享容器，但每次调用 stac 都会实例化自己的容器，因此没有全局共享状态。同时，如果拆分，这两个函数都不会正确运行：

>>> a = stac1(1)(2)
>>> a(3)(0)
1
2
3
[1, 2, 3]
>>> a(0)
1
2
3
[1, 2, 3]
# desired [1, 2]

>>> b = stac2(1)(2)
>>> b(5)(1)
1
>>> b(5)
5
# desired nothing

一种天真的方法是传递一个不可变的 sequence/frozenset，或者至少传递一个副本，例如，作为 k 的第二个默认参数。不过，这非常缓慢且浪费，至少对于 stac1 而言是这样。您可以改用链表，这样拆分后的每个分支都有自己的序列，而不必复制父节点：

from functools import partial

def stac1b(n):
    def k(p, n):
        if n:
            return partial(k, [n, p])
        s = []
        while p:
            n, p = p
            s.append(n)
        s.reverse()
        print(*s, sep='\n')
        return s
    return k(None, n)

stac2 有点难对付。一方面，类似于 stac1b 所示的链表方法是可能的。缺点是必须对每个添加的元素执行完整的线性搜索。另一方面，传递集合的副本似乎很浪费，但会使查找速度更快。由于重复元素不需要副本，我将显示后一个选项：

def stac2b(n):
    def k(s, n):
        if n in s:
            print(n)
            return partial(k, s)
        return partial(k, s | {n})
    return k(set(), n)

在调用高阶函数时存储变量

Storing variables upon calling Higher Order Function

python

higher-order-functions