Il tutorial de Python, prima parte: come usare l'interprete Python.

Python è un linguaggio di programmazione potente e di facile apprendimento. Utilizza efficienti strutture dati di alto livello e un semplice ma efficace approccio alla programmazione orientata agli oggetti. 

L'elegante sintassi di Python e la tipizzazione dinamica, unite alla sua natura di linguaggio interpretato, lo rendono ideale per lo scripting e lo sviluppo rapido di applicazioni in molte aree diverse e sulla maggior parte delle piattaforme. 

L'interprete Python e l'ampia libreria standard sono liberamente disponibili, in file sorgenti o binari, per tutte le principali piattaforme sul sito web di Python,  e possono essere liberamente distribuiti. Lo stesso sito contiene anche, oltre alle distribuzioni, puntatori a molti moduli Python liberi e gratuiti di terzi, interi programmi, strumenti di sviluppo e documentazione addizionale. 

L'interprete Python è facilmente estendibile con nuove funzioni o tipi di dato implementati in C o C++ (o altri linguaggi richiamabili dal C). Python è anche adatto come linguaggio di estensione per applicazioni personalizzabili. 

Questo tutorial introduce informalmente il lettore ai concetti e alle caratteristiche base del linguaggio e del sistema Python. È di aiuto avere un interprete Python a portata di mano per fare esperienza diretta, ma tutti gli esempi sono autoesplicativi, quindi il tutorial può essere letto anche a elaboratore spento.

Questo tutorial non si propone di essere onnicomprensivo e di coprire ogni singola funzionalità o anche solo quelle più comunemente usate. Vuole essere piuttosto un'introduzione alle caratteristiche più notevoli di Python e fornire un'idea precisa dello stile del linguaggio. 

• Usare l'interprete Python.
• Invocare l'interprete.

L'interprete Python sulle macchine Unix sulle quali è disponibile di solito è installato in /usr/local/bin/; aggiungendo /usr/local/bin al percorso di ricerca della shell è possibile farlo partire digitando il comando:

python

dalla shell. Dato che la directory in cui collocare l'interprete può essere scelta al momento dell'installazione, è possibile collocarlo altrove; in caso si consulti il proprio guru Python locale o l'amministratore di sistema (per esempio, /usr/local/python è un'alternativa diffusa).

 Digitare un carattere di EOF (Control-D su Unix, Control-Z su Windows) al prompt primario fa sì che l'interprete esca con uno status pari a zero. Se non funziona, si può uscire digitando i seguenti comandi: "import sys; sys.exit()".
Le funzioni di editing di riga dell'interprete di solito non sono molto sofisticate. Su Unix, chiunque abbia installato l'interprete può avere abilitato il supporto per la libreria GNU readline, che aggiunge funzionalità di storico e di editing interattivo più avanzate. Forse il modo più rapido di controllare se sia supportato l'editing della riga di comando è di digitare Control-P al primo prompt Python che si riceve. 
 
L'interprete opera all'incirca come una shell Unix: quando viene lanciato con lo standard input connesso ad un terminale legge ed esegue interattivamente dei comandi; quando viene invocato con il nome di un file come argomento o con un file come standard input legge ed esegue uno script da quel file.
Un secondo modo di lanciare l'interprete è tramite "python -c comando [arg] ...", che esegue la/e istruzione/i contenuta/e in comando, analogamente a quanto succede per l'opzione -c della shell. Dato che spesso le istruzioni Python contengono spazi o altri caratteri che la shell considera speciali, è molto meglio racchiudere integralmente comando tra doppie virgolette.

 Si noti che c'è una differenza tra "python file" e "python < file". Nel secondo caso le richieste di input del programma, ad esempio chiamate ad input() e raw_input(), vengono soddisfatte da file. Dato che questo file è già stato letto fino alla fine dall'analizzatore sintattico ('parser') prima che il programma venga effettivamente eseguito, il programma si imbatterà immediatamente in EOF. Nel primo caso (che di solito è quello più utile) le richieste vengono soddisfatte da qualunque file o dispositivo sia connesso allo standard input dell'interprete Python.

 Quando si usa un file di script, talvolta è utile poter lanciare lo script e successivamente entrare in modalità interattiva. Lo si può ottenere passando l'opzione -i prima dello script. Non funziona se lo script viene letto dallo standard input, per lo stesso motivo illustrato nel paragrafo precedente.

Passaggio di argomenti.

Quando noti all'interprete, il nome dello script e gli argomenti addizionali sono passati allo script tramite la variabile sys.argv, che è una lista di stringhe. La sua lunghezza minima è uno; quando non vengono forniti né script né argomenti, sys.argv[0] è una stringa vuota. Quando il nome dello script è fornito come '-' (che identifica lo standard input), sys.argv[0] viene impostato a '-'. Allorché viene usato -c comando, sys.argv[0] viene impostato a -c. Le opzioni trovate dopo -c comando non vengono consumate nell'elaborazione delle opzioni da parte dell'interprete Python, ma lasciate in sys.argv per essere gestite dal comando.

Modo interattivo.

Quando i comandi vengono letti da un terminale, si dice che l'interprete è in modalità interattiva. In questa modalità esso presenta, in attesa del prossimo comando, un prompt primario, composto di solito da tre segni consecutivi di maggiore (">>> "); per le righe di continuazione il prompt predefinito è quello secondario, tre punti consecutivi ("... "). L'interprete stampa a video un messaggio di benvenuto in cui compare il numero di versione e un avviso di copyright prima del prompt iniziale, p.e.:

python
Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06)  [GCC 2.8.1] on sunos5
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>>

Le righe di continuazione sono necessarie quando si introduce un costrutto multiriga. Come esempio si prenda questo blocco if:

>>> il_mondo_è_piatto = 1
>>> if il_mondo_è_piatto:
...     print "Occhio a non caderne fuori!"
... 

L'Interprete e il suo ambiente.

  

Gestione degli errori.

Quando sopravviene un errore, l'interprete stampa un messaggio di errore e una traccia dello stack. Se si trova in modalità interattiva ritorna poi al prompt primario; se l'input proveniva da un file, esce con uno stato diverso da zero dopo aver stampato la traccia dello stack. Eccezioni gestite da una clausola except in un'istruzione try non sono errori in questo contesto. Alcuni errori sono incondizionatamente fatali e provocano un'uscita con uno stato diverso da zero; ciò accade quando si tratta di problemi interni dell'interprete e di alcuni casi di esaurimento della memoria. Tutti i messaggi di errore vengono scritti nel flusso dello standard error; l'output normale dei comandi eseguiti viene scritto sullo standard output.
Digitando il carattere di interruzione (di solito Ctrl-C o CANC) al prompt primario o secondario si cancella l'input e si ritorna al prompt primario.Digitando un'interruzione mentre un comando è in esecuzione viene sollevata un'eccezione KeyboardInterrupt, che può essere gestita tramite un'istruzione try.

Script Python eseguibili.

Sui sistemi Unix in stile BSD, gli script Python possono essere resi direttamente eseguibili, come per gli script di shell, ponendo all'inizio dello script la riga

#! /usr/bin/env python

(dato per scontato che l'interprete si trovi nel PATH dell'utente) e dando al file il permesso di esecuzione. I caratteri "#!" devono essere i primi due del file. Su qualche piattaforma, questa prima riga terminerà in stile Unix ("\n"), non in Mac OS ("\r") o in Windows ("\r\n"). Si noti che il carattere hash "#" (NdT: in italiano cancelletto, diesis) viene usato in Python per iniziare un commento).
Lo script può essere reso eseguibile, modificandone i permessi, usando il comando chmod:

$ chmod +x myscript.py

Codifica dei file sorgenti.


È possibile usare una codifica differente dall'ASCII nei file sorgenti Python. La strada maestra consiste nell'inserire una speciale riga di commento che definisca la codifica del file sorgente, appena dopo la riga che inizia con #!:

# -*- coding: iso-8859-1 -*-

-->
Con questa dichiarazione, tutti i caratteri nel sorgente verranno elaborati come iso-8859-1 e sarà possibile scrivere direttamente stringhe costanti Unicode (NdT: string literals --> stringhe costanti manifeste, abbreviato con stringhe costanti. Nei testi di teoria informatica ``costanti manifeste'' è la normale espressione italiana dove in quelli in inglese si trova ``literals'') nella codifica selezionata.

Se si usa un editor che supporta il salvataggio dei file in UTF-8, con l'indicazione UTF-8 byte order mark (ovvero BOM), è possibile usare questo sistema al posto della dichiarazione. IDLE supporta questa caratteristica se è stato impostato Options/General/Default Source Encoding/UTF-8. Da notare che questa indicazione non è ammessa in vecchie versioni di Python (2.2 e precedenti) e anche che non è consentita dal sistema operativo per i file #!.

Usando l'UTF-8 (con il metodo dell'indicazione o quello della dichiarazione della codifica), si potranno usare simultaneamente caratteri di molte delle lingue usate nel mondo in stringhe costanti o commenti. Non sono supportati i caratteri non-ASCIInegli identificatori. Per poter visualizzare correttamente tutti questi caratteri, si dovrà usare un editor in grado di riconoscere file UTF-8 e utilizzare font che sappiano rappresentare correttamente i caratteri presenti nel file.

Il file di avvio in modalità interattiva.
Quando si usa Python interattivamente, risulta spesso comodo che alcuni comandi standard vengano eseguiti ad ogni lancio dell'interprete. È possibile farlo configurando appositamente una variabile d'ambiente chiamata PYTHONSTARTUP con il nome di un file contenente i propri comandi di avvio, all'incirca come si fa con .profile per le shell Unix.
Tale file viene letto solo nelle sessioni interattive, non quando Python legge comandi da uno script, e nemmeno quando il file di dispositivo /dev/tty è fornito espressamente come fonte dei comandi (altrimenti si comporterebbe come in una sessione interattiva). Il file viene eseguito nello stesso spazio dei nomi dove vengono eseguiti i comandi interattivi, cosicché gli oggetti che definisce o importa possono essere usati senza essere qualificati nella sessione interattiva. È anche possibile cambiare i prompt, primario sys.ps1 e secondario sys.ps2 tramite questo file.
Se si vuole far leggere all'interprete un file di avvio addizionale dalla directory corrente, è possibile farlo tramite il file di avvio globale, per esempio "if os.path.isfile('.pythonrc.py'): execfile('.pythonrc.py')". Se si vuole utilizzare il file di avvio in uno script, bisogna indicarlo esplicitamente nello script:

import os
nomefile = os.environ.get('PYTHONSTARTUP')
if nomefile and os.path.isfile(nomefile):
    execfile(nomefile)

 

Ricerca personalizzata

Se ti è piaciuto l'articolo , iscriviti al feed cliccando sull'immagine sottostante per tenerti sempre aggiornato sui nuovi contenuti del blog: