四大高阶函数

目录

1. 匿名函数

2. 三元运算

3. 高阶函数

1. 匿名函数

　　在我们需要一个函数但又不想费神的去命名一个函数的场合下使用，这就是匿名函数

f = lambda x,y,z:x+y+z
def F(x,y,z):
    return x+y+z

f = lambda x:x if x % 2 != 0 else x + 100
print(f(10))                    # 1100

1. lambda只是一个表达式，函数体比def简单很多。
2. lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
3. lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
4. 格式：lambda的一般形式是关键字lambda后面跟一个或多个参数，紧跟一个冒号，之后是一个表达式。

f = lambda x,y,z:x+y+z
print(f(1,2,3))                    # 6

my_lambda = lambda arg : arg + 1
print(my_lambda(10))                # 11

2. 三元运算

　　三元运算就是在赋值变量的时候可以直接加判断，然后赋值

1. 三元运算格式：  result=值1 if x<y else 值2    if条件成立result=1,否则result=2
2. 作用：三元运算，又称三目运算，主要作用是减少代码量，是对简单的条件语句的缩写

name = 'Tom' if 1 == 1 else 'fly'
print(name)
# 运行结果： Tom

f = lambda x:x if x % 2 != 0 else x + 100
print(f(10))                    # 110

name = 'Tom' if 1 == 1 else 'fly'
print(name)
# 运行结果： Tom

如果条件成立，if 前面的效果实现

3. 高阶函数

　　map

　　　　第一个参数接收一个函数名，第二个参数接收一个可迭代对象

　　　　利用map，lambda表达式将所有偶数元素加100

# -*- coding:utf8 -*-
l1= [11,22,33,44,55]
ret = map(lambda x:x-100 if x % 2 != 0 else x + 100,l1)
print(list(ret))
# 运行结果： [-89, 122, -67, 144, -45]

# lambda x:x-100 if x % 2 != 0 else x + 100
# 如果 "if x % 2 != 0" 条件成立返回 x-100
# 不成立：返回 x+100
def F(x):
    if x%2 != 0:
        return x-100
    else:
        return x+100
ret = map(F,l1)
print(list(ret))

map（）函数

格式：map(func, iter)

说明：
    接收两个参数：一个函数和一个可迭代对象
    返回值：返回一个生成器
    生成器内容是将func依次作用域iter每个元素的处理结果

def func(x):
    return x * x
print map(func,[1,2,3,4,5]) 

注解：
1.list里的每个元素都会走一遍f(x)方法
2.输出结果是[1,4,9,16,25]

　　filter

　　　　filter()函数可以对序列做过滤处理，就是说可以使用一个自定的函数过滤一个序列，把序列的每一项传到自定义的过滤函数里处理，并返回结果做过滤。

　　　　最终一次性返回过滤后的结果。

　　　　filter()函数有两个参数：

　　　　　　第一个，自定函数名，必须的

　　　　　　第二个，需要过滤的列，也是必须的

　　　　利用 filter、lambda表达式 获取l1中元素小于33的所有元素 l1 = [11, 22, 33, 44, 55]

l1= [11,22,33,44,55]
a = filter(lambda x: x<33, l1)
print(list(a))

#上面lambda表达式换成函数形式如下：
def F(x):
    if x<33:
        return x
b = filter(F,l1)
print(list(b))

filter( )函数

格式：filter(func, iter)

说明：
    参数是一个函数和一个可迭代对象
    返回一个生成器
    将func依次作用于iter中的元素，返回值为真的将会保留，为假的将会过滤掉

lt = [1, 2, 3, 4, 5]

# 提取偶数
f = filter(lambda x: x%2==0, lt)
print(list(f))

注解：lt中数据会走一遍匿名函数就是除以2余数为零，然后filter过滤符合要求（偶数）的打印出来，不符合要求的过滤掉 

输出结果为 2,4

　　reduce

　　　　字符串反转

# -*- coding:utf8 -*-
'''使用reduce将字符串反转'''
s = 'Hello World'
from functools import reduce

result = reduce(lambda x,y:y+x,s)
# # 1、第一次：x=H,y=e  => y+x = eH
# # 2、第二次：x=l,y=eH  => y+x = leH
# # 3、第三次：x=l,y=leH  => y+x = lleH
print( result )      # dlroW olleH

reduce（）函数

格式：reduce(func, iter)

说明：
    接收两个参数，一个函数和一个可迭代对象
    首先取前两个元素作为func的参数，计算完的结果与第三个元素继续使用func处理，直至结束
    返回处理的最后结果

from functools import reduce

lt = [1, 2, 3, 4, 5]

# 求和
# s = reduce(lambda x,y: x+y, lt)
# 转换为12345
s = reduce(lambda x,y: x*10+y, lt)
print(s)

输出结果为12345

　　sorted

　　　　经典面试题 列表排序

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
print( sorted(students, key=lambda s: s[2], reverse=False) )    # 按年龄排序
# 结果：[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

def f(x):
    # ('john', 'A', 15)
    return x[2]
print( sorted(students, key=f, reverse=False) )    # 按年龄排序

　　对字典的value排序

d = {'k1':1, 'k3': 3, 'k2':2}
# d.items() = [('k1', 1), ('k3', 3), ('k2', 2)]
a = sorted(d.items(), key=lambda x: x[1])
print(a)            # [('k1', 1), ('k2', 2), ('k3', 3)]

　　两个列表变成一个字典

L1 = ['k1','k2','k3']
L2 = ['v1','v2','v3']
print( list(zip(L1,L2)))
# zip(L1,L2) : [('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')]
# dict( [('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')] )  = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

sorted（）函数

sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
    sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
    list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted 语法：
    sorted(iterable[, cmp[, key[, reverse]]])

参数说明：
    iterable -- 可迭代对象。
    cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
    key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
    reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。


print(sorted([1,5，9，8，3]))
输出结果为 [1,3,5,8,9]