Qual è la chiave = lambda

Question

Durante l'utilizzo di alcune funzioni built-in, come ordinato, sum ... ho notato l'utilizzo di key=lambda

Qual è lambda? Come funziona?

Quali altre funzioni utilizzare key = lambda?

Ci sono altri valori chiave come, key=?

Answer 1

Un lambda è una funzione anonima:

>>> f = lambda: 'foo' 
>>> print f() 
foo 

E 'spesso utilizzato in funzioni come sorted() che prendono un richiamabile come parametro (spesso il key parametro della parola chiave). È possibile fornire anche una funzione esistente al posto di lambda, purché si tratti di un oggetto callable.

Prendere il sorted() function come esempio. Si tornerà alla data iterabile in modo ordinato:

>>> sorted(['Some', 'words', 'sort', 'differently']) 
['Some', 'differently', 'sort', 'words'] 

ma che specie in maiuscolo le parole prima di parole che sono in minuscolo. Utilizzando la parola chiave key è possibile modificare ciascuna voce in modo che venga ordinata in modo diverso. Potremmo minuscole tutte le parole prima di ordinamento, ad esempio:

>>> def lowercased(word): return word.lower() 
... 
>>> lowercased('Some') 
'some' 
>>> sorted(['Some', 'words', 'sort', 'differently'], key=lowercased) 
['differently', 'Some', 'sort', 'words'] 

Abbiamo dovuto creare una funzione separata per questo, non potevamo inline la linea def lowercased() nella sorted() espressione:

>>> sorted(['Some', 'words', 'sort', 'differently'], key=def lowercased(word): return word.lower()) 
    File "<stdin>", line 1 
    sorted(['Some', 'words', 'sort', 'differently'], key=def lowercased(word): return word.lower()) 
                 ^
SyntaxError: invalid syntax 

A lambda d'altra parte, può essere specificato direttamente, in linea nella sorted() espressione:

>>> sorted(['Some', 'words', 'sort', 'differently'], key=lambda word: word.lower()) 
['differently', 'Some', 'sort', 'words'] 

Lambdas è limitato a una sola espressione, il cui risultato è il valore restituito.

Ci sono molti posti nella libreria Python, incluse le funzioni incorporate, che accettano un callable come argomento parola chiave o posizione. Ci sono troppi da nominare qui e spesso giocano un ruolo diverso.

Answer 2

Lambda può essere qualsiasi funzione. Quindi, se si ha una funzione

def compare_person(a): 
     return a.age 

Si poteva ordinare un elenco di Person (ciascuno dei quali prevede un attributo di età) in questo modo:

sorted(personArray, key=compare_person) 

In questo modo, la lista sarebbe risolto per età in ordine ascendente.

Il parametro è chiamato lambda perché python ha una nifty keywords lambda per la definizione di tali funzioni al volo. Invece di definire una funzione compare_person e passando a che ordinato, è possibile anche scrivere:

sorted(personArray, key=lambda a: a.age) 

che fa la stessa cosa.

Answer 3

>>> sorted(['Some', 'words', 'sort', 'differently'], key=lambda word: word.lower()) 

In realtà, i codici di cui sopra possono essere:

>>> sorted(['Some','words','sort','differently'],key=str.lower) 

Secondo https://docs.python.org/2/library/functions.html?highlight=sorted#sorted, chiave specifica una funzione di un argomento che viene usato per estrarre una chiave di confronto da ogni elemento della lista: key = str.lower . Il valore predefinito è Nessuno (confronta direttamente gli elementi).

Answer 4

In Python, lambda è una parola chiave utilizzata per definire funzioni anonime (funzioni senza nome) ed è per questo che sono conosciuti come funzioni lambda.

Fondamentalmente esso è usato per definire funzioni anonime che può/non può prendere argomento (s) e restituisce il valore dei dati /espressione. Vediamo un esempio .

>>> # Defining a lambda function that takes 2 parameters(as integer) and returns their sum 
... 
>>> lambda num1, num2: num1 + num2 
<function <lambda> at 0x1004b5de8> 
>>> 
>>> # Let's store the returned value in variable & call it(1st way to call) 
... 
>>> addition = lambda num1, num2: num1 + num2 
>>> addition(62, 5) 
67 
>>> addition(1700, 29) 
1729 
>>> 
>>> # Let's call it in other way(2nd way to call, one line call) 
... 
>>> (lambda num1, num2: num1 + num2)(120, 1) 
121 
>>> (lambda num1, num2: num1 + num2)(-68, 2) 
-66 
>>> (lambda num1, num2: num1 + num2)(-68, 2**3) 
-60 
>>> 

Ora darmi una risposta del vostro secondo domanda. Anche la risposta 1st è ottima. Questo è il mio modo di spiegare con un altro esempio.

Supponiamo di avere un elenco di elementi (interi e stringhe con contenuti numerici) come segue,

nums = ["2", 1, 3, 4, "5", "8", "-1", "-10"] 

e voglio ordinare utilizzando ordinato function(), consente di vedere ciò che accade.

>>> nums = ["2", 1, 3, 4, "5", "8", "-1", "-10"] 
>>> sorted(nums) 
[1, 3, 4, '-1', '-10', '2', '5', '8'] 
>>> 

E non mi ha dato quello che mi aspettavo come ho voluto come qui di seguito,

['-10', '-1', 1, '2', 3, 4, '5', '8'] 

Significa abbiamo bisogno di qualche strategia (in modo che allineati potrebbero trattare i nostri oggetti stringa come un intimo) per raggiungere questo obiettivo. Questo è il motivo per cui viene utilizzato l'argomento chiave chiave. Si prega di guardare quello sotto.

>>> nums = ["2", 1, 3, 4, "5", "8", "-1", "-10"] 
>>> sorted(nums, key=int) 
['-10', '-1', 1, '2', 3, 4, '5', '8'] 
>>> 

Lets funzione di uso lambda come un valore di chiave

>>> names = ["Rishikesh", "aman", "Ajay", "Hemkesh", "sandeep", "Darshan", "Virendra", "Shwetabh"] 
>>> names2 = sorted(names) 
>>> names2 
['Ajay', 'Darshan', 'Hemkesh', 'Rishikesh', 'Shwetabh', 'Virendra', 'aman', 'sandeep'] 
>>> # But I don't want this o/p(here our intention is to treat 'a' same as 'A') 
... 
>>> names3 = sorted(names, key=lambda name:name.lower()) 
>>> names3 
['Ajay', 'aman', 'Darshan', 'Hemkesh', 'Rishikesh', 'sandeep', 'Shwetabh', 'Virendra'] 
>>> 

È possibile definire una propria funzione (callable) e fornire come valore della chiave .

Cari programmatori, ho scritto il codice qui sotto per voi, solo cercare di capire e commento tua spiegazione.Sarei felice di vedere la tua spiegazione (è semplice).

>>> def validator(item): 
...  try: 
...   return int(item) 
...  except: 
...   return 0 
... 
>>> sorted(['gurmit', "0", 5, 2, 1, "front", -2, "great"], key=validator) 
[-2, 'gurmit', '0', 'front', 'great', 1, 2, 5] 
>>> 

ho speranza sarebbe utile.