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

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

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

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

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

因为我在这里看不到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();
}

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

你可以把它看作一个匿名函数-这里有更多信息：Wikipedia-匿名函数

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

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

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

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

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

你看，对客户来说并没有什么区别，也并没有浪费时间去思考如何发送食物。只要发送它。

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