7. Input e Output
*****************

Ci sono diversi modi per presentare l'output di un programma; i dati
possono essere stampati in una forma leggibile dall'uomo o scritti in
un file per un uso futuro. Questo capitolo discuterà alcune delle
possibilità.


7.1. Formattazione Avanzata dell'Output
=======================================

Finora abbiamo incontrato due modi di scrivere valori: *espressioni* e
la funzione "print()". (Un terzo modo è utilizzare il metodo "write()"
degli oggetti file; il file di output standard può essere referenziato
come "sys.stdout". Vedi la Libreria di Riferimento per ulteriori
informazioni a riguardo.)

Spesso desidererai avere più controllo sulla formattazione del tuo
output rispetto al semplice stampare valori separati da spazi. Ci sono
diversi modi per formattare l'output.

* Per usare formatted string literals, inizia una stringa con "f" o
  "F" prima del segno di apertura della virgoletta o della tripla
  virgoletta. Dentro questa stringa, puoi scrivere un'espressione
  Python tra i caratteri "{" e "}", che possono riferirsi a variabili
  o valori letterali.

     >>> year = 2016
     >>> event = 'Referendum'
     >>> f'Results of the {year} {event}'
     'Results of the 2016 Referendum'

* Il metodo "str.format()" delle stringhe richiede più sforzo manuale.
  Utilizzerai comunque "{" e "}" per indicare dove una variabile sarà
  sostituita e potrai fornire direttive di formattazione dettagliate,
  ma dovrai anche fornire le informazioni da formattare. Nel blocco di
  codice seguente ci sono due esempi di come formattare variabili:

     >>> yes_votes = 42_572_654
     >>> total_votes = 85_705_149
     >>> percentage = yes_votes / total_votes
     >>> '{:-9} YES votes  {:2.2%}'.format(yes_votes, percentage)
     ' 42572654 YES votes  49.67%'

  Nota come i "yes_votes" sono riempiti con spazi e con un segno
  negativo solo per i numeri negativi. L'esempio stampa anche
  "percentage" moltiplicato per 100, con 2 cifre decimali e seguito da
  un segno di percentuale (vedi Format Specification Mini-Language per
  i dettagli).

* Infine, puoi gestire tutte le stringhe da solo usando operazioni di
  slicing e concatenazione per creare qualsiasi layout tu possa
  immaginare. Il tipo stringa ha alcuni metodi che eseguono operazioni
  utili per riempire le stringhe a una determinata larghezza di
  colonna.

Quando non hai bisogno di un output sofisticato ma vuoi solo una
rapida visualizzazione di alcune variabili per scopi di debug, puoi
convertire qualsiasi valore in una stringa con le funzioni "repr()" o
"str()".

La funzione "str()" è pensata per restituire rappresentazioni di
valori che siano abbastanza leggibili, mentre "repr()" è pensata per
generare rappresentazioni che possono essere lette dall'interprete (o
genererà una "SyntaxError" se non esiste una sintassi equivalente).
Per oggetti che non hanno una particolare rappresentazione per il
consumo umano, "str()" restituirà lo stesso valore di "repr()". Molti
valori, come i numeri o strutture come liste e dizionari, hanno la
stessa rappresentazione usando entrambe le funzioni. Le stringhe, in
particolare, hanno due rappresentazioni distinte.

Alcuni esempi:

   >>> s = 'Hello, world.'
   >>> str(s)
   'Hello, world.'
   >>> repr(s)
   "'Hello, world.'"
   >>> str(1/7)
   '0.14285714285714285'
   >>> x = 10 * 3.25
   >>> y = 200 * 200
   >>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
   >>> print(s)
   The value of x is 32.5, and y is 40000...
   >>> # The repr() of a string adds string quotes and backslashes:
   >>> hello = 'hello, world\n'
   >>> hellos = repr(hello)
   >>> print(hellos)
   'hello, world\n'
   >>> # The argument to repr() may be any Python object:
   >>> repr((x, y, ('spam', 'eggs')))
   "(32.5, 40000, ('spam', 'eggs'))"

The "string" module contains support for a simple templating approach
based upon regular expressions, via "string.Template". This offers yet
another way to substitute values into strings, using placeholders like
"$x" and replacing them with values from a dictionary. This syntax is
easy to use, although it offers much less control for formatting.


7.1.1. Stringhe Formattate Letterali
------------------------------------

Formatted string literals (anche dette f-strings per brevità) ti
permettono di includere il valore di espressioni Python all'interno di
una stringa, prefissando la stringa con "f" o "F" e scrivendo
espressioni come "{expression}".

Uno specificatore di formato opzionale può seguire l'espressione.
Questo permette un maggiore controllo su come il valore viene
formattato. Il seguente esempio arrotonda pi a tre cifre decimali:

   >>> import math
   >>> print(f'The value of pi is approximately {math.pi:.3f}.')
   The value of pi is approximately 3.142.

Passare un intero dopo "':'" farà sì che quel campo abbia una
larghezza minima di un certo numero di caratteri. Questo è utile per
allineare le colonne.

   >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
   >>> for name, phone in table.items():
   ...     print(f'{name:10} ==> {phone:10d}')
   ...
   Sjoerd     ==>       4127
   Jack       ==>       4098
   Dcab       ==>       7678

Possono essere usati altri modificatori per convertire il valore prima
che venga formattato. "'!a'" applica "ascii()", "'!s'" applica
"str()", e "'!r'" applica "repr()":

   >>> animals = 'eels'
   >>> print(f'My hovercraft is full of {animals}.')
   My hovercraft is full of eels.
   >>> print(f'My hovercraft is full of {animals!r}.')
   My hovercraft is full of 'eels'.

Lo specificatore "=" può essere usato per espandere un'espressione al
testo dell'espressione, un segno di uguale e poi la rappresentazione
dell'espressione valutata:

>>> bugs = 'roaches'
>>> count = 13
>>> area = 'living room'
>>> print(f'Debugging {bugs=} {count=} {area=}')
Debugging bugs='roaches' count=13 area='living room'

Vedi self-documenting expressions per maggiori informazioni sullo
specificatore "=". Per un riferimento su queste specifiche di formato,
consulta la guida di riferimento per Format Specification Mini-
Language.


7.1.2. Il Metodo String format()
--------------------------------

L'uso di base del metodo "str.format()" sembra così:

   >>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
   We are the knights who say "Ni!"

Le parentesi e i caratteri al loro interno (chiamati campi di formato)
sono sostituiti dagli oggetti passati nel metodo "str.format()". Un
numero nelle parentesi può essere usato per riferirsi alla posizione
dell'oggetto passato nel metodo "str.format()".

   >>> print('{0} and {1}'.format('spam', 'eggs'))
   spam and eggs
   >>> print('{1} and {0}'.format('spam', 'eggs'))
   eggs and spam

Se vengono utilizzati argomenti keyword nel metodo "str.format()", i
loro valori vengono referenziati usando il nome dell'argomento.

   >>> print('This {food} is {adjective}.'.format(
   ...       food='spam', adjective='absolutely horrible'))
   This spam is absolutely horrible.

Gli argomenti posizionali e keyword possono essere combinati
arbitrariamente:

   >>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
   ...                                                    other='Georg'))
   The story of Bill, Manfred, and Georg.

Se hai una stringa di formato molto lunga che non vuoi dividere,
sarebbe utile poter riferire le variabili da formattare per nome
invece che per posizione. Questo può essere fatto semplicemente
passando il dizionario e usando le parentesi quadre "'[]'" per
accedere alle chiavi.

   >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
   >>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
   ...       'Dcab: {0[Dcab]:d}'.format(table))
   Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Questo può essere fatto anche passando il dizionario "table" come
argomenti keyword usando la notazione "**".

   >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
   >>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
   Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Questo è particolarmente utile in combinazione con la funzione built-
in "vars()", che restituisce un dizionario contenente tutte le
variabili locali:

   >>> table = {k: str(v) for k, v in vars().items()}
   >>> message = " ".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])
   >>> print(message.format(**table))
   __name__: __main__; __doc__: None; __package__: None; __loader__: ...

Ad esempio, le seguenti righe producono un insieme di colonne
ordinatamente allineate che danno interi e loro quadrati e cubi:

   >>> for x in range(1, 11):
   ...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
   ...
    1   1    1
    2   4    8
    3   9   27
    4  16   64
    5  25  125
    6  36  216
    7  49  343
    8  64  512
    9  81  729
   10 100 1000

Per una panoramica completa della formattazione delle stringhe con
"str.format()", vedi Format String Syntax.


7.1.3. Formattazione Manuale delle Stringhe
-------------------------------------------

Ecco la stessa tabella di quadrati e cubi, formattata manualmente:

   >>> for x in range(1, 11):
   ...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
   ...     # Note use of 'end' on previous line
   ...     print(repr(x*x*x).rjust(4))
   ...
    1   1    1
    2   4    8
    3   9   27
    4  16   64
    5  25  125
    6  36  216
    7  49  343
    8  64  512
    9  81  729
   10 100 1000

(Nota che l'unico spazio tra ogni colonna è stato aggiunto dal modo in
cui funziona "print()": aggiunge sempre spazi tra i suoi argomenti.)

Il metodo "str.rjust()" degli oggetti stringa giustifica a destra una
stringa in un campo di una data larghezza riempiendola con spazi sulla
sinistra. Esistono metodi simili "str.ljust()" e "str.center()".
Questi metodi non scrivono nulla, restituiranno solo una nuova
stringa. Se la stringa di input è troppo lunga, non viene troncata, ma
restituita invariata; questo comprometterà l'allineamento delle
colonne ma di solito è meglio dell'alternativa, che sarebbe mentire su
un valore. (Se desideri davvero la troncatura, puoi sempre aggiungere
un'operazione di slicing, come in "x.ljust(n)[:n]".)

C'è un altro metodo, "str.zfill()", che riempie una stringa numerica a
sinistra con zeri. Comprende i segni più e meno:

   >>> '12'.zfill(5)
   '00012'
   >>> '-3.14'.zfill(7)
   '-003.14'
   >>> '3.14159265359'.zfill(5)
   '3.14159265359'


7.1.4. Vecchia formattazione delle stringhe
-------------------------------------------

The % operator (modulo) can also be used for string formatting. Given
"format % values" (where *format* is a string), "%" conversion
specifications in *format* are replaced with zero or more elements of
*values*. This operation is commonly known as string interpolation.
For example:

   >>> import math
   >>> print('The value of pi is approximately %5.3f.' % math.pi)
   The value of pi is approximately 3.142.

Maggiori informazioni possono essere trovate nella sezione
Formattazione delle stringhe in stile printf.


7.2. Lettura e Scrittura di File
================================

"open()" restituisce un *file object*, ed è più comunemente usato con
due argomenti posizionali e uno keyword: "open(filename, mode,
encoding=None)"

   >>> f = open('workfile', 'w', encoding="utf-8")

Il primo argomento è una stringa che contiene il nome del file. Il
secondo argomento è un'altra stringa che contiene alcuni caratteri che
descrivono il modo in cui il file verrà utilizzato. *mode* può essere
"'r'" quando il file verrà solo letto, "'w'" per solo scrivere (un
file esistente con lo stesso nome verrà cancellato), e "'a'" apre il
file per l'aggiunta dati; qualsiasi dato scritto nel file viene
automaticamente aggiunto alla fine. "'r+'" apre il file per sia
lettura che scrittura. L'argomento *mode* è opzionale; "'r'" sarà
assunto se omesso.

Normalmente, i file vengono aperti in *text mode*, ciò significa che
leggi e scrivi stringhe dal e nel file, che sono codificate in una
specifica *encoding*. Se *encoding* non è specificato, il valore
predefinito dipende dal sistema (vedi "open()"). Poiché UTF-8 è lo
standard de facto moderno, "encoding="utf-8"" è raccomandato a meno
che non si sappia che è necessario utilizzare una diversa codifica.
Aggiungendo una "'b'" al mode, si apre il file in *binary mode*. I
dati in modalità binaria sono letti e scritti come oggetti "bytes".
Non puoi specificare *encoding* quando apri file in modalità binaria.

In modalità testo, il valore predefinito durante la lettura è
convertire i terminatori di riga specifici della piattaforma ("\n" su
Unix, "\r\n" su Windows) in solo "\n". Quando si scrive in modalità
testo, il valore predefinito è convertire le occorrenze di "\n" nei
terminatori specifici della piattaforma. Questa modifica dietro le
quinte ai dati del file va bene per i file di testo, ma corromperà i
dati binari come quelli nei file "JPEG" o "EXE". Fai molta attenzione
a usare modalità binaria quando leggi e scrivi tali file.

È buona pratica usare la keyword "with" quando si lavora con oggetti
file. Il vantaggio è che il file viene chiuso correttamente dopo che
la sua suite finisce, anche se viene generata un'eccezione a un certo
punto. Usare "with" è anche molto più breve che scrivere blocchi
equivalenti "try"-"finally":

   >>> with open('workfile', encoding="utf-8") as f:
   ...     read_data = f.read()

   >>> # We can check that the file has been automatically closed.
   >>> f.closed
   True

Se non stai usando la keyword "with", allora dovresti chiamare
"f.close()" per chiudere il file e liberare immediatamente qualsiasi
risorsa di sistema utilizzata da esso.

Avvertimento:

  Chiamare "f.write()" senza usare la keyword "with" o chiamare
  "f.close()" **potrebbe** risultare nel fatto che gli argomenti di
  "f.write()" non vengano completamente scritti sul disco, anche se il
  programma termina con successo.

Dopo che un oggetto file è stato chiuso, sia tramite un'istruzione
"with", sia chiamando "f.close()", i tentativi di utilizzare l'oggetto
file falliranno automaticamente.

   >>> f.close()
   >>> f.read()
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   ValueError: I/O operation on closed file.


7.2.1. Metodi degli Oggetti File
--------------------------------

Gli altri esempi in questa sezione assumeranno che un oggetto file
chiamato "f" sia già stato creato.

Per leggere i contenuti di un file, chiama "f.read(size)", che legge
una certa quantità di dati e li restituisce come una stringa (in
modalità testo) o un oggetto bytes (in modalità binaria). *size* è un
argomento numerico opzionale. Quando *size* è omesso o negativo,
verranno letti e restituiti tutti i contenuti del file; è un tuo
problema se il file è due volte più grande della memoria del tuo
computer. Altrimenti, al massimo *size* caratteri (in modalità testo)
o *size* byte (in modalità binaria) vengono letti e restituiti. Se la
fine del file è stata raggiunta, "f.read()" restituirà una stringa
vuota ("''").

   >>> f.read()
   'This is the entire file.\n'
   >>> f.read()
   ''

"f.readline()" legge una singola riga dal file; un carattere di
newline ("\n") viene lasciato alla fine della stringa e viene omesso
solo sull'ultima riga del file se il file non termina con un newline.
Questo rende il valore di ritorno non ambiguo; se "f.readline()"
restituisce una stringa vuota, la fine del file è stata raggiunta,
mentre una linea vuota è rappresentata da "'\n'", una stringa
contenente solo un newline.

   >>> f.readline()
   'This is the first line of the file.\n'
   >>> f.readline()
   'Second line of the file\n'
   >>> f.readline()
   ''

Per leggere le righe da un file, puoi iterare sull'oggetto file.
Questo è efficiente in termini di memoria, veloce e porta a un codice
semplice:

   >>> for line in f:
   ...     print(line, end='')
   ...
   This is the first line of the file.
   Second line of the file

Se vuoi leggere tutte le righe di un file in una lista puoi anche
usare "list(f)" o "f.readlines()".

"f.write(string)" scrive i contenuti di *string* nel file, restituendo
il numero di caratteri scritti.

   >>> f.write('This is a test\n')
   15

Altri tipi di oggetti devono essere convertiti -- o in una stringa (in
modalità testo) o in un oggetto bytes (in modalità binaria) -- prima
di scriverli:

   >>> value = ('the answer', 42)
   >>> s = str(value)  # convert the tuple to string
   >>> f.write(s)
   18

"f.tell()" restituisce un intero che indica la posizione corrente
dell'oggetto file nel file, rappresentata come numero di byte
dall'inizio del file quando in modalità binaria e un numero opaco
quando in modalità testo.

Per cambiare la posizione dell'oggetto file, usa "f.seek(offset,
whence)". La posizione è calcolata sommando *offset* a un punto di
riferimento; il punto di riferimento è selezionato dall'argomento
*whence*. Un valore *whence* di 0 misura dall'inizio del file, 1 usa
la posizione corrente del file, e 2 usa la fine del file come punto di
riferimento. *whence* può essere omesso e predefinito a 0, utilizzando
l'inizio del file come punto di riferimento.

   >>> f = open('workfile', 'rb+')
   >>> f.write(b'0123456789abcdef')
   16
   >>> f.seek(5)      # Go to the 6th byte in the file
   5
   >>> f.read(1)
   b'5'
   >>> f.seek(-3, 2)  # Go to the 3rd byte before the end
   13
   >>> f.read(1)
   b'd'

Nei file di testo (quelli aperti senza una "b" nella stringa di
modalità), sono consentiti solo i seek relativi all'inizio del file
(con l'eccezione del seek alla fine del file con "seek(0, 2)") e gli
unici valori *offset* validi sono quelli restituiti da "f.tell()", o
zero. Qualsiasi altro valore *offset* produce un comportamento non
definito.

Gli oggetti file hanno alcuni metodi aggiuntivi, come "isatty()" e
"truncate()" che sono meno frequentemente usati; consulta la Libreria
di Riferimento per una guida completa agli oggetti file.


7.2.2. Salvare dati strutturati con "json"
------------------------------------------

Le stringhe possono essere facilmente scritte su e lette da un file. I
numeri richiedono un po' più di sforzo, poiché il metodo "read()"
restituisce solo stringhe, che dovranno essere passate a una funzione
come "int()", che prende una stringa come "'123'" e restituisce il suo
valore numerico 123. Quando vuoi salvare tipi di dati più complessi
come liste annidate e dizionari, il parsing e la serializzazione
manuale diventano complicati.

Piuttosto che avere utenti che scrivono e fanno debug costantemente di
codice per salvare tipi di dati complicati nei file, Python ti
permette di usare il popolare formato di interscambio dati chiamato
JSON (JavaScript Object Notation). Il modulo standard chiamato "json"
può prendere gerarchie di dati Python e convertirle in
rappresentazioni di stringhe; questo processo è chiamato
*serializzazione*. Ricostruire i dati dalla rappresentazione di
stringa è chiamato *deserializzazione*. Tra la serializzazione e la
deserializzazione, la stringa che rappresenta l'oggetto può essere
stata memorizzata in un file o dato, o inviata su una connessione di
rete a una macchina lontana.

Nota:

  Il formato JSON è comunemente usato dalle applicazioni moderne per
  permettere lo scambio di dati. Molti programmatori sono già
  familiari con esso, il che lo rende una buona scelta per
  l'interoperabilità.

Se hai un oggetto "x", puoi visualizzare la sua rappresentazione JSON
della stringa con una semplice riga di codice:

   >>> import json
   >>> x = [1, 'simple', 'list']
   >>> json.dumps(x)
   '[1, "simple", "list"]'

Un'altra variante della funzione "dumps()", chiamata "dump()",
semplicemente serializza l'oggetto in un oggetto *text file*. Quindi
se "f" è un oggetto *text file* aperto per la scrittura, possiamo fare
questo:

   json.dump(x, f)

Per decodificare l'oggetto di nuovo, se "f" è un oggetto *binary file*
o *text file* che è stato aperto per la lettura:

   x = json.load(f)

Nota:

  I file JSON devono essere codificati in UTF-8. Usa
  "encoding="utf-8"" quando apri il file JSON come *text file* sia per
  la lettura che per la scrittura.

Questa semplice tecnica di serializzazione può gestire liste e
dizionari, ma serializzare istanze di classi arbitrari in JSON
richiede un po' di sforzo extra. Il riferimento per il modulo "json"
contiene una spiegazione di questo.

Vedi anche:

  "pickle" - il modulo pickle

  Contrariamente a JSON, *pickle* è un protocollo che permette la
  serializzazione di oggetti Python arbitrariamente complessi. Come
  tale, è specifico per Python e non può essere usato
