对于一个没有计算机科学背景的人来说，计算机科学界的lambda是什么？
当前回答
@Brian我一直在C#、LINQ和非LINQ运算符中使用lambdas。例子：
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中的Lambdas也可以传递给引号运算符，然后作为列表列表进行遍历。一些强大的宏是这样生成的。
其他回答
在CS的上下文中，lambda函数是一个抽象的数学概念，它解决了数学表达式的符号求值问题。在这种情况下，lambda函数与lambda项相同。
但在编程语言中，这是不同的。这是一段被宣布为“到位”的代码，可以作为“一流公民”传递。这个概念似乎很有用，因此它几乎进入了所有流行的现代编程语言（参见lambda函数everwhere post）。
“lambda”这个名字只是一个历史产物。我们所谈论的只是一个表达式，其值是一个函数。
一个简单的例子（下一行使用Scala）是：
args.foreach(arg => println(arg))
其中foreach方法的参数是匿名函数的表达式。上面的一行与编写类似的代码大致相同（不是真正的代码，但你会明白的）：
void printThat(Object that) {
println(that)
}
...
args.foreach(printThat)
除了你不需要麻烦：
在其他地方声明函数（稍后重新访问代码时必须查找它）。命名你只使用一次的东西。
一旦你习惯了函数值，就不得不不使用它们，就像需要命名每个表达式一样愚蠢，比如：
int tempVar = 2 * a + b
...
println(tempVar)
而不是只在需要的地方编写表达式：
println(2 * a + b)
确切的符号因语言而异；希腊语并不总是必需的！；-）
Lambda为大家解释道：
Lambda是一个匿名函数。这意味着lambda是Python中的函数对象，以前不需要引用。让我们在这里考虑一下这段代码：
def name_of_func():
#command/instruction
print('hello')
print(type(name_of_func)) #the name of the function is a reference
#the reference contains a function Object with command/instruction
为了证明我的主张，我打印了name_of_func的类型，它返回我们：
<class 'function'>
函数必须有接口，但接口文档需要包含一些内容。这是什么意思？让我们更接近我们的函数，我们可能会注意到，除了函数的名称之外，我们还需要解释更多的细节，以了解函数是什么。
一个正则函数将用语法“def”定义，然后我们键入名称并用“（）”结算接口，然后用语法“：”结束定义。现在，我们使用指令/命令进入函数体。
因此，让我们在这里考虑一下这段代码：
def print_my_argument(x):
print(x)
print_my_argument('Hello')
在本例中，我们运行名为“print_my_argument”的函数，并通过接口传递参数/参数。输出将为：
Hello
现在我们知道了什么是函数，以及函数的体系结构是如何工作的，我们可以看看一个匿名函数。让我们在这里考虑一下这段代码：
def name_of_func():
print('Hello')
lambda: print('Hello')
这些函数对象几乎相同，只是上面的常规函数有一个名称，而另一个函数是匿名的。让我们仔细看看我们的匿名函数，了解如何使用它。
因此，让我们在这里考虑一下这段代码：
def delete_last_char(arg1=None):
print(arg1[:-1])
string = 'Hello World'
delete_last_char(string)
f = lambda arg1=None: print(arg1[:-1])
f(string)
因此，我们在上面的代码中所做的是再次编写一个常规函数和一个匿名函数。我们将匿名函数分配给了一个var，这与为这个函数命名几乎相同。无论如何，输出将是：
Hello Worl
Hello Worl
为了充分证明lambda是一个函数对象，而不仅仅是模拟函数，我们在这里运行以下代码：
string = 'Hello World'
f = lambda arg1=string: print(arg1[:-1])
f()
print(type(f))
输出将为：
Hello Worl
<class 'function'>
最后但并非最不重要的是，您应该知道python中的每个函数都需要返回一些内容。如果函数体中未定义任何内容，则默认情况下将返回None。看看这里的这段代码：
def delete_last_char(arg1):
print(arg1[:-1])
string = 'Hello World'
x = delete_last_char(string)
f = lambda arg1=string: print(arg1[:-1])
x2 = f()
print(x)
print(x2)
输出将为：
Hello Worl
Hello Worl
None
None
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演算，指编程中的匿名函数。
为什么这么酷？它允许您在不命名的情况下编写快速丢弃函数。它还提供了一种编写闭包的好方法。有了这种力量，你可以做这样的事情。
蟒蛇
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
