 |
 |
 |
Il manuale di riferimento di Python |  |
 |
 |
|
|
|
Il manuale di riferimento di Python | |
|
|
Una chiamata richiede un oggetto invocabile (per esempio una funzione) con una possibile lista vuota di argomenti:
call |
::= | primary "(" [argument_list [","]] ")" |
argument_list |
::= | positional_arguments ["," keyword_arguments] |
["," "*" expression] | ||
["," "**" expression] | ||
| keyword_arguments ["," "*" expression] | ||
["," "**" expression] | ||
| "*" expression ["," "**" expression] | ||
| "**" expression | ||
positional_arguments |
::= | expression ("," expression)* |
keyword_arguments |
::= | keyword_item ("," keyword_item)* |
keyword_item |
::= | identifier "=" expression |
Dopo una lista di argomenti può essere presente una virgola che non ha comunque effetto sulla semantica.
La primitiva deve valutare un oggetto invocabile (funzioni definite dall'utente, funzioni built-in, metodi di oggetti built-in, classi, metodi di istanze di classe e alcune istanze di classe che sono esse stesse invocabili; attraverso estensioni si possono definire tipi aggiuntivi di oggetti invocabili). Tutti gli argomenti vengono valutati prima di effettuare la chiamata. Fare riferimento alla sezione 7.5 per la sintassi formale delle liste di parametri.
Se sono presenti argomenti chiave, vengono prima convertiti in
argomenti posizionali, some segue. Prima viene creata una lista di
slot vuoti per i parametri formali. Se ci sono N argomenti
posizionali, vengono posti nei primi N slot. Quindi, per ogni
argomento chiave, l'identificativo viene usato per determinare lo slot
corrispondente (se l'identificativo ha lo stesso nome del primo
parametro formale, viene usato il primo slot e così via). Se lo slot
è stato già riempito, viene sollevata un'eccezione
TypeError, altrimenti, il valore dell'argomento viene
posto nello slot, riempiendolo (anche se l'argomento è None).
Quando tutti gli argomenti sono stati processati, gli slot che sono
ancora vuoti vengono riempiti con i corrispondenti valori predefiniti
nella definizione della funzione. (Valori predefiniti vengono
calcolati non appena viene definita la funzione; così un oggetto
mutabile come una lista o un dizionario, usati come valori
predefiniti, verranno condivisi da tutte le chiamate che non
specificano un argomento per lo slot corrispondente; di solito questo
dovrebbe essere evitato.) Se ci sono degli slot vuoti per i quali non
sono stati specificati dei valori predefiniti, viene sollevata
un'eccezione TypeError. Altrimenti, la lista di slot
pieni viene usata come lista di argomenti per la chiamata.
Se ci sono più argomenti posizionali degli slot di parametri formali, viene sollevata un'eccezione TypeError, a meno che non sia presente un parametro formale che usi la sintassi "*identificativo". In questo caso, il parametro formale riceve una tupla contenente gli argomenti posizionali in eccesso (o una tupla vuota se non ci sono stati argomenti posizionali in eccesso).
Se qualche argomento chiave non corrisponde al nome del parametro formale, viene sollevata un'eccezione TypeError, a meno che il parametro formale non usi la sintassi "**identificativo" nel qual caso, questo parametro formale riceve un dizionario corrispondente contenente gli argomenti chiave in eccesso (usando le parole come chiavi e gli argomenti come i valori corrispondenti), o un (nuovo) dizionario vuoto se non vi sono stati argomenti chiave in eccesso.
Se appare la sintassi "*espressione" nella chiamata a funzione, l'"espressione" deve essere valutata come una sequenza. Gli elementi di questa sequenza vengono trattati come se fossero argomenti posizionali aggiuntivi; se ci sono argomenti posizionali x1,...,xN ed "espressione" viene valutata come una sequenza y1,...,yM, è equivalente ad una chiamata con M+N argomenti posizionali x1,...,xN,y1,...,yM.
Una conseguenza di questo è che anche se la sintassi "*espressione" appare dopo ogni argomento chiave, viene processato prima l'argomento chiave (e quindi l'argomento "**espressione", se è presente - vedere sotto). Così:
>>> def f(a, b): ... print a, b ... >>> f(b=1, *(2,)) 2 1 >>> f(a=1, *(2,)) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: f() got multiple values for keyword argument 'a' >>> f(1, *(2,)) 1 2
È insolito usare gli argomenti chiave e la sintassi "*espressione" nella stessa chiamata e quindi, in pratica, non c'è confusione.
Se è presente la sintassi "**espressione" nella chiamata a funzione, "espressione" deve essere valutata come un (o una sottoclasse di un) dizionario, il cui contenuto viene trattato come argomenti chiave aggiuntivi. Nel caso in cui una parola chiave appaia sia in "espressione" che come una parola chiave di uno specifico argomento, viene sollevata un'eccezione TypeError.
Parametri formali che usano la sintassi "*identificativo" o "**identificativo" non possono essere usati come slot per argomenti posizionali o come nomi di argomenti chiave. Parametri formali che usano la sintassi "(sublist)" non possono essere usati come nomi di argomenti chiave; la sublist più lontana corrisponde ad un singolo slot senza nome ed il valore viene assegnato alla sublist usando le tipiche regole di assegnamento per le tuple, dopo che tutti gli altri parametri sono stati processati.
Una chiamata restituisce sempre qualche valore, possibilmente
None, a meno che non venga sollevata un'eccezione. Il modo in
cui viene calcolato questo valore dipende dal tipo di oggetto
invocabile.
Se è--
|
|
|
Il manuale di riferimento di Python | |
|
|