Python Guido van Rossum I Monty Python Giovanni Aglialoro slide tratte anche dalle presentazioni di Marco Barisione, Antonio Cuni, Marco Tozzi. Guido van Rossum I Monty Python www.python.org

Python: introduzione È un linguaggio di programmazione: interpretato di altissimo livello semplice da usare potente e produttivo permette programm. procedurale e a oggetti ottimo anche come primo linguaggio (molto simile allo pseudocodice) Inoltre è open source (www.python.org) è multipiattaforma è facilmente integrabile con C/C++ e Java

Python: introduzione (2) È veramente usato da qualcuno? in Linux e altre distribuzioni tool di configurazione grafici, applicazioni varie per costruire siti web: CMS, framework Django, Zope NASA www.google.com Industrial Light and Magic (quelli che fanno gli effetti speciali per Star Wars ...) … e molti altri

Python: introduzione (3) manuali, documentazione, esercizi www.python.org (ove scaricare la versione 2.7.11 …) http://www.python.it/doc/Howtothink/HowToThink_ITA.pdf http://it.diveintopython.net/ http://www.python.it/doc/articoli/instpy-0.html http://codex.altervista.org/corsopython/corsopython.html http://www.slideshare.net/eugenio1958/manuale-pythonv2 http://www.pierotofy.it/pages/sorgenti/Python/Python_p1/

Python: introduzione (4) interpretati Linguaggi (semplificando…) compilati (Basic, Perl, PHP, Python, Ruby, Java) (C/C++, Pascal, Delphi, Java) codice sorgente estrazione dell’istruzione traduzione (interpretazione) esecuzione in ling. macchina codice sorgente traduzione del programma esecuzione del programma in ling. macchina

Python: l’interprete interattivo Possiamo usare l’interprete interattivo come calcolatrice: >>> (6+3) / 2 4 >>> 3/2 1 >>> 3/2.0 1.5 Per usare una variabile basta assegnarle un valore; c’e‘ anche l’operatore ** che rappresenta l’elevamento a potenza: >>> x = 3+5 >>> x 8 >>> x**2 64

alcune caratteristiche per delimitare i cicli non usiamo né { } né begin/end: il blocco e‘ delimitato solo ed esclusivamente dall’ indentazione. assegnamento multiplo per delimitare le istruzioni non serve il ; sembrerebbe che Python non abbia tipi in realtà è strongly typed: Ogni oggetto ha un tipo che non può cambiare mai Le variabili (references) sono come delle “etichette” che si “appiccicano” agli oggetti

input e output Si può formattare l’output come il c: >>> x=18; y=15 >>> print "x=%d y=%d\n" % (x,y) x=18 y=15 Per leggere un numero si usa input() >>> x=input(‘Scrivi un numero: ’) darà errore se non si inserisce un numero. Per leggere una stringa si usa raw_input() >>> x=raw_input(‘Scrivi il tuo nome: ’)

variabili I nomi di variabili sono composti da lettere, numeri e underscore, il primo carattere non può essere un numero (come in C) Sono validi: “x” , “ciao” , “x13” , “x1_y” , “_” , “_ciao12” Non sono validi: “1x” , “x-y” , “$a” , “àñÿô” Le variabili non devono essere dichiarate (tipizzazione dinamica) Una variabile non può essere utilizzata prima che le venga assegnato un valore Ogni variabile può riferirsi ad un oggetto di qualsiasi tipo

moduli Per importare moduli (funzioni matematiche e altro): import math import random ... Per usarli: math.sqrt(2), math.log(5), random.choice(‘ATCG’), random.randint(1,50) ecc.

if La sintassi di “if” è: a=float(input("dividendo = ")) if condizione: ... elif condizione_altern.: else: Sia la parte “elif” sia la parte “else” sono facoltative Può esserci un numero qualsiasi di “elif” Non sono necessarie le parentesi intorno all’espresisone booleana Non sono possibili assegnamenti all’interno della condizione a=float(input("dividendo = ")) b=float(input("divisore = ")) quoz=a/b resto=a%b if resto!=0: print"risultato = ",int(quoz) print"resto = ",int(resto) else: print"resto = 0"

for for i in range(-8, 20, 2): print i, i*i one_to_ten = range(1,11) Il costrutto for sembra molto limitato perché, a differenza di altri linguaggi di programmazione, permette di operare solamente sulle liste. In realtà questa piccola limitazione viene facilmente superata utilizzando la funzione range Tutto quello che si fa con i cicli for potete farlo anche con while ma grazie ai cicli for è più semplice scorrere tra tutti gli elementi di una lista o compiere un'azione un determinato numero di volte one_to_ten = range(1,11) for count in one_to_ten: print count for i in range(-8, 20, 2): print i, i*i

while (c’è anche assegnamento multiplo e funzione) es.: calcoliamo i numeri di Fibonacci # Serie di Fibonacci: # Ogni numero e‘ la somma # dei due numeri precedenti a, b = 0, 1 while b < 1000: print b a, b = b, a+b 1 2 3 5 8 13 # Fibonacci series up to n # def fib(n): a,b = 0,1 while a<n: print a, a,b = b,a+b fib(5000)

Python: manipolazione di stringhe Per indicare una stringa bisogna racchiuderla tra virgolette a differenza di molti altri linguaggi, possiamo usare sia le virgolette singole che quelle doppie >>> print "ciao" ciao >>> print ’Ho detto "ciao"’ Ho detto "ciao" >>> print "ecco l’apice" ecco l’apice Possiamo creare delle stringhe multilinea usando le triple virgolette (sia ’’’ che """): >>> frase = """questa e‘ una ... stringa che occupa ... tre righe""" >>> print frase questa e‘ una stringa che occupa tre righe

Python: stringhe (2) >>> print ’ciao ’ + ’ciao’ Possiamo concatenare due stringhe usando l’operatore +: >>> print ’ciao ’ + ’ciao’ ciao ciao Possiamo ripetere una stringa usando l’operatore *: >>> print ’-’ * 20 -------------------- >>> print ’ciao ’ * 3 ciao ciao ciao Per accedere ai singoli caratteri di una stringa, usiamo l’operatore []; l’indice puo‘ anche essere negativo: >>> ’ciao’[0] ’c’ >>> ’ciao’[1] ’i’ >>> ’ciao’[-1] ’o’

Python: stringhe(3) Le stringhe in Python, come in Java, sono immutabili: non e‘ possibile assegnare un nuovo valore ai singoli caratteri. Sottostringhe e slices: usiamo una variante dell’operatore [] chiamata slice notation: >>> ’una stringa’[0:3] ’una’ >>> ’una stringa’[1:-1] ’na string’

Python: slices mystring[i:j] restituisce tutti i caratteri compresi tra gli indici i (compreso) e j (escluso): Se il primo indice viene omesso, la slice parte dal primo carattere della stringa: >>> ’una stringa’[:3] ’una’ Se il secondo indice viene omesso, la slice arriva sino all’ulitmo carattere della stringa: >>> ’una stringa’[4:] ’stringa’

Python: metodi delle stringhe Le stringhe sono oggetti a tutti gli effetti. Alcuni esempi: >>> ’Ciao’.upper() ’CIAO’ >>> ’Ciao’.lower() ’ciao’ >>> ’ciao anto’.replace(’anto’, ’marco’) ’ciao marco’ Per ottenere la lunghezza c’è la funzione len(): >>> len(’ciao’) 4 Attenzione! len() è una funzione, si applica anche ad altre sequenze

Python: liste Una lista e‘ un oggetto composto simile per molti versi agli array presenti in altri linguaggi. Possiamo creare una lista racchiudendone gli elementi tra parentesi quadre e separandoli con una virgola (gli elementi possono anche avere tipi diversi): >>> mylist = [0, 100, ’ciao’, 15.4] >>> mylist [0, 100, ’ciao’, 15.4] Per accedere agli elementi di una lista usiamo la stessa notazione usata per le stringhe: >>> mylist[1] 100 >>> mylist[:2] [0, 100]

Python: liste (2) Le liste sono oggetti mutabili: possiamo modificarne la composizione >>> mylist[1] = ’salve’ >>> mylist [0, ’salve’, ’ciao’, 15.4] Come per le stringhe, anche le liste hanno dei metodi: >>> mylist.append(1) [0, ’salve’, ’ciao’, 15.4, 1]

Python: liste (3) Per aggiungere un elemento in una posizione qualunque, usiamo il metodo insert(): >>> mylist.insert(1, 100) >>> mylist [0, 100, ’salve’, ’ciao’, 15.4, 1] Possiamo ordinare una lista usando il metodo sort(), ed invertirla con il metodo reverse(): >>> mylist = [1, 5, 7, 4, 10] >>> mylist.sort() [1, 4, 5, 7, 10] >>> mylist.reverse() [10, 7, 5, 4, 1]

Python: tuple Un altro tipo di sequenza questa volta immutabile In genere sono racchiuse tra parentesi tonde: >>> mytuple = (1, ’ciao’, 100) >>> mytuple (1, ’ciao’, 100) Possiamo usare una tupla quando in altri linguaggi siamo costretti a ricorrere a costrutti più complessi (es: struct del C) es: >>> mypoint = (4, 6) possiamo assegnare in un sol colpo ogni elemento ad una variabile diversa: >>> mypoint (4, 6) >>> x, y = mypoint >>> x 4 >>> y 6

Python: dizionari Python offre anche un supporto nativo per le hash table, chiamate dizionari. espresso come sequenza di coppie chiave:valore racchiuse tra parentesi graffe e separate da virgole: >>> voti = {’programmazione’: 18, ’LP’: 26, ’Implementazione’: 30} >>> voti {’programmazione’: 18, ’Implementazione’: 30, ’LP’: 26} per accedere ai singoli elementi: >>> voti[’LP’] 26 >>> voti[’Info Gen’] = 20 {’programmazione’: 18, ’Implementazione’: 30, ’Info Gen’: 20, ’LP’: 26}

Python funzioni La keyword def introduce una definizione di funzione … Proviamo a scrivere una funzione che calcoli i numeri di fibonacci: >>>def fib(n): ... “””Stampa la serie di Fibonacci fino a n””” ... a, b = 0, 1 ... while b < n: ... print b, ... a, b = b, a+b ... >>> fib(2000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 Il primo statement può essere una docstring usata da tools che producono documentazione

Python funzioni (2) Gli argomenti sono passati tramite call by value (value è un object reference quindi call by object reference) L’esecuzione di una funzione introduce una nuova symbol table per le variabili locali (look up: local,global,built-in table) Function name è introdotto nella symbol table corrente Il nome ha un tipo riconosciuto come user-defined function e un valore Può essere assegnato ad un altro nome (es: rinomina) >>> fib <function object at 10042ed0> >>> f = fib >>> f(100) 1 1 2 3 5 8 13 21 34 55 89

Python funzioni (3) Si possono specificare argomenti di default, quindi le chiamate possono anche non specificarli tutti: >>> def info(cognome, nome='Marco'): ... print cognome, nome ... >>> info('Tozzi') Tozzi Marco Possono essere invocate usando gli argomenti come keywords : >>> info(cognome='Cuni', nome='Antonio') Cuni Antonio Funzioni possono avere una lista arbitraria di argomenti: def foo(*arg, **keywords): * arg è una tupla contenente i parametri posizionali ** keywords è un dizionario dei keyword arguments a cui non corrisponde un parametro formale

Python Classi Definizione: class ClassName: <statement-1> … <statement-N> Successivamente ad una definizione di classe si crea un class object I class object supportano due operazioni: Riferimento agli attributi: >>> class MyClass: ... i = 12345 ... def f(self): ... return 'hello world' ... >>> MyClass.i 12345 >>> MyClass.f <unbound method MyClass.f>

Python Classi (2) Instanziazione (come una chiamata di funzione senza parametri che restituisce un’istanza): x = MyClass() Per inserire uno stato iniziale bisogna definire il metodo __init__: >>> class Complex: ... def __init__(self, realpart, imagpart): ... self.r = realpart ... self.i = imagpart ... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5) Gli attributi sono creati la prima volta che gli viene assegnato un valore La chiamata di metodo passa implicitamente l’istanza dell’oggetto come primo argomento: x.f() è perfettamente equivalente a MyClass.f(x)

Python Class Inheritance Sintassi: class DerivedClassName(BaseClassName): <statement-1> … <statement-N> Se BaseClass non è nello stesso modulo: class DerivedClassName(modname.BaseClassName): super(type,[object-or-type]) ritorna la superclasse di type: class C(B): def meth(self, arg): super(C, self).meth(arg) Supporta ereditarietà multipla: class DerivedClassName(Base1, Base2, Base3): risoluzione attributi depht-first, left-to-right