python中的map和filter避坑指南

大家好，欢迎来到IT知识分享网。

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时，你是在创建一个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)