Risoluzione Tracce di Esame II Modulo: differenze tra le versioni

Versione delle 11:12, 28 lug 2017

Indice

1 Appello 27 Giugno 2017
2 Appello 26 Luglio 2017

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 25 30 Media voti: 27,5 Esame superato

Nominativo dipendente: Luigi Bianchi 17 17 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()
```

Risoluzione Tracce di Esame II Modulo: differenze tra le versioni

Versione delle 11:12, 28 lug 2017

Indice

Appello 27 Giugno 2017

Appello 26 Luglio 2017

Menu di navigazione

Strumenti personali

Namespace

Varianti

Visite

Azioni

Ricerca

Navigazione

Strumenti

Versione delle 11:12, 28 lug 2017 (visualizza sorgente) Profbevilacqua (Discussione \| contributi) (→‎Appello 26 Luglio 2017) ← Differenza precedente		Versione delle 11:12, 28 lug 2017 (visualizza sorgente) Profbevilacqua (Discussione \| contributi) (→‎Appello 26 Luglio 2017) Differenza successiva →
Riga 320:		Riga 320:

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