匿名函数

一、有名函数

之前定的函数都是有名函数，它是基于函数名使用。

def func():
    print('from func')


func()
func()
func()
print(func)

from func
from func
from func
<function func at 0x10518b268>

二、匿名函数

匿名函数，他没有绑定名字，使用一次即被收回，加括号既可以运行。

语法:

lambda 参数列表 : 表达式

说明

1. 使用lambda关键字创建匿名函数。所谓匿名函数，就是没有名字的函数。
2. 匿名函数冒号后面的表达式有且只能有一个，注意：是表达式，而不是语句。
3. 匿名函数自带return，而return的结果就是表达式的计算后的结果。

匿名函数调用

步骤一：将创建好的匿名函数通过一个变量来去接收。

步骤二：使用变量再去调用匿名函数。

lambda x, y: x+y

<function main.(x, y)>

res = (lambda x, y: x+y)(1, 2)
print(res)

print((lambda: 1 + 1)())

3

2

三、与内置函数联用

匿名函数通常与max()、sorted()、filter()、sorted()方法联用。

salary_dict = {
    'randy': 3000,
    'laowang': 100000,
    'bar': 5000,
    'cheer': 2000
}

3.1 max()

如果我们想从上述字典中取出薪资最高的人，我们可以使用max()方法，但是max()默认比较的是字典的key。

• 首先将可迭代对象变成迭代器对象

• res=next(迭代器对象)，将res当做参数传给key指定的函数，然后将该函数的返回值当做判断依据

def func(k):
    return salary_dict[k]


print(f"max(salary_dict, key=func()): {max(salary_dict, key=func)}")
print(
    f"max(salary_dict, key=lambda name: salary_dict[name]): {max(salary_dict, key=lambda name: salary_dict[name])}")

max(salary_dict, key=func()): (‘laowang‘, 100000)
max(salary_dict, key=lambda name: salary_dict[name]): (‘laowang‘, 100000)

3.2 sorted() 排序

如果我们想对上述字典中的人，按照薪资从大到小排序，可以使用sorted()方法。

1. 首先将可迭代对象变成迭代器对象
2. res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值当做判断依据。

lis = [1, 3, 2, 5, 8, 6]
sorted(lis)
print(f"lis: {lis}")
print(f"sorted(lis,reverse=True): {sorted(lis,reverse=True)}")

lis: [1, 3, 2, 5, 8, 6]
sorted(lis,reverse=True): [8, 6, 5, 3, 2, 1]

print(
    f"sorted(salary_dict, key=lambda name: salary_dict[name]):
    {sorted(salary_dict, key=lambda name: salary_dict[name])}" # 根据value来排序
)

sorted(salary_dict, key=lambda name: salary_dict[name]): [‘cheer‘, ‘randy‘, ‘bar‘, ‘laowang‘]

3.3 map()

如果我们想对一个列表中的工资加薪，可以使用map()方法。

1. 首先将可迭代对象变成迭代器对象
2. res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值作为map()方法的结果之一。

print(list(map(lambda name: salary_dict[name] + 2000, salary_dict)),11)

[5000, 102000, 7000, 4000]

3.4 filter()

如果我们想筛选除薪资小于5000，我们可以使用filter()方法。

filter()工作原理：

1. 首先将可迭代对象变成迭代器对象
2. res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后filter会判断函数的返回值的真假，如果为真则留下。

print(list(filter(lambda i: i[1] < 5000, salary_list)))
print(list(filter(lambda name: salary_dict[name] < 5000, salary_dict)))

[(‘randy‘, 3000), (‘cheer‘, 2000)]

[‘randy‘, ‘cheer‘]

四、自定义sorted方法

def sorted(iter, key=None, reverse=None):
    iter.sort()

    if key:
        # key 是一个函数对象
        lt = []
        lt2 = []
        for i in iter:
            res = key(i)
            lt.append(res)
            lt2.append(i)
        lt.sort()

        lt3 = []
        for i in lt:
            for j in lt2:
                if j[1] == i:
                    lt3.append(j)

        if reverse:
            lt3.reverse()
        return lt3

    if reverse:
        iter.reverse()
    return iter


salary_list = list(salary_dict.items())
print(salary_list) 
print(sorted(salary_list, key=lambda i: i[1], reverse=None))  

五、总结

1. 匿名函数：lambda 参数列表 : 表达式,只可使用一次，一般和内置函数一起连用
2. max()：最大值，其中key参数为函数可以有名函数或匿名函数，都可以使用，key是对匿名函数的结果值获取最大值
3. min(): 最小值，其中key参数为函数可以有名函数或匿名函数，都可以使用，key是对匿名函数的结果值获取最小值
4. sorted: 排序，其中key参数为函数可以有名函数或匿名函数，都可以使用，key是对匿名函数的结果值进行排序
5. map: 数据统一处理，第一个参数为函数地址，第二个参数为可迭代对象，将匿名函数中表达式处理的结果返回，返回是一个对象需要list转换
6. filter: 过滤器， 第一个参数为函数地址，第二个参数为可迭代对象，将匿名函数中表达式过滤满足条件的结果，进行返回返回，返回是一个对象需要list转换

匿名函数

原文：https://www.cnblogs.com/randysun/p/12242694.html