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

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

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

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

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

MYPOW - 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

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

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

FATTORIPRIMI - LEZIONE 3
from math import floor, sqrt, 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...) def primo(n): """Restituisce True se il numero e` primo, False altrimenti""" for i in range(2, 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.append(i) return primi def scomponi(n): """Scompone il numero n in fattori primi, che sono restituiti in una lista""" fattprimi = numeriprimi(n)

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

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

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

RADICE - 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

BASE10TO2- 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)

BINSEARCH- LEZIONE 4
# Ricerca binaria in un vettore _ordinato_ # Svolto a lezione il giorno 12 novembre 2012 # def search(v, s): size = len(v) # intervallo all'interno del quale cercare il valore start = 0 stop = size - 1 # meta` dell'intervallo, locazione in cui effettuero` il confronto m = (stop + start) // 2 # while stop >= start and v[m] != s: print(m, start, stop) if s > v[m]: start = m + 1 # cerchero` oltre m else: stop = m - 1 # cerchero` prima di m # ricalcolo la meta` del nuovo intervallo [start, stop] # per il confronto all'iterazione successiva # m = (stop + start) // 2 # print(m, start, stop) # se stop >= start, 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")

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

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", niter , "iterations to complete") return v

ORDINA_VETT - LEZIONE 4

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

RADICI - LEZIONE 4

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

# # # #

SEQSEARCH - LEZIONE 4

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

ISTOVER - 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, ord('z') - ord('0')): print(m[r][c], end="") r=r-1 print("") # a capo for i in range(ord('0'), ord('z') + 1): print(chr(i), end="") print("") # a capo def istover(astring): maxrows = len(astring) maxcols = 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, maxcols): row.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, quindi ogni cambiamento # su un vettore riga si ripercuoterebbe su tutte le righe! # for r in range(0, maxrows): matrix.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]) - ord('0') # salto gli elementi che hanno gia' un '*' # sulla colonna corrispondente al carattere # caratt e sulla riga r # perche' maxrows - 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, maxord)

ISTOVER_HOMEWORK - 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): # evito di stampare le colonne vuote.. if m[0][c] != ' ': print(m[r][c], end="") r=r-1 print("") # a capo for i in range(0, 128): if m[0][i] != ' ': print(chr(i), 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, maxcols): row.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, quindi ogni cambiamento # su un vettore riga si ripercuoterebbe su tutte le righe! # for r in range(0, maxrows): matrix.append(row[:]) for i in range(0, 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 - 1 ?? while (r < maxrows - 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, maxord)

ISTOVER_SEMPLIFICATO - 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, ord('z') - ord('0')): print(m[r][c], end="") r=r-1 print("") # a capo for i in range(ord('0'), ord('z') + 1): print(chr(i), end="") print("") # a capo def istover(astring): maxrows = len(astring) maxcols = 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, maxcols): row.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, quindi ogni cambiamento # su un vettore riga si ripercuoterebbe su tutte le righe! # for r in range(0, maxrows): matrix.append(row[:]) for i in range(0, len(astring)): r = 0 # indice di riga caratt = ord(astring[i]) - ord('0') # salto gli elementi che hanno gia' un '*' # sulla colonna corrispondente al carattere # caratt e sulla riga r # perche' maxrows - 1 ?? # se fosse solo maxrows, r nel caso limite raggiungerebbe il # #valore maxrows, # 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, maxord)

NUMERIPRIMI - 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", div) while vartemp > 0: intcycle += 1 vartemp = vartemp - div; #print("vartemp", vartemp) if vartemp == 0: r=1 if r == 1: print("Numero non e` primo: e` divisibile per", div); else: print("Numero primo") print("needed iterations", intcycle * extcycle)

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

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

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

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

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

riga_scambiata = False for i in range(1, rows - l): # cerco l'elemento sotto a quello in posizione (l,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], in modo che ogni elemento m[i][i] sia pari ad 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... for j in range(0, 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.

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

##

# per il coefficiente coeff calcolato. # Il risultato e` che l'elemento sotto # a[row][row] viene annullato. # for column in range(0, ncols): m[next_row][column] = m[next_row][column] + coeff * m[row][column]; ## # 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 - 1

while prev_row >= 0: coeff = -m[prev_row][row] / m[row][row]; for column in range(0, ncols): m[prev_row][column] = m[prev_row][column] + coeff * m[row][column]; prev_row = prev_row - 1 diagonale_unitaria(m) stampa_matrice(m) # # # se voglio restituire la matrice al chiamante return m return 0

CARTESIANO - 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.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

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

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

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

def compress(sms_filename, dictionary_filename, sms_compressed_out): # leggo il testo dell'SMS originale fin = open(sms_filename, "r") testo = fin.read() # chiudo il file!

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

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

def getListaEsami(self): esami = [ ] for esame in self.facolta.getListaEsami(): esami.append(esame.nome) return esami def getEsamiSostenuti(self): esami = [ ] for esame in self.dict_esami.keys(): esami.append(esame) return esami def getEsitoEsami(self): es = dict() for nome in self.dict_esami.keys(): es[nome] = 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, esami): self.nome = nome self.esami = esami self.studenti = [ ] self.professori = [ ] def aggiungiStudente(self, studente): self.studenti.append(studente) def aggiungiProfessore(self, professore): self.professori.append(professore) def getStudente(self, nome, cognome): for studente in self.studenti: if studente.nome == nome and studente.cognome == cognome: return studente # non trovato. None parola chiave che indica nessun oggetto return None

def getStudenti(self): return self.studenti def getProfessori(self): return self.professori def getListaEsami(self): return self.esami class Esame: def __init__(self, nome, crediti): self.nome = nome self.crediti = crediti def setCrediti(self, valore): # suppongo che ogni esame abbia almeno sei crediti e non piu` # di 12 # if valore >= 4 and valore <= 12: self.crediti = valore else: print("Errore: crediti tra 4 e 12")

##

class Universita: def __init__(self, nome, luogo): self.nome = nome self.luogo = luogo self.facolta = {} self.__ultima_matricola = 0 #

#variabile privata in quanto ### #utilizzata solo dalla #classe Universit

self.esami = dict() # costruisco l'universita` con un po' di facolta'... listaEsami = [ ] for es in ["Analisi I", "Chimica", "Geometria", "Fondamenti di Informatica", "Fisica"]: listaEsami.append(Esame(es, 10))

self.esami["Ingegneria"] = listaEsami listaEsami = [ ] # ripulisco e riutilizzo la lista for es in ["Storia dell'arte", "Scienza delle costruzioni", "Matematica", "Geometria"]: listaEsami.append(Esame(es, 8)) self.esami["Architettura"] = listaEsami listaEsami = [ ] for es in ["Diritto Privato", "Diritto Civile", "Storia del diritto", "Filosofia del Diritto"]: listaEsami.append(Esame(es, 8)) self.esami["Giurisprudenza"] = listaEsami listaEsami = [ ] for es in ["Storia della Filosofia", "Estetica", "Filosofia del Linguaggio", "Filosofia della Religione", "Filosofia Teoretica"]: listaEsami.append(Esame(es, 8)) self.esami["Filosofia"] = listaEsami

for nome in ("Ingegneria", "Architettura", "Giurisprudenza", "Filosofia"): f = Facolta(nome, self.esami[nome]) self.facolta[nome] = f def getNomiFacolta(self): return self.facolta.keys() def getListaFacolta(self): return self.facolta.values() def iscriviStudente(self, nome, cognome, nomeFacolta): print("Iscrivo ", nome, cognome, "in facolta'", nomeFacolta) if nomeFacolta in self.facolta.keys(): self.__ultima_matricola = self.__ultima_matricola + 1 s = Studente(nome, cognome, self.__ultima_matricola, self.facolta[nomeFacolta])

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

u.iscriviStudente("Pippo", "Campanella", "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("Paolo", "Croce") paoloCroce.registraEsame("Storia della Filosofia", 18) benedettoCroce = u.getStudente("Benedetto", "Croce") benedettoCroce.registraEsame("Storia della Filosofia", 30) marioRes = u.getStudente("Mario", "Resistenza") marioRes.registraEsame("Fondamenti di Informatica", 22)

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

def getListaEsami(self): esami = [ ] for esame in self.facolta.getListaEsami(): esami.append(esame.nome) return esami def getEsamiSostenuti(self): esami = [ ] for esame in self.dict_esami.keys(): esami.append(esame) return esami def getEsitoEsami(self): es = dict() for nome in self.dict_esami.keys(): es[nome] = 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, esami): self.nome = nome self.esami = esami self.studenti = [ ] self.professori = [ ] def aggiungiStudente(self, studente): self.studenti.append(studente) def aggiungiProfessore(self, professore): self.professori.append(professore) def getStudente(self, nome, cognome): for studente in self.studenti: if studente.nome == nome and studente.cognome == cognome: return studente # non trovato. None parola chiave che indica nessun oggetto return None

def getStudenti(self): return self.studenti def getProfessori(self): return self.professori def getListaEsami(self): return self.esami class Esame: def __init__(self, nome, crediti): self.nome = nome self.crediti = crediti def setCrediti(self, valore): # suppongo che ogni esame abbia almeno sei crediti e non piu` # di 12 # if valore >= 4 and valore <= 12: self.crediti = valore else: print("Errore: crediti tra 4 e 12")

##

class Universita: def __init__(self, nome, luogo): self.nome = nome self.luogo = luogo self.facolta = {} self.__ultima_matricola = 0 #

#variabile privata in quanto ### #utilizzata solo dalla #classe Universit

self.esami = dict() # costruisco l'universita` con un po' di facolta'... listaEsami = [ ] for es in ["Analisi I", "Chimica", "Geometria", "Fondamenti di Informatica", "Fisica"]: listaEsami.append(Esame(es, 10))

self.esami["Ingegneria"] = listaEsami listaEsami = [ ] # ripulisco e riutilizzo la lista for es in ["Storia dell'arte", "Scienza delle costruzioni", "Matematica", "Geometria"]: listaEsami.append(Esame(es, 8)) self.esami["Architettura"] = listaEsami listaEsami = [ ] for es in ["Diritto Privato", "Diritto Civile", "Storia del diritto", "Filosofia del Diritto"]: listaEsami.append(Esame(es, 8)) self.esami["Giurisprudenza"] = listaEsami listaEsami = [ ] for es in ["Storia della Filosofia", "Estetica", "Filosofia del Linguaggio", "Filosofia della Religione", "Filosofia Teoretica"]: listaEsami.append(Esame(es, 8)) self.esami["Filosofia"] = listaEsami

for nome in ("Ingegneria", "Architettura", "Giurisprudenza", "Filosofia"): f = Facolta(nome, self.esami[nome]) self.facolta[nome] = f def getNomiFacolta(self): return self.facolta.keys() def getListaFacolta(self): return self.facolta.values() def iscriviStudente(self, nome, cognome, nomeFacolta): print("Iscrivo ", nome, cognome, "in facolta'", nomeFacolta) if nomeFacolta in self.facolta.keys(): self.__ultima_matricola = self.__ultima_matricola + 1 s = Studente(nome, cognome, self.__ultima_matricola, self.facolta[nomeFacolta])

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

u.iscriviStudente("Pippo", "Campanella", "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("Paolo", "Croce") paoloCroce.registraEsame("Storia della Filosofia", 18) benedettoCroce = u.getStudente("Benedetto", "Croce") benedettoCroce.registraEsame("Storia della Filosofia", 30) marioRes = u.getStudente("Mario", "Resistenza") marioRes.registraEsame("Fondamenti di Informatica", 22)

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

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

BIBLIOTECA - LEZIONE 9
class Articolo: def __init__(self, titolo, autore, collocazione): self.titolo = titolo self.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, titolo, autore, collocazione, genere): Articolo.__init__(self, titolo, autore, collocazione) self.genere = genere self.tipo = "libro" class CD(Articolo): def __init__(self, titolo, autore, collocazione, genere): Articolo.__init__(self, titolo, autore, collocazione) self.tipo = "CD" self.genere = genere # cd in prestito solo per una settimana def durataPrestito(self): return 7 class Cliente: def __init__(self, nome, cognome): self.nome = nome self.cognome = cognome def bonusGiorniPrestito(self): return 0

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

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

dataPrestito): articolo = self.cercaArticolo(titolo, autore) cliente = self.cercaCliente(nomeCliente, cognomeCliente) if articolo != None and cliente != None: prestito = Prestito(cliente, articolo, dataPrestito) self.prestiti.append(prestito) else: print("articolo", titolo, autore, "non trovato oppure cliente", nomeCliente, cognomeCliente, "non iscritto alla biblioteca")

b = Biblioteca("Biblioteca Civica di Trieste", "Trieste") b.aggiungiCliente("Giacomo", "Rossi") b.aggiungiCliente("Bruno", "Verdi") b.aggiungiStudente("Mario", "Resistenza", "Ingegneria") b.aggiungiStudente("Federico", "Croce", "Filosofia") b.aggiungiArticolo("CD06", "The Wall", "Pink Floyd","Rock", "CD") b.aggiungiArticolo("CD16", "Sinfonia 13 Babi Yar", "Shostakovich", "Classica", "CD") b.aggiungiArticolo("L207", "L'interpretazione dei Sogni", "Freud", "Filosofia", "libro") b.aggiungiArticolo("L208", "De sensu rerum et magia", "Campanella", "Filosofia", "libro") b.aggiungiArticolo("L205", "Il mondo come volonta", "Schopenhauer", "Filosofia", "libro") b.registraPrestito("The Wall", "Pink Floyd", "Giacomo", "Rossi", "12-012012") b.registraPrestito( "Il mondo come volonta", "Schopenhauer", "Mario", "Resistenza", "8-12-2012") b.registraPrestito( "L'interpretazione dei Sogni", "Freud", "Federico", "Croce", "9-12-2012") b.registraPrestito("Sinfonia 13 Babi Yar", "Shostakovich", "Federico", "Croce", "9-12-2012")

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

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

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

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

# genero casualmente posizione x e y e orientazione della # nave x = randint(0, self.dimX - 1) y = randint(0, self.dimY - 1) # orientazione h = 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.dimX // 2: fattore = -1 else: orientation = "Vertical" if x > self.dimY // 2: fattore = -1 print("Creo nave" , x, y, fattore * dimensioneNave,

orientation) nave = Nave(x, y, fattore * dimensioneNave, orientation) for n in self.navi: if n.collide(nave): collisione = True print("La nave", n.pos, "collide con", nave.pos) break if not collisione: self.navi.append(nave) numeroNavi = numeroNavi + 1 # ogni due navi, diminuisco la dimensione if numeroNavi % 2 == 0: dimensioneNave = dimensioneNave - 1 if dimensioneNave < 2: print("Il numero di navi e' stato ridotto a", numeroNavi)

# questa funzione disegna ciascuna cella della scacchiera, ###### ## #controllando se # essa e' occupata da una nave (nave.pos.count(cella) > 0) e, se si', se # la nave e' colpita o affondata. # Nella lista self.acqua sono contenute # le tuple che rappresentano le giocate in cui nessuna nave e' stata # colpita. Tutte le altre posizioni sono "mare". # def disegna(self): row = self.dimX - 1 print("") # a capo per dare un po' di spazio.

while row >= 0: # stampo il numero di riga seguito da un carattere di tabulazione per spaziare # i numeri di riga dall'inizio della scacchiera. print(row + 1, "\t|", end="") col = 0 while col < self.dimY: cellaoccupata = False # creo tupla (row, col) tuplepos = (row, col) for nave in self.navi: affondata = nave.affondata() if nave.pos.count(tuplepos) > 0: if affondata: print("X", end="") cellaoccupata = True elif nave.colpita(row, col): print("+", end="") cellaoccupata = True elif self.naviVisibili: cellaoccupata = True

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

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

CARTESIANO - 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.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

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

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

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

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

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