Soprattutto ho rilevato una forte curiosità su MongoDB, un database non-relazionale verso il quale sembra prevalere un atteggiamento  di generale timidezza: “vorrei ma non oso”, insomma. Per quanto riguarda Flask direi che ormai, nel vasto firmamento dei micro web framework, è una stella che brilla di luce propria.

Per quanto riguarda le registrazioni video potete andare su YouTube o sulla pagina ufficiale di EuroPython (english track e italian track). Ammetto di essere più soddisfatto della versione inglese nella quale – complice anche l’esperienza italiana del giorno prima – credo di essere stato più sintetico ed efficace. Qui mi limito a proporvi le slide:

Ringraziamenti

Un immenso grazie ai ragazzi dello staff di EuroPython che veramente hanno fatto di tutto per rendere questa manifestazione un evento straordinario – e ci sono riusciti  (una settimana di talk su cinque tracce parallele, sprint, hands-on, corsi, cibo di ottima qualità e credo oltre 800 partecipanti).

Vi racconto un episodio giusto per darvi l’idea di quanto questi ragazzi, tutti volontari, si diano da fare e ci mettano passione vera. Nella sessione italiana ho ‘sforato’ (capita anche ai migliori, mi dicono!) e così mi son trovato a sorvolare su un certo numero di slide. Ebbene il mio talk manager e il suo assistente mi hanno proposto di loro iniziativa di tenere una sessione pomeridiana straordinaria per consentirmi di portare a termine la mia relazione. Non capita tutti i giorni, credetemi. Per mia fortuna gran parte delle persone che avevano assistito alla sessione mattutina sono poi tornate per quella del pomeriggio, altrimenti sai che figura!

Se siete pythonisti o vorreste diventarlo non perdetevi la prossima edizione di questo evento internazionale che, con tutta probabilità, si terrà di nuovo a Firenze l’anno prossimo.

Ho cominciato a lavorare alla traduzione autorizzata dell’ottimo The Little MongoDB Book di Karl Seguin. Ho scovato il libro di Karl mentre raccoglievo la documentazione per un nuovo progetto super-segreto (!) a cui sto lavorando. Lo ritengo un’ottima introduzione al mondo NoSQL in generale e naturalmente al fantastico MongoDB.

Il titolo italiano sarà Il Piccolo Libro di MongoDB. La traduzione prosegue costante ma a piccoli passi perché purtroppo o per fortuna di tempo libero ne ho poco. Al momento sono tradotti più o meno grossolanamente l’introduzione e il primo capitolo. Mi farebbe comodo un po’ di aiuto, in particolare per quanto riguarda la revisione del testo. Se qualcuno vuol dare una mano è il benvenuto: potete fare delle pull request direttamente su GitHub (metodo preferibile), oppure mandarmi le correzioni via mail. In cambio vi prometto una menzione d’onore e l’eterna gratitudine dei futuri cultori italiani di MongoDB!

A lavori ultimati rilascerò il Piccolo Libro di MongoDB nei formati PDF, ePub, .mobi e probabilmente HTML. Se avete commenti o suggerimenti in proposito fatemelo sapere!

Addentriamoci dunque nel mondo delle password e scopriamo come crearne di pratiche e sicure.

Come scoprire una password

Scoprire una password è davvero semplice. Esistono cinque metodi affidabili per raggiungere l’obiettivo:

1. Domandarla. E’ incredibile, ma il modo più usato per ottenere la password di qualcuno è domandargliela (spesso in cambio di qualcosa). Le persone dicono spesso la loro password a colleghi, amici e famigliari. In questo caso l’aver adottato password complicate non aiuta di certo.
2. Indovinarla. E’ il secondo metodo più usato per accedere a un account. E’ cosa nota che la maggior parte delle persone scelgono password facili da ricordare, e le più semplici sono proprio quelle che in qualche modo hanno a che fare con la persona obiettivo dell’attacco. Password come il vostro cognome, il nome di vostra moglie, il nome del gatto, la data di nascita sono molto frequenti. In questo caso l’unica, ovvia, soluzione è quella di scegliere password che non hanno relazione diretta con la persona.
3. Attacco a Forza Bruta. Molto semplice da realizzare. Un hacker tenta l’accesso usando password diverse volta per volta. Se la nostra password è “sun”, lui tenterà di entrare con “aaa, aab, aad … sul, sum, sun (TROVATA)“. L’unica cosa che blocca un attacco a forza bruta sono password di maggiore complessità e lunghezza (è proprio a causa di questo tipo di attacco che gli esperti IT le consigliano).
4. Attacco a Parole Comuni. Forma semplificata dell’attacco a forza bruta, nel quale l’hacker tenta di accedere ricorrendo a un elenco di parole molto usate. Invece di tentare combinazioni di lettere, l’hacker tenta di accedere con parole intere diverse di volta in volta, come per esempio “sum, summer, summit, sump, sun (TROVATA)“.
5. Attacco a Dizionario. Stesso principio dell’attacco a parole comuni, solo che questa volta l’hacker usa l’intero dizionario (ci sono circa 500.000 parole nella lingua inglese).

Quando la password è sicura?

Non puoi proteggerti contro attacchi del tipo “Domandarla” e “Indovinarla”, ma puoi proteggerti bene dalle altre forme di attacco. Un hacker di solito crea uno script automatico o un programma che svolge il lavoro al posto suo. Non ha alcuna intenzione di star seduto al computer tentando manualmente 500.000 parole per scoprire se una di quelle è la tua password.

Ne consegue che l’unità di misura della sicurezza diventa “quante password può tentare un programma per ogni unità di tempo (per esempio un secondo)?“. Il numero esatto non è determinabile, ma la maggior parte delle applicazioni non è in grado di gestire più di 100 accessi al secondo.

Ciò significa che per scoprire la password “sun” sono necessari:

• Forza bruta: 3 minuti
• Attacco a Parole Comuni: 3 minuti
• Attacco a Dizionario: 1 ora 20 minuti

Nota: ci sono 17.576 combinazioni di carattere possibili per “sun”. 3 lettere dell’alfabeto minuscolo = 26^3

__Quindi “sun” è una password davvero poco sicura, ma quanto tempo deve resistere una password affinché la si possa ritenere davvero sicura?

• una password che può essere scoperta in 1 minuto è fin troppo fragile
• 10 minuti – ancora troppo fragile
• 1 ora – non ancora abbastanza
• 1 giorno – cominciamo a ragionare. La probabilità che qualcuno lasci girare un programma per un giorno intero solo per accedere a un singolo account è modesta. Tuttavia non è impossibile.
• 1 mese – solo un hacker molto motivato ci proverebbe
• 1 anno – passiamo dal rischio reale al rischio teorico. La NASA o la CIA non potrebbero accettare un livello di sicurezza così basso. Il resto di noi, beh – non abbiamo il loro tipo di nemici e la nostra azienda non è certo così allettante.
• 10 anni – siamo ormai entrati nel campo della teoria pura
• Una vita: 100 anni – probabilmente questo è un limite accettabile per la maggior parte di noi. Chi si preoccuperebbe per una password che potrebbe resistere fin dopo la sua morte? E’ confortante pensare a una password che è “sicura per tutta la vita”

Analizziamo con attenzione il livello “100 anni”. Suona bene e ci fa sentire sicuri. C’è però la possibilità che un hacker sia particolarmente fortunato e trovi la password giusta dopo soli 15 anni di tentativi, invece di 100. Improbabile, ma può succedere.

Alziamo dunque la posta ancora una volta, puntando al massimo. Vogliamo una password che richieda 1.000 anni per essere scoperta– chiamiamolo livello “sicuro per sempre“. Dovrebbe essere abbastanza, no?

Creare password sicure e davvero utilizzabili

Ora che abbiamo coperto le basi diamo una occhiata a qualche esempio sul campo, cercando di capire quanto utilizzabile possiamo rendere una password pur mantenendola “sicura per sempre”.

Nota: gli esempi sottostanti sono tutti basati su una ipotesi di 100 tentativi di accesso al secondo. Viene riportato l’attacco più efficace per scardinare ogni password – forza bruta, parole comuni o attacco a dizionario.

Cominciamo dalla classica password di 6 caratteri

[table id=1 /]

In questo caso la complessità vince chiaramente. Usare una password con caratteri maiuscoli e minuscoli, numeri e simboli è molto sicuro. Usare una semplice parola come password è inutile.

Ciò significa forse che i colleghi dell’IT e i consulenti sulla sicurezza hanno ragione? No. Una password di 6 caratteri non funzionerà comunque. Nessuno è in grado di ricordare una password come “J4fS<2”, il che vuol dire che prima o poi verrà inevitabilmente trascritta su un post-it o altrove.

Se vogliamo password veramente utilizzabili dobbiamo approcciare il problema in modo diverso. Prima di tutto abbiamo bisogno di usare parole che possiamo ricordare, qualcosa di semplice che possiamo scrivere con facilità.

Come queste:

[table id=2 /]

Usare più di una parola per password aumenta significativamente il livello di sicurezza (da 3 minuti a 2 mesi). Tuttavia, usando 3 parole invece di 2 ci ritroviamo con una password estremamente sicura.

Sono necessari:

• 1.163.859 anni per scardinarla con un attacco a forza bruta
• 2.537 anni con un attacco a parole comuni
• 39.637.240 anni con un attacco a dizionario

E’ 10 volte più sicuro usare “this is fun” come password piuttosto che “J4fS<2”.

Se poi volete stare assurdamente al sicuro, scegliete parole poco usate per comporre la vostra password – qualcosa come:

[table id=4 /]

Una password sicura e al tempo stesso davvero utilizzabile non è una password complicata. E’ piuttosto una frase semplice composta da tre o più parole.

Non è solo questione di password

Una cosa è scegliere password sicure e utilizzabili. Un’altra è prevenire gli attacchi degli hacker. Si tratta di un obiettivo semplice da raggiungere. Per impedire che gli script automatici lavorino efficacemente è necessario:

1. Aggiungere una pausa tra i tentativi di accesso. 5 secondi tra un tentativo e l’altro sono sufficienti. E’ un lasso di tempo abbastanza breve perché non si noti (ci vogliono più di 5 secondi per rendersi conto di aver sbagliato la password e digitarne una nuova). Obbliga l’hacker a un solo tentativo ogni 5 secondi (invece che 100 tentativi al secondo).
2. Aggiungere una pausa di penalizzazione se qualcuno inserisce una password sbagliata più di – diciamo – 10 volte. Una penalità di 1 ora è sufficiente. Di nuovo, una azione di questo tipo disturba seriamente qualunque script o programma hacker.

Un hacker può scoprire la password “alpine fun” in solo due mesi se è in grado di attaccare il nostro server 100 volte al secondo. Tuttavia con la pausa di 5 secondi tra un tentativo e l’altro la stessa password può resistere all’attacco per 1.889 anni.

[table id=3 /]

Tieni a mente questi concetti la prossima volta che sei al lavoro su applicazioni web o stai discutendo di sicurezza delle password con i tuoi colleghi dell’IT. Le password possono essere allo stesso tempo sicure e facili da ricordare.

Attribuzione

Flessibilità e qualità prima di tutto

Inuit.css è pronto all’uso, se siete di corsa e non avete esigenze particolari potete usarlo così com’è. Quando serve è facile adattarlo al nostro progetto, soprattutto grazie all’alta qualità del codice sorgente, commentato molto bene. E’ proprio la cura che l’autore ha dedicato alla documentazione l’elemento chiave che ci consente di intervenire rapidamente, eliminando le parti superflue o ritoccando il codice ove necessario.

Qui sopra vedete uno snippet tratto dal foglio di stile originale. Notate come l’autore si sia preoccupato di fornire indicazioni su come organizzare la gerarchia dei font. Ben fatto!

La potenza è nulla senza controllo

Difficilmente Inuit.css prende l’iniziativa, preferisce lasciarla al designer. Prendiamo gli elementi base di HTML5 e CSS3. Inuit.css li supporta ma li isola in classi dedicate che useremo all’occorrenza.

La scelta del basso profilo è apprezzabile. Lascia il controllo nelle nostre mani, ma corre il rischio che – soprattutto al primo impatto – il framework sembri meno ricco rispetto ad altre soluzioni. In effetti non è sulla ricchezza che punta Inuit ma su flessibilità, estensibilità e… mobilità.

Tablet, smartphone e non solo

Il supporto per l’attributo @media consente a Inuit di ridefinire dinamicamente gran parte delle impostazioni in base al dispositivo (tablet, smartphone, stampante) che consuma la pagina. Il Grid System adottato deriva dal capostipite 960 Grid System (vedi in proposito l’articolo precedente), supporta matrici (grid) a 12 e 16 colonne e implementa un ingegnoso marchingegno che evita l’inserimento della classica class=end nell’ultima colonna.

A differenza della Tiny Fluid Grid vista la volta scrosa, Inuit è un Framework vero e proprio e supporta ben più della sola Grid. Sono presenti impostazioni predefinite e ben fatte per tutti gli elementi più comuni di una pagina HTML: header, paragrafi, liste numerate e non, tabelle, form, citazioni, link, immagini. Non manca una implementazione del Eric Meyer CSS Reset e il supporto per la modalità debug che rende visibile la grid sullo sfondo. Una occhiata alla pagina demo e soprattutto al suo sorgente è sufficiente per rendersi conto di quanti sono gli stili che Inuit.css ci mette a disposizione.

Giovani di belle speranze

Inuit è il nuovo arrivato, ha solo una ventina di giorni ed è in revisione continua. E’ giovane come il suo autore, il ventenne Harry Roberts (l’età non tragga in inganno, Harry è la mente che si cela dietro CSS Wizardry). Come tutti i giovani di belle speranze Inuit guarda al futuro e se ne frega allegramente del passato: supporta Internet Explorer a partire dalla versione 7 (update del 24.5: la release 1.5 introduce un supporto base per le grid in IE6).

Dovrà sgomitare un bel pò per conquistarsi uno spazio in una nicchia già affollata da una concorrenza agguerrita. Ha tutte le carte in regola per sfondare, prova ne è il fatto che a pochi giorni dal lancio qualche sito qui e là ha già cominciato ad adottarlo.

Se scegliete di usare Inuit nei vostri progetti fatemelo sapere. Chissà, potrebbero finire dritti dritti nella Web Gallery del sito ufficiale.

Il Grid Design e l’era dei CSS Framework

L’avvento dei CSS Framework si deve (principalmente) alla necessità di soddisfare l’esigenza di fluidità. Il capostipite, se non in ordine cronologico senz’altro per l’influenza che ha avuto, è il 960 Grid System. Altri prodotti famosi, per citarne solo un paio, sono Blueprint e Emastic. Questi framework hanno in comune l’obiettivo di velocizzare creazione, gestione e manutenzione dei fogli di stile ma se andiamo al nocciolo della questione ci accorgiamo che tutti si basano sul concetto chiave di Grid Design:

Una griglia tipografica è una struttura bidimensionale composta da una serie di guide verticali e orizzontali intersecanti (matrice) usata per organizzare il contenuto della pagina. La griglia offre una traccia sulla quale il designer può organizzare testo e immagini in maniera ordinata e razionale (Wikipedia)

Niente di nuovo, i tipografi hanno usato questa tecnica per secoli. Il Grid Design in declinazione web è fluido: le colonne (e gli spazi tra le colonne) che compongono la matrice sono capaci di adattarsi alla risoluzione dell schermo.

Gran parte dei CSS Framework non si limitano a implementare versioni più o meno sofisticate del Grid System ma offrono una serie di servizi aggiuntivi nel tentativo di risparmiare al designer i compiti più ripetitivi e tediosi. Non sempre ci riescono. Ogni sito ha esigenze specifiche e ogni designer abitudini consolidate. E’ difficile che una soluzione standard sia l’ideale per ogni esigenza. Spesso preferisco la via di mezzo: strumenti agili che consentono di portare a casa rapidamente il risultato senza aggiungere (molto) più del necessario.

In questa mini-serie di tre articoli prenderò in esame tre diverse soluzioni che implementano il Grid Design e che ci permettono di implementare, con diversi gradi di complessità (e numero di funzionalità), pagine web fluide.

Tiny Fluid Grid

Se non altro amerete questa soluzione a causa del suo design: il sito è oggettivamente splendido. E facile da usare. In effetti Tiny Fluid Grid non è un CSS Framework vero e proprio ma una semplice soluzione interattiva che vi consente, agendo su tre semplici regolazioni (numero di colonne, spazio tra le colonne e larghezza dell’area client), di configurare online la vostra CSS grid. Il pulsante Preview offre una anteprima (anch’essa interattiva) della grid. L’unica altra opzione disponibile è il Download. Otterrete un archivio compresso che contiene due files: il foglio di stile grid.css e un index.html che contiene un esempio d’uso della grid appena creata:

Una occhiata al foglio di stile ci consente di capire la struttura della grid

Una classe per ogni larghezza di colonna. Poiché larghezza e margini delle colonne sono espressi in percentuale la nostra grid si adatta alla risoluzione dello schermo, con i limiti imposti dagli attributi min-width e max-width. L’implementazione lato HTML è banale (tralascio le parti non rilevanti):

La nostra grid è contenuta in un div di classe “container”. Le colonne sono a loro volta dei div. Per ottenere più colonne nella stessa riga dobbiamo assicurarci che la somma dei numeri contenuti nel nome di ogni classe (grid_x) sia uguale al numero di colonne di cui è composta la grid. Nel nostro caso la seconda riga è composta da tre div grid_4 (4×3=12); la terza riga da due colonne: grid_3 e grid_9 (3+9=12). Semplice no? Naturalmente possiamo ritoccare il foglio di stile come vogliamo, adattandolo alle nostre esigenze.

Nel prossimo articolo della serie affronteremo un CSS Framework vero e proprio, anche questo snello e semplice da usare. Se ancora non l’avete fatto abbonatevi al feed RSS per non perdere la prossima puntata, oppure iscrivetevi alla mailing list (riquadro in alto a destra). Mi raccomando!

Può capitare che questo comportamento non sia quello desiderato. Oggi al lavoro ho implementato una funzionalità interessante: il download della versione PDF di una pagina web. Il pdf viene costruito dinamicamente nel momento stesso in cui il visitatore clicca un link. Questo accorgimento libera il webmaster dalla tediosa (e facilmente dimenticabile) necessità di rigenerare il pdf ad ogni minimo ritocco della pagina.

Volevo che cliccando sul link si avviasse automaticamente il download, così da ‘costringere’ l’utente a interagire col PDF in un secondo tempo rispetto all’esperienza di navigazione. Se scarichi un PDF è per stamparlo o consultarlo con calma o magari passarlo a un collega, no?

Costringere l’utente a usare il menu contestuale del browser (Salva link con nome..) non è certo la scelta ideale dal punto di vista dell’esperienza utente, tanto più che in questo caso il link non è statico e invoca codice JavaScript. Per ottenere il risultato desiderato dobbiamo inviare direttamente il file all’utente. [cci_asp theme=”standard”]Response.TransmitFile()[/cci_asp] è il metodo che invia il file dall’applicazione ASP.NET al client, ma prima dobbiamo preoccuparci di aggiungere un paio di header al nostro messaggio di output:

E’ importante fornire il ContentType corretto altrimenti il browser non sarà sempre in grado di gestire i contenuti del file. Internet Explorer per esempio offre l’opzione di aprire direttamente il file (verrà scaricato nella cache). Nel nostro caso se l’utente sceglie l’apertura diretta IE lancerà Acrobat Reader perché ContentType è application/pdf.

Altro accorgimento è la chiamata al metodo Path.GetFileName() in riga 7. Non sarebbe necessario se non fosse che taluni broswer arcaici e superati (ogni riferimento a IE è naturalmente voluto) non sono in grado di gestire intelligentemente il filename e, quando propongono il nome del file da salvare, riproducono l’intero path del file sul server. Questo comportamento tra l’altro è pericoloso perché espone l’intera struttura  del sito, dalla radice al folder che contiene la pagina, al visitatore.

Se la routine deve essere usata in un modulo e non direttamente in una pagina aspx ricordate di sostituire Response con HttpContect.Current.Response. Buon lavoro!

Come usare watermark.js

La libreria innesta il marchio nelle immagini marcate con la classe CSS “watermark”. Se il nome della classe non piace è possibile cambiarlo. Se il nostro watermark è in formato JPG la libreria aggiunge per noi un livello di trasparenza, altrimenti possiamo fornirle i più idonei formati PNG e GIF.

Prima di tutto inseriamo il riferimento allo script. E’ consigliabile inserirlo in fondo alla pagina, subito prima della chiusura del tag

body

Al caricamento della pagina chiamamo il metodo wmark.init

La variabile load agisce come un flag e serve a evitare che il codice venga eseguito ad ogni postback. Infine aggiorniamo i tag HTML delle immagini a cui vogliamo aggiungere il nostro watermark

E questo è tutto.

Sul sito ufficiale sono disponibili un paio di demo funzionanti. La seconda mostra un uso senz’altro originale della libreria: l’inserimento di Codici QR nelle immagini. Trattandosi di un progetto open source è possibile scaricare anche il codice sorgente di watermark.js.

Non tutto è oro quel che luccica

Essendo implementata lato client, la protezione delle immagini non è certo garantita al cento per cento. Dobbiamo decidere cosa è più importante, l’inviolabilità delle nostre immagini o la comodità di non doverle ritoccare prima di inviarle al server. Altro fattore da non trascurare è il calo di prestazioni. Il codice JavaScript deve caricare il watermark e inserirlo nell’immagine originale. Il tempo di caricamento potrebbe risentirne, soprattutto nel caso di pagine ricche di immagini.

Watermark.js è un progetto interessante e ingegnoso che va usato tenendo ben presente i suoi pregi e tutte le possibili controindicazioni.

Come è potuto succedere?

In fatto di localizzazione una pagina ASP.NET non è diversa da una normale applicazione WinForms. In assenza di indicazioni diverse il .NET Framework rappresenta le valute in base alle impostazioni internazionali del computer che lo ospita. Durante sviluppo e collaudo non abbiamo avuto problemi perché lavoravamo su server aziendali locali. Tuttavia il server di produzione è americano, ed è così che pubblicando il sito ci siamo regalati un bel cambiamento di valuta, il tutto senza toccare una linea di codice.

Restituisce €1.567,50 in Italia e $1,567.50 negli Stati Uniti. Probabilmente a questo punto vi starete dicendo due cose:

1. Ma perché hai pubblicato un sito in italiano, per un pubblico italiano, negli Stati Uniti?
2. Te lo dovevi aspettare, cosa volevi che succedesse? Qualunque sviluppatore con un minimo di esperienza sa queste cose.

A proposito del primo punto ci sarebbe da scrivere un articolo intero (e magari lo farò). Basti sapere per ora che, malgrado le apparenze, ci sono (anche) buone ragioni per pubblicare siti italiani all’estero. Sul secondo punto naturalmente avreste ragione. Il fatto è che, nel grande schema delle cose, sono proprio i piccoli dettagli quelli che possono sfuggire. Per fortuna porre rimedio è stato semplice e indolore. Vediamo.

E’ tutta questione di Culture

In ogni pagina ASP.NET è possibile impostare il valore delle proprietà Culture e UICulture. Culture determina l’output delle funzioni influenzate dalla cultura: date, numeri, valute, orari. UICulture istruisce la pagina su quali risorse culturali caricare.

Impostare Culture e UICulture per tutto il sito

Intervenendo direttamente nel file Web.Config possiamo dire a ASP.NET quale è la cultura da usare in tutto il sito. In questo modo non dovremo preoccuparci di intervenire su ogni in pagina.

Attenzione alle maiuscole. uiCulture va bene; uiculture non va bene. Non sprecate mezz’ora per una sciocchezza del genere, l’ho già fatto io per voi.

Impostare Culture e UICulture per una pagina

Per modificare Culture e UICulture di una singola pagina è necessario impostare i corrispondenti attributi della direttiva @ Page

Questa tecnica può naturalmente venire usata in abbinamento alla precedente anche se devo dire che non mi viene in mente un motivo, uno scenario valido in cui ciò potrebbe essere utile.

Adattare l’output alla lingua del browser

Per adattare la cultura al linguaggio del browser che visita la pagina basta impostare UICulture e Culture su auto (non l’ho testato personalmente). E’ anche possibile cambiare la cultura dinamicamente via codice. Se volete sapere come fare consultate la documentazione ufficiale.

Dimenticavo…

C’è un’altra cosuccia che non ha funzionato perfettamente al momento del debutto. Immaginate la sorpresa del cliente che, ordinando un prodotto da €499 + IVA, si è visto proporre l’addebito su carta di credito per €1 (uno) IVA inclusa. Ma questa è un’altra storia…

Attribuzione

Questo articolo è una traduzione autorizzata di Learn Python in 10 minutes. Ringrazio l’amico Stavros Korokithakis per il permesso di accordatomi.

Caratteristiche

Python è un linguaggio fortemente e dinamicamente tipizzato (i tipi dati esistono e sono necessari ma non è necessario dichiararli esplicitamente), case sensitive (var e VAR sono due variabili diverse) e object oriented (tutto in Python è un oggetto).

Come ottenere aiuto

L’interprete di Python fornisce già un valido sistema di aiuto. Per sapere come usare un oggetto basta digitare help(). Sono utili anche dir, che elenca gli attributi (metodi) disponibili per l’oggetto,  e .__doc__ che mostra la documentazione completa quando disponibile:

>>> help(5)
Help on int object:
(etc etc)

>>> dir(5)
['__abs__', '__add__', ...]

>>> abs.__doc__
'abs(number) -> number\n\nReturn the absolute value of the
argument.'

Sintassi

In Python *non ci sono terminatori di riga obbligatori e i blocchi sono specificati con l’ indentazione. Indenta per cominciare un blocco e rimuovi l’indentazione per concluderlo, tutto qui. Le istruzioni che richiedono un blocco indentato terminano con i due punti (:). I commenti cominciano col cancelletto (#) e sono a linea singola. Stringhe su più righe sono usate per i commenti multi linea. Le assegnazioni si compiono col simbolo di uguale (=). Per i test di uguaglianza si usa il doppo uguale (==). Puoi aumentare e diminuire un valore usando gli operatori += e -= seguiti dall’addendo. Ciò funziona con molti tipi di dati, stringhe incluse. Puoi assegnare e usare più variabili sulla stessa riga. Alcuni esempi:

>>> myvar = 3
>>> myvar += 2
>>> myvar
5

>>> myvar -= 1
>>> myvar
4

"""Questo è un commento su più righe.
Le righe seguenti vengono concatenate."""
>>> mystring = "Hello"
>>> mystring += " world."
>>> print mystring
Hello world.

# Il codice seguente scambia due variabili in una sola riga.
# Non ci sono errori di conversione di tipo perché
# i nuovi valori non vengono assegnati. Vengono creati
# nuovi oggetti ai quali le variabili fanno ora riferimento.
>>> myvar, mystring = mystring, myvar

Tipi di dati

Le strutture più significative in Python sono liste, tuple e dizionari. I Set sono integrati in Python a partire dalla versione 2.5 (per le versioni precedenti sono disponibili nella libreria sets). Le Liste sono simili ad array mono dimensionali ma è possibile creare liste che contengono altre liste. I dizionari sono array che contengono coppie di chiavi e valori (hash table) e le tuple sono oggetti immutabili mono dimensionali. In Python gli array possono essere di qualunque tipo, quindi puoi mischiare interi, stringhe, ecc nelle tue liste/dizionari e tuple. L’indice del primo oggetto in qualunque tipo di array è sempre zero. Gli indici negativi sono ammessi e contano a partire dalla fine dell’array, -1 indica l’ultimo elemento dell’array. Le variabili possono fare riferimento a funzioni.

>>> esempio = [1, ["un'altra", "lista"], ("una", "tupla")]
>>> mialista = ["Elemento 1", 2, 3.14]
>>> mialista[0] = "Ancora elemento 1"
>>> mialista[-1] = 3.15
>>> miodizionario = {"Key 1": "Valore 1", 2: 3, "pi": 3.14}
>>> miodizionario["pi"] = 3.15
>>> miatupla = (1, 2, 3)
>>> miafunzione = len
>>> print miafunzione(mialista)
3

Puoi ottenere un range di array usando i due punti (:). Non indicare l’indice iniziale del range sottintende il primo elemento; non indicare l’indice finale sottintende l’ultimo elemento. Indici negativi contano a partire dall’ultimo elemento (-1 è l’ultimo elemento dell’array). Quindi:

>>> mialista = ["Elemento 1", 2, 3.14]
>>> print mialista[:]
['Elemento 1', 2, 3.1400000000000001]

>>> print mialista[0:2]
['Elemento 1', 2]

>>> print mialista[-3:-1]
['Elemento 1', 2]

>>> print mialista[1:]
[2, 3.14]

Stringhe

Le stringhe in Python sono indicate *indifferentemente con la virgoletta singola (') o doppia (") ed è consentito usare una notazione all’interno di una stringa delimitata dall’altra ("Egli disse 'ciao'." è valida). Stringhe su più righe sono racchiuse in triple (o singole) virgolette ("""). Python *supporta Unicode, basta ricorrere alla sintassi u"Questa è una stringa unicode". Per inserire valori in una stringa usa l’operatore % (modulo) e una tupla. Ogni % viene sostituito da un elemento della tupla, da sinistra a destra, ed è consentito usare un dizionario per le sostituzioni.

>>> "Nome: %s\nNumero: %s\nStringa: %s" % (miaclasse.nome, 3, 3 * "-")
Nome: Poromenos
Numero: 3
Stringa: ---

strString = """Questa è
una stringa
multi riga."""

# ATTENZIONE: Nota la s finale in "%(key)s".
>>> print "Questo %(verbo)s un %(nome)s." % {"nome": "test", "verbo": "è"}
Questo è un test.

Controllo di flusso

Le istruzioni per il controllo di flusso sono if, for, e while. Non esiste il select; al suo posto si usa if. Il for si usa anche per enumerare i membri di una lista. Per ottenere un elenco di numeri si usa range(numero).

rangelist = range(10)
>>> print rangelist
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for number in rangelist:
    # Verifica se numer è uno dei
    # numeri nella tupla.
    if number in (3, 4, 7, 9):
        # "Break" termina un for senza
        # eseguire la clausola "else".
        break
    else:
        # "Continue" prosegue con l'iterazione successiva
        # del loop. Piuttosto inutile in questo caso,
        # visto che siamo all'ultima istruzione del loop.
        continue
else:
    # Questo "else" è opzionale ed è
    # eseguito solo se il loop non è stato interrotto
    # con "break".
    pass # Non fa nulla

if rangelist[1] == 2:
    print "Il secondo elemento (le liste sono 0-based) è 2"
elif rangelist[1] == 3:
    print "Il secondo elemento (le liste sono 0-based) è 3"
else:
    print "Non saprei"

while rangelist[1] == 1:
    pass

Funzioni

Le funzioni sono dichiarate con la la parola chiave def. Eventuali *argomenti opzionali vanno dichiarati dopo quelli obbligatori e devono avere un valore assegnato. Quando si chiamano funzioni passando *argomenti per nome è necessario passare anche il valore. Le funzioni possono restituire una tuple (lo spacchettamento delle tuple rende possibile la restituzione di *valori multipli). Le *lambda sono funzioni in linea. I parametri sono passati per riferimento, ma i tipi immutabili (tuple, interi, stringhe, ecc.) non possono essere modificati nella funzione. Questo succede perché viene passata solo la posizione in memoria dell’elemento, e assegnare un altro oggetto alla variabile comporta la perdita del riferimento all’oggetto precedente. Per esempio:

# Equivalente a def f(x): return x + 1
funzionevar = lambda x: x + 1
>>> print funzionevar(1)
2

# un_int e una_stringa sono opzionali, hanno valori di default
# da usare se non vengono passati (2 e "Una stringa", rispettivamente).
def passing_example(una_lista, un_int=2, una_stringa="Una stringa"):
    una_lista.append("Nuovo elemento")
    un_int = 4
    return una_lista, un_int, una_string

>>> mia_lista = [1, 2, 3]
>>> mio_int = 10
>>> print passing_example(mia_lista, mio_int)
([1, 2, 3, 'Nuovo elemento'], 4, "Una stringa")

>>> mia_lista
[1, 2, 3, 'Nuovo elemento']

>>> mio_int
10

Classi

Python supporta la ereditarietà multipla delle classi. Le variabili e i metodi privati vengono dichiarati per convezione (non è una regola del linguaggio) precedendoli con due underscore (_). Possiamo assegnare attributi (proprietà) arbitrari alle istanze di una classe. Un esempio:

class MiaClasse:
    comune = 10
    def __init__(self):
        self.miavariabile = 3
    def miafunzione(self, arg1, arg2):
        return self.miavariabile

# Creiamo una istanza della classe
>>> istanza = MiaClasse()
>>> istanza.miafunzione(1, 2)
3

# Questa variabile è condivisa da tutte le istanze
>>> istanza2 = MiaClasse()
>>> istanza.comune
10

>>> istanza2.comune
10

# Nota come qui usiamo il nome della classe
# invece dell'istanza.
>>> MiaClasse.common = 30
>>> instanza.common
30

>>> instanza2.common
30

# Questo non aggiornerà la variabile nella classe,
# invece assegnerà un nuovo oggetto alla variabile
# della prima istanza.
>>> istanza.common = 10
>>> istanza.common
10

>>> istanza2.common
30

>>> MiaClasse.common = 50

# Il valore non è cambiato perché "common"
# ora è una variabile dell'istanza.
>>> istanza.common
10

>>> istanza2.common
50

# Questa classe eredita da MiaClasse. L'ereditarietà
# multipla viene dichiarata così:
# class AltraClasse(MiaClasse1, MiaClasse2, MiaClasseN)
class AltraClasse(MiaClasse):
    # L'argomento "self" è passato automaticamente
    # e fa riferimento all'istanza della classe, quindi puoi impostare
    # variabili di istanza come sopra, ma dall'interno della classe.
    def __init__(self, arg1):
        self.miavariabile = 3
        print arg1

>>> istanza = AltraClasse("hello")
hello

>>> istanza.miafunzione(1, 2)
3

# Questa classe non ha un membro (proprietà) .test member, ma
# possiamo aggiungerne uno all'istanza quando vogliamo. Nota
# che .test sarà un membro della sola istanza.
>>> istanza.test = 10
>>> istanza.test
10

Eccezioni

Le eccezioni in Python sono gestite con dei blocchi try-except [nome_eccezione]:

def una_funzione():
    try:
        # Divisione per zero causa una eccezione
        10 / 0
    except ZeroDivisionError:
        print "Oops, errore."
    else:
        # Non c'è stata eccezione, possiamo proseguire.
        pass
    finally:
        # Questo codice viene eseguito quando il blocco
        # try..except è già eseguito e tutte le eccezioni
        # sono state gestite, anche se si verifica una nuova
        # eccezione direttamente nel blocco.
        print "Abbiamo finito."

>>> una_funzione()
Oops, errore.
Abbiamo finito.

Importare librerie

Le librerie esterne si importano con import [nomelibreria]. Puoi anche usare la forma [nomelibreria] import [nomefunzione] per importare singole funzioni. Ecco un esempio:

import random
from time import clock

randomint = random.randint(1, 100)

>>> print randomint
64

Input e Output

Python vanta una vasta gamma di librerie per gestire input/output di files. In questo esempio vediamo come serializzare (convertire strutture dati in stringhe) usando la libreria pickle:

import pickle
mialista = ["Questo", "è", 4, 13327]

# Apre il file C:\binary.dat in scrittura. La lettera r
# prima del nome file serve a evitare l'escaping
# del backslash.
miofile = file(r"C:\binary.dat", "w")

pickle.dump(mialista, miofile)
miofile.close()

miofile = file(r"C:\text.txt", "w")
miofile.write("Questa è una stringa di prova")
miofile.close()

miofile = file(r"C:\text.txt")

>>> print miofile.read()
'Questa è una stringa di prova'

miofile.close()

# Apre il file in lettura.
miofile = file(r"C:\binary.dat")
listadafile = pickle.load(miofile)
miofile.close()

>>> print listadafile
['Questo', 'è', 4, 13327]

Varie ed eventuali

I *test possono essere concatenati. 1 > a < 3 verifica che a sia minore di  3 e maggiore di 1. Puoi usare del per cancellare variabili o elementi di array. Le comprensioni di lista sono uno strumento potente per creare e manipolare le liste. Consistono in una espressione seguita da una clausola for seguita da zero o più clausole if. Quindi:

>>> lst1 = [1, 2, 3]
>>> lst2 = [3, 4, 5]
>>> print [x * y for x in lst1 for y in lst2]
[3, 4, 5, 6, 8, 10, 9, 12, 15]
>>> print [x for x in lst1 if 4 > x > 1]
[2, 3]

# Verifica se almeno un elemento ha una determinata
# caratteristica.
# "any" restituisce true se qualunque elemento nella
# lista è vero.
>>> any([i % 3 for i in [3, 3, 4, 4, 3]])
True
# Funziona perché 4 % 3 = 1, e 1 in Python è true,
# quindi any() restituisce True.

# Verifica quanto elemento hanno una determinata
# caratteristica.
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
2

>>> del lst1[0]
>>> print lst1
[2, 3]

>>> del lst1

Le variabili globali vengono dichiarate all’esterno delle funzioni senza dichiarazioni particolari, ma se desideri modificarle in una funzione devi dichiararle con la parola global all’inizio della funzione, altrimenti Python assegnerà quell’oggetto a una nuova variabile locale (presta attenzione, si tratta di un piccolo dettaglio che può metterti facilmente nei guai). Per esempio: numero = 5

def miafunz():
    # Questo stamperà 5.
    print numero

def altrafunz():
    # Questo solleva una eccezione perché la variabile
    # non è stata ancora assegnata. Python crea un
    # nuovo oggetto locale invece di accedere al globale
    print numero
    numero = 3

def ancorafunz():
    global numero
    # Questo cambierà il valore alla variabile globale
    numero = 3

Epilogo

Questa non intende essere una guida completa (e nemmeno parziale) a Python. Python ha una vasta gamma di librerie e molte, moltissime funzionalità che dovrai scoprire con altri mezzi, come Dive Into Python (tradotto in italiano) o l’eccellente Learning Python di Mark Lutz, libro che consiglio a chiunque voglia davvero imparare e capire Python.

Mi auguro di averti aiutato nella transizione verso Python. Lasciami un commento se pensi che ci sia qualcosa da migliorare o se c’é qualcos’altro che vorresti approfondire.

Sono @nicolaiarocci su Twitter.

Ecco una comoda routine che fa al caso nostro. Dopo averla eseguita vi troverete il database completamente vuoto, come se fosse stato appena creato.

Anche questa routine (come quella vista ieri che cancella le sole Stored Procedure) accede alla tabella di sistema sys.objects per reperire lo schema del database. Cambia però la tecnica di accesso alle informazioni. Invece di usare un cursore qui selezioniamo il primo record utile per poi inoltrarci in un ciclo di cancellazioni ripetute. Il ciclo termina quando non ci sono più record che soddisfano i parametri di ricerca. Per evitare problemi coi vincoli relazionali è importante cancellare prima le relazioni e solo dopo le tabelle.

Nota Bene

Probabilmente c’è una ottima ragione per cui non disponete dei diritti di cancellazione del database. Prima di lanciare questo codice chiedetevi almeno dieci volte se 1) state sul database giusto, 2) siete coscienti delle conseguenze di quel che state per fare e 3) disponete di un backup dei dati. In ogni caso se perdete dati preziosi non venite a lamentarvi dal sottoscritto! 😉

La tecnica è quella di sfruttare la tabella di sistema sys.objects che elenca tutti gli oggetti contenuti nel database. Le Stored Procedure hanno tutte type = ‘P’ per cui è facile individuarle. A questo punto ci sono due possibilità: memorizzarne i nomi in una tabella temporanea per poi lanciare un loop che le cancelli una per una, oppure usare un cursore ed eseguire le cancellazioni con la funzione EXEC. La nostra routine usa il secondo approccio, senz’altro più performante.

Avidità

Il problema della avidità degli operatori regex diventa evidente quando si comincia a lavorare su ricerche avanzate. Un caso tipico è il parsing di file XML o HTML.

<p>questo è un <b>paragrafo</b></p>

Supponiamo di voler trovare tutti i tag usati.

<.*> # cerca tutti i tag

Il risultato della query non è quello che ci si potrebbe aspettare. L’operatore * è avido, ovvero cerca di catturare più caratteri possibili. Una volta trovato il primo < prosegue avidamente selezionando tutto fino all’ultimo >. In questo caso vogliamo che si fermi al primo >, non all’ultimo. E’ questa una distinzione importante, da comprendere a fondo. Possiamo disattivare il comportamento avido aggiungendo il carattere?

<.*?> # ora otteniamo quel che vogliamo (niente avidità)

Se desideriamo usare l’operatore + (1 o più) al posto del * (zero o più), la nostra query diventa <.+?>.

Confini

Nella seconda parte del nostro tutorial abbiamo convalidato un numero telefonico nel formato 555-12345678

555-\d{8}   # 555- seguito da 8 cifre

Anche se tecnicamente corretta questa query non è perfetta. Se la testiamo con queste stringhe:

testoDavanti 555-12345678
555-12345678 il mio telefono

scopriamo che vengono accettate perché la regola 555-\d{8} è ancora valida. In realtà noi desideriamo accettare il solo il numero telefonico, niente altro. La soluzione richiede l’uso degli operatori di confine:

^555-\d{8}$

I confini sono caratteri speciali perché non occupano spazio. Sono dei segnaposto che servono a delimitare il testo da cercare. Dopo l’inizio (^) deve esserci il nostro numero di telefono; prima della fine ($) deve esserci il nostro numero di telefono.

<th>
  significato
</th>

<td style="vertical-align: top;">
  Inizio del testo. Sfortunatamente gli inventori di regex hanno scelto lo stesso carattere usato per la negazione. E&#8217; importante riconoscerne il significato in base al contesto. Quando non è compreso tra [ e ] il carattere ^ è un confine e indica l&#8217;inizio del testo.
</td>

<td>
  fine del testo
</td>

Quindi

a   #  trova qualunque a
^a  #  trova solo il testo che comincia per a
a$  #  trova solo il testo che finisce per a

C’è un altro confine, quello di parola (\b). Vediamo un esempio. Vogliamo cercare le parole “for” e “she” nella nostra pagina di test.

(for|she)  # trova for e she

Non va male. Trova tutte le occorrenze di “she” e “for”, tuttavia viene selezionata anche la parola “before”. Non è il comportamento desiderato. Potremmo tentare cercando solo le occorrenze precedute e succedute da uno spazio.

[ ](for|she)[ ]  # cerca for o she

Va meglio. Non seleziona più before. Abbiamo però un nuovo problema. Nel testo c’è la frase “for she had plenty of time”. La nostra regex non ha individuato la parola “she” contenuta nella frase. Per quale motivo?

for she had plenty of time

Con il “for” iniziale abbiamo già rintracciato lo spazio che precede “she”, che quindi viene escluso. Sono queste le situazioni un cui un confine di parola può risolvere il problema.

\b(for|she)\b  # trova she oppure for

Il confine \b definisce dove la parola comincia e finisce, proprio come succede con i confini visti prima. Abbiamo detto prima che i “confini non occupano spazio”. Nell’esempio qui sopra cerchiamo esattamente “for” o “she”. Non cerchiamo la stringa \b e questa non occupa alcuno spazio durante la ricerca, a differenza di quel che è successo quando abbiamo tentato di usare la [cornice]. E’ un dettaglio importate perché con tutti gli altri operatori regex ciò che è nella query “occupa spazio” e non può essere trovato di nuovo.

Il Finale: Ricerca e Sostituzione

Ce l’hai fatta! Sei arrivato in fondo. Congratulazioni. Il meglio arriva ora. Ricerca e sostituzione è senz’altro il mio argomento preferito. Qui la pagina di test non ci può aiutare, occorre qualche tipo di editor oppure una IDE (Eclipse/Notepad++/Wordpad).

Supponiamo di avere un file composto da 100 righe come queste

31-01-10_backup32
24-01-10_backup1
24-02-10_backup_mona
11-03-09_backup_lisa

Vogliamo correggere le date portandole dal formato europeo a quello americano (da gg-mm-aa a mm-gg-aaaa).

\d{2}-\d{2}-\d{2}_backup.*  // trova le nostre righe

Per ogni riga desideriamo sostituire aree specifiche quindi ricorriamo all’operatore di raggruppamento già visto nella seconda parte di questa guida.

(\d{2})-(\d{2})-(\d{2})_backup(.*)  // ci siamo

A questo punto tutto quel che dobbiamo fare è sostituire le righe trovate con

{Gruppo2}–{Gruppo1}-20{Gruppo3}_backup{Gruppo4}

Il che si traduce nella seguente espressione di sostituzione

\2-\1-20\3_backup\4

Facile no? Niente più lavori ripetitivi. La mia regola è: se un testo richiede la modifica di più di cinque righe è giunta l’ora di ricorrere alle regex. Potrebbe sembrare una esagerazione. Eppure un programmatore dovrebbe rifiutarsi per principio di ripetere manualmente un lavoro che può essere automatizzato.

Buona fortuna.

Questo articolo è una traduzione autorizzata di Regex Primer: Part 3. Ringrazio l’autore per il permesso accordatomi.

Negazione [^]

Abbiamo già conosciuto la [cornice]. Una caratteristica importante di cui non abbiamo ancora parlato è la negazione. Supponiamo di voler cercare qualunque carattere eccetto la lettera a.

[^a] # trova b,c,d,e,f,\n .... qualunque carattere eccetto 'a'

La negazione si applica a tutti i caratteri della cornice in cui compare l’operatore ˆ. Non è possibile limitarla a solo alcuni.

[^0123456789] # trova qualunque carattere non numerico

Gli Alias

Ora siamo pronti per affrontare qualche esempio realistico di regular expression. Uno degli usi più frequenti delle regex è la convalida di Stringhe. Proviamo a verificare la correttezza di un ipotetico numero telefonico da esprimere nel formato 555-12345678. Di norma divideremmo l’input in due parti e proveremmo a convertirle in numeri. Ora tuttavia conosciamo le regex e possiamo sbrigarcela meglio.

555-[0-9]{7}

Fatto. Stiamo convalidando 555 seguito da un trattino seguito da 7 caratteri numerici. Possiamo essere addirittura più sintetici, vediamo come.

I range [0-9] e [a-z]  sono talmente frequenti da saltar fuori continuamente, tanto che sono state create scorciatoie (alias) dedicate ai range più usati. Nel nostro caso ci torna utile \d, che sta per digit (carattere numerico) ed è semanticamente identico a [0-9].

555-\d{7} # identico a 555-[0-9]{7}

Gli alias non sono certo indispensabili, puoi ottenere gli stessi risultati usando la cornice in modo esteso. Tuttavia sono molto comodi.

<th>
  significato
</th>

<th>
  coorrisponde a
</th>

<td>
  digit (numero)
</td>

<td>
  [0-9]
</td>

<td>
  word (parola)
</td>

<td>
  [a-zA-Z0-9_]  Include il carattere underscore
</td>

<td>
  spazio, tab o newline
</td>

<td>
  [ \t\r\n]
</td>

<td>
  qualsiasi non numerico
</td>

<td>
  ^\d
</td>

<td>
  quasiasi non alfanumerico
</td>

<td>
  ^\w
</td>

<td>
  quasiasi ma non lo spazio
</td>

<td>
  ^\s
</td>

Suggerimento: nota come ad ogni alias ne corrisponde uno dal significato opposto, tutto in maiuscolo. Impara i primi tre per conoscerli tutti e sei.

Il Punto

Il punto è un alias un pò speciale. Ne parlo soprattutto perchè può capitare di notarlo nel codice scritto da altri. Il punto cerca tutto eccetto il new line (\n). Il problema è che il carattere new line non è lo stesso su tutte le piattaforme.

.   # trova tutti i caratteri
.*  # equivalente a [^\n], trova tutti i paragrafi

Il punto spesso crea confusione. Consiglio di ricorrere a combinazioni di alias e cornici per ottenere gli stessi risultati senza rischiare errori.

Escaping

Capita a volte di dover cercare proprio il punto, oppure i caratteri [ o ]. Poiché fanno parte della sintassi regex in questi casi è necessario riccorrere all’escaping, ovvero precederli col carattere \ che rappresenta l’escape. Per esempio

\.    # cerca il punto invece che tutto quanto
\*    # trova tutti gli asterischi
\\    # trova tutti gli escape

Raggruppamenti e OR

Torniamo alla convalida. Questa volta vogliamo verificare la validità di un indirizzo email. Prima di tutto stabiliamo le regole (semplificate) a cui una stringa deve attenersi per venire convalidata come indirizzo email: 1) il nome utente può contenere lettere, numeri, underscore e trattini ma deve cominciare con una lettera; 2) il dominio può contenere solo lettere seguite da un punto seguito da altre lettere. Quindi domain.fakecom è valido per noi

[a-z][\w-]*@[a-z]+\.[a-z]+

Presta attenzione all’escaping del punto! Un’altro dettaglio importante è il quantificatore + che abbiamo visto nel primo articolo di questa serie. Nel dominio infatti vogliamo almeno una lettera, non zero o più.

Supponiamo ora di voler aggiornare le regole in modo da convalidare solo i domini più importanti. Il nostro indirizzo email deve finire con com oppure net. Non possiamo risolvere questo problema con quel che abbiamo imparato finora. La nostra query regex dovrà ricorrere a due nuovi concetti, l’operatore OR e i gruppi.

[a-z][\w-]*@[a-z]+\.(com|net)

Vediamo l’OR all’opera

com|net  #  trova com oppure net
a|b|c    # lo stesso di [abc].

L’aggiunta delle parentesi () si rende necessaria per chiarire che non vogliamo trovare tutte le occorrenze della parte di regex alla loro sinistra. Se volessimo “Brad Pitt” oppure “Angelina Pitt”

Brad|Angelina Pitt  # trova sia 'Brad' che 'Angelina Pitt'
(Brad|Angelina) Pitt  # ora ci siamo!

Per un programmatore il concetto del raggruppamento (grouping) con le parentesi dovrebbe essere facilmente comprensibile. Di fatto possiamo combinarlo con altri operatori che già conosciamo

(dog)+   #  trova dog,dogdog,dogdogdog ...
java(bean)?    #  trova java o javabean

Conclusione

Questo conclude la seconda parte della guida. La prossima e ultima parte verrà pubblicata tra qualche giorno. Nel frattempo raccomando di giocare con la pagina demo per fare un pò di pratica.

E’ ora disponibile anche la terza parte di questo tutorial.

Questo articolo è una traduzione autorizzata di Regex Primer: Part 2. Ringrazio l’autore per il permesso accordatomi.

1. Valide in ogni linguaggio e indipendenti dalla piattaforma, le regex sono un investimento sempre valido. Java, JavaScript, Ruby, .Net, Python… le regex non cambiano.
2. Rendono ricerca e sostituzione del testo enormemente più potenti
3. Soddisfano pienamente il principio 80/20. Basta conoscerne il 20% per risolvere l'80% dei problemi.

Ho preparato una pagina di prova per testare le regex del tutorial. In alternativa è sempre possibile usare una IDE, praticamente tutte supportano le regular expressions.

Partiamo dalla [cornice]

La regex più semplice? Eccola:

bank

La quale cerca “bank”. Cambiamola leggermente, immaginiamo di voler cercare sia “bank” che “tank” nello stesso blocco di testo.

[bt]ank  // cerca sia bank che tank

La [cornice] rappresenta comunque 1 carattere. Stiamo ancora cercando una parola di 4 caratteri, ma il primo può essere “b” oppure “t”. I caratteri inclusi nelle parentesi [] sono legati da una relazione di tipo OR. La loro posizione è irrilevante, [tb]ank è semanticamente identico. Ecco altri esempi d’uso della [cornice]:

[abc]1              // trova a1, b1 o c1
[cba]1              // trova a1, b1 o c1
file[0123456789]    // trova file0,file1,file2 ... o file9
file[0-9]           // trova file0,file1,file2 ... o file9
[a-z]               // trova a, b, c oppure ... z

Avrai notato che abbiamo introdotto un nuovo operatore. Usando il carattere - definiamo un range. Il range ci permette di evitare costrutti assurdamente lunghi come questo: [abcdefghijklmnopqrstuvwyz]. E’ una scorciatoia.

Proseguiamo coi Quantificatori

Riprendiamo dall’esempio iniziale. Immaginiamo di voler trovare tank, bank, tanks, e banks. Potremmo provare in questo modo:

[bt]anks?

Abbiamo aggiunto il quantificatore ? che agisce sul carattere che si trova direttamente alla sua sinistra. Significa una occorrenza oppure nessuna, quindi nel nostro caso stiamo dicendo “cerca [bt]ank con una ’s’ finale o meno”. Un quantificatore può essere affiancato a qualunque carattere e addirittura a una [cornice]. Dai una occhiata a questi esempi:

[bt]anks         // trova banks o tanks
[bt]anks?        // trova bank, tank, banks oppure tanks
[bt]?ank         // trova bank, tank oppure ank
ab?c?            // trova a, ab, abc oppure ac

Riassumendo, quando usiamo un carattere senza quantificatore indichiamo che ne cerchiamo una singola occorrenza. Quando aggiungiamo un quantificatore cambia il numero di occorrenze che vogliamo trovare. Nella tabella seguente trovi l’elenco dei quantificatori disponibili:

<th>
  significato
</th>

<th>
  regex
</th>

<th>
  esempio
</th>

<td>
  zero o 1
</td>

<td>
  abc?
</td>

<td>
  ab, abc
</td>

<td>
  zero o più
</td>

<td>
  abc*
</td>

<td>
  ab,abc,abcc,abccc,abcccc,… etc
</td>

<td>
  uno o più
</td>

<td>
  abc+
</td>

<td>
  abc,abcc,abccc,abcccc,…etc
</td>

<td>
  esattamente n volte
</td>

<td>
  abc{2}
</td>

<td>
  abcc
</td>

<td>
  da n a m volte
</td>

<td>
  abc{2,3}
</td>

<td>
  abcc,abccc
</td>

Concludendo

Abbiamo appreso la sintassi base che ci consente di fare un pò di pratica. E’ una buona idea fare quale esperimento in una IDE oppure sulla pagina demo.

La seconda parte di questa guida è ora pubblicata.

Questo articolo è una traduzione autorizzata di Regex Primer: Part 1. Ringrazio l’autore per il permesso accordatomi.

Ci sono poi certi sistemi di web mail (quello di Libero, per non far nomi) che semplicemente non sono capaci di riprodurre correttamente un link o se lo fanno non attivano il link per ragioni di sicurezza, lasciando così al destinatario della mail il compito di copiare e incollare l’intera URL nel browser. Operazione non sempre banale per l’utente medio, soprattutto quando (guarda caso!) il testo da copiare e incollare è lunghissimo.

Si potrebbe risolvere banalmente ricorrendo agli anchor tag HTML ma nel mio caso questa strada non è praticabile: i messaggi devono essere in puro testo. Non solo, questa soluzione non risolverebbe comunque il problema dei web mail client che non si fidano dei miei messaggi. Creare a priori URL brevi non è una opzione per ragioni di legacy (il sito non l’ho creato io!). Come fare allora?

Chiedere aiuto a un servizio URL Shortener

Gli URL shortener sono servizi molto usati in ambito social networking e non solo. Data una certa URL di qualunque lunghezza ne restituiscono una equivalente molto più breve. Pioniere in questo campo è stato TinyURL ma oggigiorno il servizio più diffuso e conosciuto è senz’altro Bit.ly, il quale ha l’indubbio vantaggio di offrire una REST API ricca, robusta e ben documentata. Questa libreria gratuita consente ai programmatori indipendenti (noi) l’implementazione di servizi di URL shortening nelle proprie applicazioni.

Ecco dunque ShortenUrl, una semplice funzione ASP.NET che restituisce una URL breve a partire da una URL di qualunque lunghezza passata come parametro. Nel caso la chiamata alla API fallisca la funzione restituirà semplicemente una stringa vuota.

La gran parte del lavoro è fatto da una sola linea di codice (ok, avrei potuto suddividerla in due o tre linee per amor di chiarezza, te lo concedo). La richiesta REST al servizio è eseguita da una istanza della classe HttpWebRequest. Il metodo Shorten può restituire risultati in formato JSON, XML o puro testo. Per semplicità ho scelto il formato testo. A seconda delle necessità potresti ricorrere al bellissimo formato JSON o al logorroico XML,  la documentazione ufficiale contiene esempi molto chiari anche per questi formati.

Se non disponi di un account Bit.ly dovrai registrarti (è gratis). Una volta creato l’account potrai recuperare facilmente la tua API Key personale, indispensabile per poter effettuare chiamate ai metodi della libreria.