# BINOMIALE - LEZIONE 2

# use another module in this directory from fattoriale import fatt # binomial calculation: suppose 0 <= k <= n def binom(n, k): return fatt(n) / fatt(k) / fatt(n - k) # to execute the program we need to provide a specific section # if __name__ == "__main__": # to return success (0) or failure (1) to the caller import sys n = int(input("Inserisci n: ")) k = int(input("Inserisci k: ")) if k > n: print("n deve essere maggiore o uguale a k!") sys.exit(1) # failure else: print("C(", n , ",", k, ") =" , binom(n, k)) sys.exit(0) # ok

BINSEARCH - LEZIONE 2
# This function finds the integer value value inside the vector def search(vector, value): size = len(vector) minidx = 0 cyclecnt = 0 maxidx = size - 1 # important! test with <= , < is not enough while minidx <= maxidx: cyclecnt = cyclecnt + 1 # calculate the middle index middleidx = (minidx + maxidx) // 2 # look for the value in the middle index if vector[middleidx] == value: # note: in Python 2.x print used to work without braces print('Found ', value, ' at index ', middleidx, 'cycle ', cyclecnt) # done, leave the loop break else: # next cycle, if vector[middleidx] < value: minidx = middleidx + 1 else: maxidx = middleidx - 1 # by adding this code at the end of your module you can make the file usable as a script as well as an # importable module, because the code that parses the command line only runs if the module is executed as the “main” file. # If the module is imported, the code is not run.

if __name__ == "__main__": # define a vector aimed at containing integers: vect = [] # ask the user the vector of integers v_in = input("Inserisci gli elementi del vettore, separati da spazi") string_vector = v_in.split(' ') for i in range(0, len(string_vector)): vect.append(int(string_vector[i])) # ask the user the value to look for: value = int(input("Inserisci il valore da cercare: ")) print("Searching ", value, " inside ", vect) # ready to call search() # call the function. Note that the argument name in the invocation hasn't to be the same as the parameter name search(vect, value)

FATTORIALE - LEZIONE 2
def fatt(n): i=1 nfatt = 1 while i <= n: nfatt = nfatt * i i=i+1 print(n , "fattoriale vale", nfatt) print(str(n) + " fattoriale vale " + str(nfatt)) print("%d fattoriale vale %d" % (n, nfatt)) return nfatt def fatt_range(n): nfatt = 1 for i in range(1, n + 1): nfatt = nfatt * i return nfatt

0 cnt = 0 # cnt < n ? while cnt < n: # y <-.y * x y=y*x cnt = cnt + 1 return y .LEZIONE 2 def mypow(): """Questa funzione richiede di inserire la base.POTENZA .1 y=1 # cnt <-. l'esponente e restituisce come valore di ritorno la potenza """ # input x x = input("Inserisci la base: ") #input x n = input("Inserisci l'esponente: ") # conversione da stringa a intero: x = int(x) n = int(n) # y <-.

x^7/7! +. # # Fermandosi al grado settimo.. la serie di Taylor approssima bene il seno #per un periodo # compreso tra -PI e PI # def sen(x..LEZIONE 2 # importiamo la funzione "valore assoluto" dalla libreria math di python from math import * # importiamo due moduli precedentemente scritti da noi (devono risiedere #nella medesima # cartella in cui si trova questo file) # from mypower import mypow from fattoriale import fact # calcola e restituisce il seno di x in un intorno dell'origine. precisione): # memorizza il valore del seno via via che viene computato senx = 0 # grado del polinomio (e fattoriale al denominatore) n=1 segno = 1 itcnt = 0 termine_corrente = 1 while(abs(termine_corrente) > precisione): itcnt = itcnt + 1 .x^3/3! + x^5/5! ..SENO . # # dove la scrittura x^3 indica x elevato al cubo e cosi` via. utilizzando lo #sviluppo in serie di Taylor # # sin(x) = x .

.. n-2.. n) / fact(n) senx = senx + termine_corrente # 1. n=n+2 # i segni si alternano. "per la precisione richiesta") return senx . segno = -segno print("iteraz ".termine_corrente = segno * mypow(x.. 3. itcnt) print("La funzione sen ha richiesto un polinomio di grado". 7. 5.

NOTE: index starts from 0 index = 0 # length of the passed vector size = len(vett) # NOTE: index < size. Creates a function object and #assigns it to # variable 'search'. NOT index <= size! ==> range is from 0 to #####size .SEQSEARCH . local scope. val): # boolean found = False # index in vector used in search. "non trovato") .LEZIONE 2 # The def statement makes new functions. #where # assigned names are local to the function call by default. val .1. Each call to the function generates a new. as in C language while index < size: if vett[index] == val: found = True # leave loop to speed up computation break # don't forget to increment index! index = index + 1 if found: print("Trovato". index) else: print("Valore". val. "in posizione". # # Arguments are passed by object reference (see function exercise) # # 'vett' and 'val' are the formal parameters def search(vett.

LEZIONE 2 # calculates the power with base base and exponent exp def mypow(base. exp): n=1 cnt = 0 # while cnt < exp: n = n * base cnt = cnt + 1 return n .MYPOW .

BASE2TO10 .1 while i >= 0: # accumulo il valore in base 10 in dec # moltiplicando 1 oppure 0 per 2 elevato alla i dec = dec + fattore * (ord(bin[i]) ... dec = 0 fattore = 1 i = len(bin) .ord('0')) fattore = fattore * 2 i=i-1 return dec .LEZIONE 3 def converti(bin): # scrivere controllo validita' dell'ingresso.

len(bin)): if bin[i] != '0' and bin[i] != '1': return "Il numero dato in ingresso non e' valido!" # 1..1 # N.LEZIONE 3 def complementa(bin): compl = "" # controlliamo che il numero sia valido for i in range(0. poi inverto tutti i bit rimanenti i=i-1 while i >= 0: if bin[i] == '0': compl = '1' + compl else: compl = '0' + compl i=i-1 return compl .1! while i >= 0 and bin[i] != '1': compl = str(bin[i]) + compl i=i-1 # i e' posizionato nella cella dove ho trovato il primo 1 # copio il primo uno. individuo il primo 1 a partire dalla fine del numero i = len(bin) .B: len .COMPLEMENTO2 .. compl = str(bin[i]) + compl # 2.

.FATTORIPRIMI .) def primo(n): """Restituisce True se il numero e` primo.append(i) return primi def scomponi(n): """Scompone il numero n in fattori primi. ceil(sqrt(n + 1))): if n % i == 0: return False return True def numeriprimi(n): """Restituisce una lista di interi che contiene i numeri primi minori del numero n passato in ingresso """ primi = [ ] #n+1 for i in range(2. che sono restituiti in una lista""" fattprimi = numeriprimi(n) .LEZIONE 3 from math import floor.. ceil # ogni numero non puo' avere piu' di un divisore grande quanto la sua #radice # per cui posso cercare un divisore fino alla radice quadrata del numero # # NOTA: devo usare ceil() e la radice deve essere calcolata per n+1 # (si pensi al quadrato perfetto 25. False altrimenti""" for i in range(2. n + 1): if primo(i): primi. sqrt.

.# # Alcune print qua e la` aiutano a capire cosa succede nel programma #se abbiamo dubbi. "i". n. q. ":". fattprimi) fatt = [ ] q=n i=0 while q > 1: if q % fattprimi[i] == 0: # q divisibile per fattore primo in #posizione i q = q / fattprimi[i] # divido fatt. # # print("Possibili fattori primi di ".append(fattprimi[i]) else: i=i+1 # print("q".. i) return fatt .

m1 print("MCD(" + str(n) + ".n1 else: n1 = n1 . membro a destra dell'operatore and while m1 != n1 and m1 != 0: if m1 > n1: m1 = m1 . m): # documentazione che viene mostrata con help() dalla console python """Questa funzione calcola il Massimo Comune Divisore utilizzando l'algoritmo di Euclide""" n1 = n m1 = m # gestire caso n == 0! # il caso m == 0 e` gestito all'interno del while. return n1 .D." + str(m) + ") vale". con l'algoritmo di Euclide def MCD(n.MCD .LEZIONE 3 # calcolo del M.C. n1).

altrimenti n #sara` il # dividendo nella prossima iterazione n=t return n . se i due numeri sono primi tra loro. n contiene l'MCD. # while m != 0: # salvo m in t temporaneamente (m contiene l'ultimo resto # ####### #calcolato nel ciclo precedente # o il secondo valore passato in MCD se e` la prima volta che ######## #entro nel ciclo) t=m m = n % m # il resto n % m e` sempre minore di m # # # copio in n il valore temporaneo salvato nella prima istruzione #del ciclo. # se m a questo punto vale zero. li scambio if(n < m): tmp = m m=n n = tmp # ad un certo punto il resto sara` zero. m): # se n e` minore di m. al limite quando calcolo il #### # resto della divisione # per uno.MCD_RESTO .LEZIONE 3 def MCD(n.

LEZIONE 3 from math import fabs def radice(n.RADICE . precisione): n1 = n n2 = 1 while fabs(n1 .n2) > precisione: n1 = (n1 + n2)/2 n2 = n / n1 return n1 .

LEZIONE 4 def converti(dieci): b2 = "" while dieci > 0: resto = dieci % 2 dieci = dieci >> 1 # divide per 2 b2 = str(resto) + b2 return int(b2) .BASE10TO2.

locazione in cui effettuero` il confronto m = (stop + start) // 2 # while stop >= start and v[m] != s: print(m. start.LEZIONE 4 # Ricerca binaria in un vettore _ordinato_ # Svolto a lezione il giorno 12 novembre 2012 # def search(v. stop] # per il confronto all'iterazione successiva # m = (stop + start) // 2 # print(m. stop) if s > v[m]: start = m + 1 # cerchero` oltre m else: stop = m . start.1 # meta` dell'intervallo. s): size = len(v) # intervallo all'interno del quale cercare il valore start = 0 stop = size .1 # cerchero` prima di m # ricalcolo la meta` del nuovo intervallo [start. stop) # se stop >= start.BINSEARCH. allora il ciclo while sopra e` terminato # a causa di v[m] == s e questo significa che ho trovato il # valore # if stop >= start: print("Trovato") # altrimenti il ciclo while e` terminato a causa di stop < start .

# e quindi il valore non e` stato trovato else: print("Non trovato") .

size): niter = niter + 1 .BUBBLESORT . size . # After each swap operation. it stores the index of the last position that has # been swapped # so that the outer cycle can stop earlier.1): niter = niter + 1 if v[i] > v[i + 1]: tmp = v[i] v[i] = v[i + 1] v[i + 1] = tmp # size = size . niter . "iterations to complete") return v # Optimization.LEZIONE 4 def busort(v): """Bubble sort algorithm implementation""" size = len(v) # number of necessary iterations niter = 0 while size > 1: for i in range(0.1 print("busort() needed".1 for i in range(0. def busort2(v): size = len(v) # number of necessary iterations niter = 0 while size > 1: size = size .

if v[i] > v[i + 1]: tmp = v[i] v[i] = v[i + 1] v[i + 1] = tmp # store last swapped index size = i + 1 # print("busort2() needed". "iterations to complete") return v . niter .

LEZIONE 4 # ordina il vettore v tramite due cicli annidati. ma algoritmo molto semplice.ORDINA_VETT . # Inefficiente. len(v)): for j in range(0. len(v)): if v[j] > v[i]: tmp = v[i] v[i] = v [j] v[j] = tmp . def ordina(v): for i in range(0.

""" # calcolo delta: delta = b ** 2 . long # la funzione complex accetta in ingresso la parte reale e quella #immaginaria.RADICI . la funzione restituisce una tupla contenente le radici dell'equazione di secondo grado associata. # return (complex(re. # accanto a int. im).sqrt(delta)) / (2 * a)) else: # radici complesse coniugate: re = -b / (2 * a) im = sqrt(-delta) / (2 * a) # # Python contempla i numeri complessi (complex) tra i tipi # #numerici. (-b . float. # Restituisce il numero complesso associato alla parte reale e # #immaginaria. b.4 * a * c if delta == 0: # radici coincidenti: return (-b / (2 * a).LEZIONE 4 from math import sqrt def radici(a. c): """Dati a. -im)) # # # # . b e c. -b / (2 * a)) elif delta > 0: # radici reali distinte: return ( (-b + sqrt(delta)) / (2 * a). complex(re.

NOTE: index starts from 0 index = 0 # length of the passed vector size = len(vett) # NOTE: index < size.LEZIONE 4 # The def statement makes new functions.1. index) else: print("Valore". # # Arguments are passed by assignment (see function exercise) # # 'vett' and 'val' are the formal parameters def search(vett. "non trovato") # . Creates a function object and #assigns it to # variable 'search'. as in C language while index < size and found == False: if vett[index] == val: found = True # don't forget to increment index! index = index + 1 if found: print("Trovato". val. #where # assigned names are local to the function call by default. "in posizione". val . NOT index <= size! ==> range is from 0 to # #size .SEQSEARCH . val): """Search a value val inside a vector vett""" # boolean found = False # index in vector used in search. local scope. Each call to the function generates a new.

end="") r=r-1 print("") # a capo for i in range(ord('0'). maxord): # stampa la matrice dall'alto verso il basso */ r = maxord c=0 while r >= 0: for c in range(0.ord('0')): print(m[r][c]. maxcols): row.ord('0') maxord = 0 # massimo valore dell'ordinata # creo e popolo la matrice di soli spazi matrix = [ ] row = [ ] # preparo una riga di maxcols elementi for c in range(0. end="") print("") # a capo def istover(astring): maxrows = len(astring) maxcols = ord('z') .ISTOVER .append(' ') . ord('z') .LEZIONE 5 # seconda versione di istover che stampa tutti i valori delle # ascisse dallo '0' fino alla 'z' # # vedi Homework Lezione 4 # def print_matrix(m. ord('z') + 1): print(chr(i).

ord('0') # salto gli elementi che hanno gia' un '*' # sulla colonna corrispondente al carattere # caratt e sulla riga r # perche' maxrows . maxord) .# inserisco maxrows righe uguali a row # NOTA BENE!! devo fare una copia di row ogni volta # prima di passarlo ad append perche' python passa i # parametri per OBJECT REFERENCE. maxrows): matrix.1) and caratt < maxcols and (matrix[r][caratt] != ' '): r=r+1 if caratt < maxcols: matrix[r][caratt] = '*' if maxord < r: maxord = r print_matrix(matrix. quindi ogni cambiamento # su un vettore riga si ripercuoterebbe su tutte le righe! # for r in range(0.append(row[:]) for i in range(0. len(astring)): r = 0 # indice di riga # controllo che i caratteri inseriti siano quelli compresi tra il # codice ASCII dello zero e quello della 'z' # if ord(astring[i]) >= ord('0') and ord(astring[i]) <= ord('z'): caratt = ord(astring[i]) .1 ?? while (r < maxrows .

maxord): # stampa la matrice dall'alto verso il basso */ r = maxord c=0 while r >= 0: for c in range(0. 128): # evito di stampare le colonne vuote. end="") print("") def istover(astring): maxrows = len(astring) maxcols = 128 # numero di caratteri ASCII standard maxord = 0 # massimo valore assunto dalle "ordinate" # creo e popolo la matrice di soli spazi matrix = [ ] row = [ ] # preparo una riga di maxcols elementi for c in range(0.append(' ') # inserisco maxrows righe uguali a row # NOTA BENE!! devo fare una copia di row ogni volta .ISTOVER_HOMEWORK .. if m[0][c] != ' ': print(m[r][c]. end="") r=r-1 print("") # a capo for i in range(0.LEZIONE 5 def print_matrix(m. maxcols): row. 128): if m[0][i] != ' ': print(chr(i).

maxord) .1 ?? while (r < maxrows . len(astring)): r = 0 # indice di riga caratt = ord(astring[i]) # salto gli elementi che hanno gia' un '*' # sulla colonna corrispondente al carattere # caratt e sulla riga r # perche' maxrows . quindi ogni cambiamento # su un vettore riga si ripercuoterebbe su tutte le righe! # for r in range(0.1) and (matrix[r][caratt] != ' '): r=r+1 matrix[r][caratt] = '* ' if maxord < r: maxord = r # salvo il valore massimo assunto dalle ordinate print_matrix(matrix. maxrows): matrix.append(row[:]) for i in range(0.# prima di passarlo ad append perche' python passa i # parametri per OBJECT REFERENCE.

LEZIONE 5 # seconda versione di istover che stampa tutti i valori delle # ascisse dallo '0' fino alla 'z' # # vedi Homework Lezione 4 # def print_matrix(m. maxord): # stampa la matrice dall'alto verso il basso */ r = maxord c=0 while r >= 0: for c in range(0. end="") print("") # a capo def istover(astring): maxrows = len(astring) maxcols = ord('z') .append(' ') . maxcols): row.ord('0')): print(m[r][c].ISTOVER_SEMPLIFICATO . ord('z') + 1): print(chr(i). end="") r=r-1 print("") # a capo for i in range(ord('0').ord('0') maxord = 0 # massimo valore dell'ordinata # creo e popolo la matrice di soli spazi matrix = [ ] row = [ ] # preparo una riga di maxcols elementi for c in range(0. ord('z') .

maxord) # .1 ?? # se fosse solo maxrows.append(row[:]) for i in range(0. r nel caso limite raggiungerebbe il # #valore maxrows. maxrows): matrix. # il quale oltrepassa i limiti della lista! while (r < maxrows .1) and (matrix[r][caratt] != ' '): r=r+1 matrix[r][caratt] = '*' if maxord < r: maxord = r print_matrix(matrix. quindi ogni cambiamento # su un vettore riga si ripercuoterebbe su tutte le righe! # for r in range(0.# inserisco maxrows righe uguali a row # NOTA BENE!! devo fare una copia di row ogni volta # prima di passarlo ad append perche' python passa i # parametri per OBJECT REFERENCE.ord('0') # salto gli elementi che hanno gia' un '*' # sulla colonna corrispondente al carattere # caratt e sulla riga r # perche' maxrows . len(astring)): r = 0 # indice di riga caratt = ord(astring[i]) .

intcycle * extcycle) . else: print("Numero primo") print("needed iterations". vartemp) if vartemp == 0: r=1 if r == 1: print("Numero non e` primo: e` divisibile per".NUMERIPRIMI . #print("vartemp". div). div) while vartemp > 0: intcycle += 1 vartemp = vartemp .div.LEZIONE 5 def primo(n): r=0 div = 1 extcycle = 0 intcycle = 0 while r == 0 and div < n .1: vartemp = n div = div + 1 extcycle += 1 #print("div".

LEZIONE 6 def fact(n): if n == 0: return 1 else: return n * fact(n-1) .FATTORIALERICORSIVO .

to. _from) def gioca(): num_dischi = int(input("Inserisci numero di dischi: ")) _from = 1 to = 3 store = 2 hanoi(num_dischi. _from. to) def hanoi(n.HANOI . store): if n == 1: # disco piu` piccolo. store. to) # e infine sposta la parte superiore della torre dal piolo # intermedio a quello di destinazione hanoi(n .1. store. to) else: # sposto gli n-1 dischi superiori della torre nel piolo intermedio (store) hanoi(n .LEZIONE 6 # muovo un pezzo dal piolo from al piolo to # NOTA: from e` una parola chiave! # def muovi(_from. "al piolo". store) print("Spostati". num_dischi.1. lo posso muovere muovi(_from. to) # sposto il disco rimasto in fondo muovi(_from. _from. to. to) . to. "dischi _froml piolo". to): print(_from. _from. _from. "-->".

MERGE_SORT . # All'interno di ciascuna meta` infatti gli elementi sono gia` # in ordine.append(vect[j]) j=j+1 # aggiungo in coda gli elementi eventualmente non copiati nel ciclo # # ### precedente # while i <= center: temp. # while i <= center and j <= right: if vect[i] <= vect[j]: temp. right) # confronto elementi appartenenti alla prima meta` con elementi # appartenenti alla seconda meta`. else: temp. left. center e right # ordinando gli elementi # def merge (vect. center.append(vect[i]) i = i + 1. vect[center+1:right+1]. left. center.append(vect[i]) . vect[left:center+1]. right): i = left j = center + 1 # define temporary ordered vector temp = [] # scommentare per tracciare l'esecuzione print("merge() entering: ".LEZIONE 6 recursion_cnt = 0 # Fonde le due meta` individuate da left.

right) mergesort(vect.1. center. left. right) return # Funzione ricorsiva per il riordinamento di un vettore vect da left a right # In questa versione.append(vect[j]) j=j+1 # nello stesso vettore di ingresso salvo gli elementi in temp. recursion_cnt) # recursion_cnt = recursion_cnt + 1 if left < right: # importante: // center = (left + right) // 2 # scommentare per tracciare l'esecuzione print("mergesort: ". right) . left. center+1. right deve essere len(vect) . for index in range(left. vect. non # la lunghezza totale del vettore. # def mergesort(vect. left. # Il range parte da left. vect. center. left. right) merge(vect. right): # print("merge sort call ".i=i+1 # aggiungo in coda gli elementi eventualmente non copiati nel primo ###ciclo # while j <= right: temp. right + 1): vect[index] = temp[index . ovvero l'indice del suo # ultimo elemento.left] # scommentare per tracciare l'esecuzione print("merge(): leaving: ". # che sono stati ordinati da left a right. center) mergesort(vect. left.

right) .# funzione principale da chiamare dalla console con il vettore da ordinare # come parametro # def sort(v): """Riordina il vettore passato come parametro in ingresso mediante l'algoritmo merge sort""" left = 0 right = len(v) .1 mergesort(v. left.

len(m)): for j in range(0. ovvero in virgola fissa oppure in formato scientifico (esponenziale)""" for i in range(0. scambia la riga l con la prima riga trovata con elemento non nullo sulla colonna l""" rows = len(m) cols = len(m[0]) . si puo' modificare il programma in modo che esso sia # robusto rispetto a una matrice di ingresso che rappresenta un sistema # impossibile o indeterminato. # La funzione gauss() accetta la matrice completa che rappresenta il # # # # sistema # lineare da risolvere e si suppone che il sistema sia determinato # # Per esercizio. end="\t") print("") def scambiariga(m. l): """La funzione prende in ingresso una matrice m e un intero l che indica la riga al di sotto della quale viene cercato un elemento non nullo sulla colonna l. # def stampa_matrice(m): """Stampa la matrice arrotondando il valore degli elementi in modo 'generale'. len(m[i])): print('%g'% (m[i][j]).SISTEMALIN . Se lo trova.LEZIONE 6 # Calcolo della soluzione di un sistema lineare di n equazioni in n # # # # # # incognite.

cols): m[i][j] = m[i][j] / mii def gauss(m): """Questa funzione applica il metodo di eliminazione di Gauss per risolvere un sistema di equazioni lineari..l) finche' ne #trovo uno non nullo # if m[l+i][l] !=0: # scambio la riga l con la l + i for j in range(0. . for j in range(0. cols): tmp = m[l + i][j] m[l + i][j] = m[l][j] m[l][j] = tmp riga_scambiata = True # ok esco dal ciclo break return riga_scambiata def diagonale_unitaria(m): """Questa funzione prende in ingresso una matrice e divide ogni elemento di una riga m[i][j] per l'elemento m[i][i].riga_scambiata = False for i in range(1.""" rows = len(m) cols = len(m[0]) for i in range(0. rows): mii = m[i][i] if mii != 0: # altrimenti riga nulla e sistema cala di rango. in modo che ogni elemento m[i][i] sia pari ad 1..l): # cerco l'elemento sotto a quello in posizione (l. rows .

row) # coeff = -m[next_row][row]/m[row][row]. count): m_row_row_nonzero = 1 # elemento della diagonale nullo? if m[row][row] == 0: # cerco sotto la colonna row-ma una riga con colonna # # #row-ma non nulla m_row_row_nonzero = scambiariga(m. ncols) for row in range(0. row) if m_row_row_nonzero: # devo annullare tutti gli elementi delle righe sotto su # # #quella colonna next_row = row + 1 while next_row < nrows: # calcolo il valore del coefficiente atto ad annullare # l'elemento sotto quello di posto (row. ove ogni riga ha lo stesso numero di # # #elementi nrows = len(m) ncols = len(m[0]) # suppongo sistema lineare n eq. n incognite. # # aggiungo agli elementi della riga next_row gli # elementi della riga row moltiplicati # ## .Ipotesi: il sistema rappresentato dalla matrice completa in ingresso deve essere determinato""" # controllo che la matrice non sia nulla if len(m) == 0 or len(m[0]) == 0: return "Matrice in input nulla!" # # suppongo matrice valida. count = min(nrows.

## # prossimo passo. applico il procedimento alla riga #successiva next_row = next_row + 1 # # ora serve annullare tutti gli elementi sopra la riga row # #nella colonna row prev_row = row . ncols): m[prev_row][column] = m[prev_row][column] + coeff * m[row][column]. for column in range(0. # Il risultato e` che l'elemento sotto # a[row][row] viene annullato.# per il coefficiente coeff calcolato. # for column in range(0.1 diagonale_unitaria(m) stampa_matrice(m) # # # se voglio restituire la matrice al chiamante return m return 0 . prev_row = prev_row .1 # while prev_row >= 0: coeff = -m[prev_row][row] / m[row][row]. ncols): m[next_row][column] = m[next_row][column] + coeff * m[row][column].

y .LEZIONE 7 class Shape: def __init__(self): pass def type(self): return '' def draw(self): return def boundingRect(self): return None def intersects(self. other): return self.b = b self.x.a/2 .b)) def boundingRect(self): return Rect(self.b=b self. a.a=a self.y.x.%d. self. self.b) def setRect(self. self. p0_x. a.overlaps(other. y. b): """Costruisce un Rect con lati a e b e top left in x. y""" self.boundingRect().a. x. self. p0_y.x = p0_x + self. b): self.boundingRect()) class Rect(Shape): def __init__ (self.y=y def draw(self): print ("Rect: topLeft %d.a = a self.a.x=x self.CARTESIANO .y = p0_y + self. self. self. %dx%d" % (self.b/2 self.

self.x and other.def overlaps(self.y . x. raggio): self.x and self.x and other.raggio=r def boundingRect(self): p0_x = self.raggio l = 2 * self.x. self.x + other. x.b > other.raggio = raggio self. p0_y. y.y and other.y + self. lato. lato): Rect. l .x and self.y) def type(self): return 'r' class Square(Rect): def __init__(self.x . x. r): if r >= 0 : self.y and self.x + self. self.x <= other.raggio return Rect(p0_x.raggio p0_y = self. lato.y <= self.y + other. y.a > self. y) def type (self): return "q" class Circle (Shape): def __init__(self. "raggio". other): return (self.self.b > self.__init__(self.x = x self.raggio) def setRadius(self. l) .y <= other.y = y def draw (self): print("Circle: centro:".a > other.y) \ or (other.x <= self.

append(s) return rects def get_circles(self): l=[ ] for s in self.shapes=[ ] def add_shape(self.shapes: if s.type()=='r': rects.shape): self.def type(self): return 'c' class Piano: def __init__(self): self.append(s) return l .shapes.type()=='c': l.append(shape) def get_rects(self): rects=[ ] for s in self.shapes: if s.

parole_chiave. " *" + parola + "* ") match = match + 1 if match == numkeywords: estratti.count(parola) > 0: paragrafo = paragrafo.\n") estratti = [ ] for paragrafo in paragrafi: match = 0 for parola in parole_chiave: if paragrafo. che nel formato UNIX e` identificato dal carattere di escape #### "\n" e nel formato DOS"\r\n" (new line + line feed).replace(parola.La funzione #### scrive sul file individuato da outfile i capoversi trovati. outfile): '''Legge il testo dal file "infile" e cerca le occorrenze di ogni parola chiave contenuta nella lista parole_chiave all'interno di ogni # #### capoverso. "r") # in text l'intero testo da analizzare text = fin.split(".append(paragrafo) print("Trovati".read() paragrafi = text. "capoversi con le seguenti parole .LEZIONE 7 def estrai(infile. evidenziando le parole chiave tra due '*' e separandoli con un po' di trattini ''' # numero di parole chiave da controllare numkeywords = len(parole_chiave) # apro il file in sola lettura fin = open(infile.ESTRAI_CAPOVERSI ... Si suppone che il capoverso sia delimitato da un "punto e #### a capo". len(estratti).

close() .chiave:") print(parole_chiave) fout = open(outfile. "w") for paragrafo in estratti: fout.close() fin.write(paragrafo + "\n\n-----------------------------------------\n\n") # importante! Chiudere i file aperti! # fout.

close() return dizionario def writeCompressedSMS(testo_compresso. "r") testo = fin. sms_compressed_out): # leggo il testo dell'SMS originale fin = open(sms_filename.LEZIONE 7 def readDictionary(filename): # apro il file in sola lettura: f = open(filename. pertanto dovro` toglierlo # a mano quando popolo il dizionario # linea = f. # Lascia il carattere di newline alla fine.readline() # quando ho finito. nomefile_out): f = open(nomefile_out.close() # non dimenticare! def compress(sms_filename.replace("\n". dictionary_filename.write(testo_compresso) f.SMSCOMPRESSI . chiudo il file f. "r") # riempio un dizionario con parola e sua forma abbreviata dizionario = dict() # # la readline() legge il contenuto di un file una linea alla volta.read() # chiudo il file! . "") linea = f.readline() while linea != '': parti = linea.split(' ') if len(parti) == 2: dizionario[parti[0]] = parti[1]. "w") f.

fin.close() lunghezza_testo_originale = len(testo) dizionario = readDictionary(dictionary_filename) for parola in dizionario.keys(): testo = testo.replace(parola, dizionario[parola]) testo_compresso = testo # scrivi l'SMS compresso sul file di uscita sms_compressed_out writeCompressedSMS(testo_compresso, sms_compressed_out) # restituisco il fattore di compressione ottenuto sul testo con il #### ## #dizionario dato, in percentuale. # return 100 * (lunghezza_testo_originale - len(testo_compresso)) / lunghezza_testo_originale

CARTESIANO - LEZIONE 8
class Shape: def __init__(self): pass def type(self): return '' def draw(self): return def boundingRect(self): return None def intersects(self, other): return self.boundingRect().overlaps(other.boundingRect()) class Rect(Shape): def __init__ (self, x, y, a, b): """Costruisce un Rect con lati a e b e top left in x, y""" self.a=a self.b=b self.x=x self.y=y def draw(self): print ("Rect: topLeft %d,%d, %dx%d" % (self.x, self.y , self.a, self.b)) def boundingRect(self): return Rect(self.x, self.y, self.a, self.b) def setRect(self, p0_x, p0_y, a, b): self.a = a self.b = b self.x = p0_x + self.b/2 self.y = p0_y + self.a/2

def overlaps(self, other): return (self.x <= other.x and self.y <= other.y and self.x + self.a > other.x and self.y + self.b > other.y) \ or (other.x <= self.x and other.y <= self.y and other.x + other.a > self.x and other.y + other.b > self.y) def type(self): return 'r' class Square(Rect): def __init__(self, x, y, lato): Rect.__init__(self, lato, lato, x, y) def type (self): return "q" class Circle (Shape): def __init__(self, x, y, raggio): self.raggio = raggio self.x = x self.y = y def draw (self): print("Circle: centro:", self.x, "raggio", self.raggio) def setRadius(self, r): if r >= 0 : self.raggio=r def boundingRect(self): p0_x = self.x - self.raggio p0_y = self.y - self.raggio l = 2 * self.raggio return Rect(p0_x, p0_y, l , l)

def type(self): return 'c' class Piano: def __init__(self): self.shapes=[ ] def add_shape(self,shape): self.shapes.append(shape) def get_rects(self): rects=[ ] for s in self.shapes: if s.type()=='r': rects.append(s) return rects def get_circles(self): l=[ ] for s in self.shapes: if s.type()=='c': l.append(s) return l

dict_esami[nomeEsame] = voto trovato = True if not trovato: print("Nella facolta".mail = mail self. nomeEsame. nome. matricola. nomeEsame. cognome.LEZIONE 8 class Persona: def __init__(self. nome.mail ="" # quando creo un professore devo specificare # la sua email.__init__(self.UNIVERSITA' .nome.dict_esami = {} def registraEsame(self.facolta.nome = nome self. nome.ufficio = "" self. voto): trovato = False esami = self. mail): Persona.facolta = facolta self.nome and voto >= 18: self. cognome): self.cognome = cognome self. "non c'e` l'esame di".telefono = -1 class Studente(Persona): def __init__(self.facolta. cognome) self.matricola = matricola # memorizza nomi esami (Stringa) e Esami (oggetti) self. nome. nome.getListaEsami() for esame in esami: if nomeEsame == esame. # class Professore(Persona): def __init__(self. "oppure il voto". cognome.__init__(self. "non e` valido") . voto. cognome) self. self. facolta): Persona.

append(studente) def aggiungiProfessore(self.studenti: if studente.append(esame) return esami def getEsitoEsami(self): es = dict() for nome in self.append(professore) def getStudente(self. cognome): for studente in self.keys(): esami. None parola chiave che indica nessun oggetto return None .dict_esami.nome = nome self.nome) return esami def getEsamiSostenuti(self): esami = [ ] for esame in self.getListaEsami(): esami. nome.studenti.professori.dict_esami[nome] return es class Facolta: # costringo a costruire una facolta con un nome e una lista di esami def __init__(self.cognome == cognome: return studente # non trovato. professore): self. studente): self.esami = esami self.def getListaEsami(self): esami = [ ] for esame in self.facolta.studenti = [ ] self.keys(): es[nome] = self.dict_esami.professori = [ ] def aggiungiStudente(self. nome.nome == nome and studente. esami): self.append(esame.

crediti = valore else: print("Errore: crediti tra 4 e 12") ## class Universita: def __init__(self. crediti): self. valore): # suppongo che ogni esame abbia almeno sei crediti e non piu` # di 12 # if valore >= 4 and valore <= 12: self.append(Esame(es. listaEsami = [ ] for es in ["Analisi I".__ultima_matricola = 0 # #variabile privata in quanto ### #utilizzata solo dalla #classe Università self.facolta = {} self.nome = nome self. "Chimica". "Fondamenti di Informatica".professori def getListaEsami(self): return self.esami = dict() # costruisco l'universita` con un po' di facolta'..nome = nome self. "Fisica"]: listaEsami. 10)) ..esami class Esame: def __init__(self.luogo = luogo self. nome. nome.crediti = crediti def setCrediti(self.def getStudenti(self): return self.studenti def getProfessori(self): return self. luogo): self. "Geometria".

"Filosofia del Linguaggio".self. 8)) self.append(Esame(es. "Storia del diritto". self.esami["Ingegneria"] = listaEsami listaEsami = [ ] # ripulisco e riutilizzo la lista for es in ["Storia dell'arte". "Matematica". "Filosofia della Religione". "Diritto Civile".facolta[nomeFacolta]) . "Architettura".esami["Giurisprudenza"] = listaEsami listaEsami = [ ] for es in ["Storia della Filosofia".values() def iscriviStudente(self. "Giurisprudenza".__ultima_matricola = self. "Estetica". 8)) self. nomeFacolta) if nomeFacolta in self. cognome.__ultima_matricola. "Filosofia Teoretica"]: listaEsami.facolta. self. "Geometria"]: listaEsami.esami["Filosofia"] = listaEsami for nome in ("Ingegneria".keys(): self. nome.__ultima_matricola + 1 s = Studente(nome.esami[nome]) self. "in facolta'". nome. "Filosofia del Diritto"]: listaEsami.facolta.keys() def getListaFacolta(self): return self.facolta[nome] = f def getNomiFacolta(self): return self.facolta. nomeFacolta): print("Iscrivo ". self.append(Esame(es. cognome. "Filosofia"): f = Facolta(nome.append(Esame(es.esami["Architettura"] = listaEsami listaEsami = [ ] for es in ["Diritto Privato". 8)) self. cognome. "Scienza delle costruzioni".

values(): s = fac.facolta[nome] # ---# # Funzioni utilizzatrici delle classi create # # Funzione che usa le classi create per iscrivere alcuni studenti def PopolaUniversita(): u = Universita("Universita` degli Studi di Trieste".iscriviStudente("Lucia". fac. "Croce". cognome): for fac in self. nome. "Ingegneria") u.facolta[nomeFacolta] print("Iscrivo ". "facolta ". "Nietzsche". s. "Ingegneria") u.cognome.aggiungiStudente(s) else: print("In questa universita' non c'e' la facolta' di". nome): return self. "Ingegneria") u.iscriviStudente("Mario".iscriviStudente("Luca". "Bruno".nome) fac. "Ingegneria") u. "Trieste") # iscriviamo un po' di studenti in varie facolta` u. cognome) if s != None: return s # non trovato return s # sara' None def getFacolta(self. "Filosofia") u.getStudente(nome. s. fac. "Croce".fac = self.iscriviStudente("Giordano".iscriviStudente("Carlo".nome.iscriviStudente("Pippo". "Filosofia") . "Valvola". "Ingegneria") u.iscriviStudente("Federico". "Transistore". "Navali". "Industria". "Filosofia") u.facolta. "Resistenza".iscriviStudente("Paolo". nomeFacolta) def getStudente(self. "Ingegneria") u.iscriviStudente("Marta". "Resistenza". "Filosofia") u.iscriviStudente("Benedetto".

registraEsame("Fondamenti di Informatica". "Filosofia") return u # funzione che recupera alcuni studenti dall'istanza di Universita passata # come parametro e registra alcuni esami def RegistraUnPoDiEsami(u): paoloCroce = u.getStudente("Benedetto".registraEsame("Storia della Filosofia".getStudente("Mario".registraEsame("Storia della Filosofia". "Resistenza") marioRes.getStudente("Paolo".iscriviStudente("Pippo". 30) marioRes = u.u. "Croce") benedettoCroce. "Campanella". "Croce") paoloCroce. 22) . 18) benedettoCroce = u.

cognome. # class Professore(Persona): def __init__(self.getListaEsami() for esame in esami: if nomeEsame == esame.facolta. "non e` valido") .__init__(self.nome = nome self. nome. nomeEsame.dict_esami = {} def registraEsame(self. nome.mail ="" # quando creo un professore devo specificare # la sua email.ufficio = "" self.nome. cognome) self. cognome) self. "oppure il voto".mail = mail self.facolta.facolta = facolta self.dict_esami[nomeEsame] = voto trovato = True if not trovato: print("Nella facolta". facolta): Persona. "non c'e` l'esame di". nomeEsame. nome. self.__init__(self.LEZIONE 8 class Persona: def __init__(self.matricola = matricola # memorizza nomi esami (Stringa) e Esami (oggetti) self. nome. nome. voto): trovato = False esami = self. cognome.telefono = -1 class Studente(Persona): def __init__(self. matricola.UNIVERSITA' .nome and voto >= 18: self. voto.cognome = cognome self. cognome): self. mail): Persona.

esami = esami self. None parola chiave che indica nessun oggetto return None . nome.facolta.getListaEsami(): esami.dict_esami[nome] return es class Facolta: # costringo a costruire una facolta con un nome e una lista di esami def __init__(self.def getListaEsami(self): esami = [ ] for esame in self.cognome == cognome: return studente # non trovato.dict_esami.append(professore) def getStudente(self. nome.nome) return esami def getEsamiSostenuti(self): esami = [ ] for esame in self.append(esame. studente): self.studenti = [ ] self.dict_esami.studenti: if studente. esami): self.keys(): esami.professori.keys(): es[nome] = self.append(studente) def aggiungiProfessore(self. cognome): for studente in self. professore): self.append(esame) return esami def getEsitoEsami(self): es = dict() for nome in self.nome = nome self.nome == nome and studente.studenti.professori = [ ] def aggiungiStudente(self.

. "Chimica". valore): # suppongo che ogni esame abbia almeno sei crediti e non piu` # di 12 # if valore >= 4 and valore <= 12: self. luogo): self.nome = nome self.crediti = crediti def setCrediti(self. nome.luogo = luogo self.def getStudenti(self): return self.professori def getListaEsami(self): return self.facolta = {} self. "Fisica"]: listaEsami.crediti = valore else: print("Errore: crediti tra 4 e 12") ## class Universita: def __init__(self.append(Esame(es. "Fondamenti di Informatica".studenti def getProfessori(self): return self.nome = nome self. "Geometria". nome. listaEsami = [ ] for es in ["Analisi I".esami = dict() # costruisco l'universita` con un po' di facolta'.__ultima_matricola = 0 # #variabile privata in quanto ### #utilizzata solo dalla #classe Università self.esami class Esame: def __init__(self. 10)) .. crediti): self.

cognome.esami["Ingegneria"] = listaEsami listaEsami = [ ] # ripulisco e riutilizzo la lista for es in ["Storia dell'arte". "Filosofia del Diritto"]: listaEsami. "Diritto Civile". self. "Scienza delle costruzioni".self. "Matematica".esami[nome]) self. "in facolta'". nomeFacolta): print("Iscrivo ". self.esami["Filosofia"] = listaEsami for nome in ("Ingegneria". nome. "Storia del diritto".__ultima_matricola + 1 s = Studente(nome. 8)) self.append(Esame(es.keys() def getListaFacolta(self): return self. "Filosofia Teoretica"]: listaEsami. "Filosofia"): f = Facolta(nome.facolta[nomeFacolta]) . "Filosofia del Linguaggio".append(Esame(es. cognome. self.values() def iscriviStudente(self.esami["Architettura"] = listaEsami listaEsami = [ ] for es in ["Diritto Privato". nomeFacolta) if nomeFacolta in self.__ultima_matricola = self. "Geometria"]: listaEsami.facolta. cognome. "Architettura". nome.append(Esame(es.__ultima_matricola. "Estetica". 8)) self.esami["Giurisprudenza"] = listaEsami listaEsami = [ ] for es in ["Storia della Filosofia".keys(): self.facolta. "Giurisprudenza".facolta. 8)) self. "Filosofia della Religione".facolta[nome] = f def getNomiFacolta(self): return self.

iscriviStudente("Benedetto". "Valvola".cognome. "Nietzsche".nome) fac.facolta. "Bruno".facolta[nome] # ---# # Funzioni utilizzatrici delle classi create # # Funzione che usa le classi create per iscrivere alcuni studenti def PopolaUniversita(): u = Universita("Universita` degli Studi di Trieste". fac. nome): return self. "Ingegneria") u. "Trieste") # iscriviamo un po' di studenti in varie facolta` u. "Industria". "Croce".iscriviStudente("Federico".iscriviStudente("Luca". cognome): for fac in self. "Ingegneria") u.iscriviStudente("Giordano". nomeFacolta) def getStudente(self.values(): s = fac. "Ingegneria") u. "Croce". "Filosofia") u. "Ingegneria") u. "Resistenza".fac = self. "Transistore".iscriviStudente("Pippo".aggiungiStudente(s) else: print("In questa universita' non c'e' la facolta' di". s. "facolta ". "Filosofia") .iscriviStudente("Lucia".getStudente(nome. cognome) if s != None: return s # non trovato return s # sara' None def getFacolta(self. "Ingegneria") u.iscriviStudente("Carlo". "Filosofia") u. "Ingegneria") u. "Resistenza".iscriviStudente("Mario".iscriviStudente("Marta". nome. s.nome. "Navali". "Filosofia") u.iscriviStudente("Paolo".facolta[nomeFacolta] print("Iscrivo ". fac.

registraEsame("Storia della Filosofia". "Croce") benedettoCroce.u. "Resistenza") marioRes.registraEsame("Fondamenti di Informatica".registraEsame("Storia della Filosofia". "Croce") paoloCroce. 30) marioRes = u. "Campanella". 22) .getStudente("Mario".getStudente("Paolo".getStudente("Benedetto". "Filosofia") return u # funzione che recupera alcuni studenti dall'istanza di Universita passata # come parametro e registra alcuni esami def RegistraUnPoDiEsami(u): paoloCroce = u.iscriviStudente("Pippo". 18) benedettoCroce = u.

h1 per giocare") print(".upper() riga = int(opzione[1]) .popolaScacchiera() s. c. colonna) s. navi) s. opzione[0]. colonna = opzione[0]..tutteAffondate(): opzione = input("> ") if len(opzione) == 2: # colonna abcde.\"mostra navi\" per mostrare le navi") print(".\"ricarica\" per ricominciare") print(". ".popolaScacchiera() s.count("ricarica") > 0: s.". " non valide!") elif opzione.disegna() else: print("Coordinate". opzione[1].disegna() opzione = "" print("Inserisci cella..ord('A') if riga >= 0 and riga < r and colonna >=0 and colonna < c: s.disegna() .colpisci(riga.1 colonna = ord(colonna) .\"nascondi navi\" per nascondere le navi") while opzione.LEZIONE 9 from scacchiera import * r = eval(input("Numero di righe desiderato: ")) c = eval(input("Numero di colonne desiderato: ")) navi = eval(input("Numero di navi desiderato: ")) if r > 4 and c > 4 and navi > 0: s = Scacchiera(r. ad es.BATTAGLIANAVALE .\"esci\" per uscire dal gioco") print(".count("esci") < 1 and not s.

count("navi") > 0: s. "non valide").disegna() elif opzione.count("navi") > 0: s. "le navi!!") else: print(":-( peccato! Non ce l'hai fatta!") else: print("opzioni righe". "numero navi". .naviVisibili = False s.disegna() print("Opzione \"". opzione.naviVisibili = True s. len(s.count("esci") == 0: s.elif opzione. r. navi.disegna() elif opzione.navi). "\" non valida\n") if s.count("nascondi") >0 and opzione.count("mostra") >0 and opzione. "colonne".tutteAffondate(): print("Complimenti! Hai affondato tutte e". c.

genere = genere # cd in prestito solo per una settimana def durataPrestito(self): return 7 class Cliente: def __init__(self. titolo.genere = genere self.BIBLIOTECA .nome = nome self.__init__(self. genere): Articolo. nome. autore. autore. titolo.autore = autore self. collocazione. collocazione): self.tipo = "" # valore predefinito per il prestito di un articolo # def durataPrestito(self): return 30 class Libro(Articolo): def __init__(self.cognome = cognome def bonusGiorniPrestito(self): return 0 . titolo. collocazione) self. cognome): self. titolo. autore.LEZIONE 9 class Articolo: def __init__(self.__init__(self.tipo = "CD" self. genere): Articolo.tipo = "libro" class CD(Articolo): def __init__(self. titolo. autore. collocazione. autore.collocazione = collocazione self.titolo = titolo self. collocazione) self.

dataInizio): self. luogo): self. nomeUniversita): Cliente. cliente.cliente = cliente self.bonusGiorniPrestito() class Biblioteca: def __init__(self.def isStudente(self): return False class Studente(Cliente): def __init__(self.prestiti . cognome.articolo.cliente.durataPrestito() + self.luogo = luogo self.__init__(self.articolo = articolo self.prestiti = [ ] self. nome.articoli = [ ] def getListaArticoli(self): return self.clienti = [ ] self. nome. nome. cognome) self.nome = nome self.dataInizioPrestito = dataInizio def durataPrestito(self): return self.nomeUniversita = nomeUniversita def bonusGiorniPrestito(self): return 10 def isStudente(self): return True class Prestito: def __init__(self. articolo.articoli def getListaPrestiti(self): return self.

autore == autore: return articolo return None def cercaCliente(self. cognome.append(articolo) def cercaArticolo(self. autore. cognome. collocazione. collocazione. titolo.articoli: if articolo. cognome): for cliente in self. collocazione.clienti: if cliente.articoli. cognomeCliente. . genere) elif tipo == "libro": articolo = Libro(titolo.titolo == titolo and articolo.clienti def aggiungiStudente(self. nome. autore): for articolo in self.clienti. genere) else: print("Tipo di articolo non supportato") if articolo != None: self. autore.append(c) def aggiungiArticolo(self. nome. universita) self. universita): s = Studente(nome. genere. autore.def getListaClienti(self): return self. nome. cognome): c = Cliente(nome. nomeCliente.nome == nome and cliente.clienti.cognome == cognome: return cliente return None def registraPrestito(self. cognome) self. titolo.append(s) def aggiungiCliente(self. tipo): articolo = None if tipo == "CD": articolo = CD(titolo. titolo. autore.

"De sensu rerum et magia". "9-12-2012") b. "Shostakovich". "Croce". dataPrestito) self. articolo. "Shostakovich".aggiungiCliente("Bruno". "Filosofia". cognomeCliente) if articolo != None and cliente != None: prestito = Prestito(cliente. "Rossi") b. "Filosofia") b.registraPrestito( "L'interpretazione dei Sogni". "Filosofia". "Verdi") b.aggiungiStudente("Federico". "Freud".aggiungiArticolo("CD16". "libro") b.registraPrestito( "Il mondo come volonta". autore. cognomeCliente. "Schopenhauer".append(prestito) else: print("articolo". "Croce". "Campanella".aggiungiStudente("Mario". "L'interpretazione dei Sogni". "Freud". "Giacomo".aggiungiArticolo("L208". "12-012012") b. "Ingegneria") b. "libro") b. "Trieste") b.prestiti. "Filosofia".aggiungiCliente("Giacomo".aggiungiArticolo("L207".cercaCliente(nomeCliente. "CD") b. nomeCliente.aggiungiArticolo("L205"."Rock". "Schopenhauer". "non iscritto alla biblioteca") b = Biblioteca("Biblioteca Civica di Trieste". "Federico".aggiungiArticolo("CD06".registraPrestito("The Wall". "9-12-2012") . "The Wall".cercaArticolo(titolo. "Mario". "Croce". "Resistenza". "CD") b. "Il mondo come volonta". "libro") b. "Sinfonia 13 Babi Yar".dataPrestito): articolo = self. autore) cliente = self. "Federico". "Resistenza". "8-12-2012") b. "non trovato oppure cliente". titolo. "Pink Floyd". "Rossi".registraPrestito("Sinfonia 13 Babi Yar". "Pink Floyd". "Classica".

b.articolo.getListaPrestiti(): # print(prestito.cercaArticolo("Sinfonia 13 Babi Yar". ".". " . ".# >>> sh = B.".cliente.b.collocazione) .autore.cognome.cliente. # àààààààààààà # # prestito.durataPrestito(). prestito. àààààààà # prestito.titolo.durata:". "Shostakovich") # >>> sh. "-->".titolo # 'Sinfonia 13 Babi Yar' # >>> sh. prestito.articolo. ]# # ### # # prestito.articolo. prestito.nome.autore # 'Shostakovich' #for prestito in B.dataInizioPrestito.

pos = [ ] # lista di tuple che contiene le posizioni colpite self.pos. y for i in range(x.LEZIONE 9 class Nave: def __init__(self.pos: if othertup == tup: return True return False #nessuna tupla uguale.pos.orientation = orientation if orientation == "Vertical": if dim > 0: # prua in x. dim. y for j in range(y. other): dim1 = len(self. x + 1): self.pos) # controllo se ci sono due tuple uguali in pos di self e # in pos di other: se si` . poppa in (x. y + dim): self.append((i. j)) elif dim < 0: # prua in (x. y)) elif orientation == "Horizontal": if(dim > 0): # prua in x.pos. y).pos.pos: for othertup in other.NAVE . nessuna intersezione .append((i.colpite = [ ] self. allora due navi si scontrano for tup in self.pos) dim2 = len(other. y + dim + 1) for j in range(y + dim + 1. orientation): # lista di tuple che contiene le posizioni occupate dalla nave self.append((x. x + dim): self. j)) def collide(self.append((x. y + 1): self. y) for i in range(x + dim + 1. y)) elif dim < 0: # prua in (x + dim + 1. y. x.

pos e non ho inserito duplicati.count(cell) == 0: self. # quindi non devo inserire tuple duplicate in self. y): cell = (x.def colpisci(self.colpite. # Pertanto basta confrontare le lunghezze # return len(self.colpite.colpite avevo inserito solo tuple gia` contenute in # self.append(cell) return True return False def colpita(self.colpite) def dimensione(self): return len(self.count(cell) == 1 and self. y) ## # il giocatore potrebbe avere colpito due volte nello stesso #### # punto. y): cell = (x. x.pos.pos) == len(self..orientation == "Horizontal" . x.count(cell) > 0 def affondata(self): # in self.pos) def orizzontale(self): return self.colpite.colpite # if self. y) return self.

dimX.dimY) // 2 while numeroNavi < self. dimX.nNavi = mindim self.naviVisibili = False if numNavi > mindim: print("Il numero di navi e` stato ridotto a". mindim) self.nNavi = numNavi # se true.nNavi and dimensioneNave > 1: collisione = False # .dimX = dimX self.) # Ogni due navi che genero. # def popolaScacchiera(self): self..LEZIONE 9 from nave import * from random import randint class Scacchiera: def __init__(self.dimY = dimY mindim = min(dimX. dimensioneNave = min(self.acqua = [ ] # # Genero navi di dimensione a partire da min(dimX. self. numNavi): self.navi = [ ] # lista di navi self. dimY..NAVE . 2 navi da 3 e 2 navi da 2 caselline. dimY) self. # In una scacchiera di 8x8 con 6 navi avro` quindi: # 2 navi da 4. diminuisco la dimensione di uno. dimY)/2 (per # # evitare che debordino. disegna() mostra le navi sulla scacchiera self.navi = [] # inizializzo lista navi numeroNavi = 0 # contatore numero navi # una nave puo' essere grande al massimo un numero di celle # # pari alla # meta' della dimensione della scacchiera.

1) # fattore moltiplicativo 1 o -1 per generare una nave con # diversa posizione della prua (vedi Nave) fattore = 1 if h == 0: orientation = "Horizontal" if y > self. "collide con". n.dimX // 2: fattore = -1 else: orientation = "Vertical" if x > self.navi. self. self.navi: if n.collide(nave): collisione = True print("La nave". fattore * dimensioneNave.append(nave) numeroNavi = numeroNavi + 1 # ogni due navi.1) y = randint(0.dimY .1 if dimensioneNave < 2: print("Il numero di navi e' stato ridotto a".dimY // 2: fattore = -1 print("Creo nave" . orientation) nave = Nave(x.dimX . y. y. orientation) for n in self. nave.1) # orientazione h = randint(0.pos) break if not collisione: self. fattore * dimensioneNave. diminuisco la dimensione if numeroNavi % 2 == 0: dimensioneNave = dimensioneNave .# # genero casualmente posizione x e y e orientazione della # nave x = randint(0. x.pos. numeroNavi) .

end="") cellaoccupata = True elif nave. print(row + 1. # def disegna(self): row = self.1 print("") # a capo per dare un po' di spazio. col) for nave in self.pos. Tutte le altre posizioni sono "mare".colpita(row.navi: affondata = nave.acqua sono contenute # le tuple che rappresentano le giocate in cui nessuna nave e' stata # colpita. col): print("+". col) tuplepos = (row. "\t|". end="") col = 0 while col < self.affondata() if nave.count(cella) > 0) e.naviVisibili: cellaoccupata = True . se si'. se # la nave e' colpita o affondata. # Nella lista self.dimX .# # questa funzione disegna ciascuna cella della scacchiera.pos. end="") cellaoccupata = True elif self.count(tuplepos) > 0: if affondata: print("X". while row >= 0: # stampo il numero di riga seguito da un carattere di tabulazione per spaziare # i numeri di riga dall'inizio della scacchiera.dimY: cellaoccupata = False # creo tupla (row. ###### ## #controllando se # essa e' occupata da una nave (nave.

in modo # casuale. end="") else: print(" ". # # # altrimenti disegno # o un'ondina oppure un semplice spazio. end="") # a capo + tab + uno spazio # stampo le lettere della scacchiera for i in range(0. self. casualmente onda = randint(0.col) e' in acqua.dimY): print(chr(ord('A') + i).orizzontale(): # #rappresentata con "=" print("=". per "disegnare" il mare # if not cellaoccupata and tuplepos in self. Se self. self.dimY): print("-". ne' affondata.1 print("") # a capo dopo una riga print("\t+". end="") # #rappresentata con "#" # # # nave non colpita. end="") else: print("#". end="") .acqua: print("o". end="") col = col + 1 row = row .naviVisibili # e' False.if nave. end="") elif not cellaoccupata: # disegno onde. end="") print("\n\t ". allora # disegno una 'o' se la tupla (row. end="") # disegno il bordo inferiore della scacchiera for i in range(0.1) if onda == 1: print("~".

affondata(): return False return True . y): colpita = False for nave in self.navi: if nave.colpisci(x.y)) def tutteAffondate(self): for nave in self. x.print("\n") def colpisci(self. y): colpita = True break if not colpita: self.append((x.acqua.navi: if not nave.

self.a=a self.LEZIONE 7 class Shape: def __init__(self): pass def type(self): return '' def draw(self): return def boundingRect(self): return None def intersects(self.CARTESIANO .b/2 self. self. x. other): return self.b = b self.boundingRect()) class Rect(Shape): def __init__ (self.b)) def boundingRect(self): return Rect(self.y. %dx%d" % (self.a.y=y def draw(self): print ("Rect: topLeft %d.x = p0_x + self.%d. a. p0_x. self. p0_y.a. y""" self.boundingRect().a/2 .b) def setRect(self. b): self.x. y.x=x self.y = p0_y + self. b): """Costruisce un Rect con lati a e b e top left in x.overlaps(other.x.b=b self. self.a = a self. self. a. self.y .

y + self.y = y def draw (self): print("Circle: centro:".def overlaps(self.a > self. x. "raggio". lato.raggio return Rect(p0_x. raggio): self.x + other.raggio l = 2 * self. lato): Rect. y) def type (self): return "q" class Circle (Shape): def __init__(self.raggio = raggio self. p0_y. r): if r >= 0 : self.y <= other. other): return (self.y <= self.x and other. y.self.x and self.y + other.x and other. lato.x.raggio p0_y = self.y .y and self.x <= self.x and self. x. self.x <= other.y and other.b > other. x.raggio) def setRadius(self.y) def type(self): return 'r' class Square(Rect): def __init__(self.x = x self.self. y. l .x .x + self. l) .raggio=r def boundingRect(self): p0_x = self.y) \ or (other. self.a > other.__init__(self.b > self.

shapes: if s.type()=='c': l.append(shape) def get_rects(self): rects=[ ] for s in self.type()=='r': rects.append(s) return l .shapes: if s.shapes=[ ] def add_shape(self.def type(self): return 'c' class Piano: def __init__(self): self.shapes.shape): self.append(s) return rects def get_circles(self): l=[ ] for s in self.

local) # add some files # the C compiler . usrlocalbin) # the python interpreter pyt = File("python". home) anna = Dir("anna".d". home) . etc) # 2 home directories gia = Dir("giacomo". etc) usrbin = Dir("bin".FYLESYSTEM .-) gcc = File("gcc". usrbin) # the famous 'vi' text editor vi = File("vi". usrlocalbin) # some system configuration files under /etc rcconf = File("rc.LEZIONE 10 from filesystem_defs import * #create root dir root = Dir("/". usrbin) # the shell iterpreter under /usr/local/bin bash = File("bash". root) home = Dir("home".conf". root) usr = Dir("usr". usr) usrlocalbin = Dir("bin". root) etc = Dir("etc". None) # create boot etc usr home under root boot = Dir("boot". confd) # file system configuration table fstab = File("fstab". root) # create some subdirs confd = Dir("conf. usr) local = Dir("local".

py". uni) # some python files under uni12 biblio = File("biblioteca. gia) # 2011 and 2012 folders under universita uni11 = Dir("2011". holidaysimgs) himg5 = File("holidays5.jpg". uni12) provetta3 = File("provetta3.jpg". annaimg) # holidays subfolder in /home/anna/images holidaysimgs = Dir("holidays". uni) uni12 = Dir("2012". uni12) # images folder under /home/anna annaimg = Dir("images".jpg".jpg". holidaysimgs) # Finally.# universita under giacomo uni = Dir("universita".py". holidaysimgs) himg3 = File("holidays3.txt for usage and test . holidaysimgs) himg4 = File("holidays4.jpg". annaimg) aimg2 = File("anna2. holidaysimgs) himg2 = File("holidays2. annaimg) # a bunch of pictures inside holidays dir himg1 = File("holidays1. anna) # some pictures of anna in /home/anna/images aimg1 = File("anna1.jpg".jpg". create the file manager fm = FileManager(root) # now see filesystem.

children.parent. parent): # prima di invocare il costruttore della classe base! # Altrimenti ripulisco la lista dei figli dopo averla # inizializzata nel costruttore di File # self.LEZIONE 10 class File: def __init__(self. file): # print('adding child with name ' + file.parent.append(file) def getChildren(self): return self.wdir = directory .children def isDir(self): return True class FileManager: def __init__(self. name. parent): self.__init__(self.getName()) self.FYLESYSTEM_DEFS .name = name if parent != None and self.name def isDir(self): return False class Dir(File): def __init__(self. name. directory): # wdir: working directory self.parent = parent self.getName() + ' to ' + # # # # # # I ## self.addChild(self) def getName(self): return self.isDir() == True: self. parent) def addChild(self.children = [ ] # costruttore classe base File. name.

isDir(): print("Error: cannot change dir to " + f.wdir.wdir = f elif f is not None and not f.children: print(f. then changes to the parent directory """ if name == ".getName()) def cd(self..getName() parent = file.wdir.def pwd(self): """Prints working directory""" print(self.getName() if parentName != '/': s = parentName + '/' + s else: s = parentName + s parent = parent.parent is not None: self.find(name) if f is not None and f.parent return s def recursive_find(self.isDir() == True: self. file.path(self.parent while parent != None: parentName = parent. file): s = file.getName() + ": it is not a valid directory") else: print("Directory " + name + " not found under " + self.wdir.parent else: f = self. name): """Sets the current working directory to the given one."." and self. name): . if exists.wdir.wdir)) def ls(self): """Lists the contents of current directory""" for f in self..wdir = self. If name is ".getName()) def path(self.

wdir. then the first file which is found is returned.getName()) if file.children: self.getName()) for f in curfile.isDir(): for f in file.# print("Searching inside " + file.wdir.recursive_find(self.print_children(f.wdir. Note: if more than one file in the system has the same name. end="") # print a + near a directory.recursive_find(f.getName()) return self." + curfile. name) def print_children(self.isDir(): print("+ " + curfile. name) if found is not None: return found return None def find(self.getName()) def tree(self): """Prints the tree of directories and files in the file system """ self.children: found = self. level): print(" ". name): """Returns a file (or directory) with the provided name.print_children(self. 0) . a . level + 1) # call print_children recursively else: print(". curfile. if it exists. Returns None otherwise. """ # print("Find inside " + self.getName() == name: return file if file. level): """recursion here!""" l=0 # indent for i in range(0.near a simple file if curfile.