Python相当于maplist？

Question

Common Lisp 的 maplist 函数的最佳 Python 等效项是什么？来自maplist documentation：

maplist 和 mapcar 一样，除了 函数应用于连续 列表的子列表。功能是 首先应用于列表本身， 然后到每个列表的 cdr，和 然后到每个 cdr 的 cdr 列表等等。

示例（伪代码，未经测试）：

>>> def p(x): return x
>>> maplist(p, [1,2,3])
[[1, 2, 3], [2, 3], [3]]

注意：在上例中传递给p 的参数将是列表[1, 2, 3]、[2, 3]、[3]；即，p 不适用于这些列表的元素。例如：

>>> maplist(lambda l: list(reversed(l)), [1,2,3])
[[3, 2, 1], [3, 2], [3]]

Answer 1

Python 有一个链表类型，称为deque：

from collections import deque

def maplist(f, lst):
    linked = deque(lst)
    results = []
    while linked:
        results.append(f(linked))
        linked.popleft() # assumes left is head, as in lisp

    return results

In [134]: maplist(lambda l: list(reversed(l))*2, [1,2,3])
Out[134]: [[3, 2, 1, 3, 2, 1], [3, 2, 3, 2], [3, 3]]

线性时间，做同样的事情，将具有与对 lisp 列表的操作相同的性能特征（即修改内部元素将在被修改列表的长度上是线性的），以及相同的语义（即如果 f修改列表，它会为 maplist 调用内的所有后续执行 f 修改它；但是，因为这会创建 lst 的副本，f 不能修改 lst，这与 Common Lisp 不同。

Answer 2

你可以为此编写一个小函数

def maplist(func, values):
    return [map(func, values[i:]) for i in xrange(len(values))]

>>> maplist(lambda a: a* 2, [1,2,3])
[[2, 4, 6], [4, 6], [6]]

[编辑]

如果您想在子列表上应用该函数，您可以将函数更改为：

def maplist(func, values):
    return [func(values[i:]) for i in xrange(len(values))]

>>> maplist(lambda l: list(reversed(l)), [1,2,3])
[[3, 2, 1], [3, 2], [3]]

Answer 3

O(N) 对链表的 maplist() 实现

maplist = lambda f, lst: cons(f(lst), maplist(f, cdr(lst))) if lst else lst

请参阅Python Linked List 问题。

Answer 4

正如@Cybis 和其他人所提到的，Python 列表无法保持 O(N) 复杂度；您必须创建一个链接列表。冒着证明Greenspun's 10th rule的风险，这里有这样一个解决方案：

class cons(tuple):
    __slots__=()

    def __new__(cls, car, cdr):
        return tuple.__new__(cls, (car,cdr))

    @classmethod
    def from_seq(class_, l):
        result = None
        for el in reversed(l):
            result = cons(el, result)
        return result

    @property
    def car(self): return self._getitem(0)

    @property
    def cdr(self): return self._getitem(1)

    def _getitem(self, i):
        return tuple.__getitem__(self, i)

    def __repr__(self):
        return '(%s %r)' % (self.car, self.cdr)

    def __iter__(self):
        v = self
        while v is not None:
            yield v.car
            v = v.cdr

    def __len__(self):
        return sum(1 for x in self)

    def __getitem__(self, i):
        v = self
        while i > 0:
            v = v.cdr
            i -= 1
        return v.car

def maplist(func, values):
    result = [ ]
    while values is not None:
        result.append(func(values))
        values = values.cdr
    return result

测试结果：

>>> l = cons.from_seq([1,2,3,4])
>>> print l
(1 (2 (3 (4 None))))
>>> print list(l)
[1, 2, 3, 4]
>>> print maplistr(lambda l: list(reversed(l)), cons.from_seq([1,2,3]))
[[3, 2, 1], [3, 2], [3]]

编辑：这是一个基于生成器的解决方案，它基本上解决了相同的问题，而无需使用链表：

import itertools

def mapiter(func, iter_):
    while True:
        iter_, iter2 = itertools.tee(iter_)
        iter_.next()
        yield func(iter2)

测试结果：

>>> print list(mapiter(lambda l: list(reversed(list(l))), [1,2,3]))
[[3, 2, 1], [3, 2], [3]]

Answer 5

Eewww... 对列表进行切片是一种线性时间操作。迄今为止发布的所有解决方案都具有 O(n^2) 时间复杂度。我相信 Lisp 的 maplist 有 O(n)。

问题是，Python 的列表类型不是链表。它是一个可动态调整大小的数组（即，像 C++ STL 的“向量”类型）。

如果保持线性时间复杂度对您很重要，则不可能在 Python 列表上创建“maplist”函数。最好修改代码以使用列表中的索引，或者将列表转换为实际的链表（仍然是线性时间操作，但会产生很多开销）。

Answer 6

您可以使用嵌套列表推导：

>>> def p(x): return x
>>> l = range(4)[1:]
>>> [p([i:]) for i in range(len(l))]
[[1, 2, 3], [2, 3], [3]]

您可以使用它自己定义地图列表：

>>> def maplist(p, l): return [p([i:]) for i in range(len(l))]
>>> maplist(p, l)
[[1, 2, 3], [2, 3], [3]]

Answer 7

修改亚伦的回答：

In [8]: def maplist(p, l): return [p([x for x in l[i:]]) for i in range(len(l))]
   ...: 

In [9]: maplist(lambda x: x + x, [1,2,3])
Out[9]: [[1, 2, 3, 1, 2, 3], [2, 3, 2, 3], [3, 3]]

Answer 8

这就像你的例子（我已经修改了 reyjavikvi 的代码）

def maplist(func, l):
    result=[]
    for i in range(len(l)):
        result.append(func(l[i:]))
    return result

Answer 9

我认为没有，但以下功能可以工作：

def maplist(func, l):
    for i in range(len(l)):
        func(l[i:])