Answers:
Lambda来自Lambda微积分,是指编程中的匿名函数。
为什么这很酷?它允许您编写快速抛出的函数而无需命名它们。它还提供了编写闭包的好方法。有了这种能力,您就可以做这样的事情。
蟒蛇
def adder(x):
return lambda y: x + y
add5 = adder(5)
add5(1)
6
从Python片段中可以看到,函数加法器接受一个参数x,并返回一个带另一个参数y的匿名函数或lambda。该匿名函数允许您从函数创建函数。这是一个简单的示例,但它应该传达出lambda和闭包所具有的功能。
其他语言的例子
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
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
a
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
[R
adder <- function(x) {
function(y) x + y
}
add5 <- adder(5)
add5(1)
#> [1] 6
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);
}
Op
,还可以简单地使用Func<int, int>
Console.WriteLine("Calculator: op " + op.Method.Name + " (" + a + ", " + b + ") = " + op(a, b));
第一个例子。
名称“ 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)
确切的符号因语言而异;并非总是需要希腊语!;-)
λ演算是一种一致的替代数学理论。在学校数学中,例如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
略微简化: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函数一样被翻译出来。
我喜欢本文中对Lambda的解释:LINQ的演变及其对C#设计的影响。这对我来说很有意义,因为它显示了Lambdas的真实世界,并将其构建为实际示例。
他们的快速解释:Lambda是一种将代码(函数)视为数据的方法。
@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也可以传递给引号运算符,然后作为列表列表进行遍历。这样可以制作一些功能强大的宏。
这个问题在形式上得到了很好的回答,因此我将不尝试在此之上添加更多内容。
用一个非常简单,非正式的词来形容那些对数学或编程了解甚少或一无所知的人,我会把它解释为一个小的“机器”或“盒子”,它需要一些输入,进行一些工作并产生一些输出,没有特定的名称,但是我们知道它在哪里,仅凭这些知识,我们就可以使用它。
实际上,对于一个知道什么是函数的人,我会告诉他们这是一个没有名称的函数,通常放在内存中的某个点,可以仅通过引用该内存来使用(通常通过使用一个变量-如果他们听说过函数指针的概念,我会把它们用作类似的概念)-这个答案涵盖了相当基本的知识(没有提到闭包等),但是很容易理解这一点。
您可以将其视为匿名函数-以下是更多信息:Wikipedia-匿名函数
我在用lambda表达式包装时遇到了麻烦,因为我在Visual FoxPro中工作,它具有Macro替换以及ExecScript {}和Evaluate()函数,这些函数似乎具有相同的目的。
? Calculator(10, 23, "a + b")
? Calculator(10, 23, "a - b");
FUNCTION Calculator(a, b, op)
RETURN Evaluate(op)
使用正式的lambda的一个明显好处是(我认为)编译时检查:Fox在尝试运行它之前不会知道您是否在上面的文本字符串中打错字。
这对于数据驱动的代码也很有用:您可以将整个例程存储在数据库的备注字段中,然后在运行时对其进行评估。这使您可以调整应用程序的一部分,而无需实际访问源代码。(但这完全是另一个主题。)
对于没有计算机科学背景的人来说,计算机科学世界中的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
现在,如果您坚持将两条seperarte行组合为一条行之有效。来了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 7中有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'的函数
尝试:
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
是匿名的希望这可以帮助。
在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]()()();
在CS的上下文中,lambda函数是一个抽象的数学概念,解决了数学表达式的符号评估问题。在这种情况下,lambda函数与lambda项相同。
但是在编程语言中却有所不同。这是一段被声明为“就地”的代码,可以作为“一等公民”来传递。这个概念似乎很有用,因此几乎可以用在所有流行的现代编程语言中(请参阅lambda函数随处可见)。
A
Lambda Function
或aSmall Anonymous Function
是可以独立传递的功能块,可以在代码中传递和使用。LAMBDA在不同的编程语言不同的名字-Lambda
在Python中和科特林,Closure
在斯威夫特,或Block
在Ç和Objective-C中。尽管lambda的含义在这些语言中非常相似,但有时会有些许区别。
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"]
希望这可以帮助。
我也知道 我已经用这个在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);
在打印到控制台的情况下,此方法将迭代数组并执行操作。现在我也明白了为什么Labmdas功能强大。
这个问题已经得到了充分的解答,我不想详细介绍。我想分享在rust中编写数值计算时的用法。
有一个lambda(匿名函数)的例子
let f = |x: f32| -> f32 { x * x - 2.0 };
let df = |x: f32| -> f32 { 2.0 * x };
当我编写Newton–Raphson方法的模块时,它被用作一阶和二阶导数。(如果您想知道什么是Newton–Raphson方法,请访问“ 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
想象一下,您有一家提供送餐服务的餐厅,而您的订单需要在30分钟内完成。关键是客户通常不在乎您是否将食物加热并绑起来,而骑车还是赤脚骑自行车送他们的食物。因此,让我们使用匿名和已定义的传输函数将此惯用法转换为Javascript。
下面我们定义了传递方式,即我们定义了函数的名称:
// ES5
var food = function withBike(kebap, coke) {
return (kebap + coke);
};
如果我们使用arrow / lambda函数来完成此转移该怎么办:
// ES6
const food = (kebap, coke) => { return kebap + coke };
您会看到客户没有区别,也没有时间浪费在思考如何发送食物上。只是发送。
顺便说一句,我不建议将可乐与可乐混在一起,这就是为什么高位代码会给您带来错误的原因。玩得开心。