Lambda 表达式

匿名函数的定义

在 Python 里有两类函数：

第一类：用 def 关键词定义的正规函数
第二类：用 lambda 关键词定义的匿名函数

Python 使用 lambda 关键词来创建匿名函数，而非def关键词，它没有函数名，其语法结构如下：

lambda argument_list: expression

lambda - 定义匿名函数的关键词。
argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
: - 冒号，在函数参数和表达式中间要加个冒号。
expression - 只是一个表达式，输入函数参数，输出一些值。

注意：

expression 中没有 return 语句，因为 lambda 不需要它来返回，表达式本身结果就是返回值。
匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

def sqr(x):
    return x ** 2


print(sqr)
# <function sqr at 0x000000BABD3A4400>

y = [sqr(x) for x in range(10)]
print(y)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

lbd_sqr = lambda x: x ** 2
print(lbd_sqr)
# <function <lambda> at 0x000000BABB6AC1E0>

y = [lbd_sqr(x) for x in range(10)]
print(y)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]


sumary = lambda arg1, arg2: arg1 + arg2
print(sumary(10, 20))  # 30

func = lambda *args: sum(args)
print(func(1, 2, 3, 4, 5))  # 15

匿名函数的应用

函数式编程是指代码中每一块都是不可变的，都由纯函数的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。
【例子】非函数式编程

def f(x):
    for i in range(0, len(x)):
        x[i] += 10
    return x


x = [1, 2, 3]
f(x)
print(x)
# [11, 12, 13]

【例子】函数式编程

def f(x):
    y = []
    for item in x:
        y.append(item + 10)
    return y


x = [1, 2, 3]
f(x)
print(x)
# [1, 2, 3]

匿名函数常常应用于函数式编程的高阶函数 (high-order function)中，主要有两种形式：

参数是函数 (filter, map)
返回值是函数 (closure)

如，在 filter和map函数中的应用：

filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

odd = lambda x: x % 2 == 1
templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist))  # [1, 3, 5, 7, 9]

map(function, *iterables) 根据提供的函数对指定序列做映射。

m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1))  
# [1, 4, 9, 16, 25]

m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(m2))  
# [3, 7, 11, 15, 19]

除了 Python 这些内置函数，我们也可以自己定义高阶函数。

def apply_to_list(fun, some_list):
    return fun(some_list)

lst = [1, 2, 3, 4, 5]
print(apply_to_list(sum, lst))
# 15

print(apply_to_list(len, lst))
# 5

print(apply_to_list(lambda x: sum(x) / len(x), lst))
# 3.0

作业

怎么给函数编写⽂档？
在定义函数的时候，可以在函数的第一行输入一个字符串，这个字符串就代表了这个函数的注释。
这个对函数的描述被保存在函数的属性里，可以用funcname.__doc__调出来。

def functionname (parameters):
       "函数_文档字符串"
        function_suite
        return [expression]

def funcname():
    """I miss a beautiful girl."""
    ...
    return ...

定义完成后，我们就可以调用这个函数的注解了：

funcname.__doc__

怎么给函数参数和返回值注解？

参数注解就是，在定义函数的时候，参数列表内部的参数后面，加上冒号和要传入的类型，例：

def accumlate(x:int, y:int):
    return x*y

写了参数注解也无法强制限定变量的类型，只能作为提示，来告知使用者应该传入什么类型的参数。

返回值注解就是：

def accumlate(x:int, y:int) -> int:
    return x*y

在参数列表后面，冒号前面，增加一个 -> 后面接返回值的类型。

闭包中，怎么对数字、字符串、元组等不可变元素更新
nonlocal关键字直接更新

def outer():
    num = 10

    def inner():
        nonlocal num  # nonlocal关键字声明
        num = 100
        print(num)

    inner()
    print(num)


outer()

#100
#100

分别根据每一行的首元素和尾元素大小对二维列表 [[6, 5], [3, 7], [2, 8]] 排序。(利用lambda表达式)
a = [[6, 5], [3, 7], [2, 8]]

a = [[6, 5], [3, 7], [2, 8]]

b = sorted(a, key = lambda x:x[0] )
print(b)

# [[2, 8], [3, 7], [6, 5]]

c = sorted(a, key = lambda x:x[1] )
print(c)

#[[6, 5], [3, 7], [2, 8]]

利用python解决汉诺塔问题？
有a、b、c三根柱子，在a柱子上从下往上按照大小顺序摞着64片圆盘，把圆盘从下面开始按大小顺序重新摆放在c柱子
上，尝试用函数来模拟解决的过程。（提示：将问题简化为已经成功地将a柱上面的63个盘子移到了b柱）

汉诺塔的解题步骤（分为两步）：
第一步：
把n-1个模块，从塔a移动到塔b
把第n个模块，从塔a移动到塔c
第二步：
把n-1个模块，从塔b移动到塔c

汉诺塔的原理：
要解决n层的汉诺塔
必须解决n-1层的汉诺塔
…
必须解决1的汉诺塔（塔a -> 塔c）

def hanoi(n,a,b,c): # n层汉诺塔，从a移动到c，中间柱为b
    if (n==1):
        print(a, "-->", c) # 只有一层汉诺塔，从a柱移动到c柱
    else:
        hanoi(n-1,a,c,b) #把n-1个模块，从塔a移动到塔b
        print(a, "-->", c) # 把第n个模块，从塔a移动到塔c
        hanoi(n-1,b,a,c) # 把n-1个模块，从塔b移动到塔c

hanoi(3,'a','b','c')

思路参考：https://www.bilibili.com/video/BV1Hk4y1k7KL?from=search&seid=8381271189889185325

Pytyon Day 7 continue - Lambda

目录

Lambda 表达式

匿名函数的定义

匿名函数的应用

作业

猜你喜欢