srl - serverless lambda aws




Cos'è una lambda(funzione)? (14)

Per una persona senza un background comp-sci, cos'è un lambda nel mondo dell'informatica?

Lo illustrerò intuitivamente passo dopo passo in codici python semplici e leggibili.

In breve, un lambda è solo una funzione anonima e in linea.

Iniziamo dall'assegnazione per capire lambdas come una matricola con uno sfondo dell'aritmetica di base.

Il modello di assegnazione è 'il nome = valore', vedi:

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

'x', 'y' sono nomi e 1, 'valore' sono valori. Prova una funzione in matematica

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

Segnalazioni di errori,
non puoi scrivere una matematica direttamente come codice, 'n' dovrebbe essere definito o essere assegnato ad un valore.

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

Funziona ora, e se insisti a combinare le due linee separate con una. Arriva lambda

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

Nessun errore segnalato.

Questo è uno sguardo a lambda , ti permette di scrivere una funzione in una singola riga come fai in matematica direttamente nel computer.

Lo vedremo più tardi.

Continuiamo a scavare più a fondo sul 'compito'.

Come illustrato sopra, il simbolo equals = funziona per il tipo di dati semplici (1 e 'valore') e l'espressione semplice (n ** 2 + 2 * n + 1).

Prova questo:

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

Funziona con semplici istruzioni, ne esistono 11 in Python 7. Semplici istruzioni - Documentazione Python 3.6.3

Che ne dici di una frase composta,

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

Arriva def abilitarlo a funzionare

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

Tada, analizzalo, 'm' è il nome, 'n ** 2 + 2 * n + 1' è valore. : è una variante di '='.
Trovalo, se solo per capire, tutto parte dall'assegnazione e tutto è compito.

Ora torna a lambda , abbiamo una funzione chiamata 'm'

Provare:

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

Ci sono due nomi di "m" qui, la funzione m ha già un nome, duplicato.

È formattazione come:

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

Non è una strategia intelligente, quindi segnalazioni di errore

Dobbiamo eliminare uno di loro, impostare una funzione senza un nome.

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

Si chiama "funzione anonima"

In conclusione,

  1. lambda in una funzione inline che ti permette di scrivere una funzione in una linea retta come fa in matematica
  2. lambda è anonima

Spero che questo ti aiuti.

Per una persona senza un background comp-sci, cos'è un lambda nel mondo dell'informatica?


È una funzione che non ha nome. Ad esempio in c # è possibile utilizzare

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

per restituire i numeri che sono maggiori di 5.

number => number > 5

è la parte lambda qui. Rappresenta una funzione che accetta un parametro (numero) e restituisce un valore booleano (numero> 5). Il metodo GetMatchingItems utilizza questo lambda su tutti gli elementi della raccolta e restituisce gli elementi corrispondenti.


Alla domanda è stata data una risposta completa, non voglio entrare nei dettagli. Voglio condividere l'utilizzo durante la scrittura di calcoli numerici in ruggine.

C'è un esempio di lambda (funzione anonima)

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

Quando stavo scrivendo un modulo di metodo Newton-Raphson, era usato come derivato del primo e del secondo ordine. (Se vuoi sapere qual è il metodo di Newton-Raphson, visita " https://en.wikipedia.org/wiki/Newton%27s_method ".

L'output come segue

println!("f={:.6}      df={:.6}", f(10.0), df(10.0))

f=98.000000       df=20.000000

Ho capito anche io. Ho provato in JS con questo:

var addAndMult = function(x) {
        return (function(y) {
            return (function(z) {
                return (x+y)*z; 
                });
            });
        };

Aggiunge 2 a 4 quindi muta il risultato per 6. Tuttavia trovo che a volte sia difficile da leggere :(

Inoltre ho reso interessante una funzione per ogni:

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

Questo metodo itererà un array ed eseguirà un'azione, nel caso stampi sulla console. Ora capisco anche perché i labmdas sono potenti.


Il calcolo lambda è una teoria matematica coerente di sostituzione. Nella matematica scolastica si vede ad esempio x+y=5 abbinato a x−y=1 . Insieme ai modi di manipolare le singole equazioni è anche possibile mettere le informazioni da questi due insieme, a condizione che le sostituzioni delle equazioni incrociate avvengano logicamente. Il calcolo Lambda codifica il modo corretto di fare queste sostituzioni.

Dato che y = x−1 è un riarrangiamento valido della seconda equazione, questo: λ y = x−1 significa una funzione che sostituisce i simboli x−1 per il simbolo y . Ora immagina di applicare λ y a ciascun termine nella prima equazione. Se un termine è y eseguire la sostituzione; altrimenti non fare nulla. Se lo fai su carta vedrai come applicare quel λ y renderà la prima equazione risolvibile.

Questa è una risposta senza alcun computer o programmazione.

L'esempio di programmazione più semplice a cui riesco a pensare proviene da http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works :

ecco come la funzione quadrata potrebbe essere definita in un linguaggio di programmazione imperativo (C):

int square(int x)
{
    return x * x;
}

La variabile x è un parametro formale che viene sostituito dal valore effettivo da squadrare quando viene chiamata la funzione. In un linguaggio funzionale (Schema) si definirà la stessa funzione:

(define square
  (lambda (x) 
    (* x x)))

Questo è diverso in molti modi, ma usa ancora il parametro formale x allo stesso modo.

Aggiunto: http://imgur.com/a/XBHub

http://imgur.com/a/XBHub


Il nome "lambda" è solo un manufatto storico. Tutto ciò di cui stiamo parlando è un'espressione il cui valore è una funzione.

Un semplice esempio (usando Scala per la riga successiva) è:

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

dove l'argomento del metodo foreach è un'espressione per una funzione anonima. La riga sopra è più o meno la stessa di scrivere qualcosa come questo (codice non proprio reale, ma avrai l'idea):

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

tranne che non devi preoccuparti di:

  1. Dichiarare la funzione da qualche altra parte (e doverla cercare quando si rivisita il codice successivamente).
  2. Dare un nome a qualcosa che stai usando solo una volta.

Una volta che sei abituato a funzionare con i valori, doverli fare a meno di loro sembra sciocco come dover nominare ogni espressione, ad esempio:

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

invece di limitarti a scrivere l'espressione dove ne hai bisogno:

println(2 * a + b)

La notazione esatta varia da una lingua all'altra; Il greco non è sempre richiesto! ;-)


In Javascript, ad esempio, le funzioni sono considerate come lo stesso tipo misto di tutto il resto ( int , string , float , bool ). In quanto tale, è possibile creare funzioni al volo, assegnarle alle cose e richiamarle in un secondo momento. È utile ma non è qualcosa che si desidera utilizzare eccessivamente o confonderai tutti quelli che devono mantenere il tuo codice dopo di te ...

Questo è un codice con cui stavo giocando per vedere quanto è profonda questa tana del coniglio:

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

La domanda è formalmente risposta molto, quindi non cercherò di aggiungere altro su questo.

In parole molto semplici e informali a qualcuno che sa molto poco o nulla sulla matematica o sulla programmazione, lo spiegherei come una piccola "macchina" o "scatola" che prende un po 'di input, fa funzionare e produce un output, non ha un nome particolare , ma sappiamo dove è e solo con questa conoscenza, lo usiamo.

In pratica, per una persona che sa cosa sia una funzione, direi che è una funzione che non ha nome, di solito messo a un punto in memoria che può essere usato semplicemente facendo riferimento a quella memoria (di solito tramite l'uso di una variabile - se hanno sentito parlare del concetto dei puntatori di funzione, li userei come un concetto simile) - questa risposta copre le basi piuttosto (non si parla di chiusure ecc.) ma si può ottenere facilmente il punto.


Leggermente semplificato: una funzione lambda è quella che può essere passata ad altre funzioni e alla sua logica.

In C # la sintassi lambda viene spesso compilata con metodi semplici allo stesso modo dei delegati anonimi, ma può anche essere scomposta e la sua logica viene letta.

Ad esempio (in C # 3):

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

LinqToSql può leggere quella funzione (x> 15) e convertirla nell'effettivo SQL da eseguire usando gli alberi di espressione.

La dichiarazione sopra diventa:

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

Questo è diverso dai metodi normali o dai delegati anonimi (che sono davvero solo magia del compilatore) perché non possono essere letti .

Non tutti i metodi in C # che usano la sintassi lambda possono essere compilati in alberi di espressioni (cioè funzioni lambda reali). Per esempio:

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

Ora l'albero delle espressioni non può essere letto - SomeComplexCheck non può essere scomposto. L'istruzione SQL verrà eseguita senza il punto e ogni riga dei dati verrà inserita in SomeComplexCheck .

Le funzioni Lambda non devono essere confuse con metodi anonimi. Per esempio:

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

Questo ha anche una funzione "in linea", ma questa volta è solo magia del compilatore - il compilatore C # lo dividerà in un nuovo metodo di istanza con un nome generato automaticamente.

I metodi anonimi non possono essere letti e quindi la logica non può essere tradotta come può per le funzioni lambda.


Mi piace la spiegazione di Lambdas in questo articolo: L'evoluzione di LINQ e il suo impatto sul design di C # . Per me ha molto senso perché mostra un mondo reale per Lambdas e lo costruisce come esempio pratico.

La loro rapida spiegazione: Lambda è un modo per trattare il codice (funzioni) come dati.


Nella programmazione per computer, lambda è un pezzo di codice (istruzione, espressione o un gruppo di essi) che accetta alcuni argomenti da una fonte esterna. Non deve sempre essere una funzione anonima: abbiamo molti modi per implementarle.

Abbiamo una chiara separazione tra espressioni, affermazioni e funzioni, che i matematici non hanno.

Anche la parola "funzione" in programmazione è diversa - abbiamo "la funzione è una serie di passi da fare" (dal latino "perform"). In matematica è qualcosa sulla correlazione tra le variabili.

Le lingue funzionali stanno cercando di essere il più possibile simili alle formule matematiche e le loro parole significano quasi la stessa cosa. Ma in altri linguaggi di programmazione lo abbiamo diverso.



Solo perché non riesco a vedere un esempio di C ++ 11, andrò avanti e pubblicherò questo bell'esempio da here . Dopo la ricerca, è l'esempio specifico più chiaro che ho trovato.

Ciao, Lambdas, versione 1

template<typename F>

void Eval( const F& f ) {
        f();
}
void foo() {
        Eval( []{ printf("Hello, Lambdas\n"); } );
}

Ciao, Lambdas, versione 2:

void bar() {
    auto f = []{ printf("Hello, Lambdas\n"); };
    f();
}

Un esempio di lambda in Ruby è il seguente:

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

hello.call

Genererà il seguente risultato:

Hello
I am inside a proc




theory