编程语言里面有几个有趣的函数

众所周知，python功能强大、语法灵活，这些得益于其丰富而强大的库。除了众多第三方库和方法函数，python自带的很多函数也非常有趣，用起来称得上优雅。

要是分享5个python内置的小函数，都是个人觉得强大而精致的几个函数。不是高深的知识，纯粹因为觉得好用而分享。

01 一用而过：lambda

很多语言都有匿名函数，python的匿名函数写作lambda，当需要实现一定功能而又不想“大张旗鼓”的def一个函数时，lambda就是最优的选择。

其语法格式一般是这样的：

1. lambda x:x**2 
2. # <function __main__.<lambda>(x)> 

也可以将它赋值给一个变量，由于python中一切皆对象，所以后续程序中就可以用该变量调用这个匿名函数。

1. f = lambda x:x**2 
2. f(2) 
3. # 4 

当然，这里其实没必要应用lambda来实现，因为既然要显式调用，还不如干脆直接写个明确的函数罢了。lambda函数更广泛的应用场景在于该匿名函数作为另一个函数的参数传递时，应用就比较合适了，例如，将lambda作为sort()函数的key参数，就可以实现特定功能的排序。

1. dyct = {'a':2, 'b':1, 'c':5} 
2. sorted(dyct.items(), key = lambda x:x[1]) 
3. # [('b', 1), ('a', 2), ('c', 5)] 

02 智能解压：zip

zip函数人如其名，是打包或者解包的函数，接受2个以上可迭代变量，输出对应位置组成元组后的迭代类型。例如：

1. a = ['a', 'b', 'c'] 
2. b = (4, 5, 6) 
3. zip(a,b) 
4. # <zip at 0x1da016d15c8> 
5. list(zip(a,b)) 
6. # [('a', 4), ('b', 5), ('c', 6)] 
7. tuple(zip(a,b)) 
8. # (('a', 4), ('b', 5), ('c', 6)) 

也可以接受多于2个输入可迭代变量，而且如果各迭代变量长度不一致也不会报错，只是此时返回迭代变量取决于输入总长度最短的一个。例如：

1. a = ['a', 'b', 'c', 'd', 'e'] 
2. b = (4, 5, 6, 7) 
3. c = [True, False, True] 
4. list(zip(a,b,c)) 
5. # (('a', 4, True), ('b', 5, False), ('c', 6, True)) 

与zip打包相对应的用法是解包，即对一个打包形式的元素进行依次解包，并返回多个新的列表。例如：

1. aZip = (('a', 4, True), ('b', 5, False), ('c', 6, True)) 
2. a, b, c = zip(*aZip) 
3. # a:('a', 'b', 'c') 
4. # b:(4, 5, 6) 
5. # c:(True, False, True) 

03 一一映射：map

map函数也正如其取名一样，是一个将接受的迭代变量依次经过某种映射，并输出映射后的迭代变量。例如，如果对列表中的某个变量依次完成求值，并返回一个新的列表，则可以应用map：

1. a = [1, 2, 3, 4] 
2. map(str, a) 
3. # <map at 0x1da017136d8> 
4. list(map(str, a)) 
5. # ['1', '2', '3', '4'] 

这是map函数的一个典型用法：接受2个参数，第一个参数(上例中是str()函数)是一个要作用的函数，第二个参数是可迭代变量。

当第一个函数的参数是是一个多变量函数时，map也可以接受更多的参数。例如：

1. a = [1, 2, 3, 4] 
2. b = [2, 2, 3, 3] 
3. list(map(lambda x, y:x**y, a, b)) 
4. # [1, 4, 27, 64] 

与zip函数中类似，当map里的函数参数长度不匹配时并不会报错，只是输出结果将由最短的决定：

1. a = [1, 2, 3, 4] 
2. b = [2, 2] 
3. list(map(lambda x, y:x**y, a, b)) 
4. # [1, 4] 

04 一夫当关：filter

与map函数类似，filter函数也接受一个函数及其变量作为参数，只是要求这个函数的返回结果是bool型，并用这个bool的结果决定输出的取舍问题。例如需要对一个输入列表过滤，要求保留3的倍数：

1. a = range(10) 
2. filter(lambda x:x%3==0, a) 
3. # <filter at 0x1da0171c0f0> 
4. list(filter(lambda x:x%3==0, a)) 
5. # [0, 3, 6, 9] 

这里需注意，当filter的第一个函数返回值不是bool型时不会报错，只是它会转化为bool型判断，如果判断结果不是False(python中会判为False的变量包括0、None、[]等等)，则会将其输出，否则过滤掉：

1. a = range(10) 
2. list(filter(lambda x:x%3, a)) 
3. # [1, 2, 4, 5, 7, 8] 

05 万剑归宗：reduce

map和filter函数都是多入多出型，实质上是完成了特定的变换或筛选。reduce则是归约函数，将一系列输入变量经过特定的函数后转化为一个结果输出。不过可能是由于应用场景有限的原因，reduce在python3中已不再是全局调用函数，必须要从functools包中导入方可使用：

1. from functools import reduce 
2. a = range(5) 
3. reduce(lambda x, y: x+y, a) 
4. # 10 

reduce函数还可以接受一个可选的初始值作为参数。应用reduce函数可以实现很多小trick，就看能不能想的到用的出：

1. from functools import reduce 
2. s = 'abcdefg' 
3. reduce(lambda x, y: y+x, s, 'AA') 
4. # 'gfedcbaAA' 

06 最后

当然，尽管几个函数用法不可谓不优美、功能不可谓不强大，但都不是必须的，甚至某种程度上都可以用其他形式加以替代，例如map和filter函数都可以用列表推导式来简单实现，reduce函数功能也顶多用一个for循环迭代就能解决。

但在致力于使python程序变得更加简洁优雅乃至耍秀的路上，这些函数也确有其用武之地，未尝不值得一试!

高级语言的出现使得计算机程序设计语言不再过度地依赖某种特定的机器或环境。这是因为高级语言在不同的平台上会被编译成不同的机器语言，而不是直接被机器执行。最早出现的编程语言之一FORTRAN的一个主要目标，就是实现平台独立。