Risoluzione Tracce di Esame II Modulo

Indice

1 Appello 27 Giugno 2017
2 Appello 26 Luglio 2017
3 Appello 7 Settembre 2017
4 Appello 27 Settembre 2017
5 Appello 08 Novembre 2017
6 Appello 17 Gennaio 2018
7 Appello 14 Febbraio 2018
8 Appello 19 Aprile 2018
9 Appello 20 Giugno 2018
10 Appello 18 Luglio 2018
11 Appello 03 Settembre 2018
12 Appello 24 Settembre 2018
13 Appello 5 Novembre 2018
14 Appello 7 Gennaio 2019
15 Appello 4 Febbraio 2019

Appello 27 Giugno 2017

Esercizio 2: Si ha la necessità di definire tre classi in Python: persona, studente, lavoratore. Le ultime due classi elencate, ovvero studente e lavoratore sono classe derivate dalla classe persona. Scrivere il codice Python che permette di definire le tre classi su elencate (tenendo conto del concetto di ereditarietà) e un piccolo main che ne richiama i metodi definiti. NOTA IMPORTANTE: si definiscano solo gli attributi (3 per la classe persona, 1 specifico di studente, 1 specifico di lavoratore) e i metodi init e str.

Codice Python Di seguito il codice python che modella l'ereditarietà tra le classi.

```
class Persona:
```

    def __init__(self, nome, indirizzo, eta):

```
        self.__nome = nome
```
```
        self.__indirizzo = indirizzo
```
```
        self.__eta = eta
```
```
 
```
```
    def __str__(self):
```

        return "Nome: "+self.__nome+", Indirizzo: "+self.__indirizzo+", Età: "+ str(self.__eta)

```
 
```
```
 
```
```
class Studente(Persona):
```

    def __init__(self, nome, indirizzo, eta, voto):

        Persona.__init__(self, nome, indirizzo, eta)

```
        self.__voto = voto
```
```
 
```
```
    def __str__(self):
```

        return Persona.__str__(self)+", Voto: "+ str(self.__voto)

```
 
```
```
 
```
```
class Lavoratore(Persona):
```

    def __init__(self, nome, indirizzo, eta, stipendio):

        Persona.__init__(self, nome, indirizzo, eta)

```
        self.__stipendio = stipendio
```
```
 
```
```
    def __str__(self):
```

        return Persona.__str__(self)+", Stipendio: "+ str(self.__stipendio)

Di seguito la funzione Main che richiama i metodi definiti.

```
import ereditarieta
```
```
 
```
```
def main():
```

    p = ereditarieta.Persona("Paolo", "Via Italia, 5", 34)

    s = ereditarieta.Studente("Antonio", "Via delle Camelie, 19", 14, 7)

    l = ereditarieta.Lavoratore("Marco", "Piazza Garibaldi, 2", 54, 1000)

```
    print(p)
```
```
    print(s)
```
```
    print(l)
```
```
 
```
```
main()
```

Esercizio 3: Si ha la necessità di leggere da file (.txt) i nomi dei dipendenti e il monte ore (numero non intero) degli stessi.

In particolare, il file è strutturato nel seguente modo:

I nominativi e i monte ore dovranno essere caricati prima in due liste distinte e successivamente ricopiate in un dizionario avente come chiave il nominativo e come elemento il monte ore. Il programma termina, dopo gli opportuni salvataggi, con la stampa a schermo dei nominativi con annesso monte ore e paga lorda (N.B. la paga lorda va calcolata basandosi su un costo orario unico per tutti i dipendenti acquisito da tastiera) secondo il seguente esempio: Nominativo dipendente: Paolo Rossi 47.8 ore lavorate Costo orario: 12.37 € Paga lorda: € 591.28 Nominativo dipendente: Luigi Bianchi 25.4 ore lavorate Costo orario: 12.37 € Paga lorda: € 314.20 …

Scrivere il codice Python, opportunamente strutturato in funzioni, dell’algoritmo che:

acquisisce da tastiera il nome del file da leggere;
legge il file e carica sia la lista dei nominativi che quella del monte ore;
carica il dizionario con i dati inseriti nelle due liste;
salva su file binario il dizionario;
acquisisce da tastiera il costo orario uguale per tutti i dipendenti;
stampa a schermo le informazioni contenute nel dizionario secondo il formato riportato in precedenza;
gestisce le eccezioni che possono essere sollevate.

Codice Python Di seguito il codice python che implementa quanto richiesto.

```
import pickle
```
```
 
```
```
def carica_dati():
```
```
    try:
```
```
        #infile = open('dati.txt','r')
```

        namefile = input('Inserire il nome del file e la sua estensione: ')

```
        infile = open(namefile,'r')
```
```
        dati = infile.readlines()
```
```
        infile.close()
```
```
    except Exception as err:
```
```
        dati = list()
```
```
        print("File non esistente")
```
```
        return dati
```
```
    else:
```
```
        return dati
```
```
 
```
```
def carica_liste(dati):
```
```
    nominativi = list()
```
```
    ore= list()
```
```
    for i in range(0,len(dati),2):
```

        nominativi.append(dati[i].rstrip('\n'))

        ore.append(float(dati[i+1].rstrip('\n')))

```
    return nominativi, ore
```
```
 
```
```
def carica_dizionario(n, o):
```
```
    d = dict()
```
```
    for i in range(0,len(n)):
```
```
        d[n[i]] = o[i]
```
```
    return d
```
```
 
```
```
def salva_dizionario(d):
```
```
    file = open('log.dat','wb')
```
```
    pickle.dump(d, file)
```
```
    file.close()
```
```
 
```
```
def visualizza_info(d, paga_oraria):
```
```
    for key in d:
```
```
        totale = d[key]*paga_oraria
```

        print("Nominativo dipendente: "+key+"\t"+ str(d[key]) + " ore lavorate\t Costo orario: "+str(paga_oraria)+ "€\t Paga lorda € "+str(totale))

```
 
```
```
 
```
```
def main():
```
```
    dati = carica_dati()
```
```
    if (len(dati)>0):
```
```
 
```
```
        try:
```
```
 
```

            nominativi, ore = carica_liste(dati)

```
 
```

            monte_ore_lav = carica_dizionario(nominativi, ore)

```
 
```

            paga_oraria = float(input('Inserire la paga oraria in Euro: '))

```
 
```

            salva_dizionario(monte_ore_lav)

            visualizza_info(monte_ore_lav, paga_oraria)

```
 
```
```
        except Exception as err:
```
```
            print(err)
```
```
 
```
```
main()
```

Esercizio 4: Si ha la necessità di definire una classe di punti 3D. Scrivere il programma Python che permette di definire la classe, gli attributi e i metodi che:

inizializzano il punto con una posizione predefinita;
restituiscono in una stringa le coordinate del punto;
permettono di spostare le coordinate del punto indicando la nuova posizione;
permettono di calcolare la distanza tra due punti;
permettono di effettuare un controllo (vero/falso) dati tre punti (vedi nota importante 2).

Scrivere, inoltre, un breve main che mostri il funzionamento dei metodi definiti.

NOTA IMPORTANTE 1: il metodo che permette di implementare il punto d) deve essere richiamato nel seguente modo: a.calcola_distanza(b) dove a e b sono due punti 3D, mentre il metodo che permette di implementare il punto e) deve essere richiamato nel seguente modo: a.check_condition(b,c) dove a,b e c sono tre punti 3D. NOTA IMPORTANTE 2: Il controllo da effettuare è il seguente. Dati i tre segmenti di misure A (es. a-b), B (es. b-c), C (es. a-c) calcolate grazie alle coordinate dei tre punti, il controllo restituirà valore vero nella seguente condizione: ciascun segmento deve essere minore della somma degli altri due e maggiore della loro differenza, ovvero si devono verificare tutte le seguenti condizioni:

AIUTO: a-b è equivalente alla distanza tra due punti; la funzione che permette di calcolare il valore assoluto è fabs

Codice Python Di seguito il codice python che definisce la classe di punti 3D.

```
import math
```
```
class Punto3D:
```
```
    def __init__(self,x,y,z):
```
```
        self.__x = x
```
```
        self.__y = y
```
```
        self.__z = z
```
```
 
```
```
    def calc_dist(self, b):
```

        x= quadrato_differenza(self.__x,b.get_x())

        y= quadrato_differenza(self.__y,b.get_y())

        z= quadrato_differenza(self.__z,b.get_z())

```
        return math.sqrt(x+y+z)
```
```
 
```
```
    def set_pos(self,x,y,z):
```
```
        self.__x = x
```
```
        self.__y = y
```
```
        self.__z = z
```
```
 
```
```
    def get_x(self):
```
```
        return self.__x
```
```
 
```
```
    def get_y(self):
```
```
        return self.__y
```
```
 
```
```
    def get_z(self):
```
```
        return self.__z
```
```
 
```
```
    def __str__(self):
```

         return "(x: "+str(self.__x) + ", y: "+str(self.__y)+", z: "+str(self.__z)+")"

```
 
```
```
    def check_condition(self,b,c):
```
```
        A = self.calc_dist(b)
```
```
        B = b.calc_dist(c)
```
```
        C = self.calc_dist(c)
```

        if (A<B+C) and (B<A+C) and (C<A+B) and (A>math.fabs(B-C)) and (B>math.fabs(A-C)) and (C>math.fabs(A-B)):

```
            return True
```
```
        else:
```
```
            return False
```
```
 
```
```
 
```
```
 
```
```
def quadrato_differenza(a,b):
```
```
    return (a-b)**2
```

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
import punto
```
```
 
```
```
 
```
```
def main():
```
```
    a = punto.Punto3D(0.0,0.0,0.0)
```
```
    b = punto.Punto3D(1.0,0.0,0.0)
```
```
    c = punto.Punto3D(1.0,1.0,1.0)
```
```
 
```
```
    print("a")
```
```
    print(a)
```
```
    print()
```
```
    print("b")
```
```
    print(b)
```
```
    print()
```
```
    print("c")
```
```
    print(c)
```
```
    print()
```

    print("distanza tra a e b\t" + str(a.calc_dist(b)))

    print("distanza tra a e c\t" + str(a.calc_dist(c)))

```
 
```
```
 
```
```
    if (a.check_condition(b,c)):
```

        print("condizione vera tra a,b e c")

```
    else:
```

        print("condizione falsa tra a,b e c")

```
 
```
```
    a.set_pos(1,2,3)
```
```
    print("nuova posizione di a")
```
```
    print(a)
```
```
 
```
```
main()
```

Appello 26 Luglio 2017

Esercizio 2: Si ha la necessità di definire quattro classi in Python: animale, mammifero, gatto, cane. Le classi elencate sono in relazioni diverse tra loro. Scrivere il codice Python che permette di definire le quattro classi su elencate (tenendo conto del concetto di ereditarietà) e un piccolo main che ne richiama i metodi definiti. NOTA IMPORTANTE: si definiscano solo gli attributi (almeno 3 per la classe base e almeno uno per ogni classe derivata) e i metodi init e str.

Codice Python Di seguito il codice python che modella l'ereditarietà tra le classi.

```
class Animale:
```

    def __init__(self, alimentazione, tipo, eta):

        self.__alimentazione = alimentazione

```
        self.__tipo = tipo
```
```
        self.__eta = eta
```
```
 
```
```
    def __str__(self):
```

        return "Alimentazione: "+self.__alimentazione+", Tipo: "+self.__tipo+", Eta': "+ str(self.__eta)

```
 
```
```
class Mammifero(Animale):
```

    def __init__(self, alimentazione, tipo, eta, zampe):

        Animale.__init__(self, alimentazione, tipo, eta)

```
        self.__zampe = zampe
```
```
 
```
```
    def __str__(self):
```

        return Animale.__str__(self)+", Numero zampe: "+ str(self.__zampe)

```
 
```
```
class Cane(Mammifero):
```

    def __init__(self, alimentazione, tipo, eta, zampe, razza):

        Mammifero.__init__(self, alimentazione, tipo, eta, zampe)

```
        self.__razza = razza
```
```
 
```
```
    def __str__(self):
```

        return Mammifero.__str__(self)+", Razza: "+ str(self.__razza)

```
 
```
```
class Gatto(Mammifero):
```

    def __init__(self, alimentazione, tipo, eta, zampe, razza):

        Mammifero.__init__(self, alimentazione, tipo, eta, zampe)

```
        self.__razza = razza
```
```
 
```
```
    def __str__(self):
```

        return Mammifero.__str__(self)+", Razza: "+ str(self.__razza)

Di seguito la funzione Main che richiama i metodi definiti.

```
import ereditarieta
```
```
 
```
```
def main():
```

    a = ereditarieta.Animale("onnivoro", "acquatico", 3)

    m = ereditarieta.Mammifero("erbivoro", "terrestre", 20, 4)

    c = ereditarieta.Cane("carnivoro", "terrestre", 10, 4, "Labrador")

    g = ereditarieta.Gatto("carnivoro", "terrestre", 7, 4, "Persiano")

```
    print(a)
```
```
    print(m)
```
```
    print(c)
```
```
    print(g)
```
```
 
```
```
main()
```

Esercizio 3: Si ha la necessità di leggere da file (.txt) i nomi degli studenti e i voti ottenuti (numero intero) nei due moduli dell’esame di informatica.

In particolare, il file è strutturato nel seguente modo:

I nominativi e la media dei due voti relativi a tale nominativo dovranno essere caricati prima in due liste distinte e successivamente ricopiate in un dizionario avente come chiave il nominativo e come elemento la media dei voti. Il programma termina, dopo gli opportuni salvataggi, con la stampa a schermo dei nominativi con annessi voti, media esami e risultato dell’esame (Superato/Non Superato) secondo il seguente esempio:

Nominativo dipendente: Paolo Rossi Media voti: 27,5 Esame superato

Nominativo dipendente: Luigi Bianchi Media voti: 17 Esame non superato

…

Scrivere il codice Python, opportunamente strutturato in funzioni, dell’algoritmo che:

acquisisce da tastiera il nome del file da leggere;
legge il file e carica sia la lista dei nominativi che quella delle medie dei voti;
carica il dizionario con i dati inseriti nelle due liste;
salva su file binario il dizionario;
stampa a schermo le informazioni contenute nel dizionario secondo il formato riportato in precedenza;
stampa a schermo un secondo elenco contenente solo i nomi di coloro che hanno superato l’esame;
gestisce le eccezioni che possono essere sollevate.

Codice Python Di seguito il codice python che implementa quanto richiesto.

```
import pickle
```
```
 
```
```
def carica_dati():
```
```
    try:
```
```
        #infile = open('dati.txt','r')
```

        namefile = input('Inserire il nome del file e la sua estensione: ')

```
        infile = open(namefile,'r')
```
```
        dati = infile.readlines()
```
```
        infile.close()
```
```
    except Exception as err:
```
```
        dati = list()
```
```
        print("File non esistente")
```
```
    return dati
```
```
 
```
```
def carica_liste(dati):
```
```
    nominativi = list()
```
```
    medie = list()
```
```
    for i in range(0,len(dati),3):
```

        nominativi.append(dati[i].rstrip('\n'))

        medie.append([(float(dati[i + 1].rstrip('\n')) + float(dati[i + 2].rstrip('\n')))//2])

```
    return nominativi, medie
```
```
 
```
```
def carica_dizionario(n, m):
```
```
    d = dict()
```
```
    for i in range(0,len(n)):
```
```
        d[n[i]] = m[i]
```
```
    return d
```
```
 
```
```
def salva_dizionario(d):
```
```
    file = open('voti.dat','wb')
```
```
    pickle.dump(d, file)
```
```
    file.close()
```
```
 
```

def visualizza_info1(nominativo_media_d):

```
    for key in nominativo_media_d:
```

        print("Nominativo studente: "+key+"\t"+ " Media voti: "+str(nominativo_media_d[key]),end='')

        if nominativo_media_d[key][0] < 18:

            print("\t Esame non superato")

```
        else:
```
```
            print("\t Esame superato")
```
```
 
```

def visualizza_info2(nominativo_media_d):

```
    print("Esame superato da:")
```
```
    for key in nominativo_media_d:
```

        if nominativo_media_d[key][0] >= 18:

```
            print(key)
```
```
 
```
```
def main():
```
```
    dati = carica_dati()
```
```
    if (len(dati)>0):
```
```
        try:
```

            nominativi, medie = carica_liste(dati)

            nominativo_media_d = carica_dizionario(nominativi, medie)

            salva_dizionario(nominativo_media_d)

            visualizza_info1(nominativo_media_d)

            visualizza_info2(nominativo_media_d)

```
        except Exception as err:
```
```
            print(err)
```
```
 
```
```
main()
```

Esercizio 4: Si ha la necessità di definire una classe di triangoli 2D e una classe di punti 2D (che costituiranno i vertici del triangolo). Scrivere il programma Python che permette di definire le classi, gli attributi e i metodi che:

inizializzano il triangolo con le posizioni dei 3 vertici;
restituiscono in una stringa le coordinate dei vertici;
permettono di calcolare il perimetro del triangolo;
permettono di controllare se i tre vertici del triangolo possono essere effettivamente i vertici di un triangolo.

Scrivere, inoltre, un breve main che mostri il funzionamento dei metodi definiti.

NOTA IMPORTANTE 1: Il metodo che permette di implementare il punto d) deve essere richiamato nel seguente modo: t.check_triangle() dove t è un triangolo 2D.

NOTA IMPORTANTE 2: Dati tre segmenti di misure A (es. a-b), B (es. b-c), C (es. a-c), dove a, b e c sono i vertici contenuti nell’oggetto triangolo, per poterci effettivamente costruire un triangolo si deve verificare la seguente condizione: ciascun segmento deve essere minore della somma degli altri due e maggiore della loro differenza.

AIUTO: a-b è equivalente alla distanza tra due punti; la funzione che permette di calcolare il valore assoluto è fabs

Codice Python Di seguito il codice python che definisce la classe di punti 2D.

```
import math
```
```
 
```
```
class Punto2D:
```
```
    def __init__(self,x,y):
```
```
        self.__x = x
```
```
        self.__y = y
```
```
 
```
```
    def calc_dist(self, b):
```

        x= quadrato_differenza(self.__x, b.get_x())

        y= quadrato_differenza(self.__y, b.get_y())

```
        return math.sqrt(x+y)
```
```
 
```
```
    def get_x(self):
```
```
        return self.__x
```
```
 
```
```
    def get_y(self):
```
```
        return self.__y
```
```
 
```
```
    def __str__(self):
```

         return "(x: "+str(self.__x) + ", y: "+str(self.__y)+")"

```
 
```
```
def quadrato_differenza(a, b):
```
```
    return (a-b)**2
```

Di seguito il codice python che definisce la classe Triangolo.

```
import math
```
```
 
```
```
class Triangolo:
```
```
    def __init__(self, a, b, c):
```
```
        self.__a = a
```
```
        self.__b = b
```
```
        self.__c = c
```
```
 
```
```
    def __str__(self):
```

        return "Vertice A: " + str(self.__a) + " Vertice B: " + str(self.__b) + " Vertice C: " + str(self.__c)

```
 
```
```
    def check_triangle(self):
```

        A = self.__a.calc_dist(self.__b)

        B = self.__b.calc_dist(self.__c)

        C = self.__c.calc_dist(self.__a)

        if (A<B+C) and (B<A+C) and (C<A+B) and (A>math.fabs(B-C)) and (B>math.fabs(A-C)) and (C>math.fabs(A-B)):

```
            return True
```
```
        else:
```
```
            return False
```
```
 
```
```
    def perimetro(self):
```

        return self.__a.calc_dist(self.__b) + self.__b.calc_dist(self.__c) + self.__c.calc_dist(self.__a)

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
from punto2d import Punto2D as punto
```
```
from triangolo import Triangolo
```
```
 
```
```
def main():
```
```
    a = punto(0, 0)
```
```
    b = punto(1, 0)
```
```
    c = punto(0, 1)
```
```
 
```
```
    t = Triangolo(a, b, c)
```
```
    print(t)
```
```
    print(t.perimetro())
```
```
    print(t.check_triangle())
```
```
 
```
```
 
```
```
main()
```

Appello 7 Settembre 2017

Esercizio 2: Si ha la necessità di definire quattro classi in Python: gatto, animale, felino, mammifero. Le classi elencate sono in relazioni diverse tra loro. Scrivere il codice Python che permette di definire le quattro classi su elencate (tenendo conto del concetto di ereditarietà) e un piccolo main che ne richiama i metodi definiti.

NOTA IMPORTANTE: si definiscano solo: gli attributi (almeno due per ogni classe); i metodi init e str per ogni classe.

Codice Python Di seguito il codice python che modella l'ereditarietà tra le classi.

```
class Animale:
```

    def __init__(self, alimentazione, tipo):

        self.__alimentazione = alimentazione

```
        self.__tipo = tipo
```
```
 
```
```
    def __str__(self):
```

        return "Alimentazione: "+self.__alimentazione+", Tipo: "+self.__tipo

```
 
```
```
class Mammifero(Animale):
```

    def __init__(self, alimentazione, tipo, eta, zampe):

        Animale.__init__(self, alimentazione, tipo)

```
        self.__eta = eta
```
```
        self.__zampe = zampe
```
```
 
```
```
    def __str__(self):
```

        return Animale.__str__(self)+", Etá: "+ str(self.__eta)+", Numero zampe: "+ str(self.__zampe)

```
 
```
```
class Felino(Mammifero):
```

    def __init__(self, alimentazione, tipo, eta, zampe, dimensione, provenienza):

        Mammifero.__init__(self, alimentazione, tipo, eta, zampe)

```
        self.__dimensione = dimensione
```

        self.__provenienza = provenienza

```
 
```
```
    def __str__(self):
```

        return Mammifero.__str__(self)+", Dimensione: "+ self.__dimensione+", Provenienza: "+ self.__provenienza

```
 
```
```
class Gatto(Felino):
```

    def __init__(self, alimentazione, tipo, eta, zampe, dimensione, provenienza, verso, pelo):

        Felino.__init__(self, alimentazione, tipo, eta, zampe, dimensione, provenienza)

```
        self.__verso = verso
```
```
        self.__pelo = pelo
```
```
 
```
```
    def __str__(self):
```

        return Felino.__str__(self)+", Verso: "+ self.__verso+", Pelo: "+ self.__pelo

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
import ereditarieta
```
```
 
```
```
def main():
```

    a = ereditarieta.Animale("onnivoro", "acquatico")

    m = ereditarieta.Mammifero("erbivoro", "terrestre", 20, 4)

    c = ereditarieta.Felino("carnivoro", "terrestre", 10, 4, "Taglia grande", "Africa")

    g = ereditarieta.Gatto("carnivoro", "terrestre", 7, 4, "Taglia piccola", "Europa", "Miagolio", "Pelo Lungo")

```
    print(a)
```
```
    print(m)
```
```
    print(c)
```
```
    print(g)
```
```
 
```
```
main()
```

Esercizio 3: Si ha la necessità di leggere da file (.txt) le coordinate x, y, z di punti 3D e di calcolarne il baricentro. In particolare, il file delle coordinate è strutturato nel seguente modo:

Scrivere il codice Python dell’algoritmo che :

definisce la classe dei punti 3D;
acquisisce da tastiera il nome del file da leggere;
legge il file e carica la lista di punti 3D;
calcola il baricentro dei punti 3D a partire dalla lista di punti;
stampa a schermo le coordinate del baricentro (inteso come ulteriore punto 3D);
gestisce le eccezioni che possono essere sollevate;
richiama le funzioni viste (main).

Lista punti d'esempio punti.txt

0.0
0.0
0.0
1.0
1.0
1.0
2.0
2.0
2.0
3.0
3.0
3.0
4.0
4.0
4.0
5.0
5.0
5.0

Codice Python Di seguito il codice python che modella l'ereditarietà tra le classi.

```
import math
```
```
class Punto3D:
```
```
    def __init__(self,x,y,z):
```
```
        self.__x = x
```
```
        self.__y = y
```
```
        self.__z = z
```
```
 
```
```
    def set_pos(self,x,y,z):
```
```
        self.__x = x
```
```
        self.__y = y
```
```
        self.__z = z
```
```
 
```
```
    def get_x(self):
```
```
        return self.__x
```
```
 
```
```
    def get_y(self):
```
```
        return self.__y
```
```
 
```
```
    def get_z(self):
```
```
        return self.__z
```
```
 
```
```
    def __str__(self):
```

         return "(x: "+str(self.__x) + ", y: "+str(self.__y)+", z: "+str(self.__z)+")"

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
import punto3d
```
```
 
```
```
def carica_dati():
```
```
    try:
```

        namefile = input('Inserire il nome del file e la sua estensione: ')

```
        infile = open(namefile,'r')
```
```
        dati = infile.readlines()
```
```
        infile.close()
```
```
    except Exception as err:
```
```
        dati = list()
```
```
        print("File non esistente")
```
```
    return dati
```
```
 
```
```
 
```
```
def carica_lista_punti(dati):
```
```
    lista_punti = list()
```
```
    for i in range(0,len(dati),3):
```
```
        x = float(dati[i].rstrip('\n'))
```

        y = float(dati[i+1].rstrip('\n'))

        z = float(dati[i+2].rstrip('\n'))

```
        p = punto3d.Punto3D(x,y,z)
```
```
        lista_punti.append(p)
```
```
    return lista_punti
```
```
 
```
```
 
```
```
def calcola_baricentro(lista):
```
```
    x = 0.0
```
```
    y = 0.0
```
```
    z = 0.0
```
```
    for i in lista:
```
```
        x+=i.get_x()
```
```
        y+=i.get_y()
```
```
        z+=i.get_z()
```
```
    n = len(lista)
```

    baricentro = punto3d.Punto3D(x/n,y/n,z/n)

```
    return baricentro
```
```
 
```
```
 
```
```
def main():
```
```
    dati = carica_dati()
```
```
    if (len(dati)>0):
```
```
        try:
```

            lista_punti = carica_lista_punti(dati)

            print("Il baricentro dei punti contenuti nel file e'"+str(calcola_baricentro(lista_punti)))

```
        except Exception as err:
```
```
            print(err)
```
```
 
```
```
main()
```

Esercizio 4: Si ha la necessità di gestire un campionato sportivo. In particolare, il campionato dovrà essere modellato come una classe (in modo tale da poter istanziare campionati di diverse nazionalità) che contiene le due informazioni fondamentali di ciascuna squadra del campionato: il nome e il punteggio ottenuto in campionato. Non possono esserci due squadre con lo stesso nome all’interno dello stesso campionato. NOTA: selezionare in modo opportuno la struttura dati che dovrà contenere le due informazioni relative a ciascuna squadra e che dovrà essere contenuta nella classe campionato.

Scrivere il programma Python che permette di definire le classi, gli attributi, le strutture dati e i metodi che:

inizializzano il campionato con un certo numero di squadre deciso dall’utente;
permettono di stabilire la squadra vincitrice del campionato e di visualizzarne le informazioni a schermo;
permettono di stabilire le ultime tre squadre in classifica e di visualizzarne le informazioni a schermo.

Scrivere, inoltre, un breve main che mostri il funzionamento dei metodi definiti.

Codice Python

```
class Campionato:
```
```
 
```
```
    def __init__(self):
```
```
        self.__s = dict()
```
```
 
```

    def add_team(self, nome, punteggio):

```
        self.__s[nome] = punteggio
```
```
 
```
```
    def get_team(self, nome):
```
```
        self.__s.get(nome,-10)
```
```
 
```
```
    def delete_team(self, nome):
```
```
        self.__s.pop(nome, 0)
```
```
 
```
```
    def get_first_team(self):
```
```
        if len(self.__s)>0:
```
```
            m=max(self.__s.values())
```
```
            for key in self.__s:
```
```
                if self.__s[key]==m:
```
```
                    return key, m
```
```
        else:
```
```
            return "",0
```
```
 
```
```
    def get_last_team(self):
```
```
        if len(self.__s)>0:
```
```
            m=min(self.__s.values())
```
```
            for key in self.__s:
```
```
                if self.__s[key]==m:
```
```
                    return key, m
```
```
        else:
```
```
            return "",0
```
```
 
```
```
    def get_number_of_team(self):
```
```
        return len(self.__s)
```
```
 
```
```
    def __str__(self):
```
```
        return str(self.__s)
```

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
import campionato
```
```
 
```
```
def main():
```
```
    c = campionato.Campionato()
```

    n = int(input("Da quante squadre e' composto il campionato? "))

```
    for i in range(0,n):
```

        nome_squadra = input("Inserire il nome della squadra: ")

        punteggio = int(input("Inserire il punteggio ottenuto dalla squadra "+nome_squadra+": "))

        c.add_team(nome_squadra, punteggio)

    print("Il campionato e' formato da "+str(c.get_number_of_team())+" squadre")

```
    if c.get_number_of_team()>1:
```
```
        squadra, p = c.get_first_team()
```

        print("La squadra che ha vinto il campionato e' "+squadra+" con un punteggio di "+str(p)+" punti")

```
    if c.get_number_of_team()>0:
```

        print("Le ultime 3 squadre del campionato sono:")

        #s servirá per ripristinare tutte le squadre cancellate

```
        s = dict()
```
```
        for i in range(0,3):
```

            squadra, p = c.get_last_team()

```
            s[squadra]=p
```
```
            c.delete_team(squadra)
```

            print(squadra+" con un punteggio di "+str(p)+" punti")

```
 
```

        #ripristina lo stato del campionato

```
        for k in s:
```
```
            c.add_team(k, s[k])
```
```
 
```

    #verifichiamo che il numero delle squadre e lo stato del campionato sia lo stesso di quello iniziale

    print("Il campionato e' formato da "+str(c.get_number_of_team())+" squadre")

```
    print(c)
```
```
 
```
```
main()
```

Appello 27 Settembre 2017

Esercizio 2: Si ha la necessità di definire tre classi in Python: operaio, persona, lavoratore. Le classi elencate sono in relazioni diverse tra loro. Scrivere il codice Python che permette di definire le tre classi su elencate (tenendo conto del concetto di ereditarietà) e un piccolo main che ne richiama i metodi definiti.

NOTA IMPORTANTE: si definiscano solo: gli attributi (almeno due per ogni classe); i metodi init, get/set e str per ogni classe.

Codice Python Di seguito il codice python che modella l'ereditarietà tra le classi.

```
class Persona:
```
```
    def __init__(self, eta, altezza):
```
```
        self.__eta = eta
```
```
        self.__altezza = altezza
```
```
 
```
```
    def get_eta(self):
```
```
        return self.__eta
```
```
 
```
```
    def set_eta(self, eta):
```
```
        self.__eta = eta
```
```
 
```
```
    def get_altezza(self):
```
```
        return self.__altezza
```
```
 
```
```
    def set_altezza(self, altezza):
```
```
        self.__altezza = altezza
```
```
 
```
```
    def __str__(self):
```

        return "Etá: "+str(self.__eta)+", Altezza: "+str(self.__altezza)

```
 
```
```
class Lavoratore(Persona):
```

    def __init__(self, eta, altezza, stipendio, ore_lav):

        Persona.__init__(self, eta, altezza)

```
        self.__stipendio = stipendio
```
```
        self.__ore_lav = ore_lav
```
```
 
```
```
    def get_stipendio(self):
```
```
        return self.__stipendio
```
```
 
```
```
    def set_stipendio(self, stipendio):
```
```
        self.__stipendio = stipendio
```
```
 
```
```
    def get_ore_lav(self):
```
```
        return self.__ore_lav
```
```
 
```
```
    def set_ore_lav(self, ore_lav):
```
```
        self.__ore_lav = ore_lav
```
```
 
```
```
    def __str__(self):
```

        return Persona.__str__(self)+", Stipendio: "+ str(self.__stipendio)+", Ore lavorate: "+ str(self.__ore_lav)

```
 
```
```
class Operaio(Lavoratore):
```

    def __init__(self, eta, altezza, stipendio, ore_lav, mansione, unita):

        Lavoratore.__init__(self, eta, altezza, stipendio, ore_lav)

```
        self.__mansione = mansione
```
```
        self.__unita = unita
```
```
 
```
```
    def get_mansione(self):
```
```
        return self.__mansione
```
```
 
```
```
    def set_mansione(self, mansione):
```
```
        self.__mansione = mansione
```
```
 
```
```
    def get_unita(self):
```
```
        return self.__unita
```
```
 
```
```
    def set_unita(self, unita):
```
```
        self.__unita = unita
```
```
 
```
```
    def __str__(self):
```

        return Lavoratore.__str__(self)+", Mansione: "+ self.__mansione+", Unitá: "+ self.__unita

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
import ereditarieta
```
```
 
```
```
def main():
```
```
    a = ereditarieta.Persona(15, 145)
```

    m = ereditarieta.Lavoratore(19, 170, 1000, 160)

    c = ereditarieta.Operaio(35, 175, 1500, 180, "Movimentazione", "Auto")

```
 
```
```
    print(a)
```
```
    print(m)
```
```
    print(c)
```
```
    print(c.get_altezza())
```
```
    m.set_stipendio(1450)
```
```
    print(m)
```
```
 
```
```
main()
```

Esercizio 3: Si ha la necessità di gestire un’agenzia immobiliare. In particolare, ogni casa in gestione all’agenzia immobiliare ha un suo codice univoco alfanumerico e diverse informazioni (circa 6) tra cui il prezzo di vendita. La tipica richiesta rivolta all’operatore dell’agenzia immobiliare è quella di trovare le case all’interno di un range di prezzo.

definisce un oggetto casa con le informazioni ad essa relative;
inizializza le informazioni di cui al punto precedente;
gestisce il dizionario delle case ed i codici identificativi delle stesse;
salva su file binario tutte le case;
stampa a schermo il catalogo case gestite dall’agenzia immobiliare;
richiede all’utente gli estremi del range di prezzo e stampa a schermo tutte le case che rientrano in tale range;
gestisce le eccezioni che possono essere sollevate;
richiama tutte le funzioni viste (main).

NOTA: l’eventuale ridondanza di codici identificativi delle case verrà penalizzata nel punteggio.

Codice Python

```
class Casa:
```
```
 
```

    def __init__(self, prezzo, n_vani=1, mq = 50, ascensore = "si", condominio = "si", garage = "si"):

```
        self.__prezzo = prezzo
```
```
        self.__n_vani = n_vani
```
```
        self.__mq = mq
```
```
        self.__ascensore = ascensore
```
```
        self.__condominio = condominio
```
```
        self.__garage = garage
```
```
 
```
```
 
```
```
    def set_prezzo(self, prezzo):
```
```
        self.__prezzo=prezzo
```
```
 
```
```
    def set_n_vani(self,n_vani):
```
```
        self.__n_vani=n_vani
```
```
 
```
```
    def set_mq(self, mq):
```
```
        self.__mq= mq
```
```
 
```
```
    def set_ascensore(self, ascensore):
```
```
        self.__ascensore= ascensore
```
```
 
```

    def set_condominio(self, condominio):

```
        self.__condominio= condominio
```
```
 
```
```
    def set_garage(self, garage):
```
```
        self.__garage= garage
```
```
 
```
```
    def get_prezzo(self):
```
```
        return self.__prezzo
```
```
 
```
```
    def get_n_vani(self):
```
```
        return self.__n_vani
```
```
 
```
```
    def get_mq(self):
```
```
        return self.__mq
```
```
 
```
```
    def get_ascensore(self):
```
```
        return self.__ascensore
```
```
 
```
```
    def get_condominio(self):
```
```
        return self.__condominio
```
```
 
```
```
    def get_garage(self):
```
```
        return self.__garage
```
```
 
```
```
    def __str__(self):
```

        return "Prezzo: "+str(format(self.__prezzo,".2f"))+" €, N. vani: "+str(self.__n_vani)+", Metri quadri: "+str(self.__mq)+", Ascensore: "+self.__ascensore+\

               ", Condominio: "+self.__condominio+", Garage: "+self.__garage

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
from casa import Casa
```
```
import pickle
```
```
 
```
```
ADD_HOUSE = 1
```
```
DELETE_HOUSE = 2
```
```
PRINT_HOUSES = 3
```
```
SAVE = 4
```
```
QUIT_CHOICE = 5
```
```
 
```
```
 
```
```
def display_menu():
```
```
    print()
```
```
    print("MENU")
```

    print("1) Inserire una nuova casa da gestire")

    print("2) Eliminare una casa dall'elenco")

    print("3) Stampare a schermo tutte le case in gestione")

    print("4) Salvare le informazioni delle case in memoria")

```
    print("5) Uscire dal programma")
```
```
    print()
```
```
 
```
```
def ask_house_info():
```
```
    try:
```

        prezzo = float(input("Inserire il prezzo della casa: "))

        n_vani = float(input("Inserire il numero dei vani della casa: "))

        mq = float(input("Inserire i metri quadri della casa: "))

        ascensore = input("La casa dispone di ascensore? ")

        condominio = input("La casa e' inserita in un condominio? ")

        garage = input("La casa dispone di un garage? ")

        c = Casa(prezzo, n_vani, mq, ascensore, condominio, garage)

```
        return c
```
```
    except Exception as err:
```
```
        print(err)
```
```
        return 1
```
```
 
```
```
def main():
```
```
    agenzia = dict()
```
```
 
```
```
    choice = 0
```
```
    while choice != QUIT_CHOICE:
```
```
        display_menu()
```
```
 
```

        choice = int(input('Inserire la scelta: '))

```
 
```
```
        if choice == ADD_HOUSE:
```

            codice = input("Inserire il codice univoco della casa: ")

```
            c = ask_house_info()
```
```
            if c!=1:
```
```
                agenzia[codice] = c
```
```
 
```
```
        elif choice == DELETE_HOUSE:
```

            codice = input("Inserire il codice univoco della casa da eliminare: ")

```
            print()
```
```
            if codice in agenzia:
```
```
                del agenzia[codice]
```

                print("La casa con "+codice+" e' stata eliminata")

```
            else:
```

                print("Codice univoco della casa non corretto")

```
            print()
```
```
 
```
```
        elif choice == PRINT_HOUSES:
```
```
            print()
```
```
            if len(agenzia)==0:
```

                print("Nessuna casa in gestione")

```
            else:
```
```
                for key in agenzia:
```

                    print("Codice: "+key+" - "+str(agenzia[key]))

```
                    print()
```
```
 
```
```
        elif choice == SAVE:
```

            namefile = input("Inserire il nome del file dove memorizzare i dati delle case: ")

```
            file = open(namefile,'wb')
```
```
            pickle.dump(agenzia, file)
```
```
            file.close()
```
```
 
```
```
        elif choice!= QUIT_CHOICE:
```

            print('Errore: scelta non valida')

```
 
```
```
 
```
```
main()
```

Appello 08 Novembre 2017

Esercizio 2: Si ha la necessità di definire quattro classi in Python: Mammifero, Felino, Canidi, Gatto. Le classi elencate sono in relazioni diverse tra loro. Scrivere il codice Python che permette di definire le quattro classi su elencate (tenendo conto del concetto di ereditarietà) e un piccolo main che ne richiama i metodi definiti.

NOTA IMPORTANTE: si definiscano solo: gli attributi (almeno due per ogni sottoclasse); i metodi init, get, set e str per ogni classe.

Codice Python Di seguito il codice python che modella l'ereditarietà tra le classi.

```
class Mammifero:
```

    def __init__(self, eta, alimentazione):

```
        self.__eta = eta
```

        self.__alimentazione = alimentazione

```
 
```
```
    def get_eta(self):
```
```
        return self.__eta
```
```
 
```
```
    def set_eta(self, eta):
```
```
        self.__eta = eta
```
```
 
```
```
    def get_alimentazione(self):
```
```
        return self.__alimentazione
```
```
 
```

    def set_alimentazione(self, alimentazione):

        self.__alimentazione = alimentazione

```
 
```
```
    def __str__(self):
```

        return "Etá: "+str(self.__eta)+", Alimentazione: "+str(self.__alimentazione)

```
 
```
```
class Felino(Mammifero):
```

    def __init__(self, eta, alimentazione, habitat, pelo):

        Mammifero.__init__(self, eta, alimentazione)

```
        self.__habitat = habitat
```
```
        self.__pelo = pelo
```
```
 
```
```
    def get_habitat(self):
```
```
        return self.__habitat
```
```
 
```
```
    def set_habitat(self, habitat):
```
```
        self.__habitat = habitat
```
```
 
```
```
    def get_pelo(self):
```
```
        return self.__pelo
```
```
 
```
```
    def set_pelo(self, pelo):
```
```
        self.__pelo = pelo
```
```
 
```
```
    def __str__(self):
```

        return Mammifero.__str__(self)+", Habitat: "+ str(self.__habitat)+", Pelo: "+ str(self.__pelo)

```
 
```
```
class Canide(Mammifero):
```

    def __init__(self, eta, alimentazione, verso, origine):

        Mammifero.__init__(self, eta, alimentazione)

```
        self.__verso = verso
```
```
        self.__origine = origine
```
```
 
```
```
    def get_verso(self):
```
```
        return self.__verso
```
```
 
```
```
    def set_verso(self, verso):
```
```
        self.__verso = verso
```
```
 
```
```
    def get_origine(self):
```
```
        return self.__origine
```
```
 
```
```
    def set_origine(self, origine):
```
```
        self.__origine = origine
```
```
 
```
```
    def __str__(self):
```

        return Mammifero.__str__(self)+", Verso: "+ str(self.__verso)+" Origine: "+ str(self.__origine)

```
 
```
```
class Gatto(Felino):
```

    def __init__(self, eta, alimentazione, habitat, pelo, razza, colore):

        Felino.__init__(self, eta, alimentazione, habitat, pelo)

```
        self.__razza = razza
```
```
        self.__colore = colore
```
```
 
```
```
    def get_razza(self):
```
```
        return self.__razza
```
```
 
```
```
    def set_razza(self, razza):
```
```
        self.__razza = razza
```
```
 
```
```
    def get_colore(self):
```
```
        return self.__colore
```
```
 
```
```
    def set_colore(self, colore):
```
```
        self.__colore = colore
```
```
 
```
```
    def __str__(self):
```

        return Felino.__str__(self)+", Razza: "+ self.__razza+", Colore: "+ self.__colore

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
import ereditarieta
```
```
 
```
```
def main():
```

    a = ereditarieta.Mammifero(15, "Vegetariano")

    b = ereditarieta.Felino(13, "Carnivoro", "Savana", "Lungo")

    c = ereditarieta.Gatto(4, "Carnivoro", "Domestico", "Corto", "Siamese", "Bianco")

    d = ereditarieta.Canide(1, "Onnivoro", "Abbaiare", "Germania")

```
 
```
```
    print(a)
```
```
    print(b)
```
```
    print(c)
```
```
    print(d)
```
```
    print(c.get_colore())
```
```
    print(c.get_habitat())
```
```
    d.set_origine("Italia")
```
```
    print(d)
```
```
 
```
```
main()
```

Esercizio 3: Si ha la necessità di gestire un laboratorio per l’analisi del sangue. In particolare, ogni parametro ematico che può essere analizzato dal laboratorio ha un suo codice univoco alfanumerico e le seguenti 5 informazioni: nome parametro, minimo (valore numerico), massimo (valore numerico), unità di misura, descrizione. Tali dati sono organizzati in un dizionario per cui:

la chiave corrisponde al codice univoco alfanumerico del parametro ematico;
il “valore” corrisponde alle informazioni del parametro ematico organizzate in una classe.

Tale dizionario è memorizzato in un file binario. La tipica richiesta rivolta all’operatore del laboratorio, a seguito dell’analisi del sangue di una persona, è quella di inserire manualmente i codici alfanumerici dei parametri ematici della persona e i corrispondenti valori risultanti dall’analisi. Si richiede sia di rappresentare uno schema grafico (non formale) delle strutture dati utilizzate sia di scrivere il codice Python dell’algoritmo che:

definisce un oggetto parametro ematico con le informazioni ad essa relative;
inizializza il dizionario leggendo da file binario;
stampa a schermo tutti i valori di riferimento contenuti nel dizionario;
permette all’operatore di interrogare N (a scelta dello stesso operatore) volte il sistema inserendo N volte i codici alfanumerici dei parametri ematici della persona e i corrispondenti valori risultanti dall’analisi. In particolare, per ciascuna interrogazione:
- dopo che l’operatore avrà inserito il codice alfanumerico corrispondente ad un parametro ematico, dovranno essere stampate a schermo tutte le informazioni relative a tale parametro ematico;
- dopo la stampa di tutte le informazioni, l’operatore dovrà poter inserire il valore del parametro ematico e ricevere un messaggio per sapere se il valore è nel range o fuori range;
gestisce le eccezioni che possono essere sollevate;
richiama tutte le funzioni viste (main).

NOTA: l’eventuale ridondanza di codici identificativi delle case verrà penalizzata nel punteggio.

Codice Python

```
class PE:
```
```
 
```

    def __init__(self, nome, minimo, massimo, u_misura, descrizione):

```
        self.__nome = nome
```
```
        self.__minimo = minimo
```
```
        self.__massimo = massimo
```
```
        self.__u_misura = u_misura
```

        self.__descrizione = descrizione

```
 
```
```
 
```
```
    def set_nome(self, nome):
```
```
        self.__nome=nome
```
```
 
```
```
    def set_minimo(self,minimo):
```
```
        self.__minimo=minimo
```
```
 
```
```
    def set_massimo(self, massimo):
```
```
        self.__massimo= massimo
```
```
 
```
```
    def set_u_misura(self, u_misura):
```
```
        self.__u_misura= u_misura
```
```
 
```

    def set_descrizione(self, descrizione):

```
        self.__descrizione= descrizione
```
```
 
```
```
    def get_nome(self):
```
```
        return self.__nome
```
```
 
```
```
    def get_minimo(self):
```
```
        return self.__minimo
```
```
 
```
```
    def get_massimo(self):
```
```
        return self.__massimo
```
```
 
```
```
    def get_u_misura(self):
```
```
        return self.__u_misura
```
```
 
```
```
    def get_descrizione(self):
```
```
        return self.__descrizione
```
```
 
```
```
    def __str__(self):
```

        return "Parametro ematico\nNome: "+self.__nome+" - Range = minimo: "+str(format(self.__minimo,".2f"))+"- massimo: "+str(format(self.__massimo,".2f"))+", u_misura: "+self.__u_misura+\

               ", descrizione: "+self.__descrizione

Di seguito la funzione main che mostra il funzionamento dei metodi definiti. Si allega il file necessario per l'esecuzione del codice di esempio: Parametri.dat

```
import pickle
```
```
import parametro_ematico    
```
```
 
```
```
def main():
```
```
    try:
```

        #namefile = input("Inserire il nome del file dove sono memorizzati i dati dei parametri ematici: ")

        input_file = open('Parametri.dat','rb')

        analisi = pickle.load(input_file)

```
 
```
```
        print()
```
```
 
```
```
        for key in analisi:
```

            print("Codice parametro ematico: "+key+"\n"+str(analisi[key]))

```
 
```
```
 
```

        N = int(input("\nInserire il numero di interrogazioni per i parametri ematici: "))

```
 
```
```
        for i in range(1,N+1):
```

            codice = input("\nInserire il codice univoco del parametro ematico: ")

            print("\nCodice parametro ematico: "+codice+"\n"+str(analisi[codice]))

            value = float(input("Inserire valore del parametro ematico derivante dall'analisi: "))

            if (value>=float(analisi[codice].get_minimo())) and (value<=float(analisi[codice].get_massimo())):

                print("Valore del parametro "+analisi[codice].get_nome()+" nella norma")

```
            else:
```

                print("Valore del parametro "+analisi[codice].get_nome()+" FUORI NORMA")

```
            print()
```
```
 
```
```
    except Exception as err:
```
```
        print(err)
```
```
        return(1)
```
```
 
```
```
main()
```

Appello 17 Gennaio 2018

Esercizio 2: Si ha la necessità di definire quattro classi in Python: Forma geometrica, Poligono, Quadrato, Ellisse. Le classi elencate sono in relazioni diverse tra loro. Scrivere il codice Python che permette di definire le quattro classi su elencate (tenendo conto del concetto di ereditarietà) e un piccolo main che ne richiama i metodi definiti.

NOTA IMPORTANTE: si definiscano solo: gli attributi (almeno uno per ogni sottoclasse); i metodi init, get, set e str per ogni classe.

Codice Python Di seguito il codice python che modella l'ereditarietà tra le classi.

```
class Forma:
```
```
    def __init__(self, colore):
```
```
        self.__colore = colore
```
```
 
```
```
    def get_colore(self):
```
```
        return self.__colore
```
```
 
```
```
    def set_colore(self, colore):
```
```
        self.__colore = colore
```
```
 
```
```
    def __str__(self):
```
```
        return "Colore: "+self.__colore
```
```
 
```
```
class Poligono(Forma):
```
```
    def __init__(self, colore, nlati):
```
```
        Forma.__init__(self, colore)
```
```
        self.__nlati = nlati
```
```
 
```
```
    def get_nlati(self):
```
```
        return self.__nlati
```
```
 
```
```
    def set_nlati(self, nlati):
```
```
        self.__nlati = nlati
```
```
 
```
```
    def __str__(self):
```

        return Forma.__str__(self)+", n. lati: "+ str(self.__nlati)

```
 
```
```
class Ellisse(Forma):
```

    def __init__(self, colore, asse_maggiore):

```
        Forma.__init__(self, colore)
```

        self.__asse_maggiore = asse_maggiore

```
 
```
```
    def get_asse_maggiore(self):
```
```
        return self.__asse_maggiore
```
```
 
```

    def set_asse_maggiore(self, asse_maggiore):

        self.__asse_maggiore = asse_maggiore

```
 
```
```
    def __str__(self):
```

        return Forma.__str__(self)+" asse_maggiore: "+ str(self.__asse_maggiore)

```
 
```
```
class Quadrato(Poligono):
```

    def __init__(self, colore, nlati, dim):

        Poligono.__init__(self, colore, nlati)

```
        self.__dim = dim
```
```
 
```
```
    def get_dim(self):
```
```
        return self.__dim
```
```
 
```
```
    def set_dim(self, dim):
```
```
        self.__dim = dim
```
```
 
```
```
    def __str__(self):
```

        return Poligono.__str__(self)+", dim: "+ str(self.__dim)

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
import ereditarieta
```
```
 
```
```
def main():
```
```
    a = ereditarieta.Forma("Giallo")
```

    b = ereditarieta.Poligono("Verde", 6)

    c = ereditarieta.Ellisse("Blu", 34.5)

    d = ereditarieta.Quadrato("Bianco",4,4.3)

```
 
```
```
    print(a)
```
```
    print(b)
```
```
    print(c)
```
```
    print(d)
```
```
    print(c.get_asse_maggiore())
```
```
    d.set_dim(6.4)
```
```
    print(d)
```
```
 
```
```
main()
```

Esercizio 3: Si ha la necessità di gestire un magazzino di prodotti. In particolare, ogni prodotto del magazzino ha un suo codice univoco alfanumerico e le seguenti 5 informazioni: nome prodotto, altezza in cm (valore numerico), larghezza in cm (valore numerico), profondità in cm (valore numerico), prezzo. Tali dati sono organizzati in un dizionario per cui:

la chiave corrisponde al codice univoco alfanumerico del prodotto;
il “valore” corrisponde alle informazioni del prodotto organizzate in una classe.

La tipica richiesta rivolta all’operatore del magazzino di prodotti, è quella di ricercare tutti i prodotti il cui prezzo risulti essere compreso in un intervallo definito dall’operatore stesso. Si richiede sia di rappresentare uno schema grafico (non formale) delle strutture dati utilizzate sia di scrivere il codice Python dell’algoritmo che:

definisce un oggetto prodotto con le informazioni ad essa relative;
inizializza il dizionario con dati inventati;
stampa a schermo tutti i prodotti contenuti nel magazzino;
permette all’operatore di inserire il valore minimo e massimo dell’intervallo di prezzo per la ricerca dei prodotti. A seguito della definizione dell’intervallo, stampa a schermo il sottoinsieme di prodotti contenuti nel magazzino il cui prezzo ricade nell’intervallo stesso;
scrive in memoria il dizionario in un file binario;
gestisce le eccezioni che possono essere sollevate;
richiama tutte le funzioni viste (main).

NOTA: l’eventuale ridondanza di codici identificativi delle case verrà penalizzata nel punteggio.

Codice Python

```
class Prodotto:
```
```
 
```

    def __init__(self, nome, altezza, larghezza, profondita, prezzo):

```
        self.__nome = nome
```
```
        self.__altezza = altezza
```
```
        self.__larghezza = larghezza
```
```
        self.__profondita = profondita
```
```
        self.__prezzo = prezzo
```
```
 
```
```
    def set_nome(self, nome):
```
```
        self.__nome=nome
```
```
 
```
```
    def set_altezza(self,altezza):
```
```
        self.__altezza=altezza
```
```
 
```
```
    def set_larghezza(self, larghezza):
```
```
        self.__larghezza= larghezza
```
```
 
```

    def set_profondita(self, profondita):

```
        self.__profondita= profondita
```
```
 
```
```
    def set_prezzo(self, prezzo):
```
```
        self.__prezzo= prezzo
```
```
 
```
```
    def get_nome(self):
```
```
        return self.__nome
```
```
 
```
```
    def get_altezza(self):
```
```
        return self.__altezza
```
```
 
```
```
    def get_larghezza(self):
```
```
        return self.__larghezza
```
```
 
```
```
    def get_profondita(self):
```
```
        return self.__profondita
```
```
 
```
```
    def get_prezzo(self):
```
```
        return self.__prezzo
```
```
 
```
```
    def __str__(self):
```

        return "Prodotto\nNome: "+self.__nome+" - Altezza: "+str(format(self.__altezza,".2f"))+"- larghezza: "+str(format(self.__larghezza,".2f"))+", profondita: "+str(format(self.__profondita,".2f"))+\

               ", prezzo: "+str(format(self.__prezzo,".2f")) + " euro"

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
import pickle
```
```
import prodotto
```
```
 
```
```
def print_magazzino(m):
```
```
	for key in m:
```

		print("Codice prodotto: "+key+"\t"+str(m[key]))

```
 
```
```
def save_magazzino(m):
```

	namefile = input("Inserire il nome del file dove salvare il magazzino prodotti: ")

```
	output_file = open(namefile,'wb')
```
```
	pickle.dump(m, output_file)
```
```
	output_file.close()
```
```
 
```
```
def inserisci_prodotto():
```

	nome = input("\nInserire il nome del prodotto: ")

	altezza = float(input("Inserire l'altezza del prodotto: "))

	larghezza = float(input("Inserire la larghezza del prodotto: "))

	profondita = float(input("Inserire la profondita' del prodotto: "))

	prezzo = float(input("Inserire il prezzo del prodotto: "))

	p = prodotto.Prodotto(nome,altezza,larghezza,profondita,prezzo)

```
	return p
```
```
 
```
```
def main():
```
```
	m=dict()
```
```
	try:
```

		N = int(input("\nInserire il numero di prodotti per il magazzino: "))

```
		for i in range(N):
```

			codice = input("Inserire il codice del prodotto: ")

```
			m[codice] = inserisci_prodotto()
```
```
 
```
```
		print_magazzino(m)
```
```
		save_magazzino(m)
```
```
 
```

		N = int(input("\nInserire il numero di ricerche di prodotti per prezzo che intendi effettuare: "))

```
		for i in range(N):
```

			ei = float(input("Inserire l'estremo inferiore dell'intervallo di prezzo: "))

			es = float(input("Inserire l'estremo superiore dell'intervallo di prezzo: "))

```
			for codice in m:
```

				if (float(m[codice].get_prezzo())>=ei) and (float(m[codice].get_prezzo())<=es):

					print("Prodotto "+codice+" - "+str(m[codice]))

```
	except Exception as err:
```
```
		print(err)
```
```
		return(1)
```
```
 
```
```
main()
```

Appello 14 Febbraio 2018

Esercizio 2: Si ha la necessità di definire quattro classi in Python: veicolo, auto, auto elettrica e moto. Le classi elencate sono in relazioni diverse tra loro. Scrivere il codice Python che permette di definire le tre classi su elencate (tenendo conto del concetto di ereditarietà) e un piccolo main che ne richiama i metodi definiti.

NOTA IMPORTANTE: si definiscano solo: gli attributi (almeno uno per ogni sottoclasse); i metodi init, get, set e str per ogni classe.

Codice Python Di seguito il codice python che modella l'ereditarietà tra le classi.

```
class Veicolo:
```
```
    def __init__(self, tipo):
```
```
        self.__tipo = tipo
```
```
 
```
```
    def get_tipo(self):
```
```
        return self.__tipo
```
```
 
```
```
    def set_tipo(self, tipo):
```
```
        self.__tipo = tipo
```
```
 
```
```
    def __str__(self):
```
```
        return "Tipo: " + self.__tipo
```
```
 
```
```
 
```
```
class Auto(Veicolo):
```
```
    def __init__(self, tipo, anno):
```
```
        Veicolo.__init__(self, tipo)
```
```
        self.__anno = anno
```
```
 
```
```
    def get_anno(self):
```
```
        return self.__anno
```
```
 
```
```
    def set_anno(self, anno):
```
```
        self.__anno = anno
```
```
 
```
```
    def __str__(self):
```

        return Veicolo.__str__(self)+", Anno: " + str(self.__anno)

```
 
```
```
 
```
```
class AutoElettrica(Auto):
```

    def __init__(self, tipo, anno, autonomia):

```
        Auto.__init__(self, tipo, anno)
```
```
        self.__autonomia = autonomia
```
```
 
```
```
    def get_autonomia(self):
```
```
        return self.__durata
```
```
 
```
```
    def set_autonomia(self, autonomia):
```
```
        self.__autonomia = autonomia
```
```
 
```
```
    def __str__(self):
```

        return Auto.__str__(self)+", Autonomia: "+ str(self.__autonomia) + " km"

```
 
```
```
class Moto(Veicolo):
```
```
    def __init__(self, tipo, modello):
```
```
        Veicolo.__init__(self, tipo)
```
```
        self.__modello = modello
```
```
 
```
```
    def get_modello(self):
```
```
        return self.__modello
```
```
 
```
```
    def set_modello(self, modello):
```
```
        self.__modello = modello
```
```
 
```
```
    def __str__(self):
```

        return Veicolo.__str__(self) + ", Modello: " + self.__modello

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
import ereditarieta
```
```
 
```
```
def main():
```
```
    v = ereditarieta.Veicolo("anfibio")
```

    a = ereditarieta.Auto("terrestre", 2005)

    ae = ereditarieta.AutoElettrica("terrestre", 2010, 300)

    m = ereditarieta.Moto("terrestre", "Ducati")

```
 
```
```
    print(v)
```
```
    print(a)
```
```
    print(ae)
```
```
    print(m)
```
```
    print(a.get_anno())
```
```
    ae.set_autonomia(400)
```
```
    print(ae)
```
```
 
```
```
main()
```

Esercizio 3: Si ha la necessità di gestire una biblioteca. In particolare, ogni articolo presente in biblioteca (libro, rivista, ecc.) ha un suo codice univoco alfanumerico e le seguenti 5 informazioni: titolo, autore/i (uno o più organizzati in una lista), anno di pubblicazione (valore numerico), tipo (stringa – es. libro, rivista, ecc.) e numero ristampe (valore numerico). Tali dati sono organizzati in un dizionario per cui:

la chiave corrisponde al codice univoco alfanumerico del prodotto;
il “valore” corrisponde alle informazioni del prodotto organizzate in una classe.

Le tipiche richieste svolte da un addetto sono l’inserimento di un nuovo articolo e la ricerca in base al tipo. Si richiede sia di rappresentare uno schema grafio (non formale) delle strutture dati utilizzate sia di scrivere il codice Python dell’algoritmo che tramite un menù:

permette di inserire un nuovo articolo e le relative informazioni;
permette di eliminare un articolo esistente;
stampa a schermo tutti gli articoli presenti;
salva su un file binario tutti gli articoli presenti;
permette di chiedere all’utente il tipo di articolo da ricercare e stampi a schermo tutti gli articoli corrispondenti;
gestisce le eccezioni che possono essere sollevate;
richiama tutte le funzioni viste (main).

NOTA: l’eventuale ridondanza di codici identificativi delle case verrà penalizzata nel punteggio.

Codice Python

```
class Articolo:
```
```
 
```

    def __init__(self, titolo, autori, anno, tipo, ristampe):

```
        self.__titolo = titolo
```
```
        self.__autori = autori
```
```
        self.__anno = anno
```
```
        self.__tipo = tipo
```
```
        self.__ristampe = ristampe
```
```
 
```
```
    def set_titolo(self, titolo):
```
```
        self.__titolo = titolo
```
```
 
```
```
    def set_autori(self, autori):
```
```
        self.__autori = autori
```
```
 
```
```
    def set_anno(self, anno):
```
```
        self.__anno = anno
```
```
 
```
```
    def set_tipo(self, tipo):
```
```
        self.__tipo = tipo
```
```
 
```
```
    def set_ristampe(self, ristampe):
```
```
        self.__ristampe = ristampe
```
```
 
```
```
    def get_titolo(self):
```
```
        return self.__titolo
```
```
 
```
```
    def get_autori(self):
```
```
        return self.__autori
```
```
 
```
```
    def get_anno(self):
```
```
        return self.__anno
```
```
 
```
```
    def get_tipo(self):
```
```
        return self.__tipo
```
```
 
```
```
    def get_ristampe(self):
```
```
        return self.__ristampe
```
```
 
```
```
    def __str__(self):
```
```
 
```

        lista_autori = self.__autori[0] + ", "

        for i in range(1,len(self.__autori)):

            lista_autori = lista_autori + self.__autori[i] + ", "

```
 
```

        return "Titolo: " + self.__titolo +\

               ", Autori: " + lista_autori +\

               "Anno: " + str(self.__anno) +\

               ", Tipo: " + self.__tipo +\

               ", N. Ristampe: " + str(self.__ristampe)

Di seguito la funzione main che mostra il funzionamento dei metodi definiti.

```
from articolo import Articolo
```
```
import pickle
```
```
 
```
```
ADD_ITEM = 1
```
```
DELETE_ITEM = 2
```
```
PRINT_ITEMS = 3
```
```
SAVE = 4
```
```
SEARCH = 5
```
```
QUIT_CHOICE = 6
```
```
 
```
```
 
```
```
def display_menu():
```
```
    print()
```
```
    print("MENU")
```

    print("1) Inserire un nuovo articolo")

    print("2) Eliminare un articolo dal catalogo")

    print("3) Stampare a schermo tutti gli articoli in catalogo")

    print("4) Salvare le informazioni degli articoli in memoria")

```
    print("5) Cerca articoli per tipo")
```
```
    print("6) Uscire dal programma")
```
```
    print()
```
```
 
```
```
def ask_item_info():
```
```
    try:
```

        titolo = input("Inserire il titolo dell'articolo: ")

```
 
```
```
        autori = []
```
```
        res = "s"
```
```
        while res == "s" or res == "S":
```

            autori.append(input("Inserire autore: "))

            res = input("Vuoi inserire un ulteriore autore? [S/s = Si, N/n = No] ")

```
 
```

        anno = int(input("Inserire l'anno di pubblicazione: "))

        tipo = input("Inserire il tipo (es. libro, rivista, ecc.): ")

        ristampe = int(input("Inserire il numero di rispampe: "))

```
 
```

        c = Articolo(titolo, autori, anno, tipo, ristampe)

```
        return c
```
```
    except Exception as err:
```
```
        print(err)
```
```
        return 1
```
```
 
```
```
def main():
```
```
    biblioteca = dict()
```
```
 
```
```
    choice = 0
```
```
    while choice != QUIT_CHOICE:
```
```
        display_menu()
```
```
 
```

        choice = int(input('Inserire la scelta: '))

```
 
```
```
        if choice == ADD_ITEM:
```

            codice = input("Inserire il codice univoco dell' articolo: ")

            if codice not in biblioteca:

```
                c = ask_item_info()
```
```
                if c!=1:
```

                    biblioteca[codice] = c

```
            else:
```

                print("Esiste gia' un articolo con questo codice univoco.")

```
 
```
```
        elif choice == DELETE_ITEM:
```

            codice = input("Inserire il codice univoco dell'articolo da eliminare: ")

```
            print()
```
```
            if codice in biblioteca:
```
```
                del biblioteca[codice]
```

                print("L'articolo con codice "+codice+" e' stato eliminato.")

```
            else:
```

                print("Articolo non trovato.")

```
            print()
```
```
 
```
```
        elif choice == PRINT_ITEMS:
```
```
            print()
```
```
            if len(biblioteca)==0:
```

                print("Nessuna articolo presente")

```
            else:
```
```
                for key in biblioteca:
```

                    print("Codice: "+key+" - "+str(biblioteca[key]))

```
                    print()
```
```
 
```
```
        elif choice == SAVE:
```

            namefile = input("Inserire il nome del file dove memorizzare i dati degli articoli: ")

```
            file = open(namefile,'wb')
```

            pickle.dump(biblioteca, file)

```
            file.close()
```
```
 
```
```
        elif choice == SEARCH:
```

            tipo = input("Inserire il tipo di articoli richiesti: ")

```
            empty = True
```
```
            for key in biblioteca:
```

                if biblioteca[key].get_tipo() == tipo:

                    print("Articolo " + key + ": " + str(biblioteca[key]))

```
                    empty = False
```
```
            if empty:
```

                print("Nessun articolo trovato.")

```
 
```
```
        elif choice!= QUIT_CHOICE:
```

            print('Errore: scelta non valida')

```
 
```
```
 
```
```
main()
```

Appello 19 Aprile 2018

Esercizio 4: Si ha la necessità di gestire le persone afferenti ad un istituto scolastico. In particolare, è necessario gestire i docenti e gli studenti appartenenti all’istituto in due liste differenti (una per i docenti e una per gli studenti). Ogni persona è caratterizzata dalle seguenti voci: nome, cognome, sesso, indirizzo di residenza e codice fiscale CF (16 caratteri alfanumerici); il personale e gli studenti sono caratterizzati da informazioni AGGIUNTIVE quali:

materia insegnata, ore settimanali e matricola (4 cifre) per i docenti;
indirizzo di studio, anno di frequenza e matricola (8 cifre) per gli studenti.

Tutte le informazioni sono contenute in un file di testo con la seguente struttura:

Docente Mario Rossi M via Orabona 4 RSSMRA18D19A662R Informatica 8 1234 Studente Tizia Caio F via Amendola 126 CAITZI18D59A662L Informatica 1 87654321

Scrivere il codice Python dell’algoritmo che:

definisce la classe persona;
definisce in maniera opportuna le classi docente e studente (ereditarietà);
legge il file di testo, carica il contenuto del file in oggetti di tipo docente o studente e li pone nelle liste corrispondenti;
stampa a schermo le informazioni dei docenti che insegnano per più di N ore settimanali, con N chiesto all’utente;
permette di cercare una persona in base al CF e stampa a schermo le relative informazioni;
permette di eliminare un utente in base al suo CF;
permette di salvare la lista di soli docenti o di soli studenti in un file binario;
gestisce le eccezioni che possono essere sollevate;
richiama mediante un menu le funzioni implementate (main).

NOTA: codice mal strutturano e il non utilizzo della programmazione OO verrà penalizzata nel punteggio.

Codice Python

Di seguito il codice Python che implementa la classe Persona.

```
class Persona():
```

    def __init__(self, nome, cognome, sesso, residenza, cf):

```
        self.nome = nome
```
```
        self.cognome = cognome
```
```
        self.sesso = sesso
```
```
        self.residenza = residenza
```
```
        self.cf = cf
```
```
 
```
```
    def setNome(self, nome):
```
```
        self.nome = nome
```
```
 
```
```
    def setCongome(self, cognome):
```
```
        self.cognome = cognome
```
```
 
```
```
    def setSesso(self, sesso):
```
```
        self.sesso = sesso
```
```
 
```
```
    def setResidenza(self, residenza):
```
```
        self.residenza = residenza
```
```
 
```
```
    def setCF(self, cf):
```
```
        self.cf = cf
```
```
 
```
```
    def getNome(self):
```
```
        return self.nome
```
```
 
```
```
    def getCognome(self):
```
```
        return self.cognome
```
```
 
```
```
    def getSesso(self):
```
```
        return self.sesso
```
```
 
```
```
    def getResidenza(self):
```
```
        return self.residenza
```
```
 
```
```
    def getCF(self):
```
```
        return self.cf
```
```
 
```
```
    def __str__(self):
```

        return "Nome: " + self.nome + "\nCognome: " + self.cognome + "\nSesso: " + self.sesso + \

               "\nResidenza: " + self.residenza + "\nCF: " + self.cf + "\n"

Di seguito il codice Python che implementa la classe Personale.

```
from persona import Persona
```
```
 
```
```
class Personale(Persona):
```

    def __init__(self, nome, cognome, sesso, residenza, cf, materia, ore, matricola):

        Persona.__init__(self, nome, cognome, sesso, residenza, cf)

```
        self.materia = materia
```
```
        self.ore = ore
```
```
        self.matricola = matricola
```
```
 
```
```
    def setMateria(self, materia):
```
```
        self.materia = materia
```
```
 
```
```
    def setOre(self, ore):
```
```
        self.ore = ore
```
```
 
```
```
    def setMatricola(self, matricola):
```
```
        self.matricola = matricola
```
```
 
```
```
    def getMateria(self):
```
```
        return self.materia
```
```
 
```
```
    def getOre(self):
```
```
        return self.ore
```
```
 
```
```
    def getMatricola(self):
```
```
        return self.matricola
```
```
 
```
```
    def __str__(self):
```

        return Persona.__str__(self) + "Materia: " + self.materia + "\nOre: " + str(self.ore) + "\nMatricola: " + \

               str(self.matricola) + "\n"

Di seguito il codice Python che implementa la classe Studente.

```
from persona import Persona
```
```
 
```
```
class Studente(Persona):
```

    def __init__(self, nome, cognome, sesso, residenza, cf, indirizzo, anno, matricola):

        Persona.__init__(self, nome, cognome, sesso, residenza, cf)

```
        self.indirizzo = indirizzo
```
```
        self.anno = anno
```
```
        self.matricola = matricola
```
```
 
```
```
    def setIndirizzo(self, indirizzo):
```
```
        self.indirizzo = indirizzo
```
```
 
```
```
    def setAnno(self, anno):
```
```
        self.anno = anno
```
```
 
```
```
    def setMatricola(self, matricola):
```
```
        self.matricola = matricola
```
```
 
```
```
    def getIndirizzo(self):
```
```
        return self.indirizzo
```
```
 
```
```
    def getAnno(self):
```
```
        return self.anno
```
```
 
```
```
    def getMatricola(self):
```
```
        return self.matricola
```
```
 
```
```
    def __str__(self):
```

        return Persona.__str__(self) + "Indirizzo: " + self.indirizzo + "\nAnno: " + str(self.anno) + "\nMatricola: " + \

               str(self.matricola) + "\n"

Di seguito la funzione main.

```
from personale import Personale
```
```
from studente import Studente
```
```
 
```
```
import pickle
```
```
 
```
```
LOAD_FILE = 1
```
```
PRINT_TEACHERS = 2
```
```
LOOK_FOR_CF = 3
```
```
REMOVE_USER = 4
```
```
SAVE_LIST = 5
```
```
QUIT = 6
```
```
 
```
```
NUMERO_INFORMAZIONI = 9
```
```
 
```
```
 
```
```
def display_menu():
```
```
    print()
```
```
    print("MENU")
```
```
    print("1) Carica file")
```

    print("2) Stampa docenti con almeno N ore settimanali")

```
    print("3) Cerca per CF")
```
```
    print("4) Elimina utente")
```

    print("5) Salva lista docenti o studenti")

```
    print("6) Esci")
```
```
    print()
```
```
 
```
```
def load_file():
```
```
    try:
```

        file_name = input("Inserisci il nome del file: ")

```
        file = open(file_name, 'r')
```
```
 
```
```
        row = file.readline()
```
```
 
```
```
        docenti = []
```
```
        studenti = []
```
```
 
```
```
        temp_info = []
```
```
 
```
```
        while (row != ""):
```

            temp_info.append(row.rstrip('\n'))

            if len(temp_info) == NUMERO_INFORMAZIONI:

                # Ho terminato di caricare le informazioni necessarie per creare l'oggetto

                if temp_info[0] == "Docente":

                    p = Personale(temp_info[1],

                                             temp_info[2],

                                             temp_info[3],

                                             temp_info[4],

                                             temp_info[5],

                                             temp_info[6],

                                             int(temp_info[7]),

                                             int(temp_info[8])

```
                    docenti.append(p)
```
```
                else:
```

                    s = Studente(temp_info[1],

                                             temp_info[2],

                                             temp_info[3],

                                             temp_info[4],

                                             temp_info[5],

                                             temp_info[6],

                                             int(temp_info[7]),

                                             int(temp_info[8])

```
                    studenti.append(s)
```
```
                temp_info = []
```
```
            row = file.readline()
```
```
 
```
```
        return docenti, studenti
```
```
 
```
```
 
```
```
    except IOError as err:
```
```
        print(err)
```

        print("Errore nella lettura del file.")

```
        return 0, 0
```
```
 
```
```
 
```
```
def print_docenti(docenti):
```
```
    try:
```

        n = int(input("Inserire il numero di ore settimanali: "))

```
        if n < 0:
```
```
            raise ValueError
```
```
 
```
```
        for d in docenti:
```
```
            if d.getOre() > n:
```
```
                print(d)
```
```
 
```
```
    except ValueError:
```
```
        print("Numero non valido.")
```
```
 
```
```
 
```
```
def look_for_cf(lista, cf):
```
```
    idx = 0
```
```
    for l in lista:
```
```
        if l.getCF() == cf:
```
```
            return idx
```
```
        idx += 1
```
```
    return -1
```
```
 
```
```
 
```
```
def remove_user(l, cf):
```
```
    idx = look_for_cf(l,cf)
```
```
    if idx != -1:
```
```
        del l[idx]
```
```
    return l
```
```
 
```
```
 
```
```
def save_list(l):
```

    file_name = input("Inserire il nome del file: ")

```
    file = open(file_name, 'wb')
```
```
    pickle.dump(l, file)
```
```
 
```
```
 
```
```
def main():
```
```
    choice = 0
```
```
    docenti = []
```
```
    studenti = []
```
```
    while choice != QUIT:
```
```
        try:
```
```
            display_menu()
```

            choice = int(input('Inserire la scelta: '))

```
 
```
```
            if choice == LOAD_FILE:
```

                docenti, studenti = load_file()

```
 
```

            elif choice == PRINT_TEACHERS:

```
                print_docenti(docenti)
```
```
 
```
```
            elif choice == LOOK_FOR_CF:
```

                cf = input("Inserisci il CF da cercare: ")

```
                if len(cf) == 16:
```

                    idx = look_for_cf(docenti, cf)

```
                    if idx != -1:
```

                        print(docenti[idx])

```
                    else:
```

                        idx = look_for_cf(studenti, cf)

```
                        if idx != -1:
```

                            print(studenti[idx])

```
                        else:
```

                            print("CF non trovato.")

```
                else:
```

                    print("CF non valido")

```
 
```
```
            elif choice == REMOVE_USER:
```

                cf = input("Inserisci il CF da eliminare: ")

```
                if len(cf) == 16:
```

                    docenti = remove_user(docenti, cf)

                    studenti = remove_user(studenti, cf)

```
                else:
```

                    print("CF non valido")

```
 
```
```
            elif choice == SAVE_LIST:
```

                tipo = input("Vuoi salvare la lista studenti (s) o docenti (d)? ")

                while tipo != 's' and tipo != 'd':

                    print("Scelta errata.")

                    tipo = input("Vuoi salvare la lista studenti (s) o docenti (d)? ")

```
                if tipo == 'd':
```
```
                    save_list(docenti)
```
```
                else:
```
```
                    save_list(studenti)
```
```
 
```
```
            elif choice != QUIT:
```

                print('Errore: scelta non valida')

```
 
```
```
        except ValueError:
```

            print('Errore: scelta non valida')

```
 
```
```
main()
```

Appello 20 Giugno 2018

Esercizio 4: Si supponga di dover realizzare un programma che permetta di realizzare alcune operazioni su semplici poligoni. Nello specifico i poligoni di interesse sono quadrato, rettangolo, e triangolo. Ogni poligono è caratterizzato da una lista di punti. Tali punti costituiscono i vertici del poligono stesso e sono elencati in senso orario. Le comuni operazioni richieste sono il calcolo del perimetro per ogni poligono e l’area per le forme rettangolo e quadrato.

Si modelli il problema secondo i paradigmi della programmazione orientata agli oggetti e si utilizzino strutture dati opportune.

Riportare uno schema non formale delle strutture dati utilizzate e scrivere quindi il codice Python dell’algoritmo che:

definisce la classe punto;
definisce in maniera opportuna le classi poligono, triangolo, quadrato e rettangolo;
permette all’utente, mediante un menu, di:
- creare una nuova figura in base alla scelta dell’utente;
- modificare i punti di una figura precedentemente creata;
- calcolare e stampare a video il valore del perimetro;
- calcolare e stampare a video il valore dell’area (per le figure per cui è ammesso);
gestisce le eccezioni che possono essere generate;

NOTA 1: scegliere la migliore struttura dati per memorizzare tutte le forme geometriche.

NOTA 2: codice mal strutturato e il non utilizzo della programmazione OO verranno penalizzati nel punteggio.

Codice Python

Di seguito il codice Python che implementa la classe Punto.

```
from math import sqrt
```
```
 
```
```
class Punto:
```
```
    def __init__(self,x,y):
```
```
        self.__x = x
```
```
        self.__y = y
```
```
 
```
```
    def set_x(self,x):
```
```
        self.__x = x
```
```
 
```
```
    def set_y(self,y):
```
```
        self.__y = y
```
```
 
```
```
    def get_x(self):
```
```
        return self.__x
```
```
 
```
```
    def get_y(self):
```
```
        return self.__y
```
```
 
```
```
    def __str__(self):
```

        return "X: " + str(self.__x) + ", Y: " + str(self.__y) + "\n"

```
 
```
```
    def distanza(self, p):
```
```
        d_x = p.get_x() - self.__x
```
```
        d_y = p.get_y() - self.__y
```
```
 
```
```
        return sqrt(d_x**2 + d_y**2)
```

Di seguito il codice Python che implementa le classi Poligono, Triangolo, Quadrato e Rettangolo.

```
class Poligono:
```
```
    def __init__(self, vertici):
```
```
        self.__vertici = vertici
```
```
 
```
```
    def set_vertici(self,vertici):
```
```
        self.__vertici = vertici
```
```
 
```
```
    def get_vertici(self):
```
```
        return self.__vertici
```
```
 
```
```
    def __str__(self):
```
```
        out = "Vertici:\n"
```
```
        for v in self.__vertici:
```
```
            out += str(v)
```
```
        return out
```
```
 
```
```
    def perimetro(self):
```
```
        per = 0
```

        for i in range(0, len(self.__vertici)-1):

```
            p1 = self.__vertici[i]
```
```
            p2 = self.__vertici[i+1]
```
```
            per += p1.distanza(p2)
```

        per += self.__vertici[0].distanza(self.__vertici[-1])

```
        return per
```
```
        #raise NotImplementedError
```
```
 
```
```
    def area(self):
```

        print("Metodo non implementato")    # O in alternative: raise NotImplementedError

```
        return 0
```
```
 
```
```
 
```
```
class Triangolo(Poligono):
```
```
    def __init__(self,a,b,c):
```

        Poligono.__init__(self, [a, b, c])

```
 
```
```
 
```
```
class Rettangolo(Poligono):
```
```
    def __init__(self,a,b,c,d):
```

        Poligono.__init__(self, [a, b, c, d])

```
 
```
```
    def area(self):
```
```
        v = Poligono.get_vertici(self)
```
```
        l1 = v[0].distanza(v[1])
```
```
        l2 = v[1].distanza(v[2])
```
```
        return l1*l2
```
```
 
```
```
 
```
```
class Quadrato(Rettangolo):
```
```
    def __init__(self,a,b,c,d):
```

        Rettangolo.__init__(self, a, b, c, d)

Di seguito la funzione main.

```
from punto import Punto
```
```
from forme_geometriche import Triangolo
```

from forme_geometriche import Rettangolo

```
from forme_geometriche import Quadrato
```
```
 
```
```
CREA = 1
```
```
MODIFICA = 2
```
```
PERIMETRO = 3
```
```
AREA = 4
```
```
ESCI = 5
```
```
 
```
```
def menu():
```
```
    print("Inserisci la scelta:")
```
```
    print("1) Crea")
```
```
    print("2) Modifica")
```
```
    print("3) Perimetro")
```
```
    print("4) Area")
```
```
    print("5) Esci")
```
```
 
```
```
    try:
```
```
        return int(input())
```
```
    except ValueError:
```
```
        return 0
```
```
 
```
```
 
```
```
def carica_lista_vertici(n):
```
```
    v = []
```
```
    for i in range(n):
```
```
        try:
```

            x = float(input("Vertice: " + str(i) + " - Inserisci X: "))

            y = float(input("Vertice: " + str(i) + " - Inserisci Y: "))

```
        except ValueError:
```

            print("Valore non ammissibile")

```
            return []
```
```
        v.append(Punto(x,y))
```
```
    return v
```
```
 
```
```
 
```
```
def main():
```
```
 
```
```
    c = menu()
```
```
    figura = None
```
```
    while c != ESCI:
```
```
        if c == CREA:
```
```
            f = ''
```

            while f != 't' and f != 'r' and f != 'q' and f != 'a':

                f = input("Inserire il tipo di figura (t = Triangolo, r = Rettangolo, q = Quadrato, a = Annulla): ")

```
 
```
```
            if f == 't':
```

                 v = carica_lista_vertici(3)

```
                 if len(v) > 0:
```

                     figura = Triangolo(v[0],v[1],v[2])

                     print("Figura creata")

```
                 else:
```

                    print("Figura non creata")

```
            elif f == 'r':
```

                v = carica_lista_vertici(4)

```
                if len(v) > 0:
```

                    figura = Rettangolo(v[0],v[1],v[2],v[3])

                    print("Figura creata")

```
                else:
```

                    print("Figura non creata")

```
            elif f == 'q':
```

                v = carica_lista_vertici(4)

```
                if len(v) > 0:
```

                    figura = Quadrato(v[0],v[1],v[2],v[3])

                    print("Figura creata")

```
                else:
```

                    print("Figura non creata")

```
 
```
```
        elif c == MODIFICA:
```
```
            if figura:
```

                v = carica_lista_vertici(len(figura.get_vertici()))

```
                if len(v) > 0:
```

                    figura.set_vertici(v)

                    print("Figura modificata")

```
                else:
```

                    print("Figura non modificata")

```
            else:
```

                print("Creare prima la figura.")

```
 
```
```
        elif c == PERIMETRO:
```
```
            if figura:
```

                print("Il perimetro è: ",format(figura.perimetro(),'.2f'))

```
            else:
```

                print("Creare prima la figura.")

```
        elif c == AREA:
```
```
            if figura:
```

                print("L'area è: ",format(figura.area(),'.2f'))

```
            else:
```

                print("Creare prima la figura.")

```
        else:
```
```
            print("Scelta errata.\n")
```
```
 
```
```
        c = menu()
```
```
 
```
```
 
```
```
main()
```

Appello 18 Luglio 2018

Esercizio 4: Si ha la necessità di gestire l’inventario dei beni afferenti ad un ente pubblico. In particolare, ogni bene è caratterizzato dall’avere un numero di inventario univoco ad esso associato, l’anno di acquisto, un numero di fattura ed una descrizione. I beni, inoltre, sono suddivisi in due tipologie differenti: mobilio (armadi, schedari, scrivanie, ecc.) e supporti informatici (monitor, computer, stampanti, ecc.). Le singole tipologie sono a loro volta caratterizzate da:

mobilio: luogo in cui è ubicato;
supporti informatici: numero di serie (alfanumerico) e responsabile (nome e cognome) a cui è affidato.

Si modelli il problema secondo i paradigmi della programmazione orientata agli oggetti e si utilizzino strutture dati opportune. Riportare uno schema non formale delle strutture dati utilizzate e scrivere quindi il codice Python dell’algoritmo che:

definisce la classe bene;
definisce in maniera opportuna le classi mobilio e supporto informatico; c) permette all’utente, mediante un menu, di:
- inserire un nuovo bene (che dovrà necessariamente appartenere ad una delle due tipologie precedenti: mobilio e supporto informatico);
- cercare un bene mediante numero di inventario e stampare a schermo le relative informazioni;
- cercare i beni acquistati in un dato anno e per ognuno di essi: stampare a schermo il numero di inventario e aggiungere al file “out.txt” il numero di fattura;
- permette di salvare in binario i mobili e i supporti informatici in due file differenti;
gestisce le eccezioni che possono essere generate.

NOTA 1: scegliere la migliore struttura dati per memorizzare tutti i beni tenendo conto delle informazioni disponibili su di essi.

NOTA 2: codice mal strutturato e il non utilizzo della programmazione OO verranno penalizzati nel punteggio. (max 23 punti)

Codice Python

Di seguito il codice Python che implementa la classe Bene.

```
class Bene:
```

    def __init__(self, anno, numero_fattura, descrizione):

```
        self.__anno = anno
```

        self.__numero_fattura = numero_fattura

        self.__descrizione = descrizione

```
 
```
```
    def set_anno(self,anno):
```
```
        self.__anno = anno
```
```
 
```

    def set_numero_fattura(self,numero_fattura):

        self.__numero_fattura = numero_fattura

```
 
```

    def set_descrizione(self,descrizione):

        self.__descrizione = descrizione

```
 
```
```
    def get_anno(self):
```
```
        return self.__anno
```
```
 
```
```
    def get_numero_fattura(self):
```
```
        return self.__numero_fattura
```
```
 
```
```
    def get_descrizione(self):
```
```
        return self.__descrizione
```
```
 
```
```
    def __str__(self):
```

        return "Anno: " + str(self.__anno) + ", Numero fattura: " + str(self.__numero_fattura) + ", Descrizione: " + self.__descrizione + "\n"

Di seguito il codice Python che implementa le classi Mobilio e Supporti Informatici.

```
from bene import Bene
```
```
 
```
```
 
```
```
class Mobilio(Bene):
```

    def __init__(self, anno, numero_fattura, descrizione, luogo):

        Bene.__init__(self, anno, numero_fattura, descrizione)

```
        self.__luogo = luogo
```
```
 
```
```
    def set_luogo(self,luogo):
```
```
        self.__luogo = luogo
```
```
 
```
```
    def get_luogo(self):
```
```
        return self.__luogo
```
```
 
```
```
    def __str__(self):
```

        return Bene.__str__(self) + "Luogo: " + self.__luogo + "\n"

```
 
```
```
 
```
```
class SupportiInformatici(Bene):
```

    def __init__(self, anno, numero_fattura, descrizione, serie, responsabile):

        Bene.__init__(self, anno, numero_fattura, descrizione)

```
        self.__serie = serie
```

        self.__responsabile = responsabile

```
 
```
```
    def set_serie(self,serie):
```
```
        self.__serie = serie
```
```
 
```

    def set_responsabile(self,responsabile):

        self.__responsabile = responsabile

```
 
```
```
    def get_serie(self):
```
```
        return self.__serie
```
```
 
```
```
    def get_responsabile(self):
```
```
        return self.__responsabile
```
```
 
```
```
    def __str__(self):
```

        return Bene.__str__(self) + "Numero di serie: " + self.__serie + ", Responsabile: " + self.__responsabile + "\n"

Di seguito la funzione main.

```
from arredi import Mobilio
```
```
from arredi import SupportiInformatici
```
```
import pickle
```
```
 
```
```
INSERISCI = 1
```
```
CERCA_PER_INVENTARIO = 2
```
```
CERCA_PER_ANNO = 3
```
```
SALVA = 4
```
```
ESCI = 5
```
```
 
```
```
def menu():
```
```
    print("Effettua la scelta:")
```
```
    print("1) Inserisci bene")
```
```
    print("2) Cerca per inventario")
```
```
    print("3) Cerca per anno")
```
```
    print("4) Salva")
```
```
    print("5) Esci")
```
```
 
```
```
    try:
```
```
        return int(input())
```
```
    except ValueError:
```
```
        return 0
```
```
 
```
```
 
```
```
def carica_attributi_bene():
```
```
    out = []
```
```
    try:
```

        out.append(int(input("Inserisci anno: ")))

        out.append(int(input("Inserisci fattura: ")))

```
    except ValueError:
```
```
        print("Valore non valido.")
```
```
        return []
```

    out.append(input("Inserisci descrizione: "))

```
    return out
```
```
 
```
```
 
```
```
def main():
```
```
    arredi = {}
```
```
 
```
```
    c = menu()
```
```
    while c != ESCI:
```
```
        if c == INSERISCI:
```

            attr = carica_attributi_bene()

```
            if len(attr) > 0:
```
```
                tipo = ''
```

                while tipo != 'm' and tipo != 'i' and tipo != 'a':

                    tipo = input("Inserire il tipo di mobilio (m = Mobilio, i = Supporto Informatico, a = Annulla): ")

```
 
```
```
                if tipo != 'a':
```
```
 
```
```
                    if tipo == 'm':
```

                        attr.append(input("Inserire locazione: "))

```
                    elif tipo == 'i':
```

                        attr.append(input("Inserire numero di serie: "))

                        attr.append(input("Inserire responsabile: "))

```
 
```
```
                    try:
```

                        n_inv = int(input("Inserire il numero di inventario: "))

```
                    except ValueError:
```

                        print("Valore non valido.")

```
                    else:
```

                        if n_inv in arredi:

                            print("Numero inventario esistente.")

```
                        else:
```

                            if tipo == 'm':

                                arredi[n_inv] = Mobilio(attr[0],attr[1],attr[2],attr[3])

                            elif tipo == 'i':

                                arredi[n_inv] = SupportiInformatici(attr[0], attr[1], attr[2], attr[3], attr[4])

```
 
```
```
 
```
```
        elif c == CERCA_PER_INVENTARIO:
```
```
            try:
```

                n_inv = int(input("Inserire il numero di inventario da cercare: "))

```
            except ValueError:
```

                print("Valore non valido.")

```
            else:
```
```
                if n_inv in arredi:
```

                    print(arredi[n_inv])

```
                else:
```

                    print("Non presente in inventario.")

```
 
```
```
        elif c == CERCA_PER_ANNO:
```
```
            try:
```

                anno = int(input("Inserire anno da cercare: "))

```
            except ValueError:
```

                print("Valore non valido.")

```
            else:
```

                file = open("out.txt","a")

```
                for n_inv in arredi:
```

                    if arredi[n_inv].get_anno() == anno:

```
                        print(n_inv)
```

                        file.write(str(arredi[n_inv].get_numero_fattura()) + "\n")

```
                file.close()
```
```
        elif c == SALVA:
```

            file_mobilio = open("mobilio.dat", "bw")

            file_supporti = open("supporti_informatici.dat", "bw")

```
            for n_inv in arredi:
```

                if isinstance(arredi[n_inv],Mobilio):

                    pickle.dump(arredi[n_inv],file_mobilio)

```
                else:
```

                    pickle.dump(arredi[n_inv], file_supporti)

```
            file_mobilio.close()
```
```
            file_supporti.close()
```
```
 
```
```
        else:
```
```
            print("Scelta non valida")
```
```
 
```
```
        c = menu()
```
```
 
```
```
 
```
```
main()
```

Appello 03 Settembre 2018

Esercizio 4: Si ha la necessità di gestire il personale afferente ad un’azienda. In particolare, ogni persona è caratterizzata dall’avere un nome, un cognome e un numero di matricola univoco (8 numeri). Ci sono inoltre tre tipologie di dipendenti ognuno caratterizzato di diverse informazioni aggiuntive:

operaio: reparto e salario;
responsabile: reparto, salario e anno di promozione;
dirigente: salario e anno di assunzione.

Tutte le informazioni sono salvate in un file di testo con la struttura riportata nel seguente esempio:

operaio
Mario
Rossi
12345678
produzione
1500
responsabile
Tizio
Caio
87654321
vendite
1800
2012
dirigente
Pinco
Pallino
01010101
3000
2018

Si modelli il problema secondo i paradigmi della programmazione orientata agli oggetti e scrivere quindi il codice Python dell’algoritmo che:

definisce la classe persona;
definisce in maniera opportuna le classi operaio, responsabile e dirigente;
permette di:
- caricare il file con le informazioni sui dipendenti all’interno di tre strutture dati opportune (una per ogni categoria di lavoro);
- calcolare e stampare la somma degli stipendi per la categoria di lavoro scelta dall’utente;
- chiedere all’utente l’anno di promozione del responsabile e stampare il numero di matricola del responsabile promosso nell’anno inserito che percepisce il salario maggiore;
- salvare in un file binario le tre strutture dati create.
gestisce le eccezioni che possono essere generate;
richiama le funzioni implementate (main);

NOTA 1: codice mal strutturato e il non utilizzo della programmazione OO verranno penalizzati nel punteggio. (max 23 punti)

Codice Python

Di seguito il codice Python che implementa la classe Persona.

```
class Persona:
```
```
    def __init__(self,nome,cognome):
```
```
        self.__nome = nome
```
```
        self.__cognome = cognome
```
```
 
```
```
    def setNome(self,nome):
```
```
        self.__nome = nome
```
```
 
```
```
    def setCognome(self,cognome):
```
```
        self.__cognome = cognome
```
```
 
```
```
    def getNome(self):
```
```
        return self.__nome
```
```
 
```
```
    def getCognome(self):
```
```
        return self.__cognome
```
```
 
```
```
    def __str__(self):
```

        return "Nome: " + self.__nome + "\nCognome: " + self.__cognome + "\n"

Di seguito il codice Python che implementa le classi Operaio, Responsabile e Dirigente.

```
from persona import Persona
```
```
 
```
```
class Operaio(Persona):
```

    def __init__(self,nome,cognome,reparto,salario):

        Persona.__init__(self,nome,cognome)

```
        self.__reparto = reparto
```
```
        self.__salario = salario
```
```
 
```
```
    def setReparto(self,reparto):
```
```
        self.__reparto = reparto
```
```
 
```
```
    def setSalario(self,salario):
```
```
        self.__salario = salario
```
```
 
```
```
    def getReparto(self):
```
```
        return self.__reparto
```
```
 
```
```
    def getSalario(self):
```
```
        return self.__salario
```
```
 
```
```
    def __str__(self):
```

        return Persona.__str__(self) + "Reparto: " + self.__reparto + "\nSalario: " + str(self.__salario) + "\n"

```
 
```
```
class Responsabile(Operaio):
```

    def __init__(self,nome,cognome,reparto,salario,annop):

        Operaio.__init__(self,nome,cognome,reparto,salario)

```
        self.__annop = annop
```
```
 
```
```
    def setAnnoP(self,annop):
```
```
        self.__annop = annop
```
```
 
```
```
    def getAnnoP(self):
```
```
        return self.__annop
```
```
 
```
```
    def __str__(self):
```

        return Operaio.__str__(self) + "\nAnno Promozione: " + str(self.__annop) + "\n"

```
 
```
```
class Dirigente(Persona):
```

    def __init__(self,nome,cognome,salario,annoa):

        Persona.__init__(self,nome,cognome)

```
        self.__salario = salario
```
```
        self.__annoa = annoa
```
```
 
```
```
    def setSalario(self,salario):
```
```
        self.__salario = salario
```
```
 
```
```
    def setAnnoA(self,annoa):
```
```
        self.__annoa = annoa
```
```
 
```
```
    def getSalario(self):
```
```
        return self.__salario
```
```
 
```
```
    def fetAnnoA(self):
```
```
        return self.__annoa
```
```
 
```
```
    def __str__(self):
```

        return Persona.__str__(self) + "\nSalario: " + str(self.__salario) + "\nAnno Assunzione: " + str(self.__annoa) + "\n"

Di seguito la funzione main.

```
from dipendenti import Operaio
```
```
from dipendenti import Responsabile
```
```
from dipendenti import Dirigente
```
```
 
```
```
import pickle
```
```
 
```
```
def load_file():
```

    filename = input("Inserisci il nome del file: ")

```
    file = open(filename,'r')
```
```
 
```
```
    operaio = {}
```
```
    responsabile = {}
```
```
    dirigente = {}
```
```
 
```
```
    # temp[0] nome
```
```
    # temp[1] cognome
```
```
    # temp[2] matricola
```
```
    # temp[3] reparto
```
```
    # temp[4] salario
```
```
    # temp[5] anno
```
```
 
```
```
    tipo = file.readline().rstrip('\n')
```
```
 
```
```
    while tipo != '':
```
```
        temp = []
```
```
 
```
```
        for i in range(5):
```

            temp.append(file.readline().rstrip('\n'))

```
 
```
```
        if tipo == 'responsabile':
```

            temp.append(file.readline().rstrip('\n'))

            responsabile[temp[2]] = Responsabile(temp[0],

                                                 temp[1],

                                                 temp[3],

                                                 temp[4],

                                                 temp[5])

```
        elif tipo == 'operaio':
```

            operaio[temp[2]] = Operaio(temp[0],

                                       temp[1],

                                       temp[3],

                                       temp[4])

```
 
```
```
        else:
```

            dirigente[temp[2]] = Dirigente(temp[0],

                                           temp[1],

                                           temp[3],

                                           temp[4])

```
 
```

        tipo = file.readline().rstrip('\n')

```
 
```
```
    file.close()
```

    return operaio,responsabile,dirigente

```
 
```
```
def somma_per_categoria(d):
```
```
    s = 0
```
```
    for key in d:
```
```
        s += float(d[key].getSalario())
```
```
    print('Somma: ',s)
```
```
 
```
```
def cerca_responsabile(d):
```
```
    best = 0.0
```
```
    matricola = []
```

    anno = int(input("Inserire anno di promozione: "))

```
    for key in d:
```

        if (int(d[key].getAnnoP()) == anno) & (float(d[key].getSalario()) >= best):

            if float(d[key].getSalario()) == best: # Stesso salario

```
                matricola.append(key)
```
```
            else:
```
```
                matricola = [key]
```

                best = float(d[key].getSalario())

```
 
```
```
    if len(matricola) > 0:
```

        print('Matricola/e: ',*matricola)

```
    else:
```

        print('Nessun elemento soddisfa i criteri di ricerca.')

```
 
```

def salva(operaio, responsabile, dirigente):

    filename = input('Inserire il nome del file in cui salvare: ')

```
    file = open(filename,'bw')
```
```
    pickle.dump(operaio, file)
```
```
    pickle.dump(responsabile, file)
```
```
    pickle.dump(dirigente, file)
```
```
    file.close()
```
```
 
```
```
def main():
```
```
    try:
```

        operaio, responsabile, dirigente = load_file()

```
 
```
```
        categoria = ''
```
```
        while categoria != 'a':
```
```
            if categoria == 'o':
```

                somma_per_categoria(operaio)

```
            elif categoria == 'r':
```

                somma_per_categoria(responsabile)

```
            elif categoria == 'd':
```

                somma_per_categoria(dirigente)

```
 
```

            categoria = input('Inserire la categoria per cui calcolare la somma ("o" per Operaio, "r" per Responsabile, "d" per Dirigente o "a" per annullare): ')

```
 
```

        cerca_responsabile(responsabile)

```
 
```

        salva(operaio, responsabile, dirigente)

```
 
```
```
    except IOError:
```

        print('Impossibile leggere il file.')

```
    except ValueError:
```
```
        print('Anno non valido')
```
```
 
```
```
main()
```

Appello 24 Settembre 2018

Esercizio 4: Si ha la necessità di gestire l’utenza di una compagnia telefonica. In particolare la compagnia ha la necessità di gestire gli utenti ad essa afferenti e i dispositivi usati dagli utenti stessi. Per quanto riguarda gli utenti le informazioni in possesso della compagnia sono: nome, cognome, età e codice fiscale. I dispositivi, invece, possono essere di due tipologie: telefono e smartphone. Le informazioni relative ad ogni telefono sono: produttore, modello e IMEI, mentre ogni smartphone possiede, oltre alle informazioni precedenti, caratteristiche aggiuntive, quali: dimensione dello schermo (lunghezza e larghezza) e anno di uscita. La compagnia ha la necessità di tenere traccia delle informazioni relative ad ogni utente ed in particolare i dispositivi (anche più di uno) in loro possesso. Si modelli il problema secondo i paradigmi della programmazione orientata agli oggetti e si scelga una opportuna struttura dati per memorizzare gli utenti, i dispositivi e per preservare l’associazione tra utente e dispositivi posseduti; si scriva quindi il codice Python dell’algoritmo che:

definisce la classe utente;
definisce in maniera opportuna le classi telefono e smartphone;
permette di inserire un nuovo utente;
permette di inserire un nuovo dispositivo e di associarlo ad un utente preesistente;
permette di eliminare un utente e conseguentemente tutti i dispositivi ad esso associati;
permette di cercare lo smartphone con schermo di area massima e stampare a schermo le relative informazioni;
gestisce le eccezioni che possono essere generate;
richiama le funzioni implementate mediante un menu.

NOTA 1: codice mal strutturato e il non utilizzo della programmazione OO verranno penalizzati nel punteggio.

Codice Python

Di seguito il codice Python che implementa la classe Utente.

```
class Utente:
```

    def __init__(self,nome,cognome,eta):

```
        self.__nome = nome
```
```
        self.__cognome = cognome
```
```
        self.__eta = eta
```
```
 
```
```
    def setNome(self,nome):
```
```
        self.__nome = nome
```
```
 
```
```
    def setCognome(self,cognome):
```
```
        self.__cognome = cognome
```
```
 
```
```
    def setEta(self,eta):
```
```
        self.__eta = eta
```
```
 
```
```
    def getNome(self):
```
```
        return self.__nome
```
```
 
```
```
    def getCognome(self):
```
```
        return self.__cognome
```
```
 
```
```
    def getEta(self):
```
```
        return self.__eta
```
```
 
```
```
    def __str__(self):
```

        return 'Nome: ' + self.__nome + '\nCognome: ' + self.__cognome + '\nEta\': ' + str(self.__eta) + '\n'

Di seguito il codice Python che implementa le classi Telefono e Smartphone.

```
class Telefono:
```

    def __init__(self,produttore,modello):

```
        self.__produttore = produttore
```
```
        self.__modello = modello
```
```
 
```
```
    def setProduttore(self,produttore):
```
```
        self.__produttore = produttore
```
```
 
```
```
    def setModello(self,modello):
```
```
        self.__modello = modello
```
```
 
```
```
    def getProduttore(self):
```
```
        return self.__produttore
```
```
 
```
```
    def getModello(self):
```
```
        return self.__modello
```
```
 
```
```
    def __str__(self):
```

        return 'Produttore: ' + self.__produttore + '\nModello: ' + self.__modello + '\nIMEI: ' + '\n'

```
 
```
```
 
```
```
class Smartphone(Telefono):
```

    def __init__(self,produttore,modello,schermo,anno):

        Telefono.__init__(self,produttore,modello)

```
        self.__schermo = schermo
```
```
        self.__anno = anno
```
```
 
```
```
    def setSchermo(self,lun,lar):
```
```
        self.__schermo = [lun,lar]
```
```
 
```
```
    def setAnno(self,anno):
```
```
        self.__anno = anno
```
```
 
```
```
    def getSchermo(self):
```
```
        return self.__schermo
```
```
 
```
```
    def getAnno(self):
```
```
        return self.__anno
```
```
 
```
```
    def __str__(self):
```

        return Telefono.__str__(self) + 'Schermo: ' + str(self.__schermo[0]) + 'x' + str(self.__schermo[1]) + '\nAnno: ' + str(self.__anno) + '\n'

Di seguito la funzione main.

```
from utente import Utente
```

from dispositivi import Telefono, Smartphone

```
 
```
```
INSERISCI_UTENTE = 1
```
```
INSERISCI_DISPOSITIVO = 2
```
```
ELIMINA_UTENTE = 3
```
```
CERCA_AREA = 4
```
```
ESCI = 5
```
```
 
```
```
def menu():
```
```
    print('Scelta:\n')
```
```
    print('1) Inserisci Utente\n')
```
```
    print('2) Inserisci Dispositivo\n')
```
```
    print('3) Elimina Utente\n')
```
```
    print('4) Cerca\n')
```
```
    print('5) Esci\n\n')
```
```
    try:
```
```
        return int(input())
```
```
    except ValueError:
```
```
        return 0
```
```
 
```
```
def inserisci_utente(d,u_d,cf=None):
```
```
    if not cf:
```
```
        cf = input('CF: ')
```
```
        if cf in d:
```

            print('Utente esistente.\n')

```
            return
```
```
    nome = input('Nome: ')
```
```
    cognome = input('Cognome: ')
```
```
    eta = input('Eta\'; ')
```
```
 
```
```
    d[cf] = Utente(nome,cognome,eta)
```
```
    u_d[cf] = []
```
```
 
```

def inserisci_dispositivo(utenti,disp,u_d):

```
    imei = input('IMEI: ')
```
```
    if imei in disp:
```

        print('Dispositivo esistente.\n')

```
        return
```
```
 
```
```
    prod = input('Produttore: ')
```
```
    mod = input('Modello: ')
```
```
 
```
```
    try:
```

        if input('E\' uno spartphone (\'s\' = si)?') == 's':

```
 
```

            lun = int(input('Lunghezza schermo: '))

            lar = int(input('Larghezza schermo: '))

```
            anno = int(input('Anno: '))
```
```
 
```

            disp[imei] = Smartphone(prod,mod,[lun,lar],anno)

```
        else:
```

            disp[imei] = Telefono(prod,mod)

```
 
```
```
        cf = input('CF: ')
```
```
        if cf in utenti:
```
```
            u_d[cf].append(imei)
```

        elif input('Utente non trovato. Creare (\'s\' = si)?') == 's':

            inserisci_utente(utenti,u_d,cf)

```
            u_d[cf].append(imei)
```
```
        else:
```
```
            del disp[imei]
```

            print('Dispositivo eliminato.')

```
 
```
```
    except ValueError:
```

        print('Inserimento non valido.')

```
 
```

def elimina_utente(utenti,dispositivi,u_d):

    cf = input('CF dell\'utente da eliminare: ')

```
 
```
```
    if cf in utenti:
```
```
        imei = u_d[cf]
```
```
        for k in imei:
```
```
            del dispositivi[k]
```
```
        del u_d[cf]
```
```
        del utenti[cf]
```
```
    else:
```
```
        print('Utente non trovato.')
```
```
 
```
```
def cerca(dispositivi):
```
```
    area_max = 0
```
```
    imei_max = None
```
```
    for imei in dispositivi:
```

        if isinstance(dispositivi[imei],Smartphone):

            schermo = dispositivi[imei].getSchermo()

            if schermo[0]*schermo[1] >= area_max:

```
                imei_max = imei
```

                area_max = schermo[0]*schermo[1]

```
    if imei_max:
```
```
        print(dispositivi[imei_max])
```
```
 
```
```
def main():
```
```
    utenti = {}
```
```
    dispositivi = {}
```
```
    u_d = {}
```
```
    scelta = menu()
```
```
    while scelta != ESCI:
```
```
        if scelta == INSERISCI_UTENTE:
```

            inserisci_utente(utenti,u_d)

        elif scelta == INSERISCI_DISPOSITIVO:

            inserisci_dispositivo(utenti,dispositivi,u_d)

```
        elif scelta == ELIMINA_UTENTE:
```

            elimina_utente(utenti,dispositivi,u_d)

```
        elif scelta == CERCA_AREA:
```
```
            cerca(dispositivi)
```
```
        else:
```

            print('Scelta non valida.\n')

```
        scelta = menu()
```
```
 
```
```
main()
```

Appello 5 Novembre 2018

Esercizio 4: Si ha la necessità di gestire due tipologie, mutuamente esclusive, di iscritti a una conferenza: “Partecipante” e “Speaker”, mantenendo traccia delle informazioni anagrafiche: nome, cognome e CF (16 valori alfanumerici). Per ogni tipologia è necessario gestire le seguenti informazioni aggiuntive:

per Partecipante è necessario conoscere la modalità di iscrizione (“Studente” o “Full”) e il costo di iscrizione;
per Speaker è necessario conoscere l’affiliazione.

Si modelli il problema secondo i paradigmi della programmazione orientata agli oggetti e si scelga una opportuna struttura dati per memorizzare partecipanti e speaker; si scriva quindi il codice Python dell’algoritmo che:

definisce in maniera opportuna le classi partecipante e speaker;
permette di inserire un nuovo iscritto;
permette di cancellare un iscritto;
permette di modificare la modalità di iscrizione dei partecipanti da studente a full e vice versa;
permette di cercare uno speaker e di stampare le relative informazioni;
permette di calcolare il numero di partecipanti iscritti in base alla modalità di iscrizione;
permette di salvare in un unico file binario tutte le informazioni raccolte;
gestisce le eccezioni che possono essere generate;
richiama le funzioni implementate mediante un menu.

Codice Python

Di seguito il codice Python che implementa la classe Iscritto.

```
class Iscritto:
```
```
    def __init__(self,nome, cognome):
```
```
        self.__nome = nome
```
```
        self.__cognome = cognome
```
```
 
```
```
    def seNome(self,nome):
```
```
        self.__nome = nome
```
```
 
```
```
    def setCognome(self,cognome):
```
```
        self.__cognome = cognome
```
```
 
```
```
    def getNome(self):
```
```
        return self.__nome
```
```
 
```
```
    def getCognome(self):
```
```
        return self.__cognome
```
```
 
```
```
    def __str__(self):
```

        return 'Nome: ' + self.__nome + '\nCognome: ' + self.__cognome + '\n'

Di seguito il codice Python che implementa le classi Partecipante e Speaker.

```
from iscritto import Iscritto
```
```
 
```
```
class Partecipante(Iscritto):
```

    def __init__(self,nome, cognome, tipologia, costo):

        Iscritto.__init__(self,nome, cognome)

```
        self.__tipologia = tipologia
```
```
        self.__costo = costo
```
```
 
```
```
    def setTipologia(self,tipologia):
```
```
        self.__tipologia = tipologia
```
```
 
```
```
    def setCosto(self,costo):
```
```
        self.__costo = costo
```
```
 
```
```
    def getTipologia(self):
```
```
        return self.__tipologia
```
```
 
```
```
    def getCosto(self):
```
```
        return self.__costo
```
```
 
```
```
    def __str__(self):
```

        return Iscritto.__str__(self) + 'Tipologia: ' + self.__tipologia + '\nCosto: ' + self.__costo + '\n'

```
 
```
```
 
```
```
class Speaker(Iscritto):
```

    def __init__(self,nome, cognome, affiliazione):

        Iscritto.__init__(self, nome, cognome)

        self.__affiliazione = affiliazione

```
 
```

    def setAffiliazione(self,affialiazione):

        self.__affiliazione = affialiazione

```
 
```
```
    def getAffiliazione(self):
```
```
        return self.__affiliazione
```
```
 
```
```
    def __str__(self):
```

        return Iscritto.__str__(self) + 'Affiliazione: ' + self.__affiliazione + '\n'

Di seguito la funzione main.

```
import pickle
```
```
 
```

from categorie import Partecipante, Speaker

```
 
```
```
INS = 1
```
```
CANC = 2
```
```
MOD = 3
```
```
CERCA = 4
```
```
CALCOLA = 5
```
```
SALVA = 6
```
```
ESCI = 7
```
```
 
```
```
def menu():
```
```
    print('1) Inserisci')
```
```
    print('2) Cancella')
```
```
    print('3) Modifica')
```
```
    print('4) Cerca')
```
```
    print('5) Calcola')
```
```
    print('6) Salva')
```
```
    print('7) Esci')
```
```
 
```
```
    try:
```
```
        c = int(input('Scelta: '))
```
```
        return c
```
```
    except ValueError:
```
```
        return 0
```
```
 
```
```
 
```
```
def inserisci(p,s):
```
```
 
```
```
    cf = input('Inserisci CF: ')
```
```
 
```
```
    if len(cf) != 16:
```
```
        print('CF non valido.')
```
```
    elif cf in p:
```

        print('Partecipante già inserito.')

```
    elif cf in s:
```
```
        print('Speaker già inserito.')
```
```
    else:
```
```
        nome = input('Nome: ')
```
```
        cognome = input('Cognome: ')
```
```
 
```
```
        m = ''
```

        while m != 'p' and m != 's' and m != 'a':

            m = input('Tipologia (p = \'partecipante\', s = \'speaker\', a = \'annulla\'):')

```
 
```
```
        if m == 'p':
```
```
            tipologia = ''
```

            while tipologia != 's' and tipologia != 'f' and tipologia != 'a':

                tipologia = input('Tipologia (s = \'studente\', f = \'full\', a = \'annulla\'):')

```
 
```
```
            costo = -1
```
```
            while costo < 0:
```
```
                try:
```

                    costo = float(input('Costo: '))

```
                    if costo < 0:
```

                        raise ValueError

```
                except ValueError:
```

                    print('Costo non valido.')

```
 
```

            p[cf] = Partecipante(nome,cognome,tipologia,costo)

```
 
```
```
        elif m == 's':
```

            affiliazion = input('Affiliazion: ')

            s[cf] = Speaker(nome, cognome, affiliazion)

```
 
```
```
 
```
```
def cancella(p,s):
```

    cf = input('Inserisci CF dell\'iscritto che si vuole cancellare: ')

```
 
```
```
    if cf in p:
```
```
        del p[cf]
```
```
    elif cf in s:
```
```
        del s[cf]
```
```
    else:
```
```
        print('CF non presente.')
```
```
 
```
```
 
```
```
def modifica(p):
```

    cf = input('Inserisci CF del partecipante da modificare: ')

```
 
```
```
    if cf in p:
```
```
        if p[cf].getTipologia() == 's':
```
```
            p[cf].setTipologia('f')
```
```
            print('studente --> full')
```
```
        else:
```
```
            p[cf].setTipologia('s')
```
```
            print('full --> studente')
```
```
    else:
```
```
        print('CF non presente.')
```
```
 
```
```
 
```
```
def cerca(s):
```

    cf = input('Inserisci CF dello speaker da cercare: ')

```
 
```
```
    if cf in s:
```
```
        print(s[cf])
```
```
    else:
```
```
        print('CF non presente.')
```
```
 
```
```
 
```
```
def calcola(p):
```
```
    tipologia = ''
```

    while tipologia != 's' and tipologia != 'f' and tipologia != 'a':

        tipologia = input('Tipologia (s = \'studente\', f = \'full\', a = \'annulla\'):')

```
 
```
```
    if tipologia != 'a':
```
```
        s = 0
```
```
        for cf in p:
```

            if p[cf].getTipologia() == tipologia:

```
                s += 1
```

        print('Il numero di iscritti per la tipologia richiesta è: ',s)

```
 
```
```
 
```
```
def salva(p,s):
```

    filename = input('Inserisci il nome del file in cui salvare (.dat): ')

```
    try:
```
```
        fid = open(filename,'wb')
```
```
        pickle.dump(p,fid)
```
```
        pickle.dump(s, fid)
```
```
        fid.close()
```
```
    except IOError:
```

        print('Errore nella scrittura del file.')

```
 
```
```
 
```
```
def main():
```
```
    partecipanti = {}
```
```
    speaker = {}
```
```
 
```
```
    c = 0
```
```
 
```
```
    while c != ESCI:
```
```
        c = menu()
```
```
        if c == INS:
```

            inserisci(partecipanti,speaker)

```
        elif c == CANC:
```

            cancella(partecipanti,speaker)

```
        elif c == MOD:
```
```
            modifica(partecipanti)
```
```
        elif c == CERCA:
```
```
            cerca(speaker)
```
```
        elif c == CALCOLA:
```
```
            calcola(partecipanti)
```
```
        elif c == SALVA:
```
```
            salva(partecipanti,speaker)
```
```
        elif c == ESCI:
```
```
            pass
```
```
        else:
```
```
            print('Scelta non valida.')
```
```
 
```
```
main()
```

Appello 7 Gennaio 2019

Esercizio 4: Si ha la necessità di gestire un servizio di autonoleggio. In particolare è necessario tenere traccia dei clienti e dei veicoli noleggiati. Per ogni cliente è necessario tenere traccia delle seguenti informazioni: nome, cognome, età, numero patente e CF. Per quanto riguarda i veicoli, invece, distinguiamo due tipologie “Utilitaria” e “Lusso” e per ognuna di esse è necessario conoscere le seguenti informazioni:

per Utilitaria è necessario conoscere targa, modello e costo;
per Lusso è necessario conoscere targa, modello, costo e accessori (lista di elementi).

Si modelli il problema secondo i paradigmi della programmazione orientata agli oggetti e si scelga una opportuna struttura dati per memorizzare i clienti, i veicoli e i noleggi effettuati; si scriva quindi il codice Python dell’algoritmo che:

definisce in maniera opportuna le classi cliente e veicolo;
permette di inserire un nuovo veicolo;
permette di inserire un nuovo cliente (se non esistente) e di associare il veicolo noleggiato;
permette di calcolare il numero di veicoli noleggiati da clienti con età superiore ad anni 24;
permette di calcolare il consto totale dei veicoli noleggiati;
gestisce le eccezioni che possono essere generate;
richiama le funzioni implementate mediante un menu .

Codice Python

Di seguito il codice Python che implementa la classe Cliente.

```
class Cliente:
```

    def __init__(self,nome,cognome,eta,n_patente):

```
        self.__nome = nome
```
```
        self.__cognome = cognome
```
```
        self.__eta = eta
```
```
        self.__n_patente = n_patente
```
```
 
```
```
    def setNome(self,nome):
```
```
        self.__nome = nome
```
```
 
```
```
    def setCognome(self,cognome):
```
```
        self.__cognome = cognome
```
```
 
```
```
    def setEta(self,eta):
```
```
        self.__eta = eta
```
```
 
```
```
    def setNPatente(self,n_patente):
```
```
        self.__n_patente = n_patente
```
```
 
```
```
    def getNome(self):
```
```
        return self.__nome
```
```
 
```
```
    def getCognome(self):
```
```
        return self.__cognome
```
```
 
```
```
    def getEta(self):
```
```
        return self.__eta
```
```
 
```
```
    def getNPatente(self):
```
```
        return self.__n_patente
```
```
 
```
```
    def __str__(self):
```

        return "Nome: " + self.__nome + "\nCognome: " + self.__cognome + "\nEta': " + str(self.__eta) + "\nNumero Patente: " + self.__n_patente + "\n"

Di seguito il codice Python che implementa le classi Utilitaria e Lusso.

```
class Utilitaria:
```
```
    def __init__(self,modello,costo):
```
```
        self.__modello = modello
```
```
        self.__costo = costo
```
```
 
```
```
    def setModello(self,modello):
```
```
        self.__modello = modello
```
```
 
```
```
    def setCosto(self,costo):
```
```
        self.__costo = costo
```
```
 
```
```
    def getModello(self):
```
```
        return self.__modello
```
```
 
```
```
    def getCosto(self):
```
```
        return self.__costo
```
```
 
```
```
    def __str__(self):
```

        return "Modello: " + self.__modello + "\nCosto: " + str(self.__costo) + "\n"

```
 
```
```
 
```
```
class Lusso(Utilitaria):
```

    def __init__(self,modello,costo,accessori):

        Utilitaria.__init__(self,modello,costo)

```
        self.__accessori = accessori
```
```
 
```
```
    def setAccessori(self,accessori):
```
```
        self.__accessori = accessori
```
```
 
```
```
    def getAccessori(self):
```
```
        return self.__accessori
```
```
 
```
```
    def __str__(self):
```
```
        out = Utilitaria.__str__(self)
```
```
 
```
```
        for i in self.__accessori:
```
```
            out = out + str(i) + "\n"
```
```
 
```
```
        return out
```

Di seguito la funzione main.

```
from cliente import Cliente
```
```
from veicolo import Utilitaria, Lusso
```
```
 
```
```
INSERISCI_VEICOLO = 1
```
```
NUOVO_NOLEGGIO = 2
```
```
ETA = 3
```
```
COSTO = 4
```
```
ESCI = 5
```
```
 
```
```
def menu():
```

    print("1) Inserisci nuovo veicolo;")

```
    print("2) Nuovo noleggio;")
```
```
    print("3) Conta;")
```
```
    print("4) Calcola costo;")
```
```
    print("5) Esci.")
```
```
 
```
```
    try:
```
```
        return int(input("Scelta: "))
```
```
    except ValueError:
```
```
        return 0
```
```
 
```
```
def inserisci_veicolo(d):
```
```
    targa = input("Inserisci targa: ")
```
```
 
```
```
    if targa in d:
```
```
        print("Veicolo Esistente.")
```
```
        return
```
```
 
```

    modello = input("Inserisci modello: ")

```
 
```
```
    try:
```

        costo = int(input("Inserisci costo: "))

```
    except ValueError:
```
```
        print("Valore non valido.")
```
```
        return
```
```
 
```
```
    c = ''
```

    while c != 'u' and c != 'l' and c != 'a':

        c =input("\"u\" = utilitaria, \"l\" = lusso, \"a\" = annulla: ")

```
 
```
```
    if c == 'u':
```

        d[targa] = Utilitaria(modello,costo)

```
    elif c == 'l':
```
```
        accessori = []
```
```
 
```
```
        c = ''
```
```
        while c != 'n':
```

            accessori.append(input("Accessorio: "))

            c = input("Nuovo accessorio (\"s\" = si, \"n\" = no): ")

```
 
```

        d[targa] = Lusso(modello,costo,accessori)

```
 
```
```
def inserisci_dati_cliente():
```
```
    nome = input("Nome: ")
```
```
    cognome = input("Cognome: ")
```
```
    try:
```
```
        eta = int(input("Eta': "))
```
```
    except ValueError:
```
```
        print("Vaolre non valido.")
```
```
        return -1
```
```
    else:
```

        npat = input("Numero patente: ")

        return Cliente(nome,cognome,eta,npat)

```
 
```
```
def nuovo_cliente(clienti,noleggi):
```
```
    cf = input("CF: ")
```

    if cf not in clienti:  # Nuovo cliente

        cliente = inserisci_dati_cliente()

        if isinstance(cliente, Cliente):

```
            clienti[cf] = cliente
```
```
            noleggi[cf] = []
```
```
            print("Cliente creato.")
```
```
    return cf
```
```
 
```
```
 
```

def nuovo_noleggio(clienti,veicoli,noleggi):

```
    targa = input("Targa: ")
```

    if targa in veicoli: # Il veicolo esiste

```
 
```
```
        for cf in noleggi:
```

            if targa in noleggi[cf]: # Veicolo non noleggiabile

                print("Veicolo non noleggiabile.")

```
                return
```
```
 
```

        cf = nuovo_cliente(clienti, noleggi)

        if cf in clienti:  # Cliente esistente

```
            noleggi[cf].append(targa)
```
```
 
```
```
    else:
```
```
        print ("Veicolo non trovato.")
```
```
 
```
```
 
```
```
def conta(clienti,noleggi):
```
```
    count = 0
```
```
    for cf in noleggi:
```
```
        if clienti[cf].getEta() > 24:
```
```
            count += len(noleggi[cf])
```
```
    print("Numero clienti: ",count)
```
```
 
```
```
def somma_costo(veicoli,noleggi):
```
```
    targhe_nol = []
```
```
    for cf in noleggi:
```
```
        targhe_nol += noleggi[cf]
```
```
 
```
```
    count = 0
```
```
    for targa in targhe_nol:
```

        count += veicoli[targa].getCosto()

```
 
```
```
    print("Costo totale: ",count)
```
```
 
```
```
 
```
```
def main():
```
```
    clienti = {}
```
```
    veicoli = {}
```
```
    noleggi = {}
```
```
 
```
```
    c = menu()
```
```
    while c != ESCI:
```
```
        if c == INSERISCI_VEICOLO:
```
```
            inserisci_veicolo(veicoli)
```
```
        elif c == NUOVO_NOLEGGIO:
```

            nuovo_noleggio(clienti,veicoli,noleggi)

```
        elif c == ETA:
```
```
            conta(clienti,noleggi)
```
```
        elif c == COSTO:
```

            somma_costo(veicoli, noleggi)

```
        else:
```
```
            print("Scelta non valida")
```
```
 
```
```
        c = menu()
```
```
 
```
```
main()
```

Appello 4 Febbraio 2019

Esercizio 4: Si ha la necessità di gestire la mailing list di un sito istituzionale. In particolare è necessario gestire tre tipologie di iscrizioni: “Guest”, “Studente” e “Docente”. Per potersi iscrivere ad ogni mailing list ogni utente deve fornire le seguenti informazioni: nome, cognome, anno di nascita ed indirizzo email. In base alla tipologia di utente, inoltre, sono necessarie le seguenti informazioni aggiuntive:

Guest: tipo di documento d’identità (passaporto o carta d’identità), numero documento;
Studente: matricola e corso di studi;
Docente: codice fiscale (16 valori alfanumerici) e dipartimento di afferenza.

Si modelli il problema secondo i paradigmi della programmazione orientata agli oggetti e si scelga una opportuna struttura dati per memorizzare le tre tipologie di utente; si scriva quindi il codice Python dell’algoritmo che:

definisce la classe utente;
definisce in maniera opportuna le classi Guest, Studente e Docente;
permette di inserire un nuovo iscritto;
permette di eliminare un iscritto;
permette di cercare e stampare il codice fiscale di ogni docente in base al dipartimento richiesto;
permette di cercare e stampare tutti gli indirizzi email degli studenti nati in un determinato intervallo temporale;
gestisce le eccezioni che possono essere generate;
richiama le funzioni implementate mediante un menu;

Codice Python

Di seguito il codice Python che implementa la classe Cliente.

```
class Utente:
```

    def __init__(self,nome,cognome,anno):

```
        self.__nome = nome
```
```
        self.__cognome = cognome
```
```
        self.__anno = anno
```
```
 
```
```
    def setNome(self,nome):
```
```
        self.__nome = nome
```
```
 
```
```
    def setCognome(self,cognome):
```
```
        self.__cognome = cognome
```
```
 
```
```
    def setAnno(self,anno):
```
```
        self.__anno = anno
```
```
 
```
```
    def getNome(self):
```
```
        return self.__nome
```
```
 
```
```
    def getCognome(self):
```
```
        return self.__cognome
```
```
 
```
```
    def getAnno(self):
```
```
        return self.__anno
```
```
 
```
```
    def __str__(self):
```

        return 'Nome: ' + self.__nome + '\nCognome: ' + self.__cognome + '\nAnno: ' + self.__anno + '\n'

Di seguito il codice Python che implementa le classi Guest, Studente e Docente.

```
from utente import Utente
```
```
 
```
```
class Guest(Utente):
```

    def __init__(self,nome,cognome,anno,tipo,doc):

        Utente.__init__(self,nome,cognome,anno)

```
        self.__tipo = tipo
```
```
        self.__doc = doc
```
```
 
```
```
    def setTipo(self,tipo):
```
```
        self.__tipo == tipo
```
```
 
```
```
    def setDoc(self,doc):
```
```
        self.__doc = doc
```
```
 
```
```
    def getTipo(self):
```
```
        return self.__tipo
```
```
 
```
```
    def getDoc(self):
```
```
        return self.__doc
```
```
 
```
```
    def __str__(self):
```

        Utente.__str__(self) + '\nTipo: ' + self.__tipo + '\nDoc: ' + self.__doc + '\n'

```
 
```
```
 
```
```
class Studente(Utente):
```

    def __init__(self,nome,cognome,anno,matricola,corso):

        Utente.__init__(self,nome,cognome,anno)

```
        self.__matricola = matricola
```
```
        self.__corso = corso
```
```
 
```
```
    def setMatricola(self,matricola):
```
```
        self.__matricola == matricola
```
```
 
```
```
    def setCorso(self,corso):
```
```
        self.__corso = corso
```
```
 
```
```
    def getMatricola(self):
```
```
        return self.__matricola
```
```
 
```
```
    def getCorso(self):
```
```
        return self.__corso
```
```
 
```
```
    def __str__(self):
```

        Utente.__str__(self) + '\nMatricola: ' + self.__matricola + '\nCorso: ' + self.__corso + '\n'

```
 
```
```
 
```
```
class Docente(Utente):
```

    def __init__(self,nome,cognome,anno,cf,dip):

        Utente.__init__(self,nome,cognome,anno)

```
        self.__cf = cf
```
```
        self.__dip = dip
```
```
 
```
```
    def setCF(self,cf):
```
```
        self.__cf == cf
```
```
 
```
```
    def setDip(self,dip):
```
```
        self.__dip = dip
```
```
 
```
```
    def getCF(self):
```
```
        return self.__cf
```
```
 
```
```
    def getDip(self):
```
```
        return self.__dip
```
```
 
```
```
    def __str__(self):
```

        Utente.__str__(self) + '\nCF: ' + self.__cf + '\nDip: ' + self.__dip + '\n'

Di seguito la funzione main.

```
from iscritto import Guest
```
```
from iscritto import Studente
```
```
from iscritto import Docente
```
```
 
```
```
 
```
```
INSERISCI = 1
```
```
ELIMINA = 2
```
```
CERCA_CF = 3
```
```
CERCA_EMAIL = 4
```
```
ESCI = 5
```
```
 
```
```
 
```
```
def menu():
```
```
    print('1) Inserisci: ')
```
```
    print('2) Elimina: ')
```
```
    print('3) Cerca CF: ')
```
```
    print('4) Cerca email: ')
```
```
    print('5) Esci: ')
```
```
 
```
```
    try:
```
```
        return int(input('Scelta: '))
```
```
    except ValueError:
```
```
        return -1
```
```
 
```
```
 
```
```
def inserisci(iscritti):
```
```
    email = input('Email: ')
```
```
 
```
```
    if email in iscritti:
```
```
        print('Utente già iscritto.')
```
```
    else:
```
```
        tipo = ''
```
```
 
```

        while tipo != 'g' and tipo != 's' and tipo != 'd' and tipo != 'a':

            tipo = input('Tipo (g = Guest, s = Studente, d = Docente, a = Annulla): ')

```
 
```
```
        if tipo != 'a':
```
```
            nome = input('Nome: ')
```

            cognome = input('Cognome: ')

```
            try:
```

                anno = int(input('Anno: '))

```
            except ValueError:
```

                print('Anno non valido.')

```
                return
```
```
 
```
```
            if tipo == 'g':
```
```
                tipo_doc = ''
```

                while tipo_doc != 'p' and tipo_doc != 'c' and tipo_doc != 'a':

                    tipo_doc = input('Tipo documento (p = Passaporto, c = CI, a = Annulla): ')

```
 
```
```
                if tipo_doc == 'a':
```
```
                    return
```
```
 
```

                doc = input('Numero documento: ')

```
 
```

                iscritti[email] = Guest(nome,cognome,anno,tipo_doc,doc)

```
 
```
```
            elif tipo == 's':
```

                matricola = input('Matricola: ')

                corso = input('Corso: ')

```
 
```

                iscritti[email] = Studente(nome,cognome,anno,matricola,corso)

```
 
```
```
            else:
```
```
                cf = input('CF: ')
```
```
 
```
```
                if len(cf) != 16:
```
```
                    return
```
```
 
```

                dip = input('Dipartimento: ')

```
 
```

                iscritti[email] = Docente(nome,cognome,anno,cf,dip)

```
 
```
```
 
```
```
def elimina(iscritti):
```
```
    email = input('Email: ')
```
```
 
```
```
    if email in iscritti:
```
```
        del iscritti[email]
```
```
 
```
```
 
```
```
def cerca_cf(iscritti):
```
```
    dip = input('Dipartimento: ')
```
```
 
```
```
    for email in iscritti:
```

        if isinstance(iscritti[email], Docente):

            if iscritti[email].getDip() == dip:

                print(iscritti[email].getCF())

```
 
```
```
 
```
```
def cerca_email(iscritti):
```
```
    try:
```

        anno1 = int(input('Da (incluso): '))

        anno2 = int(input('A (escluso): '))

```
    except ValueError:
```
```
        print('Anno non valido.')
```
```
    else:
```
```
        for email in iscritti:
```

            if isinstance(iscritti[email], Studente):

                if iscritti[email].getAnno() >= anno1 and iscritti[email].getAnno() < anno2:

```
                    print(email)
```
```
 
```
```
 
```
```
def main():
```
```
 
```
```
    iscritti = {}
```
```
 
```
```
    c = menu()
```
```
    while c != ESCI:
```
```
        if c == INSERISCI:
```
```
            inserisci(iscritti)
```
```
        elif c == ELIMINA:
```
```
            elimina(iscritti)
```
```
        elif c == CERCA_CF:
```
```
            cerca_cf(iscritti)
```
```
        elif c == CERCA_EMAIL:
```
```
            cerca_email(iscritti)
```
```
        else:
```
```
            print('Scelta non valida.')
```
```
 
```
```
        c = menu()
```
```
 
```
```
 
```
```
main()
```

Risoluzione Tracce di Esame II Modulo

Indice

Appello 27 Giugno 2017

Appello 26 Luglio 2017

Appello 7 Settembre 2017

Appello 27 Settembre 2017

Appello 08 Novembre 2017

Appello 17 Gennaio 2018

Appello 14 Febbraio 2018

Appello 19 Aprile 2018

Appello 20 Giugno 2018

Appello 18 Luglio 2018

Appello 03 Settembre 2018

Appello 24 Settembre 2018

Appello 5 Novembre 2018

Appello 7 Gennaio 2019

Appello 4 Febbraio 2019

Menu di navigazione

Strumenti personali

Namespace

Varianti

Visite

Azioni

Ricerca

Navigazione

Strumenti