Visualizza wikitesto di Python Lezione 4 Giugno 2008

== Python ==
[http://www.python.it/ Python] è un linguaggio di programmazione [http://it.wikipedia.org/wiki/Interprete_(informatica) interpretato].
Il linuaggio interpretato è simile agli altri linguaggi in circolazione ma, invece di essere trasformato direttamente in codice binario dal meccanismo automatico, viene interpretato da questo e poi mandato all'hardware.
Un linguaggio interpretato non ha bisogno di essere ricompilato: il codice scritto viene interpretato da un interprete a run-time (tempo di esecuzione) e tradotto al volo nel linguaggio macchina.
Quindi i programmi python possono girare su qualsiasi hardware e sistema operativo su cui è stato portato l'interprete. Ovviamente, questa cosa si paga sul tempo di esecuzione pure: l'approccio ha si i suoi vantaggi, ma rispetto a un linguaggio compilato direttamente in linguaggio macchina per creare un eseguibile, python e gli altri liguaggi interpretati risultano essere più lenti.

Esistono vari interpreti: [http://www.python.org Cpython], o classic python, è l'interprete "ufficiale", scritto in C e disponibile per linux, mac e windows.
[http://www.jython.org/Project/ Jython] è un interprete scritto al 100% in Java, e si interfaccia strettamente ai programmi e alla libreria Java, 
[http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython IronPython] è un interprete python che gira sulla piattaforma .NET mentre 
[http://codespeak.net/pypy/dist/pypy/doc/home.html PyPy] è (anche) un interprete python scritto in.. python

La prima riga di ogni script python deve iniziare con #!/usr/bin/env python

il #! del file fa capire al sistema operativo (solo su sistemi posix, quindi unix/linux) che quello non è un file di testo ma un eseguibile da eseguire con l'inteprete python.

== COMMENTI ==

: sono righe che l'interprete salta e non legge 
es: 
    ''# stampa:”hello word”''

== PRINT ==
Lo statement [http://docs.python.org/ref/print.html print] valuta tutte le espressioni presenti e quindi le stampa a video.
L'espressione da valutare può essere anche un semplice numero o una semplice stringa o in generale un oggetto qualsiasi

  >>> print 3
  3
  >>> print "3"
  3
  >>> 

stampa lo stesso valore anche se abbiamo passato prima un intero, poi una stringa.
Questo è normale, perchè il numero "tre" viene rappresentato dal simbolo 3 nel sistema decimale.

Invece
  >>> print 3+2
  5
  >>>
  
otteniamo a video 5: l'inteprete ha valutato l'espressione, ha eseguito la somma e stampato il risultato
Mentre se scriviamo
  >>> print "3+2"
  3+2
  
in quanto abbiamo passato la stringa composta dal carattere 3, dal simbolo + e dal carattere 2.

  >>> print "3"+"2"
  32
Stampa 3 concatenato a 2, ovvero la stringa 32. Uguale all'esempio del 3+2 tra interi, solo che qui ha usato l'opertatore
di addizione tra stringhe, che fa la concatenazione

Le variabili in python non devono essere dichiarate: esistono dalla prima volta in cui gli viene assegnato un valore
>>> messaggio = "Hello, World"
>>> print messaggio
Hello, World

l'interprete valuta l'espressione ''messaggio'' e stampa il suo contenuto

== Errori e Eccezioni ==

Commentando l'assegnamento di messaggio, vediamo che l'interprete genera un errore:


  jdoe@waste-bin ~ $ python
  Python 2.5.2 (r252:60911, May 24 2008, 15:28:31) 
  [GCC 4.2.4 (Gentoo 4.2.4 p1.0)] on linux2
  Type "help", "copyright", "credits" or "license" for more information.
  >>> print messaggio
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  NameError: name 'messaggio' is not defined

NameError è una eccezione. Vedremo più avanti come queste situazioni di errore possono essere ''catturate'' e ''gestite'' appositamente, sia
per tentare di risolvere il problema che per migliorare il feedback che il nostro programma da all'utente. Vedremo anche come
la gestione delle eccezioni è parte della programmazione normale di un programma, ovvero non è sempre legata a una situazione di errore.

Un altro esempio, tendando di sommare mele e pere:
  >>> print 1 + "a"
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: unsupported operand type(s) for +: 'int' and 'str'

Vediamo che a questo giro l'eccezione lanciata è ValueError.

== LE STRINGHE ==
Gli oggetti di tipo stringa supportano svariati metodi e proprietà. E' da notare che le stringhe sono immutabili.
Se una stringa viene dichiarata la seconda volta, quella precedente viene buttata, non viene modificata per fare spazio alla nuova.
    ''messaggio=”ciao”
    messaggio=”ciao mondo”
    print messaggio''
stampa
    '' ciao mondo''

In Python non si possono sommare cose diverse, o meglio, lo posso fare solo se è definita una conversione tra i due tipo.
Le stringhe supportano anche alcuni operatori base:
    ''print messaggio*2'' 
l'esecuzione darà
    ''messaggio messaggio
''
esempio:
     ''Print “ciao”+” mondo”''
lo eseguo e mi darà:
    '' ciao mondo''

== '''Funzione DIR''' ==


    ''messaggio=”ciao”
    dir(messaggio)''
a questo punto il programma da una serie di caratteri incomprensibili.
Praticamente dà i '''metodi''' che suporta la stringa messaggio.

== I '''metodi''' ==
sono operazioni che i vari oggetti supportano.
alcuni metodi, vedendo con la funzione dir(), iniziano e terminano con __ . Tali metodi, chiamati metodi speciali, non dovrebbero essere chiamati direttamente,
senza che ci sia una ragione specifica per farlo (ovvero: sapete quello che state facendo). In generale possono essere pensati come privati o riservati, anche se non 
essendoci controlli di accesso come in altri linguaggi (public private del java o del c++ ad esempio) nessuno vieta di chiamarli.

Ad esempio, il metodo __add__ delle stringhe è chiamato quando si fa la somma di due stringhe.
 ''"ciao" + " mondo"'' 
chiama in realtà 
 ''"ciao".__add__(" mondo")''

''__ doc__'' ce l'hanno tutti gli oggetti (stringhe, interi...), e contiene una stringa di documentazione dell'oggetto. 

i metodi che iniziano per is servono per controllare se una certa proprietà della stringa in esame è vera:
es: 
    ''messaggio.isalpha()''
mi dice se messaggio è o meno alfanumerico (composto solo da numeri e cifre, senza spazi, tab, ritorno carrello ecc ecc).
isalpha è un oggetto quindi ha le proprietà doc .
se io scrivo
    ''messaggio.isalpha.__doc__''
mi dice che fa.

es:
    '' messaggio=”gigio”
    messaggio2= messaggio.upper()''

es:
''TYPE(3)''
mi dice che variabile  è. se è intero o stringa oppure un complesso, un float o un tipo definito dall'utente.
Se io scrivo ''DIR(3)''
mi da tutta la lista dei metodi e delle proprietà degli int (dato che 3 è in intero)
'''

Esistono stringhe, interi, float (numeri con virgola)booleano (che ha due valori, vero o falso, True e False)e i vari contenitori:

== '''LE LISTE''' ==

es. lo scaffale ha I pc, I pc sono oggetti (pc1,pc2...).Se voglio uno scaffale di pc senza dare I nomi a tutti gli oggetti, definisco lo scaffale.
Lo scaffale si chiama''' Lista'''  .si usano le parentesi quadre con oggetti separati da virgola
es.    '' a = [ “pc1” , “schermo rotto” , 2]
dir (scaffale)''
da la lista dei metodi, da qui si capisce che la lista è un oggetto.
Ad esempio:
    ''a.append(“4”)''
aggiunge alla lista a la stringa "4".
La lista, a differenza delle stringhe, è un oggetto mutabile, quindi la funzione append di fatto manipola la lista esistente per far spazio al nuovo oggetto da inserir

Se faccio     ''print (“a”)''
mi da la lista degli oggetti più "4"

Da notare che

  >>> mialista = []
  >>> mialista
  []
  >>> dir(a)
  ['__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']

Da qui vediamo che il risultato della funziona dir su una lista ritorna .. una lista.

Vediamo come una lista può contenere qualsiasi oggetto, anche una lista o una tupla (vedi sotto)
  >>> mialista = [ (1,1,1), [2,2,2], 3, ([4,4,4],(4,4,4))]

Questa è una lista di 4 oggetti, uno dei quali è una tupla, il secondo è una lista, il terzo un intero, il quarto una tupla contenente a sua volta una lista e una tupla.

== '''TUPLE''' ==

simile a una lista, è un contenitore di elementi. La tupla non è mutabile, per cui se definita con 4 oggetti non potrà mai contenerne 5 come non si può cambiare il
valore a uno degli oggetti

  >>> miatupla = ( 1, 2,  "a" ,(1,2,3))
  >>> miatupla
  (1, 2, 'a', (1, 2, 3))
  >>> len(miatupla)
  4
  
Dall'esempio vediamo come una tupla possa contenere al suo interno oggetti di vario tipo (tra cui una tupla stessa): a tal proposito
si vede che la lunghezza della tupla è 4 , infatti la tupla in essa contenuta - e che a sua volta contiene 3 oggetti - viene considerata
un unico oggetto (perchè difatto lo è.)

Vediamo come si può accedere posizionalmente agli elementi della tupla (l'indice parte da zero)
  >>> miatupla[0] # primo elemento
  1
  >>> miatupla[2] # terzo elemento
  'a'
  >>> primo, secondo, terzo, quarto = miatupla  # scompatta la tupla in 4 variabili
  >>> terzo
  'a'
  >>> quarto
  (1, 2, 3)

Inoltre, tentare di assegnare un nuovo valore a un elemento della tupla genera una eccezione
  >>> miatupla[0] = 3
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: 'tuple' object does not support item assignment
  >>>

== '''DIZIONARI''' ==

il dizionario si definisce con le parentesi graffe {chiave:valore, chiave:valore}
a[chiave]
da il valore associato alla chiave.

Dizionari liste e tuple sono dele sequenze e sono iterable e si possono quindi scorrere.

== '''If elif else''' ==

  if condizione :
      ''statement1''
      ''statement2''
  ''statement3''

Python supporta o tab o spazio, si decide quanti tab o spazi alla prima indentazione.
Di solito si usa 4 spazi.
Non c'è la graffa in pyton o I begin o gli end, si chiude e si apre un blocco indentando
Nell'esempio precedente, ''statement1'' e ''statement2'' vengono eseguiti solo se la condizione è vera, 
mentre ''statement3'' viene eseguito sempre.


Esempio:
  >>> a=3
  >>> b=1
  >>> if a > b:
  ...     print ("a è maggiore di b")
  ... elif a == b:
  ...     print ("a è uguale a b")
  ... else:
  ...     print ("a è minore di b")
  ... 
  a è maggiore di b
  >>> 

in questo programma definisco due valori, a e b.
Chiedo al programma se a è maggiore di b di scrivere : a è maggiore di b, se a è uguale a b di scrivere che a è uguale a b e in tutte le altre condizioni (else) di scrivere che a è minore di b.

	'''2.is, is not or, and,!='''
  >>> if a is 1:
  ...     print (“si”)
  >>> elif a is not 1:
  ...     print (“no”)
  no
  >>> if a is 1 and b is 3:
  ...     print (“si”)
  >>> if a is 3 or b is 3:
  ...     print (“okkei”)
  okkei

'''!= è il diverso.'''

Oltre ai classici test a volte siamo interessati a vedere se un particolare elemento è presente in una tupla, lista o dizionario

  >>> miodizionario = { 'primo': 1, 'secondo': "golem", 'terzo': [1,2,3] }
  >>> if "primo" in miodizionario: 
  ...     print 'yeah'
  ... 
  yeah
  >>>

Vediamo come l'operatore ''in'' cerca nelle chiavi del dizionario
Analogamente possiamo farlo nelle liste

  >>> mialista = [1,2,3]
  >>> if 4 not in mialista:
  ...     print "non c'è"
  ... 
  non c'è
  >>>

L'esempio precedente mostra anche che l'operazione può essere negata usando ''not''

== '''append, insert''' ==

    ''a.append(“4”)''
aggiunge alla lista a il 4.
Se faccio print (“a”)
mi da la lista degli oggetti più il 4.

con '''insert''' devo inserire anche la posizione
    ''a.insert(2,34)''
mette il 34 in posizione 2



== '''for''' ==

specifica un ciclo, fa le cose tante volte fino ad una condizione.
For variabile in una sequenza di qualche tipo.

  >>> miatupla = ( 1, 2,  "a" ,(1,2,3))
  >>> for variabile in miatupla:
  ...     print "nella tupla: ",
  ...     print variabile
  ... 
  nella tupla:  1
  nella tupla:  2
  nella tupla:  a
  nella tupla:  (1, 2, 3)
  >>>

In caso volessi, nel ciclo, sapere "a che punto" della tupla (o della sequenza, in generale a che punto dell' '''iterable''') sono:

  >>> for indice, variabile in enumerate(miatupla):
  ...     print "elemento",
  ...     print indice
  ...     print variabile
  ... 
  elemento 0
  1
  elemento 1
  2
  elemento 2
  a
  elemento 3
  (1, 2, 3)
  >>> 

Iterando su un dizionario, che è un iterable, vengono resistuite le chiave, non i valori.

  >>> miodizionario = { 'primo': 1, 'secondo': "golem", 'terzo': [1,2,3] }
  >>> for chiave in miodizionario:
  ...     print chiave,
  ...     print ":",
  ...     print miodizionario[chiave]
  ... 
  terzo : [1, 2, 3]
  primo : 1
  secondo : golem

Vediamo come gli elementi del dizionario non ci vengono resistuiti in un particolare ordine, anzi, non ci soono garanzie a riguardo

  >>> dir (miodizionario)
  ['__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']

se vogliamo iterare su i valori e non sulle chiavi dobbiamo usare il metodo '''itervalues''' degli oggetti dizionario:
  >>> for valore in  miodizionario.itervalues():
  ...     print valore
  ... 
  [1, 2, 3]
  1
  golem
  >>>

== '''xrange''' ==

xrange è un iterable di dieci elementi con il primo valore uguale a 0 .E' una lista ma non ha le proprietà di una lista.
se io voglio fare un for da uno a dieci (cioè la somma da uno a 10)

es:     ''for I xrange(10)
               print I''
lui stampa
''1
2
3
4
5
6
7
8
9
10''

== '''range''' ==

ha la stessa funzione di xrange, ovvero servire da iterable su N numeri, però ritorna non un oggetto di tipo xrange ma una lista.
E' più lento di xrange

  >>> print range(10)
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>>

== '''len''' ==

    ''len (a)''
da la lunghezza della stringa

== '''enumerate''' ==

se io ho una lista di tre elmenti
''a=[“ciao”,”bel”, “mondo”]''

''for I, elem in enumerate(a):
     print str(I) + “:” + elem
''
da la posizione corrente di ogni elemento.
''0:ciao
1:bel
2:mondo''


== '''raw_input''' ==

dai il valore.
''Base= raw_input (“inserisce la base:”)
esponente=raw_input (“inserisci l'/ esponente”)''

ti chiede il valore di base ed esponente.

== '''Int''' ==

forza il fatto che quel valore sia un intero.
''
Es:base=int(base)
  result=int(result)''


== '''UPPER,LOWER,CAPITALIZE''' ==

'''capitalize''' è un comando che sulla la stringa su cui viene applicato ,prende la prima lettera dopo gli spazi e ci mette la maiuscola

es: 
    ''print “ciao mondo”.capitalize()''
    ''Ciao mondo''
es: 
    ''print “ciao mondo”.title()
    Ciao Mondo''

'''LOWER:''' prende la striga e emette tutto minuscolo
'''UPPER:''' il contrario di lower

== '''ESEMPIO DELLA SERATA:''' ==


Calcolo di una potenza.

    ''
    base= raw_input (“inserisce la base:”)
    esponente=raw_input ('inserisci l\' esponente')

    base=int(base)
    result=int(result)

    result=1
    for i in xrange(esponente):
         result = result * base
    print result''

il [http://docs.python.org/lib/built-in-funcs.html built-in] int() è necessario, dato che tutto quello che proviene dalla tastiera viene acquisito da raw_input() come stringa. Dato che dobbiamo usarli come interi, occorre effettuare un cast, ovvero
una trasformazione di tipo, da stringa a intero.
E' interessante notare che int() non cerca di fare i miracoli: provate a vedere cosa succede se cercate di convertire "awlerorj" in int!

[[Category: Howto]]