Il linguaggio Python per Haiku

Indice

• Storia e caratteristiche
• Installazione e script
• Primi esempi
• Introduzione a Bethon
• Cosa sono i file .pyc
• Freeze
• Tipi semplici
• Liste
• Stringhe
• Tuple e Set
• Dizionari
• Controllo del flusso (flow control)
• Eccezioni

L'obiettivo di questo tutorial è fornire una semplice introduzione alla programmazione in Python con un occhio di riguardo alle particolarità dell'uso di questo linguaggio sul sistema operativo Haiku, ed ai moduli Bethon che consentono l'uso delle API di BeOS in Python. Mi scuso fin da ora per eventuali errori o imprecisioni che vi prego di segnalarmi (Questo indirizzo email è protetto dagli spambots. È necessario abilitare JavaScript per vederlo.), grazie.

Giuseppe Gargaro

Storia e caratteristiche

Python è il linguaggio di programmazione creato dall'olandese Guido Van Rossum nel 1989, mentre lavorava come ricercatore ad Amsterdam. Il nome del linguaggio deriva dalla passione dell'autore per il gruppo di comici inglesi Monty Python.

Il Python è un linguaggio di programmazione interpretato, infatti è possibile eseguire direttamente il codice sorgente o introdurre direttamente dal suo prompt le istruzioni (perciò è detto interattivo). Nonostante l'eliminazione della fase di compilazione (presente in linguaggi come il C++) vada a scapito della velocità, le prestazioni restano comunque molto buone. Python è un linguaggio portatile che consente di eseguire i nostri programmi sotto una moltitudine di sistemi operativi.

Python supporta i vari paradigmi di programmazione, come la programmazione strutturata, funzionale o quella ad oggetti (object oriented) e mette a disposizione una vasta gamma di librerie chiamate "Moduli".

In Python i blocchi di codice vengono definiti dall'indentazione (non ci sono parentesi) per cui é assolutamente vietato essere disordinati altrimenti si rischia il non funzionamento del programma.

Il controllo dei tipi è dinamico e ciò vuol dire che una variabile può assumere valori diversi tuttavia in ogni istante appartiene ad un tipo ben definito.

Python permette l'implementazione di moduli scritti in C e C++ per cui è possibile ottimizzare la velocità di esecuzione utilizzando tali moduli per i calcoli. Ci sono diverse librerie grafiche per la creazione di GUI specifiche dei diversi sistemi operativi; per realizzare GUI sulla nostra piattaforma è possibile sfruttare Bethon che consente l'uso di una parte delle API di BeOS in Python.

E' possibile la creazione di binari grazie al modulo Freeze un programma che permette di distribuire un programma Python come singolo eseguibile indipendente.

Alcuni link utili:

http://www.python.it
http://it.wikipedia.org/wiki/Python

torna all'indice

Installazione e script

Prima di iniziare è necessario installare Python in Haiku. Scaricate Python da qui:

http://www.haiku-os.it/zip/Python-2.4.4-alex.zip

una volta decompresso il file zip installate python (se avete decompresso il file zip sul Desktop aprite il terminale scrivete

cd /boot/home/Desktop/Python-2.4.4-alex

date Invio e poi

install-python

e nuovamente Invio(Enter).

Python è un linguaggio interpretato infatti i programmi vengono eseguiti da un'interprete. Per avviare l'interprete aprite il terminale e dopo aver digitato python premete sul tasto di Invio (Enter), comparirà quanto segue:

$ python Python 2.4.2 (#1, Oct 5 2005, 22:49:22) [GCC 2.9-beos-991026] on beos5 Type "help", "copyright", "credits" or "license" for more information. >>>

Dove >>> è il prompt dell'interprete dei comandi di Python. I file di codice sorgente in Python hanno l'estensione .py ed anche se potete omettere l'estensione è sconsigliabile visto che alcuni comandi richiedono tale estensione.

Ci sono due modi per utilizzare l'interprete Python:
1) a linea di comando, scrivendo il programma una riga per volta.
2) in modalità script, il programma viene scritto in un file (detto script, ad esempio prova.py) con un qualsiasi editor di testo, ad esempio l'ottimo editor open source Pe; il file Python può essere avviato da terminale scrivendo python prova.py ; naturalmente prima del nome dello script deve esserci il percorso in cui si trova ad es. /boot/home , per non perdere tempo vi basta scrivere nel terminale python e poi trascinare il vostro script sul terminale ed infine dare Invio (Enter) per avviare lo script.

Molti script non partono direttamente in Haiku poiché la prima linea spesso contiene qualcosa di simile a:
#! /usr/bin/env python
mentre affinchè lo script sia avviabile, deve contenere quanto segue:
#! /boot/home/config/bin/python
inoltre lo script deve essere reso eseguibile aprendo il terminale e digitando quanto segue
chmod 755 /path/nome_script
ad esempio se il vostro script si chiama prova.py e si trova in home il comando da lanciare sarà:
chmod 755 /boot/home/prova.py
quanto detto funziona molto bene con gli script che hanno un'interfaccia ad esempio scritta in bethon mentre molti altri script non si avvieranno se non lanciati da terminale scrivendo:
python nome_script.py

torna all'indice

Primi esempi

Ogni volta che leggete un libro o un tutorial sulla programmazione vi verrà presentato come primo esempio il classico "Hello World", il cui unico scopo è appunto scrivere Hello World(Ciao Mondo), un esempio un po stucchevole che vale la pena guardare solo perché rende chiaro quanto sia conciso ed espressivo il linguaggio Python.

>>> print "Hello World!"

mentre in C++ lo stesso effetto si ottiene con il seguente codice:

#include 
int main() 
{ 
cout<<"Hello World!" 
endl; 
return 0; 
}​

Gli esempi sono importanti e quello appena visto dice davvero poco, vediamo un altro programmino che ci permette di calcolare il fattoriale di un numero.

a = "inserire il numero di cui si vuole calcolare il fattoriale: " 

i = input(a) 
def Fattoriale(n): # La funzione che calcola il fattoriale 
    if type(n) != type(1): 
        print "Il fattoriale e' definito solo per valori interi." 
        return -1 
    elif n         print "Il fattoriale e' definito solo per interi positivi." 
        return -1 
    elif n==0: 
        return 1 
    else: 
        return n * Fattoriale(n-1) 
f=Fattoriale(i) 
print "Il fattoriale di", i, " e' ", f​

L'esempio qui sopra vi può dare un'idea di come va scritto un programma in Python (come già detto in Python i blocchi sono individuati dall'indentazione) ed è facile capire dove inizia e dove finisce un blocco di codice, e non é una questione di stile poiché il disordine non è permesso dalla sintassi del linguaggio.

Analizziamo un po il programmino qui sopra:

Il carattere # indica l'inizio di un commento e nonostante Python sia un linguaggio molto espressivo è sempre utile commentare il codice.

Parleremo dettagliatamente dell'input e dell'output in una sezione dedicata per ora vi basti sapere che la funzione input permette di leggere l'intero da voi inserito per ottenerne il fattoriale.

L'istruzione def ci permette di creare una funzione, che in questo caso accetta come parametro n, mentre return è l'istruzione che termina la funzione e restituisce il valore cercato.

Il comando print mostra in output le espressioni che gli vengono passate dopo averle convertite in stringa, alla fine print inserisce automaticamente un a capo a meno che l'ultimo elemento non sia una virgola.

torna all'indice

Introduzione a Bethon

Bethon, realizzato da Donn Cave, non è un modulo per la realizzazione di GUI ma un vero e proprio wrapper che consente di incorporare le API native di BeOS nei vostri programmi Python. L'intento di questo modulo è tradurre le API C++ di BeOS in Python, per cui nella programmazione si può consultare il "Be Book" e trovare le stesse classi e funzioni con qualche piccola modifica per Python, soprattutto per quanto riguarda cosa ritornano le funzioni e nelle eccezioni. Non mancano alcune limitazioni anche se Bethon consente di scrivere reali applicazioni BeOS, inoltre il sistema viene distribuito con i sorgenti e i moduli vengono generati da template descrittivi semplici percui se è necessario potete aggiungerli da soli.

Se avete installato Python-2.4.4-alex non dovete fare nient'altro poiché in questa installazione di Python è già incluso Bethon 0.5.3

Torniamo al classico esempio "Hello World".... non preoccupatevi non ho intenzione di tediarvi, questa volta grazie a Bethon realizzeremo un Hello World un pò più evoluto che presenta la classica scritta in una finestra.

#! /boot/home/config/bin/python 

import BApplication 
from BStringView import BStringView 
from BWindow import BWindow 
from BBox import BBox 
from InterfaceKit import B_FOLLOW_ALL,B_TITLED_WINDOW,B_WILL_DRAW,B_NOT_RESIZABLE,B_NOT_ZOOMABLE 
from AppKit import B_QUIT_REQUESTED 
class HelloWindow(BWindow): 

    def __init__(self): 
        BWindow.__init__(self, (100, 100, 440, 180), 'Hello World',B_TITLED_WINDOW,0) 
    self.top = BBox(self.Bounds(), 'top', B_FOLLOW_ALL, B_WILL_DRAW, B_NOT_RESIZABLE) 
        self.AddChild(self.top) 
        self.view = BStringView((100, 1, 340, 60), 'HelloView','Hello world!', 0, B_WILL_DRAW) 
        from BFont import be_bold_font 
        self.view.SetHighColor(66,77,214) 
        self.view.SetFont(be_bold_font) 
        self.view.SetFontSize(24.0) 
        self.top.AddChild(self.view) 

    def QuitRequested(self): 
        BApplication.be_app.PostMessage(B_QUIT_REQUESTED) 
        return 1 
class HelloApplication(BApplication.BApplication): 
    def __init__(self): 
        BApplication.BApplication.__init__(self,"application/x-vnd.Be-HelloWorldSample") 
    def ReadyToRun(self): 
        window = HelloWindow() 
        window.Show() 
myApplication = HelloApplication() 
myApplication.Run()

Se avete un minimo di conoscenza delle BeOS API vi risulterà tutto molto chiaro, nel caso contrario per ora vi basti prendere familiarità con alcuni comandi.

Il comando import ci permette di caricare i moduli specificati, che in questo caso sono alcuni moduli Bethon che ci permettono di creare una finestra. Vengono inoltre definite due classi derivate, la prima è HelloWindow che deriva da BWindow mentre la seconda è HelloApplication che deriva da BApplication. Nelle ultime due righe viene creata un'istanza di HelloApplication e viene chiamata la funzione Run della stessa che avvia il programma. Non preoccupatevi se il codice vi risulta poco chiaro in una successiva sezione dedicata alle API di BeOS, necessarie alla creazione della GUI, approfondiremo l'argomento.

torna all'indice

Cosa sono i file .pyc

Il codice Python è sempre tradotto in "byte-code" prima di venire interpretato. Per evitare di tradurre ogni volta moduli che cambiano di rado, l'interprete dopo aver analizzato il codice di un modulo ne scrive il byte-code in un file con estensione ".pyc" che come detto viene generato a partire dal file sorgente ".py", se il rispettivo codice sorgente cambia il file .pyc viene generato di nuovo. La differenza tra i due tipi di file sta nel fatto che la lettura del codice da un file .pyc risulta più veloce che l'analisi e la traduzione di un file .py, percui i file .pyc migliorano il tempo di avvio delle applicazioni.

Se si vuole forzare la creazione di file .pyc si può utilizzare il modulo /boot/home/config/lib/python2.4/compileall.py
l'uso è semplice basta dare il seguente comando da terminale:

python /boot/home/config/lib/python2.4/compileall.py /boot/home/nome_directory_programma/

quindi dopo compileall.py vi basta indicare il percorso della directory che contiene il vostro programma e i relativi moduli.

Va tenuto presente che il modulo principale di un programma Python non produce un file .pyc ciò perché anche se tale modulo viene compilato in byte-code non viene salvato su un file.

torna all'indice

Freeze

Se cercate un modo per distribuire i vostri programmi python in forma binaria, potete utilizzare Freeze un'applicazione python che crea un singolo file eseguibile che incorpora il vostro programma, l'interprete e le librerie python utilizzate dal vostro programma. L'eseguibile che si ottiene grazie a Freeze girerà solo sulla piattaforma su cui è stato generato.
Per ora potete provare quanto segue su BeOS visto che attualmente ci sono ancora alcuni problemi per la compilazione sotto Haiku.
Prima di tutto scaricate ed installate
http://www.haiku-os.it/zip/cx_Freeze-3.0.2.zip
una volta decompresso il file vi basterà cliccare su install.sh

Ora proviamo insieme freeze sul programma Hello World visto nella precedente sezione. Creiamo una cartella sul Desktop che chiamiamo "freeze_prova" e ci inseriamo il nostro file Hello_world.py, poi apriamo il terminale, digitiamo quanto segue e diamo Invio(Enter):

$ python /boot/home/config/lib/python2.4/freeze/freeze.py -o /boot/home/Desktop/freeze_prova /boot/home/Desktop/freeze_prova/Hello_world.py

Freeze creerà, nella cartella indicata dopo l'opzione -o, una serie di file c tra cui frozen.c, config.c, ecc. ed un Makefile.

Ora per terminare l'operazione e ottenere il binario dovete portarvi nella directory
cd /boot/home/Desktop/freeze_prova
dare Invio, poi digitare "make" e dare di nuovamente Invio; alla fine del processo avrete il vostro Hello_world nella cartella freeze_prova

Quanto visto può essere ottenuto in maniera ancora più semplice utilizzando l'interfaccia FreedomFreeze una GUI python per freeze realizzata da James Mayfield (a.k.a Cube-ness).
Scaricate FreedomFreeze 0.9 da
http://www.haiku-os.it/zip/FreedomFreeze.zip
e dopo aver decompresso il file entrate nella directory e avviate FreedomFreeze cliccandoci sopra.

Trascinate Hello_world.py su FreedomFreeze

Non vi resta che inserire un nome per ila cartella di destinazione in cui verrà creato il binario, ad esempio possiamo chiamarla prova

Per finire basta cliccare su Build Binary ed alla fine del processo avrete il vostro file nella cartella prova.

torna all'indice

Tipi Semplici

Python è un linguaggio in cui il controllo dei tipi è dinamico, percui non dovete dichiarare il tipo di una variabile. Se avete bisogno di un intero, vi basterà assegnare un valore intero ad una variabile e Python creerà un oggetto intero e gli assegnerà la variabile come riferimento.

a = 45

Per determinare il tipo di una variabile si può usare la funzione type

>>> a = 45 
>>> type(a) 

>>> g = 5.0 
>>> type(g)

Python ha cinque tipi semplici: bool, int, long, float e complex. Quando il valore di una variabile di uno di questi tipi cambia viene creato un nuovo oggetto poiché i cinque tipi semplici sono immutabili; se ad esempio create un oggetto intero il suo valore non può essere cambiato ma, come già detto, ciò che accade è che viene creato un nuovo oggetto.

La funzione id restituisce l'identificativo di ogni oggetto.

>>> a = 45 
>>> id(a) 
1067275 

>>> a = 46 
>>> id(a) 
1067283​

Il tipo bool può avere soltanto uno dei due valori: True (vero) o False (falso)
Questo tipo può essere utilizzato nelle espressioni booleane con i seguenti operatori:

< minore
<= minore o uguale
> maggiore
>= maggiore o uguale
== uguale
!= diverso

not negazione logica
and and logico es. (a>=10) and (b<=20)
or or logico es. (a>=10) or (b<=20)

Gli operatori di comparazione hanno precedenza maggiore degli operatori logici (gli ultimi tre).

>>> c = 32 > 4 
>>> print c 
True​

Come detto Python ha solo tipi oggetto (anzi tutto in Python è un oggetto) per cui esistono i rispettivi costruttori.

>>> a = int(10) 
>>> b = bool(True) 
>>> c = long(10) 
>>> d = complex (5.1, 2.3) 
>>> e = float(10.5)​

Omettendo le parentesi dopo int si può creare un alias alla classe originale

>>> numeri_interi = int # crea un alias alla classe interi 
>>> numeri_interi(5) 
5 
>>> type(numeri_interi) # abbiamo creato un nuovo tipo definito a partire dalla classe int 

torna all'indice

Liste

Una lista è un elenco ordinato di elementi di vario tipo. Vediamo alcuni esempi di lista:

>>> lista1 = [4, 7, 56, 78] 
>>> lista2 = [3, 6, lista1, "ciao"] 
>>> lista3 = [] # lista vuota​

Come è possibile notare dal secondo esempio una lista può contenere di tutto: interi, altre liste, stringhe, ecc.
Vediamo come estrarre un elemento da una lista:

>>> lista1[0] 
4​

In una lista di n elementi, questi saranno individuati da un indice che va da 0 a n-1 per cui se intendiamo estrarre il primo elemento utilizziamo, come appena visto, l'indice 0. Se vogliamo ottenere l'ultimo elemento possiamo nel caso della lista1 utilizzare lista1[3] o in alternativa lista1[-1] mentre per il penultimo usiamo lista1[-2] e così via fino a -n.
Per estrarre uno o più elementi contemporaneamente si può utilizzare lo "slicing", indicando due indici separati dai ":".
La forma generale di uno slicing è oggetto[start:end:step] ossia [inizio indice : fine indice : passo]

>>> lista1[4,7,56,78] 
>>> lista1[0:2] 
[4, 7] 
>>> lista1[2:4] 
[56, 78] 
>>> lista1[0:-1] 
[4, 7, 56] 
>>> lista1[2:] # si può omettere uno dei due valori e python raggiungerà l'inizio o la fine della lista a secondo che i : si trovino davanti o dietro l'indice 
[56, 78] 

>>> lista1[:2] 
[4, 7] 
>>> lista1[:] # duplica l'intera lista 
[4, 7, 56, 78]

Lo slicing può essere utilizzato per assegnare, inserire o cancellare elementi in una lista:

>>> lista1[1:3] = [3, 6] 
>>> lista1 
[4, 3, 6, 78] 
>>> lista1[3:3] = [7, 8, 9] 
>>> lista1 
[4, 3, 6, 7, 8, 9, 78] 
>>> lista1[3:6] = [] 
[4, 3, 6, 78]

Il comando dir ci permette di visualizzare tutti gli attributi dell'oggetto che gli passiamo come argomento.

>>> dir(lista1) 
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Proviamo ad utilizzare alcuni metodi:

>>> lista1.append(5) # append aggiunge un elemento in fondo alla lista 
>>> lista1 
[4, 3, 6, 78, 5] 
>>> lista1.insert(1, 'ciao') # insert inserisce un elemento nella posizione indicata 
>>> lista1 
[4, 'ciao', 3, 6, 78, 5] 
>>> lista3 = [ 2, 1] 
>>> lista1.extend(lista3) # extend aggiunge una seconda lista infondo alla prima 
>>>lista1 
[4, 'ciao', 3, 6, 78, 5, 2, 1] 
>>> lista1.remove('ciao') # remove elimina l'elemento indicato 
>>> lista1 
[4, 3, 6, 78, 5, 2, 1] 
>>> lista1.pop(2) # pop elimina l'elemento nella posizione indicata 
6 
>>> lista1 
[4, 3, 78, 5, 2, 1] 
>>> lista1.index(3) # index restituisce la posizione dell'elemento passato come argomento 
1 
>>> lista1.reverse() # reverse inverte la lista 
[1, 2, 5, 78, 3, 4] 
>>> lista1.sort() # sort ordina la lista 
[1, 2, 3, 4, 5, 78]​

Per avere maggiori informazioni su un argomento in Python potete sempre utilizzare la funzione help, che qui sotto vediamo all'opera sulla classe list.

>>> help(list) 
Help on class list in module __builtin__: 
class list(object) 
| list() -> new list 
| list(sequence) -> new list initialized from sequence's items 
| 
| Methods defined here: 
| 
| __add__(...) 
| x.__add__(y) <==> x+y 
| 
| __contains__(...) 
| x.__contains__(y) <==> y in x 
| 
| __delitem__(...) 
| x.__delitem__(y) <==> del x[y] 
| 
| __delslice__(...) 
| x.__delslice__(i, j) <==> del x[i:j] 
| 
| Use of negative indices is not supported. 
| 
| __eq__(...) 
| x.__eq__(y) <==> x==y 
| 
:​

La classe list è molto flessibile e ci permette di trasformare in lista una sequenza come una tupla o una lista.

>>> lista = list("789") # crea una lista da una stringa 
>>> lista 
['7', '8', '9']​

torna all'indice

Stringhe

Una stringa è una sequenza di caratteri, e come ogni elemento di Python è un oggetto con i suoi metodi. Le stringhe sono immutabili e sono delimitate da apici singoli o doppi, nel primo caso possiamo anche inserire apici doppi al loro interno mentre nel secondo apici singoli.

>>> s="ciao" 
>>> dir(s) 
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__str__', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'replace', 'rfind', 'rindex', 'rjust', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] 
>>> a=s[1] 
>>> print a 
i

In Python tutti gli oggetti, come le stringhe o le liste, costituiti da una sequenza usufruiscono della funzionalità di "slicing".

>>> s[1:3] 
'ia' 
>>> s[1::2] # prende un carattere ogni due partendo dal secondo 
'io' 
>>> str("Il linguaggio python è fantastico") 
>>> a = str("W") 
>>> a += (" python") 
>>> a 
'W python' 
>>> len(s) # la funzione len restituisce il numero di caratteri di una stringa 
4​

E' possibile inserire un carattere di "a capo" utilizzando "\n", ottenere la tabulazione con \t, e scrivere stringhe su più righe utilizzando una sequenza di tre apici.

>>> help=""" 
... Questo è l'help 
... del nostro programma""" 
>>> 

>>> a='ciao' 
>>> b='\npeppe' 
>>> a+b 
'ciao\npeppe' 
>>> print a+b 
ciao 
peppe 
>>> a+b.replace('peppe', 'paolo') # replace sostituisce una sotto-stringa con un'altra 
'ciao\npaolo' 
>>>c=a+b 
>>> print c 
ciao 
peppe 
>>> print c.replace('peppe', 'paolo') 
ciao 
paolo 

>>> f=("mela pera ciliegia")>>> f.split() # il metodo split spezza una stringa in una lista 
['mela', 'pera', 'ciliegia'] 
>>> "".join(f) 
'mela pera ciliegia' 
>>> f=("mela-pera-ciliegia") 
>>> f.split("-") 
['mela', 'pera', 'ciliegia'] 
>>> e=("/") 
>>> e.join(['mela', 'pera', 'ciliegia']) # il metodo join unisce una lista per formare una stringa 
'mela pera ciliegia' 
paolo​

Possiamo creare una stringa utilizzando il costruttore di classe str, e più in generale visto che ogni cosa in Python è un oggetto possiamo utilizzare i metodi delle classi per ottenere ulteriore controllo sugli oggetti. Per ottenere altre informazioni sulla classe potete utilizzare la funzione help(str).

torna all'indice

Tuple e Set

Le tuple sono simili alle liste ma a differenza di queste sono immutabili.

>>> t = ('la', 'nostra', 'prima', 'tupla') 
>>> t[2:] # anche con le tuple si può utilizzare lo slicing 
('prima', 'tupla') 
>>> 'una' in t # l'operatore in ci permette di verificare se è presente un elemento in una tupla 
True 
>>> a=('s',) # per creare una tupla con un singolo elemento va aggiunta la virgola finale altrimenti diventa una stringa

Set
I set(insiemi) comprendono elementi non ordinati e senza duplicati.

>>> insieme = set(['mela', 'pera', 'banana']) 
>>> insieme2= set(t) # possiamo utilizzare una sequenza qualunque come una lista o una tupla 
>>> insieme2 
set(['la', 'nostra', 'prima', 'tupla'])

Le operazioni che possiamo effettuare sugli insiemi sono:
| unione
- differenza
& intersezione
^ xor (differenza simmetrica, gli elementi presenti solo in uno dei due insiemi ma non in entrambi)

torna all'indice

Dizionari

Un dizionario è essenzialmente un insieme di oggetti che possono essere estratti tramite una chiave.
Mentre stringhe, liste e tuple usano gli interi come indici, i dizionari possono usare qualsiasi tipo di dato come indice.

>>> catalogo=dict() # oppure in alternativa catalogo={} che crea un dizionario vuoto 
>>> catalogo['scarpe']='123' 
>>> catalogo['gonne']='347' 
>>> catalogo['maglie']='678' 
>>> catalogo['capotti']='897' 
>>> catalogo {'gonne': '347', 'maglie': '678', 'scarpe': '123', 'capotti': '897'} 
>>> catalogo['maglie'] # estraiamo un valore '678' 

>>> dir(catalogo) ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'] 
>>> 

>>> catalogo.keys() # per elencare tutte le chiavi di un dizionario possiamo utilizzare il metodo keys 
['gonne','maglie','scarpe','cappotti'] 

>>> del catalogo['maglie'] # del cancella un elemento dal dizionario 
>>> catalogo {'gonne': '347', 'scarpe': '123', 'capotti': '897'}

Un dizionario può essere inizializzato con le parentesi graffe che contengono le coppie chiave valore.

>>> frutta = {'mela':1, 'pera':2, 'banana':3} 

>>> frutta.values() # values invece delle chiavi estrae tutti gli elementi 
[2, 1, 3]​

torna all'indice

Controllo del flusso (flow control)

Per controllare il flusso di esecuzione in un programma Python ci sono tre istruzioni principali

- l'istruzione if che esegue un particolare blocco del programma a seconda del risultato di una espressione booleana (es. x<10)

- l'istruzione while, ripete l'esecuzione di un blocco di codice (iterazione) finché non diviene vera la condizione passata come argomento (questo tipo di flusso è detto ciclo o loop).

- l'istruzione for, permette di eseguire un blocco di codice un certo numero di volte (iterazione)

Uno dei concetti che va tenuto ben presente quando si opera con le istruzioni appena viste è che i blocchi sono individuati dall'indentazione e non da parentesi graffe come in altri linguaggi. Se una linea di codice è troppo lunga potete andare a capo utilizzando il carattere \ per distribuire il codice su più linee. Le condizioni di controllo dei flussi terminano tutte con i ":"

if a 
print a,"e' minore di", b 
elif a>b: # abbreviazione di else if 
print a,"e' maggiore di", b 
else: 
print a,"e", b ,"sono uguali"​

Potete aggiungere quanti elif volete ma un solo else (facoltativo) che indica cosa va eseguito se nessuna delle precedenti condizioni è soddisfatta. Grazie ad una sequenza if elif elif ... else possiamo creare qualcosa di simile all'istruzione switch presente nel C, ma che non esiste in Python.

L'istruzione if può trovarsi anche annidata all'interno di un'altra istruzione if.

if a==b: 
print a+b 
else: 
if c10: # utilizziamo l'operatore booleano and per combinare due condizioni, in alternativa possiamo scrivere if 10 < c < d: 
print c 
else: 
print d 

a=10 
b=0 
while a>b: 
b+=1 ; d-=3 # l'operatore += incrementa il valore di d mentre l'operatore -= decrementa il valore di d 
else 
print "il risultato e' ", d

l'istruzione while supporta 3 istruzioni addizionali:
- continue, consente di continuare il flusso passando al prossimo passo del ciclo
- break, termina il ciclo
- pass, viene inserito al posto di un blocco di codice non ancora scritto solo per occuparne il posto, va quindi inserito ogni qualvolta in un ciclo if o while è richiesta un'istruzione che non compie nessuna azione.

if a<2 
# da completare 
pass​

Il ciclo for ci consente di svolgere delle iterazioni in una qualsiasi sequenza di oggetti, come ad esempio: tuple, stringhe, liste, ecc. Se non abbiamo una sequenza adatta possiamo utilizzare il metodo range.

for a in range(3): 
print a 
for a in range(0,20,2): # a range vengono passati inizio, fine e passo dell'iterazione 

print a 

for a in "frutta": # ad ogni ciclo a assume il valore del prossimo carattere della stringa 
print a 

lista1 = [4, 7, 56, 78] 
for n in lista1: 
print n 

contatore=0 
for n in lista1: 
if n % 2: # quando n è divisibile per 2 il resto è diverso da 0 per cui la condizione è verificata (true) 
continue 
contatore += n 
else: 
print contatore 

stringa="Haiku è il mio sistema operativo" 
contatore=0 
for a in stringa: 
if a in "aeiou": # valutiamo quante vocali ci sono nella stringa 
contatore += 1 
else: 
print contatore

torna all'indice

Eccezioni

Le eccezioni sono prodotte da errori di varia natura che fanno si che l'interprete si fermi e mostri un messaggio di errore.

>>> 3/0 
Traceback (most recent call last): 
File "", line 1, in ? 
ZeroDivisionError: integer division or modulo by zero ​

Una eccezione può essere gestita con le istruzioni try ed except.

a=3 
try: 
print a/0 
except ZeroDivisionError: <br< print "divisione per zero!" ​

Se non viene sollevata nessuna eccezione viene eseguito fino in fondo il blocco di istruzioni che segue il try mentre non viene eseguito il blocco di istruzioni che segue except. I blocchi except per ogni try possono essere anche più di uno e se except non specifica nessuna eccezione allora verrà utilizzato come default except e quindi eseguito per ogni eccezione sollevata. Si può anche sollevare un'eccezione grazie all'istruzione raise.

a=input("Inserire un numero tra 1 e 4: ") 
if a>4 or a<1 : 
try: 
raise ValueError, "Errore" # raise con parametri 
except: 
print "il numero deve essere compreso tra 1 e 4\n" 
raise # raise senza parametri 
else: 
print a**2​

Se proviamo ad eseguire lo script qui sopra e gli passiamo 5 avremo il seguente risultato:

Inserire un numero tra 1 e 4: 5 

il numero deve essere compreso tra 1 e 4 

Traceback (most recent call last): 

File "/Archivio/Python/esercizi_python/prova.py", line 4, in ? 

raise ValueError, "Errore" 

ValueError: Errore 

$​

In un blocco di istruzioni try.... except può esserci anche l'istruzione else.

a=input("Inserire il numero da dividere: ") 
b=input("Inserire il denominatore: ") 
try: 
c=a/b 
except ZeroDivisionError: 
print "Il denominatore deve essere diverso da zero!" 
else: 
print "Il risultato e': ",c​

torna all'indice