Superprincipianti in programmazione ?

Sommario


Introduzione

Ricordo quando ho iniziato ad interessarmi alla programmazione in BASIC nei primissimi anni 80 (quando ancora non avevo un computer sotto mano) e leggevo le spiegazioni sui singoli comandi cercando di capire che risultato producessero. Ora come ora mi sembra strano, ma ho fatto davvero molta fatica a capire dei concetti elementari che a quel tempo mi erano completamente estranei, in particolare mi sfuggivano i loop (cicli), ma anche la semplice operazione A=A+1 non era immediatamente intuitiva, perché presupponeva di avere chiaro il concetto di variabile.... ed era "solo" BASIC.

Se fosse stato un altro linguaggio come il Pascal o il C, sarebbe stato un disastro, perché in tutti i linguaggi più evoluti, prima di scrivere delle istruzioni, queste vanno inserite in una struttura ben precisa, che spesso necessita di includere librerie esterne, e sono quindi necessarie molte conoscenze preliminari.

Ora, un giovane (o anche meno giovane) di oggi che si volesse avvicinare da zero alla programmazione, non solo per realizzare un progetto specifico, ma anche e soprattutto per il piacere di sperimentare e comprendere la programmazione stessa, dove dovrebbe sbattere la testa? Rispetto ad una volta la programmazione si è evoluta, dapprima al paradigma ad oggetti, e successivamente, con l'arrivo delle interfacce grafiche, anche all' "event driven" (guidata dagli eventi), dove i programmi sono pilotati dalle interazioni dell'utente sull'interfaccia... Oggi ogni linguaggio per essere funzionale si deve appoggiare ad un' infinità di librerie o moduli esterni, non è più possibile come una volta avere in mente tutti i comandi, e anche per rendere funzionante una singola istruzione questa va quasi sempre "incastonata" in un insieme di righe di codice "preconfezionate" che vanno prese, almeno all'inizio, per buone come un atto di fede.

E chi volesse partire oggi con qualcosa di più semplice? Si procura un vecchio complilatore anni 80 o un vecchissimo BASIC? E'una possibilità, ma forse non troverà nemmeno più libri adeguati, e c'è anche da considerare che le vecchie implementazioni dei linguaggi di 10 o 15 anni fa non sono più adatte a gestire le necessità di connessione e comunicazione dei PC moderni, le interfacce con l'esterno sono cambiate, in favore di USB/Ethernet e protocolli ad alto livello, e le applicazioni attuali sono sempre più web-based.

Esiste dunque qualcosa che possieda entrambe le caratteristiche? La possibilità di essere affrontato all'inizio con la stessa semplicità, interattività e immediatezza del BASIC originale, ma che nel contempo abbia le potenzialità per interfacciarsi, quando più esperti, con ciò che esiste oggi (web, database, ethernet, file multimediali ecc)? La risposta è si, e questo qualcosa è anche gratuito e di libero utilizzo in quanto open source, il suo nome è......... PYTHON!

Python è un linguaggio nato nel 1989 ad opera di Guido Van Rossum. E' un linguaggio ad oggetti open source che dispone di moduli per far fronte a qualsiasi tipo di necessità attuale, dal calcolo scientifico (nasce già predisposto per il calcolo con i numeri complessi) alla comunicazione tramite rete ethernet / internet.

E'nato per essere semplice ed essenziale nella sua sintassi di base, è un linguaggio interpretato che si appoggia a semplici file di testo, e nella sua forma base a riga di comando ricorda molto l'uso del vecchio GWbasic. Ma in realtà è molto di più, ed ha anche l'enorme vantaggio di essere multipiattaforma, per cui un programma Python può funzionare su Windows, Linux, MacOs (e altre piattaforme, basta installare l'interprete adatto a ciascuna macchina).

Come si è detto Python viene incontro a tutte le necessità attuali, pur mantenendo la (o ritornando alla) semplicità di un tempo. Forse anche questo lo ha reso molto popolare, tanto che per alcune operazioni è stato adottato da centri di ricerca fisica e astronomica, dalla NASA, ed e' stato utile anche in alcune fasi della lavorazione di Guerre Stellari. Lo stesso Google ha funzionalità che si basano su script Python, e quindi possiamo essere fiduciosi che il suo utilizzo si diffonderà e consoliderà sempre di più.

Per chi lavora con l'elettronica, python è usabile anche come linguaggio su schede di controllo embedded basate su Linux, ad esempio: piattaforma di controllo GSM e scheda FOX.


E dunque?

Dunque questo linguaggio può essere adatto a chiunque voglia avvicinarsi alla programmazione partendo da zero assoluto, in modo gratuito, e senza doversi far carico inizialmente di tutti quei concetti richiesti da un qualsiasi altro linguaggio e ambiente di sviluppo attuale. Tutto quello che serve è disporre di un computer su cui installare la corretta versione dell'interprete Python, che è liberamente scaricabile dal sito www.python.org/.



Concetti fondamentali

Per chi si affaccia per la prima volta al mondo della programmazione i concetti da comprendere sono molti, le righe che seguono sono una prima introduzione a quelli fondamentali per per partire.

Python è un linguaggio interpretato, su ciascuna piattaforma va installato l'interprete adeguato, che, una volta avviato, si presenta sotto forma di finestra testuale, detta anche console o shell.

Avviamo quindi l'interprete Python: si apre una finestra con un messaggio iniziale, e a caporiga compaiono i simboli >>> Questi simboli sono detti prompt, e indicano che l'interprete è in attesa di un nostro comando scritto sulla tastiera (i comandi vanno sempre confermati con il tasto Invio).

Avere a che fare con un interprete riporta un po' indietro nel tempo, quando i primi personal computer erano programmabili in BASIC, e permette di provare già subito in diretta, e con estrema semplicità, il funzionamento di molti comandi.

Per verificare il funzionamento dell'interprete possiamo scrivere i comandi dell'esempio seguente (in rosso c'è quello che dobbiamo scrivere noi e che va confermato alla fine col tasto Invio): 

>>> print 12*30
360
>>> print "W il Python!"
W il Python!
>>>

Il comando print significa stampa, scrivi, e quello che lo segue è ciò che deve essere scritto, che può essere come in questi due esempi un'espressione matematica, oppure (nel secondo caso) una stringa, cioè una sequenza di caratteri (che si indica sempre racchiusa tra virgolette). Quando diamo invio l'interprete esegue il comando e si rimette in attesa. Il comando print scrive sulla console, cioè sullo schermo, per cui battendo invio vediamo subito comparire i risultati.

Per uscire dall'interprete è sufficiente dare il comando quit()



Programmi dati e variabili

Un programma è una sequenza di istruzioni (comandi) che vengono date al computer per fargli svolgere un certo lavoro e ottenere un certo risultato.

Ogni programma utilizza (elabora o manipola) dei dati, che sono tutte le cose, o meglio dire tutti gli oggetti con cui ci interessa lavorare: ad esempio nel caso più semplice dei numeri per effettuare dei calcoli matematici, oppure delle stringhe di caratteri (come gli indirizzi di una rubrica o le righe di un testo).

Per essere utilizzabili i dati vanno memorizzati nella memoria del computer.
Come facciamo a memorizzarli? Dobbiamo forse conoscere come è fatta la memoria e dove andare a scriverli? No, a tutto questo fortunatamente pensa l'interprete, da parte nostra è sufficiente dare un nome ai nostri dati, e riferirci ad essi usando quel nome.

Scriviamo quindi: 
>>> a=150
>>>

Apparentemente non accade nulla, in realtà abbiamo detto all'interprete di memorizzare un numero dandogli il nome a. Questo nome è chiamato variabile, l'operazione è chiamata assegnazione di una variabile, e 150 è il valore assegnato alla variabile a.

Per semplicità all'inizio possiamo quindi immaginare le variabili come memorie per contenere i nostri dati, ma questa è solo un'approssimazione molto limitata. In generale in Python è sempre meglio pensare ad una variabile come ad un nome che diamo a qualsiasi oggetto elaborabile dal programma. Quando nel programma scriviamo il nome di una variabile, ci riferiamo implicitamente all'oggetto identificato (puntato / referenziato) dal suo nome, e si dice che quell' oggetto è il valore della variabile.

Possiamo creare tutte le variabili che ci servono per identificare i nostri oggetti di lavoro, ciascuna col suo nome. Il nome può essere composto da numeri lettere e trattini di sottolineatura _ (Nota: gli unici nomi che non si possono usare sono le parole riservate del linguaggio).

Come possiamo a questo punto verificare che il numero 150 sia stato effettivamente memorizzato da qualche parte? Anche questo è molto semplice, chiediamo all'interprete di mostrarci il valore dalla variabile a (cioè l'oggetto identificato dal suo nome che è appunto il nostro 150): 

>>> print a
150
>>>


Una grande potenzialità delle variabili è che si possono usare in espressioni matematiche di qualsiasi complessità, e nel calcolo delle espressioni verrà considerato il loro valore. E' perfettamente lecito scrivere i seguenti comandi: 

>>> print a+45
195
>>> print a*a
22500
>>> print (a+45)*a
29250
>>>


Inoltre la parola stessa "variabili" indica che il loro valore può anche cambiare. Nell'esempio seguente assegnamo ad a il risultato dell'operazione matematica posta dopo l'uguale, cioè la somma di 800 con il valore attuale di a. Finora il valore di a era rimasto sempre pari a 150 dall'assegnazione iniziale, ma dopo questa operazione il suo valore diventa 950, come si può verificare facendone la stampa: 

>>> a=a+800
>>> print a
950
>>>


Si è detto che un altro tipo di dato memorizzabile sono le stringhe di caratteri. L'esempio seguente crea la variabile b, cioè il nome della stringa "questa e' una stringa" (che viene memorizzata da qualche parte), e successivamente fa stampare il suo valore con il comando print: 

>>> b="questa e' una stringa"
>>> print b
questa e' una stringa
>>>


Anche sulle stringhe è possibile compiere qualche operazione, la più comune è il concatenamento, cioè l'unione di due o più stringhe una dietro l'altra usando l'operatore di somma +. Nell'esempio seguente con il primo comando diciamo all'interprete di stampare il valore della variabile b e di attaccare in coda alla stampa anche la stringa " un po' piu' lunga" (notare lo spazio bianco lasciato all'inizio per non visualizzare la parola "un" attaccata a "stringa"). Con il secondo comando invece andiamo a modificare direttamente il valore di b, a questo punto la stringa identificata da b contiene anche l'aggiunta, lo possiamo verificare come al solito facendola stampare. Successivamente effettuiamo un ulteriore concatenamento che a questo punto dovrebbe essere chiaro. 

>>> print b+" un po' piu' lunga"
questa e' una stringa un po' piu' lunga
>>> b=b+" con una aggiunta."
>>> print b
questa e' una stringa con una aggiunta.
>>> b="Sicuramente "+b
>>> print b
Sicuramente questa e' una stringa con aggiunta.
>>>


Una seconda operazione è la ripetizione di una stringa per un certo numero di volte, ottenuta con l'operatore di moltiplicazione * 

>>> c="Ciao!"*3
>>> print c
Ciao!Ciao!Ciao!
>>>


Come ultima cosa, bisogna fare attenzione a non confondersi tra numeri e stringhe: 

>>> a=150    assegna il valore numerico 150 ad a
>>> a="150"  assegna la stringa di caratteri "1" "5" e "0" ad a


Nel primo caso la variabile a identifica un dato numerico, e può essere usata per effettuare calcoli matematici, nel secondo caso invece identifica una stringa, e può essere usata per effettuare elaborazioni simboliche (come la ricerca di parole all'interno di un testo ecc).



L'input da tastiera

Finora abbiamo assegnato dei valori alle variabili scrivendo delle assegnazioni esplicite (a=150 ecc). E' anche possibile far si che l'interprete ci chieda di immettere manualmente da tastiera i valori da assegnare alle variabili, e questo è utile in un programma interattivo che pone delle domande all'operatore e si attende delle risposte.

I comandi per fare questo sono input(), per i valori numerici, e raw_input() per le stringhe di caratteri qualsiasi. L'esempio seguente dice all'interprete che deve stampare il messaggio "Immetti un numero " e che deve attendere che noi lo digitiamo sulla tastiera. Quando diamo invio il valore viene assegnato alla variabile d. 

>>> d=input("Immetti un numero ")
Immetti un numero 1890
>>>


Lo spazio alla fine della stringa serve per fare in modo che la scrittura del valore non appaia attaccata alla fine della parola "numero". A questo punto possiamo verificare il valore di d, e dobbiamo vedere stampato il valore che abbiamo inserito: 

>>> print d
1890
>>>


La stessa cosa se volessimo far chiedere l'inserimento di una stringa (sono sempre evidenziate in rosso le parti che dobbiamo scrivere noi). : 

>>> e=raw_input("Immetti una stringa: ")
Immetti una stringa: ecco la stringa
>>> print e
ecco la stringa
>>>



Verso la programmazione

Si può cominciare a comprendere che la programmazione consiste fondamentalmente nello scrivere una certa sequenza di comandi per manipolare i dati (gli oggetti di lavoro) identificati dalle variabili, chiedere eventualmente dei valori all'operatore umano, effettuare operazioni, scrivere risultati ecc. A questo punto abbiamo quasi tutte le conoscenze per poter scrivere dei semplici programmi matematici interattivi, e sta solo alla nostra fantasia applicarli ed estenderli a qualsiasi tipo di calcolo ci venga in mente di fare.

In Python, come in tutti gli altri linguaggi, le quattro operazioni fondamentali somma sottrazione moltiplicazione e divisione si indicano rispettivamente con + - * / L'elevamento a potenza si indica invece con il doppio asterisco ** Altre funzioni matematiche più complesse (come la radice quadrata che si indica con sqrt) si rendono disponibili caricando il modulo (libreria di funzioni Python) di nome math. Basta scrivere all'inizio: 

>>> import math
>>>


Le operazioni matematiche sono eseguite con certe priorità, prima moltiplicazioni divisioni elevamenti a potenza, poi somme e sottrazioni. Si possono usare le parentesi per stabilire le proprie priorità di calcolo, e naturalmente il contenuto all'interno delle parentesi verrà calcolato per primo. Il seguente esempio mostra il risultato di un'operazione con e senza le parentesi: 

>>> print (10+3)*5
65
>>> print 10+3*5
25
>>>



Il primo vero programma

Anche se può non sembrare, con le conoscenze acquisite finora possiamo finalmente scrivere il primo vero programma, cioè un insieme di comandi Python raggruppati in un file di testo esterno, da richiamare (o se preferite: lanciare, avviare, eseguire) con il comando execfile(). L'interprete leggerà il file una riga dopo l'altra ed eseguirà quello che vi è scritto di fare.

Ecco il programma, che a questo punto non dovrebbe presentare particolari difficoltà di comprensione, a parte alcuni particolari di cui parliamo dopo. Scriviamolo con un editor di testo (come il blocco note) e salviamolo in un file di nome pitagora.py 

# Teorema di Pitagora
import math
print "Calcolo ipotenusa triangolo rettangolo"
a=input("Inserisci la misura del primo cateto ")
b=input("Ora il secondo cateto ")
c=math.sqrt( a*a + b*b )
print "L'ipotenusa misura",c


Per avviarlo basta dire all'interprete: >>> execfile("pitagora.py") (in alcuni casi potrebbe servire specificare il nome completo del percorso del file, ad esempio "c:\prove\pitagora.py")

A questo punto il nostro programma si avvia e questo è ciò che appare a video (nell'ipotesi di rispondere 100 alla prima richiesta e 200 alla seconda): 

Calcolo ipotenusa triangolo rettangolo
Inserisci la misura del primo cateto 100
Ora il secondo cateto 200
L'ipotenusa misura 223.60679775
>>>


Nel suo piccolo questo programma presenta tutte le fasi tipiche dell'elaborazione: l'acquisizione di dati, l'elaborazione, e la presentazione dei risultati, in più è interattivo, nel senso che per compiere il suo lavoro chiede informazioni all'esterno attraverso la console (schermo e tastiera). Dal momento in cui l'esecuzione ha inizio, l'interprete non mostra più il prompt, e sarà il nostro programma a dirigere gli eventi. Solo al termine del programma l'interprete si rifà vivo con >>> in attesa di nuovi comandi.


Le cose da spiegare

La prima riga "# Teorema di Pitagora" è un semplice commento per chi legge il programma e viene ignorata dall'interprete, infatti l'interprete Python considera il carattere # come l'inizio di un commento e ignora ciò che si trova dopo. Nei programmi, soprattutto quando cominciano a diventare grandi, è buona norma inserire sempre dei commenti che ricordino le funzioni svolte dalle diverse sezioni. (Nota: l'unico caso in cui il carattere # non è considerato l'inizio di un commento è quando fa parte dei caratteri di una stringa).

La seconda riga "import math" carica il modulo matematico math di Python, cioè rende utilizzabili le funzioni matematiche in esso contenute. Nel pacchetto di installazione di base sono compresi moltissimi moduli contenenti funzioni aggiuntive a quelle di base. Le funzioni di base, cioè quelle usabili senza caricare moduli aggiuntivi, sono dette built-in. Per una visione più organica e completa si può sempre consultare la libreria di riferimento di Python.
Ma prima di tutto è meglio studiarsi questi due ottimi tutorial:
Corso pensare da informatico (versione .PDF)
Tutorial in italiano

Nella penultima riga troviamo il comando math.sqrt() questo è il modo in cui si richiamano le funzioni dei moduli esterni, cioè nome del modulo.funzione (è detta notazione punto).

Nell'ultima riga si può notare una virgola tra le cose da stampare. Questa dice all'interprete che dopo la stringa "L'ipotenusa misura" c'è ancora qualcosa da stampare sulla stessa riga. Gli elementi da stampare separati da una virgola risulteranno sempre searati da uno spazio: 

>>> print "stringa1",1280,"stringa2",44
stringa1 1280 stringa2 44
>>>