| Contenuto del capitolo |
|---|
| Molti altri usi dei commenti, come organizzare il programma usando le linee indentate per migliorare la leggibilità ed una introduzione all'uso dei moduli per archiviare i programmi. |
Abbiamo già parlato dei commenti nel capitolo "Ancora sequenze di comandi...". Ma ci sono altre cose che possono essere fatte con i commenti e ci dedicheremo adesso ad approfondirle:
#############################
# Modulo: Prosciutto.py
# Autore: A.J.Gauld
# Data: 1999/09/03
# Versione: Preliminare 0.4
#
# Descrizione: Questo modulo fornisce un oggetto di tipo prosciutto
# che puo' essere combinato con atri oggetti di tipo Cibo per creare
# interessanti variazioni di pranzi.
#
###############################
# Storia:
# 1999/09/01 AJG - Prima creazione
# 1999/09/02 AJG - Corretto errore nella strategia dei prezzi
# 1999/09/02 AJG - Questa volta e' giusto!
# 1999/09/03 AJG - Aggiunto il metodo stufato(vedi Richiesta #1234)
################################
import sys, string, cibo
...
Questa tecnica viene spesso usata per isolare parti di programma che non funzionano. Ad esempio, supponiamo che un programma legga alcuni dati, li elabori, scriva i risultati e quindi memorizzi i risultati nello stesso file dei dati. Se i risultati non sono quelli che ci attendiamo potrebbe essere utile evitare temporaneamente che i risultati (errati) siano scritti nel file dei dati che ne risulterebbe corrotto. Potremmo semplicemennte cancellare le istruzioni relative ma una soluzione meno radicale può essere quella di trasformare le istruzioni in linee di commento, ad esempio:
data = leggiDati(datafile)
for item in data:
results.append(calcolaRisultato(item))
scriviRisultato(results)
######################
# Linee commentate in attesa di correggere calcolaRisultato()
# for item in results:
# dataFile.save(item)
######################
print 'Programma terminato'
Quando avremo corretto l'errore potremo semplicemente cancellare i caratteri di commento e riattivare le istruzioni.
Tutti i linguaggi consentono di aggiungere commenti per documentare il fuzionamento di un modulo o una funzione, ma alcuni come Python e Smalltalk si collocano un passo più avanti e consentono di documentare la funzione in un modo che permette al linguaggio o all'ambiente di programmazione di fornire aiuto interattivamente durante la programmazione. In Python questo può essere ottenuto usando lo stile delle stringhe di """documentazione""" :
class Prosciutto:
"""Un tipo di carne da combinare con altri cibi
puo' essere usata con altri cibi per creare interessanti piatti.
Contiene molti elementi nutrienti e puo' essere cucinata
in molti modi differenti """
def __init__(self):
...
print Prosciutto.__doc__
Nota: Possiamo estrarre la stringa di documentazione visualizzando la variabile speciale __doc__. Moduli, funzioni, classi e metodi possono tutti avere stringhe di documentazione. Provate, per esempio:
import sys print sys.__doc__
Questo è uno degli argomenti più dibattuti nel campo della programmazione. Sembra quasi che ciascun programmatore abbia la sua idea particolare di quale sia il miglior modo di scrivere le linee indentate. Risulta che ci siano stati alcuni studi che hanno dimostrato che almeno alcuni fattori sono realmente importanti e non puramente estetici - ovvero migliorano effettivamente la comprensione del programma.
Il motivo del dibattito è semplice. In molti linguaggi di programmazione la scrittura indentata ha un valore puramente estetico; un artificio per il lettore del programma. (In Python invece è un elemento necessario ed indispensabile per il buon funzionamento del programma). Perciò:
FOR I = 1 TO 10
PRINT I
NEXT I
È esattamente la stessa cosa di:
FOR I = 1 TO 10 PRINT I NEXT I
per quanto riguarda l'interprete BASIC. La scrittura indentata risulta solo più facile da leggere.
Il punto importante è che l'indentazione delle linee dovrebbe riflettere la struttura del programma in modo che visivamente consenta di seguire la sequenza delle istruzioni. Questo è reso più facile se i blocchi appaiono come blocchi, ad esempio:
XXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX
e più facile da leggere di:
XXXXXXXXXXXXXXXXXXXXX
XXXXX
XXXXXXXXXXXX
XXXXXXXXXXXX
XXXXXXXXXXXX
XXXXX
perché il blocco è chiaramente identificato. Alcuni studi hanno mostrato significativi miglioramenti nella capacità di comprensione quando le indentazioni riflettono la struttura logica dei blocchi. Questo può non sembrare essenziale guardando i brevi esempi fin qui mostrati, ma lo diventa quando si devono scrivere programmi con centinaia o migliaia di istruzioni.
I nomi delle variabili che abbiamo usato fino ad ora erano sostanzialmente privi di significato, soprattutto perché avevano solo lo scopo di illustrare alcune tecniche. In generale è assai meglio se il nome della variabile riflette ciò che vogliamo che essa rappresenti. Ad esempio nell'esercizio delle tabelline abbiamo usato la variabile 'moltiplicatore' per indicare quale tabellina stavamo creando. Questo è assai più significativo che non se avessimo usato semplicementen 'm' - che avrebbe funzionato altrettanto bene ed avrebbe richiesto minor numero di tasti da digitare.
Si tratta di adottare un compromesso fra la comprensibilità e la complicazione. In generale è bene usare nomi brevi, ma significativi. Nomi troppo lunghi causano confusione e sono difficili da adottare in modo consistente (ad esempio avremmo potuto usare la_tabellina_che_stiamo_calcolando invece di moltiplicatore ma sarebbe stato troppo lungo e non molto più chiaro).
Tratteremo di questo argomento con maggiori dettagli in seguito, ma per il momento vorremmo introdurre il concetto e soprattutto come possiamo usare i moduli per salvare il lavoro fatto: fino ad ora tutti i nostri programmi sono andati perduti appena abbiamo terminato Python.
L'interprete interattivo di Python con il suo "prompt" (>>>) è assai utile per mettere alla prova le idee in modo rapido, ma tutto ciò che viene scritto va perduto non appena Python termina. Col tempo vorremmo essere in grado di scrivere programmi e quindi eseguirli più volte. Per fare ciò in Python dobbiamo creare un file con una estensione .py (questa è solo una convenzione, si può usare qualunque estensione si voglia, ma sono convinto che sia una buona idea seguire la convenzione...). Il programma può essere eseguito da un "prompt" dei comandi scrivendo:
$ python prosciutto.py
Se prosciutto.py è il nome del file contenente il programma Python.
Nota per gli utilizzatori di Unix: La prima linea di un file di uno script Python dovrebbe contenere la sequenza: #! seguita del percorso completo di Python sul vostro sistema. (Potete trovare il percorso scrivendo $ which python al prompt della shell.)
Sul mio sistema la linea è:
#! /usr/local/bin/python
Questo artificio vi permette di eseguire il programma senza chiamare esplicitamente Python:
$ prosciutto.py
La linea iniziale non ha alcun effetto sui sistemi Windows/Mac, quindi gli utilizzatori di questi sistemi possono metterla comunque se c'è qualche probabilità che il programma debba girare in ambiente Unix.
Nota per gli utilizzatori di Windows: Nell'ambiente Windows potete attivare in Explorer una associazione per i files che terminano in .py e questo consente di mandare in esecuzione i programmi Python con un semplice "doppio clic" sull'icona del programma. Questo dovrebbe essere stato fatto dal programma di installazione di Python. Potete verificarlo trovando qualche file con estensione .py e cercando di eseguirlo. Se va in esecuzione (anche se genera errori) l'associazione è già attiva.
Un altro vantaggio di usare i file per memorizzare i programmi consiste nel fatto che potete correggere gli errori senza dover digitare di nuovo l'intero programma o, se usate IDLE, seguire il percorso all'indietro fino al punto dove si trova l'errore. IDLE consente di tenere un file aperto per modificarlo e contemporaneamente mandarlo in esecuzione dal menù "Edit|Run module".
Da questo momento non mostreremo più il prompt >>> , ma presupporremo che i programmi siano scritti in files e mandati in esecuzione mediante IDLE oppure (è il modo che preferiamo) da un prompt del sistema operativo.
| Promemoria |
|---|
|
Se avete domande o suggerimenti relativi a questa pagina
mandate un e-mail all'autore:
alan.gauld@yahoo.co.uk
o al traduttore italiano:
lfini@arcetri.astro.it