什么是lambda（函数）？

对于一个没有comp-sci背景的人来说，计算机科学界的lambda是什么？

它指的是一个形式系统，它只有lambda表达式，表示一个函数，该函数以函数作为其唯一参数并返回一个函数。lambda演算中的所有函数都属于该类型，即λ：λ→ λ

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

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

它可以像这样在线应用到50：

---

您可以将其视为一个匿名函数—这里有更多信息：

Lambda来自，并在编程中引用匿名函数

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

蟒蛇

def adderx： 返回λy:x+y add5=addr5 地址51 6. 正如您从Python代码片段中看到的，函数加法器接受一个参数x，并返回一个匿名函数或lambda，该函数接受另一个参数y。该匿名函数允许您从函数创建函数。这是一个简单的示例，但它应该传达lambdas和闭包所具有的强大功能

其他语言的例子

Perl 5

子加法器{ 我的$x=@； 返回接头{ 我的$y=@； $x+$y } } 我的$add5=adder5； 打印&$add51==6？正常\n：不正常\n； JavaScript

var加法器=函数x{ 返回函数y{ 返回x+y； }; }; add5=ADDR5； add51==6 JavaScript ES6

常数加法器=x=>y=>x+y； add5=ADDR5； add51==6 计划

定义加法器 λx 兰姆达y +xy 定义add5 加法器5 地址5 1 6. Func加法器= int x=>int y=>x+y；//`int`声明可选 Func add5=adder5； var add6=adder6；//使用隐式类型 Debug.Assertadd51==6； Debug.Assertadd6-1==5； //闭包示例 int-yEnclosed=1； Func addWithClosure= x=>x+Y闭合； Debug.AssertaddWithClosure2==3； 迅捷的

函数加法器：整数->整数->整数{ 返回{y在x+y} } 设add5=addr5 地址51 6. PHP

$a=1； $b=2； $lambda=fn=>$a+b； echo$lambda； 哈斯克尔

爪哇岛

//以下是谓词的一个示例： //接受参数的函数接口 //并返回布尔基元类型。 谓词pred=x->x%2==0；//测试参数是否为偶数。 布尔结果=pred.test4；//符合事实的 卢阿

加法器=函数x 返回函数 返回x+y 终止 终止 add5=addr5 add51==6-正确 科特林

val pred={x:Int->x%2==0} val result=pred4//true 红宝石

Ruby稍有不同，因为不能使用与调用函数完全相同的语法调用lambda，但它仍然有lambda

def加法器 λ{| y | x+y} 终止 add5=addr5 add5[1]==6 Ruby是Ruby，有一个lambdas的简写，因此您可以这样定义加法器：

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

R

---

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

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

公共Int32附加32 a、Int32 b { 返回a+b； } 公共Int32子Int32 a、Int32 b { 返回a-b； } 公共代表Int32意见32 a、Int32 b； 公共无效计算器Int32 a、Int32 b、Op { Console.WriteLineCalculator:op+a+，+b+=+opa，b； } 公共空隙试验 { 计算器10、23、Add； 计算器10、23、Sub； } 这将调用Calculator，不仅传递两个数字，还传递在Calculator内部调用哪个方法以获得计算结果

在C 2.0中，我们使用了匿名方法，将上述代码缩短为：

公共代表Int32意见32 a、Int32 b； 公共无效计算器Int32 a、Int32 b、Op { Console.WriteLineCalculator:op+a+，+b+=+opa，b； } 公共空隙试验 { 计算器10，23，被授权者Int32 a，Int32 b { 返回a+b； }; 计算器10，23，被授权者Int32 a，Int32 b { 返回a-b； }; } 在C 3.0中，我们得到了lambdas，这使得代码更加简短：

公共代表Int32意见32 a、Int32 b； 公共无效计算器Int32 a、Int32 b、Op { Console.WriteLineCalculator:op+a+，+b+=+opa，b； } 公共空隙试验 { 计算器10，23，a，b=>a+b； 计算器10，23，a，b=>a-b； }

---

它是一个没有名字的函数。例如，在c语言中，您可以使用

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

---

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

我喜欢本文中对lambda的解释：。信息技术 这对我来说很有意义，因为它为Lambdas展示了一个真实的世界，并将其构建为一个实际的例子

---

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

稍微简化了一点：lambda函数是可以传递给其他函数并访问其逻辑的函数

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

例如在C3中：

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

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

上述声明变为：

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

这与普通方法或匿名委托不同，后者只是编译器的魔法，因为它们无法读取

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

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

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

现在无法读取表达式树-无法分解SomeComplexCheck。SQL语句将在没有where的情况下执行，并且数据中的每一行都将通过一些ComplexCheck进行检查

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

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

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

这也有一个“内联”函数，但这一次它只是一个编译器魔法——C编译器将把它拆分成一个新的实例方法，并使用一个自动生成的名称

---

匿名方法无法读取，因此无法将逻辑转换为lambda函数的逻辑。

Ruby中的lambda示例如下：

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

hello.call

将生成以下输出：

Hello
I am inside a proc

---

@Brian我一直在C中使用lambdas，在LINQ和非LINQ运算符中。例如：

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

然而，C的lambda语法的有趣之处在于，它们本身无法推断它们的类型，也就是说，不能键入var foo=x，y=>x*y，但这取决于它们被分配到的类型，它们将被编译为代表表达式的委托或抽象语法树，这就是LINQ对象映射器如何实现语言集成的魔力

---

LISP中的lambda还可以传递给引号操作符，然后作为列表列表进行遍历。一些强大的宏就是这样生成的

我很难理解lambda表达式，因为我使用的是visualfoxpro，它有宏替换、ExecScript{}和求值函数，它们似乎也有同样的用途

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

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

使用正式lambdas的一个明确好处是我假设编译时检查：在Fox尝试运行之前，它不会知道您是否键入了上面的文本字符串

---

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

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)

---

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

例如，在Javascript中，函数被视为与int、string、float、bool等所有函数相同的混合类型。因此，您可以动态创建函数，将它们分配给对象，然后稍后再调用它们。它是有用的，但是，不是你想过度使用的东西，否则你会混淆所有在你之后维护你的代码的人

这是我用来查看兔子洞有多深的代码：

var x=新对象； x、 thingy=新阵列； x、 thingy[0]=函数{返回函数{返回函数{alert'index 0 pressed'；}；}；} x、 thingy[1]=函数{返回函数{返回函数{alert'index 1 pressed'；}；}；} x、 thingy[2]=函数{返回函数{返回函数{alert'index 2 pressed'；}；}；}

---

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

你好，Lambdas，版本1

---

lambda演算是一种一致的数学替代理论。例如，在学校数学中，我们可以看到x+y=5与x成对出现−y=1。除了操纵单个方程的方法外，还可以将这两个方程中的信息放在一起，前提是跨方程替换是合乎逻辑的。Lambda calculu s规定了进行这些替换的正确方法

假设y=x−1是第二个方程的有效重排，即：λy=x−1表示替换符号x的函数−符号y为1。现在想象一下将λy应用于第一个方程中的每个项。如果术语为y，则进行替换；否则什么也不做。如果你在纸上这样做，你会看到应用λy将如何使第一个方程可解

这是一个没有任何计算机科学或编程的答案

我能想到的最简单的编程示例来自：

下面是如何在命令行中定义square函数 编程语言C：

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

变量x是一个形式参数，由实际值替换 调用函数时要平方的值。以功能性的方式 将定义相同功能的语言方案：

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

这在许多方面是不同的，但它仍然使用形式参数 以同样的方式

增加：

---

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

---

但在编程语言中，它是不同的。这是一段声明到位的代码，可以作为一等公民传递。这个概念似乎很有用，因此几乎所有流行的现代编程语言都用到了它。这个问题已经得到了正式的回答，所以我不想再多说了

对于一个对数学或编程知之甚少或一无所知的人来说，我会用非常简单、非正式的话来解释它，就像一台小型机器或盒子，它接受一些输入，做一些工作，产生一些输出，没有特定的名称，但我们知道它在哪里，通过这些知识，我们使用它

---

实际上，对于一个知道函数是什么的人来说，我会告诉他们，它是一个没有名字的函数，通常放在内存中的某个点上，可以通过引用该内存来使用，通常通过使用变量来使用-如果他们听说过函数指针的概念，我会把它们当作一个类似的概念来使用——这个答案涵盖了非常基本的内容，没有提到闭包等，但你可以很容易地理解这一点。

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

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

编程中的“函数”一词也不同——我们有一个函数，它是从拉丁语perform开始的一系列步骤。在数学中，它是关于变量之间的相关性

函数式语言正试图尽可能地与数学公式相似，它们的词义几乎相同。但在其他编程语言中，我们的情况有所不同

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

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

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

让我们从作业开始，了解lambdas作为一名具有基础算术背景的大一新生

分配蓝图为“名称=值”，请参见：

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

“x”、“y”是名称，“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

现在可以了，如果你坚持把两条独立的线合并成一条呢。 兰姆达来了

它适用于简单语句，python中有11种类型

复合语句呢

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

来了，让它工作吧

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'的函数

尝试：

这里有两个名称'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是一个内联函数，它使您能够像在数学中一样在一条直线上编写函数 兰姆达是匿名的

---

希望，这会有所帮助。

这个问题已经得到了充分的回答，我不想详细说明。我想分享一下在rust中编写数值计算时的用法

这里有一个lambdaanonymous函数的示例

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

当我写牛顿-拉斐逊法的模块时，它被用作一阶和二阶导数。如果你想知道什么是牛顿?

---

复杂函数有助于理解lambda函数的优点，这比简单函数的优点多得多，因为简单函数看起来没有太多的优化。这是使用lambda函数的第一个解释/示例，让我清楚了它的含义。感谢您，Amda表达式解释得很好。请参阅lambda函数在各种语言中的外观，以及它们是在哪一年在这些语言中引入的。我认为您使用λ：λ->λ实际上是混乱和无效的。Visual Fox Pro。这让我想起了很久以前的事了。lambda函数仅限于一个表达式-这实际上不是真的。C有语句lambda，您可以在其中将代码块作为一个体，这与许多其他语言相同。也许您应该提到，python的lambda在某处。@Cool I die这意味着lambda是python中位于顶部的函数对象

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

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

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

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

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

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

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

f=98.000000       df=20.000000

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

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

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

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


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

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

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

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

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

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

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

reverseOrder = coffee.sorted(by: >)

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

<class 'function'>

Hello

Hello Worl
Hello Worl

Hello Worl
<class 'function'>

Hello Worl
Hello Worl
None
None