CENNI MINIMI DI PROGRAMMAZIONE FUNZIONALE IN PYTHON - V. 0.3

Transcript

1 CENNI MINIMI DI PROGRAMMAZIONE FUNZIONALE IN PYTHON - V. 0.3 MATTEO PRADELLA 1. Introduzione e concetti base La programmazione funzionale è uno stile di programmzione che enfatizza la valutazione di espressioni, piuttosto che l esecuzione di comandi. Le espressioni in questi linguaggi sono costruite per mezzo di applicazioni di funzioni che combinano valori di base. Un linguaggio funzionale supporta ed incoraggia la programmazione in stile funzionale. Esempio tipico di linguaggio con un approccio essenzialmente funzionale è il Lisp. Noi proveremo con Python. Per esempio, consideriamo il problema di calcolare la somma degli interi tra 1 e 10. In un linguaggio imperativo (es. il C) si può fare per mezzo di un ciclo e di una variabile che memorizza i risultati intermedi: int tot = 0; for (int i=1; i<=10; ++i) tot += i; In un linguaggio funzionale lo stesso programma viene espresso senza senza variabili e assegnamenti. Per esempio in Python in stile funzionale si può fare così: reduce(lambda a,b : a+b, range(1,11)) Occhio che Python non è di per se funzionale! Potevamo fare la stessa cosa in stile C: tot = 0 for i in range(1,11) : tot += i In breve, il paradigma funzionale è basato sui seguenti caposaldi: (1) La variabile riassume il suo significato matematico (non è più una cella di memoria); (2) i dati sono espressioni simboliche manipolate per mezzo di funzioni (funzioni pure, senza effetti collaterali); (3) i programmi sono le funzioni; (4) strumento fondamentale per la definizione delle funzioni: ricorsione; (5) assegnamento = male! Date: A.D. MMIII. 1

2 2 MATTEO PRADELLA Python permette di valutare una espressione simbolica per mezzo di eval. Per esempio eval("1+2") restituisce Le Liste: accesso e costruzione Ora introduciamo qualche funzione a-la Lisp sulle liste, che useremo come principali strutture dati. Per prima cosa definiamo atomo: servirà spesso come test per la chiusura di una ricorsione su liste Atomo. Un atomo è una lista vuota, oppure una non-lista. def atom (l) : return l == [] or not type(l) is list 2.2. Funzioni di accesso. Approccio stile Lisp per accesso alle liste: first restituisce il primo elemento di una lista, mentre last restituisce il resto della lista (una lista anch essa). Notate analogia con ricorsione: first - caso base, last - passo ricorsivo. Nota: Python fornisce funzioni di accesso a liste molto potenti, e ne permette la modifica degli elementi - non è quello che vogliamo fare! def first(l) : return l[0] def rest(l) : return l[1:] Se ci serve, possiamo usare direttamente l operatore di slice (es. a[2:5]) Costruttore. Useremo come costruttori di liste + e [ ]. Una nota culturale: il Lisp usa come costruttore l operatore cons, che può essere definito in Python in questo modo: def cons(e,l) : return [e]+l Cons è fondamentale in Lisp, perché le liste del Lisp sono implementate per mezzo di coppie. Per esempio, la lista [1, 2, 3] in Lisp viene implementata come (1, (2, (3, nil))) (in Python), dove nil è un valore speciale che denota la lista vuota. Inoltre in Lisp gli stessi programmi sono liste, dunque si possono manipolare in modo analogo ai dati. 3. Esempi 3.1. Esempio 1: implementazione di reverse. Vogliamo definire una funzione reverse che, data una lista, ne restituisca la versione rovesciata. Per esempio: reverse([1,2,3]) restituisce [3,2,1]. def reverse(l) : return l return (reverse(rest(l)) + [first(l)])

3 CENNI MINIMI DI PROGRAMMAZIONE FUNZIONALE IN PYTHON - V Esempio 2: appiattiamo una lista. Appiattiamo la nostra lista di liste! Es. flatten([[1],[2,[3]],[4]]) restituisce [1,2,3,4]. def flatten(l) : if l == []: return l el return [l] return flatten(first(l)) + flatten(rest(l)) 3.3. Esempio 3: calcolo profondità. Profond: restituisce la profondità di una lista. Es. profond([[1],[2,[3]],[4]]) restituisce 3. def profond(l) : return 0 return max(profond(first(l))+1,profond(rest(l))) 3.4. Esempio 4: l append del Lisp. La funzione append in Lisp ha lo stesso ruolo dell operatore + su liste in Python: append([1,2],[3,4]) restituisce [1,2,3,4]. Proviamo ad implementarla usando cons, dunque in stile Lisp: def append_lisp(x,y) : if x == [] : return y return append_lisp(reverse(rest(reverse(x))),\ cons(first(reverse(x)),y)) 4. Da iterazione a ricorsione Un approccio funzionale puro non fa uso dell iterazione: i cicli vengono espressi per mezzo di opportune funzioni ricorsive. In pratica gli strumenti necessari per scrivere un programma che segua il paradigma funzionale sono: il costrutto if-then-else, i confronti, liste e atomi e relative funzioni di accesso/costruttori, la definizione di funzioni (ricorsive). Come possiamo ottenere un analogo funzionale di codice iterativo? Facciamo un esempio di ciclo doppio: def pcart(a,b) : r = [] for a in A : for b in B : r += [[a,b]] In pratica abbiamo definito un prodotto cartesiano tra liste, per esempio:

4 4 MATTEO PRADELLA >>> pcart([1,2,3],[ a, b ]) [[1, a ], [1, b ], [2, a ], [2, b ], [3, a ], [3, b ]] Come fare lo stesso doppio ciclo adottando un approccio funzionale puro? Be, per esempio in questo modo: def ciclo_b(a,b) : if B == [] : return [] return [[a,first(b)]] + ciclo_b(a,rest(b)) def pcartf(a,b) : if A == [] : return [] return ciclo_b(first(a),b) + pcartf(rest(a),b) In pratica la funzione ciclo b ha il ruolo del ciclo for sulla lista B, mentre il ciclo esterno viene eseguito direttamente da pcartf. 5. Viceversa: da ricorsione a iterazione Una funzione ricorsiva è detta impropria (o tail-recursive) se restituisce immediatamente il risultato della sua chiamata ricorsiva, cioè non la usa come argomento di un altra funzione. Per esempio, si può costruire una versione ricorsiva impropria della reverse vista prima. Possiamo sfruttare un nuovo parametro per memorizzare i risultati intermedi del calcolo (lo chiamiamo r): def rev_tr(l, r=[]): ev_tr(rest(l),[first(l)]+r) In questo modo possiamo applicare la funzione più esterna (in questo caso +) rirettamente a r. Nota come il risultato di rev_tr(rest(l),[first(l)]+r) sia passato direttamente a return. Inoltre attenzione: r = [] in questo caso non è un assegnamento, ma la definizione di un valore di default per il parametro r. Dunque la struttura tipica di una funzione ricorsiva impropria è: def f(l, r=e) : if F(l) : return f(g(l),h(r))

5 CENNI MINIMI DI PROGRAMMAZIONE FUNZIONALE IN PYTHON - V Una funzione ricorsiva impropria è facilmente (e automaticamente) traducibile in una funzione iterativa. In effetti, molti compilatori per il linguaggio Lisp traducono automaticamente le ricorsioni improprie in iterazioni (che sono in genere più efficienti). Prendiamo come esempio la funzione f di prima - può essere tradotta in una versione iterativa in questo modo: def f_it(l) : temp = l r = e while not(f(l)) : temp0 = temp r0 = r temp = G(temp0) r = H(r0) Per fare un esempio reale, prendiamo rev tr: in quel caso, e = [] F (l) = atom(l), G(l) = rest(l), H(r) = [first(l)] + r. Dunque otteniamo: def rev_it(l) : temp = l r = [] while not(atom(temp)) : temp0 = temp r0 = r temp = rest(temp0) r = [first(temp0)] + r0 Nota: chiaramente questo codice non è più funzionale!