匿名函数lambda,map,filter,reduce,zip
有名函数 下面这种函数定义方式，有函数名的嘛，func就是函数的名字，指向函数代码在内存中的地址，加上括号就可以运行
def func(x,y):
return x+y
print(func) # <function func at 0x005A9540> func就是函数的名字，指向函数代码在内存中的地址
匿名函数 lambda 不要问为什么，匿名函数就叫lambda 记住就可以。中文的释义 就是没有名字的函数，哈哈。英文我也没找到出处。
lambda x,y: x+y # 它代表一个内存地址 <function <lambda> at 0x00270858>
(lambda x,y: x+y)(1,2) # 3， 内存地址加括号，传参数后运行函数，但是一般不这样用的
用lambda 去定义一个过渡的函数，是不是简单很多了。这个通常用在 将函数做成一个‘桥’ 就是短暂的用一下下的时候。通常跟其他函数联合使用。\
匿名函数，由于没有名字，只是一串内存地址，所以它会被Python解释器识别成 垃圾， 运行完了 就会被回收。
一、匿名函数的应用
dic = {'jack':5000,'joe':2000,'sue':6000} # 找出工资最高和最低的人
p1 = max(dic,key = lambda k: dic[k]) # max函数有两个参数，一个可迭代对象，一个key = 函数的内存地址。key的意思是 对于可迭代对象按照key排序后取出最大值
p2 = min(dic,key = lambda k : dic[k])
dic_new = sorted(dic, key = lambda k : dic[k]) # 也是一样，按照key去排序，默认升序）
1.map 函数
l = ['jack','joe','sue']
g= map(lambda name:name+'_l',l) # map 函数有两个参数，前面是函数的内存地址（它决定这如何处理可迭代对象中的每个值），后面是可迭代对象。
print(g) # <map object at 0x005B8BD0> map()返回的是一个可迭代对象。
l = [i.upper() for i in l] # 用列表生成式也是可以做的
2.filter 函数
l = ['jack','joe','sue','bob'] # 留下已e结尾的名字
g = filter(lambda name: name.endswith('e') , l) # filter 函数有两个参数，前面是函数的内存地址（它接收可迭代对象传进来的值，经过运算后，得到True或者False. filter会过滤掉结果为False的可迭代对象的值），后面是可迭代对象
print(g) # <filter object at 0x005B8BD0>
print(list(g)) # ['joe', 'sue']
g = [i for i in l if i.endswith('e')] # 用列表生成式也可以的
3.reduce 函数
reduce 是一个累加操作，不要问为什么reduce 是合并累加的意思，他就是这个意思。在Python 3中，reduce不是内置函数，需要从functools中导入。
from functools import reduce
reduce(lambda x,y: x+y, [1,2,3],10) # 16 其实是从列表中取出一个值，跟初始值合并成一个....，重复操作，最后合并成一个值。初始值可以省略
除了数字的合并，reduce也可以用来做字符串的合并
reduce(lambda x,y: x+y, [‘a','b','c'],'hello') # ‘helloabc’
3.zip 函数
zip()---> print(list(zip(("a", "b","C"), (1,2,3)))) # [('a', 1), ('b', 2), ('C', 3)]
p = {"name":"alex","age":18}
print(list(zip(p.keys(),p.values()))) # [('name', 'alex'), ('age', 18)]
salaries = {
'tom': 3000,
'jack': 122121221,
'rose': 100,
}
k_and_v = zip(salaries.values(), salaries.keys())
print(k_and_v) # <zip object at 0x0000000000C07BC8>
print(max(k_and_v)) # (122121221, 'jack')
#k_and_v是迭代器，因而只能访问一次
# print(min(k_and_v)) #报错了
k_and_v2 = zip(salaries.values(), salaries.keys())
# print(list(k_and_v2)) # [(3000, 'tom'), (122121221, 'jack'), (100, 'rose')]
# print(list(zip(k_and_v2))) #[((3000, 'tom'),), ((122121221, 'jack'),), ((100, 'rose'),)]
# print(list(zip(*k_and_v2))) #[(3000, 122121221, 100), ('tom', 'jack', 'rose')]
print(list(map(list, zip(*k_and_v2)))) #[[3000, 122121221, 100], ['tom', 'jack', 'rose']]
class zip(object)
| zip(iter1 [,iter2 [...]]) --> zip object
|
Return a zip object whose .__next__() method returns a tuple
where the i-th element comes from the i-th iterable argument.
The .__next__() method continues until the shortest iterable in the argument sequence is exhausted and then it raises StopIteration.
返回一个zip对象，其剩余的next__()方法返回一个元组
第i个元素来自第i个可迭代参数。
剩余的next__()方法一直持续到参数序列中最短的可迭代被耗尽，然后它抛出StopIteration。
