python高阶函数

lambda函数

例1:传入多个参数的lambda函数

def sum(x,y):
      return x+y

用lambda来实现：

p = lambda x,y:x+y
print(p(4,6))

lambda函数减少了代码的冗余

例2：传入一个参数的lambda函数

a=lambda x:x*x
print(a(3))       # 注意：这里直接a(3)可以执行，但没有输出的，前面的print不能少 

例3：多个参数的lambda形式：

a = lambda x,y,z:(x+8)*y-z
print(a(5,6,8))

匿名函数lambda：是指一类无需定义标识符（函数名）的函数或子程序。
lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。

要点：

1. lambda 函数不能包含命令
2. 包含的表达式不能超过一个。

说明：一定非要使用lambda函数；任何能够使用它们的地方，都可以定义一个单独的普通函数来进行替换。我将它们用在需要封装特殊的、非重用代码上，避免令我的代码充斥着大量单行函数。

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

a=lambda x:x*x
print(a)
print(a(3))
---->
<function <lambda> at 0x0000000002093E18>
9

高阶函数

一个函数可以接收另一个函数作为参数，这种函数称之为高阶函数

传入高阶函数的函数参数都可以用lambda函数表示，这样可以简化def…return的代码

用lambda函数结合高阶函数首先减少了代码的冗余，其次，用lambda函数，不用费神地去命名一个函数的名字，可以快速的实现某项功能，最后，lambda函数使代码的可读性更强，程序看起来更加简洁。

一般的高阶函数的形式

advanced_fun(function,iterable)

第一个参数function接受一个函数名

后面的参数iterable接受一个(有些高阶函数可以传入多个如map)可迭代的序列

return返回的是一个迭代器

注意，必须要用list(advanced_fun(…))才能将其变为列表显示出来，否则是一个迭代器没有办法显示里面的元素。

map函数

map()函数的简介以及语法

map是python内置函数，会根据提供的函数对指定的序列做映射。

map()函数的格式是：

map(function,iterable,...)

• function：映射函数
• iterable： 一个或多个序列

它的作用是把函数依次作用在iterable中的每一个元素上，得到一个新的迭代器并返回。

map()函数实例

通过定义函数的方式传入map()高阶函数

def square(x):
    return x ** 2

map(square,[1,2,3,4,5]) # 注意返回的是一个迭代器
# <map object at 0x000002E9AAEC1550>
list(map(square,[1,2,3,4,5])) # 需要list之后才能返回列表
# [1, 4, 9, 16, 25]

通过使用lambda匿名函数的方法使用map()函数：

list(map(lambda x, y: x+y,[1,3,5,7,9],[2,4,6,8,10]))

[3,7,11,15,19]

注意：如果传入多个序列iterable，前面的函数lambda也必须传入对应序列个数的参数

通过lambda函数使返回元组组成的列表：

list(map(lambda x, y : (x**y,x+y),[2,4,6],[3,2,1]))

[(8,5),(16,6),(6,7)]

fliter函数

filter()函数的简介以及语法

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

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

**filter()**函数的格式是：

filter(function,iterable)

• function – 判断函数（一个表达式，结果只能是True 或 False的表达式，和mysql中的where类似）

• iterable – 可迭代对象，只允许一个序列

filter()函数实例

返回原列表中是3的倍数组成的新列表

list(filter(lambda x:x%3==0,[1,2,3,4,5,6]))

[3,6]

返回原列表中都是小写的字母组成的新列表

list(filter(lambda x:x.islower(),"Alex"))

sorted函数

filter()函数的简介以及语法

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

sorted 语法：

sorted(iterable, key=None, reverse=False)

参数说明：

• iterable – 可迭代对象。
• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。如果不给出key则默认按照可迭代对象中的第一个元素来排序。
• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值：注意sorted与前面高阶函数的区别是：

1. 返回的不是一个迭代器，是返回重新排序的列表。
2. sorted的function相当于key，即按照什么规律排序，所以key是传入一个lambda函数，iterable先于key函数给出

sort 与 sorted 区别：

1. sort 是应用在 list 上的方法，它的应用对象只有list

   sorted 可以对所有可迭代的对象（包括字典，字符串等）进行排序操作。

2. list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，也就是说直接对原列表进行排序

   而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作，即对原列表无影响。

   A = [1,32,4,12]
   sorted(A)
   print(A)
   # [1, 32, 4, 12]
   A.sort()
   print(A)
   # [1, 4, 12, 32]
   

sorted()函数实例

sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作，即对原列表无影响，会保留原列表。

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=[('a',2),('c',1),('b',3),('d',4)]
sorted(L)   # 不给出key元素默认按照元组中的第一位排序
#[('a', 2), ('b', 3), ('c', 1), ('d', 4)]
sorted(L, key=lambda x:x[1])       # 规定key为元素的第二个，则按照元组中的第二位排序
#[('c', 1), ('a', 2), ('b', 3), ('d', 4)]

对字典进行排序

1. 按字典的key排序：

   因为对于字典来说，字典的键是dict.keys()，可以将dict.keys()传入iterable参数

   遍历字典相当于遍历字典的键，所以直接将dict传入iterable也可以，可以省略

第一种：只需要保留key

my_dict = {'zzy':25, 'lby':24, 'zxt':12}
sorted(my_dict.keys())
sorted(my_dict)

# ['lby', 'zxt', 'zzy']

第二种：要保留dict的key和value对，按key排序

这里传入的信息要key和value，所以要用dict_items，这个例子中即dict_items([(‘zzy’, 25), (‘lby’, 24), (‘zxt’, 12)])

那么对于每一次迭代的元素x即传入lambda的参数(‘zzy’, 25)…，按照x的第一个元素排即key，所以key=lambda x:x[0]

sorted(my_dict.items(),key=lambda x:x[0])
# [('lby', 24), ('zxt', 12), ('zzy', 25)]

2. 按字典的value排序：

   字典的键是dict.values()，将dict.keys()传入iterable参数, 这里不能传入dict，因为dict遍历的是key

第一种：只需要保留values

sorted(my_dict.values())
# [12, 24, 25]

第二种：要保留dict的key和value对，按value排序

sorted(my_dict.items(),key=lambda item:item[1])
# [('zxt', 12), ('lby', 24), ('zzy', 25)]

zip()函数和借助*解包

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

zip()的用法是将多个iterable(字符串，元组或列表)相同位置的元素(注意set是无序的，而zip是要按照位置打包的，所以最好不要传入一个set**)归并到一个元组**，返回的也是一个迭代器

压缩zip()语法：

zip(iterable1,iterable2 ...iterable_n)

• iterable1,iterable2 …iterable_n – 一个或多个迭代器，一般传入多个

如果各个iterable 的元素个数不一致，则返回列表长度与最短的对象相同.

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
print(list(zip(a,b,c)))
# 此例中zip会将a，b，c三个iterable中第一个位置的打包成为zip后的一个元素
# 同理三个iterable中第二个位置的打包成为zip后的一个元素
# [(1, 4, 4), (2, 5, 5), (3, 6, 6)]

扩展：zip可以同时打包不同类型iterable（set除外）

a = [1,2,3] 
b = (4,5,6)
c = "abc"
# 列表，元组，字符串都是有位置的iterable，所以都可以传入
d = {7,8,9}
# set是无序的，而zip是按照位置打包的，所以加入set后最后zip的结果不能保证，即最好别用set
print(list(zip(a,b,c)))
# [(1, 4, 'a'), (2, 5, 'b'), (3, 6, 'c')]
print(list(zip(a,b,c,d)))
# [(1, 4, 'a', 8), (2, 5, 'b', 9), (3, 6, 'c', 7)]
# 和预期的7，8，9顺序不一致，因为set无序

*利用 * 号的参数解包操作符，zip(list(iterables))可以更加灵活

解压zip(*)语法：

zip(*[iterable1,iterable2 ...iterable_n])

本质上是利用了函数传参时*的解包操作（不懂的可以再去看 《星号参数的作用》这一篇文章）

传入参数 zip(*[iterable1,iterable2 ...iterable_n])
等效于将整个列表解包成各个iterable并全部传入函数
zip(iterable1,iterable2 ...iterable_n)

• [iterable1,iterable2 …iterable_n] – 一个由多个iterables组成的列表，注意传入的是一个列表进行解包

list(zip(*[(2,3,2),(4,2,4),(6,1,3,4),(2,1,5)]))
# 本质上等效于zip((2,3,2),(4,2,4),(6,1,3,4),(2,1,5))所以得到以下结果
# [(2, 4, 6, 2), (3, 2, 1, 1), (2, 4, 3, 5)]