La lezione 2 appena conclusa ha  il suo bel set di esercizi e anche un’esercitazione. Qui svolgo gli esercizi assegnati, per le esercitazioni terrò degli appunti a parte.

Ovviamente si comincia con delle domande di autoverifica che hanno lo scopo di “capire se hai capito”.

1) Che cos’è un “type”?

Un type o tipo è il modo con cui classifichiamo gli oggetti. È evidente come la tipologia di dati che verranno trattati, ad esempio: intero, float, stringa eccetera.

Definire il tipo di oggetto è importantissimo perché comprometterà come questo viene trattato nel codice. Spesso una svista riguardo il tipo di oggetto produce errori non sempre facili da individuare e risolvere.

2) Cos’è un’espressione?

Un’espressione è una composizione di oggetti operatori e oggetti operandi. Ad esempio 3 + y.

3 ed y sono operandi mentre “+” è un operatore.

3) Cos’è una conversione di tipo?

Alcuni tipi di oggetti possono essere convertiti in altri, con le dovute accortezze. Se converto l’intero 3 in float, ottengo 3.00. Ma se convertissi un float 3,99 in intero, otterrei 3. Questo comporta una perdita di informazione che va sicuramente tenuta di conto.

4) Cos’è una parola chiave?

Una parola chiave è una parola che ha un significato particolare per il compilatore. Quindi non può essere utilizzata a nostro piacimento. Ad esempio la parola “if” va usata nella sua forma di istruzione, con tutta la sintassi a corredo.

Spesso vengono chiamate parole riservate, e questo rende bene l’idea.

5) Qual è la differenza tra programmazione lineare e programmazione ramificata?

Un codice di tipo lineare viene eseguito istruzione dopo istruzione senza applicare decisioni o confronti. Ciò significa che, qualunque siano i dati passati, svolgerà sempre tutte le sue istruzioni.

Un codice ramificato invece, include il concetto di confronto/condizione/decisione dunque il software viene eseguito ma può prendere ramificazioni diverse eseguendo set di istruzioni solo in determinate circostanze.

Più difficile a scriverlo che a fare il disegnino!

6) Cos’è una condizione?

Una condizione è una verifica che si pone nel codice. Se l’esito di questa verifica o confronto è vera, viene eseguito un set di istruzioni, altrimenti un altro.

Problem Set 1: robe di carte di credito 🙂

Il Problem Set 1 serve per fare pratica sulle cose appena imparate, dunque diamoci da fare e via al codice!

Prima di mettere le mani sul codice è necessaria un’introduzione al mondo delle carte di credito, che dio che ne scampi! 🙂

Poniamo il caso che io faccia un acquisto di 5000 € con la mia carta di credito. Ho un tasso di interesse annuo del 18% e una rata da versare mensilmente per minimo il 2% del saldo.

Quello che è importante puntualizzare è che le società di credito guadagnano dall’interesse ed è quello che vorranno farsi pagare per primo, scalando poco dal saldo. Dunque facciamo un esempio numerico per trovarci:

PRIMO MESE

La rata minima da versare è del 2% del credito, dunque: .02 * 5000 € = 100€

In questa rata minima ci sarà una parte di interesse e una di capitale.

La parte di interesse è data da quel 18% di tasso annuale diviso per 12. Ci interessa infatti l’incidenza mensile. Questo tasso viene applicato al saldo, dunque: (.18/12) * 5000 € = 75 €

La parte di capitale che andremo a rimborsare è perciò data dalla rata minima – interesse: 100 € – 75 € = 25 €

Alla fine del primo mese dunque il saldo rimanente è di 5000 € – 25 € = 4975,00

SECONDO MESE

Rata minima = .02 * 4975 € = 99.50 €

Quota di interesse = (.18/12) * 4975 = 74.63 €

Quota di capitale = 99.50 € – 74.63 € = 24.87 €

Saldo rimanente = 4975 € – 24.87 € = 4950.13 €

È evidente allora che, se continuiamo questa iterazione per 12 mesi, avremo pagato un totale di 1167.55 € ma avremo ancora un saldo di 4708.10 €. Fa paura, vero?

Fortunatamente noi useremo la carta di credito solo per un esempio informatico 🙂 giusto?

Problema 1

Scrivere un programma che calcola il saldo della carta di credito dopo un anno di pagamenti se una persona si limita a versare solo la rata minima mensile.

Usare raw_input() per avere i seguenti dati dall’utente (ovviamente sono float):

  1. Il saldo attuale della carta
  2. Il tasso di interesse annuo
  3. L’importo minimo da pagare mensilmente

Per ogni mese, visualizzare l’importo della rata minima, il capitale restituito e il saldo. Tutti i valori vanno arrotondati al centesimo ovviamente.

Alla fine visualizzare l’importo pagato durante l’anno e il saldo.

E, dopo aver inserito i valori che seguono, avremo questo output:

Inserisci il saldo corrente: 4800
Inserisci il tasso annuo percentuale: 20
Inserisci il valore percentuale della rata minima: 2
Mese: 1
Rata minima da versare: 96.0
Capitale restituito: 16.0
Saldo: 4784.0
Mese: 2
Rata minima da versare: 95.68
Capitale restituito: 15.95
Saldo: 4768.05
Mese: 3
Rata minima da versare: 95.36
Capitale restituito: 15.89
Saldo: 4752.16
Mese: 4
Rata minima da versare: 95.04
Capitale restituito: 15.84
Saldo: 4736.32
Mese: 5
Rata minima da versare: 94.73
Capitale restituito: 15.79
Saldo: 4720.53
Mese: 6
Rata minima da versare: 94.41
Capitale restituito: 15.73
Saldo: 4704.8
Mese: 7
Rata minima da versare: 94.1
Capitale restituito: 15.69
Saldo: 4689.11
Mese: 8
Rata minima da versare: 93.78
Capitale restituito: 15.63
Saldo: 4673.48
Mese: 9
Rata minima da versare: 93.47
Capitale restituito: 15.58
Saldo: 4657.9
Mese: 10
Rata minima da versare: 93.16
Capitale restituito: 15.53
Saldo: 4642.37
Mese: 11
Rata minima da versare: 92.85
Capitale restituito: 15.48
Saldo: 4626.89
Mese: 12
Rata minima da versare: 92.54
Capitale restituito: 15.43
Saldo: 4611.46
Alla fine dell’anno hai pagato: 1131.12
e hai ancora un saldo scoperto di: 4611.46

E se, come è successo negli ultimi anni per il credit crunch, le banche alzassero la rata minima al 4%, le cose cambierebbero così:

Inserisci il saldo corrente: 4800
Inserisci il tasso annuo percentuale: 20
Inserisci il valore percentuale della rata minima: 4
Mese: 1
Rata minima da versare: 192.0
Capitale restituito: 112.0
Saldo: 4688.0
Mese: 2
Rata minima da versare: 187.52
Capitale restituito: 109.39
Saldo: 4578.61
Mese: 3
Rata minima da versare: 183.14
Capitale restituito: 106.83
Saldo: 4471.78
Mese: 4
Rata minima da versare: 178.87
Capitale restituito: 104.34
Saldo: 4367.44
Mese: 5
Rata minima da versare: 174.7
Capitale restituito: 101.91
Saldo: 4265.53
Mese: 6
Rata minima da versare: 170.62
Capitale restituito: 99.53
Saldo: 4166.0
Mese: 7
Rata minima da versare: 166.64
Capitale restituito: 97.21
Saldo: 4068.79
Mese: 8
Rata minima da versare: 162.75
Capitale restituito: 94.94
Saldo: 3973.85
Mese: 9
Rata minima da versare: 158.95
Capitale restituito: 92.72
Saldo: 3881.13
Mese: 10
Rata minima da versare: 155.25
Capitale restituito: 90.56
Saldo: 3790.57
Mese: 11
Rata minima da versare: 151.62
Capitale restituito: 88.44
Saldo: 3702.13
Mese: 12
Rata minima da versare: 148.09
Capitale restituito: 86.39
Saldo: 3615.74
Alla fine dell’anno hai pagato: 2030.15
e hai ancora un saldo scoperto di: 3615.74

Come si vede però, il codice proposto non è il massimo. È chiaro che stiamo ricavando le percentuali e la rata mensile ad ogni ciclo. Perchè? In fondo sono valori che possiamo trasformare direttamente dopo l’acquisizione e basta. Così:

Problema 2

Adesso ci viene richiesto di scrivere un programmino in grado di toglierci dalla morsa del debito in un anno. Cosa dovremmo pagare per eliminare il nostro debito in 12 mesi?

Ovviamente per questo esempio non consideriamo la rata minima da versare e immaginiamo di poter fare quello che ci pare.

Il problema richiede anche che la rata sia un multiplo di 10, quindi partendo proprio da 10€, proveremo ogni importo successivo fino ad estinguere il debito.

Problema 3

Chiaramente non è elegante cercare il valore della rata a 10€ per volta e ci lascia in effetti con un risultato abbastanza grezzo. Se volessimo essere più precisi? Se volessimo pagare precisamente in 12 mesi il nostro debito?

Bene, potremmo di sicuro provare ogni importo da zero in poi, incrementando di un centesimo ad ogni tentativo…ma quanto lavoro! Perfino il nostro PC suderebbe ad usare questo sistema per cifre ragguardevoli.

In questi casi si fa molto prima usando il metodo della bisezione. In pratica ipotizziamo un valore minimo e uno massimo, ad ogni iterazione dividiamo a metà e decidiamo da che parte proseguire con lo stesso sistema.

Quali saranno allora i nostri valori minimi e massimi? Il minimo è semplicemente una rata senza interessi, dunque il saldoIniziale/12.

Il massimo è invece l’ipotesi peggiore, quella in cui non restituiamo nulla fino all’ultimo mese e quindi ci piove tra capo e collo tutto l’interesse cumulato nei mesi.

Per calcolare l’ipotesi peggiore, cioè un anno di capitale e interessi da pagare tutti l’ultimo mese, usiamo la formula per il montante. In matematica finanziaria, il montante, indica la somma del capitale iniziale più gli interessi maturati nel tempo.

La formula per calcolare il Montante alla fine del 12esimo mese è la seguente:

\(M = C_0 (1+r)^n\)
Dove \(C_0\) è il capitale al tempo zero, cioè il capitale iniziale, \(r\) è il tasso di interesse mensile e \(n\) è il periodo interessato (12 mesi).

Ovviamente questa formula ci darà la somma totale che bisognerebbe pagare alla fine dell’anno, se dividiamo questo importo per 12 abbiamo la rata massima mensile.

Mi sono perso il mio codice e non mi va di riscriverlo, eccovi quello del prof: