对于一个没有计算机科学背景的人来说，计算机科学界的lambda是什么？
当前回答
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中，我们得到了lambdas，这使得代码更短：
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);
}
其他回答
在CS的上下文中，lambda函数是一个抽象的数学概念，它解决了数学表达式的符号求值问题。在这种情况下，lambda函数与lambda项相同。
但在编程语言中，这是不同的。这是一段被宣布为“到位”的代码，可以作为“一流公民”传递。这个概念似乎很有用，因此它几乎进入了所有流行的现代编程语言（参见lambda函数everwhere post）。
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中，我们得到了lambdas，这使得代码更短：
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);
}
lambda函数可以接受任意数量的参数，但它们只包含一个表达式。。。Lambda函数可用于返回函数对象。语法上，lambda函数仅限于一个表达式。
Lambda来自Lambda演算，指编程中的匿名函数。
为什么这么酷？它允许您在不命名的情况下编写快速丢弃函数。它还提供了一种编写闭包的好方法。有了这种力量，你可以做这样的事情。
蟒蛇
def adder(x):
return lambda y: x + y
add5 = adder(5)
add5(1)
6
从Python片段中可以看到，函数加法器接受一个参数x，并返回一个接受另一个参数y的匿名函数或lambda。该匿名函数允许您从函数创建函数。这是一个简单的例子，但它应该传达lambdas和闭包的强大功能。
其他语言示例
Perl 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 = fn () => $a + $b;
echo $lambda();
哈斯克尔
(\x y -> x + y)
Java查看此帖子
// 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
Lua
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
Ruby稍有不同，因为不能使用与调用函数完全相同的语法调用lambda，但它仍然有lambda。
def adder(x)
lambda { |y| x + y }
end
add5 = adder(5)
add5[1] == 6
Ruby是Ruby，有一个lambdas的简写，所以您可以这样定义加法器：
def adder(x)
-> y { x + y }
end
R
adder <- function(x) {
function(y) x + y
}
add5 <- adder(5)
add5(1)
#> [1] 6
对于一个没有计算机科学背景的人来说，计算机科学界的lambda是什么？
我将用简单易读的python代码一步一步直观地说明它。
简而言之，lambda只是一个匿名内联函数。
让我们从作业开始，了解兰达斯作为一名有基础算术背景的新生。
任务蓝图为“名称=值”，请参见：
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
它现在起作用了，如果你坚持将两条seperarte线合并为一条呢。lambda来了
In [13]: j = lambda i: i**2 + 2*i + 1
In [14]: j
Out[14]: <function __main__.<lambda>>
未报告错误。
这是对lambda的一瞥，它使您能够像在数学中那样在单行中直接将函数写入计算机。
我们稍后再看。
让我们继续深入了解“任务”。
如上所示，等号=适用于简单数据（1和“value”）类型和简单表达式（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
它适用于简单的语句，在python7中有11种类型。简单语句-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
Tada，分析一下，“m”是名称，“n**2+2*n+1”是值是“=”的变体。找到它，如果只是为了理解，一切都从任务开始，一切都是任务。
现在返回lambda，我们有一个名为“m”的函数
Try:
In [28]: m = m(3)
In [29]: m
Out[29]: 16
这里有两个“m”的名称，函数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
它叫做“匿名函数”
总之，
内联函数中的lambda，它使您能够像数学中那样在一条直线上编写函数lambda是匿名的
希望，这有帮助。
