什么是 lambda（函数）？

Question

对于没有计算机科学背景的人来说，计算机科学世界中的 lambda 是什么？

Answer 1

拉姆达来自 拉姆达演算 指编程中的匿名函数。

为什么这很酷？它允许您快速编写废弃函数而无需命名它们。它还提供了一种编写闭包的好方法。有了这种力量，你就可以做这样的事情。

Python

def adder(x):
    return lambda y: x + y
add5 = adder(5)
add5(1)
6

正如您从 Python 代码片段中看到的，函数 adder 接受一个参数 x，并返回一个匿名函数或 lambda，该函数接受另一个参数 y。该匿名函数允许您从函数创建函数。这是一个简单的示例，但它应该传达 lambda 和闭包的强大功能。

其他语言的示例

珀尔5

sub adder {
    my ($x) = @_;
    return sub {
        my ($y) = @_;
        $x + $y
    }
}

my $add5 = adder(5);
print &$add5(1) == 6 ? "ok\n" : "not ok\n";

JavaScript

var adder = function (x) {
    return function (y) {
        return x + y;
    };
};
add5 = adder(5);
add5(1) == 6

JavaScript (ES6)

const adder = x => y => x + y;
add5 = adder(5);
add5(1) == 6

方案

(define adder
    (lambda (x)
        (lambda (y)
           (+ x y))))
(define add5
    (adder 5))
(add5 1)
6

C# 3.5 或更高版本

Func<int, Func<int, int>> adder = 
    (int x) => (int y) => x + y; // `int` declarations optional
Func<int, int> add5 = adder(5);
var add6 = adder(6); // Using implicit typing
Debug.Assert(add5(1) == 6);
Debug.Assert(add6(-1) == 5);

// Closure example
int yEnclosed = 1;
Func<int, int> addWithClosure = 
    (x) => x + yEnclosed;
Debug.Assert(addWithClosure(2) == 3);

迅速

func adder(x: Int) -> (Int) -> Int{
   return { y in x + y }
}
let add5 = adder(5)
add5(1)
6

PHP

$a = 1;
$b = 2;

$lambda = function () use (&$a, &$b) {
    echo $a + $b;
};

echo $lambda();

哈斯克尔

(\x y -> x + y) 

爪哇 看 这个帖子

// The following is an example of Predicate : 
// a functional interface that takes an argument 
// and returns a boolean primitive type.

Predicate<Integer> pred = x -> x % 2 == 0; // Tests if the parameter is even.
boolean result = pred.test(4); // true

卢阿

adder = function(x)
    return function(y)
        return x + y
    end
end
add5 = adder(5)
add5(1) == 6        -- true

科特林

val pred = { x: Int -> x % 2 == 0 }
val result = pred(4) // true

红宝石

Ruby 略有不同，因为您无法使用与调用函数完全相同的语法来调用 lambda，但它仍然具有 lambda。

def adder(x)
  lambda { |y| x + y }
end
add5 = adder(5)
add5[1] == 6

Ruby 就是 Ruby，有 lambda 的简写，所以你可以定义 adder 这边走：

def adder(x)
  -> y { x + y }
end

Answer 2

lambda 是一种内联定义的函数。除了 lambda 之外，您通常还拥有某种变量类型，可以保存对函数、lambda 或其他函数的引用。

例如，下面是一段不使用 lambda 的 C# 代码：

public Int32 Add(Int32 a, Int32 b)
{
    return a + b;
}

public Int32 Sub(Int32 a, Int32 b)
{
    return a - b;
}

public delegate Int32 Op(Int32 a, Int32 b);

public void Calculator(Int32 a, Int32 b, Op op)
{
    Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}

public void Test()
{
    Calculator(10, 23, Add);
    Calculator(10, 23, Sub);
}

这会调用 Calculator，不仅传递两个数字，还会传递调用 Calculator 内部的哪个方法来获取计算结果。

在 C# 2.0 中，我们有了匿名方法，它将上面的代码缩短为：

public delegate Int32 Op(Int32 a, Int32 b);

public void Calculator(Int32 a, Int32 b, Op op)
{
    Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}

public void Test()
{
    Calculator(10, 23, delegate(Int32 a, Int32 b)
    {
        return a + b;
    });
    Calculator(10, 23, delegate(Int32 a, Int32 b)
    {
        return a - b;
    });
}

然后在 C# 3.0 中，我们使用了 lambda，这使得代码变得更短：

public delegate Int32 Op(Int32 a, Int32 b);

public void Calculator(Int32 a, Int32 b, Op op)
{
    Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}

public void Test()
{
    Calculator(10, 23, (a, b) => a + b);
    Calculator(10, 23, (a, b) => a - b);
}

Answer 3

它指的是 拉姆达演算, ，这是一个只有 lambda 表达式的形式系统，它表示一个函数，该函数接受一个函数作为其唯一参数并返回一个函数。lambda 演算中的所有函数都是该类型，即 λ : λ → λ.

Lisp 使用 lambda 概念来命名其匿名函数文字。此 lambda 表示一个函数，该函数接受两个参数 x 和 y，并返回它们的乘积：

(lambda (x y) (* x y)) 

它可以像这样在线应用（评估为 50):

((lambda (x y) (* x y)) 5 10)

Answer 4

“lambda”这个名字只是一个历史文物。我们所讨论的只是一个其值为函数的表达式。

一个简单的示例（下一行使用 Scala）是：

args.foreach(arg => println(arg))

其中参数 foreach method 是匿名函数的表达式。上面的行或多或少与编写类似的代码相同（不是真正的代码，但你会明白的）：

void printThat(Object that) {
  println(that)
}
...
args.foreach(printThat)

除了你不需要担心：

1. 在其他地方声明该函数（并且当您稍后重新访问代码时必须查找它）。
2. 命名您只使用一次的东西。

一旦您习惯了函数值，就必须不用它们，这看起来就像需要命名每个表达式一样愚蠢，例如：

int tempVar = 2 * a + b
...
println(tempVar)

而不是只在需要的地方编写表达式：

println(2 * a + b)

确切的符号因语言而异；希腊语并不总是必需的！;-)

Answer 5

lambda 演算是一种一致的数学替代理论。例如，在学校数学中，人们会看到 x+y=5 配对 x−y=1. 。除了操纵各个方程的方法之外，还可以将这两个方程的信息放在一起，只要逻辑上完成交叉方程替换即可。Lambda 演算编码了进行这些替换的正确方法。

鉴于 y = x−1 是第二个方程的有效重新排列，即： λ y = x−1 表示替换符号的函数 x−1 对于符号 y. 。现在想象一下应用 λ y 第一个方程中的每一项。如果一个术语是 y 然后进行替换；否则什么都不做。如果你把这个写在纸上，你就会看到如何应用它 λ y 将使第一个方程可解。

这是不需要任何计算机科学或编程的答案。

我能想到的最简单的编程示例来自 http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works:

这是如何在命令式编程语言（C）中定义平方函数的方式：

int square(int x)
{
    return x * x;
}

变量X是一个形式参数，在调用函数时要平方的实际值代替。在功能语言（方案）中，将定义相同的功能：

(define square
  (lambda (x) 
    (* x x)))

这在许多方面都是不同的，但是它仍然以相同的方式使用正式参数x。

---

添加： http://imgur.com/a/XBHub

Answer 6

稍微过于简单化了：lambda 函数是一种可以传递给其他函数并且可以进行逻辑访问的函数。

在 C# 中，lambda 语法通常以与匿名委托相同的方式编译为简单方法，但它也可以被分解并读取其逻辑。

例如（在 C#3 中）：

LinqToSqlContext.Where( 
    row => row.FieldName > 15 );

LinqToSql 可以读取该函数 (x > 15) 并将其转换为实际的 SQL，以便使用表达式树执行。

上面的语句就变成：

select ... from [tablename] 
where [FieldName] > 15      --this line was 'read' from the lambda function

这与普通方法或匿名委托（这实际上只是编译器魔法）不同，因为它们不能 读.

并非 C# 中使用 lambda 语法的所有方法都可以编译为表达式树（即实际的 lambda 函数）。例如：

LinqToSqlContext.Where( 
    row => SomeComplexCheck( row.FieldName ) );

现在无法读取表达式树 - SomeComplexCheck 无法分解。SQL语句将在没有where的情况下执行，并且数据中的每一行都会被遍历 SomeComplexCheck.

Lambda 函数不应与匿名方法混淆。例如：

LinqToSqlContext.Where( 
    delegate ( DataRow row ) { 
        return row.FieldName > 15; 
    } );

它还有一个“内联”函数，但这一次它只是编译器的魔法 - C# 编译器会将其拆分为一个具有自动生成名称的新实例方法。

匿名方法无法被读取，因此逻辑无法像 lambda 函数那样被翻译出来。

Answer 7

我喜欢这篇文章中对 Lambda 的解释： LINQ 的演变及其对 C# 设计的影响. 。这对我来说很有意义，因为它展示了 Lambda 的真实世界并将其构建为一个实际示例。

他们的快速解释：Lambda 是一种将代码（函数）视为数据的方法。

Answer 8

Ruby 中的 lambda 示例如下：

hello = lambda do
    puts('Hello')
    puts('I am inside a proc')
end

hello.call

将生成以下输出：

Hello
I am inside a proc

Answer 9

@Brian 我一直在 C#、LINQ 和非 LINQ 运算符中使用 lambda。例子：

string[] GetCustomerNames(IEnumerable<Customer> customers)
 { return customers.Select(c=>c.Name);
 }

在 C# 之前，我在 JavaScript 中使用匿名函数来回调 AJAX 函数，甚至在 Ajax 一词被创造之前：

getXmlFromServer(function(result) {/*success*/}, function(error){/*fail*/});

不过，C# 的 lambda 语法的有趣之处在于，它们本身无法推断出它们的类型（即，您不能输入 var foo = (x,y) => x * y），但取决于它们的类型分配给，它们将被编译为代表表达式的委托或抽象语法树（这就是 LINQ 对象映射器发挥其“语言集成”魔力的方式）。

LISP 中的 Lambda 表达式也可以传递给引用运算符，然后作为列表的列表进行遍历。一些强大的宏就是通过这种方式制作的。

Answer 10

这个问题已经得到了很好的正式回答，所以我不会尝试对此添加更多内容。

在非常简单的情况下， 非正式的 对于对数学或编程知之甚少或一无所知的人来说，我会将其解释为一个小型“机器”或“盒子”，它接受一些输入，进行一些工作并产生一些输出，没有特定的名称，但我们知道在哪里它确实如此，并且正是通过这些知识，我们才使用它。

实际上，对于知道函数是什么的人，我会告诉他们这是一个没有名称的函数，通常放在内存中的一个点上，只需引用该内存即可使用该点（通常通过使用一个变量 - 如果他们听说过函数指针的概念，我会将它们用作类似的概念） - 这个答案涵盖了非常基础的知识（没有提到闭包等），但人们可以很容易地明白这一点。

Answer 11

您可以将其视为匿名函数 - 这里有更多信息： 维基百科 - 匿名函数

Answer 12

只是因为我在这里看不到 C++11 示例，所以我将继续发布这个很好的示例 这里. 。经过搜索，这是我能找到的最清晰的语言特定示例。

你好，Lambdas，版本 1

template<typename F>

void Eval( const F& f ) {
        f();
}
void foo() {
        Eval( []{ printf("Hello, Lambdas\n"); } );
}

你好，Lambdas，版本 2：

void bar() {
    auto f = []{ printf("Hello, Lambdas\n"); };
    f();
}

Answer 13

我很难理解 lambda 表达式，因为我在 Visual FoxPro 中工作，它具有宏替换以及 ExecScript{} 和 Evaluate() 函数，它们似乎具有相同的目的。

? Calculator(10, 23, "a + b")
? Calculator(10, 23, "a - b");

FUNCTION Calculator(a, b, op)
RETURN Evaluate(op)

使用正式 lambda 的一个明显好处是（我认为）编译时检查：Fox 不会知道您是否打错了上面的文本字符串，直到它尝试运行它。

这对于数据驱动的代码也很有用：您可以将整个例程存储在数据库的备注字段中，然后在运行时评估它们。这使您可以调整应用程序的一部分，而无需实际访问源代码。（但这完全是另一个话题了。）

Answer 14

对于没有计算机科学背景的人来说，计算机科学世界中的 lambda 是什么？

我将用简单易读的Python代码一步步直观地说明。

简而言之，lambda 只是一个匿名内联函数。

我们先从作业开始理解 lambdas 作为一名具有基础算术背景的新生。

赋值的蓝图是“名称=值”，参见：

In [1]: x = 1
   ...: y = 'value'
In [2]: x
Out[2]: 1
In [3]: y
Out[3]: 'value'

'x'、'y' 是名称，1、'value' 是值。尝试数学中的函数

In [4]: m = n**2 + 2*n + 1
NameError: name 'n' is not defined

错误报告，
您不能直接将数学编写为代码，应该定义“n”或将其分配给一个值。

In [8]: n = 3.14
In [9]: m = n**2 + 2*n + 1
In [10]: m
Out[10]: 17.1396

现在可以了，如果您坚持将两条单独的线路合并为一条会怎么样？来了 lambda

In [13]: j = lambda i: i**2 + 2*i + 1
In [14]: j
Out[14]: <function __main__.<lambda>>

没有报告错误。

这是一眼 lambda, ，它使您能够像在数学中直接将函数写入计算机一样在一行中编写函数。

我们稍后会看到。

让我们继续深入挖掘“作业”。

如上图所示，等号 = 适用于简单数据（1 和“值”）类型和简单表达式（n**2 + 2*n + 1）。

尝试这个：

In [15]: x = print('This is a x')
This is a x
In [16]: x
In [17]: x = input('Enter a x: ')
Enter a x: x

它适用于简单的语句，Python中有11种类型 7.简单语句 — Python 3.6.3 文档

复合语句怎么样，

In [18]: m = n**2 + 2*n + 1 if n > 0
SyntaxError: invalid syntax
#or
In [19]: m = n**2 + 2*n + 1, if n > 0
SyntaxError: invalid syntax

来了 def 使其工作

In [23]: def m(n):
    ...:     if n > 0:
    ...:         return n**2 + 2*n + 1
    ...:
In [24]: m(2)
Out[24]: 9

多田，分析一下，'m'是名称，'n**2 + 2*n + 1'是值。: 是“=”的变体。
找到了，如果只是为了理解，一切都是从赋值开始，一切都是赋值。

现在回到 lambda, ，我们有一个名为“m”的函数

尝试：

In [28]: m = m(3)
In [29]: m
Out[29]: 16

这里的“m”有两个名字，function m 已经有一个名字了，重复的。

它的格式如下：

In [27]: m = def m(n):
    ...:         if n > 0:
    ...:             return n**2 + 2*n + 1
    SyntaxError: invalid syntax

这不是一个明智的策略，因此会报告错误

我们必须删除其中一个，设置一个没有名称的函数。

m = lambda n:n**2 + 2*n + 1

它被称为“匿名函数”

综上所述，

1. lambda 在内联函数中，它使您能够像数学中一样在一条直线上编写函数
2. lambda 是匿名的

希望这可以帮助。

Answer 15

这是一个没有名称的函数。例如在 c# 中你可以使用

numberCollection.GetMatchingItems<int>(number => number > 5);

返回大于 5 的数字。

number => number > 5

这里是 lambda 部分。它表示一个接受参数（数字）并返回布尔值（数字 > 5）的函数。GetMatchingItems 方法对集合中的所有项目使用此 lambda 并返回匹配的项目。

Answer 16

例如，在 Javascript 中，函数被视为与其他所有内容相同的混合类型（int, string, float, bool）。因此，您可以即时创建函数，将它们分配给事物，然后稍后调用它们。它很有用，但你不想过度使用它，否则你会让每个必须维护你的代码的人感到困惑......

这是我正在玩的一些代码，看看这个兔子洞有多深：

var x = new Object;
x.thingy = new Array();
x.thingy[0] = function(){ return function(){ return function(){ alert('index 0 pressed'); }; }; }
x.thingy[1] = function(){ return function(){ return function(){ alert('index 1 pressed'); }; }; }
x.thingy[2] = function(){ return function(){ return function(){ alert('index 2 pressed'); }; }; }

for(var i=0 ;i<3; i++)
    x.thingy[i]()()();

Answer 17

在 CS 的上下文中，lambda 函数是一个抽象的数学概念，用于解决数学表达式的符号求值问题。在这种情况下，lambda 函数与 拉姆达项.

但在编程语言中，情况有所不同。这是一段被声明为“就位”的代码，并且可以作为“一等公民”进行传递。这个概念似乎很有用，因此它进入了几乎所有流行的现代编程语言（参见 无处不在的 lambda 函数 邮政）。

Answer 18

我也明白了。我在 JS 中尝试过这个：

var addAndMult = function(x) {
        return (function(y) {
            return (function(z) {
                return (x+y)*z; 
                });
            });
        };

它将 2 加 4，然后将结果乘以 6。然而我发现有时很难阅读:(

我还做了一个有趣的 forEach 函数：

var forEach = function(arr) {
            return (function(x) {
            for (var i=0; arr[i]; i++) {
                 x(arr[i]);
             }
        });
    }

forEach([1,2,3,4,5])(console.log);

此方法将迭代一个数组并执行一个操作 - 在打印到控制台的情况下。现在我也明白为什么 Labmda 如此强大了。

Answer 19

在计算机编程中，lambda 是一段代码（语句、表达式或它们的一组），它从外部源获取一些参数。它不能总是匿名函数——我们有很多方法来实现它们。

我们在表达式、语句和函数之间有明确的区分，这是数学家所没有的。

编程中的“函数”一词也有所不同 - 我们有“函数是一系列要做的步骤”（来自拉丁语“执行”）。在数学中，它是关于变量之间的相关性。

函数式语言试图尽可能与数学公式相似，而且它们的单词含义几乎相同。但在其他编程语言中我们有不同的做法。

Answer 20

A Lambda Function, ，或一个 Small Anonymous Function, ，是一个独立的功能块，可以在代码中传递和使用。Lambda 在不同的编程语言中有不同的名称 – Lambda 在 Python 和 科特林, Closure 在 迅速, ， 或者 Block 在 C 和 Objective-C. 。尽管 lambda 的含义对于这些语言非常相似，但有时也有细微的区别。

让我们看看 Lambda（闭包）在 Swift 4.2 中如何使用排序（）方法工作——从普通函数到最短表达式：

let coffee: [String] = ["Cappuccino", "Espresso", "Latte", "Ristretto"]

1.正常功能

func backward(_ n1: String, _ n2: String) -> Bool {
    return n1 > n2
}
var reverseOrder = coffee.sorted(by: backward)


// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]

2.闭包表达式

reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in
    return n1 > n2
})

3.内联闭包表达式

reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in return n1 > n2 } )

4.从上下文推断类型

reverseOrder = coffee.sorted(by: { n1, n2 in return n1 > n2 } )

5.单表达式闭包的隐式返回

reverseOrder = coffee.sorted(by: { n1, n2 in n1 > n2 } )

6.参数名称简写

reverseOrder = coffee.sorted(by: { $0 > $1 } )

// $0 and $1 are closure’s first and second String arguments.

7.操作方法

reverseOrder = coffee.sorted(by: >)

// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]

希望这可以帮助。

Answer 21

这个问题已经回答得很完整了，我不想再赘述了。我想分享一下用 Rust 编写数值计算时的用法。

有一个 lambda（匿名函数）的例子

let f = |x: f32| -> f32 { x * x - 2.0 };
let df = |x: f32| -> f32 { 2.0 * x };

当我编写牛顿-拉夫森方法的模块时，它被用作一阶和二阶导数。（如果您想了解什么是牛顿-拉夫逊法，请访问“https://en.wikipedia.org/wiki/Newton%27s_method".

输出如下

println!("f={:.6}      df={:.6}", f(10.0), df(10.0))

f=98.000000       df=20.000000

Answer 22

想象一下，您有一家提供送货服务的餐厅，并且您的订单需要在 30 分钟内完成。关键是客户通常不在乎你是骑自行车还是赤脚送食物，只要你保持食物温暖并绑好即可。因此，让我们使用匿名和定义的传输函数将这个习惯用法转换为 Javascript。

下面我们定义了传递的方式，也就是定义函数的名称：

// ES5 
var food = function withBike(kebap, coke) {
return (kebap + coke); 
};

如果我们使用箭头/lambda 函数来完成此传输会怎样：

// ES6    
const food = (kebap, coke) => { return kebap + coke };

您会发现，对于客户来说没有什么区别，也没有浪费时间考虑如何发送食物。发送即可。

顺便说一句，我不推荐加可乐的烤肉串，这就是为什么上面的代码会给你错误。玩得开心。