CONNETTERSI AL DATABASE CON PYTHON E MySQLdb

Con questa semplice guida, verrà introdotto come connettersi ad un database mysql con la libreria MySQLdb. Prima di tutto assicuratevi di aver installato nel proprio sistema python (nel caso di windows, al momento della stesura è necessaria la versione 2.5). Ora scarichiamo la libreria MySQdb, se si usa linux basta usare il gestore di pacchetti, se si usa windows la si può trovare qui mentre se usate un mac non dovete fare nulla. Per il database usiamo MySql che dovrà essere installato nella vostra macchina.
Definiamo una tabella semplicissima per l'esempio, dentro il database test inserendo nel da riga di comando di MySql le seguenti:

mysql> create database test;
mysql> use test;
mysql> create table persona (id int not null auto_increment primary key,nome varchar(50) not null,cognome varchar(50) not null);

bene ora abbiamo creato la nostra tabella nel database test.
Apriamo il nostro editor preferito e scriviamo il nostro script che andrà ad inserire un record nel database e leggerà i dati dentro la tabella persona:

import MySQLdb
#Creiamo la connessione
db = MySQLdb.connect (host="localhost", user="root", passwd="",db="tests")
#Otteniamo il cursore
c = db.cursor ()
#Effettuiamo la insert
c.execute ("INSERT INTO persona (nome,cognome) VALUES (\"Riccardo\",\"Degan\")")
#Eseguiamo la select
c.execute ("SELECT * FROM persona")
#Otteniamo tutte le tuple
result = c.fetchall ()
#Le stampiamo a video
for ris in result:
    print "NOME : %s COGNOME : %s \n" %(ris[1],ris[2])

Salviamo il file con un nome qualsiasi ed estensione .py. Apriamo una shell e ci spostiamo nella directory dove abbiamo salvato il file appena creato e digitiamo :
python nome_file.py
otterremo un output di questo tipo :

NOME : Riccardo COGNOME : Degan

Il modo per connettersi è davvero semplice e la cosa utile che python essendo interpretato è comodo per fare modifiche veloci e semplici!

This week in... ChromeExperiments

Seguendo alcuni webdesigner di fama internazionale su Twitter vengo a scoprire di giorno in giorno link sempre più interessanti e che mi allontanano sempre più facilmente dai miei doveri pubblici.

Oggi mi sono imbattuto in chromeexperiments.com, un sito che, come potrete intuire dal nome, propone uno spazio per tutti coloro che vogliono rendere pubblici i loro esperimenti con uno dei motori javascript e HTML più veloci nel mercato. 

Gli esperimenti proposti sono davvero notevoli, e sfrutttano veramente appieno il motore V8 e Webkit, tanto che spesso se provati con altri browser risultano lentissimi.

Tra i più divertenti sicuramente quello che applica la gravità alla pagina di ricerca di google oppure quello che permettte di parlare direttamente attraverso il microfono e vedere in tempo reale la bocca che si muove... speciale

SickTimestamp

Secondo me non troverete questo screenshot da nessun'altra parte.
Soprattutto non troverete uno screenshot di una linuxbox con il timestamp avanti di 5 ore che ha fatto uno screenshot così.
Per ricordare che noi siamo sick, non nerd.

Download di pagine html in python

Con questo semplice script si può fare il download di una pagina html.
Lo script è scritto in python e funziona dalla riga di comando. Il funzionamento è molto semplice dalla shell scrivere: python nomefile.py http://pagina.html nomeFileDaSalvare lo script salva nella cartella corrente la pagina.
Lo script è il seguente:

import urllib;
import sys;
if len(sys.argv) < 2:
         print "Manca l'indirizzo della pagine e il nome del file...";
         exit(0);
if len(sys.argv) < 3:
         print "Manca il nome del file...";
        exit(0);
urllib.urlretrieve(sys.argv[1],sys.argv[2]);
print "Dowload della pagina : " + sys.argv[1] + " con il nome : " + sys.argv[2] + " completato";

Con le prime due righe indichiamo i due pacchetti che ci servono, urllib ci serve per fare il download e sys per leggere gli argomenti da riga di comando.

Questo controllo if len(sys.argv) verifica se nell'array degli argomenti (sys.args) sia specificato l'url della pagina da scaricare e il secondo controlla if len(sys.argv) verifica che sia anche il nome del file che verrà salvato nella cartella corrente. Nel caso mancasse un parametro viene visualizzato un messaggio di errore e viene terminato il programma.

Questa istruzione : urllib.urlretrieve(sys.argv[1],sys.argv[2]); è la più importante in quanto è quella che si preoccupa di scaricare e salvare la pagina.

Infine viene stampato un messaggio che avvisa che il download è terminato.

Con poche righe di codice abbiamo scritto uno script abbastanza potente, che se avessimo provato a scriverlo con un altro linguaggio come java o c++ sarebbe stato molto più prolisso.

Differenza tra Inheritance e Subtyping

Stanotte il nostro migliore amico Skep si è svegliato dal sonno a causa di un incubo terribile. Il sogno era dei peggiori: un gigantesco punto di domanda lo inseguiva e più Skep correva forte più il demone si avvicinava. Alla fine il nostro amico veniva raggiunto e il punto di domanda, con tono minaccioso, gli poneva una difficile questione: qual'è la differenza tra inheritance e subtyping?

Certo, il sogno non era dei più drammatici peruna persona normale, ma per un nerd della programmazione come Skep questa domanda è pressochè terrorizzante. Si vogliano indicare come li abbiamo chiamati o con la loro traduzione italiana, ovvero ereditarietà e sottotipaggio, questi due cardini della programmazione ad oggetti sono spesso, almeno nel linguaggio comune dei programmatori, usati come sinonimi o almeno come intercambiati senza creare uno scandalo internazionale. Se il vostro linguaggio di riferimento è Java, questo è assolutamente lecito in quanto questi due concetti sono strettamenete legati l'uno all'altro. Anche in C++ la situazione è simile, anche se come vedremo esiste una "via di fuga" che permette di analizzarli separatamente. In ogni caso, come sicuramente saprete, noi Sickdevelopers non ci fermiamo mai alle apparenze e vogliamo capire perchè, per un concetto che SEMBRA simile, si usano due termini diversi.

Ragioniamo ora al di fuori di ogni linguaggio di programmazione specifico. Secondo la teoria dei linguaggi, i due termini hanno un significato ben diverso, che ora riassumo in queste due definizioni:

• Inheritance (ereditarietà): l'abilità di riutilizzare la definizione di un oggetto per definire un nuovo tipo.
• Subtyping (sottotipaggio): un oggetto B è sottotipo di un oggetto A se e solo se ogni qual volta sia richiesto un oggetto di tipo A si possa utilizzare un oggetto di tipo B senza causare un errore di tipo.

Già da queste due brevi definizioni si può intuire la differenza marcata tra i due: l'ereditarità riguarda l'implementazione, il subtyping riguarda le interfacce.

L'ereditarietà è un concetto strettamente legato al riuso del codice già scritto per creare nuovi tipi e alla facilità di manutenzione, in quanto cambiamenti a codice condiviso da più tipi comportano la modifica di una sola porzione di programma scritto. L'ereditarietà è fondamentalmente "inutile" da un punto di vista teorico ma drammaticamente indispensabile da un punto di vista pratico: potremmo pensare di eliminare questo concetto semplicemente duplicando il codice condiviso in ogni definizione di tipo. E' chiaro che una modifica importante a tale codice risulterebbe improponibile su larga scala in quant comporterebbe la modifica di ogni singola porzione duplicata.

Il subtyping concerne invece il rapporto che lega due tipi definiti in rapporto di parentela: esso lega le due classi in maniera inscindibile di modo che, come detto, un oggetto "figlio" possa essere usato al posto del "padre" ogni qual volta sia necessario il padre. E' questo che permette il polimorfismo nei linguaggi di programmazione ad oggetti con lookup dinamico. Teoricamente non è necessario che classi padre e figlio condividano lo stesso codice, piuttosto è importante la possibilità di scambio tra figlio e padre (chiaramente in una sola direzione).

Abbiamo visto i significati dei due termini, che sono profondamente diversi. Ma perchè allora essi vengono spesso fraintesi e utilizzati in maniera simile? La risposta è semplice: nei moderni linguaggi di programmazione possimo, come detto in precedenza, considerarli sostanzialmente uniti in una sola idea. Quest'unione è una scelta di design motlo importante che, sicuramente insieme ad altre altrettanto impoertanti, ha decretato il successo planetario di linguaggi come C++ prima e Java poi. Vediamo di analizzarli singolarmente, cominciando da quest'ultimo.

Il minestrone Java
Una volta tritale le verdure e bollite insieme risulta impossibile scinderle e mangiarle separatamente. Allo stesso modo, nel linguaggio oggi più diffuso, ereditarietà e subtyping sono legati in maniera inscindibile. Quando estendiamo una classe base, il suo sottotipo deve condividerne il codice già scritto, ereditandone i campi dati e i metodi, con la possibilità di ridefinizione. Quindi, perchè ci sia subtyping deve assolutamente esserci ereditarietà. E' valido anche il contratio, in quanto per riutilizzare il codice scritto per la definizione dei metodi di un oggetto è necessario definirne un sottotipo, altrimenti bisognerebbe riscriverne completamente le funzioni. I due concetti sono quindi assolutamente inseparabili, scelta teoricamente discutibile ma praticamente efficientissima nel 99.9% dei casi (sickStatistica assolutamente casuale, empirica [per i dati esatti chiedete a Skep]).

La pizza C++
In pizzeria, una pizza ordinata viene portata di default con il pomodoro. A tutti, bene o male, piace la pizza col pomodoro, ma alcune persone potrebbero esserne allergiche o addirittura potrebbe non piacere loro il pomodoro (sacrilegio!!). Supponiamo il subtyping come la pasta della pizza e l'ereditarietò come il pomodoro: è chiaro alla maggioranza come le due cose vadano a braccetto, ma per qualcuno potrebbe non essere piacevole a addirittura nocivo! Quello che sto cercando di dire con questo esempio culinario è che C++ permette subtyping senza ereditarietà, anceh se in forma minore. La scelta progettuale di Bjarne Stroustrup è stata di unire i due concetti in uno (con ottimi risultati), ma di mantenere una porticina aperta per una separazione. Esiste infatti l'ereditarietà privata che fa sì che un oggetto A sia sottotipo di un oggetto B senza che dall'esterno di A sia possibile accedere ai metodi ereditati da B, rendendo l'idea della parzialità della separazione. Insomma, in un mondo scritto in Java, qualcuno non mangerebbe la pizza.

Esistono inguaggi che separano i due concetti in maniera stretta, uno su tutti Smalltalk, sul quale onestamente non potrei dire niente di interessante.

Skep ora può tornare a dormire sonni tranquilli, almeno fino al prossimo incubo...

Prima di andarmene voglio lanciare una piccola sfida: qualcuno riuscirebbe a farmi un esempio sensato e possibilmente utile di ereditarietà privata?

Un Virus

grazie ai commenti qui

Destroy rpm packet