Python高阶函数--map、lambda、reduce、filter、zip
一、map()函数
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把list 的每个元素依次作用在函数 f 上，得到一个新的 list 并返回。 例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list的每个元素都作平方，就可以用map()函数，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算：
def f(x):
return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
输出结果： [1, 4, 9, 10, 25, 36, 49, 64, 81]
注意：map()函数不改变原有的 list，而是返回一个新的 list。 利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。 由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。
任务 假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list： 输入：['adam', 'LISA', 'barT'] 输出：['Adam', 'Lisa', 'Bart']
def format_name(s):
s1=s[0:1].upper()+s[1:].lower();
return s1;
print map(format_name, ['adam', 'LISA', 'barT'])
map（）函数是python内置的高阶函数，对传入的list的每一个元素进行映射，返回一个新的映射之后的list
python3中，map函数返回的是一个map对象，需要list（map(fun,itor)）来将映射之后的map对象转换成列表
二、lambda 函数
python 使用 lambda 来创建匿名函数。
- lambda只是一个表达式，函数体比def简单很多。
- lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
以lambda x: x+1为例，首先，它是一个函数：
def f(x):
return x+1
好，这个函数引用时需要传入一个参数，并且有一个返回值。这个参数一般是for x in L之类的传进来，或者直接调用f(3)。
（1）先看第一个例子
f = lambda x: x**2
print(f(5)) # 25
结果是25，很easy，这里要说明的是lambda x: x**2是一个函数，你如果print(f)的得到的是一个函数的地址，记住它是一个函数。
（2）和append搭配、在for循环内部
for x in range(5):
li.append(lambda x: x**2)
print(li[0](2)) # 4
print(li[1](3)) # 9
注：此处省略li = []的初始化代码，后续一样
li是一个list，但是list里面存的可不是数，而是函数地址，而且是5个x**2的函数，所以无论你是li[0](2)还是li[1](2)，结果都是4。一般情况下不会这样写程序，因为没什么用途。
这里说一下，看过一个程序这样写，猜测原作者是想让li在运算时append的是数据，或者是以为这样可以让li在调用时n的值不随x变，不管这样，这个程序实际效果和上面一样，x本身在变，n = x写不写没有区别，li内部仍然是5个一样的函数的地址。
for x in range(5):
li.append(lambda n=x: n**2)
print(li[0](2)) # 4
print(li[1](3)) # 9
总结一下：lambda在for循环内部，和append搭配时，for循环不是为了给函数传递参数，只是为了生成多个函数。
（3）只和append搭配
li.append(lambda x: x**2)
print(li[0](1)) # 1
print(li[0](3)) # 9
print(li[1](3)) # IndexError: list index out of range
这儿说的是另外一种情况，程序中并没有给出匿名函数lambda的参数，在调用时才会给。而且li仅仅append了一次，所以li内部也仅有一个函数地址。调用时就不会有li[1]这种情况。
补充一种它的变形，说明一下对于这种情况，参数赋初值并无意义。
li.append(lambda x=5: x**2)
print(li[0](1)) # 1
print(li[0](3)) # 9
print(li[1](3)) # IndexError: list index out of range
（4）和append搭配、参数由for循环给出
举个栗子
li.append(lambda :x for x in range(10))
print(next(li[0])()) # 0
print(next(li[0])()) # 1
print(next(li[1])()) # IndexError: list index out of range
此处有大坑，首先你得认出来(lambda :x for x in range(10))这种形式可没有那么简单，这是产生一个生成器最简单的方法，它的返回值是一个generator，所以li内部就存了一个generator。还有此时的函数是没有参数的，等效为：
def f():
return x
有人会说这个函数有什么意义吗，是没什么意义，但是如果return x**2，其实还是有些意义的。
（5）放在[]中、参数由for循环给出
li = [lambda :x for x in range(10)]
print(li[0]()) # 9
print(li[1]()) # 9
这个函数其实不好理解，首先别看成生成器了，跟它没关系。
lambda :x仍然是一个函数（return x），在没有print(li[0]())之前它是不会被执行的，一旦运行print(li[0]())，就会输出x的值，那么x是多少呢，显然x在上一句程序里面已经变成9了，所以结果都是9，这里其实是闭包的问题，想避免这个问题，程序就不能写这么简洁了。
for x in range(5):
def f():
return x**2
li.append(f())# instant run
print(li[0], li[1], li[2], li[3], li[4])
结果是0, 1, 4, 9, 16，是我们想要的，有人会说这儿为什么不把def f()简化一下呢？还真不能简化，比较结果便知：
for x in range(5):
li.append(lambda :x**2) # uninstant run
print(li[0](), li[1](), li[2](), li[3](), li[4]())
#16 16 16 16 16
看到区别了吧，f 是一个函数地址，而 f() 是一个函数被执行后的返回值，所以第一个程序可以得到每次循环的 x 值。
（6）lambda最常用：和map、reduce、filter等结合用
其实lambda最常用的还是和map、reduce、filter这些高级函数结合使用，不过那个时候就把它当做一个函数，而且格式相对固定，具体使用就看高级函数的使用规则，较为简单，就不展开。
#我们原来的函数是这样的 def square_z(x): return xx #现在我们可以写成下面这样（冒号后面的一切都是对输入的操作，然后lambda x会返回结果）：square1=lambda x:xx print(square1(2)) #配合map，filter等lambda能发挥更大作用,一行代码就能打印列表内元素的平方数 print(list(map(lambda x:x*x,[1,2,3,4,5]))) print(list(filter(lambda x:x<3,[1,2,3,4,5])))
三、归纳函数(reduce):
第一个参数是函数名，第二个参数是sequence(序列,像list，tuple，str，set，dict都可以)
效果是这样的:reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
# 提前准备一个函数，计算两数之和 from functools import reduce def add_z(x, y): return x + y # 计算1～10之间数字之和（还是不包含10） r_z = reduce(add_z, range(1, 10)) print(r_z) print("r_z 的类型：%s" % type(r_z))
结果如下：
45 r_z 的类型：<class 'int'>
四、过滤器(filter):
第一个参数是函数名，用于筛选的函数，第二个参数是Iterable（list，tuple，set，dict，str）,返回一个filter且filter属于Iterator
#用于过滤掉一切不需要的东西，下面我们以打印1～10之间的奇数为例说明： from collections import Iterable,Iterator #提前准备一个函数，判断是否为奇数 def odd_z(x): if x%2==1: return True else: return False f=filter(odd_z,range(1,10)) print("f 的类型：%s"%type(f)) print("f 是Iterator：%s"%isinstance(f,Iterator)) try: print(next(f),end='*')#f作为Iterator使用 print(next(f),end='*') except: print("\n结束了") for i in f:#f作为Iterable使用 print(i,end='$')
结果如下：
五、zip函数
zip() 函数用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。
如果各个可迭代对象的元素个数不一致，则返回的对象长度与最短的可迭代对象相同。
利用 * 号操作符，与zip相反，进行解压。
语法：
zip(iterable1,iterable2, ...)
参数说明：
- iterable--一个或多个可迭代对象（字符串，列表，元组，字典）
举例说明
a = [1, 2, 3] b = [4, 5, 6] c = [7, 8, 9] z = zip(a, b, c) print('z值：', list(z)) print('打包a、c列表:', list(zip(a, c))) z = zip(a, b) print('解压z:', list(zip(*z))) # 字典形式 v1 = {1: 11, 2: 22} v2 = {3: 33, 4: 44} v3 = {5: 55, 6: 66} v = zip(v1, v2, v3) print('v值：', list(v)) w = zip(*zip(v1, v2, v3)) print("w值：", list(w)) # 搭配for循环 list1 = [2, 3, 4] list2 = [5, 6, 7] for x, y in zip(list1, list2): print(x, y, '--', x * y)
结果：
/usr/local/bin/python3.9 /Users/chenshifeng/MyCode/PythonCode/SFDSZL/1/a.py z值： [(1, 4, 7), (2, 5, 8), (3, 6, 9)] 打包a、c列表: [(1, 7), (2, 8), (3, 9)] 解压z: [(1, 2, 3), (4, 5, 6)] v值： [(1, 3, 5), (2, 4, 6)] w值： [(1, 2), (3, 4), (5, 6)] 2 5 -- 10 3 6 -- 18 4 7 -- 28 Process finished with exit code 0
