programmi svolti python

BINOMIALE - LEZIONE 2

# use another module in this directoryfrom 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 callerimport 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 = 0cyclecnt = 0maxidx = size - 1

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

FATTORIALE - LEZIONE 2

def fatt(n):i = 1nfatt = 1

while i <= n:nfatt = nfatt * ii = i + 1

print(n , "fattoriale vale", nfatt)print(str(n) + " fattoriale vale " + str(nfatt))print("%d fattoriale vale %d" % (n, nfatt))return nfatt

def fatt_range(n):nfatt = 1

for i in range(1, n + 1):nfatt = nfatt * i

return nfatt

POTENZA - LEZIONE 2

def mypow():"""Questa funzione richiede di inserire la base, l'esponente e restituisce come valore di ritorno la potenza""" # input 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

segno = 1

itcnt = 0

termine_corrente = 1

while(abs(termine_corrente) > precisione): itcnt = itcnt + 1

termine_corrente = segno * mypow(x, n) / fact(n)

senx = senx + termine_corrente

# 1, 3, 5, 7... n = n + 2

# i segni si alternano... segno = -segno

print("iteraz ", itcnt)

print("La funzione sen ha richiesto un polinomio di grado", n-2, "per la precisione richiesta")

return senx

SEQSEARCH - LEZIONE 2

# The def statement makes new functions. Creates a function object and #assigns it to# variable 'search'. Each call to the function generates a new, local scope, #where # assigned names are local to the function call by default.## Arguments are passed by object reference (see function exercise)## 'vett' and 'val' are the formal parameters

def search(vett, val):

# boolean found = False# index in vector used in search. NOTE: index starts from 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 mypow(base, exp):n = 1cnt = 0# while cnt < exp:

n = n * basecnt = cnt + 1

return n

BASE2TO10 - LEZIONE 3

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 m1 != n1 and m1 != 0:if m1 > n1:

m1 = m1 - n1else:

n1 = n1 - m1

print("MCD(" + str(n) + "," + str(m) + ") vale", n1);return n1

MCD_RESTO - LEZIONE 3

def MCD(n, m):

# se n e` minore di m, li scambioif(n < m):

tmp = mm = nn = tmp

# ad un certo punto il resto sara` zero, al limite quando calcolo il #### # resto della divisione

# per uno, se i due numeri sono primi tra loro.#while m != 0:

# salvo m in t temporaneamente (m contiene l'ultimo resto # ####### #calcolato nel ciclo precedente

# o il secondo valore passato in MCD se e` la prima volta che ######## #entro nel ciclo)

t = m m = n % m # il resto n % m e` sempre minore di m

# copio in n il valore temporaneo salvato nella prima istruzione # #del ciclo.

# se m a questo punto vale zero, n contiene l'MCD, altrimenti n # #sara` il

# dividendo nella prossima iterazionen = t

return n

RADICE - LEZIONE 3

from math import fabs

def radice(n, precisione):n1 = nn2 = 1while fabs(n1 - n2) > precisione:

n1 = (n1 + n2)/2n2 = n / n1

return n1

BASE10TO2- LEZIONE 4

def converti(dieci):b2 = ""

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

dell'equazione di secondo grado associata."""

# calcolo delta:delta = b ** 2 - 4 * a * c

if delta == 0:# radici coincidenti:return (-b / (2 * a), -b / (2 * a))

elif delta > 0:# radici reali distinte:return ( (-b + sqrt(delta)) / (2 * a), (-b - sqrt(delta)) / (2 * a))

else:# radici complesse coniugate:re = -b / (2 * a)im = sqrt(-delta) / (2 * a)## Python contempla i numeri complessi (complex) tra i tipi #

# #numerici, # accanto a int, float, long# la funzione complex accetta in ingresso la parte reale e quella

# #immaginaria.# Restituisce il numero complesso associato alla parte reale e #

# #immaginaria.#

# return (complex(re, im), complex(re, -im))

SEQSEARCH - LEZIONE 4

# The def statement makes new functions. Creates a function object and #assigns it to# variable 'search'. Each call to the function generates a new, local scope, #where # assigned names are local to the function call by default.## Arguments are passed by assignment (see function exercise)## 'vett' and 'val' are the formal parameters

def search(vett, val):"""Search a value val inside a vector vett"""

# boolean found = False# index in vector used in search. NOTE: index starts from 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="")

print("") # a capo

def istover(astring):maxrows = len(astring)maxcols = ord('z') - ord('0') maxord = 0 # massimo valore dell'ordinata

# creo e popolo la matrice di soli 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="")


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"


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




caratt = ord(astring[i])


# perche' maxrows - 1 ??while (r < maxrows - 1) and (matrix[r][caratt] != ' '):

r = r + 1

matrix[r][caratt] = '* 'if maxord < r:

maxord = r # salvo il valore massimo assunto dalle ordinate


ISTOVER_SEMPLIFICATO - LEZIONE 5

# seconda versione di istover che stampa tutti i valori delle# ascisse dallo '0' fino alla 'z'## vedi Homework Lezione 4#def print_matrix(m, maxord):

# stampa la matrice dall'alto verso il basso */r = maxordc = 0

while r >= 0:

for c in range(0, ord('z') - ord('0')):print(m[r][c], end="")


for i in range(ord('0'), ord('z') + 1):print(chr(i), end="")

print("") # a capo

def istover(astring):maxrows = len(astring)maxcols = ord('z') - ord('0') maxord = 0 # massimo valore dell'ordinata


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




caratt = ord(astring[i]) - ord('0')


# 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


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)

while vartemp > 0:intcycle += 1vartemp = vartemp - div;#print("vartemp", vartemp)

if vartemp == 0:r = 1

if r == 1:print("Numero non e` primo: e` divisibile per", div);

else:print("Numero primo")

print("needed iterations", intcycle * extcycle)

FATTORIALERICORSIVO - LEZIONE 6

def fact(n):if n == 0:

return 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

hanoi(num_dischi, _from, to, store)

print("Spostati", num_dischi, "dischi _froml piolo", _from, "al piolo", to)

MERGE_SORT - LEZIONE 6

recursion_cnt = 0

# Fonde le due meta` individuate da left, center e right # ordinando gli elementi#def merge (vect, left, center, right): i = left j = center + 1

# define temporary ordered vector temp = []

# scommentare per tracciare l'esecuzione print("merge() entering: ", vect[left:center+1], vect[center+1:right+1], left, center, right)

# confronto elementi appartenenti alla prima meta` con elementi # appartenenti alla seconda meta`. # All'interno di ciascuna meta` infatti gli elementi sono gia` # in ordine. # while i <= center and j <= right: if vect[i] <= vect[j]: temp.append(vect[i]) i = i + 1; else: temp.append(vect[j]) j = j + 1 # aggiungo in coda gli elementi eventualmente non copiati nel ciclo # # ### precedente # while i <= center: temp.append(vect[i])

i = i + 1 # aggiungo in coda gli elementi eventualmente non copiati nel primo ###ciclo # while j <= right: temp.append(vect[j]) j = j + 1

# nello stesso vettore di ingresso salvo gli elementi in temp, # che sono stati ordinati da left a right. # Il range parte da left. for index in range(left, right + 1): vect[index] = temp[index - left] # scommentare per tracciare l'esecuzione print("merge(): leaving: ", vect, left, center, right) return

# Funzione ricorsiva per il riordinamento di un vettore vect da left a right# In questa versione, right deve essere len(vect) - 1, ovvero l'indice del suo # ultimo elemento, non# la lunghezza totale del vettore.# def mergesort(vect, left, right):

# print("merge sort call ", recursion_cnt)# recursion_cnt = recursion_cnt + 1 if left < right: # importante: // center = (left + right) // 2 # scommentare per tracciare l'esecuzione print("mergesort: ", vect, left, right) mergesort(vect, left, center) mergesort(vect, center+1, right) merge(vect, left, center, right)

# funzione principale da chiamare dalla console con il vettore da ordinare# come parametro#def sort(v):

"""Riordina il vettore passato come parametro in ingresso mediante l'algoritmo merge sort"""

left = 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):

m[next_row][column] = m[next_row][column] + coeff * m[row][column];

# prossimo passo, applico il procedimento alla riga # # #successiva

next_row = next_row + 1## ora serve annullare tutti gli elementi sopra la riga row #

# #nella colonna rowprev_row = row - 1

while prev_row >= 0:coeff = -m[prev_row][row] / m[row][row];for column in range(0, ncols):

m[prev_row][column] = m[prev_row][column] + coeff * m[row][column];

prev_row = prev_row - 1

diagonale_unitaria(m)

stampa_matrice(m)

# se voglio restituire la matrice al chiamante## return m

return 0

CARTESIANO - LEZIONE 7

class Shape: def __init__(self): pass def type(self): return '' def draw(self): return

def boundingRect(self): return None

def intersects(self, other): return self.boundingRect().overlaps(other.boundingRect())

class Rect(Shape): def __init__ (self, x, y, a, b): """Costruisce un Rect con lati a e b e top left in x, y""" self.a=a self.b=b self.x=x self.y=y def draw(self): print ("Rect: topLeft %d,%d, %dx%d" % (self.x, self.y , self.a, self.b)) def boundingRect(self): return Rect(self.x, self.y, self.a, self.b) def setRect(self, p0_x, p0_y, a, b): self.a = a self.b = b self.x = p0_x + self.b/2 self.y = p0_y + self.a/2

def overlaps(self, other): return (self.x <= other.x and self.y <= other.y and self.x + self.a > other.x and self.y + self.b > other.y) \

or (other.x <= self.x and other.y <= self.y and other.x + other.a > self.x and other.y + other.b > self.y)

def type(self): return 'r'

class Square(Rect):

def __init__(self, x, y, lato): Rect.__init__(self, lato, lato, x, y)

def type (self): return "q" class Circle (Shape): def __init__(self, x, y, raggio): self.raggio = raggio self.x = x self.y = y def draw (self): print("Circle: centro:", self.x, "raggio", self.raggio) def setRadius(self, r): if r >= 0 : self.raggio=r def boundingRect(self): p0_x = self.x - self.raggio p0_y = self.y - self.raggio l = 2 * self.raggio return Rect(p0_x, p0_y, l , l)

def type(self): return 'c'

class Piano: def __init__(self): self.shapes=[ ]

def add_shape(self,shape): self.shapes.append(shape)

def get_rects(self): rects=[ ] for s in self.shapes: if s.type()=='r': rects.append(s)

return rects def get_circles(self): l=[ ]

for s in self.shapes: if s.type()=='c': l.append(s) return l

ESTRAI_CAPOVERSI - LEZIONE 7

def estrai(infile, parole_chiave, outfile):'''Legge il testo dal file "infile" e cerca le occorrenze di ogni parola chiave contenuta nella lista parole_chiave all'interno di ogni #

#### capoverso. Si suppone che il capoverso sia delimitato da un "punto e #### a capo", che nel formato UNIX e` identificato dal carattere di escape #### "\n" e nel formato DOS"\r\n" (new line + line feed)...La funzione #### scrive sul file individuato da outfile i capoversi trovati,

evidenziando le parole chiave tra due '*' e separandoli con un po' di trattini'''

# numero di parole chiave da controllare numkeywords = len(parole_chiave)

# apro il file in sola 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

chiave:")print(parole_chiave)

fout = open(outfile, "w")

for paragrafo in estratti:fout.write(paragrafo +

"\n\n-----------------------------------------\n\n")

# importante! Chiudere i file aperti!#fout.close()fin.close()

SMSCOMPRESSI - LEZIONE 7

def readDictionary(filename):# apro il file in sola lettura:f = open(filename, "r")

# riempio un dizionario con parola e sua forma 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:

dizionario[parti[0]] = parti[1].replace("\n", "")linea = f.readline()

# quando ho finito, chiudo il filef.close()

return dizionario

def writeCompressedSMS(testo_compresso, nomefile_out):f = open(nomefile_out, "w")f.write(testo_compresso)f.close() # non dimenticare!

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

# chiudo il file!

fin.close()

lunghezza_testo_originale = len(testo)

dizionario = readDictionary(dictionary_filename)

for parola in dizionario.keys():testo = testo.replace(parola, dizionario[parola])

testo_compresso = testo

# scrivi l'SMS compresso sul file di uscita sms_compressed_outwriteCompressedSMS(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




class Square(Rect):



UNIVERSITA' - LEZIONE 8

class Persona:def __init__(self, nome, cognome):

self.nome = nomeself.cognome = cognomeself.mail =""

# quando creo un professore devo specificare # la sua email.#class Professore(Persona):

def __init__(self, nome, cognome, mail):Persona.__init__(self, nome, cognome)self.mail = mailself.ufficio = ""self.telefono = -1

class Studente(Persona):def __init__(self, nome, cognome, matricola, facolta):

Persona.__init__(self, nome, cognome)self.facolta = facoltaself.matricola = matricola# memorizza nomi esami (Stringa) e Esami (oggetti)self.dict_esami = {}

def registraEsame(self, nomeEsame, voto):trovato = Falseesami = self.facolta.getListaEsami()

for esame in esami:if nomeEsame == esame.nome and voto >= 18:

self.dict_esami[nomeEsame] = vototrovato = True

if not trovato:print("Nella facolta", self.facolta.nome, "non c'e` l'esame

di", nomeEsame, "oppure il voto", voto, "non e` valido")

def getListaEsami(self):esami = [ ]for esame in self.facolta.getListaEsami():

esami.append(esame.nome)return esami

def getEsamiSostenuti(self):esami = [ ]for esame in self.dict_esami.keys():

esami.append(esame)return esami

def getEsitoEsami(self):es = dict()for nome in self.dict_esami.keys():

es[nome] = self.dict_esami[nome]return es

class Facolta:# costringo a costruire una facolta con un nome e una lista di esamidef __init__(self, nome, esami):

self.nome = nomeself.esami = esamiself.studenti = [ ]self.professori = [ ]

def aggiungiStudente(self, studente):self.studenti.append(studente)

def aggiungiProfessore(self, professore):self.professori.append(professore)

def getStudente(self, nome, cognome):for studente in self.studenti:

if studente.nome == nome and studente.cognome == cognome:

return studente# non trovato. None parola chiave che indica nessun oggettoreturn None

def getStudenti(self):return self.studenti

def getProfessori(self):return self.professori

def getListaEsami(self):return self.esami

class Esame:def __init__(self, nome, crediti):

self.nome = nomeself.crediti = crediti

def setCrediti(self, valore):# suppongo che ogni esame abbia almeno sei crediti e non piu`

## # di 12# if valore >= 4 and valore <= 12:

self.crediti = valoreelse:

print("Errore: crediti tra 4 e 12")

class Universita:def __init__(self, nome, luogo):

self.nome = nomeself.luogo = luogoself.facolta = {}self.__ultima_matricola = 0 #variabile privata in quanto ###

# #utilizzata solo dalla #classe Università

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

Informatica", "Fisica"]:listaEsami.append(Esame(es, 10))

self.esami["Ingegneria"] = listaEsami

listaEsami = [ ] # ripulisco e riutilizzo la listafor es in ["Storia dell'arte", "Scienza delle costruzioni",

"Matematica", "Geometria"]:listaEsami.append(Esame(es, 8))

self.esami["Architettura"] = listaEsami

listaEsami = [ ]for es in ["Diritto Privato", "Diritto Civile", "Storia del diritto",

"Filosofia del Diritto"]:listaEsami.append(Esame(es, 8))

self.esami["Giurisprudenza"] = listaEsami

listaEsami = [ ]for es in ["Storia della Filosofia", "Estetica", "Filosofia del

Linguaggio", "Filosofia della Religione", "Filosofia Teoretica"]:listaEsami.append(Esame(es, 8))

self.esami["Filosofia"] = listaEsami

for nome in ("Ingegneria", "Architettura", "Giurisprudenza", "Filosofia"):

f = Facolta(nome, self.esami[nome])self.facolta[nome] = f

def getNomiFacolta(self):return self.facolta.keys()

def getListaFacolta(self):return self.facolta.values()

def iscriviStudente(self, nome, cognome, nomeFacolta):print("Iscrivo ", nome, cognome, "in facolta'", nomeFacolta)if nomeFacolta in self.facolta.keys():

self.__ultima_matricola = self.__ultima_matricola + 1s = Studente(nome, cognome, self.__ultima_matricola,

self.facolta[nomeFacolta])

fac = self.facolta[nomeFacolta]print("Iscrivo ", s.nome, s.cognome, "facolta ", fac,

fac.nome)fac.aggiungiStudente(s)

else:print("In questa universita' non c'e' la facolta' di",

nomeFacolta)

def getStudente(self, nome, cognome):for fac in self.facolta.values():

s = fac.getStudente(nome, cognome)if s != None:

return s# non trovatoreturn s # sara' None

def getFacolta(self, nome):return self.facolta[nome]

# ----# # Funzioni utilizzatrici delle classi create## Funzione che usa le classi create per iscrivere alcuni 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")

u.iscriviStudente("Paolo", "Croce", "Filosofia")u.iscriviStudente("Benedetto", "Croce", "Filosofia")u.iscriviStudente("Federico", "Nietzsche", "Filosofia")u.iscriviStudente("Giordano", "Bruno", "Filosofia")

u.iscriviStudente("Pippo", "Campanella", "Filosofia")

return u

# funzione che recupera alcuni studenti dall'istanza di Universita passata # come parametro e registra alcuni 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)

UNIVERSITA' - LEZIONE 8

class Persona:def __init__(self, nome, cognome):

self.nome = nomeself.cognome = cognomeself.mail =""

# quando creo un professore devo specificare # la sua email.#class Professore(Persona):

def __init__(self, nome, cognome, mail):Persona.__init__(self, nome, cognome)self.mail = mailself.ufficio = ""self.telefono = -1

class Studente(Persona):def __init__(self, nome, cognome, matricola, facolta):

Persona.__init__(self, nome, cognome)self.facolta = facoltaself.matricola = matricola# memorizza nomi esami (Stringa) e Esami (oggetti)self.dict_esami = {}

def registraEsame(self, nomeEsame, voto):trovato = Falseesami = self.facolta.getListaEsami()

for esame in esami:if nomeEsame == esame.nome and voto >= 18:

self.dict_esami[nomeEsame] = vototrovato = True

if not trovato:print("Nella facolta", self.facolta.nome, "non c'e` l'esame

di", nomeEsame, "oppure il voto", voto, "non e` valido")

def getListaEsami(self):esami = [ ]for esame in self.facolta.getListaEsami():

esami.append(esame.nome)return esami

def getEsamiSostenuti(self):esami = [ ]for esame in self.dict_esami.keys():

esami.append(esame)return esami

def getEsitoEsami(self):es = dict()for nome in self.dict_esami.keys():

es[nome] = self.dict_esami[nome]return es

class Facolta:# costringo a costruire una facolta con un nome e una lista di esamidef __init__(self, nome, esami):

self.nome = nomeself.esami = esamiself.studenti = [ ]self.professori = [ ]

def aggiungiStudente(self, studente):self.studenti.append(studente)

def aggiungiProfessore(self, professore):self.professori.append(professore)

def getStudente(self, nome, cognome):for studente in self.studenti:

if studente.nome == nome and studente.cognome == cognome:

return studente# non trovato. None parola chiave che indica nessun oggettoreturn None

def getStudenti(self):return self.studenti

def getProfessori(self):return self.professori

def getListaEsami(self):return self.esami

class Esame:def __init__(self, nome, crediti):

self.nome = nomeself.crediti = crediti

def setCrediti(self, valore):# suppongo che ogni esame abbia almeno sei crediti e non piu`

## # di 12# if valore >= 4 and valore <= 12:

self.crediti = valoreelse:

print("Errore: crediti tra 4 e 12")

class Universita:def __init__(self, nome, luogo):

self.nome = nomeself.luogo = luogoself.facolta = {}self.__ultima_matricola = 0 #variabile privata in quanto ###

# #utilizzata solo dalla #classe Università

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

Informatica", "Fisica"]:listaEsami.append(Esame(es, 10))

self.esami["Ingegneria"] = listaEsami

listaEsami = [ ] # ripulisco e riutilizzo la listafor es in ["Storia dell'arte", "Scienza delle costruzioni",

"Matematica", "Geometria"]:listaEsami.append(Esame(es, 8))

self.esami["Architettura"] = listaEsami

listaEsami = [ ]for es in ["Diritto Privato", "Diritto Civile", "Storia del diritto",

"Filosofia del Diritto"]:listaEsami.append(Esame(es, 8))

self.esami["Giurisprudenza"] = listaEsami

listaEsami = [ ]for es in ["Storia della Filosofia", "Estetica", "Filosofia del

Linguaggio", "Filosofia della Religione", "Filosofia Teoretica"]:listaEsami.append(Esame(es, 8))

self.esami["Filosofia"] = listaEsami

for nome in ("Ingegneria", "Architettura", "Giurisprudenza", "Filosofia"):

f = Facolta(nome, self.esami[nome])self.facolta[nome] = f

def getNomiFacolta(self):return self.facolta.keys()

def getListaFacolta(self):return self.facolta.values()

def iscriviStudente(self, nome, cognome, nomeFacolta):print("Iscrivo ", nome, cognome, "in facolta'", nomeFacolta)if nomeFacolta in self.facolta.keys():

self.__ultima_matricola = self.__ultima_matricola + 1s = Studente(nome, cognome, self.__ultima_matricola,

self.facolta[nomeFacolta])

fac = self.facolta[nomeFacolta]print("Iscrivo ", s.nome, s.cognome, "facolta ", fac,

fac.nome)fac.aggiungiStudente(s)

else:print("In questa universita' non c'e' la facolta' di",

nomeFacolta)

def getStudente(self, nome, cognome):for fac in self.facolta.values():

s = fac.getStudente(nome, cognome)if s != None:

return s# non trovatoreturn s # sara' None

def getFacolta(self, nome):return self.facolta[nome]

# ----# # Funzioni utilizzatrici delle classi create## Funzione che usa le classi create per iscrivere alcuni 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")

u.iscriviStudente("Paolo", "Croce", "Filosofia")u.iscriviStudente("Benedetto", "Croce", "Filosofia")u.iscriviStudente("Federico", "Nietzsche", "Filosofia")u.iscriviStudente("Giordano", "Bruno", "Filosofia")

u.iscriviStudente("Pippo", "Campanella", "Filosofia")

return u

# funzione che recupera alcuni studenti dall'istanza di Universita passata # come parametro e registra alcuni 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:

s.colpisci(riga, colonna)s.disegna()

else:print("Coordinate", opzione[0], ",", opzione[1], "

non valide!")

elif opzione.count("ricarica") > 0:s.popolaScacchiera()s.disegna()

elif opzione.count("mostra") >0 and opzione.count("navi") > 0:s.naviVisibili = Trues.disegna()

elif opzione.count("nascondi") >0 and opzione.count("navi") > 0:s.naviVisibili = Falses.disegna()

elif opzione.count("esci") == 0:s.disegna()print("Opzione \"", opzione, "\" non valida\n")

if s.tutteAffondate():print("Complimenti! Hai affondato tutte e", len(s.navi), "le

navi!!")else:

print(":-( peccato! Non ce l'hai fatta!")

else:print("opzioni righe", r, "colonne", c, "numero navi", navi, "non

valide");

BIBLIOTECA - LEZIONE 9

class Articolo:def __init__(self, titolo, autore, collocazione):

self.titolo = titoloself.autore = autoreself.collocazione = collocazioneself.tipo = ""

# valore predefinito per il prestito di un articolo#def durataPrestito(self):

return 30

class Libro(Articolo):def __init__(self, titolo, autore, collocazione, genere):

Articolo.__init__(self, titolo, autore, collocazione)self.genere = genereself.tipo = "libro"

class CD(Articolo):def __init__(self, titolo, autore, collocazione, genere):

Articolo.__init__(self, titolo, autore, collocazione)self.tipo = "CD"self.genere = genere

# cd in prestito solo per una settimanadef durataPrestito(self):

return 7

class Cliente:def __init__(self, nome, cognome):

self.nome = nomeself.cognome = cognome

def bonusGiorniPrestito(self):return 0

def isStudente(self):return False

class Studente(Cliente):def __init__(self, nome, cognome, nomeUniversita):

Cliente.__init__(self, nome, cognome)self.nomeUniversita = nomeUniversita

def bonusGiorniPrestito(self):return 10

def isStudente(self):return True

class Prestito:def __init__(self, cliente, articolo, dataInizio):

self.cliente = clienteself.articolo = articoloself.dataInizioPrestito = dataInizio

def durataPrestito(self):return self.articolo.durataPrestito() +

self.cliente.bonusGiorniPrestito()

class Biblioteca:def __init__(self, nome, luogo):

self.nome = nomeself.luogo = luogo

self.prestiti = [ ]self.clienti = [ ]self.articoli = [ ]

def getListaArticoli(self):return self.articoli

def getListaPrestiti(self):return self.prestiti

def getListaClienti(self):return self.clienti

def aggiungiStudente(self, nome, cognome, universita):s = Studente(nome, cognome, universita)self.clienti.append(s)

def aggiungiCliente(self, nome, cognome):c = Cliente(nome, cognome)self.clienti.append(c)

def aggiungiArticolo(self, collocazione, titolo, autore, genere, tipo):articolo = Noneif tipo == "CD":

articolo = CD(titolo, autore, collocazione, genere)elif tipo == "libro":

articolo = Libro(titolo, autore, collocazione, genere)else:

print("Tipo di articolo non supportato")

if articolo != None:self.articoli.append(articolo)

def cercaArticolo(self, titolo, autore):for articolo in self.articoli:

if articolo.titolo == titolo and articolo.autore == autore:return articolo

return None

def cercaCliente(self, nome, cognome):for cliente in self.clienti:

if cliente.nome == nome and cliente.cognome == cognome:

return clientereturn None

def registraPrestito(self, titolo, autore, nomeCliente, cognomeCliente,

dataPrestito):articolo = self.cercaArticolo(titolo, autore)cliente = self.cercaCliente(nomeCliente, cognomeCliente)

if articolo != None and cliente != None:prestito = Prestito(cliente, articolo, dataPrestito)self.prestiti.append(prestito)

else:print("articolo", titolo, autore, "non trovato oppure

cliente", nomeCliente, cognomeCliente, "non iscritto alla biblioteca")

b = Biblioteca("Biblioteca Civica di Trieste", "Trieste")b.aggiungiCliente("Giacomo", "Rossi")b.aggiungiCliente("Bruno", "Verdi")b.aggiungiStudente("Mario", "Resistenza", "Ingegneria")b.aggiungiStudente("Federico", "Croce", "Filosofia")

b.aggiungiArticolo("CD06", "The Wall", "Pink Floyd","Rock", "CD")b.aggiungiArticolo("CD16", "Sinfonia 13 Babi Yar", "Shostakovich", "Classica", "CD")

b.aggiungiArticolo("L207", "L'interpretazione dei Sogni", "Freud", "Filosofia", "libro")b.aggiungiArticolo("L208", "De sensu rerum et magia", "Campanella", "Filosofia", "libro")b.aggiungiArticolo("L205", "Il mondo come volonta", "Schopenhauer", "Filosofia", "libro")

b.registraPrestito("The Wall", "Pink Floyd", "Giacomo", "Rossi", "12-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")

# >>> sh = B.b.cercaArticolo("Sinfonia 13 Babi Yar", "Shostakovich")# >>> sh.titolo# 'Sinfonia 13 Babi Yar'# >>> sh.autore# 'Shostakovich'

#for prestito in B.b.getListaPrestiti():# print(prestito.articolo.titolo, ",", prestito.articolo.autore, ",", ]# # ### # # prestito.dataInizioPrestito, "-->", prestito.cliente.nome, # àààààààààààà # # prestito.cliente.cognome, " - durata:", prestito.durataPrestito(), àààààààà # prestito.articolo.collocazione)

NAVE - LEZIONE 9

class Nave:def __init__(self, x, y, dim, orientation):

# lista di tuple che contiene le posizioni occupate dalla naveself.pos = [ ]# lista di tuple che contiene le posizioni colpiteself.colpite = [ ]

self.orientation = orientationif orientation == "Vertical":

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:

for othertup in other.pos:if othertup == tup:

return True

return False #nessuna tupla uguale, nessuna intersezione

def colpisci(self, x, y):cell = (x, y)

# il giocatore potrebbe avere colpito due volte nello stesso #### ## # punto..

# quindi non devo inserire tuple duplicate in self.colpite#if self.pos.count(cell) == 1 and self.colpite.count(cell) == 0:

self.colpite.append(cell)return True

return False

def colpita(self, x, y):cell = (x, y)return self.colpite.count(cell) > 0

def affondata(self):# in self.colpite avevo inserito solo tuple gia` contenute in # self.pos e non ho inserito duplicati.# Pertanto basta confrontare le lunghezze#return len(self.pos) == len(self.colpite)

def dimensione(self):return len(self.pos)

def orizzontale(self):return self.orientation == "Horizontal"

NAVE - LEZIONE 9

from nave import *from random import randint

class Scacchiera:def __init__(self, dimX, dimY, numNavi):

self.navi = [ ] # lista di 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)

for n in self.navi:if n.collide(nave):

collisione = Trueprint("La nave", n.pos, "collide con", nave.pos)break

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:

cellaoccupata = False# creo tupla (row, col)tuplepos = (row, col)

for nave in self.navi:affondata = nave.affondata()if nave.pos.count(tuplepos) > 0:

if affondata:print("X", end="")cellaoccupata = True

elif nave.colpita(row, col):print("+", end="")cellaoccupata = True

elif self.naviVisibili:cellaoccupata = True

if nave.orizzontale(): # #rappresentata con "="

print("=", end="")else:

print("#", end="") # #rappresentata con "#"

# nave non colpita, ne' affondata. Se self.naviVisibili # # e' False, allora

# disegno una 'o' se la tupla (row,col) e' in acqua, # # # # altrimenti disegno

# o un'ondina oppure un semplice spazio, in modo # casuale, per "disegnare" il mare#if not cellaoccupata and tuplepos in self.acqua:

print("o", end="")elif not cellaoccupata:

# disegno onde, casualmenteonda = randint(0,1)if onda == 1:

print("~", end="")else:

print(" ", end="")

col = col + 1row = row - 1print("") # a capo dopo una riga

print("\t+", end="")

# disegno il bordo inferiore della scacchierafor i in range(0, self.dimY):

print("-", end="")

print("\n\t ", end="") # a capo + tab + uno spazio

# stampo le lettere della scacchierafor i in range(0, self.dimY):

print(chr(ord('A') + i), end="")

print("\n")

def colpisci(self, x, y):colpita = Falsefor nave in self.navi:

if nave.colpisci(x, y):colpita = Truebreak

if not colpita:self.acqua.append((x,y))

def tutteAffondate(self):for nave in self.navi:

if not nave.affondata():return False

return True




class Square(Rect):



FYLESYSTEM - LEZIONE 10

from filesystem_defs import *

#create root dirroot = Dir("/", None)

# create boot etc usr home under rootboot = Dir("boot", root)etc = Dir("etc", root)usr = Dir("usr", root)home = Dir("home", root)

# create some subdirsconfd = Dir("conf.d", etc)usrbin = Dir("bin", usr)local = Dir("local", usr)usrlocalbin = Dir("bin", local)

# add some files # the C compiler ;-)gcc = File("gcc", usrbin)

# the famous 'vi' text editorvi = File("vi", usrbin)

# the shell iterpreter under /usr/local/binbash = File("bash", usrlocalbin)

# the python interpreterpyt = File("python", usrlocalbin)

# some system configuration files under /etcrcconf = File("rc.conf", confd)

# file system configuration tablefstab = File("fstab", etc)

# 2 home directoriesgia = Dir("giacomo", home)anna = Dir("anna", home)

# universita under giacomouni = Dir("universita", gia)# 2011 and 2012 folders under universitauni11 = Dir("2011", uni)uni12 = Dir("2012", uni)

# some python files under uni12biblio = File("biblioteca.py", uni12)provetta3 = File("provetta3.py", uni12)

# images folder under /home/annaannaimg = Dir("images", anna)

# some pictures of anna in /home/anna/imagesaimg1 = File("anna1.jpg", annaimg)aimg2 = File("anna2.jpg", annaimg)

# holidays subfolder in /home/anna/imagesholidaysimgs = Dir("holidays", annaimg)

# a bunch of pictures inside holidays dir

himg1 = File("holidays1.jpg", holidaysimgs)himg2 = File("holidays2.jpg", holidaysimgs)himg3 = File("holidays3.jpg", holidaysimgs)himg4 = File("holidays4.jpg", holidaysimgs)himg5 = File("holidays5.jpg", holidaysimgs)

# Finally, create the file 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)

programmi svolti python

Documents