Lambda in Python

Studiamo le funzioni lambda in Python, ovvero le funzioni anonime.

Nelle precedenti lezioni abbiamo visto come creare delle funzioni utilizzando la parola chiave def seguita dal nome della funzione e dagli argomenti se ce ne sono.

Al contrario la funzione lambda non ha un nome, ma solo gli argomenti e un’unica espressione di calcolo.

La sintassi della funzione lambda in Python è dunque la seguente:

lambda argomenti: espressione

Esempi sulla funzione lambda in Python

Facciamo alcuni esempi per capire meglio il funzionamento.

Come primo esempio costruiamo una funzione lambda utile per calcolare il cubo di un numero:


f_cube = lambda x : x * x * x
print(f_cube(3))

La stessa funzione utilizzando def si poteva scrivere in questo modo:



def f_cube(x):
      return x * x * x

print(f_cube(3))

Il risultato è chiaramente lo stesso.

Possiamo anche scrivere in maniera molto compatta in questo modo:



print((lambda x: x * x * x)(3))

Più argomenti nella funzione lambda in Python

Si possono inserire anche più argomenti, separandoli da virgole. Facciamo un esempio con una funzione che calcola l’area di un rettangolo.



f_area = lambda x, y : x * y
print(f_area(4,5))

#in maniera compatta
print((lambda x, y: x*y)(4,5))

Valutare un’espressione Booleana

Possiamo anche valutare un’espressione booleana.

Prendiamo ad esempio in considerazione un numero e stabiliamo se è pari oppure dispari.



f_even = lambda x : x % 2 == 0
print(f_even(8))
print(f_even(9))

L’output prodotto sarà dunque questo:

True
False

Perchè usare la funzione lambda in Python

Sicuramente uno dei motivi per cui viene utilizzata è quello di risparmiare righe di codice, migliorandone la leggibilità. Quando infatti devo usare una funzione per un tempo breve, non serve definirla.

Inoltre uno dei campi maggiori di utilizzo è quando si vuole passare una funzione come argomento di un’altra funzione.

Vedremo molto spesso le funzioni lambda utilizzare con le funzioni map() o filter() di Python.

Facciamo un primo esempio utilizzando filter():


list_number = [11,8,4,5]

new_list = list(filter(lambda x: x%2 == 0, list_number))

print(new_list)

In questo caso l’output prodotto sarà questo: [8, 4]

Oppure possiamo anche utilizzare map().


list_number = [11,8,4,5]

new_list = list(map(lambda x: x%2==0, list_number))

print(new_list)

L’output prodotto sarà questo: [False, True, True, False]

La lista sarà popolata con i valori booleani.

Potremmo anche utilizzare un ciclo for in:


list_number = [11,8,4,5]

new_list = [even for even in list_number if even %2 ==0]

print(new_list)

Infine possiamo aggiungere che l’utilizzo della funzione lambda in Python è particolarmente indicato quando si lavora con alcune librerie, come ad esempio Pandas, Numpy, ecc.

Invece non si può utilizzare quando ad esempio vogliamo eseguire più operazioni indipendenti nell’ambito di una funzione. O ancora quando ho bisogno di scrivere istruzioni su più righe.

Alcuni link utili

Indice tutorial sul linguaggio Python

1 – Introduzione al linguaggio Python

2 – Le variabili

3 – Operatori aritmetici e di assegnazione

4 – Stringhe

5 – Casting

6 – Input e print

7 – Primi esercizi in Python

8 – Errori in Python

Continua la lettura su: https://www.codingcreativo.it/lambda-in-python/ Autore del post: Coding Creativo Fonte: https://www.codingcreativo.it

Articoli Correlati

Ordinare un dizionario in Python

Si può ordinare un dizionario in Python per chiave o per valore. Facciamo alcuni esempi pratici di ordinamento in Python in base alle nostre esigenze.

Tutti gli esempi proposti possono essere provati nel compiler online che troverete al seguente link: Python compiler online.

Primo esempio – Ordinare un dizionario in Python per chiave

In questo primo esempio dapprima creiamo un dizionario in Python. Abbiamo poi detto di ordinare per chiave, quindi dobbiamo decidere se seguire un ordine crescente o decrescente, infine dobbiamo richiamare la funzione sul dizionario.

Implementiamo, dunque, una prima soluzione. Per ordinare in senso crescente possiamo utilizzare la funzione sorted sul nostro dizionario, in questo modo:

student = {
“name”: ‘Cristina’,
“age”: ’29’,
“hobby”: ‘swim’,
“mail”: ‘codingcreatico@gmail.com’,
“passion”: ‘coding’
}

for key in sorted(student):
print(key, student[key])

E se vogliamo un ordinamento decrescente? Basterà semplicemente utilizzare il parametro reverse della funzione sorted, impostandolo a False.

Ecco un esempio di dizionario ordinato in senso decrescente in Python:

student = {
“name”: ‘Cristina’,
“age”: ’29’,
“hobby”: ‘swim’,
“mail”: ‘codingcreatico@gmail.com’,
“passion”: ‘coding’
}

for key in sorted(student, reverse = True):
print(key, student[key])

Secondo esempio – Ordinare un dizionario in Python per chiave

Cerchiamo adesso una seconda soluzione al problema proposto.

Innanzitutto potremmo ad esempio pensare di utilizzare il metodo keys() sul dizionario, ma cosa succede?

Proviamolo, dunque, con un esempio:

student = {
“name”: ‘Cristina’,
“age”: ’29’,
“hobby”: ‘swim’,
“mail”: ‘codingcreatico@gmail.com’,
“passion”: ‘coding’
}

sorted_key = sorted(student.keys())

for element in sorted_key:
print(element)

In questo caso si avrà il seguente output:

age
hobby
mail
name
passion

Ovvero avremo le sole chiavi ordinate in senso crescente.

Quindi, anche se uso il metodo dict() non riuscirò in questo modo ad ordinare un dizionario in Python.

E se invece proviamo ad utilizzare il metodo values()?

student = {
“name”: ‘Cristina’,
“age”: ’29’,
“hobby”: ‘swim’,
“mail”: ‘codingcreatico@gmail.com’,
“passion”: ‘coding’
}

sorted_values = sorted(student.values())

for element in sorted_values:
print(element)

Il risultato sarà il seguente:

29
Cristina
coding
codingcreatico@gmail.com
swim

Quindi se voglio ordinare un dizionario in Python per chiave cosa devo fare? Quale altra soluzione posso pensare?

Possiamo, ad esempio, utilizzare il metodo items(), che abbiamo studiato in questa lezione: items Python.

Ricordiamo inoltre che questo metodo è utilizzato per restituire l’elenco con tutte le chiavi del dizionario con i suoi rispettivi valori.

Dopo, possiamo nuovamente riconvertire le coppie di tuple in un dizionario utilizzando il metodo dict().

Ecco una possibile soluzione al nostro algoritmo:

student = {
“name”: ‘Cristina’,
“age”: ’29’,
“hobby”: ‘swim’,
“mail”: ‘codingcreatico@gmail.com’,
“passion”: ‘coding’
}

sorted_student = sorted(student.items())
sorted_student_dict = dict(sorted(student.items()))

print(sorted_student_dict)

for element in sorted_student_dict:
print(element, ‘: ‘, sorted_student_dict[element])

Così abbiamo ottenuto tutte le coppie di tuple chiave, valori ordinate in senso crescente. Poi, convertiamolo in dizionario con il metodo dict(). Così riusciamo ad ordinare il dizionario in Python per chiave.

Utilizziamo una funzione per poterla poi utilizzare per creare l’ordinamento su più dizionari:

student = {
“name”: ‘Cristina’,
“age”: ’29’,
“hobby”: ‘swim’,
“mail”: ‘codingcreatico@gmail.com’,
“passion”: ‘coding’
}

def sort_dict(d):
return dict(sorted(student.items()))

print(sort_dict(student))

Ordinare un dizionario in Python per chiave in senso decrescente

Questa volta utilizziamo il parametro reverse di sorted per creare un ordinamento decrescente sui dizionari. Infatti impostandolo a True l’ordinamento sarà decrescente. Di default il suo valore è False.

student = {
“name”: ‘Cristina’,
“age”: ’29’,
“hobby”: ‘swim’,
“mail”: ‘codingcreatico@gmail.com’,
“passion”: ‘coding’
}

def sort_dict(d):
return dict(sorted(student.items(), reverse = True))

print(sort_dict(student))

Per completezza potremmo passare questo parametro anche alla funzione, in questo modo:

student = {
“name”: ‘Cristina’,
“age”: ’29’,
“hobby”: ‘swim’,
“mail”: ‘codingcreatico@gmail.com’,
“passion”: ‘coding’
}

def sort_dict(d, rev):
return dict(sorted(student.items(), reverse = rev))

print(sort_dict(student, True))

Conclusione

In questa lezione abbiamo affrontato alcuni interessanti esempi su come ordinare un dizionario in Python per chiave, in ordine crescente e decrescente.

Alcuni link utili

Indice tutorial sul linguaggio Python

1 – Introduzione al linguaggio Python

2 – Le variabili

3 – Operatori aritmetici e di assegnazione

4 – Stringhe

5 – Casting

6 – Input e print

7 – Primi esercizi in Python

8 – Errori in Python

9 – Script Python

10 – Scambio di variabili

11 – Modulo math

Bubble Sort Python

L’algoritmo bubble sort in Python è l’argomento di questa lezione. Il bubble sort è un algoritmo di ordinamento molto semplice da implementare, ma dobbiamo dire che è anche poco efficiente.

Infatti il bubble sort è utilizzato principalmente in ambito didattico per far apprendere le logiche e le basi della programmazione.

Il funzionamento del bubble sort è questo:

Si confrontano gli elementi vicini tra di loro, portando l’elemento maggiore in ultima posizione durante la prima “passata” (eseguendo n-1 confronti), poi il secondo massimo in penultima posizione e così via finché l’array non è ordinato.

Quindi ad ogni passaggio si inserisce nell’elenco il valore successivo più grande al posto giusto.

La complessità dell’algoritmo è O(n2), sia nel caso peggiore, sia nel caso migliore.

Implementazione bubble sort in Python

Implementiamo la soluzione all’algortimo bubble sort in Python in maniera diversa rispetto agli altri linguaggi di programmazione. Questo perchè per lo scambio delle variabili in Python non è necessaria una variabile di appoggio temporanea.

In questa guida tratto l’argomento dello scambio delle variabili. Come scambiare il valore delle variabili

Dunque non sarà necessaria questa operazione:

temp = a;
a = b;
b = temp;

Ma basterà semplicemente scrivere:

a,b = b,a

Questa procedura, detta assegnazione simultanea, mi consente di snellire l’algoritmo bubble sort in Python.

def bubbleSort(array):
for j in range(0, len(array)-1):
for i in range(0, len(array)-1):
if array[i] >array[i+1]:
array[i], array[i+1] = array[i+1], array[i]

array_numbers = [54,26,93,17,77,31,44,55,20]
bubbleSort(array_numbers)

print(array_numbers)

L’algoritmo è molto semplice, basandosi sul confronto di elementi adiacenti.

Ma se l’algoritmo fosse ordinato? In ogni caso dovrei ripetere il ciclo esterno sempre n-1 volte. Possiamo pensare allora a fare delle ottimizzazioni all’algoritmo proposto.

Ottimizzazione bubble sort in Python – ordinamento per scambio con sentinella

Possiamo pensare di interrompere il ciclo for esterno, con un break, se al termine del primo ciclo interno non si è fatto alcuno scambio. Per questo scopo utilizziamo una variabile di appoggio chiamata flag, che inizializziamo a 0. Dopo, cambiamo il valore di questa variabile se nel ciclo interno si effettua almeno uno scambio. In alternativa a 0 ed 1 posso usare una variabile booleana.

Ecco il codice di esempio:

def bubbleSort(array):
for j in range(0, len(array)-1):
flag = False
for i in range(0, len(array)-1):
if array[i] >array[i+1]:
array[i], array[i+1] = array[i+1], array[i]
flag = True
if not(flag):
break

array_numbers = [54,26,93,17,77,31,44,55,20]
bubbleSort(array_numbers)

print(array_numbers)

Seconda ottimizzazione dell’algoritmo bubble sort in Python

Possiamo ottimizzare l’algoritmo bubble sort riflettendo sul fatto che ad ogni incremento di j, almeno gli ultimi j+1 elementi sono già stati ordinati. Questo in considerazione del fatto che ad ogni iterazione, l’elemento più grande è stato spostato verso destra.

Quindi ad ogni iterazione accorciamo il ciclo dei confronti. Infatti all’n-esima iterazione si può fare a meno di toccare gli ultimi n-1 elementi che ormai sono nella loro posizione definitiva. Dunque decrementiamo n di uno ad ogni iterazione (- -n), in modo da diminuire di 1, di volta in volta, il numero dei confronti effettuati.

Ecco dunque il codice completo dell’algoritmo ottimizzato:

def bubbleSort(array):
len_array = len(array)
for j in range(0, len_array-1):
flag = False
for i in range(0, len_array-1):
if array[i] >array[i+1]:
array[i], array[i+1] = array[i+1], array[i]
flag = True
len_array = len_array – 1
if not(flag):
break

array_numbers = [54,26,93,17,77,31,44,55,20]
bubbleSort(array_numbers)

Terza ottimizzazione dell’algoritmo bubble sort in Python

Un’ulteriore ottimizzazione all’algoritmo bubble sort in Python può essere sviluppata in considerazione del fatto che il ciclo interno si interrompe proprio dove è avvenuto lo scambio. Quindi, dopo ogni iterazione più elementi si trovano nella posizione definitiva e si può evitare di ordinarli nuovamente.

Occorre memorizzare la posizione ( i+1) dell’ultimo scambio effettuato in una variabile che chiameremo ad esempio pos. Dopo assegniamo alla lunghezza dell’array il valore di pos.

Ecco una possibile implementazione dell’algoritmo ottimizzato:

def bubbleSort(array):
len_array = len(array)
for j in range(0, len_array-1):
flag = False
for i in range(0, len_array-1):
if array[i] >array[i+1]:
array[i], array[i+1] = array[i+1], array[i]
flag = True
pos = i + 1
if not(flag):
break
else:
len_array = pos

print(i,j)

array_numbers = [54,26,93,17,77,31,44,55,20]
bubbleSort(array_numbers)

print(array_numbers)

Conclusioni

In questa lezione ho realizzato alcune implementazioni dell’algoritmo bubble sort in Python, cercando di ottimizzare un algoritmo semplice da implementare, ma lento. Nelle prossime lezioni spiegherò altri algoritmi di ordinamento.

Alcuni link utili

Indice tutorial sul linguaggio Python

1 – Introduzione al linguaggio Python

2 – Le variabili

3 – Operatori aritmetici e di assegnazione

4 – Stringhe

5 – Casting

6 – Input e print

7 – Primi esercizi in Python

8 – Errori in Python

9 – Script Python

10 – Scambio di variabili

11 – Modulo math

Vuoi rimanere aggiornato sulle nuove tecnologie per la Didattica e ricevere suggerimenti per attività da fare in classe?

Sei un docente?

soloscuola.it la prima piattaforma
No Profit gestita dai

Volontari Per la Didattica
per il mondo della Scuola. 

 

Tutti i servizi sono gratuiti. 

Associazione di Volontariato Koinokalo Aps

Ente del Terzo Settore iscritta dal 2014
Tutte le attività sono finanziate con il 5X1000