usar - servidor lambda




¿Qué es una lambda(función)? (14)

Para una persona sin antecedentes comp-sci, ¿qué es un lambda en el mundo de la informática?


Para una persona sin antecedentes comp-sci, ¿qué es un lambda en el mundo de la informática?

Lo ilustraré intuitivamente paso a paso en códigos Python simples y legibles.

En resumen, una lambda es solo una función anónima y en línea.

Empecemos por la tarea de entender a las lambdas como estudiantes de primer año con antecedentes de aritmética básica.

El plano 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 nombres y 1, 'valor' son valores. Probar una función en matemáticas.

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

Informes de error,
no puede escribir una matemática directamente como código, 'n' debe definirse o asignarse 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, y si insiste en combinar las dos líneas separadas en una. Viene lambda

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

No hay errores reportados.

Esta es una mirada a lambda , le permite escribir una función en una sola línea como lo hace en matemática en la computadora directamente.

Lo veremos más tarde.

Vamos a seguir profundizando en la 'asignación'.

Como se ilustra arriba, el símbolo igual = funciona para el tipo de datos simples (1 y 'valor') y la expresión simple (n ** 2 + 2 * n + 1).

Prueba 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 declaraciones simples, hay 11 tipos de ellas en Python 7. Declaraciones simples - Documentación de Python 3.6.3

¿Qué hay de declaració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

Ahí viene de habilitarlo funcionando

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

Tada, analízalo, 'm' es nombre, 'n ** 2 + 2 * n + 1' es valor. : es una variante de '='.
Encuéntralo, aunque solo sea por comprensión, todo comienza desde la asignación y todo es asignación.

Ahora regresa a lambda , tenemos una función llamada 'm'

Tratar:

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

Aquí hay dos nombres de 'm', la función m ya tiene un nombre, duplicado.

Se está formateando 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 error

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,

  1. lambda en una función en línea que le permite escribir una función en una línea recta al igual que en matemáticas
  2. lambda es anonima

Espero que esto ayude.


@Brian uso lambdas todo el tiempo en C #, en operadores LINQ y no LINQ. Ejemplo:

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

Antes de C #, usé funciones anónimas en JavaScript para las devoluciones de llamadas a las funciones AJAX, antes incluso de que se acuñara el término Ajax:

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

Sin embargo, lo interesante de la sintaxis lambda de C # es que, por su propia cuenta, no se puede inferir su tipo (es decir, no se puede escribir var foo = (x, y) => x * y) pero dependiendo de qué tipo son asignados a, se compilarán como delegados o árboles de sintaxis abstracta que representan la expresión (que es la forma en que los mapeadores de objetos LINQ hacen su magia "integrada en el idioma").

Lambdas en LISP también se puede pasar a un operador de cotización y luego recorrer como una lista de listas. Algunas macros poderosas se hacen de esta manera.


El nombre "lambda" es solo un artefacto histórico. Todo lo que estamos hablando es una expresión cuyo valor es una función.

Un ejemplo simple (usando Scala para la siguiente línea) es:

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

donde el argumento del método foreach es una expresión para una función anónima. La línea anterior es más o menos lo mismo que escribir algo como esto (no es un código real, pero obtendrás la idea):

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

excepto que no necesitas molestarte con:

  1. Declarar la función en otro lugar (y tener que buscarla cuando vuelva a visitar el código más adelante).
  2. Nombrando algo que solo estás usando una vez.

Una vez que te acostumbras a los valores de la función, tener que prescindir de ellos parece tan tonto como tener que nombrar cada expresión, como:

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

En lugar de simplemente escribir la expresión donde la necesite:

println(2 * a + b)

La notación exacta varía de un idioma a otro; ¡El griego no siempre es necesario! ;-)


En Javascript, por ejemplo, las funciones se tratan como el mismo tipo mixto que todo lo demás ( int , string , float , bool ). Como tal, puede crear funciones sobre la marcha, asignarlas a cosas y volver a llamarlas más tarde. Es útil pero, no es algo que quieras usar en exceso o confundirás a todos los que tienen que mantener tu código después de que ...

Este es un código con el que estaba jugando para ver qué tan profundo va este agujero de conejo:

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 programación de computadoras, lambda es un fragmento de código (declaración, expresión o un grupo de ellos) que toma algunos argumentos de una fuente externa. No siempre debe ser una función anónima, tenemos muchas formas de implementarlas.

Tenemos una separación clara entre expresiones, declaraciones 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 a seguir" (del latín "realizar"). En matemáticas es algo acerca de la correlación entre variables.

Los lenguajes funcionales intentan ser tan similares a las fórmulas matemáticas como sea posible, y sus palabras significan casi lo mismo. Pero en otros lenguajes de programación lo tenemos diferente.


Es una función que no tiene nombre. Por ejemplo, en c # puedes usar

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

para devolver los números que son mayores que 5.

number => number > 5

Es la parte lambda aquí. Representa una función que toma un parámetro (número) y devuelve un valor booleano (número> 5). El método GetMatchingItems usa esta lambda en todos los elementos de la colección y devuelve los elementos coincidentes.


La pregunta ha sido respondida completamente, no quiero entrar en detalles. Quiero compartir el uso al escribir cálculos numéricos en el óxido.

Hay un ejemplo de un lambda (función anónima)

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

Cuando estaba escribiendo un módulo del método de Newton-Raphson, se usó como derivado de primer y segundo orden. (Si desea saber qué es el método de Newton-Raphson, 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

La pregunta tiene una gran respuesta formal, por lo que no intentaré agregar más sobre esto.

En palabras muy simples e informales para alguien que sabe muy poco o nada sobre matemática o programación, lo explicaría como una pequeña "máquina" o "caja" que toma alguna entrada, hace algo de trabajo y produce algo de salida, no tiene un nombre particular , pero sabemos dónde está y solo por este conocimiento, lo usamos.

Hablando en términos prácticos, para una persona que sabe qué es una función, les diría que es una función que no tiene nombre, que generalmente se coloca en un punto de la memoria que se puede usar solo haciendo referencia a esa memoria (generalmente a través del uso de una variable - si han escuchado sobre el concepto de los punteros de función, los usaría como un concepto similar) - esta respuesta cubre los conceptos básicos bonitos (sin mencionar los cierres, etc.) pero se puede obtener el punto fácilmente.


Ligeramente simplificado: una función lambda es aquella que se puede pasar a otras funciones y se puede acceder a la lógica.

En C #, la sintaxis lambda se compila a menudo con métodos simples de la misma forma que los delegados anónimos, pero también se puede desglosar y leer su lógica.

Por ejemplo (en C # 3):

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

LinqToSql puede leer esa función (x> 15) y convertirla al SQL real para ejecutar utilizando árboles de expresiones.

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 los delegados anónimos (que en realidad son simplemente la magia del compilador) porque no se pueden leer .

No todos los métodos en C # que usan la sintaxis lambda se pueden compilar en árboles de expresión (es decir, funciones lambda reales). Por ejemplo:

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

Ahora el árbol de expresiones no se puede leer: SomeComplexCheck no se puede dividir. La instrucción SQL se ejecutará sin el dónde, y cada fila en los datos se pondrá a través de SomeComplexCheck .

Las funciones Lambda no deben confundirse con métodos anónimos. Por ejemplo:

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

Esto también tiene una función 'en línea', pero esta vez solo es magia del compilador: el compilador de C # dividirá esto en un nuevo método de instancia con un nombre generado automáticamente.

Los métodos anónimos no se pueden leer y, por lo tanto, la lógica no se puede traducir como se puede hacer para las funciones lambda.


Me gusta la explicación de Lambdas en este artículo: La evolución de LINQ y su impacto en el diseño de C # . Tenía mucho sentido para mí, ya que muestra un mundo real para Lambdas y lo construye como un ejemplo práctico.

Su rápida explicación: Lambdas es una forma de tratar el código (funciones) como datos.


Se refiere al cálculo lambda , que es un sistema formal que solo tiene expresiones lambda, que representan una función que toma una función como único argumento y devuelve una función. Todas las funciones en el cálculo lambda son de ese tipo, es decir, λ : λ → λ .

Lisp usó el concepto lambda para nombrar sus funciones anónimas literales. Esta lambda representa una función que toma dos argumentos, x e y, y devuelve su producto:

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

Se puede aplicar en línea de esta manera (se evalúa a 50 ):

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

Solo porque no puedo ver un ejemplo de C ++ 11 aquí, seguiré adelante y publicaré este buen ejemplo desde here . Después de buscar, es el ejemplo más claro de lenguaje específico que pude 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();
}

Un ejemplo de un lambda en Ruby es el siguiente:

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

hello.call

Generará la siguiente salida:

Hello
I am inside a proc

Un lambda es un tipo de función, definido en línea. Junto con un lambda, también suele tener algún tipo de tipo de variable que puede contener una referencia a una función, lambda o de otro tipo.

Por ejemplo, aquí hay un código de C # que no usa 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 llama a la Calculadora, pasando no solo dos números, sino a qué método llamar dentro de la Calculadora para obtener los resultados del cálculo.

En C # 2.0 obtuvimos métodos anónimos, lo que acorta el código anterior a:

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 luego, en C # 3.0, obtuvimos lambdas que hacen que el código sea 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);
}






theory