Pythonic的方式使用map和filter

列表迭代在python中是非常pythonic的使用方式

def inc(x): 
    return x+1
>>> list(map(inc,range(10)))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# pythonic way
>>> [inc(i) for i in range(10)]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def is_even(x): return x%2==0 
>>> list(filter(is_even, range(10)))
[0, 2, 4, 6, 8]

# pythonic way
>>> [i for i in range(10) if is_even(i)]
[0, 2, 4, 6, 8]

列表迭代在python中针对迭代效率和性能是进行过定制化优化的使用方式，因此一般来说推荐这么写，不过在使用的过程中也难免踩到坑，本文希望一次性将使用注意事项讲清楚，避免采坑。

首先要明白在python中什么是值类型

在python中要想了解值类型，首先得明白以下两个：

• 什么是可变类型

• 什么是不可变类型

我们拿常见的几个类型来开场：

1. string 是值类型吗？

是的，因为string是不可变类型。

2. list 是值类型吗？

不是，因为list是可变类型。

3. tuple是值类型吗？

是的，因为tuple是不可变类型

4. iterator是值类型吗？

这个问题不好说，我拿代码来举例：

>>> a = iter((1,2,3))
>>> next(a)
1
>>> next(a)
2
>>> next(a)
3

从上述示例我们看到每次返回结果会发生变化，那么他是可变的，那么他不是值类型。

上述介绍只是一个引子，因为了解什么是可变的，什么是不可变的，什么是值类型对于资深pythoner是非常有意义的。

接下来我们从几个常见的问题来开始下面的课程。

问题1：map和filter返回的是iterator

>>> res = map(inc, range(10))
# let's check if it worked 
>>> list(res)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# let's filter all even integers from res
>>> list(filter(is_even, res))
[]

如果您是一个有经验的pythonista，您可能知道哪里出错了，这是意料之中的。

以下是为什么这种是不符合预期的。如果我们使用列表推导式，就不会遇到这种情况。

>>> res=[inc(i) for i in range(10)]

# let's check if it worked 
>>> res
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# let's filter all even integers from res
>>> [i for i in res if is_even(i)]
[2, 4, 6, 8, 10]

# unless you directly mutate res
# you can do more things with res.

我简化了一点，但是map和filter在调用list或tuple时返回一个迭代器。list (res)穷举迭代器，res变为空。

>>> res = map(inc, range(10))

# res returns an iterator here
>>> list(res)  
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# list(res) exhausts the iterator 
# so you're filtering an empty iterator here
# so you get an empty list
>>> list(filter(is_even, res))
[]

你可以立即实现迭代器并存储结果到列表中。

res = list(map(inc, range(10)))

>>> list(res)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# works fine!
>>> list(filter(is_even, res))
[2, 4, 6, 8, 10]

但是如果这么做，就会失去了map和filter的惰性加载的特性，不方便做list(map…)。

问题2：map and filter 的懒加载模式

>>> filter(is_even, [1,2,3])        
<filter object at 0x0000018B347B0EB0>

这里，当你调用filter时，你是在创建一个filter对象，你不是在计算结果。你只在绝对需要的时候计算它，这是懒惰。这在函数式编程中很常见。这就是为什么这在python中是一个问题。

>>> a = [1,2,3,4]
>>> res = filter(is_even, a)
>>> a.append(10)
>>> a.append(12)

你认为过滤的结果会是什么?如果你使用list(res)，你会得到什么?需要你好好想想。

答案如下：

>>> list(res)
[2, 4, 10, 12]

大多数人都能猜对答案，但这并不难。

>>> res = filter(is_even, a)

我肯定是指过滤a的值，它是[1,2,3,4]。这会导致难以追踪的bug，更重要的是，这会使你的代码难以推理。

大多数函数式语言都具有不可变性是有原因的。只有当可以保证表达式的参数每次都具有相同的含义时，才能延迟表达式的求值。

在本例中，filter(is_even, a)的结果取决于迭代器的实现时间。它取决于时间。

>>> a = [1,2,3,4]
>>> res = filter(is_even,a) 
>>> a.append(10)
>>> a.append(12)
>>> a.append(14) 
>>> a.append(16) 
>>> list(res)
[2, 4, 10, 12, 14, 16]

这是完全相同的代码行，但结果改变了。这是另一种思考方式。

你未来的行为会影响你过去行为的结果。我们实质上是在改变过去，这使得对代码进行推理变得极为困难。

我将快速向您展示一个clojure示例。(别担心，它看起来很像python)

user=> (def a [1,2,3,4]) ; equivalent to a = [1,2,3,4]
#'user/a
user=> (def res (filter even? a)) ; even? = is_even
#'user/res
user=> (def a (concat a [10])) ; concat is similar to append
#'user/a
user=> (def a (concat a [12])) 
#'user/a
user=> res  
(2 4) ; isn't this what you expected?

user=> a ; proof that a is something else
(1 2 3 4 10 12)

Filter在clojure中是惰性的，但是你得到了正确的结果，即过滤[1,2,3,4]而不是[1,2,3,4,10,12]。

你无法改变过去。你可以看到为什么时间旅行可能是一个坏主意

只是为了提醒您，列表推导式解决了这些问题。

在用 map and filter的时候如何避免入坑

要解决这些问题，我们必须

返回一个值，而不是迭代器

消除惰性或确保可变性不会影响返回值。

修复第一个问题就像返回一个列表或元组一样简单。解决第二个问题更难。如果我们想要确保返回值不受可变性的影响，并试图有惰性，我们需要对输入可迭代对象做一个深度复制。

这是方法之一。

class filter:
    def __init__(self,fn, iterable):
        self.fn = fn
        self.iterable = deepcopy(iterable)
        self.res = None
    
    def __iter__(self):
        return [i for i in self.iterable if self.fn(i)]

但懒惰不仅拖延了计算，还只在需要的时候计算结果。

user=> (take 10 (map inc (range)))
(1 2 3 4 5 6 7 8 9 10)

由于map是惰性的，它只计算前10个元素。

filter实现中的deepcopy意味着我的实现不是完全懒惰的。这种实现的唯一优点是当过滤函数很昂贵时。

使用即时计算

我认为最实用的解决方案是即时地计算map和filter。

def map(fn, *iterables): 
    return [fn(*i) for i in zip(*iterables)]

def filter(fn, iterable):
    return [i for i in iterable if fn(i)]

这样做的好处是，它可以作为python默认map和filter的替换项，如果iterable是可哈希的，那么我们甚至可以向这些函数添加lru_cache。但列表是最常用的容器，而且它们是不可哈希的，所以可能没有那么大的好处?

那么在什么场景使用呢？

可能在一些罕见的情况下，用户可能想要迭代一个无限序列或一个巨大的序列，而懒惰是必要的。在这种情况下，我们可以定义一个lazymap和lazyfilter。在我看来，让默认情况变得迫切，并强迫用户在需要时显式地使用惰性版本更好。这将减少新手使用map和filter时的意外。

我们能做得比python默认的惰性实现更好吗

实际上是可以的

class lazymap:
    def __init__(self,fn, *iterables):
        self.fn = fn
        self.iterables = iterables
    def __iter__(self):
        return (self.fn(*i) for i in zip(*self.iterables))

class lazyfilter:
    def __init__(self,fn, iterable):
        self.fn = fn
        self.iterable = iterable
    def __iter__(self):
        return (i for i in self.iterable if self.fn(i))

以下是为什么它更好。让我们来定义。

# taken from functionali
def take(n: int, iterable: Iterable) -> Tuple:
    """Returns the first n number of elements in iterable.
    Returns an empty tuple if iterable is empty
    >>> take(3, [1,2,3,4,5])
    (1, 2, 3)
    """
    it = iter(iterable)
    accumulator = []
    i = 1
    while i <= n:
        try:
            accumulator.append(next(it))
            i += 1
        except StopIteration:
            break
    return tuple(accumulator)

现在让我们看一个带有默认python实现的示例。

>>> res = map(inc, range(100))
>>> take(5, res)                 
(1, 2, 3, 4, 5)
>>> take(5, res)
(6, 7, 8, 9, 10)

你不会得到相同的结果，即使它看起来是计算相同的表达式。

lazymap也是一样的。

>>> res = lazymap(inc, range(100))

>>> take(5, res)
(1, 2, 3, 4, 5)
>>> take(5, res)
(1, 2, 3, 4, 5)
>>> take(5, res)
(1, 2, 3, 4, 5)

您总是会得到相同的结果，就像在clojure或任何其他函数式编程语言中一样。

user=> (def res (map inc (range 100)))
#'user/res
user=> (take 5 res)
(1 2 3 4 5)
user=> (take 5 res)
(1 2 3 4 5)