python基础（函数式编程(高阶函数)map、filter、reduce、lambda匿名函数）

函数式编程
可能习惯了像使用其他对象（字符串、数、序列等）一样使用函数：将其赋给变量，将其作为参数进行传递，以及从函数返回它们。在 Python 中，通常不会如此倚重函数（而是创建自定义对象），但完全可以这样做。 
Python提供了一些有助于进行这种函数式编程的函数：map、filter和reduce。在较新的Python版本中，函数map和filter的用途并不大，应该使用列表推导来替代它们。你可使用map将序列的所有元素传递给函数。
>>> list(map(str, range(10))) # 与[str(i) for i in range(10)]等价
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] 
你可使用filter根据布尔函数的返回值来对元素进行过滤。
>>> def func(x): 
...         return x.isalnum() 
... 
>>> seq = ["foo", "x41", "?!", "***"] 
>>> list(filter(func, seq)) 
['foo', 'x41'] 
就这个示例而言，如果转而使用列表推导，就无需创建前述自定义函数。
>>> [x for x in seq if x.isalnum()] 
['foo', 'x41'] 
实际上，Python提供了一种名为lambda表达式的功能，让你能够创建内嵌的简单函数（主要供map、filter和reduce使用）。
>>> filter(lambda x: x.isalnum(), seq) 
['foo', 'x41'] 
然而，使用列表推导的可读性不是更高吗？
要使用列表推导来替换函数reduce不那么容易，而这个函数提供的功能即便能用到，也用得不多。它使用指定的函数将序列的前两个元素合二为一，再将结果与第3个元素合二为一，依此类推，直到处理完整个序列并得到一个结果。例如，如果你要将序列中的所有数相加，可结合使用reduce和lambda x, y: x+y。
>>> numbers = [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33] 
>>> from functools import reduce 
>>> reduce(lambda x, y: x + y, numbers) 
1161 
当然，就这个示例而言，还不如使用内置函数sum。

实际上，可不使用这个lambda函数，而是导入模块operator中的函数add（这个模块包含对应于每个内置运算符的函数）。与使用自定义函数相比，使用模块operator中的函数总是效率更高。

 

高阶函数满足条件：

1、函数接收的参数是一个函数名

2、函数的返回值是一个函数名

3、满足上述条件任意一个，都可称之为高阶函数

 

map函数

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，处理序列中的每一个元素，返回包含每次 function 函数返回值的新列表，该新列表元素个数及位置与原来一样。

map() 函数语法：

map(function, iterable, ...)

a = [1,2,3,4,5]

b = map(lambda x:x**2, a)

print(list(b))

 

reduce函数

reduce() 函数会对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

reduce() 函数语法：

reduce(function, iterable[, initializer])

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

from functools import reduce

实例：

from functools import reduce

def add(x,y):

     return x + y

print(reduce(add, range(1, 101)))

输出结果为：

5050

 

filter函数

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

filter() 方法的语法:

filter(function, iterable)

实例：

过滤出列表中的所有奇数：

def is_odd(n):

     return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print(newlist)

输出结果为：

[1, 3, 5, 7, 9]

实例：

过滤出1~100中平方根是整数的数：

import math

def is_sqr(x):

    return math.sqrt(x) % 1 == 0

newlist = filter(is_sqr, range(1, 101))

print(newlist)

输出结果 ：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 

sorted函数

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort方法是应用在 list列表上的方法，返回的是对已经存在的列表进行操作，无返回值。而内建函数 sorted 方法可以对所有可迭代的对象进行排序操作，返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted 语法：

sorted(iterable[, cmp[, key[, reverse]]])

实例

以下实例展示了 sorted 的使用方法：

>>>a = [5,7,6,3,4,1,2] #不同类型之间不能比较，例如字符串和数字

>>> b = sorted(a) # 保留原列表

>>> a

[5, 7, 6, 3, 4, 1, 2]

>>> b

 [1, 2, 3, 4, 5, 6, 7]

------------------------------------------------------------------------------------------

>>> L=[('b',2),('a',1),('c',3),('d',4)]

>>> sorted(L, key=lambda x:x[1])

[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

-------------------------------------------------------------------------------------------

>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

>>> sorted(students, key=lambda s: s[2]) # 按年龄排序

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

>>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序

[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

--------------------------------------------------------------------------------------------

a = ('12', '45', '61', '13')

b = sorted(a, reverse=True, key=lambda x:x[1]) #按字符串里的第2位数字大小进行排序

print(b)

 

lambda匿名函数

关键字lambda表示匿名函数，lambda是单一的表达式，而不是语句。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

lambda的设计是为了满足简单函数的场景，仅能够在lambda中封装有限的业务逻辑，这样设计的目的:让lambda纯粹为了编写简单的函数而设计，def则专注于处理更大的业务。这就使它能够出现在一些def不能出现的地方，比如，列表常量中。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x   #冒号前面的x表示函数参数。
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

同样，也可以把匿名函数作为返回值返回，比如：

def build(x, y):
    return lambda: x * x + y * y

另外，lambda表达式是可以嵌套的

>>> action = (lambda x : (lambda y : x + y))
>>> a = action(10)
>>> a(5)
15

这就是一个用lambda实现的闭包，与普通闭包一样，内嵌lambda表达式可以获得上层lambda函数的变量。

 

跳转表(jump table)

lambda的另一种用法是用来编写跳转表,也就是行为列表或字典，能按需执行特定的动作。

>>> key = "get"
>>> {"abc":(lambda : 2 + 2),"bcd" : (lambda : 3 + 3), "get" : (lambda : 4 + 4)}[key]()
8

这样在字典中，每个lambda都留下了一个后续可以调用的函数，通过索引可以取出来，并调用。这就使字段可以成为更加通用的多路分支工具。