Python（9）匿名函数及匿名函数与内置函数的结合

一、匿名函数

匿名函数：简化函数的定义

例如：一个函数只有一行或较少的代码

格式：lambda 参数... : 返回的结果

def add(a, b):
    s = a + b
    return s

s = lambda a, b: a + b
print(s)    #s 是函数function

result = s(1, 2)
print(result)

s1 = lambda a, b: a * b
result = s1(2, 5)
print(result)

匿名函数作为参数

def func(x, y, func):
    print(x, y)
    print(func)
    s = func(x, y)
    print(s)

#调用
func(1, 2, lambda a, b: a + b)

 

二、匿名函数与内置函数的结合使用

max()  最大值函数

list1 = [3, 5, 8, 9, 0]
m = max(list1)  #列表的最大值

list2 = [{"name1":18, "name2":10}, {"name1":13, "name2":20}, {"name1":9, "name2":29}]
#找name1的最大值
m = max(list2, key = lambda x: x['name1'])  #按照字典中 name1取出value，并进行比较
print("列表的最大值：", m)  #找到key 为name1的最大值的字典

map()  遍历列表，并对列表进行操作

list1 = [3, 5, 8, 9, 2]
result = map(lambda x: x + 2, list1)
print(result)  #返回map地址
print(list(result))  #将map中转成列表并输出

#如果数为奇数，则数+1，如果为偶数则直接输出
func = lambda  x : x if x % 2 == 0 else x + 1
result = func(5)
print(result)  #输出：6

#只对列表中的奇数+1
result = map(lambda x : x if x % 2 == 0 else x + 1, list1)
print(list(result))  #输出：[4, 6, 8, 10, 2]
#等价于下方写法
for index, i in enumerate(list1):
    if i % 2 != 0:
        list1[index] = i + 1
print(list1)

reduce()  对列表中的元素进行加减乘除的运算的函数

reduce()  函数，需要先导入包  from functools import reduce

from functools import reduce
tuple1 = (1, 3, 5, 6, 2)
result = reduce(lambda  x, y : x + y, tuple1)   #tuple1将元组中所有元素求和
print(result)

tuple2 = (1,)   #输出：1
result = reduce(lambda x, y: x + y, tuple2, 10)
print(result)   #输出：11

result = reduce(lambda x, y: x - y, tuple2, 10)
print(result)   #输出：9  10-1  初始值放在首位

tuple3 = (1, 3)
result = reduce(lambda x, y: x - y, tuple3)
print(result)   #输出：-2  1-3=-2

filter()  过滤

list2 = [12, 6, 8, 98, 34, 36, 2, 8, 0]
result = filter(lambda x: x > 10, list2)
print(result)
print(list(result))
#等价于
def func_filter(list2):
    list2_new = []
    for i in list2:
        if i > 10:
            list2_new.append(i)
    return list2_new
result = func_filter(list2)
print(result)

#找出所有年龄大于20岁的
students = [
    {"name":"name1", "age":20},
    {"name":"name2", "age":19},
    {"name":"name3", "age":13},
    {"name":"name4", "age":23},
    {"name":"name5", "age":21}
]
result = filter(lambda x : x['age'] > 20, students)
print(list(result))

sorted()  排序

#按照年龄从小到大排序
students = [
    {"name":"name1", "age":20},
    {"name":"name2", "age":19},
    {"name":"name3", "age":13},
    {"name":"name4", "age":23},
    {"name":"name5", "age":21}
]

students = sorted(students, key=lambda x : x['age'])
print(students)

 

三、递归函数

递归函数特点：

1、自身调用自身

2、递归函数必须要设定终点

3、通常都会有入口

例：确定任意数字，从1~n的累加和

def sum(n):  #1~n
    if n == 0:
        return 0
    else:
        return n + sum(n - 1)

result = sum(10)
print(result)
#等价于
sum_number = 0
for i in range(11):
    sum_number += i
print(sum_number)

 

四、函数的总结

匿名函数能够与内置函数结合使用

内置函数包括：max()  min()  sorted()  map()  reduce()  filter()

总结函数：

普通函数：def func() : pass

def 函数名([参数......]):

        函数体

1、如何定义函数

2、调用函数

参数：1）无参数

          def func(): pass

          func()  调用

           2）有参数

          def func(a, b): pass

          func(1, 2)

可变参数：

def func(*args, **kwargs):    *args：单个元素    **kwargs：关键字参数

        pass

func()

func(1)

func(a = 1)

默认值参数：

def func(a = 10, b = 20):

        pass

func()

func(100)

关键字参数：

func(b = 99)

 

返回值：return

没有返回值：

def func():

        print("------")

x = func()  ---> x = None

有返回值：

def func():

        return 'a', 'b'

x = func()    --->('a', 'b')

 

变量的作用域

global  nonlocal

globals() 查看全局变量  locals() 查看局部变量

LEGB

L：local  本地  局部变量

E：encloseing  嵌套

G：global  全局

B：built-in  内置

 

嵌套函数： ——（将内层函数返回）——> 闭包 ——（将函数作为参数传递）——> 装饰器

def func():

        def wrapper():

                pass

        return wrapper

装饰器：

单层装饰器

def decorate():

       def wrapper(*args, **kwargs):

               pass

       return wrapper

@decorate

def house():

        pass

@decorate

def f1(a, b):

        pass

 

多层装饰器

@zhuang1

@zhuang2

def f1(a, b):

        pass

 

装饰器带参数：

def outer(a):

        def decorate(func):

                def wrapper(*args, **kwargs):

                                pass

               return wrapper

        return decorate

@zhuang(10)

def house():

        pass

@zhuang(100)

def street(10000):
        pass

 

匿名函数：lambda 参数 : 返回结果

lambda 参数 : 返回值

 

递归函数：普通函数的一种表现形式

自身调用自身