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 <-.POTENZA .y * x y=y*x cnt = cnt + 1 return y .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 <-.LEZIONE 2 def mypow(): """Questa funzione richiede di inserire la base.

. # # dove la scrittura x^3 indica x elevato al cubo e cosi` via.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 . la serie di Taylor approssima bene il seno #per un periodo # compreso tra -PI e PI # def sen(x. # # Fermandosi al grado settimo..x^3/3! + x^5/5! .SENO . utilizzando lo #sviluppo in serie di Taylor # # sin(x) = x ..x^7/7! +.

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

# # Arguments are passed by object reference (see function exercise) # # 'vett' and 'val' are the formal parameters def search(vett.LEZIONE 2 # The def statement makes new functions. val . #where # assigned names are local to the function call by default. Creates a function object and #assigns it to # variable 'search'. val.1. "non trovato") . val): # boolean found = False # index in vector used in search.SEQSEARCH . 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". "in posizione". local scope. index) else: print("Valore". NOTE: index starts from 0 index = 0 # length of the passed vector size = len(vett) # NOTE: index < size. Each call to the function generates a new. NOT index <= size! ==> range is from 0 to #####size .

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

LEZIONE 3 def converti(bin): # scrivere controllo validita' dell'ingresso.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]) ..BASE2TO10 .ord('0')) fattore = fattore * 2 i=i-1 return dec .. dec = 0 fattore = 1 i = len(bin) .

.. len(bin)): if bin[i] != '0' and bin[i] != '1': return "Il numero dato in ingresso non e' valido!" # 1. 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 .LEZIONE 3 def complementa(bin): compl = "" # controlliamo che il numero sia valido for i in range(0.1 # N.COMPLEMENTO2 . individuo il primo 1 a partire dalla fine del numero i = len(bin) .B: len . compl = str(bin[i]) + compl # 2.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.

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. n + 1): if primo(i): primi.. 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. sqrt.FATTORIPRIMI ..append(i) return primi def scomponi(n): """Scompone il numero n in fattori primi.) def primo(n): """Restituisce True se il numero e` primo.

append(fattprimi[i]) else: i=i+1 # print("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. "i". i) return fatt ..# # Alcune print qua e la` aiutano a capire cosa succede nel programma #se abbiamo dubbi. # # print("Possibili fattori primi di ". n.. ":". q.

return n1 .D. con l'algoritmo di Euclide def MCD(n." + str(m) + ") vale".C.m1 print("MCD(" + str(n) + ". membro a destra dell'operatore and while m1 != n1 and m1 != 0: if m1 > n1: m1 = m1 .n1 else: n1 = n1 .MCD . n1).LEZIONE 3 # calcolo del M. 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.

n contiene l'MCD. al limite quando calcolo il #### # resto della divisione # per uno. # se m a questo punto vale zero. # 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.MCD_RESTO . m): # se n e` minore di m. se i due numeri sono primi tra loro. li scambio if(n < m): tmp = m m=n n = tmp # ad un certo punto il resto sara` zero. altrimenti n #sara` il # dividendo nella prossima iterazione n=t return n .LEZIONE 3 def MCD(n.

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

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.

stop) # se stop >= start. start. 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.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 . s): size = len(v) # intervallo all'interno del quale cercare il valore start = 0 stop = size . stop) if s > v[m]: start = m + 1 # cerchero` oltre m else: stop = m .1 # meta` dell'intervallo.1 # cerchero` prima di m # ricalcolo la meta` del nuovo intervallo [start.

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

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

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 .

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

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

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".SEQSEARCH . index) else: print("Valore". # # Arguments are passed by assignment (see function exercise) # # 'vett' and 'val' are the formal parameters def search(vett. Each call to the function generates a new. NOT index <= size! ==> range is from 0 to # #size . #where # assigned names are local to the function call by default. val. "in posizione". local scope.1.LEZIONE 4 # The def statement makes new functions. Creates a function object and #assigns it to # variable 'search'. NOTE: index starts from 0 index = 0 # length of the passed vector size = len(vett) # NOTE: index < size. "non trovato") # . val): """Search a value val inside a vector vett""" # boolean found = False # index in vector used in search. val .

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.append(' ') .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') . ord('z') + 1): print(chr(i).ISTOVER . maxcols): row.ord('0')): print(m[r][c]. end="") print("") # a capo def istover(astring): maxrows = len(astring) maxcols = ord('z') . end="") r=r-1 print("") # a capo for i in range(ord('0').

ord('0') # 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.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]) . maxrows): matrix. 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.1 ?? while (r < maxrows .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.

.LEZIONE 5 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. 128): if m[0][i] != ' ': print(chr(i). end="") r=r-1 print("") # a capo for i in range(0.append(' ') # inserisco maxrows righe uguali a row # NOTA BENE!! devo fare una copia di row ogni volta . maxcols): row. if m[0][c] != ' ': print(m[r][c].ISTOVER_HOMEWORK . 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. 128): # evito di stampare le colonne vuote.

maxord) .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.# prima di passarlo ad append perche' python passa i # parametri per OBJECT REFERENCE.append(row[:]) for i in range(0. maxrows): matrix.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.

maxord): # stampa la matrice dall'alto verso il basso */ r = maxord c=0 while r >= 0: for c in range(0.ISTOVER_SEMPLIFICATO . maxcols): row. end="") print("") # a capo def istover(astring): maxrows = len(astring) maxcols = ord('z') . ord('z') + 1): print(chr(i). ord('z') .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('0')): print(m[r][c]. end="") r=r-1 print("") # a capo for i in range(ord('0').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.append(' ') .

# 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 . r nel caso limite raggiungerebbe il # #valore maxrows. maxrows): 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.1) and (matrix[r][caratt] != ' '): r=r+1 matrix[r][caratt] = '*' if maxord < r: maxord = r print_matrix(matrix. maxord) # . len(astring)): r = 0 # indice di riga caratt = ord(astring[i]) . # il quale oltrepassa i limiti della lista! while (r < maxrows .1 ?? # se fosse solo maxrows.

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

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

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

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

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

# 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. right) .

# 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. len(m[i])): print('%g'% (m[i][j]). len(m)): for j in range(0.LEZIONE 6 # Calcolo della soluzione di un sistema lineare di n equazioni in n # # # # # # incognite. # def stampa_matrice(m): """Stampa la matrice arrotondando il valore degli elementi in modo 'generale'. si puo' modificare il programma in modo che esso sia # robusto rispetto a una matrice di ingresso che rappresenta un sistema # impossibile o indeterminato. ovvero in virgola fissa oppure in formato scientifico (esponenziale)""" for i in range(0. Se lo trova.SISTEMALIN . 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. scambia la riga l con la prima riga trovata con elemento non nullo sulla colonna l""" rows = len(m) cols = len(m[0]) .

.. rows): mii = m[i][i] if mii != 0: # altrimenti riga nulla e sistema cala di rango. .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. 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]. 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. rows .riga_scambiata = False for i in range(1.l): # cerco l'elemento sotto a quello in posizione (l. for j in range(0.""" rows = len(m) cols = len(m[0]) for i in range(0. in modo che ogni elemento m[i][i] sia pari ad 1.

count = min(nrows. 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. 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.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. row) # coeff = -m[next_row][row]/m[row][row]. n incognite. ove ogni riga ha lo stesso numero di # # #elementi nrows = len(m) ncols = len(m[0]) # suppongo sistema lineare n eq. # # aggiungo agli elementi della riga next_row gli # elementi della riga row moltiplicati # ## .

for column in range(0. # Il risultato e` che l'elemento sotto # a[row][row] viene annullato. 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 .1 diagonale_unitaria(m) stampa_matrice(m) # # # se voglio restituire la matrice al chiamante return m return 0 . prev_row = prev_row . ncols): m[prev_row][column] = m[prev_row][column] + coeff * m[row][column]. # for column in range(0. ncols): m[next_row][column] = m[next_row][column] + coeff * m[row][column].# per il coefficiente coeff calcolato. ## # prossimo passo.1 # while prev_row >= 0: coeff = -m[prev_row][row] / m[row][row].

x.b)) def boundingRect(self): return Rect(self. p0_x.CARTESIANO .x=x self.y .x = p0_x + self. self.x.%d. b): self. self.a.a.b=b self.y=y def draw(self): print ("Rect: topLeft %d.boundingRect(). y.a=a self.overlaps(other. a.y = p0_y + self. y""" 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.a/2 . other): return self. self. %dx%d" % (self. self.y.boundingRect()) class Rect(Shape): def __init__ (self.b) def setRect(self. b): """Costruisce un Rect con lati a e b e top left in x. a.b = b self.a = a self.b/2 self. self. p0_y.x. self.

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

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

len(estratti)..read() paragrafi = text.split(". parole_chiave.La funzione #### scrive sul file individuato da outfile i capoversi trovati. " *" + parola + "* ") match = match + 1 if match == numkeywords: estratti. 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.ESTRAI_CAPOVERSI . "capoversi con le seguenti parole .LEZIONE 7 def estrai(infile.replace(parola.append(paragrafo) print("Trovati". 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..\n") estratti = [ ] for paragrafo in paragrafi: match = 0 for parola in parole_chiave: if paragrafo. Si suppone che il capoverso sia delimitato da un "punto e #### a capo". "r") # in text l'intero testo da analizzare text = fin.count(parola) > 0: paragrafo = paragrafo. che nel formato UNIX e` identificato dal carattere di escape #### "\n" e nel formato DOS"\r\n" (new line + line feed).

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

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

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

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

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

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

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

"Ingegneria") u. cognome): for fac in self. nome.getStudente(nome.iscriviStudente("Lucia".aggiungiStudente(s) else: print("In questa universita' non c'e' la facolta' di".nome) fac. "Filosofia") u.iscriviStudente("Luca".iscriviStudente("Marta". "Ingegneria") u. nomeFacolta) def getStudente(self. "Nietzsche". "Resistenza".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".facolta.iscriviStudente("Carlo". s. s. "Croce". "Croce". "Ingegneria") u. "Resistenza". "Filosofia") . "Ingegneria") u. "Industria". fac.iscriviStudente("Federico". "Valvola".iscriviStudente("Paolo".fac = self. "Filosofia") u.facolta[nomeFacolta] print("Iscrivo ". cognome) if s != None: return s # non trovato return s # sara' None def getFacolta(self.values(): s = fac. "Trieste") # iscriviamo un po' di studenti in varie facolta` u. "Transistore".cognome.iscriviStudente("Benedetto".iscriviStudente("Mario". "facolta ".iscriviStudente("Giordano".nome. fac. "Ingegneria") u. "Filosofia") u. "Navali". "Ingegneria") u.iscriviStudente("Pippo". nome): return self. "Bruno".

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

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

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

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

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

facolta. nome. fac.iscriviStudente("Carlo".nome. "Valvola". "Ingegneria") u. s. "Resistenza".facolta[nomeFacolta] print("Iscrivo ". "Industria".fac = self. "Navali". fac.iscriviStudente("Giordano".iscriviStudente("Marta".cognome.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". "Filosofia") u. cognome) if s != None: return s # non trovato return s # sara' None def getFacolta(self. "facolta ". "Ingegneria") u. "Filosofia") u.iscriviStudente("Mario".getStudente(nome. nome): return self. nomeFacolta) def getStudente(self. "Nietzsche". "Transistore".iscriviStudente("Federico". "Ingegneria") u.aggiungiStudente(s) else: print("In questa universita' non c'e' la facolta' di". "Trieste") # iscriviamo un po' di studenti in varie facolta` u.nome) fac.iscriviStudente("Pippo". "Bruno". "Croce".values(): s = fac.iscriviStudente("Benedetto". "Ingegneria") u. "Croce". "Resistenza". "Filosofia") u.iscriviStudente("Luca". "Filosofia") . s. "Ingegneria") u. cognome): for fac in self.iscriviStudente("Paolo". "Ingegneria") u.iscriviStudente("Lucia".

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

colonna = opzione[0]..colpisci(riga.\"nascondi navi\" per nascondere le navi") while opzione. " non valide!") elif opzione.ord('A') if riga >= 0 and riga < r and colonna >=0 and colonna < c: s.disegna() opzione = "" print("Inserisci cella. opzione[1].\"esci\" per uscire dal gioco") print(".\"ricarica\" per ricominciare") print(".popolaScacchiera() s. h1 per giocare") print(".count("esci") < 1 and not s. navi) s.".disegna() else: print("Coordinate".upper() riga = int(opzione[1]) . ad es. ". c.\"mostra navi\" per mostrare le navi") print("..popolaScacchiera() s.BATTAGLIANAVALE .1 colonna = ord(colonna) .count("ricarica") > 0: s.disegna() .tutteAffondate(): opzione = input("> ") if len(opzione) == 2: # colonna abcde. colonna) s.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. opzione[0].

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

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

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

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

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

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

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

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

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

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

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

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

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

a = a self. y""" self.y = p0_y + self. b): self.b) def setRect(self.a=a self. other): return self.overlaps(other.y. a. a.y . self. x.b=b self. self.b = b self.%d. %dx%d" % (self.x.a.y=y def draw(self): print ("Rect: topLeft %d. self.x=x self. b): """Costruisce un Rect con lati a e b e top left in x. y.a.boundingRect().x. 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. self. p0_x.boundingRect()) class Rect(Shape): def __init__ (self. p0_y. self.x = p0_x + self.b/2 self.b)) def boundingRect(self): return Rect(self.a/2 .CARTESIANO .

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

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

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

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

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

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

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

Sign up to vote on this title
UsefulNot useful