调用高阶函数时存储变量

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

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

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)