09-高阶函数

map()函数

• 格式：map(func,lsd)
  • func:可以是一个python内置函数，也可以是我们的自己定义的函数
  • lsd:必须是一个序列，也可以说是一个容器
  • 功能: lsd这个容器里边的数据，会依次作用在前边的func上
  • map() 函数生成的是一个惰性序列，可以用类型转换成为序列，也可以用多个变量接收

# str1 = ["1","3","5","8","2","4"]
# print(str1)
# # print(int(str1))
# map1 = map(int,str1)
# # int("1")  int("3") int("5")  int("8")   int("2")  int("4")
# #map是一个惰性序列
# print(list(map1))

def func(value):
    dict = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,}
    return dict[value]
res = func("1")
print(res,type(res))
map1 = map(func,str1)
#把str1里边的所有元素依次赋值给前边的func函数
print(list(map1))

例2：
list1 = [1,4,2,6,3,4,7,9]
dict = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,}
dict1 = {}
for key,value in dict.items():
    dict1[value] = key
# print(dict1)

def func(key1):
    dict = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,}
    dict1 = {}
    for key, value in dict.items():
        dict1[value] = key
    return dict1[key1]

map1 = map(func,list1)
print(list1)
print(list(map1))

reduce()函数

• 格式：reduce(fn,lsd)
  • fn:一个函数 但是这个函数必须有两个参数
  • lsd:是一个序列 也可以说是一个容器
  • 功能: 把容器里边的前两个元素作用在 fn 上，然后得出的结果再和容器里边的第三位数作用在fn上，一直到容器里边的所有元素全部计算完毕
• reduce() 函数在 functools 库中，需要 reduce 函数时需要先调用 functools 库

lsd = [1,2,3,4,5,6]
fn(fn(fn(fn(fn(1,2),3),4),5),6)

lsd = {1,3,6,4,5,8,7,2}
def func(a,b):
    return a*10 + b
res = reduce(func,lsd)
print(res,type(res))
# 相当于：
# func(1,3) ===> 13
# func(func(1,3),6) == func(13,6) == 136
# func(func(func(1,3),6),4) == func(func(13,6),4) = func(136,4) = 1364 ......

# lsd = "241356"  转换成 241356，不可用int、list等函数
# 利用 map() 函数把字符串转化为int型列表 
lsd = "241356"
dict1 = {"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,0:"0"}
def func1(key1):
    return dict1[key1]
res1 = list(map(func1,lsd))
# 利用 reduce() 函数把int型列表组合成int型数据
def func2(num1,num2):
    return num1 * 10 + num2
res2 = reduce(func2,res1)
print(res2,type(res2))

sorted函数

• 格式：sorted(lsd,key,reverse)
  • 用来排序的函数,参数必须是一个序列
  • lsd：一个序列
  • key：作用的函数，序列中的数值依此作用到函数上，得出的序列再进行排序
  • reverse：排序的方式，默认值为False，为升序排列；True为倒叙排列
  • 注意：key=函数，reverse=True

# 1.默认按照升序排列
# 整型和浮点型默认按照从小到大排序
# list1 = [1,2.3,5,7,3,9,0]
list1 = [-1,-2,-5,-3,1,2,3]
print(list1)
list2 = sorted(list1)
print(list2)

# 字符串按照ascii码排序
str1 = "a额bc啊d哦"
print(str)
str2 = sorted(str1)
print(str2)

# 2.通过参数设置进行降序排列
list3 = [1,-3,4,7,5,2,9,0]
print(list3)
list4 = sorted(list3,reverse=True)
print(list4)

# 通过绝对值降序排序
list5 = [1,3,4,-9,-8,6,7]
print(list5)
list6 = sorted(list5,key=abs,reverse=True)
print(list6)

# 列表中的字符串排序
list7 = ["1231","asdfaf","galifaifaoiflf","alsjflaj"]
print(list7)
# 按照字符串由短至长排序
list8 = sorted(list7,key=len)
print(list8)
# 按照字符串由长至短排序
list9 = sorted(list7,key=len,reverse=True)
print(list9)

filter()函数

filter(fn,lsd)
fn：一个函数
lst:一个序列
功能:过滤，判断序列中的数据依此作用在前面函数时返回的bool值，如果True，返回这个数值，如果为False，过滤掉这个数值

# lsd = [1,2,3,4,5,6,7,8,9]
#
# def func(key):
#     if key % 2 == 0:
#         return True
#     else:
#         return False
#
# #filter 同样是一个惰性序列
# res = filter(func,lsd)
# print(list(res))

lambda匿名函数

lambda表达式是一种简洁格式的函数。该表达式不是正常的函数结构，而是属于表达式的类型。 基本格式：

lambda 参数,参数...：函数功能代码
如：lambda x,y:x + y    获取2个值的和的lambda函数

带分支格式:

lambda 参数,参数... :值1  if 条件表达式  else 值2
如：lambda sex : '有胡子' if sex == 'man' else '没胡子'

调用函数格式：

lambda 参数,参数...:其他函数(...)
如：lambda x:type(x)

lambda表达式的优缺点:

优点：
    书写简单不需要def关键字
    不需要费脑子想函数名(匿名函数)看起来高大上！

缺点：
    lambda表达式功能受限，无法使用循环和多项分支
    复杂的操作，不适合lambda表达式

示例

#方式1.声明一个简单的lambda表达式
mylamb = lambda x,y:x+y
#调用函数
result = mylamb(4,5)
print(result)

#方式2.声明一个带有分支的lambda表达式
mylamb= lambda sex : '有胡子' if sex == 'man' else '没胡子'
#调用函数
result = mylamb('woman')
print(result)

#方式3.声明一个调用函数的lambda表达式
mylamb = lambda x:type(x)
#调用函数
result = mylamb('拾元')
print(result)

小试牛刀

需求：
    有列表["1","4","7","3","2","6","5","8","9"]
    1、求出这个列表由所有偶数组成的最大整数
    2、求出这个列表由所有奇数组成的最小奇数

lsd = ["1","4","7","3","2","6","5","8","9"]

#把字符串变成整型
dict1 = {"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9,}
str1 = lambda str0:dict1[str0]
i = list(map(str1,lsd))
print(i)
#过滤掉所有奇数
j = lambda i:i if i % 2 == 0 else 0
j1 = list(filter(j,i))
print(j1)
#降序排序
j1 = sorted(j1,reverse = True)
print(j1)
#将数据进行整合
a1 = lambda a,b:a*10+b
s = reduce(a1,j1)
print(s,type(s))