4. Altri Strumenti di Controllo del Flusso
******************************************

Oltre all'istruzione "while" appena introdotta, Python ne utilizza
altre che incontreremo in questo capitolo.


4.1. Istruzioni "if"
====================

Forse il tipo di istruzione più conosciuto è l'istruzione "if".  Ad
esempio:

   >>> x = int(input("Please enter an integer: "))
   Please enter an integer: 42
   >>> if x < 0:
   ...     x = 0
   ...     print('Negative changed to zero')
   ... elif x == 0:
   ...     print('Zero')
   ... elif x == 1:
   ...     print('Single')
   ... else:
   ...     print('More')
   ...
   More

Possiamo avere zero o più parti "elif", e la parte "else" è
facoltativa. La parola chiave '"elif"' è l'abbreviazione di 'else if',
ed è utile per evitare un'eccessiva indentazione. Una sequenza "if"
... "elif" ... "elif" ... è un sostituto per le istruzioni "switch" o
"case" trovate in altri linguaggi.

Se stai confrontando lo stesso valore con diverse costanti, o
controllando tipi o attributi specifici, potresti trovare utile
l'istruzione "match". Per maggiori dettagli, consulta Istruzioni
match.


4.2. Istruzioni "for"
=====================

L'istruzione "for" in Python differisce leggermente da ciò a cui
potresti essere abitualmente abituato in C o Pascal. Piuttosto che
iterare sempre su una progressione aritmetica di numeri (come in
Pascal), o dare all'utente la possibilità di definire sia il passo di
iterazione che la condizione di arresto (come in C), l'istruzione
"for" di Python itera sugli elementi di qualsiasi sequenza (una lista
o una stringa), nell'ordine in cui appaiono nella sequenza. Ad
esempio:

   >>> # Measure some strings:
   >>> words = ['cat', 'window', 'defenestrate']
   >>> for w in words:
   ...     print(w, len(w))
   ...
   cat 3
   window 6
   defenestrate 12

Il codice che modifica una collezione durante l'iterazione sulla
stessa può essere difficile da scrivere correttamente. Invece, è
generalmente più semplice iterare su una copia della collezione o
crearne una nuova:

   # Create a sample collection
   users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}

   # Strategy:  Iterate over a copy
   for user, status in users.copy().items():
       if status == 'inactive':
           del users[user]

   # Strategy:  Create a new collection
   active_users = {}
   for user, status in users.items():
       if status == 'active':
           active_users[user] = status


4.3. La Funzione "range()"
==========================

Se hai bisogno di iterare su una sequenza di numeri, la funzione
integrata "range()" è utile.  Genera progressioni aritmetiche:

   >>> for i in range(5):
   ...     print(i)
   ...
   0
   1
   2
   3
   4

Il valore finale fornito non fa parte della sequenza generata;
"range(10)" genera 10 valori, gli indici legali per gli elementi di
una sequenza di lunghezza 10. È possibile far partire l'intervallo da
un altro numero, o specificare un incremento diverso (anche negativo;
talvolta questo è chiamato 'passo'):

   >>> list(range(5, 10))
   [5, 6, 7, 8, 9]

   >>> list(range(0, 10, 3))
   [0, 3, 6, 9]

   >>> list(range(-10, -100, -30))
   [-10, -40, -70]

Per iterare sugli indici di una sequenza, puoi combinare "range()" e
"len()" nel seguente modo:

   >>> a = ['Mary', 'had', 'a', 'little', 'lamb']
   >>> for i in range(len(a)):
   ...     print(i, a[i])
   ...
   0 Mary
   1 had
   2 a
   3 little
   4 lamb

Nella maggior parte di questi casi, però, è conveniente utilizzare la
funzione "enumerate()", vedi Tecniche di Looping.

Attenzione: succede una cosa strana se provi a stampare un range:

   >>> range(10)
   range(0, 10)

In molti casi, l'oggetto restituito da "range()" si comporta come se
fosse una lista, ma in realtà non lo è. È un oggetto che restituisce
gli elementi successivi della sequenza desiderata quando ci si itera
sopra, ma non crea effettivamente la lista, risparmiando così spazio.

Diciamo che un tale oggetto è un *iterable*, cioè adatto per funzioni
e costrutti che si aspettano qualcosa da cui possono ottenere elementi
fino a quando il contenitore è vuoto. Abbiamo visto che l'istruzione
"for" è un tale costrutto, mentre un esempio di una funzione che
prende come argomento un oggetto iterabile è "sum()":

   >>> sum(range(4))  # 0 + 1 + 2 + 3
   6

In seguito vedremo altre funzioni che restituiscono oggetti iterabili
e prendono oggetti iterabili come argomenti. Nel capitolo Strutture
Dati, discuteremo in modo più dettagliato riguardo a "list()".


4.4. "break" and "continue" Statements
======================================

The "break" statement breaks out of the innermost enclosing "for" or
"while" loop:

   >>> for n in range(2, 10):
   ...     for x in range(2, n):
   ...         if n % x == 0:
   ...             print(f"{n} equals {x} * {n//x}")
   ...             break
   ...
   4 equals 2 * 2
   6 equals 2 * 3
   8 equals 2 * 4
   9 equals 3 * 3

The "continue" statement continues with the next iteration of the
loop:

   >>> for num in range(2, 10):
   ...     if num % 2 == 0:
   ...         print(f"Found an even number {num}")
   ...         continue
   ...     print(f"Found an odd number {num}")
   ...
   Found an even number 2
   Found an odd number 3
   Found an even number 4
   Found an odd number 5
   Found an even number 6
   Found an odd number 7
   Found an even number 8
   Found an odd number 9


4.5. "else" Clauses on Loops
============================

In a "for" or "while" loop the "break" statement may be paired with an
"else" clause.  If the loop finishes without executing the "break",
the "else" clause executes.

In a "for" loop, the "else" clause is executed after the loop finishes
its final iteration, that is, if no break occurred.

In un ciclo "while", viene eseguita dopo che la condizione del ciclo
diventa falsa.

In either kind of loop, the "else" clause is **not** executed if the
loop was terminated by a "break".  Of course, other ways of ending the
loop early, such as a "return" or a raised exception, will also skip
execution of the "else" clause.

Questo è esemplificato nel seguente ciclo "for", che cerca numeri
primi:

   >>> for n in range(2, 10):
   ...     for x in range(2, n):
   ...         if n % x == 0:
   ...             print(n, 'equals', x, '*', n//x)
   ...             break
   ...     else:
   ...         # loop fell through without finding a factor
   ...         print(n, 'is a prime number')
   ...
   2 is a prime number
   3 is a prime number
   4 equals 2 * 2
   5 is a prime number
   6 equals 2 * 3
   7 is a prime number
   8 equals 2 * 4
   9 equals 3 * 3

(Yes, this is the correct code.  Look closely: the "else" clause
belongs to the "for" loop, **not** the "if" statement.)

One way to think of the else clause is to imagine it paired with the
"if" inside the loop.  As the loop executes, it will run a sequence
like if/if/if/else. The "if" is inside the loop, encountered a number
of times. If the condition is ever true, a "break" will happen. If the
condition is never true, the "else" clause outside the loop will
execute.

When used with a loop, the "else" clause has more in common with the
"else" clause of a "try" statement than it does with that of "if"
statements: a "try" statement's "else" clause runs when no exception
occurs, and a loop's "else" clause runs when no "break" occurs. For
more on the "try" statement and exceptions, see Gestione delle
Eccezioni.


4.6. Istruzioni "pass"
======================

L'istruzione "pass" non fa nulla. Può essere utilizzata quando è
richiesta un'istruzione sintatticamente, ma il programma non richiede
alcuna azione. Per esempio:

   >>> while True:
   ...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
   ...

Questo è comunemente usato per creare classi minime:

   >>> class MyEmptyClass:
   ...     pass
   ...

Un altro posto in cui "pass" può essere usato è come segnaposto per il
corpo di una funzione o condizionale quando si sta lavorando su nuovo
codice, permettendo di continuare a pensare a un livello più astratto.
L'istruzione "pass" viene ignorata silenziosamente:

   >>> def initlog(*args):
   ...     pass   # Remember to implement this!
   ...

For this last case, many people use the ellipsis literal "..." instead
of "pass". This use has no special meaning to Python, and is not part
of the language definition (you could use any constant expression
here), but "..." is used conventionally as a placeholder body as well.
See L'Oggetto Ellipsis.


4.7. Istruzioni "match"
=======================

A "match" statement takes an expression and compares its value to
successive patterns given as one or more case blocks.  This is
superficially similar to a switch statement in C, Java or JavaScript
(and many other languages), but it's more similar to pattern matching
in languages like Rust or Haskell. Only the first pattern that matches
gets executed and it can also extract components (sequence elements or
object attributes) from the value into variables. If no case matches,
none of the branches is executed.

La forma più semplice confronta un valore con uno o più letterali:

   def http_error(status):
       match status:
           case 400:
               return "Bad request"
           case 404:
               return "Not found"
           case 418:
               return "I'm a teapot"
           case _:
               return "Something's wrong with the internet"

Note the last block: the "variable name" "_" acts as a *wildcard* and
never fails to match.

Puoi combinare diversi letterali in un singolo schema usando "|"
("or"):

   case 401 | 403 | 404:
       return "Not allowed"

Gli schemi possono sembrare assegnazioni di decomposizione e possono
essere utilizzati per associare variabili:

   # point is an (x, y) tuple
   match point:
       case (0, 0):
           print("Origin")
       case (0, y):
           print(f"Y={y}")
       case (x, 0):
           print(f"X={x}")
       case (x, y):
           print(f"X={x}, Y={y}")
       case _:
           raise ValueError("Not a point")

Studialo attentamente! Il primo schema ha due letterali, e può essere
pensato come un'estensione dello schema letterale mostrato sopra. Ma i
successivi due schemi combinano un letterale e una variabile, e la
variabile *associa* un valore dal soggetto ("point"). Il quarto schema
cattura due valori, che lo rende concettualmente simile
all'assegnazione con *unpacking* "(x, y) = point".

Se stai utilizzando classi per strutturare i tuoi dati, puoi usare il
nome della classe seguito da un elenco di argomenti che assomiglia a
un costruttore, ma con la capacità di catturare attributi in
variabili:

   class Point:
       def __init__(self, x, y):
           self.x = x
           self.y = y

   def where_is(point):
       match point:
           case Point(x=0, y=0):
               print("Origin")
           case Point(x=0, y=y):
               print(f"Y={y}")
           case Point(x=x, y=0):
               print(f"X={x}")
           case Point():
               print("Somewhere else")
           case _:
               print("Not a point")

Puoi utilizzare parametri posizionali con alcune classi integrate che
forniscono un ordinamento per i loro attributi (ad esempio le
dataclassi). Puoi anche definire una posizione specifica per gli
attributi negli schemi impostando l'attributo speciale
"__match_args__" nelle tue classi. Se è impostato su ("x", "y"), gli
schemi seguenti sono tutti equivalenti (e tutti associano l'attributo
"y" alla variabile "var"):

   Point(1, var)
   Point(1, y=var)
   Point(x=1, y=var)
   Point(y=var, x=1)

Un modo consigliato per leggere gli schemi è considerarli come una
forma estesa di quello che metteresti a sinistra di un'assegnazione,
per capire quali variabili verrebbero impostate su cosa. Solo i nomi
autonomi (come "var" qui sopra) vengono assegnati da un'istruzione di
match. I nomi puntati (come "foo.bar"), i nomi degli attributi (il
"x=" e "y=" qui sopra) o i nomi delle classi (riconosciuti dalle
"(...)" accanto a loro come "Point" qui sopra) non vengono mai
assegnati.

Gli schemi possono essere arbitrariamente nidificati. Ad esempio, se
abbiamo una breve lista di Punti, con "__match_args__" aggiunto,
potremmo abbinarla così:

   class Point:
       __match_args__ = ('x', 'y')
       def __init__(self, x, y):
           self.x = x
           self.y = y

   match points:
       case []:
           print("No points")
       case [Point(0, 0)]:
           print("The origin")
       case [Point(x, y)]:
           print(f"Single point {x}, {y}")
       case [Point(0, y1), Point(0, y2)]:
           print(f"Two on the Y axis at {y1}, {y2}")
       case _:
           print("Something else")

Possiamo aggiungere una clausola "if" a uno schema, nota come
"guardia". Se la guardia è falsa, "match" passa a provare il blocco
case successivo. Nota che la cattura del valore avviene prima che la
guardia venga valutata:

   match point:
       case Point(x, y) if x == y:
           print(f"Y=X at {x}")
       case Point(x, y):
           print(f"Not on the diagonal")

Altre caratteristiche chiave di questa istruzione:

* Come le assegnazioni di decomposizione, gli schemi di tuple e liste
  hanno esattamente lo stesso significato e corrispondono
  effettivamente a sequenze arbitrarie. Un'importante eccezione è che
  non corrispondano a iteratori o stringhe.

* Le sequenze di schemi supportano l'unpacking esteso: "[x, y, *rest]"
  e "(x, y, *rest)" funzionano in modo simile alle assegnazioni di
  decomposizione. Il nome dopo "*" può anche essere "_", quindi "(x,
  y, *_)" corrisponde a una sequenza di almeno due elementi senza la
  necessità di associare gli elementi rimanenti.

* Schemi di mapping: "{"bandwidth": b, "latency": l}" cattura i valori
  ""bandwidth"" e ""latency"" da un dizionario. A differenza degli
  schemi di sequenza, le chiavi aggiuntive vengono ignorate. È
  supportato anche un unpacking come "**rest". (Ma "**_" sarebbe
  ridondante, quindi non è possibile utilizzarlo.)

* I sotto-schemi possono essere catturati utilizzando la parola chiave
  "as":

     case (Point(x1, y1), Point(x2, y2) as p2): ...

  acquisirà il secondo elemento dell'input come "p2" (a patto che
  l'input sia una sequenza di due punti)

* La maggior parte dei letterali sono confrontati per uguaglianza,
  tuttavia i *singleton* "True", "False" e "None" sono confrontati per
  identità.

* Gli schemi possono utilizzare costanti nominate. Queste devono
  essere nomi puntati per impedire che vengano interpretati come
  variabili di cattura:

     from enum import Enum
     class Color(Enum):
         RED = 'red'
         GREEN = 'green'
         BLUE = 'blue'

     color = Color(input("Enter your choice of 'red', 'blue' or 'green': "))

     match color:
         case Color.RED:
             print("I see red!")
         case Color.GREEN:
             print("Grass is green")
         case Color.BLUE:
             print("I'm feeling the blues :(")

Per una spiegazione più dettagliata e ulteriori esempi, puoi
consultare **PEP 636** che è scritta in un formato simile a un
tutorial.


4.8. Definizione di Funzioni
============================

Possiamo creare una funzione che scrive la serie di Fibonacci fino a
un limite arbitrario:

   >>> def fib(n):    # write Fibonacci series less than n
   ...     """Print a Fibonacci series less than n."""
   ...     a, b = 0, 1
   ...     while a < n:
   ...         print(a, end=' ')
   ...         a, b = b, a+b
   ...     print()
   ...
   >>> # Now call the function we just defined:
   >>> fib(2000)
   0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

La parola chiave "def" introduce una *definizione* di funzione. Deve
essere seguita dal nome della funzione e dall'elenco tra parentesi dei
parametri formali. Le istruzioni che formano il corpo della funzione
iniziano alla riga successiva, e devono essere indentate.

La prima istruzione del corpo della funzione può opzionalmente essere
una stringa letterale; questa stringa letterale è la stringa di
documentazione della funzione, o *docstring*. (Maggiori informazioni
sulle docstring possono essere trovate nella sezione Stringhe di
Documentazione.) Ci sono strumenti che utilizzano le docstring per
produrre automaticamente documentazione online o stampata, o per
consentire all'utente di navigare interattivamente attraverso il
codice; è una buona pratica includere le docstring nel codice che
scrivi, quindi prendilo come abitudine.

L'*esecuzione* di una funzione introduce una nuova tabella dei simboli
utilizzata per le variabili locali della funzione. Più precisamente,
tutte le assegnazioni di variabili in una funzione memorizzano il
valore nella tabella dei simboli locali; mentre i riferimenti alle
variabili cercano prima nella tabella dei simboli locali, poi nelle
tabelle dei simboli locali delle funzioni circostanti, poi nella
tabella dei simboli globali, e infine nella tabella dei nomi
incorporati. Pertanto, le variabili globali e le variabili delle
funzioni circostanti non possono essere direttamente assegnate un
valore all'interno di una funzione (a meno che, per le variabili
globali, siano nominate in un'istruzione "global", o, per le variabili
delle funzioni circostanti, siano nominate in un'istruzione
"nonlocal"), anche se possono essere referenziate.

I parametri effettivi (argomenti) di una chiamata di funzione vengono
introdotti nella tabella dei simboli locali della funzione chiamata
quando viene chiamata; quindi, gli argomenti sono passati utilizzando
il *passaggio per valore* (dove il *valore* è sempre un *riferimento*
all'oggetto, non il valore dell'oggetto). [1] Quando una funzione
chiama un'altra funzione, o si chiama ricorsivamente, viene creata una
nuova tabella dei simboli locali per quella chiamata.

Una definizione di funzione associa il nome della funzione all'oggetto
funzione nella tabella dei simboli corrente. L'interprete riconosce
l'oggetto puntato da quel nome come una funzione definita dall'utente.
Altri nomi possono anche puntare a quello stesso oggetto funzione e
possono anche essere utilizzati per accedere alla funzione:

   >>> fib
   <function fib at 10042ed0>
   >>> f = fib
   >>> f(100)
   0 1 1 2 3 5 8 13 21 34 55 89

Provenendo da altri linguaggi, potresti obiettare che "fib" non è una
funzione ma una procedura poiché non restituisce un valore. Infatti,
anche le funzioni senza un'istruzione "return" restituiscono un
valore, sebbene piuttosto noioso. Questo valore si chiama "None" (è un
nome riservato del linguaggio). Scrivere il valore "None" è
normalmente soppresso dall'interprete se sarebbe l'unico valore
scritto. Puoi vederlo se lo desideri davvero utilizzando "print()":

   >>> fib(0)
   >>> print(fib(0))
   None

È semplice scrivere una funzione che restituisce una lista dei numeri
della serie di Fibonacci, invece di stamparla:

   >>> def fib2(n):  # return Fibonacci series up to n
   ...     """Return a list containing the Fibonacci series up to n."""
   ...     result = []
   ...     a, b = 0, 1
   ...     while a < n:
   ...         result.append(a)    # see below
   ...         a, b = b, a+b
   ...     return result
   ...
   >>> f100 = fib2(100)    # call it
   >>> f100                # write the result
   [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Questo esempio, come al solito, dimostra alcune nuove funzionalità di
Python:

* L'istruzione "return" restituisce un valore da una funzione.
  "return" senza un argomento espressione restituisce "None". Anche
  uscire dalla fine di una funzione restituisce "None".

* The statement "result.append(a)" calls a *method* of the list object
  "result".  A method is a function that 'belongs' to an object and is
  named "obj.methodname", where "obj" is some object (this may be an
  expression), and "methodname" is the name of a method that is
  defined by the object's type. Different types define different
  methods.  Methods of different types may have the same name without
  causing ambiguity.  (It is possible to define your own object types
  and methods, using *classes*, see Classi) The method "append()"
  shown in the example is defined for list objects; it adds a new
  element at the end of the list.  In this example it is equivalent to
  "result = result + [a]", but more efficient.


4.9. Ulteriori informazioni sulla Definizione di Funzioni
=========================================================

È anche possibile definire funzioni con un numero variabile di
argomenti. Esistono tre forme, che possono essere combinate.


4.9.1. Valori predefiniti degli argomenti
-----------------------------------------

La forma più utile è specificare un valore predefinito per uno o più
argomenti. Questo crea una funzione che può essere chiamata con meno
argomenti di quelli che è definita per consentire. Ad esempio:

   def ask_ok(prompt, retries=4, reminder='Please try again!'):
       while True:
           reply = input(prompt)
           if reply in {'y', 'ye', 'yes'}:
               return True
           if reply in {'n', 'no', 'nop', 'nope'}:
               return False
           retries = retries - 1
           if retries < 0:
               raise ValueError('invalid user response')
           print(reminder)

Questa funzione può essere chiamata in diversi modi:

* dando solo l'argomento obbligatorio: "ask_ok('Vuoi davvero
  uscire?')"

* dando uno degli argomenti opzionali: "ask_ok('OK sovrascrivere il
  file?', 2)"

* o addirittura dando tutti gli argomenti: "ask_ok('OK sovrascrivere
  il file?', 2, 'Dai su, solo sì o no!')"

Questo esempio introduce anche la parola chiave "in". Questo testa se
una sequenza contiene o meno un certo valore.

I valori predefiniti vengono valutati nel punto di definizione della
funzione nello *scope* di definizione, in modo che

   i = 5

   def f(arg=i):
       print(arg)

   i = 6
   f()

stamperà "5".

**Avvertenza importante:** Il valore predefinito viene valutato solo
una volta. Questo fa la differenza quando il valore predefinito è un
oggetto mutabile come una lista, un dizionario, o istanze della
maggior parte delle classi. Ad esempio, la seguente funzione accumula
gli argomenti passati ad essa nelle chiamate successive:

   def f(a, L=[]):
       L.append(a)
       return L

   print(f(1))
   print(f(2))
   print(f(3))

Questo stamperà

   [1]
   [1, 2]
   [1, 2, 3]

Se non vuoi che il valore predefinito sia condiviso tra le chiamate
successive, puoi scrivere la funzione in questo modo:

   def f(a, L=None):
       if L is None:
           L = []
       L.append(a)
       return L


4.9.2. Argomenti chiave-valore
------------------------------

Le funzioni possono anche essere chiamate utilizzando *argomenti
chiave-valore* della forma "kwarg=value". Ad esempio, la seguente
funzione:

   def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
       print("-- This parrot wouldn't", action, end=' ')
       print("if you put", voltage, "volts through it.")
       print("-- Lovely plumage, the", type)
       print("-- It's", state, "!")

accetta un argomento obbligatorio ("voltage") e tre argomenti
opzionali ("state", "action", e "type"). Questa funzione può essere
chiamata in uno dei seguenti modi:

   parrot(1000)                                          # 1 positional argument
   parrot(voltage=1000)                                  # 1 keyword argument
   parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
   parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
   parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
   parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

ma tutte le chiamate seguenti non sarebbero valide:

   parrot()                     # required argument missing
   parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
   parrot(110, voltage=220)     # duplicate value for the same argument
   parrot(actor='John Cleese')  # unknown keyword argument

In una chiamata di funzione, gli argomenti chiave-valore devono
seguire gli argomenti posizionali. Tutti gli argomenti chiave passati
devono corrispondere a uno degli argomenti accettati dalla funzione
(ad esempio, "actor" non è un argomento valido per la funzione
"parrot"), e il loro ordine non è importante. Questo include anche gli
argomenti non opzionali (ad esempio, "parrot(voltage=1000)" è valido).
Nessun argomento può ricevere un valore più di una volta. Ecco un
esempio che fallisce a causa di questa restrizione:

   >>> def function(a):
   ...     pass
   ...
   >>> function(0, a=0)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: function() got multiple values for argument 'a'

Quando è presente un parametro formale finale della forma "**name",
riceve un dizionario (vedi Tipi di Mapping --- dict) contenente tutti
gli argomenti chiave tranne quelli corrispondenti a un parametro
formale. Questo può essere combinato con un parametro formale della
forma "*name" (descritto nella prossima sottosezione) che riceve una
tupla contenente gli argomenti posizionali oltre all'elenco dei
parametri formali. ("*name" deve occorrere prima di "**name".) Ad
esempio, se definiamo una funzione in questo modo:

   def cheeseshop(kind, *arguments, **keywords):
       print("-- Do you have any", kind, "?")
       print("-- I'm sorry, we're all out of", kind)
       for arg in arguments:
           print(arg)
       print("-" * 40)
       for kw in keywords:
           print(kw, ":", keywords[kw])

Potrebbe essere chiamato in questo modo:

   cheeseshop("Limburger", "It's very runny, sir.",
              "It's really very, VERY runny, sir.",
              shopkeeper="Michael Palin",
              client="John Cleese",
              sketch="Cheese Shop Sketch")

e naturalmente stamperà:

   -- Do you have any Limburger ?
   -- I'm sorry, we're all out of Limburger
   It's very runny, sir.
   It's really very, VERY runny, sir.
   ----------------------------------------
   shopkeeper : Michael Palin
   client : John Cleese
   sketch : Cheese Shop Sketch

Nota che l'ordine in cui gli argomenti chiave-valore vengono stampati
è garantito corrispondere all'ordine in cui sono stati forniti nella
chiamata della funzione.


4.9.3. Parametri speciali
-------------------------

Per impostazione predefinita, gli argomenti possono essere passati a
una funzione Python sia per posizione che esplicitamente per chiave.
Per leggibilità e prestazioni, ha senso limitare il modo in cui gli
argomenti possono essere passati in modo che uno sviluppatore debba
solo guardare la definizione della funzione per determinare se gli
elementi sono passati per posizione, per posizione o per chiave, o per
chiave.

Ecco come potrebbe essere la definizione di una funzione:

   def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
         -----------    ----------     ----------
           |             |                  |
           |        Positional or keyword   |
           |                                - Keyword only
            -- Positional only

dove "/" e "*" sono opzionali. Se utilizzati, questi simboli indicano
il tipo di parametro in base a come gli argomenti possono essere
passati alla funzione: solo per posizione, per posizione o per chiave,
e solo per chiave. I parametri chiave-valore sono anche chiamati
parametri nominali.


4.9.3.1. Argomenti Posizionali o per Chiave
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Se "/" e "*" non sono presenti nella definizione della funzione, gli
argomenti possono essere passati a una funzione per posizione o per
chiave.


4.9.3.2. Parametri Solo per Posizione
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Guardando questo in modo più dettagliato, è possibile contrassegnare
certi parametri come *solo per posizione*. Se lo sono, l'ordine dei
parametri è importante, e i parametri non possono essere passati per
chiave. I parametri solo per posizione sono posizionati prima di un
"/" (barra obliqua). Il "/" è utilizzato per separare logicamente i
parametri posizionali dal resto dei parametri. Se non c'è un "/" nella
definizione della funzione, non ci sono parametri posizionali.

I parametri che seguono il "/" possono essere *posizionali o per
chiave* o *solo per chiave*.


4.9.3.3. Argomenti Solo per Chiave
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Per contrassegnare i parametri come *solo per chiave*, indicando che i
parametri devono essere passati per argomento chiave, posiziona un "*"
nell'elenco degli argomenti subito prima del primo parametro *solo per
chiave*.


4.9.3.4. Esempi di Funzioni
~~~~~~~~~~~~~~~~~~~~~~~~~~~

Considera le seguenti definizioni di funzioni di esempio prestando
particolare attenzione ai marcatori "/" e "*":

   >>> def standard_arg(arg):
   ...     print(arg)
   ...
   >>> def pos_only_arg(arg, /):
   ...     print(arg)
   ...
   >>> def kwd_only_arg(*, arg):
   ...     print(arg)
   ...
   >>> def combined_example(pos_only, /, standard, *, kwd_only):
   ...     print(pos_only, standard, kwd_only)

Nella prima definizione di funzione, "standard_arg", la forma più
familiare, non pone restrizioni sulla convenzione di chiamata e gli
argomenti possono essere passati per posizione o per chiave:

   >>> standard_arg(2)
   2

   >>> standard_arg(arg=2)
   2

La seconda funzione "pos_only_arg" è limitata a utilizzare solo
parametri posizionali poiché c'è un "/" nella definizione della
funzione:

   >>> pos_only_arg(1)
   1

   >>> pos_only_arg(arg=1)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: pos_only_arg() got some positional-only arguments passed as keyword arguments: 'arg'

The third function "kwd_only_arg" only allows keyword arguments as
indicated by a "*" in the function definition:

   >>> kwd_only_arg(3)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given

   >>> kwd_only_arg(arg=3)
   3

E l'ultimo utilizza tutte e tre le convenzioni di chiamata nella
stessa definizione di funzione:

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

   >>> combined_example(1, 2, kwd_only=3)
   1 2 3

   >>> combined_example(1, standard=2, kwd_only=3)
   1 2 3

   >>> combined_example(pos_only=1, standard=2, kwd_only=3)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: combined_example() got some positional-only arguments passed as keyword arguments: 'pos_only'

Infine, considera questa definizione di funzione che ha un potenziale
conflitto tra l'argomento posizionale "name" e "**kwds" che ha "name"
come chiave:

   def foo(name, **kwds):
       return 'name' in kwds

Non esiste una chiamata possibile che lo farà restituire "True" poiché
la chiave "'name'" si legherà sempre al primo parametro. Ad esempio:

   >>> foo(1, **{'name': 2})
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: foo() got multiple values for argument 'name'
   >>>

Ma utilizzando "/" (argomenti solo per posizione), è possibile poiché
consente "name" come argomento posizionale e "'name'" come chiave
negli argomenti chiave-valore:

   >>> def foo(name, /, **kwds):
   ...     return 'name' in kwds
   ...
   >>> foo(1, **{'name': 2})
   True

In altre parole, i nomi dei parametri solo per posizione possono
essere utilizzati in "**kwds" senza ambiguità.


4.9.3.5. Riepilogo
~~~~~~~~~~~~~~~~~~

Il caso d'uso determinerà quali parametri utilizzare nella definizione
della funzione:

   def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):

Come guida:

* Usa solo argomenti per posizione se vuoi che il nome dei parametri
  non sia disponibile per l'utente. Questo è utile quando i nomi dei
  parametri non hanno un vero significato, se vuoi imporre l'ordine
  degli argomenti quando la funzione viene chiamata o se devi prendere
  alcuni parametri posizionali e argomenti chiave arbitrari.

* Usa solo argomenti per chiave quando i nomi hanno significato e la
  definizione della funzione è più comprensibile essendo esplicita con
  i nomi o vuoi impedire agli utenti di fare affidamento sulla
  posizione dell'argomento passato.

* Per un'API, usa solo per posizione per evitare rotture delle
  modifiche API se il nome del parametro viene modificato in futuro.


4.9.4. Liste di Argomenti Arbitrarie
------------------------------------

Infine, l'opzione meno utilizzata è specificare che una funzione può
essere chiamata con un numero arbitrario di argomenti. Questi
argomenti saranno racchiusi in una tupla (vedi Tuple e Sequenze).
Prima del numero variabile di argomenti, possono verificarsi zero o
più argomenti normali.

   def write_multiple_items(file, separator, *args):
       file.write(separator.join(args))

Normalmente, questi argomenti *variadici* saranno gli ultimi
nell'elenco dei parametri formali, perché raccolgono tutti gli
argomenti di input rimanenti che vengono passati alla funzione.
Qualsiasi parametro formale che si verifica dopo il parametro "*args"
sono argomenti 'solo per chiave', il che significa che possono essere
utilizzati solo come argomenti chiave piuttosto che argomenti
posizionali.

   >>> def concat(*args, sep="/"):
   ...     return sep.join(args)
   ...
   >>> concat("earth", "mars", "venus")
   'earth/mars/venus'
   >>> concat("earth", "mars", "venus", sep=".")
   'earth.mars.venus'


4.9.5. Spacchettamento delle Liste di Argomenti
-----------------------------------------------

La situazione inversa si verifica quando gli argomenti sono già in una
lista o tupla ma devono essere spacchettati per una chiamata di
funzione che richiede argomenti posizionali separati. Ad esempio, la
funzione built-in "range()" si aspetta argomenti *start* e *stop*
separati. Se non sono disponibili separatamente, scrivi la chiamata di
funzione con l'operatore "*"per spacchettare gli argomenti da una
lista o tupla:

   >>> list(range(3, 6))            # normal call with separate arguments
   [3, 4, 5]
   >>> args = [3, 6]
   >>> list(range(*args))            # call with arguments unpacked from a list
   [3, 4, 5]

Nello stesso modo, i dizionari possono fornire argomenti chiave-valore
con l'operatore "**"::

   >>> def parrot(voltage, state='a stiff', action='voom'):
   ...     print("-- This parrot wouldn't", action, end=' ')
   ...     print("if you put", voltage, "volts through it.", end=' ')
   ...     print("E's", state, "!")
   ...
   >>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
   >>> parrot(**d)
   -- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !


4.9.6. Espressioni Lambda
-------------------------

Piccole funzioni anonime possono essere create con la parola chiave
"lambda". Questa funzione restituisce la somma dei suoi due argomenti:
"lambda a, b: a+b". Le funzioni lambda possono essere utilizzate
ovunque siano richiesti oggetti funzione. Sono sintatticamente
limitate a una singola espressione. Semanticamente, sono solo zucchero
sintattico per una normale definizione di funzione. Come le
definizioni di funzione nidificate, le funzioni lambda possono fare
riferimento a variabili dallo scope contenente:

   >>> def make_incrementor(n):
   ...     return lambda x: x + n
   ...
   >>> f = make_incrementor(42)
   >>> f(0)
   42
   >>> f(1)
   43

The above example uses a lambda expression to return a function.
Another use is to pass a small function as an argument.  For instance,
"list.sort()" takes a sorting key function *key* which can be a lambda
function:

   >>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
   >>> pairs.sort(key=lambda pair: pair[1])
   >>> pairs
   [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]


4.9.7. Stringhe di Documentazione
---------------------------------

Ecco alcune convenzioni sul contenuto e la formattazione delle
stringhe di documentazione.

La prima riga dovrebbe essere sempre un breve e conciso riassunto
dello scopo dell'oggetto. Per brevità, non dovrebbe esplicitamente
indicare il nome o il tipo dell'oggetto, poiché questi sono
disponibili in altri modi (tranne se il nome è un verbo che descrive
l'operazione di una funzione). Questa riga dovrebbe iniziare con una
lettera maiuscola e terminare con un punto.

Se ci sono più righe nella stringa di documentazione, la seconda riga
dovrebbe essere vuota, separando visivamente il riassunto dal resto
della descrizione. Le righe seguenti dovrebbero essere uno o più
paragrafi che descrivono le convenzioni di chiamata dell'oggetto, i
suoi effetti collaterali, ecc.

The Python parser strips indentation from multi-line string literals
when they serve as module, class, or function docstrings.

Di seguito è riportato un esempio di una stringa di documentazione
multilinea:

   >>> def my_function():
   ...     """Do nothing, but document it.
   ...
   ...     No, really, it doesn't do anything:
   ...
   ...         >>> my_function()
   ...         >>>
   ...     """
   ...     pass
   ...
   >>> print(my_function.__doc__)
   Do nothing, but document it.

   No, really, it doesn't do anything:

       >>> my_function()
       >>>


4.9.8. Annotationi delle Funzioni
---------------------------------

Le annotationi delle funzioni sono informazioni di metadati
completamente opzionali sui tipi utilizzati dalle funzioni definite
dall'utente (vedi **PEP 3107** e **PEP 484** per ulteriori
informazioni).

*Annotations* are stored in the "__annotations__" attribute of the
function as a dictionary and have no effect on any other part of the
function.  Parameter annotations are defined by a colon after the
parameter name, followed by an expression evaluating to the value of
the annotation.  Return annotations are defined by a literal "->",
followed by an expression, between the parameter list and the colon
denoting the end of the "def" statement.  The following example has a
required argument, an optional argument, and the return value
annotated:

   >>> def f(ham: str, eggs: str = 'eggs') -> str:
   ...     print("Annotations:", f.__annotations__)
   ...     print("Arguments:", ham, eggs)
   ...     return ham + ' and ' + eggs
   ...
   >>> f('spam')
   Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
   Arguments: spam eggs
   'spam and eggs'


4.10. Intermezzo: Stile di Codifica
===================================

Ora che stai per scrivere pezzi di Python più lunghi e complessi, è un
buon momento per parlare dello *stile di codifica*. La maggior parte
dei linguaggi può essere scritta (o più concisamente, *formattata*) in
stili diversi; alcuni sono più leggibili di altri. Rendere facile per
gli altri leggere il tuo codice è sempre una buona idea, e adottare
uno stile di codifica piacevole aiuta enormemente.

Per Python, la **PEP 8** è la guida di stile a cui aderiscono la
maggior parte dei progetti; promuove uno stile di codifica molto
leggibile e piacevole alla vista. Ogni sviluppatore Python dovrebbe
leggerla prima o poi; ecco i punti più importanti estratti per te:

* Usa l'indentazione a 4 spazi, e niente tabulazioni.

  4 spazi sono un buon compromesso tra una piccola indentazione
  (permette una maggiore profondità di nidificazione) e una grande
  indentazione (più facile da leggere). Le tabulazioni introducono
  confusione, ed è preferibile non usarle.

* Manda a capo le righe in modo che non superino i 79 caratteri.

  Questo aiuta gli utenti con schermi piccoli e rende possibile avere
  diversi file di codice affiancati su schermi più grandi.

* Usa righe vuote per separare funzioni e classi, e blocchi di codice
  più grandi all'interno delle funzioni.

* Quando possibile, metti i commenti su una riga a parte.

* Usa le stringhe di documentazione.

* Usa spazi attorno agli operatori e dopo le virgole, ma non
  direttamente all'interno dei costrutti tra parentesi: "a = f(1, 2) +
  g(3, 4)".

* Nomina le tue classi e funzioni in modo coerente; la convenzione è
  utilizzare "UpperCamelCase" per le classi e
  "lowercase_with_underscores" per le funzioni e i metodi. Usa sempre
  "self" come nome per il primo argomento del metodo (vedi Una prima
  occhiata alle classi per ulteriori informazioni su classi e metodi).

* Non utilizzare codifiche complesse se il tuo codice è destinato ad
  essere utilizzato in ambienti internazionali. Il predefinito di
  Python, UTF-8, o anche il semplice ASCII funzionano meglio in ogni
  caso.

* Allo stesso modo, non utilizzare caratteri non-ASCII negli
  identificatori se c'è solo la minima possibilità che persone che
  parlano una lingua diversa leggano o mantengano il codice.

-[ Note a piè di pagina ]-

[1] In realtà, *chiamata per riferimento all'oggetto* sarebbe una
    descrizione migliore, poiché se viene passato un oggetto mutabile,
    il chiamante vedrà qualsiasi modifica che il chiamato fa ad esso
    (elementi inseriti in una lista).
