2. Uso dell'interprete di Python
********************************


2.1. Invocazione dell'interprete
================================

The Python interpreter is usually installed as
"/usr/local/bin/python3.9" on those machines where it is available;
putting "/usr/local/bin" in your Unix shell's search path makes it
possible to start it by typing the command:

   python3.9

alla shell. [1] Poiché la scelta della cartella in cui è situato
l'interprete è un'opzione di installazione, è possibile trovarlo anche
in altri percorsi; verificate con il vostro guru Python o con
l'amministratore di sistema.  (Ad esempio, "/usr/local/python" è
un'alternativa popolare.)

On Windows machines where you have installed Python from the Microsoft
Store, the "python3.9" command will be available. If you have the
py.exe launcher installed, you can use the "py" command. See Excursus:
Setting environment variables for other ways to launch Python.

Digitando un carattere di fine file ("Control-D" su Unix, "Control-Z"
su Windows) nel prompt, l'interprete esce con stato zero.  Se non
funziona, è possibile uscire dall'interprete digitando il seguente
comando: "quit()".

The interpreter's line-editing features include interactive editing,
history substitution and code completion on systems that support the
GNU Readline library. Perhaps the quickest check to see whether
command line editing is supported is typing "Control-P" to the first
Python prompt you get.  If it beeps, you have command line editing;
see Appendix Interactive Input Editing and History Substitution for an
introduction to the keys.  If nothing appears to happen, or if "^P" is
echoed, command line editing isn't available; you'll only be able to
use backspace to remove characters from the current line.

L'interprete opera in maniera simile alla shell Unix: quando viene
chiamato con lo *standard input* collegato ad un dispositivo tty,
legge ed esegue i comandi in modo interattivo; quando viene chiamato
con un nome di file come argomento o con un file come *standard
input*, legge ed esegue un *script* da quel file.

Un secondo modo di iniziare l'interprete è "python -c command [arg]
...", che esegue le istruzioni in *command*, analogamente all'opzione
"-c".  Poiché le istruzioni di Python spesso contengono spazi o altri
caratteri speciali per la shell, di solito si consiglia di racchiudere
*command*, nella sua interezza, con apici singoli.

Alcuni moduli Python sono utili anche come script.  Questi possono
essere invocati usando "python -m module [arg] ...", che esegue il
file sorgente del *modulo* come se tu avessi scritto il suo nome
completo sulla riga di comando.

Quando si utilizza un file di script, a volte è utile essere in grado
di eseguire lo script ed entrare in modalità interattiva in seguito.
Questo può essere fatto passando "-i" prima dello script.

Tutte le opzioni della riga di comando sono descritte in Command line
and environment.


2.1.1. Passare Argomenti
------------------------

Una volta resi noti all'interprete, il nome dello script e gli
argomenti aggiuntivi vengono poi trasformati in una lista di stringhe
e assegnati alla variabile "argv" nel modulo "sys".  È possibile
accedere a questa lista eseguendo "importa sys".  La lunghezza della
lista è almeno una; quando non viene dato alcuno script e nessun
argomento, "sys.argv[0]" è una stringa vuota.  Quando il nome dello
script è dato come "'-'" (che significa ingresso standard),
"sys.argv[0]" è settato a "’-‘". Quando è usato il *comando* "-c",
"sys.argv[0]" viene settato a "’-c’".  Quando viene usato il *modulo*
"-m", "sys.argv[0]"  viene impostato con il nome completo del modulo.
Tutte le opzioni trovate dopo i comandi "-c" o i moduli "-m" non
vengono consumati dell’interprete di Python che processa le opzioni,
ma vengono lasciate in "sys.argv" in modo che vengano poi gestite
manualmente dal comando o dal modulo.


2.1.2. Modalità Interattiva
---------------------------

Quando i comandi vengono letti da una tty, l'interprete è detto essere
in *modo interattivo*.  In questa modalità richiede il comando
successivo con il *prompt*, di solito tre simboli di *maggiore di*
(">>>"); per le linee di continuazione viene emesso un *prompt*
secondario, che per impostazione predefinita consiste di tre punti
("..."). L'interprete stampa un messaggio di benvenuto indicando il
numero di versione e un avviso di copyright prima di stampare il
*prompt*:

   $ python3.9
   Python 3.9 (default, June 4 2019, 09:25:04)
   [GCC 4.8.2] on linux
   Type "help", "copyright", "credits" or "license" for more information.
   >>>

Le linee di continuazione sono necessarie quando si inserisce un
costrutto su più linee. Come esempio, date un'occhiata a questa
dichiarazione "if":

   >>> the_world_is_flat = True
   >>> if the_world_is_flat:
   ...     print("Be careful not to fall off!")
   ...
   Be careful not to fall off!

Per ulteriori informazioni sulla modalità interattiva, vedere
Interactive Mode.


2.2. L'interprete e il suo ambiente
===================================


2.2.1. Codifica del codice sorgente
-----------------------------------

Per impostazione predefinita, i file sorgente di Python sono trattati
come codificati in UTF-8.  In questa codifica, i caratteri della
maggior parte delle lingue del mondo possono essere usati
simultaneamente in stringhe, variabili e commenti --- la libreria
standard tuttavia usa solo caratteri ASCII per le variabili, una
convenzione che ogni codice portatile dovrebbe seguire.  Per
visualizzare correttamente tutti questi caratteri, l'editor deve
riconoscere che il file è UTF-8, e deve utilizzare un font che
supporti tutti i caratteri del file.

Per dichiarare una codifica diversa da quella predefinita, è
necessario aggiungere un commento speciale come *prima* riga del file.
La sintassi è la seguente:

   # -*- coding: encoding -*-

dove *codifica* è uno dei "codecs" validi supportati da Python.

Per esempio, per dichiarare che deve essere usata la codifica
Windows-1252, la prima riga del file del codice sorgente dovrebbe
essere:

   # -*- coding: cp1252 -*-

Un'eccezione alla regola della *prima linea* è quando il codice
sorgente inizia con una linea UNIX “shebang” line. In questo caso, la
dichiarazione della codifica dovrebbe essere aggiunta come seconda
riga del file.  Per esempio:

   #!/usr/bin/env python3
   # -*- coding: cp1252 -*-

-[ Note ]-

[1] Su Unix, l'interprete Python 3.x non è installato di default con
    l'eseguibile chiamato "python", in modo che non sia in conflitto
    con un eseguibile Python 2.x installato contemporaneamente.
