avviciniamoci al linguaggio python!

donato taddei su n.v.d.a., 01\02\2008, h. 14.27.

    scusi  chi avà  il messaggio doppio; la ragione è credo intuitiva:
stimolare l'interesse.
Giusto quanto si  diceva qualche giorno fa con Simone circa la necessità  di
contribuire allo sviluppo di nvda mi adesso ho anche  un terrario sulla mia
macchina.

Ed ora, un po' di pubblicità

Ciclicamente ogni tanto su uictech ritorna la richiesta di  nozioni di
programmazione e più di qualcuno ci ha provato: Giuseppe Di Grande, Fabio
Ferrero e il povero Andrea Roveretto ha messo pure su una lista
nv-programmare, normalmente quasi desertica.
I tentativi si sono finora arenati al massimo alla seconda lezione. Motivo:
la fatica è immane, manca una finalità condivisa.

Provo a cambiare formula:
voglio intraprendere un percorso di apprendimento, finalizzato a vedere come
è fatto dentro il giocattolo nvda, e penso di socializzare questo mio
apprendistato,  sperando  far venire voglia anche a qualcun altro, e questo
implica la socializzazione oltre che delle figuracce e delle incompiute
anche di nozioni di programmazione che come si sa sono relativamente
abbastanza indipendenti  dai linguaggi:
In questo quadro Il python  può essere utilizzato come falsarga  il tutto
finalizzato alla comprensione di come lavora nvda e questo implica anche la
comprensione di come lavora il sistema operativo col quale nvda interagisce.
C'è insomma spazio per ogni genere di spunti e di acquisizioni di interesse
della lista.

Mi sono quindi procurato  gli ingredienti:

il pitone si può prelevare dal sito di Activestate.com,
http://www.activestate.com/Store/?_x=1

da cui si può scaricare anche tcl e soprattutto perl, della cui versione per
windows activestate.com è mantentore ufficiale e personalmente ho avuto modo
di apprezzarne  la professionalità.
Il pitone contiene anche la documentazione completa nonchè tutte le
estensioni specifiche per windows.
Il link per il download (21 mega circa) dovrebbe essere:
http://www.activestate.com/store/download.aspx?prdGUID=b08b04e0-6872-4d9...

Nella prossima puntata ne faremo una piccola ricognizione pratica andando
cioè a scrivere le prime righe di codice, il più banale dei  programmi.
A prima vista il tutto mi è sembrato estremamente semplice ed accessibile e
deve essere così se, a dispetto del senso comune, un orbaccio agli antipodi
con quello ci ha fatto addirittura uno screen-reader.

Ma me ne sarei fatto molto poco poichè la documentazione oltre ad essere
sconfinata è pure in inglese.

Ma questo non può essere un alibi Infatti sul sito italiano di Python
http://www.python.it

c'è  una copiosa documentazione in lingua italiana, ivi compresa una serie
di guide per principianti anche completamente digiuni di programmazione.
La cosa più importante però è che sono stati tradotti i in italiano i
documenti principali e cioè la guida dell'utente o "user guide" e il
"technical reference" ovvero la documentazione di tutte le funzioni o più
terra terra di tutti i comandi che l'interprete python comprende.

Faccio un po una setacciata e comincio a proporvi qualche materiale
introduttivo.

Per chiudere il cerchio ho reperito il terzo ingrediente della frittata: il
codice sorgente di nvda.
Fino all'anno scorso lo distribuivano in un zip ma ora è cambiata la
politica, per permettere a più persone di lavorare insieme c'è un server
dedicato chepermette di mantenere l'allineamento del codice con tutte le
subversioni tipiche di un work in progresso o di un cantiere, qual'è
appunto un processo di sviluppo di un software.

Allora ho messo nei preferiti una versione a caso, quella di ieri, e da lì
partirò per una disamina ragionata di questo  codice.

http://svn.nvda-project.org/nvda/trunk/source/

Se questo procura il piccolo fastiddio di dover salvare uno per uno i vari
files contenenti il codice, ha però il grande vantaggio di indicare l'ordine
con cui sono stati sviluppati, sollevando quindi gli interessati dal
difficile lavorio di capire con che testa l'autore  ha scritto il suo
codice.
Per finire riporto, sempre tratta dal sito italiano di python, una
brevissima presentazione di questo linguaggio, che introduce anche spunti
sulla differenza tra linguaggi di programmazione coompilati e linguaggi
interpretati o di script.
Qui si racconta anche che il python è un linguaggio bello, facile e
intuitivo e, se è vero non si potà camuffare la pigrizia  con una presunta
difficoltà.
L'appello è a     quelli che sanno  tante cose, i cosiddetti smanettoni, che
quasi invidio perchè mi fanno sentire trogloinformatico, ma c'è posto
proprio per tutti, purchè interessati.
Mi aspetteei non dico calore, ma un minimo di interesse, compreso quesiti,
spunti e riflessioni inerenti ma anche, in senso più ampio,  ciò che
concerne la programmazione in generale.

Poichè però in questo percorsosono al tempo stesso docente e alunno di me
stesso, ovvero non voglio dare lezioni a nessuno, a questa prima puntata
teorica seguià la  cronaca di un esercizio pratico:
sulla scorta di una minima base introduttiva generale, attingibile dalla
documentazione del python e sulla base delle indicazioni di compilazione
contenute nel sito del progetto nvda, l'esercizio consiste nel fare amicizia
col compilatore python, riuscire a fargli compilare una sola riga di codice,
il solito "hello world" o "ciao mondo", con cui solitamente si assaggiano
assolutamente tutti i linguaggi di programmazione.

A presto
                        Don

introduzione a Python
Il linguaggio Python nasce ad Amsterdam nel 1989, dove il suo creatore Guido
Van Rossum lavorava come ricercatore. Nei suoi dieci anni di vita, si è
diffuso in tutto il mondo. In Italia, la "comunità Python" era veramente
ristretta. Nel 1999 l'Italia si è svegliata dal suo torpore e sembra che
l'interesse stia crescendo.

Python è innanzitutto un linguaggio di script pseudocompilato. Questo
significa che, similmente al Perl ed al Tcl/Tk, ogni programma sorgente deve
essere pseudocompilato da un interprete. L'interprete è un normale programma
che va installato sulla propria macchina, e si occuperà di interpretare il
codice sorgente e di eseguirlo. Quindi, diversamente dal C++, non abbiamo un
fase di compilazione - linking che trasforma il sorgente in eseguibile, ma
avremo a disposizione solo il sorgente che viene eseguito dall'interprete.

Il principale vantaggio di questo sistema è la portabilità: lo stesso
programma potrà girare su una piattaforma Linux, Mac o Windows purché vi sia
installato l'interprete.

Python è un linguaggio orientato agli oggetti. Supporta le classi,
l'ereditarietà e si caratterizza per il binding dinamico. Ragionando in
termini di C++ potremo dire che tutte le funzioni sono virtuali. La memoria
viene gestita automaticamente e non esistono specifici costruttori o
distruttori; inoltre esistono diversi costrutti per la gestione delle
eccezioni.

Un altro importante elemento per inquadrare Python è la facilità di
apprendimento. Chiunque nell'arco di un paio di giornate può imparare ad
usarlo e a scrivere le sue prime applicazioni. In questo ambito gioca un
ruolo fondamentale la struttura aperta del linguaggio, priva di
dichiarazioni ridondanti e estremamente simile ad un linguaggio parlato.
L'indentazione perde il suo ruolo inteso come stile di buona programmazione
per facilitare la lettura del codice, per diventare parte integrante della
programmazione che consente di suddividere il codice in blocchi logici.

Non so se sono riuscito nell'intento di farvi venire l'acquolina in bocca,
comunque vi consiglio di dare uno sguardo alla documentazione, sperando che
il passo successivo sia il download dell'intero package contenente
l'interprete.
***
adriano barbieri
Ciao Donato e tutti.
Inanzi tutto scusa il ritardo della risposta, ma in questi giorni sono stato
preso da molti impegni guardacaso riguardanti la tua proposta...
E ti dirò che ci sto ancora lavorando.
Non ti posso anticipare niente, ma riguarda proprio le Regex...
A proposito ecco una stringhina aggiornata per addomesticare la bimba come
la chiami tu (sorriso):

# Correzione pronuncia cc
Voce:
"[ ][cC]{2}|^[cC]{2}"
Voce in sostituzione:"
c c"

Quindi i centimetri cubici non li pronuncia più.
La stringa precedente, piu lunga e grezza aveva un bug, trovava troppe cose,
trovava le doppie c all'interno di una parola, ad esempio:
faccine diventava faciccìne.
Esilarante, no?
ma del resto più si apprende sulle regex e più si riesce a ottenere stringhe
più potenti e raffinate.
E il nostro dizionario è basato su di esse, ecco perché ho deciso di
approfondirne la conoscenza.
Il Regex supportato dal dizionario di Nvda si differenzia leggermente dalle
direttive del linguaggio standard, anche se non di molto.
Quindi, se leggi uiciechi e pc-ciechi, senz'altro prossimamente troverai una
sorpresina.

Per quanto riguarda invece la programmazione in Pyton devo confessare che mi
piacerebbe che tu approfondissi la questione, sappi che ho già installato
l'interprete, ma ho notato scarsa accessibilità alla shell IDLE (Python
GUI), non del tutto però, i menù sono accessibili, ma le finestre
necessitano di un po' di cursore Jaws, il paradosso è che Nvda non fa meglio
e addirittura i menù li vede come voce di menù 1, voce di menù2, eccetera.
Mi domando, visto che Nvda è stato scritto in Pyton, perché non hanno
incluso IDLE (Python GUI)? usano un altro screen reader o hanno un'altra
shell?
Quale Shell?
la vorrei anch'io!
Per quanto riguarda l'interprete diretto: Python (command line), nulla da
dire è carino, occorre rispettare le indentazioni del linguaggio però, sennò
si incavola e occorre reinserire tutte le righe di istruzioni.
Menomale che le tiene in buffer e quindi non occorre ridigitarle, ma è
sufficiente richiamare quelle corrette usando le frecce verticali e fare
invio fino alla linea nuova da digitare.
Le istruzioni indentate,solitamente sono precedute dal cursore composto da 3
puntini: "..." mentre il cursore di inizio input da 3 simboli maggiore:
">>>".
Interessante il link:
http://www.python.it/

Quì mi fermo e aspetto dritte da te, sempre se ancora interessato.
Tieni presente che a differenza di te, pratico di c+ eccetera, io
programmavo solo in basic c64 e Amiga basic, ma soprattutto Amos
Professional da cui ho avuto ai suoi tempi risultati strabilianti in
grafica, suoni, musica, eccetera.
Rimpiango questo stupendo interprete e il suo ottimo compilatore... (sig!)
Quindi cerca di essere magnanime, (sorriso).
donato taddei
Ciao Adriano;
Allora a naso Non mi sbagliavo l'altra volta:
mi sembrava troppo lunga anche se mi riservai di applicarmici.

Facciamo una cosa:
giro qui questo articolo.
Avrei dovuto  prima leggerlo per educazione ma non l'ho fatto e come vado
lentamente passerà ancora tempo.
Dunque te lo giro dalla documentazione  italiana di Python
www.python.it

sezione documentazione/arrticoli

                        Don

     Introduzione alle Espressioni Regolari
      Le espressioni regolari sono una funzionalità che permette di ottenere
      risultati stupefacenti attraverso la ricerca di corrispondenze di
testo
      (``pattern matching''). Il modulo re implementa la gestione efficiente
      delle espressioni regolari in stile Perl all'interno di Python.
      La prima cosa da fare è importare il modulo che le implementa:
>>> import re
Esso permette di "compilare" le nostre espressioni regolari in oggetti
      istanza, i cui metodi principali sono search e match.
      Tra l'altro a partire dalla versione 1.6 c'è un nuovo motore per le
      espressioni regolari: si tratta di SRE di F.Lundh, che comunque è
      compatibile all'indietro col vecchio motore (di cui si parla nel
Regular
      Expression HOWTO).
      Il nuovo motore permette le ricerche su stringhe Unicode oltre che su
      quelle tradizionali a 8 bit, questo crea delle complicazioni
aggiuntive
      che comunque eviterò, visto anche che attualmente sto usando Python
1.6.
      Si raccomanda in ogni caso di consultare la Library Reference, che
      fornisce l'interfaccia ufficiale.
      Sintassi delle Espressioni Regolari
      Come si costruisce un'espressione regolare?
      Le espressioni regolari operano sulle stringhe, e le stringhe più
semplici
      sono costituite da singoli caratteri. La maggior parte dei caratteri
      corrisponde semplicemente a se stessa, quindi a corrisponderà alla
stringa
      "a" (circa la discriminazione tra maiuscolo e minuscolo si veda la
sezione
      opzioni più avanti), stessa cosa per una stringa costituita da
caratteri
      ordinari, come a esempio spam.
      Alcuni caratteri assumono invece significati particolari e vengono
      chiamati metacaratteri. Laddove si voglia vengano interpretati come
      caratteri ordinari dovranno essere protetti. Eccone una lista
completa:
[ \ { | ( )  ^ $ ? + * .
I metacaratteri
      I metacaratteri costituiscono uno dei fondamenti della potenza delle
      espressioni regolari, da qui in avanti indicate come RE.
      Insiemi di caratteri specificati tramite [ e ]
      Un esempio:
[abc]
corrisponderà a uno qualsiasi dei caratteri tra [ e ], l'intervallo
      completo tra due caratteri può essere abbreviato usando -, quindi
      l'esempio sopra è equivalente a:
[a-c]
È anche possibile indicare un carattere esterno a un intervallo
      ("complementazione"), usando il metacarattere ^ (`caret'), per esempio
a
[^c]
corrisponderà qualunque carattere eccetto "c", ma a
[^]
corrisponder` semplicemente "^". Infatti eventuali metacaratteri
      compresi tra [ e ] verranno presi alla lettera, quindi
[]]
corrisponderà a "]".
      Le RE adiacenti vengono concatenate, per cui se A e B sono due
espressioni
      regolari, AB è un'espressione regolare. Se una stringa p corrisponde
ad A
      e un'altra stringa q a B, la stringa pq corrisponderà ad AB.
      Possiamo costruire insiemi di caratteri concatenando intervalli, a
esempio

[a-zA-Z]
corrisponderà a un qualunque carattere alfabetico (per problemi di
      localizzazione si veda la sezione opzioni).
      Il metacarattere \ e relativi problemi
      Intervalli come quello sopra possono essere specificati tramite
      particolari sequenze che corrispondono a classi di caratteri, eccone
      alcune:
        \d
        corrisponde a una qualsiasi cifra decimale; è equivalente a [0-9].
        \D
        corrisponde a un qualsiasi carattere che non sia una cifra; è
        equivalente a [0-9].
        \s
        corrisponde a uno spazio bianco; è equivalente a [ \t\n\r\f\v]. (Lo
        spazio bianco in testa è necessario! \t corrisponde a uno stop di
        tabulazione, \n a un `newline' ecc.).
        \S
        corrisponde a un qualsiasi carattere che non sia uno spazio bianco;
è
        equivalente a [^ \t\n\r\f\v].
        \w
        corrisponde a un qualsiasi carattere alfanumerico; equivale a:
        [a-zA-Z0-9_].
        \W
        corrisponde a un qualsiasi carattere non alfanumerico; equivale a:
        [â-zA-Z0-9_].
      (Questa trattazione è volutamente semplificata visto il carattere
      introduttivo. Si veda, qui e altrove, la Library Reference e il
Regular
      Expression HOWTO, tenendo conto che quest'ultimo si riferisce alla
      versione pre del motore).
      Oltre che a segnalare tali sequenze, `\' svolge la funzione di
proteggere
      (il noto `escape') caratteri speciali quali a es.`*', facendo sì che
      vengano interpretati come caratteri normali.
      Purtroppo questo può essere fonte di problemi; non si dimentichi
infatti
      che `\' è usato in Python quale carattere di escape nelle stringhe
      letterali!
      Vogliamo ad esempio una RE che corrisponda alla stringa "\index" che
      s'incontra in file sorgenti .tex . È necessario proteggere la barra
      obliqua inversa con una seconda barra, quindi si ottiene "
\\index",

che è
      la stringa che dev'essere passata a compile(). Per esprimerla come
stringa
      letterale tocca però proteggere nuovamente le barre oblique inverse,
per
      cui si ottiene un folle "\\\\index". Quindi per esprimere un `\'
letterale
      ne occorrono ben quattro.
      ("Letterale" in Python è un elemento di programma, una notazione per
      valori costanti di alcuni tipi built-in. Può essere un numero o una
      stringa, visto che i caratteri sono stringhe di lunghezza unitaria).
      Per evitare tale moltiplicazione delle barre oblique inverse, nei
pattern
      complessi si può usare la notazione raw per le stringhe. Prefissando a
una
      stringa letterale una r si otterrà che i caratteri speciali non
vengano
      gestiti in modi particolari. A esempio la nostra \index sarà scritta
come
      stringa raw r"
\\index"

      Altri metacaratteri
        .
        corrisponde a un qualsiasi carattere eccetto un newline. Affinché
        corrisponda anche a un newline bisogna abilitare l'opzione DOTALL,
si
        veda la sezione sulle opzioni.
        ^
        (`caret') corrisponde all'inizio della stringa, nel modo MULTILINE
        significa anche "subito dopo un newline". Inoltre serve per
specificare
        un intervallo di caratteri tramite "complemento", come riportato
sopra.
        $
        corrisponde alla fine della stringa, nel modo MULTILINE significa
anche
        "subito prima di un newline"; banana corrisponde sia a "banana" che
a
        "bananasplit", "bananarama" ecc. mentre banana$ corrisponde solo a
        "banana".
      Ripetizioni
      Devono naturalmente essere gestite anche le particolari corrispondenze
in
      cui tutta o parte della RE si ripetono.
      Il metacarattere `*' specifica che la RE che lo precede (può essere un
      singolo carattere, ma a esempio anche un intervallo [a-z]) può
ripetersi
      zero o più volte, quindi a esempio pip*o trova corrispondenza in "pio"
      (zero "p"), "pipo", "pippo", "pipppo" e così via.
      Simile è il comportamento di `+', che specifica che la RE che lo
precede
      può ripetersi una o più volte (attenzione a tale differenza!). Quindi
      pip+o troverà corrispondenza in "pipo", "pippo", "pipppo" e così via,
ma
      non in "pio" (al minimo una "p").
      Più ristretto è il comportamento di `?', che specifica che la RE che
lo
      precede può ripetersi zero o una volte. Quindi la nostra pip?o troverà
      corrispondenza solo in "pio" o "pipo".
      Resta il modificatore più complesso tra quelli dedicati alle
ripetizioni:
      {m,n}, con m e n interi decimali. Esso specifica che della RE che lo
      precede vanno ricercate un numero di corrispondenze compreso tra m e
n, il
      massimo possibile. n può essere omesso, in tal caso viene preso un
limite
      superiore talmente alto da poter essere considerato infinito agli
effetti
      pratici. A esempio ar{1,3}gh può corrispondere ad "argh", "arrgh" e
      "arrrgh", ma non ad "agh" o "arrrrgh".
      Si faccia attenzione a un aspetto: i modificatori `*', `+' e `{m,n}'
      cercheranno di far corrispondere il massimo numero di caratteri
possibile.

      Di `{m,n}' esiste una versione "minimalista", `{m,n}?' che specifica
la
      corrispondenza di un numero di RE sempre compreso tra m e n, ma questa
      volta il minimo possibile.
      Si noti che {0,} equivale a `*', {1,} a `+' e {0,1} è la stessa cosa
di
      `?'. Il loro uso è semplicemente una questione di concisione e
facilità di
      lettura.
      Come viene effettuato il confronto
      Riportando un esempio del Regular Expression HOWTO, cerchiamo di
fornire
      una spiegazione pratica del funzionamento del "motore di confronto"
      (``matching engine'').
      Prendiamo l'espressione a[bcd]*b. Corrisponde alle stringhe costituite
da
      "a", zero o più caratteri compresi in [bcd] e che terminano con una
"b".
      Ora immaginiamo di confrontare tale RE con la stringa "abcbd".
            PassoConfrontoSpiegazione
            1aLa a presente in testa alla RE corrisponde.
            2abcbdIl motore cerca il massimo numero di corrispondenze di
[bcd]*,
            arrivando quindi alla fine della stringa.
            3Fallimento!Il motore cerca di trovare corrispondenza a b, ma la
            posizione attuale è alla fine della stringa, quindi fallisce.
            4abcbTorna indietro, in modo da far corrispondere a [bcd]* un
            carattere in meno.
            5Fallimento!Tenta di nuovo con b, ma la posizione attuale è
            all'ultimo carattere della stringa, che è una "d".
            6abcDi nuovo indietro, adesso [bcd]* viene fatto corrispondere
            solamente a "bc".
            6abcbOra la b in coda alla RE trova corrispondenza nel carattere
            corrente, il penultimo, quindi il confronto ha successo.

      Il risultato dell'operazione di confronto è "abcb". In pratica il
motore
      ha cercato di trovare la corrispondenza più estesa possibile,
arrivando
      più lontano possibile all'inizio e poi arretrando e riprovando con
sezioni
      più piccole. Nel caso si fosse trovato a fallire il confronto con zero
      occorrenze di caratteri compresi in [bcd] (visto l'uso di `*'),
avrebbe
      concluso che non c'è corrispondenza con la RE.
      Nella prossima parte ci occuperemo della compilazione delle nostre RE
e
      dei metodi degli oggetti ottenuti.

***
adriano barbieri
Ciao Donato e tutti.
Al momento finchè non penseranno di implementare una casella di controllo
che permetta di disattivare/attivare l'elaborazione deidizionari..
Io magari metterei una casella combinata che rapidamente consentirebbe di
scegliere il dizionario di default, quello specifico per la voce, entrambi,
oppure nessuna elaborazione.
Metterei addirittura un menù di contesto apribile direttamente dall'iconcina
nel system tray.
Per ora bisogna arrangiarsi con qualche acrocco, ad esempio:

1. Se si dispone di altre sintesi vocali installate si può selezionarne
un'altra che di conseguenza userà un altro file dizionario, che ovviamente
non avrà alcun filtro sulla punteggiatura al suo interno.
Occorre però evitare di inserire tali filtri nel dizionario generale,
altrimenti non servirebbe a nulla visto che ha la priorità.

2. Se proprio desideri invece usare la bimba preferita, potresti fare una
copia del file dizionario specifico della voce.
I dizionari si trovano nella cartella di installazione di Nvda, nella
sottocartella: "userdicts".
Conviene creare un paio di cartelle ognuna con nome univoco in modo da
contenere rispettivamente una singola copia del dizionario, ma solo una sarà
priva dei filtri caratteri da zittire.
All'occorrenza basterà copiare e sovrascrivere il terzo file correntemente
in uso presente nella cartella: "userdicts".
a seconda dell'esigenza del momento, alla fine dell'utilizzo basterà
risovrascrivere il file in: "userdicts" nuovamente col dizionario completo.
Più difficile a dire che da fare.
Non scordarsi mai di aggiornare le copie nel caso si aggiunga dei nuovi
vocaboli.
Un'altra cosa che manca al modulo dizionario è l'ordinamento dei vocaboli.
Ogni volta che se ne aggiungono, questi vengono accoddati a quelli
esistenti.
Io però mi sono fatto un collegamento sul desktop che mi apre il dizionario
col Blocco note, e mi diverto a ordinare per categoria le varie linee, ecco
anche spiegato il motivo delle note descrittive... cerco di raggruppare
quelle in comune in modo di averle rapidamente sotto orecchio, (sorriso).