Gestire gli argomenti delle funzioni in Python

Per la definizione delle funzioni in Python è necessario tener presente alcune regole sintattiche in modo da evitare la generazione di errori. Vi sono poi dei cotrutti particolari che semplificheranno il lavoro dello sviluppatore.

Il numero degli argomenti

Quando si definisce una funzione, in Python è necessario che gli argomenti passati ad essa come parametri siano definiti a priori sia nella loro natura che nel loro numero; se per esempio si prevede che una funzione debba accettare due argomenti non si potr passare ad essa un solo parametro. A tal proposito è possibile proporre un semplice esempio basato su una funzione che prevede di elaborare due parametri.

# Passaggio di argomenti ad un funzione
# in esecuzione non verranno generati errori
# perché il numero di parametri passati
# è quello corretto
def dev(linguaggio,database):
   """Una semplice
   funzione che pone una domanda sulla base di
   due parametri"""
   print('Sviluppi applicazioni in ' + linguaggio + '? Utilizzi ' + database + '?')

dev('Python','MySQL')

Ora, si provi a non passare alcun parametro alla funzione, effettuando la chiamata in questo modo:

dev()

L’interprete di Python rileverà la sintassi inattesa e notificherà la presenza di un errore nell’istruzione attraverso il seguente output:

TypeError: dev() missing 2 required positional arguments: 'linguaggio' and 'database'

Nello stesso modo, si otterrebbe una notifica di errore effettuando nuovamente la chiamata con il passaggio di un singolo parametro:

dev('Python')

In questo secondo caso, infatti, l’interprete del linguaggio reagirebbe attraverso la seguente segnalazione indicando il nome dell’argomento mancante:

TypeError: dev() missing 1 required positional argument: 'database'

Nello sviluppo della applicazioni Python sarà quindi necessario tener presente che le funzioni definite dagli utenti richiedono un numero fisso di argomenti.

Argomenti predefiniti per le funzioni

Nell’esempio analizzato precedentemente sono stati passati due argomenti ad una funzione, tali parametri sono stati poi valorizzati successivamente; nell’esempio seguente verrà analizzato uno scenario diverso, quello in cui ad uno degli argomenti utilizzati viene assegnato un valore predefinito:

# Passaggio di argomenti ad un funzione
# con definizione di un valore predefinito
# per uno dei due parametri
def dev(linguaggio,database = "PostgreSQL"):
   """Per la chiamata alla
   funzione sarà suffiente il passaggio di un solo argomento
   il primo è stato definito a priori"""
   print('Sviluppi applicazioni in ' + linguaggio + '? Utilizzi ' + database + '?')

dev('Python')

Si noti come in questo caso basterà passare alla chiamata della funzione soltanto l’argomento non associato ad un valore predefinito, ma dato che tutti i parametri potranno essere valorizzati di default come nell’esempio seguente:

# Passaggio di argomenti ad un funzione
# con definizione di valori predefiniti
# per tutti i parametri previsti
def dev(linguaggio = 'Python',database = 'PostgreSQL'):
   """Per la chiamata alla
   funzione non verrà richiesto il passaggio di argomenti
   in quanto entrambi già definiti a priori"""
   print('Sviluppi applicazioni in ' + linguaggio + '? Utilizzi ' + database + '?')

dev()

in questo caso non sarà necessario passare alcun argomento alla chiamata della funzione perché tutti i parametri sono stati già abbinati a dei valori di default al momento della sua definizione.

Override degli argomenti

Un caso particolare riguardante la definizione di argomenti predefiniti riguarda la possibilità di effettuarne l’override, cioè di sovrascriverne i valori; in pratica, come mostrato efficacemente dall’esempio proposto di seguito, i valori di default definiti dall’utente potranno essere sostituiti dinamicamente con altri all’atto della chiamata:

# Passaggio di argomenti ad un funzione
# con definizione di valori predefiniti
# e successivo override dei parametri
def dev(linguaggio = 'Python',database = 'PostgreSQL'):
   """Per la chiamata alla
   funzione sarà richiesto il passaggio di argomenti
   per sovrascrivere quelli definiti a priori"""
   print('Sviluppi applicazioni in ' + linguaggio + '? Utilizzi ' + database + '?')

dev('PHP','MongoDB')

In pratica, grazie alla sovrascrittura dinamica dei valori non si riceverà più in output il risultato inizialmente atteso:

Sviluppi applicazioni in Python? Utilizzi PostgreSQL?

Ma un nuovo risultato basato sui nuovi valori associati agli argomenti che, come sarà possibile notare, rimarranno invece i medesimi.

Sviluppi applicazioni in PHP? Utilizzi MongoDB?

Si tenga conto del fatto che nel caso in cui ad un primo argomento sia stato attribuito un valore predefinito, anche tutti gli argomenti successivi (per inciso, quelli alla sua destra) dovranno essere valorizzati di default, altrimenti l’interprete di Python invierà una segnalazione di errore di tipo sintattico:

non-default argument follows default argument

esattamente come accadrebbe nel caso in cui si eseguisse il codice contenuto nell’esempio seguente:

# Passaggio di argomenti ad un funzione
# con definizione di un valore predefinito
# per il solo prametro iniziale
def dev(linguaggio = 'Python',database):
   """La chiamata alla
   funzione produrrà un errore perché gli argomenti successivi
   al primo non sono stati valorizzati di default"""
   print('Sviluppi applicazioni in ' + linguaggio + '? Utilizzi ' + database + '?')

dev('PostgreSQL')

Arbitrarietà degli argomenti

Come descritto in precedenza, Python prevede che il numero degli argomenti sia fisso, esiste però una soluzione sintattica che consente di gestire i casi in cui non sia possibile stabilire a priori il numero di parametri da passare alla funzione. Questo accorgimento si basa sull’utilizzo del carattere wildcard "*" da inserire precedentemente ad un argomento che potrà essere sottoposto successivamente ad un ciclo di iterazione con il quale estrarre i valori definiti in fase di chiamata:

# Passaggio di un numero arbitrario 
# di argomenti ad un funzione
def dev(*linguaggi):
    """L'esecuzione alla funzione
    determinerà l'estrazione di tutti i valori
    associati al parametro passato come argomento
    tramite "*" """

   # ciclo per l'estrazione dei valori dall'argomento
   for linguaggio in linguaggi:
       print('Io sviluppo in',linguaggio)

dev('Python','PHP','Java','JavaScript')

Grazie all’adozione di "*" il parametro passato alla funzione verrà convertito in una tuple, cioè un costrutto per alcune versi simile ad una lista i cui elementi non potranno essere modificati una volta definiti. Tuple e liste sono due datatypes di Python che verranno approfonditi ulteriormente a breve.