Python、C++ lambda 表达式

Python、C++ lambda 表达式

lambda函数简介

匿名函数lambda：是指一类无需定义标识符（函数名）的函数或子程序。所谓匿名函数，通俗地说就是没有名字的函数，lambda函数没有名字，是一种简单的、在同一行中定义函数的方法。

lambda函数一般功能简单：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。由于其实现的功能一目了然，甚至不需要专门的名字来说明。

lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。

lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的运算结果就是函数的返回值。

python中的lambda函数

语法

在 python 中，lambda函数实际上会返回一个 lambda 对象，基本语法如下：

lambda arg1, arg2, ... : Expr

其中 arg1、arg2 作为函数的输入，即参数列表，Expr 表达式的值作为函数的输出，即返回值。

例：

lambda x, y: x*y

上面的 lambda 表达式接受两个参数，并返回他们的乘积。相当于以下正常定义的函数：

def test_lambda(x, y):
  return x*y

可以看到，对于这种一句话就能表达清楚的函数，使用 lambda 表达式的形式明显要简洁很多。

值得注意的是，虽然 lambda 表达式被称为匿名函数，并且我们通常也不需要它对它命名，但它其实是可以有一个名字的。

def func(x, y, z):
  return x - y + z

func_lambda = lambda x, y, z: x - y + z

print(func(5, 2, 1))
print(func_lambda(5, 2, 1))

这段代码中的 func、func_lambda 函数的使用是完全相同的，上面输出都为 4。

应用

由于 lambda 语法是固定的，其本质上只有一种用法，那就是定义一个 lambda 函数。在实际中，根据这个 lambda 函数应用场景的不同，可以将 lambda 函数的用法扩展为以下几种：

1. 将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数

   这就是我们上面说的给 lambda 表达式命名的做法。例如，执行语句 add = lambda x, y: x+y，定义了加法函数 add，这样就可以直接调用加法函数：执行 add(1,2)，输出为3。

2. 将 lambda 函数赋值给其他函数，从而将其他函数用该 lambda 函数替换

   例如，为了把标准库 time 中的函数 sleep 的功能屏蔽(Mock)，我们可以在程序初始化时调用：time.sleep = lambda x:None。这样，在后续代码中调用 time 库的 sleep 函数将不会执行原有的功能。例如，执行time.sleep(3) 时，程序不会休眠3秒钟，而是什么都不做。

3. 将lambda函数作为参数传递给其他函数

   函数的返回值也可以是函数。例如 return lambda x, y: x+y 返回一个加法函数。这时，lambda 函数实际上是定义在某个函数内部的函数，称之为嵌套函数，或者内部函数。对应的，将包含嵌套函数的函数称之为外部函数。内部函数能够访问外部函数的局部变量，这个特性是闭包(Closure)编程的基础，在这里我们不展开。

   关于 python 中常用的需要接收函数作为参数的内置函数，我们在下一小节介绍。

python 中常用的将函数作为参数的内置函数

部分Python内置函数接受函数作为参数,典型的此类内置函数有这些：

• filter函数 此时lambda函数用于指定过滤列表元素的条件。

  例如 filter(lambda x: x % 3 == 0, [1, 2, 3]) 指定将列表 [1,2,3] 中能够被3整除的元素过滤出来，其结果是 [3]。

  注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

• sorted函数 此时 lambda 函数用于指定对列表中所有元素进行排序的准则。

  例如 sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x)) 将列表 [1, 2, 3, 4, 5, 6, 7, 8, 9] 按照元素与5距离从小到大进行排序，其结果是 [5, 4, 6, 3, 7, 2, 8, 1, 9] 。

• map函数 此时lambda函数用于指定对列表中每一个元素的共同操作。

  例如 map(lambda x: x+1, [1, 2,3]) 将列表 [1, 2, 3] 中的元素分别加1，其结果[2, 3, 4]。

  注意 map 函数的返回值也是 Iterator 对象。

• reduce函数 此时 lambda 函数用于指定列表中两两相邻元素的结合条件。

  例如 reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9]) 将列表 [1, 2, 3, 4, 5, 6, 7, 8, 9] 中的元素从左往右两两以逗号分隔的字符的形式依次结合起来，其结果是 ‘1, 2, 3, 4, 5, 6, 7, 8, 9’。

• 另外，部分Python库函数也接收函数作为参数，例如 gevent 的 spawn 函数。此时，lambda函数也能够作为参数传入。

对于 python 中的这些高阶函数的详细解释，推荐查看 廖雪峰的博客。

C++中的lambda表达式

C++11的一大亮点就是引入了 lambda 表达式。利用 lambda 表达式，可以方便的定义和创建匿名函数。

语法

[capture list] (params list) mutable exception -> return type { function body }

各项含义如下：

• capture list：捕获外部变量列表

• params list：形参列表

• mutable指示符：用来说用是否可以修改捕获的变量

• exception：异常设定

• return type：返回类型

• function body：函数体

此外，我们还可以省略其中的某些成分来声明“不完整”的Lambda表达式，常见的有以下几种：

	格式
1	[capture list] (params list) -> return type {function body}
2	[capture list] (params list) {function body}
3	[capture list] {function body}

其中：

• 格式1声明了const类型的表达式，这种类型的表达式不能修改捕获列表中的值。
• 格式2省略了返回值类型，但编译器可以根据以下规则推断出Lambda表达式的返回类型： （1）：如果function body中存在return语句，则该Lambda表达式的返回类型由return语句的返回类型确定； （2）：如果function body中没有return语句，则返回值为void类型。
• 格式3中省略了参数列表，类似普通函数中的无参函数。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

bool cmp(int a, int b){
    return  a < b;
}

int main(){
    vector<int> myvec{ 3, 2, 5, 7, 3, 2 };
    vector<int> lbvec(myvec);

    sort(myvec.begin(), myvec.end(), cmp); // 旧式做法
    cout << "predicate function:" << endl;
    for (int it : myvec)
        cout << it << ' ';
    cout << endl;

    sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   // Lambda表达式
    cout << "lambda expression:" << endl;
    for (int it : lbvec)
        cout << it << ' ';
    cout << endl;
}

在C++11之前，我们使用STL的sort函数，需要提供一个谓词函数。如果使用C++11的Lambda表达式，我们只需要传入一个匿名函数即可，方便简洁，而且代码的可读性也比旧式的做法好多了。

下面，我们就简单介绍一下 lambda 表达式各项的具体用法。

各项的具体用法

捕获外部变量

lambda 表达式可以使用其可见范围内的外部变量，但必须明确声明（明确声明哪些外部变量可以被该Lambda表达式使用）。那么，在哪里指定这些外部变量呢？lambda 表达式通过在最前面的方括号 [] 来明确指明其内部可以访问的外部变量，这一过程也称过 lambda 表达式“捕获”了外部变量。

我们通过一个例子来直观地说明一下：

#include <iostream>
using namespace std;

int main(){
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    f(); // 输出：123

    //或通过“函数体”后面的‘()’传入参数
    auto x = [](int a){cout << a << endl;}(123); 
}

上面这个例子先声明了一个整型变量a，然后再创建Lambda表达式，该表达式“捕获”了a变量，这样在Lambda表达式函数体中就可以获得该变量的值。

类似参数传递方式（值传递、引入传递、指针传递），在Lambda表达式中，外部变量的捕获方式也有值捕获、引用捕获、隐式捕获。对于这三种捕获方式，本文就不具体介绍了，可参考博客：C++11 Lambda表达式。

总之，C++11 中 lambda 表达式捕获外部变量主要有以下形式：

捕获形式	说明
[]	不捕获任何外部变量
[变量名, …]	默认以值得形式捕获指定的多个外部变量（用逗号分隔），如果引用捕获，需要显示声明（使用&说明符）
[this]	以值的形式捕获this指针
[=]	以值的形式捕获所有外部变量
[&]	以引用形式捕获所有外部变量
[=, &x]	变量x以引用形式捕获，其余变量以传值形式捕获
[&, x]	变量x以值的形式捕获，其余变量以引用形式捕获

修改捕获的外部变量

前面我们提到过，在 lambda 表达式中，如果以传值方式捕获外部变量，则函数体中不能修改该外部变量，否则会引发编译错误。那么有没有办法可以修改值捕获的外部变量呢？这是就需要使用 mutable 关键字，该关键字用以说明表达式体内的代码可以修改值捕获的变量，示例：

int main(){
    int a = 123;
    auto f = [a]()mutable { cout << ++a; }; // 不会报错
    cout << a << endl; // 输出：123
    f(); // 输出：124
}

lambda 表达式的参数

lambda 表达式的参数和普通函数的参数类似，那么这里为什么还要拿出来说一下呢？原因是在 lambda 表达式中传递参数还有一些限制，主要有以下几点：

1. 参数列表中不能有默认参数
2. 不支持可变参数
3. 所有参数必须有参数名

常用举例：

int main(){
　　　　 int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5);
        std::cout << "m:" << m << std::endl;            　　//输出m:16

        std::cout << "n:" << [](int x, int y) { return x + y; }(5, 4) << std::endl;            //输出n:9
        
        auto gFunc = [](int x) -> function<int(int)> { return [=](int y) { return x + y; }; };
        auto lFunc = gFunc(4);
        std::cout << lFunc(5) << std::endl;

        auto hFunc = [](const function<int(int)>& f, int z) { return f(z) + 1; };
        auto a = hFunc(gFunc(7), 8);

        int a = 111, b = 222;
        auto func = [=, &b]()mutable { a = 22; b = 333; std::cout << "a:" << a << " b:" << b << std::endl; };

        func();
        std::cout << "a:" << a << " b:" << b << std::endl;

        a = 333;
        auto func2 = [=, &a] { a = 444; std::cout << "a:" << a << " b:" << b << std::endl; };
        func2();

        auto func3 = [](int x) ->function<int(int)> { return [=](int y) { return x + y; }; };

    　　
　　　　 std::function<void(int x)> f_display_42 = [](int x) { print_num(x); };
	f_display_42(44);
　　}

Ref：

https://zhuanlan.zhihu.com/p/58579207

https://www.cnblogs.com/DswCnblog/p/5629165.html