python中的map和filter避坑指南
◆ 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中要想了解值类型，首先得明白以下两个：
- 什么是可变类型
- 什么是不可变类型
我们拿常见的几个类型来开场：
- string 是值类型吗？
是的，因为string是不可变类型。
- list 是值类型吗？
不是，因为list是可变类型。
- tuple是值类型吗？
是的，因为tuple是不可变类型
- 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)来源：
https://www.toutiao.com/article/7147958185474015779/?log_from=e13a76ddfaacd_1664420830749
“IT大咖说”欢迎广大技术人员投稿，投稿邮箱：aliang@itdks.com
来都来了，走啥走，留个言呗~
IT大咖说 | 关于版权
由“IT大咖说（ID：itdakashuo）”原创的文章，转载时请注明作者、出处及微信公众号。投稿、约稿、转载请加微信：ITDKS10（备注：投稿），茉莉小姐姐会及时与您联系！
感谢您对IT大咖说的热心支持！
- 相关推荐 推荐文章
- MySql的InnoDB的三层B+树可以存储两千万左右条数据的计算逻辑
- 呼吁停用 C/C++，微软 Azure CTO 更青睐 Rust
- 六边形架构：三个原则和一个实现示例
- Java 19 正式发布，七大特性齐发，最常用的还是 Java 11
- Redis 内存淘汰策略，从根儿上理解
- 这个牛逼了，基于（SpringBoot+VUE）实现的自定义拖拽式智能大屏
- 终于有人把怎么搭建数据指标体系给讲明白了，数据分析师必备
- SpringBoot企业级技术中台微服务架构与服务能力开发平台
- SQLSERVER backup 命令总结
- MyBatisPlus又在搞事了！一个依赖轻松搞定权限问题！堪称神器