Download Documentazione FAQ Aiutaci!!!

      #------ Chiamate condizionali "Corto-circuito" in Python -----#
      # Normale controllo di flusso basato sugli statement.

      if <cond1>:   func1()
      elif <cond2>: func2()
      else:         func3()

      # Espressione "corto circuito" equivalente

      (<cond1> and func1()) or (<cond2> and func2()) or (func3())

      # Esempio di espressione "corto circuito" 
      >>> x = 3
      >>> def pr(s): return s
      >>> (x==1 and pr(´one´)) or (x==2 and pr(´two´)) or (pr(´other´))
      ´other´
      >>> x = 2
      >>> (x==1 and pr(´one´)) or (x==2 and pr(´two´)) or (pr(´other´))
      ´two´

      #--------- Lambda con la valutazione corto-circuito in Python -------#
      >>> pr = lambda s:s
      >>> namenum = lambda x: (x==1 and pr("uno")) \
      ...                  or (x==2 and pr("due")) \
      ...                  or (pr("altri"))
      >>> namenum(1)
      ´uno´
      >>> namenum(2)
      ´due´
      >>> namenum(3)
      ´altri´

    list = [ 2, 1, 2, -1, 2]
    def maggioredi0(x): return (x>0)
    filter(maggioredi0,list)

    list=[-2, -4, 4, 5, 6, 10] 
    def minoredi0(x): return (x<0)
    def plus2(x): return(x+2)
    map(plus2,(filter(minoredi0,list)))

    
    list=[-2, -4, 4, 5, 6, 10] 
    reduce(lambda n,m:n+m,list)

    
    list=[-2, -4, 4, 5, 6, 10] 
    def minoredi0(x): return (x<0)
    reduce(lambda n,m:n+m,filter(minoredi0,list))

Cicli funzionali in Python

Rimpiazzare i cicli è semplice quanto lo è stato rimpiazzare i blocchi condizionali. Il for puó essere direttamente tradotto in map(). Per la nostra esecuzione condizionale, abbiamo bisogno di semplificare i blocchi degli statement a singole chiamate di funzioni:

      for e in lst:  func(e)      # ciclo imperativo
      map(func,lst)               # ciclo funzionale basato su map

Occorre notare che una tecnica simile è disponibile per un approccio funzionale al flusso sequenziale dei programmmi. Cioè la programmazione imperativa consiste principalmente di statement che indicano "fai questo, poi fai quello, e poi fai quell'altra cosa". map() ci permette di fare questo con :

      # creiamo una funzione utility per l'esecuzione;
      do_it = lambda f: f()

      # siano f1, f2, f3 funzioni che svolgono un qualche compito
      map(do_it, [f1,f2,f3])    # applicazione di map sulle funzioni

In generale, il nostro programma principale puó essere interamente un´espressione `map()´ con una lista di funzioni da eseguire per completare il programma. Un´altra caratteristica comoda di una funzione di prima classe è che potete metterla in una lista. Tradurre il ´while´ è leggermente più complicato, ma è ancora possibile direttamente:

      
      # while imperativo
      while <cond>:
          <pre-suite>
          if <break_condition>:
              break
          else:
              <suite>

      # while realizzato in maniera funzionale
      def blocco_while():
          <pre-suite>
          if <break_condition>:
              return 1
          else:
              <suite>
          return 0

      while_PF = lambda: (<cond> and blocco_while()) or while_PF()
      while_PF()

La nostra traduzione di while richiede ancora un blocco_while() che può esso stesso contenere statement piuttosto che unicamente espressioni. Ma potremmo essere in grado di applicare ulteriori eliminazioni a quelle funzioni (per esempio facendo il corto-circuito di ´if/else´. Inoltre, è difficile che la <condizione> sia utile con i testi usuali, come ad esempio ´while myvar==7´, siccome il corpo del ciclo (per come è stato progettato) non può cambiare nessun valore di variabili (beh, le variabili globali potrebbero essere modificate in ´blocco_ciclo()´). Un modo per aggiungere una condizione più utile è permettere che il "blocco_while()" restituisca un valore più interessante, confronti tale valore per una condizione di terminazione. E´ conveniente illustrare un esempio concreto di eliminazione di statement:

      #---------- Ciclo funzionale di ´echo´ in Python ------------#
      # versione imperativa di "echo()"
      def echo_IMP():
          while 1:
              x = raw_input("IMP -- ")
              if x == ´quit´:
                  break
              else:
                  print x
      echo_IMP()

      # funzione di utilità per "identificare gli effetti-collaterali"

      def stampa_monadica(x):
          print x
          return x

      # versione funzionale di "echo()"
      echo_PF = lambda: stampa_monadica(raw_input("PF -- "))==´quit´ or echo_PF()
      echo_PF()

Quello che abbiamo svolto sopra è un esempio completo che comporta l'I/O da terminale, un ciclo e statement condizionali realizzato con un´espressione pura con ricorsione (infatti un oggetto funzione può essere passato ovunque se lo si vuole). Noi utilizziamo ancora la funzione ´stampa_monadica()´, ma questa funzione è completamente generale, e puo essere riusata in ogni espressione di un programma funzionale che potremmo creare successivamente. Notate che ogni espressione contenente ´stampa_monadica(x)´ valuta la stessa cosa come se avesse semplicemente contenuto ´x´. La programmazione funzionale ha la nozione di un "monade"[1] per una funzione che "non fa nulla, e ha un effetto collaterale nel processo".

Eliminazione degli effetti collaterali

Dopo tutto questo lavoro nel descrivere le caratteristiche funzionali di Python, qualche curioso potrebbe chiedersi: "Perché?". Tutte gli esempi visti possono essere realizzati in maniera imperativa, ma la programmazione funzionale porta a compimento l'eliminazione di effetti collaterali dovuti alle transizioni di stato tipiche del paradigma imperativo. Infatti una percentuale molto ampia degli errori nei programmi è dovuta al fatto che le variabili ottengono valori inaspettati durante l'esecuzione del programma. La programmazione funzionale scavalca questo problema semplicemente non assegnando completamente valori a variabili.

Facciamo un´ulteriore esempio, supponiamo di dover scrivere un programma che abbia come compito stampare una lista di coppie di numeri che sono essi stessi presi da due altre liste. Vediamo prima l'approccio imperativo, che potrebbe essere il seguente:

 # Cicli e sottocicli per il calcolo in maniera imperativa
      xs = (1,2,3,4)
      ys = (10,15,3,22)
      bigmuls = []
      # ...ulteriori linee...
      for x in xs:
          for y in ys:
              # ...ulteriori linee...
              if x*y > 25:
                  bigmuls.append((x,y))
                  # ...ulteriori linee...
      # ...ulteriori linee...
      print bigmuls

Questo programma è di dimensioni ridotte, percui è molto improbabile che ci sia qualcosa che vada per il verso sbagliato. E se il nostro compito fosse quello di includere questo pezzo di codice in un progetto più grande che faccia più cose? Beh, vediamo, infatti possiamo notare le sezioni commentate con "ulteriori linee" sono le porzioni di codice dove gli effetti collaterali probabilmente conducono a bachi. In ciascuno di questi punti le variabili ´xs´, ´ys´, ´bigmuls´, ´x´, ´y´ potrebbere acquisire valori inaspettati nel codice ipotetico abbreviato.

Inoltre, dopo che questo codice viene eseguito, tutte le variabili hanno valori che possono o non possono essere aspettati o voluti dal codice successivo. Ovviamente, l'incapsulazione in funzioni/istanze e l'attenzione allo scoping possono essere usati per salvaguardarvi contro questo tipo di errori. E potete sempre usare ´del' sulle vostre variabili quando avete finito di utilizzarle. Ma in pratica, i tipi di errori segnalati sono comuni.

Un approccio funzionale al nostro esempio elimina sia questi effetti collaterali che gli errori. Una possibile versione funzionale del codice imperativo visto sopra potrebbe essere:

 bigmuls = lambda xs,ys: filter(lambda (x,y):x*y > 25, combine(xs,ys))
      combine = lambda xs,ys: map(None, xs*len(ys), dupelms(ys,len(xs)))
      dupelms = lambda lst,n: reduce(lambda s,t:s+t, map(lambda l,n=n: [l]*n, lst))
      print bigmuls((1,2,3,4),(10,15,3,22))

In questo esempio colleghiamo il nostro oggetto funzione anonimo (´lambda´) a nomi, ma questo non è strettamente necessario. Potremo invece semplicemente includerla nelle definizioni, ma per ottenere una maggiore leggibilità procediamo in questo modo. Inoltre procedendo in questo modo otteniamo una funzione utile da avere, combine(), che produce una lista di tutte le coppie degli elementi presenti in due liste date in input. La funzione ´dupelms()´ fornisce più che altro supporto a combine. Anche se questo esempio funzionale è piu prolisso rispetto alla versione imperativa, una volta che ne considerate il riuso delle funzioni di supporto (dupelms e combine), il nuovo codice in ´bigmuls()´ esso stesso è minore che di quello della versione imperativa.

Il vantaggio reale in questo esempio funzionale è che nel codice nessuna variabile cambia il proprio valore, evitando così i possibili effetti collaterali non voluti, dovuti alle transizioni di stato mediante l'assegnamento classico.

Conclusioni

Queste note hanno dimostrato un semplice utilizzo della programmazione funzionale in Python, e che tale utilizzo puo´ permettere un miglioramento del codice, prevenendo errori tipici della programmazione imperativa. Queste note saranno successivamente ampliate al fine di includere esempi tipici di utilizzo di programmazione funzionale e problemi ben noti risolubili con essa.