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

Question

如果我想用一个参数调用一个函数，而不使用任何花哨的东西，比如声明非局部变量或创建一个列表，我如何在每次调用我的函数时存储我的参数，以便它“记住”我之前的参数以前打过电话吗？ 我的想法如下：

# 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

我对如何处理这个想法的想法是，我们返回一个在当前帧中定义的函数，这样，如果我们在新帧中的参数满足条件（或不满足），它会在我们首先调用一个参数。虽然我不确定这是否有效。如果有人知道如何实现它，我将不胜感激！

Answer 1

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

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

一种天真的方法是传递一个不可变的序列/冻结集，或者至少是一个副本，例如，作为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)