P. 1
Programmi Svolti Python

Programmi Svolti Python

|Views: 47|Likes:
Published by Grezoo

More info:

Published by: Grezoo on Jul 07, 2013
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

02/08/2014

pdf

text

original

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

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

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

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

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

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

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. 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 .B: len . compl = str(bin[i]) + compl # 2.. 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.COMPLEMENTO2 .LEZIONE 3 def complementa(bin): compl = "" # controlliamo che il numero sia valido for i in range(0..

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

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

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

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

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

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

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

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

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

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

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

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

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

maxrows): matrix.ord('0') # salto gli elementi che hanno gia' un '*' # sulla colonna corrispondente al carattere # caratt e sulla riga r # perche' maxrows .# 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.append(row[:]) for i in range(0. maxord) . 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]) . quindi ogni cambiamento # su un vettore riga si ripercuoterebbe su tutte le righe! # for r in range(0.

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

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 .# prima di passarlo ad append perche' python passa i # parametri per OBJECT REFERENCE. maxrows): matrix.append(row[:]) for i in range(0. quindi ogni cambiamento # su un vettore riga si ripercuoterebbe su tutte le righe! # for r in range(0. 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.

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

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

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

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

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

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

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

1 mergesort(v.# 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) . right) . left.

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

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

row) # coeff = -m[next_row][row]/m[row][row]. count): m_row_row_nonzero = 1 # elemento della diagonale nullo? if m[row][row] == 0: # cerco sotto la colonna row-ma una riga con colonna # # #row-ma non nulla m_row_row_nonzero = scambiariga(m. 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 # ## . count = min(nrows. ncols) for row in range(0. row) if m_row_row_nonzero: # devo annullare tutti gli elementi delle righe sotto su # # #quella colonna next_row = row + 1 while next_row < nrows: # calcolo il valore del coefficiente atto ad annullare # l'elemento sotto quello di posto (row. n incognite.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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->