Funzioni in

Informazioni su Funzioni

Una function è un blocco di codice organizzato e riutilizzabile che serve a svolgere un compito specifico. Le Functions offrono una migliore modularità per l'applicazione e un alto grado di riutilizzo del codice. Python, come altri linguaggi di programmazione, ha delle built-in functions (print, map e così via) già pronte all'uso. Puoi anche definire funzioni tue. Queste si chiamano user-defined functions. Le funzioni possono fare cose semplici come stampare un messaggio sulla console, oppure essere piuttosto complesse.

Per eseguire il codice dentro una funzione, devi chiamare la funzione: per farlo, scrivi il nome della funzione seguito da una coppia di parentesi tonde [()]. I dati, noti come arguments, possono essere passati alla funzione inserendoli tra le parentesi. La definizione di una funzione può includere zero o più parameters. I parametri definiscono quali argomenti la funzione accetta. Un parametro definisce quale tipo di argomento deve essere passato. L'argomento è il valore effettivo che viene passato quando la funzione viene chiamata. Le funzioni possono svolgere compiti diversi a seconda degli argomenti passati ai parametri.

Una funzione può anche restituire un valore usando la parola chiave return. Il valore restituito dalla funzione è noto come return value. Il valore restituito viene restituito a chi ha chiamato la funzione.

Creazione

In Python, le funzioni si creano con la parola chiave def. La definizione della funzione è seguita dal nome della funzione e da una coppia di parentesi tonde [()]. Tra le parentesi si specificano i parametri, separati da virgole. Dopo la parentesi di chiusura, i due punti (:) separano la firma della funzione dal corpo della funzione.

Il corpo della funzione è un blocco di codice che viene eseguito quando la funzione viene chiamata. Il corpo della funzione è indentato. L'indentazione è importante perché Python si basa su di essa per sapere dove finisce quel blocco di codice. Un valore può essere restituito dalla funzione usando la parola chiave return, e chi ha chiamato la funzione può usarlo in seguito.

def function_name(parameter1, parameter2, ...):
    # function body
    return parameter1 + parameter2

Possiamo anche definire una funzione senza parametri né valore restituito.

def function_name():
    # function body
    pass

Tieni presente che la funzione ha comunque bisogno di un corpo, anche se il corpo non fa nulla: se provi a eseguire il programma, otterrai un errore di indentazione.

>>> def my_bodyless_func():
...      

File ~/temp.py:1
    
    ^
IndentationError: expected an indented block

Chiamare una funzione

Per chiamare una funzione, usa il nome della funzione seguito da parentesi [()]. I parametri passati alla funzione si inseriscono tra le parentesi, separati da virgole.

Considera la seguente funzione:

def greet():
    print("Hello")

La funzione qui sopra si può chiamare con la seguente sintassi:

>>> greet()
Hello

I parametri e i loro argomenti

Gli argomenti sono valori che vengono passati alla funzione quando viene chiamata. Possono essere di qualsiasi tipo di dato, comprese altre funzioni o classi.

Definiamo una funzione add che somma due numeri:

def add(first, second):
    print(first + second)

I parametri first e second definiscono quali argomenti la funzione add accetterà. (Va detto che le parole parameter e argument vengono spesso usate in modo intercambiabile, anche se in modo impreciso.) Quando la funzione viene chiamata, gli argomenti vengono passati alla funzione. Dobbiamo passare un argomento per entrambi i parametri, altrimenti viene sollevato un TypeError.

>>> add(2, 3)
5

# Function can be called multiple times, with different parameters
>>> add(4, 3)
7
>>> add(5, 6)
11

# Passing an incorrect number of parameters will raise a `TypeError`
>>> add(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'second'

>>> add(2, 3, 4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() takes 2 positional arguments but 3 were given

Il valore restituito

Il valore restituito è un valore che viene restituito a chi ha chiamato la funzione. Un return value può essere di qualsiasi tipo di dato, comprese altre funzioni o classi. Chi ha chiamato la funzione può usarlo per svolgere altre operazioni. Se una funzione non definisce esplicitamente un return value, l'interprete Python restituirà il valore None.

Definiamo una funzione add:

def add(first, second):
    return first + second

Possiamo memorizzare il valore restituito in una variabile e poi stamparlo:

>>> result = add(2, 3)
>>> print(result)
5
# Type of result is `int`
>>> type(result)
<class 'int'>

# We can also perform operations on the return value
>>> result * 2
10

# A function without an explicit return value will return `None`
>>> def log(message):
    print(message)

# Hello is printed because of print(message), but return value is `None`
>>> return_value = log("Hello")
Hello
>>> return_value
None

L'uso di return esce immediatamente dalla funzione e restituisce il valore a chi l'ha chiamata.

>>> def show(first, second):
    print(first)
    return first
    print(second)

# second never gets printed, because the function exits after the return statement
>>> show(1, 2)
1

Modularità

I programmi complessi si possono suddividere in parti più piccole. Funzioni diverse possono svolgere compiti specifici diversi.

Supponiamo che un programma debba svolgere i seguenti compiti:

• Calcolare l'area di un cerchio
• Calcolare l'area di un rettangolo
• Calcolare l'area di un triangolo

Possiamo suddividere il programma in parti più piccole.

def circle_area(radius):
    return 3.14 * radius * radius

def rectangle_area(length, breadth):
    return length * breadth

def triangle_area(base, height):
    return 0.5 * base * height

Ora possiamo chiamare le funzioni nell'ordine che vogliamo.

>>> circle_area(2)
12.56
>>> triangle_area(2, 3)
3.0
>>> rectangle_area(2, 3)
6
>>> rectangle_area(1, 2) + circle_area(2) + triangle_area(1, 2)
15.56

Lo scope delle variabili

Se una variabile (o nome) è definita dentro una funzione, sarà accessibile solo all'interno dello scope della funzione (o namespace locale), anche se esiste una variabile con lo stesso nome fuori dallo scope della funzione.

Le variabili definite fuori da una funzione, a livello di modulo, rientrano nel namespace globale. Le variabili definite fuori da una funzione ma dentro una funzione o una classe che la racchiude stanno nel namespace nonlocal.

Python usa la regola LEGB (Local, Enclosing, Global, Built-in) per risolvere i nomi delle variabili mentre un programma è in esecuzione:

1. Ricerca nel namespace local (o function).
2. Ricerca nel namespace enclosing (o nonlocal) se un nome non si trova in local.
3. Ricerca nel namespace global (livello di modulo) se il nome non si trova in nonlocal/enclosing.
4. Ricerca nel namespace built-in (del programma o di tutto Python) se il nome non si trova in global.

Se il nome resta irrisolto, Python solleva una NameError exception.

# Global namespace.
general_favorite = "apples"


def alices_favorite():
   # Local namespace.  
   favorite = "cherries"
   
   # This works because Python will eventually find general_favorite in the global namespace.
   # Python will find 'print' in the built-in namespace.
   print(f'Alice has always liked {favorite}, but most people like {general_favorite}.')

   
def our_favorite_fruits():
    # Enclosing or nonlocal namespace.
    yours = "peaches"
    
    def my_favorite():
        # Local namespace.
        mine = "pears"
        
        # This works because Python will eventually find 'yours' in the enclosing/nonlocal namespace.
        print(f'My favorite is {mine}, but you like {yours} instead.')
        
        # This works because Python will eventually find 'general_favorite' in the global namespace.
        print(f'Everyone seems to like {general_favorite}')
    
    # This function is in the local namespace of the 'our_favorite_fruits' function.  
    my_favorite()

    
# This will raise NameError: name 'favorite' is not defined, because the variable favorite is local to alices_favorite.
print(favorite)

Se vogliamo rendere un nome di variabile accessibile fuori dallo scope locale della funzione (o modificare una variabile definita fuori dallo scope della funzione), dobbiamo usare la parola chiave global oppure nonlocal.

Usare la parola chiave global indica a Python di iniziare la ricerca nel namespace globale. Le assegnazioni alla variabile modificheranno quindi la variabile globale, invece di creare una versione locale. Quando global viene usato per dichiarare una variabile, la variabile viene aggiunta al namespace globale. Di conseguenza, global va usato con cautela: aggiungere o modificare una variabile globale può avere effetti su tutto il resto del codice che ne usa il valore.

La parola chiave nonlocal indica a Python di cercare o creare la variabile nel namespace nonlocal o enclosing. Si usa quando una funzione è annidata dentro un'altra funzione o classe e ha bisogno di accedere alle variabili e allo scope della funzione esterna.

Le funzioni come oggetti di prima classe

In Python, le funzioni si possono assegnare a variabili e passare come argomenti ad altre funzioni. Si possono usare come valori restituiti. Le funzioni si possono anche inserire in una sequenza (list, tuple e così via) oppure come valore in un dict. Le funzioni si possono usare ovunque si possa usare qualsiasi altro oggetto. Questo perché le funzioni sono first class objects. Per questo motivo hanno attributi speciali e possono persino definire attributi personalizzati propri da leggere e scrivere.

# print is a function

# A function can be assigned to a variable.
>>> function_as_variable = print
>>> function_as_variable("Hello")
Hello
>>> type(fake_print)
<class 'builtin_function_or_method'>

# Functions can be passed as an argument to another function.
>>> def check_print(func):
    func("Hello")
>>> check_print(print)
Hello

# Function can be used as an item in a sequence.
>>> my_list = [print, "Hello"]
>>> my_list[0]("Hello")
Hello

# Functions can be used as a value in a dictionary.
>>> my_dict = {"key": print}
>>> my_dict["key"]("Hello")
Hello

# Functions can be returned from a function.
>>> def return_func():
    return print
>>> return_func()("Hello")
Hello

Le funzioni possono anche essere annidate dentro altre funzioni.

def outer():
    num = 10
    
    # This is a nested, or "inner" function.
    def inner():
        print(num)
    
    # Outer function calling inner function
    inner()

La funzione interna può accedere alla variabile num definita nella funzione esterna.

>>> outer()
10

Attributi speciali

Le funzioni in Python hanno attributi speciali. Alcuni di questi sono:

• __name__: nome della funzione
• __doc__: stringa di documentazione della funzione
• __module__: modulo in cui è definita la funzione
• __globals__: dizionario delle variabili globali nella funzione
• __code__: oggetto codice che contiene le istruzioni della funzione

>>> def add(first, second):
      return first + second

# Function name
>>> print.__name__
'print'
>>> len.__name__
'len'
>>> add.__name__
'add'

# Function documentation
>>> abs.__doc__
'Return the absolute value of the argument.'

# Module
>>> len.__module__
'builtins'
>>> add.__module__
'__main__'

L'elenco completo degli attributi delle funzioni si trova in Python DataModel.