Risoluzione Tracce di Esame II Modulo: differenze tra le versioni

Versione delle 12:36, 15 set 2017

Indice

1 Appello 27 Giugno 2017
2 Appello 26 Luglio 2017
3 Appello 7 Settembre 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 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:

x_punto1
y_punto1
z_punto1
x_punto2
...

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 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()
```

@@ Riga 691: / Riga 691: @@
 '''Codice Python'''
+<syntaxhighlight lang="python" line>
 class Campionato:

Risoluzione Tracce di Esame II Modulo: differenze tra le versioni

Versione delle 12:36, 15 set 2017

Indice

Appello 27 Giugno 2017

Appello 26 Luglio 2017

Appello 7 Settembre 2017

Menu di navigazione

Strumenti personali

Namespace

Varianti

Visite

Azioni

Ricerca

Navigazione

Strumenti