Funzioni

Prof. Pietro Liguori

DIETI, Università degli Studi di Napoli Federico II, Italy
[email protected]

Laboratorio di Programmazione, Corso di Laurea Magistrale in Ingegneria Biomedica

Funzioni in Python

§ Le funzioni permettono di scrivere codice riusabile

§ Le funzioni non vengono eseguite nel programma finché non vengono
chiamate o invocate
§ Caratteristiche di una funzione:
• Ha un nome
• Ha dei parametri (0 or più)
• Ha una docstring (opzionale ma raccomandata)
• La prima istruzione (commento) di una funzione che funge da documentazione
• Ha un corpo
• Ritorna qualcosa
Come scrivere e invocare una funzione
in Python

def is_even( i ):
"""
Input: i, a positive int
Returns True if i is even, otherwise False
"""
print("inside is_even")
return i%2 == 0

is_even(3)

3
Corpo della funzione

def is_even( i ):
"""
Input: i, a positive int
Returns True if i is even, otherwise False
"""
print("inside is_even")
return i%2 == 0

4
Scope

§ Ogni identificatore ha una sua visibilità (scope) che

determina dove può essere usato nel programma. Per
quella porzione di programma, l’identificatore è “visibile”
(“in scope”).
§ Visibilità locale
§ È “visibile” solo dalla sua definizione fino alla fine del blocco della
funzione. La variabile “non è più visibile” quando la funzione
ritorna al suo chiamante. Di conseguenza, una variabile locale può
essere usata solo all’interno della funzione in cui è definita.
§ Visibilità globale
§ Gli identificatori definiti al di fuori di una funzione (o di una classe)
hanno una visibilità globale, e questo vale per funzioni, variabili e
classi. Le variabili con visibilità globale sono dette variabili globali.
Dopo aver def inito un identif icatore con visibilità globale in un file
.py o in una sessione interattiva è possibile utilizzarlo ovunque.

5
Visibilità (scope) di una variabile

§ formal parameter sono legati al valore di un actual parameter quando una funzione
viene invocata
§ Viene creato un nuovo scope/frame/environment quando si entra in una funzione
§ scope è il mapping tra i nomi e gli oggetti

def f( x ):
x = x + 1
print('in f(x): x =', x)
return x

x = 3
z = f( x )

6
Visibilità (scope) di una variabile

def f( x ): Global scope f scope

x = x + 1
Some
print('in f(x): x =', x) f x 3
code
return x
x 3
x = 3
z = f( x ) z

7
Visibilità (scope) di una variabile

def f( x ): Global scope f scope

x = x + 1
Some
print('in f(x): x =', x) f x 4
code
return x
x 3
x = 3
z = f( x ) z

8
Visibilità (scope) di una variabile

def f( x ): Global scope f scope

x = x + 1
Some
print('in f(x): x =', x) f x 4
code
return x
x 3 returns 4
x = 3
z = f( x ) z

9
Visibilità (scope) di una variabile

def f( x ): Global scope

x = x + 1
Some
print('in f(x): x =', x) f
code
return x
x 3
x = 3
z = f( x ) 4
z

10
Istruzione return e il tipo None

def is_even( i ):
"""
Input: i, a positive int
Does not return anything
"""
i%2 == 0

§ Python ritorna il valore None se non si usa l’istruzione return!

§ None rappresenta l’assenza di valore

11
Funzioni come argomenti

§ Gli argomenti di funzione possono essere di

qualunque tipo, anche funzioni!
def func_a():
print 'inside func_a'
def func_b(y):
print 'inside func_b'
return y
def func_c(z):
print 'inside func_c'
return z()
print func_a()
print 5 + func_b(2)
print func_c(func_a)
6.0001 LECTURE 4

12
Funzioni come argomenti

Global scope func_a scope

def func_a(): func_a Some
print 'inside func_a' code
def func_b(y): Some
func_b code
print 'inside func_b'
return y Some
def func_c(z): func_c code
print 'inside func_c'
None returns None
return z()
print func_a()
print 5 + func_b(2)
print func_c(func_a)

13
Funzioni come argomenti

Global scope func_b scope

def func_a(): func_a Some y 2
print 'inside func_a' code
def func_b(y): Some
func_b code
print 'inside func_b'
return y Some
def func_c(z): func_c code

print 'inside func_c'

None
return z()
print func_a() 7 returns 2
print 5 + func_b(2) 1
print func_c(func_a) 4

14
Funzioni come argomenti

Global scope func_c scope

def func_a(): func_a Some z func_a
print 'inside func_a' code
def func_b(y): Some
func_b code
print 'inside func_b'
return y Some func_a scope

def func_c(z): func_c code

print 'inside func_c'

None
return z()
returns None
print func_a() 7
print 5 + func_b(2)
print func_c(func_a) None returns None

15
Esempio di scope
§Dentro una funzione, possiamo accedere ad una
variabile definita al di fuori della funzione
§ Dentro una funzione, non possiamo modificare una
variabile definita al di fuori della funzione – possiamo
usare variabili globali, ma non è una buona pratica

def f(y): def g(y): def h(y):

x = 1 print(x) x += 1
x += 1 print(x + 1)
print(x) x = 5
x = 5 h(x)
x = 5 g(x) print(x)
f(x) print(x)
print(x)

16
Esempio di scope
§Dentro una funzione, possiamo accedere ad una
variabile definita al di fuori della funzione
§ Dentro una funzione, non possiamo modificare auna
variabile definita al di fuori della funzione – possiamo
usare variabili globali, ma non è una buona pratica

def f(y): def g(y): def h(y):

x = 1 print(x) x += 1
x += 1 print(x + 1)
print(x) x = 5
x = 5 h(x)
x = 5 g(x) print(x)
f(x) print(x)
print(x)

17
Esempio complesso sullo scope

def g(x): Global scope

def h(): g Some

x = 'abc' code

x = x + 1
print('g: x =', x) x 3
h()
return x z

x = 3
z = g(x)

18
Esempio complesso sullo scope

def g(x): Global scope g scope

def h(): g Some x

3
x = 'abc' code

x = x + 1
print('g: x =', x) x h Some
3
code
h()
return x z

x = 3
z = g(x)

19
Esempo complesso sullo scope

def g(x): Global scope g scope

def h(): g Some x

4
x = 'abc' code

x = x + 1
print('g: x =', x) x h Some
3
code
h()
return x z

x = 3
z = g(x)

20
Esempo complesso sullo scope

def g(x): Global scope g scope h scope

def h(): g Some x x

4
3 “abc”
x = 'abc' code

x = x + 1
print('g: x =', x) x h Some
3
code
h()
return x
z
returns None
x = 3
z = g(x)

21
Esempo complesso sullo scope

def g(x): Global scope g scope

def h(): g Some x

4
x = 'abc' code

x = x + 1
print('g: x =', x) x h Some
3
code
h()
return x None
z

x = 3 returns 4
z = g(x)

22
Esempo complesso sullo scope

def g(x): Global scope

def h(): g Some

x = 'abc' code

x = x + 1
print('g: x =', x) x 3
h()
return x z 4

x = 3
z = g(x)

23
La funzione main()

§ Generalmente la funzione main() è il punto di ingresso principale di un

programma
§ Tuttavia l'interprete Python esegue il codice fin dalla prima riga, a
prescindere dal fatto che ci sia o meno la definizione della funzione
main()
§ In Python non esiste una funzione main()
§ Quando viene dato all'interprete il comando di esecuzione di un programma Python,
viene eseguito il codice che si trova al livello 0 di indentazione
§ Tuttavia, prima di fare ciò, vengono definite alcune variabili speciali come
__name__
§ __name__ è una variabile built-in che valuta il nome del modulo corrente.
§ Se il file .py viene eseguito come programma principale, l'interprete imposta la
variabile __name__ in modo che abbia il valore __main__
§ Se il file .py viene importato da un altro modulo, __name__ sarà impostato sul
nome del modulo.

24
Esempio di main() \1
# Python program to demonstrate
# main() function
print("Hello")
# Defining main function
def main():
print("hey there")

# Using the special variable

# __name__
if __name__=="__main__":
main()

§ Output
Hello
hey there

25
L’istruzione import

§ Molte funzioni in Python sono nella standard library,

ma alcune sono in file denominati moduli
§ Questi moduli di base sono installati quando
installiamo Python (e.g., moduli per operazioni
matematiche, operazioni su file, etc.)
§ Per invocare funzioni implementate in moduli
dobbiamo utilizzare l’istruzione import
§ import math
Il modulo math contiene diverse funzioni matematiche che
lavorano con numeri floating point

26
L’istruzione import

§ L’istruzione import impone all’interprete Python di

caricare in memoria il contenuto del modulo
specificato in modo da rendere invocabili le funzioni
§ E’ possibile utilizzare anche le variabili definite nel
modulo
§ E.g.:
import math
print(math.pi)

§ E’ possibile importare funzioni e variabili specifiche

da importare
from module_name import function_name

27
Esempio di main() \2

Output: Output:
File1 __name__ = __main__ File1 __name__ = File1
File1 is being run directly File1 is being imported
File2 __name__ = __main__
File2 is being run directly

28
Passaggio Parametri
Valore del parametron predefinito

def my_function(country = "Norway"):

print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

30
Passaggio strutture dati come argomento

§ Si può passare qualsiasi tipo di dato come

argomento a una funzione (stringa, numero,
lista, dizionario ecc.) e verrà trattato come lo
stesso tipo di dato all'interno della funzione

def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)

31
Simboli speciali come argomenti

§ Simboli speciali utilizzati per passare argomenti in

Python:
§ *args (argomenti non basati su parole chiave)
§ **kwargs (argomenti di parole chiave)

32
*args

§ La sintassi speciale *args nelle definizioni di funzioni in Python

viene utilizzata per passare un numero variabile di argomenti a una
funzione. Viene utilizzato per passare un elenco di argomenti senza
parole chiave e di lunghezza variabile.
§ La sintassi prevede l'utilizzo del simbolo * per accogliere un numero
variabile di argomenti; per convenzione viene spesso utilizzato con
la parola args.
§ Ciò che *args ti consente di fare è accettare più argomenti rispetto
al numero di argomenti formali definiti in precedenza. Con *args, è
possibile aggiungere un numero qualsiasi di argomenti aggiuntivi ai
parametri formali correnti (inclusi zero argomenti aggiuntivi).
§ Ad esempio, vogliamo creare una funzione di moltiplicazione che
accetta un numero qualsiasi di argomenti ed è in grado di
moltiplicarli tutti insieme. Può essere fatto usando *args.
§ Usando *, la variabile che associamo a * diventa iterabile, il che
significa che puoi fare cose come iterare su di essa, eseguire
alcune funzioni di ordine superiore come mappa e filtro, ecc.

33
*args
def myFun(*args):
for arg in args:
print(arg)

myFun('Hello', 'Welcome', 'to', ‘Lab Progr. Class’)

def myFun2(arg1, *args):

print("First argument :", arg1)
for arg in args:
print("Next argument through *args :", arg)

myFun2('Hello', 'Welcome', 'to', ' Lab Progr. Class ')

34
**kwargs

§ La sintassi speciale **kwargs nelle definizioni di funzioni

in Python viene utilizzata per passare un elenco di
argomenti di lunghezza variabile con parole chiave.
§ Usiamo il nome kwargs con la doppia stella. Il motivo è
che la doppia stella ci consente di passare attraverso gli
argomenti delle parole chiave (e un numero qualsiasi di
essi).
§ Un argomento con parola chiave è il luogo in cui fornisci
un nome alla variabile mentre la passi alla funzione.
§ Si può pensare ai kwargs come a un dizionario che
associa ciascuna parola chiave al valore che le passiamo
accanto. Questo è il motivo per cui quando iteriamo sui
kwarg non sembra esserci alcun ordine in cui sono stati
stampati.

35
**kwargs

§ La keyword **kwargs ha un comportamento simile a *args ma

bisogna passare un valore nominato alla funzione.
§ Non potrò passare “valore”, ma dovrò specificare
chiave=”valore”.
§ In questo modo l'ordine degli argomenti non ha importanza

def supporter(**kwargs):
for k, v in kwargs.items():
print(f"{k} tifa per la squadra {v}")

supporter(Alessio="Napoli")

36
**kwargs

def my_function(child3, child2, child1):

print("The youngest child is " + child3)

my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")

def myFun(arg1, **kwargs):

for key, value in kwargs.items():
print("%s == %s" % (key, value))

myFun("Hi", first=‘Laboratorio', mid=‘di', last=‘Programmazione')

37
*args e **kwargs

def myFun(*args, **kwargs):

print("args: ", args)
print("kwargs: ", kwargs)

# Now we can use both *args ,**kwargs

# to pass arguments to this function :
myFun(‘L', ‘d', ‘P', first="L", mid="d",
last="P")
38
Esempio *args

def somma_numeri(*args):
somma = 0
for numero in args:
somma += numero
return somma

# Puoi passare quanti numeri vuoi

print(somma_numeri(1, 2, 3)) # Risultato: 6
print(somma_numeri(10, 20)) # Risultato: 30

39
Esempio *kwargs

def descrivi_persona(**kwargs):
for chiave, valore in kwargs.items():
print(f"{chiave}: {valore}")

# Puoi passare qualsiasi numero di argomenti con

parole chiave
descrivi_persona(nome="Mario", età=30, città="Roma")

40
Esempio *args e **kwargs

def funzione_esempio(*args, **kwargs):

print("args:", args)
print("kwargs:", kwargs)

funzione_esempio(1, 2, 3, chiave1="valore1",
chiave2="valore2")

41
 Decoratori

Laboratorio di Programmazione, Corso di Laurea Magistrale in Ingegneria Biomedica 42

Decoratori

§ I decoratori (in inglese decorator) sono uno strumento

che ci consente di estendere e modificare il
comportamento di funzioni e classi senza doverne
alterare direttamente il codice sorgente.
§ I decoratori sono molto potenti anche per il fatto che una
volta definiti, possono essere utilizzati su più funzioni,
rispettando in questa maniera il precetto DRY, Don’t
Repeat Yourself, che tradotto significa: evita di scrivere
lo stesso codice più volte di quanto non sia strettamente
necessario.
§ Sono un esempio di metaprogrammazione, ovvero un
modo per modificare parti del programma durante
l'esecuzione. In Python, i decoratori sono implementati
utilizzando funzioni o classi.

43
Definizione

§ Un decoratore è una funzione che prende come

parametro un’altra funzione, aggiunge delle
funzionalità e restituisce un’altra funzione senza
alterare il codice sorgente della funzione passata
come parametro.
§ Questo è possibile per il fatto che in Python le
funzioni possono essere passate come parametro e
restituite come qualsiasi altro valore, possono venire
definite all’interno di altre funzioni (nel qual caso si
parla di funzioni annidate) e assegnate a delle
variabili.

44
 Utilizzo
def funzione_decoratore(funzione_parametro):
def wrapper():
""" nome convenzionale - wrapper significa 'incarto, confezione' """
print("... codice da eseguire prima di 'funzione_parametro' ...")
funzione_parametro()
print("... codice da eseguire dopo di 'funzione_parametro' ...")
return wrapper
def mia_funzione():
print("Hello World!")
mia_funzione = funzione_decoratore(mia_funzione)
mia_funzione
# output:
... codice da eseguire prima di funzione_parametro ...
Hello World!
... codice da eseguire dopo di funzione_parametro ...

45
Utilizzo

@funzione_decoratore
def mia_funzione():
print("Hello World!")
mia_funzione()

# output:
... codice da eseguire prima di funzione_parametro ...
hello world!
... codice da eseguire dopo di funzione_parametro ...

46
Esempio

§ Quindi ciò che stiamo facendo coi decoratori, è sostanzialmente

sostituire una funzione con un’altra: questo determina che alcuni
dettagli riguardo a mia_funzione vadano persi.
§ Facciamo un primo test senza utilizzare il decoratore:

def mia_funzione():
print("Hello World!")
>>> print(mia_funzione.__name__)
# output
mia_funzione

§ Otteniamo in output il nome della nostra funzione

47
Esempio

§ Decoriamo la funzione con @funzione_decoratore:

@funzione_decoratore
def mia_funzione():
print("Hello World!")
>>> print(mia_funzione.__name__)

# output
wrapper

§ Così facendo abbiamo perso delle informazioni che potrebber

essere utili, ad esempio in fase di debugging.

48
 Decoratore Wraps
§ Per ovviare al problema e salvaguardare queste informazioni (metadata), possiamo utilizzare un decoratore apposito
incluso con la standard library, il decoratore wraps, in questo modo:
from functools import wraps
def funzione_decoratore(funzione_parametro):
@wraps(funzione_parametro)
def wrapper():
""" nome convenzionale - wrapper significa 'incarto, confezione' """
print("... codice da eseguire prima di 'funzione_parametro' ...")
funzione_parametro()
print("... codice da eseguire dopo di 'funzione_parametro' ...")
return wrapper
@funzione_decoratore
def mia_funzione():
print("Hello World!")
>>> print(mia_funzione.__name__)
# output
mia_funzione

49
Esempio: Trasformare output funzioni
in lettere maiuscole
def caps_lock(funzione_parametro):
@wraps(funzione_parametro)
def wrapper():
""" wrapper significa 'incarto, confezione' """
return funzione_parametro().upper()
return wrapper

@caps_lock
def mia_funzione():
return "hello world!"

>>> print(mia_funzione())

# output HELLO WORLD!

50
Decoratori di funzioni con parametri

def caps_lock(funzione_parametro):
@wraps(funzione_parametro)
def wrapper(*args, **kwargs):
""" wrapper significa 'incarto, confezione' """
return funzione_parametro(*args, **kwargs).upper()
return wrapper

@caps_lock
def echo(msg):
return msg

>>> print(echo("I decoratori sono fantastici, e molto potenti!"))

# output I DECORATORI SONO FANTASTICI, E MOLTO POTENTI!

51