pricing - lambda funktion java




Was ist ein Lambda(Funktion)? (13)

Was ist ein Lambda in der Welt der Informatik für eine Person ohne einen Comp-sci-Hintergrund?

Ich werde es Schritt für Schritt intuitiv in einfachen und lesbaren Python-Codes veranschaulichen.

Kurz gesagt, ein Lambda ist nur eine anonyme und Inline-Funktion.

Beginnen wir mit der Aufgabe, lambdas als Neuling mit Grundkenntnissen zu verstehen.

Der Blueprint der Zuweisung ist 'der Name = Wert', siehe:

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

'x', 'y' sind Namen und 1, 'value' sind Werte. Versuchen Sie eine Funktion in Mathematik

In [4]: m = n**2 + 2*n + 1
NameError: name 'n' is not defined

Fehlerberichte,
Sie können eine Mathematik nicht direkt als Code schreiben, 'n' sollte definiert oder einem Wert zugewiesen werden.

In [8]: n = 3.14
In [9]: m = n**2 + 2*n + 1
In [10]: m
Out[10]: 17.1396

Es funktioniert jetzt, was, wenn Sie darauf bestehen, die zwei getrennten Linien zu einem zu kombinieren. Da kommt lambda

In [13]: j = lambda i: i**2 + 2*i + 1
In [14]: j
Out[14]: <function __main__.<lambda>>

Keine Fehler gemeldet.

Dies ist ein Blick auf lambda , es ermöglicht Ihnen, eine Funktion in einer einzigen Zeile zu schreiben, wie Sie in Mathematik direkt in den Computer tun.

Wir werden es später sehen.

Lasst uns weiter nach "Zuweisung" suchen.

Wie oben dargestellt, funktioniert das Gleichheitszeichen = für einfache Daten (1 und "Wert") und einfachen Ausdruck (n ** 2 + 2 * n + 1).

Versuche dies:

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

Es funktioniert für einfache Aussagen, es gibt 11 Arten von ihnen in Python 7. Einfache Anweisungen - Python 3.6.3 Dokumentation

Wie wäre es mit einer zusammengesetzten Aussage,

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

Es kommt def aktivieren es funktioniert

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

Tada, analysiere es, 'm' ist der Name, 'n ** 2 + 2 * n + 1' ist der Wert. : ist eine Variante von '='.
Finden Sie es, wenn nur für das Verständnis, alles beginnt mit der Aufgabe und alles ist Aufgabe.

Jetzt zurück zu lambda , wir haben eine Funktion namens 'm'

Versuchen:

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

Es gibt zwei Namen von 'm' hier, Funktion m bereits einen Namen, dupliziert.

Es ist wie folgt formatiert:

In [27]: m = def m(n):
    ...:         if n > 0:
    ...:             return n**2 + 2*n + 1
    SyntaxError: invalid syntax

Es ist keine clevere Strategie, also Fehlermeldungen

Wir müssen einen von ihnen löschen, eine Funktion ohne einen Namen festlegen.

m = lambda n:n**2 + 2*n + 1

Es heißt "anonyme Funktion"

Abschließend,

  1. lambda in einer Inline-Funktion, die es Ihnen ermöglicht, eine Funktion in einer geraden Linie wie in der Mathematik zu schreiben
  2. lambda ist anonym

Hoffe das hilft.

Was ist ein Lambda in der Welt der Informatik für eine Person ohne einen Comp-sci-Hintergrund?


@ Brian Ich benutze lambdas die ganze Zeit in C #, in LINQ und Nicht-LINQ-Operatoren. Beispiel:

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

Vor C # verwendete ich anonyme Funktionen in JavaScript für Callbacks zu AJAX-Funktionen, bevor der Begriff Ajax überhaupt geprägt wurde:

getXmlFromServer(function(result) {/*success*/}, function(error){/*fail*/});

Das Interessante an C # 's Lambdasyntax ist jedoch, dass ihr Typ selbst nicht eingegeben werden kann (dh Sie können nicht var foo = (x, y) => x * y) eingeben, aber abhängig davon, um welchen Typ es sich handelt zugewiesen werden, werden sie als Delegaten oder abstrakte Syntaxbäume kompiliert, die den Ausdruck darstellen (auf diese Weise erledigen LINQ-Objektmapper ihre "sprachintegrierte" Magie).

Lambdas in LISP können auch an einen Angebotsoperator übergeben und dann als Liste von Listen durchlaufen werden. Einige mächtige Makros werden auf diese Weise erstellt.


Der Name "Lambda" ist nur ein historisches Artefakt. Wir reden nur von einem Ausdruck, dessen Wert eine Funktion ist.

Ein einfaches Beispiel (mit Scala für die nächste Zeile) ist:

args.foreach(arg => println(arg))

wobei das Argument der foreach Methode ein Ausdruck für eine anonyme Funktion ist. Die obige Zeile ist mehr oder weniger dasselbe wie etwas so zu schreiben (nicht ganz richtiger Code, aber Sie werden die Idee bekommen):

void printThat(Object that) {
  println(that)
}
...
args.foreach(printThat)

außer dass Sie sich nicht damit beschäftigen müssen:

  1. Die Funktion an einem anderen Ort deklarieren (und danach suchen, wenn Sie den Code später erneut aufrufen).
  2. Benennen Sie etwas, das Sie nur einmal verwenden.

Sobald Sie daran gewöhnt sind, Werte zu verwenden, ist der Verzicht auf sie so albern wie nötig, um jeden Ausdruck zu benennen, wie zum Beispiel:

int tempVar = 2 * a + b
...
println(tempVar)

anstatt nur den Ausdruck zu schreiben, wo Sie ihn brauchen:

println(2 * a + b)

Die genaue Schreibweise variiert von Sprache zu Sprache; Griechisch ist nicht immer erforderlich! ;-)


Die Frage wird formal sehr beantwortet, also werde ich nicht versuchen, mehr dazu hinzuzufügen.

In sehr einfachen, informellen Worten zu jemandem, der sehr wenig oder nichts über Mathe oder Programmierung weiß, würde ich es als eine kleine "Maschine" oder "Box" erklären, die etwas Input nimmt, etwas Arbeit macht und etwas produziert, keinen bestimmten Namen hat Aber wir wissen, wo es ist, und durch dieses Wissen benutzen wir es.

Praktisch gesagt, würde ich für eine Person, die weiß, was eine Funktion ist, ihnen sagen, dass es sich um eine Funktion handelt, die keinen Namen hat, normalerweise an einen Punkt im Speicher gelegt wird, der nur durch Bezugnahme auf diesen Speicher verwendet werden kann (normalerweise über die Verwendung von eine Variable - wenn sie von dem Konzept der Funktionszeiger gehört haben, würde ich sie als ein ähnliches Konzept verwenden - diese Antwort deckt die schönen Grundlagen ab (keine Erwähnung von Schließungen usw.), aber man kann es leicht verstehen.


Ein Lambda ist ein inline definierter Funktionstyp. Zusammen mit einem Lambda haben Sie normalerweise auch eine Art von Variablentyp, der einen Verweis auf eine Funktion, Lambda oder anders, enthalten kann.

Zum Beispiel ist hier ein C # Stück Code, der kein Lambda verwendet:

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);
}

Dies ruft Calculator auf, wobei nicht nur zwei Zahlen weitergegeben werden, sondern welche Methode innerhalb Calculator aufgerufen wird, um die Ergebnisse der Berechnung zu erhalten.

In C # 2.0 haben wir anonyme Methoden, die den oben genannten Code verkürzt:

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;
    });
}

Und dann haben wir in C # 3.0 lambdas, was den Code noch kürzer macht:

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);
}

Es bezieht sich auf den Lambda-Kalkül , ein formales System, das nur Lambda-Ausdrücke hat, die eine Funktion darstellen, die eine Funktion für ihr einziges Argument übernimmt und eine Funktion zurückgibt. Alle Funktionen im Lambda-Kalkül sind von diesem Typ, dh λ : λ → λ .

Lisp verwendete das Lambda-Konzept, um seine anonymen Funktionsliterale zu benennen. Dieses Lambda stellt eine Funktion dar, die zwei Argumente, x und y, akzeptiert und ihr Produkt zurückgibt:

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

Es kann inline wie folgt angewendet werden (ergibt 50 ):

((lambda (x y) (* x y)) 5 10)

Etwas vereinfacht: Eine Lambda-Funktion ist eine Funktion, die an andere Funktionen weitergegeben werden kann und auf die logisch zugegriffen werden kann.

In C # wird die Lambda-Syntax oft wie einfache Methoden zu einfachen Methoden kompiliert, aber sie kann auch zerlegt und ihre Logik gelesen werden.

Zum Beispiel (in C # 3):

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

LinqToSql kann diese Funktion lesen (x> 15) und sie in das eigentliche SQL konvertieren, das mit Ausdrucksbäumen ausgeführt wird.

Die obige Aussage wird:

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

Dies unterscheidet sich von normalen Methoden oder anonymen Delegaten (die nur Compilermagie sind), weil sie nicht gelesen werden können .

Nicht alle Methoden in C #, die Lambda-Syntax verwenden, können in Ausdrucksbäume kompiliert werden (dh tatsächliche Lambda-Funktionen). Zum Beispiel:

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

Nun kann der Ausdrucksbaum nicht mehr gelesen werden - SomeComplexCheck kann nicht aufgelöst werden. Die SQL-Anweisung wird ohne where ausgeführt, und jede Zeile in den Daten wird über SomeComplexCheck .

Lambda-Funktionen sollten nicht mit anonymen Methoden verwechselt werden. Zum Beispiel:

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

Dies hat auch eine Inline-Funktion, aber dieses Mal ist es nur Compiler-Magie - der C # -Compiler wird dies in eine neue Instanzmethode mit einem automatisch generierten Namen aufteilen.

Anonyme Methoden können nicht gelesen werden, daher kann die Logik nicht wie für Lambda-Funktionen übersetzt werden.


Ich habe Mühe, meinen Kopf um Lambda-Ausdrücke zu wickeln, weil ich in Visual FoxPro arbeite, das Makro-Ersetzung und die Funktionen ExecScript {} und Evaluate () hat, die dem gleichen Zweck zu dienen scheinen.

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

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

Ein eindeutiger Vorteil für die Verwendung von formalen Lambdas ist (ich nehme an) Kompilierzeitüberprüfung: Fox wird nicht wissen, ob Sie die Textzeichenfolge oben tippen, bis es versucht, es auszuführen.

Dies ist auch nützlich für datengesteuerten Code: Sie können ganze Routinen in Memofeldern in der Datenbank speichern und dann nur zur Laufzeit auswerten. Dadurch können Sie einen Teil der Anwendung optimieren, ohne tatsächlich auf die Quelle zugreifen zu müssen. (Aber das ist ein anderes Thema insgesamt.)



Im Kontext von CS ist eine Lambda-Funktion ein abstraktes mathematisches Konzept, das ein Problem der symbolischen Bewertung von mathematischen Ausdrücken anpackt. In diesem Zusammenhang ist eine Lambda-Funktion die gleiche wie ein Lambda-Ausdruck .

Aber in Programmiersprachen ist es etwas anderes. Es ist ein Stück Code, das "an Ort und Stelle" erklärt wird, und das kann als "erstklassiger Bürger" weitergegeben werden. Dieses Konzept schien nützlich zu sein, so dass es in fast allen gängigen modernen Programmiersprachen vorkam (siehe Lambda-Funktionen, die man überallhin findet ).


In der Computerprogrammierung ist Lambda ein Stück Code (Aussage, Ausdruck oder eine Gruppe von ihnen), die einige Argumente von einer externen Quelle nimmt. Es muss nicht immer eine anonyme Funktion sein - wir haben viele Möglichkeiten, sie zu implementieren.

Wir haben eine klare Trennung zwischen Ausdrücken, Aussagen und Funktionen, die Mathematiker nicht haben.

Das Wort "Funktion" in der Programmierung ist auch anders - wir haben "Funktion ist eine Reihe von Schritten zu tun" (aus dem Lateinischen "perform"). In Mathe ist es etwas über die Korrelation zwischen Variablen.

Funktionelle Sprachen versuchen, den mathematischen Formeln so ähnlich wie möglich zu sein, und ihre Wörter bedeuten fast dasselbe. Aber in anderen Programmiersprachen haben wir es anders.


Lambda stammt aus dem Lambda-Kalkül und bezieht sich auf anonyme Funktionen in der Programmierung.

Warum ist das cool? Es erlaubt Ihnen, schnelle Wegwerffunktionen zu schreiben, ohne sie zu benennen. Es bietet auch eine gute Möglichkeit, Schließungen zu schreiben. Mit dieser Kraft kannst du solche Dinge tun.

Python

def adder(x):
    return lambda y: x + y
add5 = adder(5)
add5(1)
6

Wie Sie aus dem Ausschnitt von Python sehen können, nimmt der Funktionsaddierer ein Argument x auf und gibt eine anonyme Funktion oder Lambda zurück, die ein anderes Argument y verwendet. Diese anonyme Funktion ermöglicht es Ihnen, Funktionen aus Funktionen zu erstellen. Dies ist ein einfaches Beispiel, aber es sollte die Macht Lambdas und Schließungen haben.

Beispiele in anderen Sprachen

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

Planen

(define adder
    (lambda (x)
        (lambda (y)
           (+ x y))))
(define add5
    (adder 5))
(add5 1)
6

C # 3.5 oder höher

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);

Schnell

func adder(x: Int) -> (Int) -> Int{
   return { y in x + y }
}
let add5 = adder(5)
add5(1)
6

PHP

$a = 1;
$b = 2;

$lambda = function () use (&$a, &$b) {
    echo $a + $b;
};

echo $lambda();

Haskell

(\x y -> x + y) 

Java diesen Beitrag sehen

// 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





theory