Come definire funzioni in Python 3

Introduzione

A function is a block of instructions that performs an action and, once defined, can be reused. Functions make code more modular, allowing you to use the same code over and over again.

Python ha diverse funzioni integrate con cui potresti essere familiare, tra cui:

• print() che stamperà un oggetto sul terminale
• int() che convertirà una stringa o un numero in un tipo di dato intero
• len() che restituisce la lunghezza di un oggetto

I nomi delle funzioni includono parentesi e possono includere parametri.

In questo tutorial, esamineremo come definire le tue funzioni da utilizzare nei tuoi progetti di codifica.

Prerequisiti

Dovresti avere Python 3 installato e un ambiente di programmazione configurato sul tuo computer o server. Se non hai un ambiente di programmazione configurato, puoi fare riferimento alle guide di installazione e configurazione per un ambiente di programmazione locale o per un ambiente di programmazione sul tuo server appropriato per il tuo sistema operativo (Ubuntu, CentOS, Debian, ecc.).

Definizione di una Funzione

Cominciamo trasformando il classico programma “Ciao, Mondo!” in una funzione.

Creeremo un nuovo file di testo nel nostro editor di testo preferito e chiameremo il programma hello.py. Poi, definiremo la funzione.

A function is defined by using the def keyword, followed by a name of your choosing, followed by a set of parentheses which hold any parameters the function will take (they can be empty), and ending with a colon.

In questo caso, definiremo una funzione chiamata hello():

def hello():

Questo stabilisce l’istruzione iniziale per la creazione di una funzione.

Da qui, aggiungeremo una seconda riga con un rientro di 4 spazi per fornire le istruzioni su cosa fa la funzione. In questo caso, stamperemo Ciao, Mondo! sulla console:

def hello():
    print("Hello, World!")

Ora la nostra funzione è completamente definita, ma se eseguiamo il programma in questo punto, non succederà nulla poiché non abbiamo chiamato la funzione.

Quindi, al di fuori del nostro blocco di funzione definito, chiamiamo la funzione con hello():

def hello():
    print("Hello, World!")

hello()

Adesso, eseguiamo il programma:

python hello.py

Dovresti ricevere l’output seguente:

Output
Hello, World!

Le funzioni possono essere più complicate della funzione hello() che abbiamo definito in precedenza. Ad esempio, possiamo utilizzare cicli for, dichiarazioni condizionali e altro ancora all’interno del blocco della nostra funzione.

Per esempio, la funzione definita di seguito utilizza una dichiarazione condizionale per controllare se l’input per la variabile name contiene una vocale, quindi utilizza un for loop per iterare sui caratteri nella stringa name.

# Definire la funzione names()
def names():
    # Impostare la variabile name con input
    name = str(input('Enter your name: '))
    # Verificare se name contiene una vocale
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # Iterare su name
    for letter in name:
        print(letter)

# Chiamare la funzione
names()

La funzione names() che abbiamo definito sopra imposta una dichiarazione condizionale e un for loop, mostrando come il codice possa essere organizzato all’interno di una definizione di funzione. Tuttavia, a seconda di ciò che intendiamo con il nostro programma e di come vogliamo organizzare il nostro codice, potremmo voler definire la dichiarazione condizionale e il for loop come due funzioni separate.

Definire le funzioni all’interno di un programma rende il nostro codice modulare e riutilizzabile in modo che possiamo chiamare le stesse funzioni senza riscriverle.

Lavorare con i Parametri

Fino ad ora abbiamo esaminato le funzioni con parentesi vuote che non accettano argomenti, ma possiamo definire parametri nelle definizioni delle funzioni all’interno delle loro parentesi.

A parameter is a named entity in a function definition, specifying an argument that the function can accept.

Creiamo un piccolo programma che prende in input i parametri x, y e z. Creeremo una funzione che aggiunge i parametri insieme in diverse configurazioni. Le somme di questi verranno stampate dalla funzione. Poi chiameremo la funzione e passeremo dei numeri alla funzione.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    print(a, b, c)

add_numbers(1, 2, 3)

Abbiamo passato il numero 1 per il parametro x, 2 per il parametro y e 3 per il parametro z. Questi valori corrispondono con ciascun parametro nell’ordine in cui sono dati.

Il programma sta essenzialmente facendo la seguente matematica basata sui valori che abbiamo passato ai parametri:

a = 1 + 2
b = 1 + 3
c = 2 + 3

La funzione stampa anche a, b e c, e in base alla matematica sopra ci aspetteremmo che a sia uguale a 3, b sia 4 e c sia 5. Eseguiamo il programma:

python add_numbers.py

Output
3 4 5

Quando passiamo 1, 2 e 3 come parametri alla funzione add_numbers(), otteniamo l’output previsto.

I parametri sono argomenti che vengono tipicamente definiti come variabili all’interno delle definizioni di funzione. Possono essere assegnati valori quando si esegue il metodo, passando gli argomenti alla funzione.

Argomenti con parola chiave

Oltre a chiamare i parametri in ordine, è possibile utilizzare gli argomenti con parola chiave in una chiamata di funzione, in cui il chiamante identifica gli argomenti per nome parametro.

Quando si utilizzano gli argomenti con parola chiave, è possibile utilizzare i parametri fuori ordine perché l’interprete Python utilizzerà le parole chiave fornite per corrispondere i valori ai parametri.

Creiamo una funzione che ci mostrerà le informazioni del profilo per un utente. Passeremo i parametri ad essa sotto forma di username (inteso come stringa) e followers (inteso come un intero).

# Definire la funzione con parametri
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

All’interno della dichiarazione della definizione della funzione, username e followers sono contenuti tra le parentesi della funzione profile_info(). Il blocco della funzione stampa le informazioni sull’utente come stringhe, facendo uso dei due parametri.

Ora, possiamo chiamare la funzione e assegnare parametri ad essa:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Chiamare la funzione con i parametri assegnati come sopra
profile_info("sammyshark", 945)

# Chiamare la funzione con argomenti con parola chiave
profile_info(username="AlexAnglerfish", followers=342)

Nella prima chiamata di funzione, abbiamo compilato le informazioni con un nome utente di sammyshark e un numero di follower pari a 945, nella seconda chiamata di funzione abbiamo utilizzato gli argomenti di parola chiave, assegnando valori alle variabili di argomento.

Eseguiamo il programma:

python profile.py

Output
Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

L’output ci mostra i nomi utente e il numero di follower per entrambi gli utenti.

Ciò ci permette anche di modificare l’ordine dei parametri, come in questo esempio del medesimo programma con una chiamata diversa:

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Cambia l'ordine dei parametri
profile_info(followers=820, username="cameron-catfish")

Quando eseguiamo nuovamente il programma con il comando python profile.py, riceveremo il seguente output:

Output
Username: cameron-catfish
Followers: 820

Poiché la definizione della funzione mantiene lo stesso ordine delle istruzioni print(), se utilizziamo gli argomenti di parola chiave, non importa in quale ordine li passiamo nella chiamata di funzione.

Valori predefiniti degli argomenti

Possiamo anche fornire valori predefiniti per uno o entrambi i parametri. Creiamo un valore predefinito per il parametro followers con un valore di 1:

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

Ora, possiamo eseguire la funzione con solo il nome utente assegnato e la quantità di follower verrà automaticamente impostata su 1 per default. Possiamo comunque cambiare il numero di follower se lo desideriamo.

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)

Quando eseguiamo il programma con il comando python profile.py, riceveremo il seguente output:

Output
Username: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

Fornire parametri predefiniti con valori può consentirci di saltare la definizione dei valori per ciascun argomento che ha già un valore predefinito.

Restituire un Valore

È possibile passare un valore del parametro in una funzione, e una funzione può anche produrre un valore.

A function can produce a value with the return statement, which will exit a function and optionally pass an expression back to the caller. If you use a return statement with no arguments, the function will return None.

Fino ad ora, abbiamo usato l’istruzione print() invece dell’istruzione return nelle nostre funzioni. Creiamo un programma che invece di stampare restituirà una variabile.

In un nuovo file di testo chiamato square.py, creeremo un programma che eleva al quadrato il parametro x e restituisce la variabile y. Emettiamo una chiamata per stampare la variabile result, che è formata eseguendo la funzione square() con 3 passato ad essa.

def square(x):
    y = x ** 2
    return y

result = square(3)
print(result)

Possiamo eseguire il programma e ricevere l’output:

python square.py

Output
9

Il numero intero 9 viene restituito come output, che è ciò che ci aspetteremmo chiedendo a Python di trovare il quadrato di 3.

Per comprendere meglio come funziona l’istruzione return, possiamo commentare l’istruzione return nel programma:

def square(x):
    y = x ** 2
    # return y

result = square(3)
print(result)

Ora, eseguiamo di nuovo il programma:

python square.py

Output
None

Senza utilizzare l’istruzione return qui, il programma non può restituire un valore quindi il valore predefinito è None.

Come altro esempio, nel programma add_numbers.py sopra, potremmo sostituire l’istruzione print() con un’istruzione return.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

sums = add_numbers(1, 2, 3)
print(sums)

All’esterno della funzione, abbiamo impostato la variabile somme uguale al risultato della funzione che prende in input 1, 2, e 3 come abbiamo fatto prima. Poi abbiamo chiamato una stampa della variabile somme.

Eseguiamo il programma di nuovo ora che ha l’istruzione return:

python add_numbers.py

Output
(3, 4, 5)

Riceviamo gli stessi numeri 3, 4, e 5 come output che abbiamo ricevuto precedentemente usando l’istruzione print() nella funzione. Questa volta viene restituito come una tupla perché la lista di espressioni dell’istruzione return ha almeno una virgola.

Le funzioni escono immediatamente quando incontrano un’istruzione return, che stiano o meno restituendo un valore.

def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # Interrompe la funzione quando x == 5
            return
    print("This line will not execute.")

loop_five()

Usare l’istruzione return all’interno del ciclo for termina la funzione, quindi la riga che è al di fuori del ciclo non verrà eseguita. Se, invece, avessimo usato un istruzione break, solo il ciclo sarebbe uscito in quel momento, e l’ultima riga print() sarebbe stata eseguita.

Il comando return esce da una funzione e può restituire un valore quando emesso con un parametro.

Utilizzare main() come funzione

Anche se in Python è possibile chiamare la funzione alla fine del programma e verrà eseguita (come abbiamo fatto negli esempi precedenti), molti linguaggi di programmazione (come C++ e Java) richiedono una funzione main per poter eseguire. Includere una funzione main(), anche se non è obbligatorio, può strutturare i nostri programmi Python in modo logico che mette i componenti più importanti del programma in una funzione. Può anche rendere i nostri programmi più facili da leggere per i programmatori non esperti di Python.

Cominceremo aggiungendo una funzione main() al programma hello.py sopra. Manterremo la nostra funzione hello(), e poi definiremo una funzione main():

def hello():
    print("Hello, World!")

def main():

All’interno della funzione main(), includiamo una dichiarazione print() per farci sapere che siamo nella funzione main(). Inoltre, chiamiamo la funzione hello() all’interno della funzione main():

def hello():
    print("Hello, World!")


def main():
    print("This is the main function")
    hello()

Infine, nella parte inferiore del programma, chiameremo la funzione main():

def hello():
    print("Hello, World!")

def main():
    print("This is the main function.")
    hello()

main()

A questo punto, possiamo eseguire il nostro programma:

python hello.py

Riceveremo l’output seguente:

Output
This is the main function.
Hello, World!

Poiché abbiamo chiamato la funzione hello() all’interno di main() e poi abbiamo chiamato solo main() per eseguire, il testo Hello, World! viene stampato solo una volta, dopo la stringa che ci diceva che eravamo nella funzione principale.

Successivamente lavoreremo con più funzioni, quindi vale la pena rivedere la portata delle variabili globali e locali. Se definisci una variabile all’interno di un blocco di funzione, potrai utilizzare quella variabile solo all’interno di quella funzione. Se vuoi utilizzare variabili tra le funzioni, potrebbe essere meglio dichiarare una variabile globale.

In Python, '__main__' è il nome dello scope in cui verrà eseguito il codice di livello superiore. Quando un programma viene eseguito da input standard, da uno script o da un prompt interattivo, il suo __name__ viene impostato uguale a '__main__'.

Per questo motivo, c’è una convenzione per utilizzare la seguente costruzione:

if __name__ == '__main__':
    # Codice da eseguire quando questo è il programma principale qui

Questo consente ai file del programma di essere utilizzati sia:

• come programma principale ed eseguire ciò che segue l’istruzione if
• come modulo e non eseguire ciò che segue l’istruzione if.

Qualsiasi codice che non è contenuto in questa istruzione verrà eseguito all’avvio. Se stai utilizzando il tuo file di programma come modulo, il codice che non è in questa istruzione verrà eseguito anche durante l’importazione mentre viene eseguito il file secondario.

Espandiamo il nostro programma names.py sopra, e creiamo un nuovo file chiamato more_names.py. In questo programma dichiareremo una variabile globale e modificheremo la nostra funzione originale names() in modo che le istruzioni siano in due funzioni discrete.

La prima funzione, has_vowel(), verificherà se la stringa name contiene una vocale.

La seconda funzione print_letters() stamperà ogni lettera della stringa name.

# Dichiarare la variabile globale name per l'uso in tutte le funzioni
name = str(input('Enter your name: '))


# Definire la funzione per verificare se il nome contiene una vocale
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterare sulle lettere nella stringa del nome
def print_letters():
    for letter in name:
        print(letter)

Con questa configurazione, definiamo la funzione main() che conterrà una chiamata sia alla funzione has_vowel() che alla funzione print_letters().

# Dichiarare la variabile globale name per l'uso in tutte le funzioni
name = str(input('Enter your name: '))


# Definire la funzione per verificare se il nome contiene una vocale
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterare sulle lettere nella stringa del nome
def print_letters():
    for letter in name:
        print(letter)


# Definire il metodo principale che chiama le altre funzioni
def main():
    has_vowel()
    print_letters()

Infine, aggiungeremo la costruzione if __name__ == '__main__': in fondo al file. Ai nostri scopi, poiché abbiamo inserito tutte le funzioni che vorremmo eseguire nella funzione main(), chiameremo la funzione main() seguendo questa istruzione if.

# Dichiarare la variabile globale name per l'uso in tutte le funzioni
name = str(input('Enter your name: '))


# Definire la funzione per verificare se il nome contiene una vocale
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterare sui caratteri nella stringa nome
def print_letters():
    for letter in name:
        print(letter)


# Definire il metodo principale che chiama le altre funzioni
def main():
    has_vowel()
    print_letters()


# Eseguire la funzione main()
if __name__ == '__main__':
    main()

Adesso possiamo eseguire il programma:

python more_names.py

Il programma mostrerà lo stesso output del programma names.py, ma qui il codice è più organizzato e può essere utilizzato in modo modulare senza modifiche.

Se non avessi voluto dichiarare una funzione main(), avresti potuto terminare il programma in questo modo:

...
if __name__ == '__main__':
    has_vowel()
    print_letters()

Utilizzare main() come una funzione e l’istruzione if __name__ == '__main__': può organizzare il tuo codice in modo logico, rendendolo più leggibile e modulare.

Conclusioni

Le funzioni sono blocchi di istruzioni che eseguono azioni all’interno di un programma, aiutando a rendere il nostro codice riutilizzabile e modulare.

Per saperne di più su come rendere il tuo codice più modulare, puoi leggere la nostra guida su Come Scrivere Moduli in Python 3.