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


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

L'interprete Python è solitamente installato come
"/usr/local/bin/python3.16" su quelle macchine dove è disponibile;
aggiungere "/usr/local/bin" al path di ricerca della vostra shell Unix
rende possibile avviarlo digitando il comando:

   python3.16

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.)

Sulle macchine Windows dove hai installato Python dallo Microsoft
Store, il comando "python3.16" sarà disponibile. Se hai installato il
py.exe launcher, puoi utilizzare il comando "py". Consulta Python
install manager per altri modi di avviare 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 most systems. Perhaps the
quickest check to see whether command line editing is supported is
typing a word in on the Python prompt, then pressing Left arrow (or
"Control"-"b"). If the cursor moves, you have command line editing;
see Appendix Editing dell'input interattivo e sostituzione della
history for an introduction to the keys. If nothing appears to happen,
or if a sequence like "^[[D" or "^B" appears, 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.16
   Python 3.16 (default, May 7 2026, 19:03:04)
   [GCC 10.2.0] 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 Modalità
Interattiva.


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.
