匿名函数与内置函数

语法：
    lambda 参数: 返回值
    lambda :

例如：lambda x,n:x**n 
f = lambda x,n:x**n
f(2,3)
>>>8

注意:
匿名函数需要一次性使用。
匿名函数单独使用毫无意义，它必须配合 “内置函数” 一起使用的才有意义。

# 有名函数
def func():   #func --->内存地址
    return 1
print(func())  # func函数对象 + ()   即调用

# 匿名函数:
# 匿名()， return 已经自动添加了
# lambda 匿名(): return 1
func = lambda : 1
print(func())   # 1

func = lambda : 1
print()

二、内置函数
内置函数：python内部提供的自带的内置方法
如：range,print,len,max,min,sorted,map,filter

max：求最大值 max(可迭代对象)

max内部会将可迭代对象中的每一个值取出，并且进行判断
list1 = [1,2,3,4,5]
print(max(list1))  
>>>5

# 需求: 获取dict1中薪资最大的人的 名字
dict1 = {
    'tank': 1000,
    'egon': 500,
    'sean': 200,
    'jason': 100
}
print(max(dict1, key=lambda x: dict1[x]))
>>>tank

sorted: 默认升序（从小到大） reverse:反转 reverse默认是False

list1 = [10, 2, 3, 4, 5]
print(sorted(list1))
print(sorted(list1, reverse=True))     # reverse=True--> 降序


dict1 = {
    'tank': 100,
    'egon': 500,
    'sean': 200,
    'jason': 50
}
# new_list = ['egon', 'sean', 'tank', 'jason']
new_list = sorted(dict1, key=lambda x: dict1[x], reverse=True)      #联想到for对字典取值都是去的键值
print(new_list)

[2, 3, 4, 5, 10]
[10, 5, 4, 3, 2]
['egon', 'sean', 'tank', 'jason]

map映射

语法：map(函数地址, 可迭代对象) ---> map对象
     map会将可迭代对象中的每一个值遍历取出，并且按照指定的规则映射到一个map对象中，
     可以再将map对象转换成列表/元组。
     注意: 只能转一次。

如：
name_list = ['egon', 'jason', 'sean',  'tank']
map_1 = (map(lambda x : x + '喜欢吃生蚝' if x == 'tank' else x + '_DJB',name_list))
print(map_1)   # map_1 是一个map对象  即<map object at 0x00000177C926FB48>
print(list(map_1))   #转成列表  map_1-->生成器--->用完后，就不能再取了
#print(tuple(list(map_1)))   #是一个空元组

Map
Map会将⼀个函数映射到⼀个输⼊列表的所有元素上。 这是它的规范：
规范
map(function_to_apply, list_of_inputs)
⼤多数时候， 我们要把列表中所有元素⼀个个地传递给⼀个函数， 并收集输出。 ⽐⽅说：
items = [1, 2, 3, 4, 5]
squared = []
for i in items:
squared.append(i**2)
Map可以让我们⽤⼀种简单⽽漂亮得多的⽅式来实现。 就是这样：
items = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, items))
⼤多数时候， 我们使⽤匿名函数(lambdas)来配合map, 所以我在上⾯也是这么做的。 不仅
⽤于⼀列表的输⼊， 我们甚⾄可以⽤于⼀列表的函数！
def multiply(x):
return (x*x)
def add(x):
return (x+x)
funcs = [multiply, add]
for i in range(5):
value = map(lambda x: x(i), funcs)
print(list(value))
# 译者注： 上⾯print时， 加了list转换， 是为了python2/3的兼容性
# 在python2中map直接返回列表， 但在python3中返回迭代器
# 因此为了兼容python3, 需要list转换⼀下
# Output:
# [0, 0]
# [1, 2]
# [4, 4]
# [9, 6]
# [16, 8]

reduce合并

from functools import reduce

    -每次从可迭代对象中获取两个值进行合并，并且可以设置初始值    
    -语法：reduce(lambda x, y: x + y, range(1, 101), 0)
    
# 需求: 求1——100的和
res = reduce(lambda x, y: x + y, range(1, 101), 1000)
print(res)  # 6050

filter过滤

语法：filter(函数地址，可迭代对象）
      filter_obj = filter(lambda x: x, name_list)
      filter会将可迭代对象中的值遍历取出，然后通过判断，把条件成立 “过滤获取”出来的值添加到 filter对象中
    
name_list = ['egon_dsb', 'jason_dsb','sean_dsb', 'tank']    
filter_obj = filter(lambda name: name.endswith('_dsb'), name_list)  #filter_obj是一个filter对象
print(filter_obj)   #<filter object at 0x0000016CC5A5ED48>
print(list(filter_obj))  #转成列表
# print(tuple(filter_obj))  #['egon_dsb', 'jason_dsb', 'sean_dsb']

 zip

zip(*Iterables),zip接受多个可迭代对象

列表并⾏排序
data = zip(list1, list2)
data.sort()
list1, list2 = map(lambda t: list(t), zip(*data))


解压列表
a=[1,2,3,4]
b=[7,8,9,0]
zipped=zip[a,b]
list[zipped]
a2,b2=zip(*zip(a,b))           
print(a==list(a2) and b==list(b2))

注：zip(a,b)是一个可迭代对象
*迭代器结果为（1,7）（2,8）（3,9）（4,0）  #打印时没有逗号，其实本质上是一样的
zip(*zip(a,b))等价于zip(（1,7）,（2,8）,（3,9）,（4,0）)

xxx(*Iterables)的接受参数理解：

接受多个可迭代对象，

迭代器打散后为可以是多个普通元素，也可以是多个可迭代对象