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
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
BINOMIALE - LEZIONE 2
# use another module in this directoryfrom fattoriale import fatt
# important! test with <= , < is not enoughwhile minidx <= maxidx:
cyclecnt = cyclecnt + 1# calculate the middle indexmiddleidx = (minidx + maxidx) // 2# look for the value in the middle indexif vector[middleidx] == value:
# note: in Python 2.x print used to work without bracesprint('Found ', value, ' at index ', middleidx, 'cycle ',
cyclecnt)# done, leave the loopbreak
else:# next cycle, if vector[middleidx] < value:
minidx = middleidx + 1else:
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 integersv_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 namesearch(vect, value)
def mypow():"""Questa funzione richiede di inserire la base, l'esponente e restituisce come valore di ritorno la potenza""" # input xx = input("Inserisci la base: ")#input xn = input("Inserisci l'esponente: ")
# conversione da stringa a intero:x = int(x)n = int(n)
# y <-- 1y = 1
# cnt <-- 0cnt = 0
# cnt < n ?while cnt < n:
# y <-- y * xy = y * x
cnt = cnt + 1
return y
SENO - LEZIONE 2
# importiamo la funzione "valore assoluto" dalla libreria math di pythonfrom math import *
# importiamo due moduli precedentemente scritti da noi (devono risiedere #nella medesima # cartella in cui si trova questo file)#from mypower import mypowfrom 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 computatosenx = 0# grado del polinomio (e fattoriale al denominatore)n = 1
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 0index = 0# length of the passed vectorsize = 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 computationbreak
# 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 converti(bin):# scrivere controllo validita' dell'ingresso...
dec = 0fattore = 1i = len(bin) - 1
while i >= 0:# accumulo il valore in base 10 in dec# moltiplicando 1 oppure 0 per 2 elevato alla idec = 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 validofor 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]) + compli = 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 rimanentii = i - 1while i >= 0:
if bin[i] == '0':compl = '1' + compl
else:compl = '0' + compl
i = i - 1return 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 iq = q / fattprimi[i] # dividofatt.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 = nm1 = m
# gestire caso n == 0! # il caso m == 0 e` gestito all'interno del while, membro a destra dell'operatore and
while dieci > 0:resto = dieci % 2dieci = dieci >> 1 # divide per 2b2 = 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 valorestart = 0stop = size - 1
# meta` dell'intervallo, locazione in cui effettuero` il confrontom = (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 trovatoelse:
print("Non trovato")
BUBBLESORT - LEZIONE 4
def busort(v):"""Bubble sort algorithm implementation"""size = len(v)# number of necessary iterationsniter = 0
while size > 1:for i in range(0, size - 1):
niter = niter + 1if 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 iterationsniter = 0
while size > 1:size = size - 1for 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 indexsize = 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
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 0index = 0# length of the passed vectorsize = 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 = maxordc = 0
while r >= 0:
for c in range(0, ord('z') - ord('0')):print(m[r][c], end="")
r = r - 1print("") # a capo
for i in range(ord('0'), ord('z') + 1):print(chr(i), end="")
# creo e popolo la matrice di soli spazimatrix = [ ]row = [ ]# preparo una riga di maxcols elementifor 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 = maxordc = 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 - 1print("") # 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 standardmaxord = 0 # massimo valore assunto dalle "ordinate"
# creo e popolo la matrice di soli spazimatrix = [ ]row = [ ]# preparo una riga di maxcols elementifor 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
# creo e popolo la matrice di soli spazimatrix = [ ]row = [ ]# preparo una riga di maxcols elementifor 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 = 0div = 1extcycle = 0intcycle = 0
while r == 0 and div < n - 1:vartemp = ndiv = div + 1extcycle += 1#print("div", div)
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 1else:
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 fondomuovi(_from, to)# e infine sposta la parte superiore della torre dal piolo# intermedio a quello di destinazionehanoi(n - 1, store, to, _from)
def gioca():num_dischi = int(input("Inserisci numero di dischi: "))_from = 1to = 3store = 2
# 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 = 0right = len(v) - 1mergesort(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 = Falsefor 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 nullaif 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 colonnanext_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):
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 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 letturafin = open(infile, "r")
# in text l'intero testo da analizzaretext = fin.read()
paragrafi = text.split(".\n")
estratti = [ ]
for paragrafo in paragrafi:match = 0for 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
# 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 abbreviatadizionario = 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:
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)
# ----# # Funzioni utilizzatrici delle classi create## Funzione che usa le classi create per iscrivere alcuni studentidef 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")
# ----# # Funzioni utilizzatrici delle classi create## Funzione che usa le classi create per iscrivere alcuni studentidef 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")
# funzione che recupera alcuni studenti dall'istanza di Universita passata # come parametro e registra alcuni esamidef 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]) - 1colonna = ord(colonna) - ord('A')if riga >= 0 and riga < r and colonna >=0 and colonna < c:
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-01-2012")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")
if dim > 0: # prua in x, yfor 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 scontranofor tup in self.pos:
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)
class Scacchiera:def __init__(self, dimX, dimY, numNavi):
self.navi = [ ] # lista di naviself.dimX = dimXself.dimY = dimYmindim = min(dimX, dimY)self.nNavi = numNavi
# se true, disegna() mostra le navi sulla scacchieraself.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)# orientazioneh = 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 = -1else:
orientation = "Vertical"if x > self.dimY // 2:
fattore = -1
print("Creo nave" , x, y, fattore * dimensioneNave, orientation)
nave = Nave(x, y, fattore * dimensioneNave, orientation)
if not collisione:self.navi.append(nave)numeroNavi = numeroNavi + 1# ogni due navi, diminuisco la dimensioneif 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 = 0while col < self.dimY:
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)
# Finally, create the file managerfm = 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)