¿Qué es un lambda (función)?
https://stackoverflow.com/questions/16501
-
08-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Para una persona sin comp-sci fondo, ¿qué es un lambda en el mundo de la informática?
Solución
Lambda viene de la Cálculo Lambda y se refiere a las funciones anónimas en la programación.
¿Por qué es este lugar?Permite escribir rápido tirar funciones sin nombrarlos.También proporciona una buena manera de escribir los cierres.Con ese poder puede hacer cosas como esta.
Python
def adder(x):
return lambda y: x + y
add5 = adder(5)
add5(1)
6
Como se puede ver en el fragmento de código de Python, la función de serpiente tiene un argumento x, y devuelve una función anónima, o lambda, que tiene otro argumento y.Que función anónima permite crear funciones a partir de funciones.Este es un ejemplo sencillo, pero que debe transmitir la potencia de lambdas y cierres.
Ejemplos en otros idiomas
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
Esquema de
(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);
Swift
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 ver este post
// 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
Kotlin
val pred = { x: Int -> x % 2 == 0 }
val result = pred(4) // true
Ruby
Ruby es ligeramente diferente en el que no puedes llamar a un lambda de utilizar exactamente la misma sintaxis que llama a una función, pero todavía tiene lambdas.
def adder(x)
lambda { |y| x + y }
end
add5 = adder(5)
add5[1] == 6
Ruby se Ruby, no es una abreviación de lambdas, así se puede definir adder de esta manera:
def adder(x)
-> y { x + y }
end
Otros consejos
Una expresión lambda es un tipo de función, definida en línea.Junto con un lambda también suelen tener algún tipo de tipo de variable que puede contener una referencia a una función lambda o de otra manera.
Por ejemplo, este es un C# trozo de código que no uso un lambda:
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);
}
Esto requiere Calculadora, pasando a lo largo no sólo de dos números, pero el método de llamada en el interior de la Calculadora para obtener los resultados del cálculo.
En C# 2.0 tenemos los métodos anónimos, por lo que se acorta el anterior código:
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;
});
}
Y, a continuación, en C# 3.0 tenemos lambdas que hace el código es aún más corto:
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);
}
Se refiere a cálculo lambda, que es un sistema formal que sólo ha expresiones lambda, que representan una función que toma una función para su único argumento y devuelve una función.Todas las funciones en el cálculo lambda son de ese tipo, es decir, λ : λ → λ.
Lisp utiliza la expresión lambda concepto a nombre de su función anónima literales.Este lambda representa una función que toma dos argumentos, x y y, y devuelve su producto:
(lambda (x y) (* x y))
Puede ser aplicado en-línea como esta (se evalúa a 50):
((lambda (x y) (* x y)) 5 10)
El nombre de "lambda" es sólo un artefacto histórico.Todo lo que estamos hablando es una expresión cuyo valor es una función.
Un simple ejemplo (usando Scala para la línea siguiente) es:
args.foreach(arg => println(arg))
donde el argumento de la foreach el método es una expresión para una función anónima.La línea de arriba es más o menos lo mismo que escribir algo como esto (no muy real de código, pero usted consigue la idea):
void printThat(Object that) {
println(that)
}
...
args.foreach(printThat)
excepto que usted no tiene que molestarse con:
- Declarar la función en algún otro lugar (y tener que buscarlo cuando tienes que revisar el código más adelante).
- Nombrar algo que solo se uso una vez.
Una vez que estás acostumbrado a los valores de la función, no les parece tan absurdo como estar obligado a nombre de cada una de sus expresiones, tales como:
int tempVar = 2 * a + b
...
println(tempVar)
en lugar de sólo escribir la expresión donde la necesita:
println(2 * a + b)
La exacta notación varía de un idioma a otro;Griego no siempre es necesario!;-)
El cálculo lambda es una constante matemática de la teoría de la sustitución.En la escuela de matemáticas que uno ve por ejemplo x+y=5 emparejado con x−y=1.Junto con formas de manipular las ecuaciones individuales también es posible poner la información de estos dos juntos, siempre de la cruz-la ecuación de sustituciones se realizan de forma lógica.Cálculo Lambda codifica la forma correcta de hacer estas sustituciones.
Dado que y = x−1 es válido el reordenamiento de la segunda ecuación, esta: λ y = x−1 significa una función de la sustitución de los símbolos x−1 para el símbolo y.Ahora imagina la aplicación de λ y a cada término de la primera ecuación.Si un término es y luego de realizar la sustitución;de lo contrario, no hacer nada.Si usted hace esto, sobre el papel, verás cómo solicitar que λ y será la primera ecuación solucionable.
Esa es una respuesta sin ningún ciencias de la computación o programación.
El más simple de programación de ejemplo que se me ocurre viene de http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works:
aquí es cómo el cuadrado de la función se puede definir en un imperativo lenguaje de programación (C):
int square(int x) { return x * x; }La variable x es un parámetro formal que es sustituida por el real valor a elevar al cuadrado cuando se llama a la función.En un funcional idioma (Esquema) de la misma función que podría ser definido:
(define square (lambda (x) (* x x)))Esto es diferente en muchos aspectos, pero todavía se utiliza el parámetro formal x de la misma manera.
Añadió: http://imgur.com/a/XBHub
Ligeramente simplificada:una función lambda es uno que se puede pasar de ronda a otras funciones, y es la lógica de acceso.
En C# sintaxis lambda es a menudo compilado a los métodos simples de la misma manera como los delegados anónimos, pero también puede ser descompuesto y su lógica de lectura.
Por ejemplo (en C#3):
LinqToSqlContext.Where(
row => row.FieldName > 15 );
LinqToSql puede leer que la función (x > 15) y convertirlo en el real de SQL para ejecutar usando árboles de expresión.
La declaración anterior se convierte en:
select ... from [tablename]
where [FieldName] > 15 --this line was 'read' from the lambda function
Esto es diferente de los métodos normales o delegados anónimos (que son sólo compilador de la magia) porque no se puede leer.
No todos los métodos en C# que el uso de la lambda de la sintaxis puede ser compilado para árboles de expresión (es decir,real de las funciones lambda).Por ejemplo:
LinqToSqlContext.Where(
row => SomeComplexCheck( row.FieldName ) );
Ahora el árbol de expresión no se puede leer - SomeComplexCheck no se puede descomponer.La instrucción SQL que se ejecutará sin el dónde, y cada fila de los datos se pondrán a través de SomeComplexCheck.
Las funciones Lambda no debe ser confundido con métodos anónimos.Por ejemplo:
LinqToSqlContext.Where(
delegate ( DataRow row ) {
return row.FieldName > 15;
} );
Esto también tiene un 'inline' función, pero esta vez es sólo el compilador de magia - el compilador de C# va a dividir esto en un nuevo método de instancia con un nombre generado automáticamente.
Los métodos anónimos no se puede leer, y así que la lógica no puede ser traducido como puede para las funciones lambda.
Me gusta la explicación de las Lambdas en este artículo: La Evolución De LINQ Y Su Impacto En El Diseño De C#.Es de hace un montón de sentido para mí, ya que muestra un mundo real para Lambdas y la construye como un ejemplo práctico.
Su explicación rápida:Las Lambdas son una forma de tratar de código (funciones) como de datos.
Un ejemplo de una expresión lambda en Ruby es como sigue:
hello = lambda do
puts('Hello')
puts('I am inside a proc')
end
hello.call
Se genereate el siguiente resultado:
Hello
I am inside a proc
@Brian yo uso lambdas todo el tiempo en C#, en LINQ y no los operadores de LINQ.Ejemplo:
string[] GetCustomerNames(IEnumerable<Customer> customers)
{ return customers.Select(c=>c.Name);
}
Antes de C#, he utilizado anónimo funciones en JavaScript para las devoluciones de llamada de funciones AJAX, antes de que el término Ajax fue incluso acuñó:
getXmlFromServer(function(result) {/*success*/}, function(error){/*fail*/});
Lo interesante con C#'s lambda sintaxis, sin embargo, es que en su propia su tipo no puede ser infered (es decir, que no se puede escribir var foo = (x,y) => x * y) pero dependiendo de que tipo son asignados, que van a ser compilado como delegados o de sintaxis abstracta de los árboles que representan la expresión (que es como LINQ objeto de mappers hacer su "lenguaje integrado" magia).
Las Lambdas en LISP también se pueden pasar un presupuesto operador y entonces atravesó como una lista de listas.Algunos potentes macros se hizo de esta manera.
La pregunta es formalmente respondió, en gran medida, así que voy a tratar de no agregar más sobre esto.
En muy simple, informal palabras de alguien que sabe muy poco o nada acerca de las matemáticas o de la programación, me gustaría explicar es como una pequeña "máquina" o "cuadro" que se lleva a algunos de entrada, hace que el trabajo de algunos y produce alguna salida, no tiene ningún nombre en particular, pero sabemos de dónde es y por solo este conocimiento, la usamos.
Prácticamente hablando, para una persona que sabe lo que es una función, yo les diría que se trata de una función que no tiene nombre, generalmente se ponen a un punto en la memoria que puede ser utilizado simplemente haciendo referencia a que la memoria (por lo general mediante el uso de una variable de si han escuchado sobre el concepto de la función de los punteros, me gustaría usarlos como un concepto similar) - esta respuesta cubre bastante basico (sin mención de cierres, etc), pero se puede obtener el punto fácilmente.
Usted puede pensar en él como una función anónima - he aquí algo más de información: Wikipedia - Función Anónima
Sólo porque yo no puedo ver una C++11 ejemplo aquí, voy a seguir adelante y publicar este bonito ejemplo de aquí.Después de la búsqueda, es el lenguaje más claro ejemplo específico que he podido encontrar.
Hola, Lambdas, versión 1
template<typename F>
void Eval( const F& f ) {
f();
}
void foo() {
Eval( []{ printf("Hello, Lambdas\n"); } );
}
Hola, Lambdas, versión 2:
void bar() {
auto f = []{ printf("Hello, Lambdas\n"); };
f();
}
Tengo problemas para envolver mi cabeza alrededor de las expresiones lambda, ya que yo trabajo en Visual FoxPro, que tiene la sustitución de Macros y la ExecScript{} y Evaluar las funciones (), que parecen servir el mismo propósito.
? Calculator(10, 23, "a + b")
? Calculator(10, 23, "a - b");
FUNCTION Calculator(a, b, op)
RETURN Evaluate(op)
Un claro beneficio para el uso formal de las lambdas es (supongo) en tiempo de compilación de la comprobación:Fox no va a saber si usted errata de la cadena de texto de arriba hasta que se intenta ejecutarlo.
Esto también es útil para los datos de código basada en:usted puede almacenar toda la rutina en campos memo en la base de datos y, a continuación, sólo evalúan en tiempo de ejecución.Esto le permite ajustar la parte de la aplicación sin necesidad de tener acceso a la fuente.(Pero eso es otro tema por completo.)
Para una persona sin comp-sci fondo, ¿qué es un lambda en el mundo de la informática?
Voy a ilustrar de forma intuitiva, paso por paso, simple y legible de python códigos.
En definitiva, una expresión lambda es sólo un anónimo y función en línea.
Vamos a empezar a partir de la asignación a entender lambdas como un estudiante de primer año con el fondo de la aritmética básica.
El modelo de asignación es el "nombre = valor", ver:
In [1]: x = 1
...: y = 'value'
In [2]: x
Out[2]: 1
In [3]: y
Out[3]: 'value'
'x', 'y' son y nombres 1, 'valor' son los valores.Intente una función en matemáticas
In [4]: m = n**2 + 2*n + 1
NameError: name 'n' is not defined
Los informes de errores,
usted no puede escribir un matemático directamente como código,'n' debe ser definida o ser asignado a un valor.
In [8]: n = 3.14
In [9]: m = n**2 + 2*n + 1
In [10]: m
Out[10]: 17.1396
Funciona ahora,lo que si insisten en la combinación de los dos seperarte líneas a uno.Llega lambda
In [13]: j = lambda i: i**2 + 2*i + 1
In [14]: j
Out[14]: <function __main__.<lambda>>
No hay errores reportados.
Este es un vistazo en lambda, se le permite escribir una función en una sola línea, como en matemáticas en el ordenador directamente.
Vamos a ver más adelante.
Vamos a continuar profundizando en "asignación".
Como se ilustra arriba, el símbolo es igual a = obras de datos simples(1 y 'valor') el tipo y la expresión simple(n**2 + 2*n + 1).
Intente esto:
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
Funciona para las simples declaraciones,hay 11 tipos de ellos en python 7.Declaraciones simples — Python 3.6.3 documentación
Cómo acerca de la instrucción compuesta,
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
Llega def permiten trabajar
In [23]: def m(n):
...: if n > 0:
...: return n**2 + 2*n + 1
...:
In [24]: m(2)
Out[24]: 9
Tada, analizar, 'm' es el nombre, 'n**2 + 2*n + 1 es el valor.: es una variante de '='.
Encontrar, si sólo para la comprensión, todo comienza a partir de la asignación y todo lo de la cesión.
Ahora regrese a lambda, tenemos una función denominada 'm'
Probar:
In [28]: m = m(3)
In [29]: m
Out[29]: 16
Hay dos nombres de la 'm' aquí, la función de m ya tiene un nombre, duplicado.
Es el formato como:
In [27]: m = def m(n):
...: if n > 0:
...: return n**2 + 2*n + 1
SyntaxError: invalid syntax
No es una estrategia inteligente, por lo que los informes de errores
Tenemos que eliminar uno de ellos,establecer una función sin nombre.
m = lambda n:n**2 + 2*n + 1
Se llama "función anónima'
En conclusión,
lambdaen una función en línea que le permiten escribir una función en una línea recta como se hace en matemáticaslambdaes anónimo
Esperanza esto ayuda.
Es una función que no tiene nombre.Por ejemplo,en c# se puede utilizar
numberCollection.GetMatchingItems<int>(number => number > 5);
para volver a los números que son mayores que 5.
number => number > 5
es la lambda parte aquí.Representa una función que toma un parámetro (número) y devuelve un valor booleano (número > 5).GetMatchingItems método utiliza este lambda en todos los elementos de la colección y devuelve los elementos coincidentes.
En Javascript, por ejemplo, las funciones son tratados como el mismo tipo mixto, como todo lo demás (int, string, float, bool).Como tal, puede crear funciones sobre la marcha, se les asigne a las cosas, y llame de nuevo más tarde.Es útil, pero, no es algo que desea utilizar o te vas a confundir a todo el que tiene que mantener el código después de...
Este es el código que estaba jugando conmigo a ver la profundidad de este agujero del conejo va:
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]()()();
En el contexto de CS una función lambda es un abstracto concepto matemático que aborda un problema de la evaluación simbólica de expresiones matemáticas.En ese contexto una función lambda es igual a un lambda plazo.
Pero en los lenguajes de programación es algo diferente.Es un pedazo de código que se declara "en el lugar", y que puede ser pasado como un "ciudadanos de primera categoría".Este concepto apareció a ser útil, así que vino en casi todos los lenguajes de programación modernos (ver las funciones lambda everwhere post).
Yo tengo demasiado.Yo lo he probado en JS con esto:
var addAndMult = function(x) {
return (function(y) {
return (function(z) {
return (x+y)*z;
});
});
};
Agrega de 2 a 4, a continuación, mults el resultado por 6.Sin embargo me resulta a veces difícil de leer :(
También he hecho una interesante función forEach:
var forEach = function(arr) {
return (function(x) {
for (var i=0; arr[i]; i++) {
x(arr[i]);
}
});
}
forEach([1,2,3,4,5])(consola.de registro);
Este método se repite una matriz y realiza una acción - en el caso de la impresión de la consola.Ahora tengo demasiado por qué labmdas son poderosos.
En la programación de computadoras, lambda es una pieza de código (declaración, la expresión o un grupo de ellos) que tiene algunos argumentos desde una fuente externa.No siempre debe ser una función anónima - tenemos muchas maneras de ponerlas en práctica.
Tenemos una clara separación entre las expresiones, sentencias y funciones, que los matemáticos no tienen.
La palabra "función" en la programación también es diferente, tenemos "la función es una serie de pasos para hacer" (del latín "llevar a cabo").En matemáticas es algo acerca de la correlación entre las variables.
Los lenguajes funcionales están tratando de ser lo más parecido a fórmulas matemáticas como sea posible, y sus palabras significan casi lo mismo.Pero en otros lenguajes de programación que tienen es diferente.
Un
Lambda Function, o unSmall Anonymous Function, es un auto-contenidos bloque de funcionalidad que puede ser pasado y se utiliza en el código.Lambda tiene diferentes nombres en diferentes lenguajes de programación –Lambdaen Python y Kotlin,Closureen Swift, oBlocken C y Objective-C.Aunque lambda significado es muy similar para estos idiomas se tiene ligeras distinciones a veces.
Vamos a ver cómo Lambda (Cierre) trabaja en Swift 4.2 con ordenada() método de la función normal hasta que el menor expresión:
let coffee: [String] = ["Cappuccino", "Espresso", "Latte", "Ristretto"]
1.La Función Normal
func backward(_ n1: String, _ n2: String) -> Bool {
return n1 > n2
}
var reverseOrder = coffee.sorted(by: backward)
// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]
2.Cierre De Expresión
reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in
return n1 > n2
})
3.En Línea De Cierre De La Expresión
reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in return n1 > n2 } )
4.Inferir El Tipo De Contexto
reverseOrder = coffee.sorted(by: { n1, n2 in return n1 > n2 } )
5.Implícito Devuelve a partir de una Sola Expresión Cierres
reverseOrder = coffee.sorted(by: { n1, n2 in n1 > n2 } )
6.De Taquigrafía Los Nombres De Los Argumentos
reverseOrder = coffee.sorted(by: { $0 > $1 } )
// $0 and $1 are closure’s first and second String arguments.
7.Operador De Métodos
reverseOrder = coffee.sorted(by: >)
// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]
Espero que esto ayude.
La pregunta ha sido respondida completamente, no quiero entrar en detalles.Quiero compartir el uso de la escritura de computación numérica en rust.
Hay un ejemplo de una expresión lambda(función anónima)
let f = |x: f32| -> f32 { x * x - 2.0 };
let df = |x: f32| -> f32 { 2.0 * x };
Cuando yo estaba escribiendo un módulo de Newton–Raphson método, se utilizó como primer y segundo orden derivados.(Si quieres saber lo que es el Newton–Raphson método, por favor visite "https://en.wikipedia.org/wiki/Newton%27s_method".
La salida como la siguiente
println!("f={:.6} df={:.6}", f(10.0), df(10.0))
f=98.000000 df=20.000000
Imagine que usted tiene un restaurante con una opción de entrega y usted tiene una orden de que se necesita hacer en menos de 30 minutos.El punto es que los clientes a menudo no importa si usted envía su comida moto con un coche o descalzo mientras se mantenga la comida caliente y atado.Así que vamos a convertir este modismo para Javascript con anónimo y define las funciones de transporte.
A continuación se define la forma de nuestra entrega aka definimos un nombre para una función:
// ES5
var food = function withBike(kebap, coke) {
return (kebap + coke);
};
¿Qué pasa si queremos usar la flecha/lambda funciones a realizar esta transferencia:
// ES6
const food = (kebap, coke) => { return kebap + coke };
Se ve que no hay diferencia para el cliente y no perder el tiempo para pensar acerca de cómo enviar los alimentos.Sólo tiene que enviar.
Por cierto, no recomiendo el kebap con coca-cola esta es la razón por la parte superior de códigos de dar errores.La diversión.
