Python常用内置函数介绍【filter,map,reduce,apply,zip】

本是古典何须时尚 2022-08-21 01:04 162阅读 0赞

[Python][]是一门很简洁，很优雅的语言，其很多内置函数结合起来使用，可以使用很少的代码来实现很多复杂的功能，如果同样的功能要让C/C++/Java来实现的话，可能会头大，其实Python是将复杂的数据结构隐藏在内置函数中，用C语言来实现，所以只要写出自己的业务逻辑Python会自动得出你想要的结果。这方面的内置函数主要有,filter,map,reduce,apply,结合匿名函数，列表解析一起使用，功能更加强大.使用内置函数最显而易见的好处是:

**1. **速度快，使用内置函数，比普通的PYTHON实现，速度要快一倍左右。相当于C/C++的速度

**2.** 代码简洁

Buildin函数源码链接地址: (感兴趣的可以看看 ^\_^)

[https://hg.python.org/cpython/file/57c157be847f/Python/bltinmodule.c][https_hg.python.org_cpython_file_57c157be847f_Python_bltinmodule.c]

[https://docs.python.org/3.3/library/functions.html][https_docs.python.org_3.3_library_functions.html]

**filter:**

语法:

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  >>> help(filter)  
2.  Help on built-**in** function filter **in** module \_\_builtin\_\_:  
3.    
4.  filter(...)  
5.      filter(function **or** None, sequence) -> list, tuple, **or** string  
6.    
7.      Return those items of sequence **for** which function(item) **is** true.  If  
8.      function **is** None, **return** the items that are true.  If sequence **is** a tuple  
9.      **or** string, **return** the same type, **else** **return** a list.

用途:

用于过滤与函数func()不匹配的值, 类似于SQL中select value != 'a'

相当于一个迭代器，调用一个布尔函数func来迭代seq中的每个元素，返回一个是bool\_seq返回为True的序列

>>>第一个参数: function or None, 函数或None

>>>第二个参数: sequence,序列

说明:

>>>如果第一个参数为function,那么返回条件为真的序列(列表，元祖或字符串)

>>>如果第一个参数为None的话,那么返回序列中所有为True的项目

例1: 要过滤掉所有值为False的列表

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **print** filter(None,\[-2,0,2,'',\{\},()\])     \#输出\[-2,2\],其余的都为False

例2: 过滤某个字母

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> filter(**lambda** x: x !='a','abcd')  
2.  'bcd'

例3: 过滤字母以B开头的人名

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> names = \['Alice','Bob','Smith','David','Barbana'\]  
2.  >>> filter(**lambda** x: x.startswith('B'),names)  
3.  \['Bob', 'Barbana'\]

例4: 过滤fib列表中的奇数，偶数项

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> fib = \[0,1,1,2,3,5,8,13,21\]  
2.  >>> filter(**lambda** x: x%2,fib)   \#实际上等同于x%2 == 1的项才过滤  
3.  \[1, 1, 3, 5, 13, 21\]  
4.  >>> filter(**lambda** x: x%2 ==0,fib)  
5.  \[0, 2, 8\]

例5: 将2-20间所有质数列出来

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> filter(**lambda** x: **not** \[x **for** i **in** range(2,x) **if** x%i == 0\],range(2,20))  
2.  \[2, 3, 5, 7, 11, 13, 17, 19\]

例6: 过滤人名为空的序列

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> names = \['Alice','Jerry','Sherry','Bob','Tom',''\]  
2.  >>> filter(None,names)  
3.  \['Alice', 'Jerry', 'Sherry', 'Bob', 'Tom'\]

例7: 过滤某目录下所有以test.py结尾的文件

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  **import** os,re                                 \#需要的模块  
2.  files = os.listdir(r'D:\\python')             \#列出需要查找的目录的所有文件  
3.  test  = re.compile('test.py$',re.IGNORECASE) \#re.IGNORECASE忽略大小写  
4.  **print** filter(test.search,files)              \#过滤所有满足条件的文件  
5.    
6.  >>>   
7.  \['1test.py', 'test.py'\]

例8: 过滤所有子列表中，单词为'Python'的

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **def** filter\_word(word):  
2.    **try**:  
3.      **return** word != 'Python'  
4.    **except** ValueError:  
5.      **return** False  
6.    
7.  words = \[\['Perl','Python','Shell'\],\['Java','C/C++'\],\['VB','Dephi'\]\]  
8.    
9.  **print** \[filter(filter\_word,word) **for** word **in** words\]  
10. \#用了列表解析的方法

filter的逻辑实现:

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **def** filter(func,seq):  
2.      f\_seq = \[\]                         \#建一个空序列，用于存储过滤后的元素  
3.      **for** item **in** seq:                   \#对序列中的每个元素进行迭代  
4.          **if** func(item):                 \#如果为真的话  
5.              f\_seq.append(item)         \#满足条件者，则加入  
6.      **return** f\_seq                       \#返回过滤后的元素  
7.    
8.  **print** filter(**lambda** x: x> 0,\[-2,0, 2\]) \#对匿名函数进行过滤，返回正值  
9.  >>>  
10. \[2\]

**map:**

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  >>> help(map)  
2.  Help on built-**in** function map **in** module \_\_builtin\_\_:  
3.    
4.  map(...)  
5.      map(function, sequence\[, sequence, ...\]) -> list  
6.    
7.      Return a list of the results of applying the function to the items of  
8.      the argument sequence(s).  If more than one sequence **is** given, the  
9.      function **is** called with an argument list consisting of the corresponding  
10.     item of each sequence, substituting None **for** missing values when **not** all  
11.     sequences have the same length.  If the function **is** None, **return** a list of  
12.     the items of the sequence (**or** a list of tuples **if** more than one sequence).

用途:

>>>对一个及多个序列执行同一个操作，返回一个列表

说明:

1. 返回一个列表，该列表是参数func对seq1,seq2处理的结果集

2. 可以有多个序列,如果函数为None的话，返回一个序列的列表

例1:常规用法

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> map(**lambda** x: x+1,\[1,2,3,4\])  
2.  \[2, 3, 4, 5\]  
3.  >>> map(**lambda** x,y: x+y,\[1,2,3,4\],(10,20,30,40))  
4.  \[11, 22, 33, 44\]  
5.  >>> map(**lambda** x,y: x+y **if** y **else** x+10,\[1,2,3,4,5\],(1,2,3,4))  
6.  \#第一个序列中的第五个元素存在,但在第二个序列中不存在，所以y为False,所以执行5+10  
7.  \[2, 4, 6, 8, 14\]  
8.  >>> map(None,\[1,2,3,4,5\],(1,2))  \#如果是None的话，以None来补齐短序列造成的空缺  
9.  \[(1, 1), (2, 2), (3, None), (4, None), (5, None)\]  
10. >>> names = \['Alice','Jerry','Bob','Barbar'\]  
11. >>> map(len,names)               \#求列表中每个元素的长度  
12. \[5, 5, 3, 6\]  
13. >>> m = \[1,4,7\]  
14. >>> n = \[2,5,8\]  
15. >>> map(None,m,n)  
16. \[(1, 2), (4, 5), (7, 8)\]  
17. >>> **import** operator               \#比较两个列表中元素大小  
18. >>> a = \[1,2,3\]  
19. >>> b = \[0,4,9\]  
20. >>> map(operator.gt,a,b)  
21. \[True, False, False\]

例2: 求0-5之间数，\[本身，平方，立方\],如:元素2，则返回:\[2,4,8\]

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **def** func1(x): **return** x                   \#返回自身  
2.  **def** func2(x): **return** x \*\* 2              \#返回平方  
3.  **def** func3(x): **return** x \*\* 3              \#返回立方  
4.    
5.  funcs = \[func1,func2,func3\]              \#函数列表  
6.    
7.  **for** i **in** range(5):                       \#遍历列表  
8.      **print** map(**lambda** func: func(i),funcs)\#对其中每个元素执行func1(i),func2(i),func3(i)操作

例3: 实现下面的逻辑结构

1.0 \[1,2,3,4,5\]

2.0 \[1,2,3,4,5\]

....

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  foos = \[1.0,2.0,3.0,4.0,5.0\]  
2.  bars = \[1,2,3,4,5\]  
3.    
4.    
5.  **def** test(foo):  
6.      **print** foo,bars  
7.    
8.    
9.  **print** map(test,foos)

例4: 结合map和filter，求0-10之间偶数的平方，汇合成列表

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> map(**lambda** x:x\*\*2, filter(**lambda** x: x%2==0,range(10)))  
2.  \[0, 4, 16, 36, 64\]

例5: 用map函数实现下面的业务逻辑

s = \[50,62,15,76,57,97,82,99,45,23\]  
'''  
Require: print the grade from s as belows:  
grage<60  - E  
grade<70  - D  
grade<80  - C  
grade<90  - B  
grage>90  - A  
'''

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  s = \[50,62,15,76,57,97,82,99,45,23\]  
2.    
3.  **def** grage(x):  
4.      **try**:  
5.          **if** x < 60:  
6.              **return** 'E'  
7.          **else**:  
8.              **if**   x < 70:  
9.                  **return** 'D'  
10.             **elif** x < 80:  
11.                 **return** 'C'  
12.             **elif** x < 90:  
13.                 **return** 'B'  
14.             **else**:  
15.                 **return** 'A'  
16.     **except** ValueError:  
17.         **print** 'Input error, x should be int!'  
18.   
19. li = map(**lambda** x: "\{0\}-\{1\}".format(x,grage(x)),s) \#对输出进行格式化处理  
20.   
21. **for** i **in** li:                                       \#对生成的列表进行遍历  
22.     **print** i  
23.   
24. >>>   
25. 50\-E  
26. 62\-D  
27. 15\-E  
28. 76\-C  
29. 57\-E  
30. 97\-A  
31. 82\-B  
32. 99\-A  
33. 45\-E  
34. 23\-E

map的逻辑实现:

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **def** map(func,seq):  
2.      map\_seq = \[\]                      \#建空序列  
3.      **for** item **in** seq:                  \#对序列中每个元素进行处理  
4.          map\_seq.append(func(item))    \#往空序列中添加func处理过的元素  
5.      **return** map\_seq                    \#返回最后的列表  
6.    
7.  **print** map(**lambda** x: x \* 2,\[1,2,3,4\])  \#\[2,4,6,8\]

**reduce:**

用途:

func为二元函数，将func作用于seq序列的元素，每次携带一对（先前的结果以及下一个序列的元素），连续的将现有的结果和下一个值作用在获得的随后的结果上，最后减少我们的序列为一个单一的返回值：如果初始值init给定，第一个比较会是init和第一个序列元素而不是序列的头两个元素。

说明:

**1.** 在Python3.0里面必须导入functools模块,from functools import reduce

**2.** reduce返回的必然是一个值，可以有初始值.

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  >>> help(reduce)  
2.  Help on built-**in** function reduce **in** module \_\_builtin\_\_:  
3.    
4.  reduce(...)  
5.      reduce(function, sequence\[, initial\]) -> value  
6.    
7.      Apply a function of two arguments cumulatively to the items of a sequence,  
8.      **from** left to right, so as to reduce the sequence to a single value.  
9.      For example, reduce(**lambda** x, y: x+y, \[1, 2, 3, 4, 5\]) calculates  
10.     ((((1\+2)+3)+4)+5).  If initial **is** present, it **is** placed before the items  
11.     of the sequence **in** the calculation, **and** serves as a default when the  
12.     sequence **is** empty.

例子:

>>> reduce(lambda x,y: x+y, \[47,11,42,13\])  
113

其实现过程如下图所示:

![20141117100749371][]

其实现过程等同下面的:

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> **import** operator  
2.  >>> reduce(operator.add,\[47,11,42,13\])  
3.  113

NOTE: ** **

**1.** func()函数不能为None,否则报错

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> reduce(None,\[1,2,3,4\])  
2.  Traceback (most recent call last):  
3.    File "<stdin>", line 1, **in** <module>  
4.  TypeError: 'NoneType' object **is** **not** callable

**2.** func(x,y)只能有两个参数，否则报错:

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> reduce(**lambda** x,y,z: x+y+z, \[1,2,3,4\],9)  
2.  Traceback (most recent call last):  
3.    File "<stdin>", line 1, **in** <module>  
4.  TypeError: <**lambda**>() takes exactly 3 arguments (2 given)

reduce的逻辑实现:

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **def** reduce(func,seq,init=None):  
2.      l\_seq = list(seq)                  \#先转为列表  
3.      **if** init **is** None:                   \#如果初始值  
4.          res = l\_seq.pop(0)  
5.      **else**:  
6.          res = init  
7.    
8.      **for** item **in** l\_seq:  
9.          res = func(res,item)           \#func(res,item)作为结果集传给res  
10.   
11.     **return** res                         \#返回结果集  
12. **print** reduce(**lambda** x,y:x+y,\[1,2,3,4\]) \#结果为10  
13. **print** reduce(**lambda** x,y:x+y,\[1,2,3,4\],10)     \#结果为20,init初始值为10

**apply:**

语法:

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  >>> help(apply)  
2.  Help on built-**in** function apply **in** module \_\_builtin\_\_:  
3.    
4.  apply(...)  
5.      apply(object\[, args\[, kwargs\]\]) -> value  
6.    
7.      Call a callable object with positional arguments taken **from** the tuple args,  
8.      **and** keyword arguments taken **from** the optional dictionary kwargs.  
9.      Note that classes are callable, as are instances with a \_\_call\_\_() method  
10.   
11.     Deprecated since release 2.3. Instead, use the extended call syntax:  
12.         function(\*args, \*\*keywords).

用途:

>>>当一个函数的参数存在于一个元组或者一个字典中时，用来间接的调用这个函数，元组或者字典中的参数按照顺序传递

说明:

**1.** args是一个包含按照函数所需参数传递的位置参数的一个元组，假如func(a=1,b=2),那么这个元组中就必须严格按照这个参数的位置顺序进行传递(a=3,b=4)，而不能是(b=4,a=3)这样的顺序

**2.** kwargs是一个包含关键字参数的字典，而其中args如果不传递，kwargs需要传递，则必须在args的位置留空

**3.** apply函数的返回值就是func函数的返回值.

**4.** 其实apply(func,args,kwargs)从Python2.3开始，已经被func(\*args,\*\*kwargs)代替了.

例1： 常规使用

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **def** func1():               \#无参函数  
2.    **print** 'No Args!'  
3.    
4.  **def** func2(arg1,arg2):      \#两个参数  
5.    **print** arg1,arg2  
6.    
7.  **def** func3(arg1=1,arg2=2):  \#带字典函数  
8.    **print** arg1,arg2  
9.    
10. **if** \_\_name\_\_=='\_\_main\_\_':  
11.   apply(func1)  
12.   apply(func2,('Hello','World!'))  
13.   apply(func3,(),\{ 'arg1':'This is param1','arg2':'This is param2'\})  \#注意元祖参数为()

既然可以用func(\*args,\*\*kwargs)来代替apply().那么apply有什么好处呢，几个看得见的好处，

**1. **如果函数名，变量名太长的话，用apply()还是很方便的.

**2.** 如果不能确认有多少变量在args里面时，则必须使用apply,她能动态加载变量，及函数

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  \# Sorry about the long variable names ;-)  
2.    
3.  args = function\_returning\_list\_of\_numbers()  
4.  func = function\_returning\_a\_function\_which\_operates\_on\_a\_list\_of\_numbers()  
5.    
6.  \# You want to do f(arg\[0\], arg\[1\], ...) but you don't know how many  
7.  \# arguments are in 'args'.  For this you have to use 'apply':  
8.    
9.  result = apply(func, args)

**3. **如果函数名作为一个对象来传递时，用apply()很方便

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  **def** test(f,a,b):  
2.      **print** 'test'  
3.      **print** f(a,b)  
4.    
5.  test(func,a,b)  
6.  \#可以看出,test函数的第一个参数f就是一个函数对象。我们将func传递给f,  
7.  \#那么test中的f()所做的实际上就是func()所实现的功能  
8.  \#这样，我们就大大提供了程序的灵活性。假如我们我们有另外一个函数取代func,就可以使用相同的test函数  
9.  test(**lambda** x,y: x \*\* 2 + y,2,3)  
10.   
11. >>>   
12. test  
13. 7

**zip**

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  >>> help(zip)  
2.  Help on built-**in** function zip **in** module \_\_builtin\_\_:  
3.    
4.  zip(...)  
5.      zip(seq1 \[, seq2 \[...\]\]) -> \[(seq1\[0\], seq2\[0\] ...), (...)\]  
6.    
7.      Return a list of tuples, where each tuple contains the i-th element  
8.      **from** each of the argument sequences.  The returned list **is** truncated  
9.      **in** length to the length of the shortest argument sequence.

用途:

>>>返回一个元祖列表，该元祖按顺序包含每个序列的相应元素，以最小的一个为准

说明:

>>>这个内置函数其实比较好理解，返回的对象就是一个元祖列表，看例子就好明白

例子:

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  >>> zip(range(5),range(1,20,2))  
2.  \[(0, 1), (1, 3), (2, 5), (3, 7), (4, 9)\]  
3.  >>> x=(1,2,3); y=(4,5);z=(6,)  
4.  >>> zip(x,y,z)  
5.  \[(1, 4, 6)\]

zip的逻辑实现:

**\[python\]**  [view plain][]  [copy][view plain]

[print][view plain] [?][view plain]

1.  **def** zip(\*iterables):  
2.      \# zip('ABCD', 'xy') --> Ax By  
3.      sentinel = object()  
4.      iterators = \[iter(it) **for** it **in** iterables\]  
5.      **while** iterators:  
6.          result = \[\]  
7.          **for** it **in** iterators:  
8.              elem = next(it, sentinel)  
9.              **if** elem **is** sentinel:  
10.                 **return**  
11.             result.append(elem)  
12.         **yield** tuple(result)

可以参看这个综合例子:

http://www.360doc.com/content/14/0507/11/7821691\_375450523.shtml

http://my.oschina.net/cloudcoder/blog/226461

[Python]: http://lib.csdn.net/base/11
[https_hg.python.org_cpython_file_57c157be847f_Python_bltinmodule.c]: https://hg.python.org/cpython/file/57c157be847f/Python/bltinmodule.c
[https_docs.python.org_3.3_library_functions.html]: https://docs.python.org/3.3/library/functions.html
[view plain]: http://blog.csdn.net/Jerry_1126/article/details/41143579#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/522460
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/522460/fork
[20141117100749371]: /images/20220731/d9685826ed1f4a3b9df3664bf45e4fde.png