Risoluzione Tracce di Esame II Modulo: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
Riga 1 458: Riga 1 458:
 
print(err)
 
print(err)
 
return(1)
 
return(1)
 +
 +
main()
 +
 +
</syntaxhighlight>
 +
 +
 +
 +
== 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.
 +
 +
<syntaxhighlight lang="python" line>
 +
 +
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
 +
 +
</syntaxhighlight>
 +
 +
Di seguito la funzione main che mostra il funzionamento dei metodi definiti.
 +
 +
<syntaxhighlight lang="python" line>
 +
 +
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()
 +
 +
</syntaxhighlight>
 +
 +
 +
'''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'''
 +
 +
<syntaxhighlight lang="python" line>
 +
 +
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)
 +
 +
</syntaxhighlight>
 +
 +
Di seguito la funzione main che mostra il funzionamento dei metodi definiti.
 +
 +
<syntaxhighlight lang="python" line>
 +
 +
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()
 
main()
  
 
</syntaxhighlight>
 
</syntaxhighlight>

Versione delle 19:58, 14 feb 2018


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. 

  1. class Persona:
  2.     def __init__(self, nome, indirizzo, eta):
  3.         self.__nome = nome
  4.         self.__indirizzo = indirizzo
  5.         self.__eta = eta
  6.  
  7.     def __str__(self):
  8.         return "Nome: "+self.__nome+", Indirizzo: "+self.__indirizzo+", Età: "+ str(self.__eta)
  9.  
  10.  
  11. class Studente(Persona):
  12.     def __init__(self, nome, indirizzo, eta, voto):
  13.         Persona.__init__(self, nome, indirizzo, eta)
  14.         self.__voto = voto
  15.  
  16.     def __str__(self):
  17.         return Persona.__str__(self)+", Voto: "+ str(self.__voto)
  18.  
  19.  
  20. class Lavoratore(Persona):
  21.     def __init__(self, nome, indirizzo, eta, stipendio):
  22.         Persona.__init__(self, nome, indirizzo, eta)
  23.         self.__stipendio = stipendio
  24.  
  25.     def __str__(self):
  26.         return Persona.__str__(self)+", Stipendio: "+ str(self.__stipendio)

Di seguito la funzione Main che richiama i metodi definiti. 

  1. import ereditarieta
  2.  
  3. def main():
  4.     p = ereditarieta.Persona("Paolo", "Via Italia, 5", 34)
  5.     s = ereditarieta.Studente("Antonio", "Via delle Camelie, 19", 14, 7)
  6.     l = ereditarieta.Lavoratore("Marco", "Piazza Garibaldi, 2", 54, 1000)
  7.     print(p)
  8.     print(s)
  9.     print(l)
  10.  
  11. 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:

Es3 image.png

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:

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

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

  1. import pickle
  2.  
  3. def carica_dati():
  4.     try:
  5.         #infile = open('dati.txt','r')
  6.         namefile = input('Inserire il nome del file e la sua estensione: ')
  7.         infile = open(namefile,'r')
  8.         dati = infile.readlines()
  9.         infile.close()
  10.     except Exception as err:
  11.         dati = list()
  12.         print("File non esistente")
  13.         return dati
  14.     else:
  15.         return dati
  16.  
  17. def carica_liste(dati):
  18.     nominativi = list()
  19.     ore= list()
  20.     for i in range(0,len(dati),2):
  21.         nominativi.append(dati[i].rstrip('\n'))
  22.         ore.append(float(dati[i+1].rstrip('\n')))
  23.     return nominativi, ore
  24.  
  25. def carica_dizionario(n, o):
  26.     d = dict()
  27.     for i in range(0,len(n)):
  28.         d[n[i]] = o[i]
  29.     return d
  30.  
  31. def salva_dizionario(d):
  32.     file = open('log.dat','wb')
  33.     pickle.dump(d, file)
  34.     file.close()
  35.  
  36. def visualizza_info(d, paga_oraria):
  37.     for key in d:
  38.         totale = d[key]*paga_oraria
  39.         print("Nominativo dipendente: "+key+"\t"+ str(d[key]) + " ore lavorate\t Costo orario: "+str(paga_oraria)+ "€\t Paga lorda € "+str(totale))
  40.  
  41.  
  42. def main():
  43.     dati = carica_dati()
  44.     if (len(dati)>0):
  45.  
  46.         try:
  47.  
  48.             nominativi, ore = carica_liste(dati)
  49.  
  50.             monte_ore_lav = carica_dizionario(nominativi, ore)
  51.  
  52.             paga_oraria = float(input('Inserire la paga oraria in Euro: '))
  53.  
  54.             salva_dizionario(monte_ore_lav)
  55.             visualizza_info(monte_ore_lav, paga_oraria)
  56.  
  57.         except Exception as err:
  58.             print(err)
  59.  
  60. 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:

  1. inizializzano il punto con una posizione predefinita;
  2. restituiscono in una stringa le coordinate del punto;
  3. permettono di spostare le coordinate del punto indicando la nuova posizione;
  4. permettono di calcolare la distanza tra due punti;
  5. 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:

Es4 image.png

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. 

  1. import math
  2. class Punto3D:
  3.     def __init__(self,x,y,z):
  4.         self.__x = x
  5.         self.__y = y
  6.         self.__z = z
  7.  
  8.     def calc_dist(self, b):
  9.         x= quadrato_differenza(self.__x,b.get_x())
  10.         y= quadrato_differenza(self.__y,b.get_y())
  11.         z= quadrato_differenza(self.__z,b.get_z())
  12.         return math.sqrt(x+y+z)
  13.  
  14.     def set_pos(self,x,y,z):
  15.         self.__x = x
  16.         self.__y = y
  17.         self.__z = z
  18.  
  19.     def get_x(self):
  20.         return self.__x
  21.  
  22.     def get_y(self):
  23.         return self.__y
  24.  
  25.     def get_z(self):
  26.         return self.__z
  27.  
  28.     def __str__(self):
  29.          return "(x: "+str(self.__x) + ", y: "+str(self.__y)+", z: "+str(self.__z)+")"
  30.  
  31.     def check_condition(self,b,c):
  32.         A = self.calc_dist(b)
  33.         B = b.calc_dist(c)
  34.         C = self.calc_dist(c)
  35.         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)):
  36.             return True
  37.         else:
  38.             return False
  39.  
  40.  
  41.  
  42. def quadrato_differenza(a,b):
  43.     return (a-b)**2

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

  1. import punto
  2.  
  3.  
  4. def main():
  5.     a = punto.Punto3D(0.0,0.0,0.0)
  6.     b = punto.Punto3D(1.0,0.0,0.0)
  7.     c = punto.Punto3D(1.0,1.0,1.0)
  8.  
  9.     print("a")
  10.     print(a)
  11.     print()
  12.     print("b")
  13.     print(b)
  14.     print()
  15.     print("c")
  16.     print(c)
  17.     print()
  18.     print("distanza tra a e b\t" + str(a.calc_dist(b)))
  19.     print("distanza tra a e c\t" + str(a.calc_dist(c)))
  20.  
  21.  
  22.     if (a.check_condition(b,c)):
  23.         print("condizione vera tra a,b e c")
  24.     else:
  25.         print("condizione falsa tra a,b e c")
  26.  
  27.     a.set_pos(1,2,3)
  28.     print("nuova posizione di a")
  29.     print(a)
  30.  
  31. 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. 

  1. class Animale:
  2.     def __init__(self, alimentazione, tipo, eta):
  3.         self.__alimentazione = alimentazione
  4.         self.__tipo = tipo
  5.         self.__eta = eta
  6.  
  7.     def __str__(self):
  8.         return "Alimentazione: "+self.__alimentazione+", Tipo: "+self.__tipo+", Eta': "+ str(self.__eta)
  9.  
  10. class Mammifero(Animale):
  11.     def __init__(self, alimentazione, tipo, eta, zampe):
  12.         Animale.__init__(self, alimentazione, tipo, eta)
  13.         self.__zampe = zampe
  14.  
  15.     def __str__(self):
  16.         return Animale.__str__(self)+", Numero zampe: "+ str(self.__zampe)
  17.  
  18. class Cane(Mammifero):
  19.     def __init__(self, alimentazione, tipo, eta, zampe, razza):
  20.         Mammifero.__init__(self, alimentazione, tipo, eta, zampe)
  21.         self.__razza = razza
  22.  
  23.     def __str__(self):
  24.         return Mammifero.__str__(self)+", Razza: "+ str(self.__razza)
  25.  
  26. class Gatto(Mammifero):
  27.     def __init__(self, alimentazione, tipo, eta, zampe, razza):
  28.         Mammifero.__init__(self, alimentazione, tipo, eta, zampe)
  29.         self.__razza = razza
  30.  
  31.     def __str__(self):
  32.         return Mammifero.__str__(self)+", Razza: "+ str(self.__razza)

Di seguito la funzione Main che richiama i metodi definiti. 

  1. import ereditarieta
  2.  
  3. def main():
  4.     a = ereditarieta.Animale("onnivoro", "acquatico", 3)
  5.     m = ereditarieta.Mammifero("erbivoro", "terrestre", 20, 4)
  6.     c = ereditarieta.Cane("carnivoro", "terrestre", 10, 4, "Labrador")
  7.     g = ereditarieta.Gatto("carnivoro", "terrestre", 7, 4, "Persiano")
  8.     print(a)
  9.     print(m)
  10.     print(c)
  11.     print(g)
  12.  
  13. 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:

Es3 2.png

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:

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

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

  1. import pickle
  2.  
  3. def carica_dati():
  4.     try:
  5.         #infile = open('dati.txt','r')
  6.         namefile = input('Inserire il nome del file e la sua estensione: ')
  7.         infile = open(namefile,'r')
  8.         dati = infile.readlines()
  9.         infile.close()
  10.     except Exception as err:
  11.         dati = list()
  12.         print("File non esistente")
  13.     return dati
  14.  
  15. def carica_liste(dati):
  16.     nominativi = list()
  17.     medie = list()
  18.     for i in range(0,len(dati),3):
  19.         nominativi.append(dati[i].rstrip('\n'))
  20.         medie.append([(float(dati[i + 1].rstrip('\n')) + float(dati[i + 2].rstrip('\n')))//2])
  21.     return nominativi, medie
  22.  
  23. def carica_dizionario(n, m):
  24.     d = dict()
  25.     for i in range(0,len(n)):
  26.         d[n[i]] = m[i]
  27.     return d
  28.  
  29. def salva_dizionario(d):
  30.     file = open('voti.dat','wb')
  31.     pickle.dump(d, file)
  32.     file.close()
  33.  
  34. def visualizza_info1(nominativo_media_d):
  35.     for key in nominativo_media_d:
  36.         print("Nominativo studente: "+key+"\t"+ " Media voti: "+str(nominativo_media_d[key]),end='')
  37.         if nominativo_media_d[key][0] < 18:
  38.             print("\t Esame non superato")
  39.         else:
  40.             print("\t Esame superato")
  41.  
  42. def visualizza_info2(nominativo_media_d):
  43.     print("Esame superato da:")
  44.     for key in nominativo_media_d:
  45.         if nominativo_media_d[key][0] >= 18:
  46.             print(key)
  47.  
  48. def main():
  49.     dati = carica_dati()
  50.     if (len(dati)>0):
  51.         try:
  52.             nominativi, medie = carica_liste(dati)
  53.             nominativo_media_d = carica_dizionario(nominativi, medie)
  54.             salva_dizionario(nominativo_media_d)
  55.             visualizza_info1(nominativo_media_d)
  56.             visualizza_info2(nominativo_media_d)
  57.         except Exception as err:
  58.             print(err)
  59.  
  60. 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:

  1. inizializzano il triangolo con le posizioni dei 3 vertici;
  2. restituiscono in una stringa le coordinate dei vertici;
  3. permettono di calcolare il perimetro del triangolo;
  4. 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.

Es4 2.png

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. 

  1. import math
  2.  
  3. class Punto2D:
  4.     def __init__(self,x,y):
  5.         self.__x = x
  6.         self.__y = y
  7.  
  8.     def calc_dist(self, b):
  9.         x= quadrato_differenza(self.__x, b.get_x())
  10.         y= quadrato_differenza(self.__y, b.get_y())
  11.         return math.sqrt(x+y)
  12.  
  13.     def get_x(self):
  14.         return self.__x
  15.  
  16.     def get_y(self):
  17.         return self.__y
  18.  
  19.     def __str__(self):
  20.          return "(x: "+str(self.__x) + ", y: "+str(self.__y)+")"
  21.  
  22. def quadrato_differenza(a, b):
  23.     return (a-b)**2

Di seguito il codice python che definisce la classe Triangolo. 

  1. import math
  2.  
  3. class Triangolo:
  4.     def __init__(self, a, b, c):
  5.         self.__a = a
  6.         self.__b = b
  7.         self.__c = c
  8.  
  9.     def __str__(self):
  10.         return "Vertice A: " + str(self.__a) + " Vertice B: " + str(self.__b) + " Vertice C: " + str(self.__c)
  11.  
  12.     def check_triangle(self):
  13.         A = self.__a.calc_dist(self.__b)
  14.         B = self.__b.calc_dist(self.__c)
  15.         C = self.__c.calc_dist(self.__a)
  16.         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)):
  17.             return True
  18.         else:
  19.             return False
  20.  
  21.     def perimetro(self):
  22.         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. 

  1. from punto2d import Punto2D as punto
  2. from triangolo import Triangolo
  3.  
  4. def main():
  5.     a = punto(0, 0)
  6.     b = punto(1, 0)
  7.     c = punto(0, 1)
  8.  
  9.     t = Triangolo(a, b, c)
  10.     print(t)
  11.     print(t.perimetro())
  12.     print(t.check_triangle())
  13.  
  14.  
  15. 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. 

  1. class Animale:
  2.     def __init__(self, alimentazione, tipo):
  3.         self.__alimentazione = alimentazione
  4.         self.__tipo = tipo
  5.  
  6.     def __str__(self):
  7.         return "Alimentazione: "+self.__alimentazione+", Tipo: "+self.__tipo
  8.  
  9. class Mammifero(Animale):
  10.     def __init__(self, alimentazione, tipo, eta, zampe):
  11.         Animale.__init__(self, alimentazione, tipo)
  12.         self.__eta = eta
  13.         self.__zampe = zampe
  14.  
  15.     def __str__(self):
  16.         return Animale.__str__(self)+", Etá: "+ str(self.__eta)+", Numero zampe: "+ str(self.__zampe)
  17.  
  18. class Felino(Mammifero):
  19.     def __init__(self, alimentazione, tipo, eta, zampe, dimensione, provenienza):
  20.         Mammifero.__init__(self, alimentazione, tipo, eta, zampe)
  21.         self.__dimensione = dimensione
  22.         self.__provenienza = provenienza
  23.  
  24.     def __str__(self):
  25.         return Mammifero.__str__(self)+", Dimensione: "+ self.__dimensione+", Provenienza: "+ self.__provenienza
  26.  
  27. class Gatto(Felino):
  28.     def __init__(self, alimentazione, tipo, eta, zampe, dimensione, provenienza, verso, pelo):
  29.         Felino.__init__(self, alimentazione, tipo, eta, zampe, dimensione, provenienza)
  30.         self.__verso = verso
  31.         self.__pelo = pelo
  32.  
  33.     def __str__(self):
  34.         return Felino.__str__(self)+", Verso: "+ self.__verso+", Pelo: "+ self.__pelo

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

  1. import ereditarieta
  2.  
  3. def main():
  4.     a = ereditarieta.Animale("onnivoro", "acquatico")
  5.     m = ereditarieta.Mammifero("erbivoro", "terrestre", 20, 4)
  6.     c = ereditarieta.Felino("carnivoro", "terrestre", 10, 4, "Taglia grande", "Africa")
  7.     g = ereditarieta.Gatto("carnivoro", "terrestre", 7, 4, "Taglia piccola", "Europa", "Miagolio", "Pelo Lungo")
  8.     print(a)
  9.     print(m)
  10.     print(c)
  11.     print(g)
  12.  
  13. 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:

D563b14e9d0ab84d9f8010b2224d44df.png

Scrivere il codice Python dell’algoritmo che :

  1. definisce la classe dei punti 3D;
  2. acquisisce da tastiera il nome del file da leggere;
  3. legge il file e carica la lista di punti 3D;
  4. calcola il baricentro dei punti 3D a partire dalla lista di punti;
  5. stampa a schermo le coordinate del baricentro (inteso come ulteriore punto 3D);
  6. gestisce le eccezioni che possono essere sollevate;
  7. 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. 

  1. import math
  2. class Punto3D:
  3.     def __init__(self,x,y,z):
  4.         self.__x = x
  5.         self.__y = y
  6.         self.__z = z
  7.  
  8.     def set_pos(self,x,y,z):
  9.         self.__x = x
  10.         self.__y = y
  11.         self.__z = z
  12.  
  13.     def get_x(self):
  14.         return self.__x
  15.  
  16.     def get_y(self):
  17.         return self.__y
  18.  
  19.     def get_z(self):
  20.         return self.__z
  21.  
  22.     def __str__(self):
  23.          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. 

  1. import punto3d
  2.  
  3. def carica_dati():
  4.     try:
  5.         namefile = input('Inserire il nome del file e la sua estensione: ')
  6.         infile = open(namefile,'r')
  7.         dati = infile.readlines()
  8.         infile.close()
  9.     except Exception as err:
  10.         dati = list()
  11.         print("File non esistente")
  12.     return dati
  13.  
  14.  
  15. def carica_lista_punti(dati):
  16.     lista_punti = list()
  17.     for i in range(0,len(dati),3):
  18.         x = float(dati[i].rstrip('\n'))
  19.         y = float(dati[i+1].rstrip('\n'))
  20.         z = float(dati[i+2].rstrip('\n'))
  21.         p = punto3d.Punto3D(x,y,z)
  22.         lista_punti.append(p)
  23.     return lista_punti
  24.  
  25.  
  26. def calcola_baricentro(lista):
  27.     x = 0.0
  28.     y = 0.0
  29.     z = 0.0
  30.     for i in lista:
  31.         x+=i.get_x()
  32.         y+=i.get_y()
  33.         z+=i.get_z()
  34.     n = len(lista)
  35.     baricentro = punto3d.Punto3D(x/n,y/n,z/n)
  36.     return baricentro
  37.  
  38.  
  39. def main():
  40.     dati = carica_dati()
  41.     if (len(dati)>0):
  42.         try:
  43.             lista_punti = carica_lista_punti(dati)
  44.             print("Il baricentro dei punti contenuti nel file e'"+str(calcola_baricentro(lista_punti)))
  45.         except Exception as err:
  46.             print(err)
  47.  
  48. 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:

  1. inizializzano il campionato con un certo numero di squadre deciso dall’utente;
  2. permettono di stabilire la squadra vincitrice del campionato e di visualizzarne le informazioni a schermo;
  3. 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 

  1. class Campionato:
  2.  
  3.     def __init__(self):
  4.         self.__s = dict()
  5.  
  6.     def add_team(self, nome, punteggio):
  7.         self.__s[nome] = punteggio
  8.  
  9.     def get_team(self, nome):
  10.         self.__s.get(nome,-10)
  11.  
  12.     def delete_team(self, nome):
  13.         self.__s.pop(nome, 0)
  14.  
  15.     def get_first_team(self):
  16.         if len(self.__s)>0:
  17.             m=max(self.__s.values())
  18.             for key in self.__s:
  19.                 if self.__s[key]==m:
  20.                     return key, m
  21.         else:
  22.             return "",0
  23.  
  24.     def get_last_team(self):
  25.         if len(self.__s)>0:
  26.             m=min(self.__s.values())
  27.             for key in self.__s:
  28.                 if self.__s[key]==m:
  29.                     return key, m
  30.         else:
  31.             return "",0
  32.  
  33.     def get_number_of_team(self):
  34.         return len(self.__s)
  35.  
  36.     def __str__(self):
  37.         return str(self.__s)

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

  1. import campionato
  2.  
  3. def main():
  4.     c = campionato.Campionato()
  5.     n = int(input("Da quante squadre e' composto il campionato? "))
  6.     for i in range(0,n):
  7.         nome_squadra = input("Inserire il nome della squadra: ")
  8.         punteggio = int(input("Inserire il punteggio ottenuto dalla squadra "+nome_squadra+": "))
  9.         c.add_team(nome_squadra, punteggio)
  10.     print("Il campionato e' formato da "+str(c.get_number_of_team())+" squadre")
  11.     if c.get_number_of_team()>1:
  12.         squadra, p = c.get_first_team()
  13.         print("La squadra che ha vinto il campionato e' "+squadra+" con un punteggio di "+str(p)+" punti")
  14.     if c.get_number_of_team()>0:
  15.         print("Le ultime 3 squadre del campionato sono:")
  16.         #s servirá per ripristinare tutte le squadre cancellate 
  17.         s = dict()
  18.         for i in range(0,3):
  19.             squadra, p = c.get_last_team()
  20.             s[squadra]=p
  21.             c.delete_team(squadra)
  22.             print(squadra+" con un punteggio di "+str(p)+" punti")
  23.  
  24.         #ripristina lo stato del campionato
  25.         for k in s:
  26.             c.add_team(k, s[k])
  27.  
  28.     #verifichiamo che il numero delle squadre e lo stato del campionato sia lo stesso di quello iniziale
  29.     print("Il campionato e' formato da "+str(c.get_number_of_team())+" squadre")
  30.     print(c)
  31.  
  32. 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. 

  1. class Persona:
  2.     def __init__(self, eta, altezza):
  3.         self.__eta = eta
  4.         self.__altezza = altezza
  5.  
  6.     def get_eta(self):
  7.         return self.__eta
  8.  
  9.     def set_eta(self, eta):
  10.         self.__eta = eta
  11.  
  12.     def get_altezza(self):
  13.         return self.__altezza
  14.  
  15.     def set_altezza(self, altezza):
  16.         self.__altezza = altezza
  17.  
  18.     def __str__(self):
  19.         return "Etá: "+str(self.__eta)+", Altezza: "+str(self.__altezza)
  20.  
  21. class Lavoratore(Persona):
  22.     def __init__(self, eta, altezza, stipendio, ore_lav):
  23.         Persona.__init__(self, eta, altezza)
  24.         self.__stipendio = stipendio
  25.         self.__ore_lav = ore_lav
  26.  
  27.     def get_stipendio(self):
  28.         return self.__stipendio
  29.  
  30.     def set_stipendio(self, stipendio):
  31.         self.__stipendio = stipendio
  32.  
  33.     def get_ore_lav(self):
  34.         return self.__ore_lav
  35.  
  36.     def set_ore_lav(self, ore_lav):
  37.         self.__ore_lav = ore_lav
  38.  
  39.     def __str__(self):
  40.         return Persona.__str__(self)+", Stipendio: "+ str(self.__stipendio)+", Ore lavorate: "+ str(self.__ore_lav)
  41.  
  42. class Operaio(Lavoratore):
  43.     def __init__(self, eta, altezza, stipendio, ore_lav, mansione, unita):
  44.         Lavoratore.__init__(self, eta, altezza, stipendio, ore_lav)
  45.         self.__mansione = mansione
  46.         self.__unita = unita
  47.  
  48.     def get_mansione(self):
  49.         return self.__mansione
  50.  
  51.     def set_mansione(self, mansione):
  52.         self.__mansione = mansione
  53.  
  54.     def get_unita(self):
  55.         return self.__unita
  56.  
  57.     def set_unita(self, unita):
  58.         self.__unita = unita
  59.  
  60.     def __str__(self):
  61.         return Lavoratore.__str__(self)+", Mansione: "+ self.__mansione+", Unitá: "+ self.__unita

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

  1. import ereditarieta
  2.  
  3. def main():
  4.     a = ereditarieta.Persona(15, 145)
  5.     m = ereditarieta.Lavoratore(19, 170, 1000, 160)
  6.     c = ereditarieta.Operaio(35, 175, 1500, 180, "Movimentazione", "Auto")
  7.  
  8.     print(a)
  9.     print(m)
  10.     print(c)
  11.     print(c.get_altezza())
  12.     m.set_stipendio(1450)
  13.     print(m)
  14.  
  15. 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.

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

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

Codice Python 

  1. class Casa:
  2.  
  3.     def __init__(self, prezzo, n_vani=1, mq = 50, ascensore = "si", condominio = "si", garage = "si"):
  4.         self.__prezzo = prezzo
  5.         self.__n_vani = n_vani
  6.         self.__mq = mq
  7.         self.__ascensore = ascensore
  8.         self.__condominio = condominio
  9.         self.__garage = garage
  10.  
  11.  
  12.     def set_prezzo(self, prezzo):
  13.         self.__prezzo=prezzo
  14.  
  15.     def set_n_vani(self,n_vani):
  16.         self.__n_vani=n_vani
  17.  
  18.     def set_mq(self, mq):
  19.         self.__mq= mq
  20.  
  21.     def set_ascensore(self, ascensore):
  22.         self.__ascensore= ascensore
  23.  
  24.     def set_condominio(self, condominio):
  25.         self.__condominio= condominio
  26.  
  27.     def set_garage(self, garage):
  28.         self.__garage= garage
  29.  
  30.     def get_prezzo(self):
  31.         return self.__prezzo
  32.  
  33.     def get_n_vani(self):
  34.         return self.__n_vani
  35.  
  36.     def get_mq(self):
  37.         return self.__mq
  38.  
  39.     def get_ascensore(self):
  40.         return self.__ascensore
  41.  
  42.     def get_condominio(self):
  43.         return self.__condominio
  44.  
  45.     def get_garage(self):
  46.         return self.__garage
  47.  
  48.     def __str__(self):
  49.         return "Prezzo: "+str(format(self.__prezzo,".2f"))+" €, N. vani: "+str(self.__n_vani)+", Metri quadri: "+str(self.__mq)+", Ascensore: "+self.__ascensore+\
  50.                ", Condominio: "+self.__condominio+", Garage: "+self.__garage

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

  1. from casa import Casa
  2. import pickle
  3.  
  4. ADD_HOUSE = 1
  5. DELETE_HOUSE = 2
  6. PRINT_HOUSES = 3
  7. SAVE = 4
  8. QUIT_CHOICE = 5
  9.  
  10.  
  11. def display_menu():
  12.     print()
  13.     print("MENU")
  14.     print("1) Inserire una nuova casa da gestire")
  15.     print("2) Eliminare una casa dall'elenco")
  16.     print("3) Stampare a schermo tutte le case in gestione")
  17.     print("4) Salvare le informazioni delle case in memoria")
  18.     print("5) Uscire dal programma")
  19.     print()
  20.  
  21. def ask_house_info():
  22.     try:
  23.         prezzo = float(input("Inserire il prezzo della casa: "))
  24.         n_vani = float(input("Inserire il numero dei vani della casa: "))
  25.         mq = float(input("Inserire i metri quadri della casa: "))
  26.         ascensore = input("La casa dispone di ascensore? ")
  27.         condominio = input("La casa e' inserita in un condominio? ")
  28.         garage = input("La casa dispone di un garage? ")
  29.         c = Casa(prezzo, n_vani, mq, ascensore, condominio, garage)
  30.         return c
  31.     except Exception as err:
  32.         print(err)
  33.         return 1
  34.  
  35. def main():
  36.     agenzia = dict()
  37.  
  38.     choice = 0
  39.     while choice != QUIT_CHOICE:
  40.         display_menu()
  41.  
  42.         choice = int(input('Inserire la scelta: '))
  43.  
  44.         if choice == ADD_HOUSE:
  45.             codice = input("Inserire il codice univoco della casa: ")
  46.             c = ask_house_info()
  47.             if c!=1:
  48.                 agenzia[codice] = c
  49.  
  50.         elif choice == DELETE_HOUSE:
  51.             codice = input("Inserire il codice univoco della casa da eliminare: ")
  52.             print()
  53.             if codice in agenzia:
  54.                 del agenzia[codice]
  55.                 print("La casa con "+codice+" e' stata eliminata")
  56.             else:
  57.                 print("Codice univoco della casa non corretto")
  58.             print()
  59.  
  60.         elif choice == PRINT_HOUSES:
  61.             print()
  62.             if len(agenzia)==0:
  63.                 print("Nessuna casa in gestione")
  64.             else:
  65.                 for key in agenzia:
  66.                     print("Codice: "+key+" - "+str(agenzia[key]))
  67.                     print()
  68.  
  69.         elif choice == SAVE:
  70.             namefile = input("Inserire il nome del file dove memorizzare i dati delle case: ")
  71.             file = open(namefile,'wb')
  72.             pickle.dump(agenzia, file)
  73.             file.close()
  74.  
  75.         elif choice!= QUIT_CHOICE:
  76.             print('Errore: scelta non valida')
  77.  
  78.  
  79. 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. 

  1. class Mammifero:
  2.     def __init__(self, eta, alimentazione):
  3.         self.__eta = eta
  4.         self.__alimentazione = alimentazione
  5.  
  6.     def get_eta(self):
  7.         return self.__eta
  8.  
  9.     def set_eta(self, eta):
  10.         self.__eta = eta
  11.  
  12.     def get_alimentazione(self):
  13.         return self.__alimentazione
  14.  
  15.     def set_alimentazione(self, alimentazione):
  16.         self.__alimentazione = alimentazione
  17.  
  18.     def __str__(self):
  19.         return "Etá: "+str(self.__eta)+", Alimentazione: "+str(self.__alimentazione)
  20.  
  21. class Felino(Mammifero):
  22.     def __init__(self, eta, alimentazione, habitat, pelo):
  23.         Mammifero.__init__(self, eta, alimentazione)
  24.         self.__habitat = habitat
  25.         self.__pelo = pelo
  26.  
  27.     def get_habitat(self):
  28.         return self.__habitat
  29.  
  30.     def set_habitat(self, habitat):
  31.         self.__habitat = habitat
  32.  
  33.     def get_pelo(self):
  34.         return self.__pelo
  35.  
  36.     def set_pelo(self, pelo):
  37.         self.__pelo = pelo
  38.  
  39.     def __str__(self):
  40.         return Mammifero.__str__(self)+", Habitat: "+ str(self.__habitat)+", Pelo: "+ str(self.__pelo)
  41.  
  42. class Canide(Mammifero):
  43.     def __init__(self, eta, alimentazione, verso, origine):
  44.         Mammifero.__init__(self, eta, alimentazione)
  45.         self.__verso = verso
  46.         self.__origine = origine
  47.  
  48.     def get_verso(self):
  49.         return self.__verso
  50.  
  51.     def set_verso(self, verso):
  52.         self.__verso = verso
  53.  
  54.     def get_origine(self):
  55.         return self.__origine
  56.  
  57.     def set_origine(self, origine):
  58.         self.__origine = origine
  59.  
  60.     def __str__(self):
  61.         return Mammifero.__str__(self)+", Verso: "+ str(self.__verso)+" Origine: "+ str(self.__origine)
  62.  
  63. class Gatto(Felino):
  64.     def __init__(self, eta, alimentazione, habitat, pelo, razza, colore):
  65.         Felino.__init__(self, eta, alimentazione, habitat, pelo)
  66.         self.__razza = razza
  67.         self.__colore = colore
  68.  
  69.     def get_razza(self):
  70.         return self.__razza
  71.  
  72.     def set_razza(self, razza):
  73.         self.__razza = razza
  74.  
  75.     def get_colore(self):
  76.         return self.__colore
  77.  
  78.     def set_colore(self, colore):
  79.         self.__colore = colore
  80.  
  81.     def __str__(self):
  82.         return Felino.__str__(self)+", Razza: "+ self.__razza+", Colore: "+ self.__colore

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

  1. import ereditarieta
  2.  
  3. def main():
  4.     a = ereditarieta.Mammifero(15, "Vegetariano")
  5.     b = ereditarieta.Felino(13, "Carnivoro", "Savana", "Lungo")
  6.     c = ereditarieta.Gatto(4, "Carnivoro", "Domestico", "Corto", "Siamese", "Bianco")
  7.     d = ereditarieta.Canide(1, "Onnivoro", "Abbaiare", "Germania") 
  8.  
  9.     print(a)
  10.     print(b)
  11.     print(c)
  12.     print(d)
  13.     print(c.get_colore())
  14.     print(c.get_habitat())
  15.     d.set_origine("Italia")
  16.     print(d)
  17.  
  18. 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:

  1. definisce un oggetto parametro ematico con le informazioni ad essa relative;
  2. inizializza il dizionario leggendo da file binario;
  3. stampa a schermo tutti i valori di riferimento contenuti nel dizionario;
  4. 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;
  5. gestisce le eccezioni che possono essere sollevate;
  6. richiama tutte le funzioni viste (main).

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

Codice Python 

  1. class PE:
  2.  
  3.     def __init__(self, nome, minimo, massimo, u_misura, descrizione):
  4.         self.__nome = nome
  5.         self.__minimo = minimo
  6.         self.__massimo = massimo
  7.         self.__u_misura = u_misura
  8.         self.__descrizione = descrizione
  9.  
  10.  
  11.     def set_nome(self, nome):
  12.         self.__nome=nome
  13.  
  14.     def set_minimo(self,minimo):
  15.         self.__minimo=minimo
  16.  
  17.     def set_massimo(self, massimo):
  18.         self.__massimo= massimo
  19.  
  20.     def set_u_misura(self, u_misura):
  21.         self.__u_misura= u_misura
  22.  
  23.     def set_descrizione(self, descrizione):
  24.         self.__descrizione= descrizione
  25.  
  26.     def get_nome(self):
  27.         return self.__nome
  28.  
  29.     def get_minimo(self):
  30.         return self.__minimo
  31.  
  32.     def get_massimo(self):
  33.         return self.__massimo
  34.  
  35.     def get_u_misura(self):
  36.         return self.__u_misura
  37.  
  38.     def get_descrizione(self):
  39.         return self.__descrizione
  40.  
  41.     def __str__(self):
  42.         return "Parametro ematico\nNome: "+self.__nome+" - Range = minimo: "+str(format(self.__minimo,".2f"))+"- massimo: "+str(format(self.__massimo,".2f"))+", u_misura: "+self.__u_misura+\
  43.                ", 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 

  1. import pickle
  2. import parametro_ematico    
  3.  
  4. def main():
  5.     try:
  6.         #namefile = input("Inserire il nome del file dove sono memorizzati i dati dei parametri ematici: ")
  7.         input_file = open('Parametri.dat','rb')
  8.         analisi = pickle.load(input_file)
  9.  
  10.         print()
  11.  
  12.         for key in analisi:
  13.             print("Codice parametro ematico: "+key+"\n"+str(analisi[key]))
  14.  
  15.  
  16.         N = int(input("\nInserire il numero di interrogazioni per i parametri ematici: "))
  17.  
  18.         for i in range(1,N+1):
  19.             codice = input("\nInserire il codice univoco del parametro ematico: ")
  20.             print("\nCodice parametro ematico: "+codice+"\n"+str(analisi[codice]))
  21.             value = float(input("Inserire valore del parametro ematico derivante dall'analisi: "))
  22.             if (value>=float(analisi[codice].get_minimo())) and (value<=float(analisi[codice].get_massimo())):
  23.                 print("Valore del parametro "+analisi[codice].get_nome()+" nella norma")
  24.             else:
  25.                 print("Valore del parametro "+analisi[codice].get_nome()+" FUORI NORMA")
  26.             print()
  27.  
  28.     except Exception as err:
  29.         print(err)
  30.         return(1)
  31.  
  32. 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. 

  1. class Forma:
  2.     def __init__(self, colore):
  3.         self.__colore = colore
  4.  
  5.     def get_colore(self):
  6.         return self.__colore
  7.  
  8.     def set_colore(self, colore):
  9.         self.__colore = colore
  10.  
  11.     def __str__(self):
  12.         return "Colore: "+self.__colore
  13.  
  14. class Poligono(Forma):
  15.     def __init__(self, colore, nlati):
  16.         Forma.__init__(self, colore)
  17.         self.__nlati = nlati
  18.  
  19.     def get_nlati(self):
  20.         return self.__nlati
  21.  
  22.     def set_nlati(self, nlati):
  23.         self.__nlati = nlati
  24.  
  25.     def __str__(self):
  26.         return Forma.__str__(self)+", n. lati: "+ str(self.__nlati)
  27.  
  28. class Ellisse(Forma):
  29.     def __init__(self, colore, asse_maggiore):
  30.         Forma.__init__(self, colore)
  31.         self.__asse_maggiore = asse_maggiore
  32.  
  33.     def get_asse_maggiore(self):
  34.         return self.__asse_maggiore
  35.  
  36.     def set_asse_maggiore(self, asse_maggiore):
  37.         self.__asse_maggiore = asse_maggiore
  38.  
  39.     def __str__(self):
  40.         return Forma.__str__(self)+" asse_maggiore: "+ str(self.__asse_maggiore)
  41.  
  42. class Quadrato(Poligono):
  43.     def __init__(self, colore, nlati, dim):
  44.         Poligono.__init__(self, colore, nlati)
  45.         self.__dim = dim
  46.  
  47.     def get_dim(self):
  48.         return self.__dim
  49.  
  50.     def set_dim(self, dim):
  51.         self.__dim = dim
  52.  
  53.     def __str__(self):
  54.         return Poligono.__str__(self)+", dim: "+ str(self.__dim)

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

  1. import ereditarieta
  2.  
  3. def main():
  4.     a = ereditarieta.Forma("Giallo")
  5.     b = ereditarieta.Poligono("Verde", 6)
  6.     c = ereditarieta.Ellisse("Blu", 34.5)
  7.     d = ereditarieta.Quadrato("Bianco",4,4.3) 
  8.  
  9.     print(a)
  10.     print(b)
  11.     print(c)
  12.     print(d)
  13.     print(c.get_asse_maggiore())
  14.     d.set_dim(6.4)
  15.     print(d)
  16.  
  17. 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:

  1. definisce un oggetto prodotto con le informazioni ad essa relative;
  2. inizializza il dizionario con dati inventati;
  3. stampa a schermo tutti i prodotti contenuti nel magazzino;
  4. 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;
  5. scrive in memoria il dizionario in un file binario;
  6. gestisce le eccezioni che possono essere sollevate;
  7. richiama tutte le funzioni viste (main).

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

Codice Python 

  1. class Prodotto:
  2.  
  3.     def __init__(self, nome, altezza, larghezza, profondita, prezzo):
  4.         self.__nome = nome
  5.         self.__altezza = altezza
  6.         self.__larghezza = larghezza
  7.         self.__profondita = profondita
  8.         self.__prezzo = prezzo
  9.  
  10.     def set_nome(self, nome):
  11.         self.__nome=nome
  12.  
  13.     def set_altezza(self,altezza):
  14.         self.__altezza=altezza
  15.  
  16.     def set_larghezza(self, larghezza):
  17.         self.__larghezza= larghezza
  18.  
  19.     def set_profondita(self, profondita):
  20.         self.__profondita= profondita
  21.  
  22.     def set_prezzo(self, prezzo):
  23.         self.__prezzo= prezzo
  24.  
  25.     def get_nome(self):
  26.         return self.__nome
  27.  
  28.     def get_altezza(self):
  29.         return self.__altezza
  30.  
  31.     def get_larghezza(self):
  32.         return self.__larghezza
  33.  
  34.     def get_profondita(self):
  35.         return self.__profondita
  36.  
  37.     def get_prezzo(self):
  38.         return self.__prezzo
  39.  
  40.     def __str__(self):
  41.         return "Prodotto\nNome: "+self.__nome+" - Altezza: "+str(format(self.__altezza,".2f"))+"- larghezza: "+str(format(self.__larghezza,".2f"))+", profondita: "+str(format(self.__profondita,".2f"))+\
  42.                ", prezzo: "+str(format(self.__prezzo,".2f")) + " euro"

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

  1. import pickle
  2. import prodotto
  3.  
  4. def print_magazzino(m):
  5. 	for key in m:
  6. 		print("Codice prodotto: "+key+"\t"+str(m[key]))
  7.  
  8. def save_magazzino(m):
  9. 	namefile = input("Inserire il nome del file dove salvare il magazzino prodotti: ")
  10. 	output_file = open(namefile,'wb')
  11. 	pickle.dump(m, output_file)
  12. 	output_file.close()
  13.  
  14. def inserisci_prodotto():
  15. 	nome = input("\nInserire il nome del prodotto: ")
  16. 	altezza = float(input("Inserire l'altezza del prodotto: "))
  17. 	larghezza = float(input("Inserire la larghezza del prodotto: "))
  18. 	profondita = float(input("Inserire la profondita' del prodotto: "))
  19. 	prezzo = float(input("Inserire il prezzo del prodotto: "))
  20. 	p = prodotto.Prodotto(nome,altezza,larghezza,profondita,prezzo)
  21. 	return p
  22.  
  23. def main():
  24. 	m=dict()
  25. 	try:
  26. 		N = int(input("\nInserire il numero di prodotti per il magazzino: "))
  27. 		for i in range(N):
  28. 			codice = input("Inserire il codice del prodotto: ")
  29. 			m[codice] = inserisci_prodotto()
  30.  
  31. 		print_magazzino(m)
  32. 		save_magazzino(m)
  33.  
  34. 		N = int(input("\nInserire il numero di ricerche di prodotti per prezzo che intendi effettuare: "))
  35. 		for i in range(N):
  36. 			ei = float(input("Inserire l'estremo inferiore dell'intervallo di prezzo: "))
  37. 			es = float(input("Inserire l'estremo superiore dell'intervallo di prezzo: "))
  38. 			for codice in m:
  39. 				if (float(m[codice].get_prezzo())>=ei) and (float(m[codice].get_prezzo())<=es):
  40. 					print("Prodotto "+codice+" - "+str(m[codice]))
  41. 	except Exception as err:
  42. 		print(err)
  43. 		return(1)
  44.  
  45. 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. 

  1. class Veicolo:
  2.     def __init__(self, tipo):
  3.         self.__tipo = tipo
  4.  
  5.     def get_tipo(self):
  6.         return self.__tipo
  7.  
  8.     def set_tipo(self, tipo):
  9.         self.__tipo = tipo
  10.  
  11.     def __str__(self):
  12.         return "Tipo: " + self.__tipo
  13.  
  14.  
  15. class Auto(Veicolo):
  16.     def __init__(self, tipo, anno):
  17.         Veicolo.__init__(self, tipo)
  18.         self.__anno = anno
  19.  
  20.     def get_anno(self):
  21.         return self.__anno
  22.  
  23.     def set_anno(self, anno):
  24.         self.__anno = anno
  25.  
  26.     def __str__(self):
  27.         return Veicolo.__str__(self)+", Anno: " + str(self.__anno)
  28.  
  29.  
  30. class AutoElettrica(Auto):
  31.     def __init__(self, tipo, anno, autonomia):
  32.         Auto.__init__(self, tipo, anno)
  33.         self.__autonomia = autonomia
  34.  
  35.     def get_autonomia(self):
  36.         return self.__durata
  37.  
  38.     def set_autonomia(self, autonomia):
  39.         self.__autonomia = autonomia
  40.  
  41.     def __str__(self):
  42.         return Auto.__str__(self)+", Autonomia: "+ str(self.__autonomia) + " km"
  43.  
  44. class Moto(Veicolo):
  45.     def __init__(self, tipo, modello):
  46.         Veicolo.__init__(self, tipo)
  47.         self.__modello = modello
  48.  
  49.     def get_modello(self):
  50.         return self.__modello
  51.  
  52.     def set_modello(self, modello):
  53.         self.__modello = modello
  54.  
  55.     def __str__(self):
  56.         return Veicolo.__str__(self) + ", Modello: " + self.__modello

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

  1. import ereditarieta
  2.  
  3. def main():
  4.     v = ereditarieta.Veicolo("anfibio")
  5.     a = ereditarieta.Auto("terrestre", 2005)
  6.     ae = ereditarieta.AutoElettrica("terrestre", 2010, 300)
  7.     m = ereditarieta.Moto("terrestre", "Ducati")
  8.  
  9.     print(v)
  10.     print(a)
  11.     print(ae)
  12.     print(m)
  13.     print(a.get_anno())
  14.     ae.set_autonomia(400)
  15.     print(ae)
  16.  
  17. 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ù:

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

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

Codice Python 

  1. class Articolo:
  2.  
  3.     def __init__(self, titolo, autori, anno, tipo, ristampe):
  4.         self.__titolo = titolo
  5.         self.__autori = autori
  6.         self.__anno = anno
  7.         self.__tipo = tipo
  8.         self.__ristampe = ristampe
  9.  
  10.     def set_titolo(self, titolo):
  11.         self.__titolo = titolo
  12.  
  13.     def set_autori(self, autori):
  14.         self.__autori = autori
  15.  
  16.     def set_anno(self, anno):
  17.         self.__anno = anno
  18.  
  19.     def set_tipo(self, tipo):
  20.         self.__tipo = tipo
  21.  
  22.     def set_ristampe(self, ristampe):
  23.         self.__ristampe = ristampe
  24.  
  25.     def get_titolo(self):
  26.         return self.__titolo
  27.  
  28.     def get_autori(self):
  29.         return self.__autori
  30.  
  31.     def get_anno(self):
  32.         return self.__anno
  33.  
  34.     def get_tipo(self):
  35.         return self.__tipo
  36.  
  37.     def get_ristampe(self):
  38.         return self.__ristampe
  39.  
  40.     def __str__(self):
  41.  
  42.         lista_autori = self.__autori[0] + ", "
  43.         for i in range(1,len(self.__autori)):
  44.             lista_autori = lista_autori + self.__autori[i] + ", "
  45.  
  46.         return "Titolo: " + self.__titolo +\
  47.                ", Autori: " + lista_autori +\
  48.                "Anno: " + str(self.__anno) +\
  49.                ", Tipo: " + self.__tipo +\
  50.                ", N. Ristampe: " + str(self.__ristampe)

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

  1. from articolo import Articolo
  2. import pickle
  3.  
  4. ADD_ITEM = 1
  5. DELETE_ITEM = 2
  6. PRINT_ITEMS = 3
  7. SAVE = 4
  8. SEARCH = 5
  9. QUIT_CHOICE = 6
  10.  
  11.  
  12. def display_menu():
  13.     print()
  14.     print("MENU")
  15.     print("1) Inserire un nuovo articolo")
  16.     print("2) Eliminare un articolo dal catalogo")
  17.     print("3) Stampare a schermo tutti gli articoli in catalogo")
  18.     print("4) Salvare le informazioni degli articoli in memoria")
  19.     print("5) Cerca articoli per tipo")
  20.     print("6) Uscire dal programma")
  21.     print()
  22.  
  23. def ask_item_info():
  24.     try:
  25.         titolo = input("Inserire il titolo dell'articolo: ")
  26.  
  27.         autori = []
  28.         res = "s"
  29.         while res == "s" or res == "S":
  30.             autori.append(input("Inserire autore: "))
  31.             res = input("Vuoi inserire un ulteriore autore? [S/s = Si, N/n = No] ")
  32.  
  33.         anno = int(input("Inserire l'anno di pubblicazione: "))
  34.         tipo = input("Inserire il tipo (es. libro, rivista, ecc.): ")
  35.         ristampe = int(input("Inserire il numero di rispampe: "))
  36.  
  37.         c = Articolo(titolo, autori, anno, tipo, ristampe)
  38.         return c
  39.     except Exception as err:
  40.         print(err)
  41.         return 1
  42.  
  43. def main():
  44.     biblioteca = dict()
  45.  
  46.     choice = 0
  47.     while choice != QUIT_CHOICE:
  48.         display_menu()
  49.  
  50.         choice = int(input('Inserire la scelta: '))
  51.  
  52.         if choice == ADD_ITEM:
  53.             codice = input("Inserire il codice univoco dell' articolo: ")
  54.             if codice not in biblioteca:
  55.                 c = ask_item_info()
  56.                 if c!=1:
  57.                     biblioteca[codice] = c
  58.             else:
  59.                 print("Esiste gia' un articolo con questo codice univoco.")
  60.  
  61.         elif choice == DELETE_ITEM:
  62.             codice = input("Inserire il codice univoco dell'articolo da eliminare: ")
  63.             print()
  64.             if codice in biblioteca:
  65.                 del biblioteca[codice]
  66.                 print("L'articolo con codice "+codice+" e' stato eliminato.")
  67.             else:
  68.                 print("Articolo non trovato.")
  69.             print()
  70.  
  71.         elif choice == PRINT_ITEMS:
  72.             print()
  73.             if len(biblioteca)==0:
  74.                 print("Nessuna articolo presente")
  75.             else:
  76.                 for key in biblioteca:
  77.                     print("Codice: "+key+" - "+str(biblioteca[key]))
  78.                     print()
  79.  
  80.         elif choice == SAVE:
  81.             namefile = input("Inserire il nome del file dove memorizzare i dati degli articoli: ")
  82.             file = open(namefile,'wb')
  83.             pickle.dump(biblioteca, file)
  84.             file.close()
  85.  
  86.         elif choice == SEARCH:
  87.             tipo = input("Inserire il tipo di articoli richiesti: ")
  88.             empty = True
  89.             for key in biblioteca:
  90.                 if biblioteca[key].get_tipo() == tipo:
  91.                     print("Articolo " + key + ": " + str(biblioteca[key]))
  92.                     empty = False
  93.             if empty:
  94.                 print("Nessun articolo trovato.")
  95.  
  96.         elif choice!= QUIT_CHOICE:
  97.             print('Errore: scelta non valida')
  98.  
  99.  
  100. main()
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Risoluzione_Tracce_di_Esame_II_Modulo&oldid=600"