一文看懂Python列表表达式及高阶函数如lamda, zip, enumerate, map和filter方法。

深入了解和熟练使用python的列表表达式和内置的一些高阶函数如lamda, zip, enumerate, map, filter, reduce, sorted方法是python学习，面试和工作的必备技能。正是它们给了python优秀的特性，从而使python有别于其它编程语言。网上的介绍和教程有很多，但感觉还是比较零散，解读也不够深入，所以决定再次动手写篇总结。本文内含很多实例代码，以帮助新手更好理解。

列表表达式[List Comprehension]

顾名思义，这个表达式作用是以一个快捷的方法对列表进行操作或运算，返回新的列表。其使用方式为[表达式 for 变量 in 列表]  或者  [表达式 for 变量 in 列表 if 条件]。

一个最简单的列表表达式的例子如下。

>>> list1 = [1, 2, 3, 4, 5]
>>> list2 = [ i * i for i in list1]
>>> list3 = [i * i for i in list1 if i>2]
>>> print(list2)
[1, 4, 9, 16, 25]
>>> print(list3)
[9, 16, 25]

列表表达式也可以遍历元组生成新的列表(如list5)，然而却不能直接生成新的元组。比如list6实际上是个生成器表达式，不属于列表表达式了。对于生成器表达式可以通过使用list6.__next__()方法一次一次取值。

>>> truple = (1, 2, 3, 4)
>>> list5 = [i * i for i in truple]
>>> print(list5)
[1, 4, 9, 16]
>>> list6 = (i*i for i in truple)
>>> print(list6)
<generator object <genexpr> at 0x034685F0>

下面我们来看下3个常考的关于列表表达式应用的例子。

1.统计字符串列表中每个字符串的长度

>>> word = ['hello', 'abc', 'i love you', 'nice too meet you']
>>> len_list = [len(word) for word in word]
>>> print(len_list)
[5, 3, 10, 17]

2. 利于列表表达式求两个列表的交集。

>>> a = [3, 5, 6, 8]
>>> b = [5, 6, 9 ,2]
>>> a_b = [i for i in a if i in b]
>>> print(a_b)
[5, 6]

3. 打印出100以内所有十位数比个位数大1位的数字。

>>> num = [n1*10+n2 for n1 in range(0, 10)
...     for n2 in range(0, 10) if n1 == n2+1]
>>> print( num)
[10, 21, 32, 43, 54, 65, 76, 87, 98]

匿名函数lambda函数

Lambda函数又称匿名函数，也有人称为lambda表达式。顾名思义，匿名函数就是没有名字的函数。函数没有名字也行？当然可以啦。有些函数如果只是临时一用，而且它的业务逻辑也很简单时，就没必要非给它取个名字不可。

lambda匿名函数的格式是 lambda 参数: 表达式。冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式。其实lambda返回值是一个函数的地址，也就是函数对象。下面是个最简单的lambda函数的例子。

>>> add = lambda x, y: x+y
>>> type(add)
<class 'function'>
>>> print(add(3,5))
8

既然是匿名函数，我们为什么还要给它取个叫add的名字？这的确是多次一举。其实lambda最常用的还是和sorted, map、reduce、filter这些高级函数结合使用。我们再来看下2个使用lambda函数结合sorted方法排序的经典例子。一个按绝对值大小排序，一个按字符串长度排序。

>>> list1 = [2, 4, -5, -3, 8]
>>> list2 = sorted(list1, key=lambda x:abs(x))
>>> print(list2)
[2, -3, 4, -5, 8]
>>> list3 = ['hello', 'i love you', 'nice too meet you', 'good morning']
>>> list4 = sorted(list3, key=lambda x:len(x))
>>> print(list4)
['hello', 'i love you', 'good morning', 'nice too meet you']

下面是一道关于lambda函数的经典面试题。flist[0]能输出什么？这个主要考函数对象列表，千万不要和列表表达式搞混了啊。答: flist[0]输出的是函数对象。

>>> flist = [lambda x:x*x for x in range(1, 4)]
>>> print(flist)
[<function <listcomp>.<lambda> at 0x034F9588>, <function <listcomp>.<lambda> at 0x034F9468>, <function <listcomp>.<lambda> at 0x034F9660>]
>>> flist[2]
<function <listcomp>.<lambda> at 0x034F9660>
>>> flist[2](3)
9

zip函数

zip()函数来可以把2个或多个列表合并，并创建一个元组对的列表。元组对的数量以合并列表的最短长度为准。python 3中zip方法合并列表后生成的是zip对象，使用list方法可以将其变成列表，使用dict方法可以将其变成字典。

>>> l1 = [1, 2, 3]
>>> l2 = ['x', 'y', 'z']
>>> l3 = ['x', 'y']
>>> zip(l1, l2)
<zip object at 0x03501B48>
>>> print(list(zip(l1, l2)))
[(1, 'x'), (2, 'y'), (3, 'z')]
>>> print(list(zip(l1,l3)))
[(1, 'x'), (2, 'y')]
>>> print(dict(zip(l1,l3)))
{1: 'x', 2: 'y'}

实际上zip方法支持所有可迭代对象（字符串、列表、元祖、字典), 而不仅仅是列表。利用这个特性，我们可以很容易创建各种字典，包括很复杂的字典。我们来看下面2个经典例子。注意zip对象支持直接遍历哦，不需要先转成list或dict哦。

 

>> > l1 = [1, 2, 3]
>> > str1 = "abc"
>> > print(dict(zip(l1, str1)))
{1: 'a', 2: 'b', 3: 'c'}
>> > name = ["John", "Jim", "Lucy"]
>> > year = [1983, 1985, 1995]
>> > birth_year = dict(zip(name, year))
>> > print(birth_year)
{'John': 1983, 'Jim': 1985, 'Lucy': 1995}
>> > for name, year in zip(name, year):
    print("{} - {}".format(name, year))

John - 1983
Jim - 1985
Lucy - 1995

利用zip(*some_list)方法可以实现元组列表的反向解压，见下面案例。注意unzip只支持元组列表，不支持dict直接解压哦。这也是面试常考内容。

>>> l1 = [("John", 1995), ("Lucy", 2000), ("Max", 1985)]
>>> name = zip(*l1)
>>> print(name)
<zip object at 0x03501D78>
>>> l1 = [("John", 1995), ("Lucy", 2000), ("Max", 1985)]
>>> name, year = zip(*l1)
>>> print(name)
('John', 'Lucy', 'Max')
>>> print(year)
(1995, 2000, 1985)
>>> l2 = dict(l1)
>>> print(l2)
{'John': 1995, 'Lucy': 2000, 'Max': 1985}
>>> name1, year1 = zip(*l2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

enumerate() 函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，常见用于for循环。一般只有需要同时用到索引index和value值的时候才用enumerate方法。注意直接使用enumerate方法生成是个enumerate对象，可以遍历的。

>> > name = ["John", "Lucy", "Mary"]
>> > name1 = enumerate(name)
>> > print(name1)
< enumerate object at 0x030D0FA8 >
>> > for index, name in enumerate(name):
    print("{}-{}".format(index, name))

0 - John
1 - Lucy
2 - Mary

map函数

map函数是个非常有用的方法，其语法是 map(function, iterable, ...)。map方法可以接收函数作为参数，并将其映射于列表的多个元素。python 2中返回列表，python 3中返回迭代器，需要使用list方法再生成列表。map函数不仅支持自定义的函数和lambda函数，还支持python自带的函数。

 

下面是map函数应用一个最简单的例子。该例子将计算平方的lambda函数映射于列表中的每个元素。

>>> l = map(lambda x: x**2, [1, 2, 3, 4,5])
>>> print(l)
<map object at 0x03502370>
>>> print(list(1))
[1, 4, 9, 16, 25]

map函数还支持多个列表的映射和计算，如下所示。lambda函数中的x, y, z分别对应列表l1, l2和l3中的元素。计算后的生成的列表长度取决于各个列表的最短长度。

>>> l1 = [1, 2, 3]
>>> l2 = [4, 5, 6, 7]
>>> l3 = [8, 9]
>>> print(list(map(lambda x,y,z: x+y*z, l1, l2, l3)))
[33, 47]

我们下面来看下一道关于map函数的经典考题。我们有两个字符串A和B，现在要统计字符串A中有多少个字符也在字符串B中可以找到。常规函数解法如下:

字符也在字符串B中可以找到。常规函数解法如下:

>>> strA = "aAAAbBCC"
>>> strB = "aA"
>>> def count1(str1, str2):
   a = 0
   for c in str1:
      if c in str2:
         a += 1
   return a

>>> count1(strA, strB)
4

使用map函数经典解法如下，是不是好简单好牛叉的样子?

>>> strA = "aAAAbBCC"
>>> strB = "aA"
>>> print(sum(map(strA.count, strB)))
4

我们现在来分析下上面这段代码。python自带的string.count(char)函数的作用是统计一个字符串string含有字符char的数量。在本例中strB相当于char的一个参数列表["a", "A"], map函数先统计strA中字符a的数量，再统计strA中字符A的数量，获得列表[1, 3], 然后将它们相加，即可获得字符串A中总共有多少字符可以在B中找到。

reduce函数

reduce() 函数会对参数序列中元素进行累积。该方法第一个参数必需是函数，而且传入的函数必需要有2个参数，否则出现错误。该方法将一个数据集合（列表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

reduce函数很适合连续计算(比如列表求和或连乘计算阶乘)，经典代码如下。

>>> from functools import reduce
>>> reduce(lambda x, y: x+y, [1,2,3,4,5])
15
>>> reduce(lambda x,y:x*y,range(1,5))
24

注意: python 3中reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 fucntools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数。

 

filter函数

Python的 filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。该方法与map和reduce类似，第一个参数都是函数，作用于可以迭代的对象比如列表和元组，但不同的是filter方法传入的函数是判断性函数, 只有符合条件的列表元素才会加入新的列表。Python 2中返回列表，python 3中返回filter对象，使用list方法可以转化为列表。

下面是使用filter方法打印出10以内偶数的经典代码。只有满足x % 2 == 0 的列表元素才会加入新的列表。

>>> l = filter(lambda x: x % 2 == 0, range(10))
>>> print(l)
<filter object at 0x02C0BBF0>
>>> print(list(l))
[0, 2, 4, 6, 8]

下面这段代码利用filter方法删除字符串列表里的空白字符串。只有满足s and s.strip() = True的字符串才会加入新的列表。

def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

最好一道是关于filter方法的经典面试题，利用filter方法筛选出一个列表中的素数。网上大多数代码都不完美，一是不能对小于等于2的数(包括0, 1和2)做出准确判断，二是使用了for i in range(2, n+1)，做了很多无效循环。

>>> import math
>>> def isPrime(n):
       if n <= 1:
          return False
       elif n == 2:
          return True
       else:
          for i in range(2, int(math.sqrt(n))+1):
             if n%i == 0:
                return False
          return True

>>> l1 = [-1, 0, 2, 3, 6, 7, 8]
>>> l2 = list(filter(isPrime, l1))
>>> print(l2)
[2, 3, 7]

 

小结

本文详细总结了python的列表表达式及常用高阶函数如lambda, zip, map, enumerate, reduce, filter的用法。你学了吗？看懂的点个赞，没看懂的留个言啊。