Python基础知识点——高阶函数

高阶函数

1、 lambda基本使用

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

3、Map是对序列根据设定条件进行操作后返回他设置的是操作方法

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

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

map()函数用法：

map(function, iterable, …)

功能：

• 将第一个参数 function 依次作用在参数可迭代对象中的每一个元素上，返回包含每次 function 函数返回值的新迭代器
• map() 会根据提供的函数对指定序列做映射。(映射及对应)
• 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

参数：
function – 函数，有两个参数
iterable – 一个或多个可迭代对象（如：序列）

返回值：
Python 3.x 返回迭代器

# demo
def func(x):
    return x*x
ret = map(func, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(ret))

# 运行结果：
[1, 4, 9, 16, 25, 36, 49, 64, 81]

4、reduce函数

使用reduce进行求和运算

1. reduce()函数即为化简函数，它的执行过程为：每一次迭代，都将上一次的迭代结果与下一个元素一同传入二元func函数中去执行。
2. 在reduce()函数中，init是可选的，如果指定，则作为第一次迭代的第一个元素使用，如果没有指定，就取seq中的第一个元素。

from functools import reduce
def f(x, y):	
 return x + y

print(reduce(f, [1, 3, 5, 7, 9]))  # 25
# 1、先计算头两个元素：f(1, 3)，结果为4；
# 2、再把结果和第3个元素计算：f(4, 5)，结果为9；
# 3、再把结果和第4个元素计算：f(9, 7)，结果为16；
# 4、再把结果和第5个元素计算：f(16, 9)，结果为25；
# 5、由于没有更多的元素了，计算结束，返回结果25。

print( reduce(lambda x, y: x + y, [1, 3, 5, 7, 9])  )  # 25

reduce()函数语法

reduce(function, iterable[, initializer])

功能：

• 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第
  1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。 其效果类似：reduce(f,
  [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
• reduce() 函数会对参数序列中元素进行累积。
• 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第
  1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

参数：

function – 函数，有两个参数
iterable – 可迭代对象
initializer – 可选，初始参数

返回值：
返回函数计算结果。

# demo:

from functools import reduce
def add(x, y):
    return x + y
 
r = reduce(add, [1, 3, 5, 7, 9])
print(r)

# 1. 运行结果：
25

5、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))

filter()函数：

filter(function, iterable)

功能

• 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回
  True 的元素放到新迭代器对象中
• filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

参数：

function – 判断函数
iterable – 可迭代对象（如：序列）

返回值：

返回一个迭代器对象

# demo：
def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)

# 运行结果：
[1, 3, 5, 7, 9]

6、sorted函数

sorted对字典排序

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)]

sorted()函数

sorted(iterable, key=abs, reverse=False)

功能:

• 对所有可迭代的对象进行排序操作

参数:

iterable – 可迭代对象。
key – key指定的函数将作用于可迭代对象上的每一个元素，并根据key函数返回的结果进行排序
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）

返回值:
返回重新排序的列表

# demo:

print(sorted([36, 5, -12, 9, -21]))
运行结果：[-21, -12, 5, 9, 36]
print(sorted([36, 5, -12, 9, -21], key=abs))

#abs 匿名函数
运行结果：[5, 9, -12, -21, 36]

返回函数：
高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum        #将定义的函数sum()作为结果值返回
 
f = lazy_sum(1, 3, 5, 7, 9)
f()