Elementi base di un linguaggio -  · Application Programming Interface (API) Struttura dati per...

Elementi base di un linguaggio

1. Dati numerici (3, 4, 1.41) e booleani (True, False)

2. Operatori aritmetici, in notazione prefix (add, sub, mul, truediv) o post-fix (+, -, *, /, //, %)

3. Operatori di confronto (>, >=, <, <=, ==, !=)

4. Operatori logici (and, or, not)

5. La definizione di procedure, eventualmente ricorsive, tramite le parole chiavi def e return ()

6. La procedura print()e il comando who

7. Le funzioni type() e help

8. La parola chiave yield

9. Le funzioni iter()e next()

Controllo del flusso di un blocco di codice

1. Espressioni condizionali:

if <predicato1>:

<block1>

elif <predicato2>:

<block2>

else:

<block3>

2. Cicli condizionali (blocco di codice ripetuto):

while <predicato>:

<block1>

# Per “rompere” il ciclo: break

3. Cicli iterativi su dati composti o generators (e.g., range). Un tipo di dato“iterabile” supporta le funzione iter()e next()

for <nome_variable> in <iterabile>:

<block1>

Concetti di Programmazione1. Valutazione di espressioni semplici e composte tramite

il ciclo read-evaluate-printa) Metodo di sostituzione: prima valuta gli argomenti e poi

sostituisci, chiamato “applicative-order evaluation”

b) Prima sostituisci le procedure e poi riduci, chiamato“normal-order evaluation”

2. Ricerca di un valore per (e.g., radice quadrata di x):a) Ricerca per enumerazione esaustiva

b) Ricerca per bisezione

c) Ricerca per approssimazioni successive (e.g., Newton)

3. Processi di calcolo:a) Processo ricorsivo lineare (e.g. Fattoriale)

b) Processo iterativo lineare (e.g. Fattoriale)

c) Processo con ricorsione ad albero (e.g. Fibonacci)

Errori Comuni 1/2• Errori di sintassi:

• Errori di mancata definizione di variabili:

Errori Comuni 2/2• Errori sul limite Massimo di chiamate ricorsive :

• ValueError: invalid literal for int() with base 10: '3.0'

• AttributeError: readonly attribute (z.real = 3)

• NameError: name 'x' is not defined (dopo del x)

• TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int‘

• TypeError: 'int' object is not iterable

• StopIteration: chiamata a next() su un iteratore vuoto

Handling Exceptions

Gli errori precedenti sono generate dal commando

raise ValueError(‘Vostro msg errore’)

E possono essere gestiti tramite i comanditry:

ChiamataFunzione()

except ValueError:

print(‘decidete voi cosa fare, ma no crash!’)

Plot di funzioni

Abbiamo definito dati composti usando gli elementi base del linguaggio con due esempi fondamentali:

1. I numeri razionali, definiti da numeratore e denominatori (esempio: 3/2)

2. Le pairslist, definiti come catena di coppie

Entrambi i tipi di dati sono definiti a partire dalle coppie(pairs) che sono in pratica tuple di lunghezza due.

Strutture dati composte (ricorsive)

1

v v v v

2 3

v v

4

v v

v v 2

3

Application Programming Interface (API)

Struttura dati per gestire una coppia di numeri

Abbiamo usato le coppie di Pythonv v 2

3

Struttura dati “Num. Razionale”: MakeQ, Num, Den

Definizione COSTRUTTORE E SELETTORI

def MakeQ(n, d):

def Num(x):

def Den(x):

Definizione delle procedure AddQ, SubQ, EqualQ,…

Definizione Funzioni aritmetiche per i numeri razionali

def Equal(x, y):

def AddQ(x):

def SubQ(x):

…

Programmi che usano i numeri razionali

Numeri razionali usati in una certa applicazione

Funzioni per creare un nuovo oggetto di “tipo” pairslist, ovvero i COSTRUTTORI:

def EmptyList():

return ‘EL’

def MakeList(x, y=EmptyList()):

return (x, y)

Funzioni per accedere ai dati base del dato composto pairslist, ovvero i SELETTORI:

Pairslist

def Head(As):

return As[0]

def Tail(As):

return As[1]

def Nth(As, i):

if IsEmptyList(As):

return As

if i == 0:

return Head(As)

return Nth(Tail(As), i-1)

def MakeRange(a, b):

def MakeI(n):

if n > b:

return EmptyList()

return MakeList(n, MakeI(n+1))

return MakeI(a)

Application Programming Interface (API)

Definizione di funzioni per “usare” le pairslist

Funzioni più comuni per sequenze di oggetti

def Equal(x, y):

def Append(x):

def Length(x):

…

Funzioni che individuano Pattern per le pairslist

Funzioni molto importanti

def Map(x, y):

def Filter(x):

def Reduce(x):

…

Programmi che usano le pairslist

Pairslist usate in programmi di “alto livello”

Supporto di base per struttura dati “PairsList”

Definizione COSTRUTTORE E SELETTORI

def MakeList(x,y):

def Head(As):

def Tail(As):

def EmptyList():

Nel definire le funzioni di base sulle pairslist, si possono notare degli schemiricorrenti (“pattern”) che ci permettono di definre tre procedure molto generali cheoperano su sequenze di oggetti:

Funzioni su Pairslist: pattern ricorrenti

def Map(F, As): # “F” è una funzione

if IsEmptyList(As):

return As

return MakeList(F(Head(As)), Map(F, Tail(As)))

def Filter(P, As): # “P” è un predicato

if IsEmptyList(As):

return As

if P(Head(As)):

return MakeList(Head(As), Filter(P, Tail(As)))

return Filter(P, Tail(As))

# Chiamata anche FoldRight

def ReduceR(Op, As, z): # “Op” è una funzione che prende due input

if IsEmptyList(As):

return z

return Op(Head(As), ReduceR(Op, Tail(As), z))

Abbiamo notato come molte delle funzioni della tabella precedente possano esseredefinite in termini della funzione “Fold”, e che la stessa può essere definita in due modi: ReduceRight(FoldRight) e ReduceLeft (FoldLeft)

Funzioni su Pairslist: pattern ricorrenti

(1+(2+(3+(4+(5+(6+(7+(8+(9+(10+(11+(12+(13+0)))))))))))))

Abbiamo notato come molte delle funzioni della tabella precedente possano esseredefinite in termini della funzione “Fold”, e che la stessa può essere definita in due modi: FoldRight e FoldLeft

Funzioni su Pairslist: pattern ricorrenti

(((((((((((((0+1)+2)+3)+4)+5)+6)+7)+8)+9)+10)+11)+12)+13)

Abbiamo un insieme di funzioni che ci permettono di utilizzare il dato composto“pairslist”, che generalizza il concetto di “sequenza di elementi”

Funzioni su Pairslist

Funzione Descrizione

Equal(As, Bs) Confronto elemento per element

Length(As) Lunghezza della lista

Append(As, Bs) Concatena Bs a As

Contains(As, value) Controlla se value è un elemento della lista

RemoveFirst(As,value) Rimuovi il primo elemento uguale a value

RemoveAll(As, value) Rimuovi tutti gli elementi uguale a value

Count(As, value) Conta il numero di volte che value appare in As

Min(As) Trova il minimo in As

Max(As) Trova il massimo in As

Sum(As) Calcola la somma di tutti gli elementi in As

Prod(As) Calcola la produttoria di tutti gli elementi in As

Reverse(As) Inverti la sequenza degli elementi nella lista As

MakeRandomInts(n,a,b) Crea una lista di n numeri pseudo-casuali interi in [a,b] uniforme

Confronto semantico Pairslist e list()

Pairslist List

Equal(As, Bs) “==“

Length(As) len(As)

Append(As, Bs) As.append() oppure As + Bs

Contains(As, value) value in As

RemoveFirst(As,value) Ls.remove(value)

RemoveAll(As, value) Esercizio, con filter

Count(As, value) As.count(value)

Min(As) min(As)

Max(As) max(As)

Sum(As) sum(As)

Prod(As) In termini di reduce

Reverse(As) reversed(As)

MakeRandomInts(n,a,b) Maniera analoga, user defined

MakeIntRange(a,b) range(As)

La possibilità di manipolare sequenze di elementi è un elemento di programmazione che in Python esiste una struttura dati:

list()

implementata direttamente nel linguaggio.

Oltre alle liste, abbiamo visto altri dati composti builtin :

1. tuple(), ovvero sequenze di oggetti (non modificabili)

2. str() , ovvero sequenze di caratteri (non modificabili)

3. dict() , ovvero insieme di coppie di dati (key, value), indicizzati dalla chiave

Abbiamo poi i tipi di dati “lazy”

1. iterator : vedi, ad esempio, range e enumerate

2. generator: funzioni che usano la parola chiave yield

Dati composti builtin in Python

Operazioni sulle stringhe

ATTENZIONE: Ricordarsi che le stringhe sono tipi di dati di sola lettura:

t = s.replace(‘\n’, ’’)

s = s.upper()

Operazioni sui dizionari

ATTENZIONE: I cicli for ciclano sulle chiavi del dizionario

D = {‘a’: 0, ‘b’: 2, ‘c’: 2}

for key in D:

print(key, D[key])

Containers, Generators, e Iterators

GENERATORS: https://docs.python.org/3/howto/functional.html#generators

ITERATORS: https://docs.python.org/3/howto/functional.html#iterators

LE TRE FUNZIONI PRINCIPALI CHE DOVETE RICORDARVI

map(F,Ls) filter(P,Ls)

reduce(F,Ls,v)

LE DUE REDUCE

ReduceRight(Ls,F,v)ReduceLeft(Ls,F,v)

La libreria itertools contiene la funzione:

reduce(Op, Ls, value)

Attenzione: è una ReduceLeft

LE TRE FUNZIONI PRINCIPALI CHE DOVETE RICORDARVI

Lettura di un file

# Esercizio: Lettura di un File di testo

def ParseFlowers(filename):

filehandle = open(filename, 'r', encoding="utf-8")

Rs = []

# Saltiamo la prima riga di intestazione

filehandle.readline()

# Il file handler è un “iterabile”

for line in filehandle:

row = line.replace('\n','').split(',')

Rs.append(Flower(row))

return Rs

Definizione di Classiclass <NomeNuovoTipo>(object):

def __init__(self, n):

self.<attributo1> = n

self.<attributo2> = ‘prova’

def __str__(self):

return “NuovoTipo ”+ self.<attributo2>

def __repr__(self): # pagina dopo per str vs. repr

return self.__str__()

def <metodo1>(self, b):

# esempio codice da eseguire…

return self.attributo1 + b

# Esempio di definizione oggetto

Obj = NomeNuovoTipo(3) # Costruttore

print(Obj.attributo1, Obj.attributo2) # Selettoriprint(Obj.metodi1(4)) # Metodi

IMPARATE A LEGGERE LA DOCUMENTAZIONE

https://docs.python.org/3/reference/datamodel.html

Algoritmi di Ordinamento (Sorting)

Abbiamo visto 5 diversi algoritmi di sorting:

1. Selection Sort2. Insertion Sort3. Merge Sort4. Quick Sort5. (Radix Sort) settimana prossima

Dovete essere in grado di implementare ciascun algoritmo di ordinamento sia utilizzando le PairsList che utilizzando le listebuilt-in in Python.

Funzioni già viste e usate

Funzioni da vedere a breve

https://docs.python.org/3.7/library/functions.html

Leggete la documentazione!

Documentazione con tutte le possibili ECCEZIONI:https://docs.python.org/3/library/exceptions.html

Documentazione con tutti i possibili METODI DI OVERLOADING:https://docs.python.org/3/reference/datamodel.html

Documentazione sulle CLASSI:https://docs.python.org/3.6/tutorial/classes.html

Documentazione sulle LISTE:https://docs.python.org/3/tutorial/datastructures.html

Svolgete i temi d’esame

Il sito del corso verrà aggiornato sino all’esame:

Come prepararsi per l’esame

Avete a disposizione il seguente materiale didattico:

1. 15 Notebooks, sia in HTML che il codice sorgente, con esercizi proposti

2. Diversi insiemi dei lucidi (slides in .pdf) di argomenti trattatisolo in parte nei notebooks

3. 8 Esercitazioni con soluzioni (da fare, e rifare, e rifare,…)4. Tutti i temi d’eame del 2018 con la soluzione5. Tutti i temi d’eame del 2019 senza soluzione6. Avete la documentazione online di Python (da leggere!)7. Avete accesso alla biblioteca per cercare libri da consultare

per approfondire eventualmnete degli argomenti

Come prepararsi per l’esame

Avete a disposizione il seguente materiale didattico:

1. 15 Notebooks, sia in HTML che il codice sorgente, con esercizi proposti

2. Diversi insiemi dei lucidi (slides in .pdf) di argomenti trattatisolo in parte nei notebooks

3. 8 Esercitazioni con soluzioni (da fare, e rifare, e rifare,…)4. Tutti i temi d’eame del 2018 con la soluzione5. Tutti i temi d’eame del 2019 senza soluzione6. Avete la documentazione online di Python (da leggere!)7. Avete accesso alla biblioteca per cercare libri da consultare

per approfondire eventualmnete degli argomenti

Programmare, programmare, e programmare

Soprattutto: Svolgete i temi d’esame!

Se avete dei dubbi sulle soluzioni, scrivetemi un email e chiedete ricevimento