Pycurl è un'interfaccia a libcurl, una libreria free per il trasferimento di file che supporta ftp, http, https, scp, telnet e molte altre. Supporta trasferimento di file come tunneling e altro.
Per usufrire di pycurl bisogna importare la libreria, supponiamo di lavorare da interprete:
>>>import pycurl
per creare poi un oggetto pycurl, la sintassi è:
>>>myCurl = pycurl.Curl()
Per recuperare poi informazioni relativamente ad un dato url:
>>>myCurl.setopt(pycurl.URL,"www.dominio_considerato.it")
a questo punto si possono recuperare le informazioni della pagina del sito con il metodo getinfo().
>>>myCurl.perform()
>>>myCurl.getinfo(pycurl.HTTP_HEAD)
200
Ci sono moltissime opzioni per recupero delle informazioni, esempio:
HTTP_HEADER
WRITEFUNCTION # scrive contenuto scaricato su file o buffer
FOLLOWLOCATION
MAXREDIRS
mercoledì 30 aprile 2008
martedì 29 aprile 2008
Lettura e Scrittura in un buffer di memoria - StringIO
Per velocizzare la scrittura e la lettura di informazioni su file, può essere usata la clase StringIO() che permette di utilizzare un buffer di memoria (in ram) come contenitore delle informazioni.
Questo approccio è molto usato per moli di dati enormi da gestire, per rendere più veloce il sistema evitando la scrittura su file e quindi allocazione di celle con puntatori ad esse.
L'uso è semplicissimo, la classe è dotata di tre metodi fondamentali:
write('stringa da scrivere nel buffer')
getvalue()
close()
Una semplice implementazione della classe, applicando i sui metodi può essere:
>>>from StringIO import StringIO
>>>myBuffer = StringIO()
>>>myBuffer.write("Ciao mondo!")
>>>print myBuffer.getvalue()
Ciao Mondo!
>>>myBuffer.write("Oggi c'è il sole!")
>>>print myBuffer.getvalue()
Ciao mondo! Oggi c'è il sole!
>>>myBuffer.close()
Questo approccio è molto usato per moli di dati enormi da gestire, per rendere più veloce il sistema evitando la scrittura su file e quindi allocazione di celle con puntatori ad esse.
L'uso è semplicissimo, la classe è dotata di tre metodi fondamentali:
write('stringa da scrivere nel buffer')
getvalue()
close()
Una semplice implementazione della classe, applicando i sui metodi può essere:
>>>from StringIO import StringIO
>>>myBuffer = StringIO()
>>>myBuffer.write("Ciao mondo!")
>>>print myBuffer.getvalue()
Ciao Mondo!
>>>myBuffer.write("Oggi c'è il sole!")
>>>print myBuffer.getvalue()
Ciao mondo! Oggi c'è il sole!
>>>myBuffer.close()
Etichette:
buffer,
python,
scrittura su buffer,
StringIO
lunedì 28 aprile 2008
Connessione Mysql con Python
Per effettuare una connessione ad un database MySQL attraverso Python, un sistema è utilizzare il modulo MySQLdb, che fornisce una classe con i metodi più comuni per creare una connessione ed eseguire delle query al database cui ci si è connessi.
Per spiegare al meglio un piccolo script che crea la connessione:
import MySQLdb
""""""""""""""""""""""""""""""""""
imposto informazioni connessione
""""""""""""""""""""""""""""""""""
host= "il mio host"
passw = "La mia password"
db = "nome del database"
unix_socket = "/percorso/to/mysql.sock"
"""""""""""""""""""""""""""""""""
Gestisco la connessione al db
"""""""""""""""""""""""""""""""""
try:
myConn = MySQLdb.connect(host,user,passw,db,unix_socket)
except MySQLdb.error,e
print "Errore %s nella connessione: "+e.args[1]
Raccomando sempre di gestire l'eccezione per capire effettivamente cosa può essere che non abbia funzionato nella connessione. Inoltre da tenere presente che gli errori sono contenuti nella lista e.args, e che in posizione [0] ho il numero dell'errore mentre in posizione [1] ho l'errore vero e proprio.
Nell'esempio viene riportato un parametro non obbligatorio, unix_socket, molto importante però, perchè non sempre il socket di mysql si trova nella posizione che di default si aspetta il metodo connect, questo può causare il lancio di una eccezione.
Essitono altri parametri non obbligatori, tipo la porta di connessione, ma questi sono molto standard e difficilemente diversi da sistema a sistema.
Per spiegare al meglio un piccolo script che crea la connessione:
import MySQLdb
""""""""""""""""""""""""""""""""""
imposto informazioni connessione
""""""""""""""""""""""""""""""""""
host= "il mio host"
passw = "La mia password"
db = "nome del database"
unix_socket = "/percorso/to/mysql.sock"
"""""""""""""""""""""""""""""""""
Gestisco la connessione al db
"""""""""""""""""""""""""""""""""
try:
myConn = MySQLdb.connect(host,user,passw,db,unix_socket)
except MySQLdb.error,e
print "Errore %s nella connessione: "+e.args[1]
Raccomando sempre di gestire l'eccezione per capire effettivamente cosa può essere che non abbia funzionato nella connessione. Inoltre da tenere presente che gli errori sono contenuti nella lista e.args, e che in posizione [0] ho il numero dell'errore mentre in posizione [1] ho l'errore vero e proprio.
Nell'esempio viene riportato un parametro non obbligatorio, unix_socket, molto importante però, perchè non sempre il socket di mysql si trova nella posizione che di default si aspetta il metodo connect, questo può causare il lancio di una eccezione.
Essitono altri parametri non obbligatori, tipo la porta di connessione, ma questi sono molto standard e difficilemente diversi da sistema a sistema.
Etichette:
eccezione,
mysql,
MySQLdb,
python,
unix_socket
giovedì 24 aprile 2008
I moduli in Python
In Python, come in C e Java, si possono importare dei moduli esterni.
Questo permette di rendere disponibili, allo script che li importa, le classi o meglio, i metodi le funzioni in esso contenute.
Un modulo può contenere un numero variabile di classi, a seconda della scuola di pensiero; c'è chi preferisce un approccio un modulo = una classe (Java-like) o chi preferisce inserire nel modulo tutte le classi logicamente correlabili (C-like).
Comunque la si pensi, per importare i moduli in un proprio script e farne uso si usano due sintassi in cima allo script:
import nome_modulo
o
from nome_modulo import nomeClasse1
from nome_modulo import nomeClasse2
Come si può facilmente capire, con il primo modo si importa tutto il contenuto del modulo, ovvero tutte le classi o funzioni presenti in esso, con il secondo sistema si importa solo ciò che si pensa possa servire nel modulo.
La differenza sta nella pulizia del codice, importare solo ciò che serve rende il codice più leggibile; essendo l'importazione all'inizio è daricordare che chi legge ha la percezione di ciò che viene usato subito all'apertura dello script.
A seconda della sintassi usata, cambia poi il sistema con cui si richiamano le classi nel modulo.
myClass = nome_modulo.NomeClasse()
o
myClass = nomeClasse()
questo perchè nel primo metodo non sappiamo se esistono due classi con lo stesso nome in moduli diversi
Questo permette di rendere disponibili, allo script che li importa, le classi o meglio, i metodi le funzioni in esso contenute.
Un modulo può contenere un numero variabile di classi, a seconda della scuola di pensiero; c'è chi preferisce un approccio un modulo = una classe (Java-like) o chi preferisce inserire nel modulo tutte le classi logicamente correlabili (C-like).
Comunque la si pensi, per importare i moduli in un proprio script e farne uso si usano due sintassi in cima allo script:
import nome_modulo
o
from nome_modulo import nomeClasse1
from nome_modulo import nomeClasse2
Come si può facilmente capire, con il primo modo si importa tutto il contenuto del modulo, ovvero tutte le classi o funzioni presenti in esso, con il secondo sistema si importa solo ciò che si pensa possa servire nel modulo.
La differenza sta nella pulizia del codice, importare solo ciò che serve rende il codice più leggibile; essendo l'importazione all'inizio è daricordare che chi legge ha la percezione di ciò che viene usato subito all'apertura dello script.
A seconda della sintassi usata, cambia poi il sistema con cui si richiamano le classi nel modulo.
myClass = nome_modulo.NomeClasse()
o
myClass = nomeClasse()
questo perchè nel primo metodo non sappiamo se esistono due classi con lo stesso nome in moduli diversi
Etichette:
classi python,
from import,
import,
moduli,
python
Le classi in Python
Prima di formalizzare le classi in Python facciamo alcune premesse su cosa sono le classi e su cosa vogliono rappresentare.
Una classe è un insieme dotato di attributi e metodi, tali da permettere di spiegarla al meglio.
Un classico esempio che ci viene di aiuto è quello della bicicletta.
La bicicletta fa parte di un insieme a cui appartengono oggetti dello stesso tipo (altre biciclette) dotati di caratteristiche, quali attributi (colore, marce, ecc..) e metodi (metti in movimento la bicicletta, ferma la bicicletta, ecc...) che permettono di definirne le "capacità".
Quindi l'uso della classe permette di raccogliere informzioni per oggetti dello stesso tipo in un unico insieme.
Python integra il paradigma a classi la sintassi con cui una classe viene scritta è la seguente (legata all'esempio sopra descritto per renderla più leggibile):
class Bici:
pedali = 2
manubrio =1
sellino = 1
colore = ''
marce = 1
#costruttore della classe
def __init__(self,col,nmar):
self._colore = col
self._marce = nmar
#Metodo per mettere la bici in movimento
def parte(self):
self._pedala();
# Metodo per pedalare
def _pedala(self):
"algoritmo del processo di pedalata"
miaBici = Bici('bianca',12)
Come si vede la miaBici appartiene all'insieme delle Bici ed è bianca a 12 marce.
A questo punto posso farla partire in questo modo:
miaBici.parte()
I metodi preceduti da "_" sono metodi interni alla classe, i così detti metodi privati, non possono quindi essere richiamati da istanze ("miaBici" è un'istanza della classe "Bici") della classe, ma solo da metodi interni alla classe stessa; ad esempio il metodo _pedala viene richiamato dal metodo parte dentro la classe.
Una classe è un insieme dotato di attributi e metodi, tali da permettere di spiegarla al meglio.
Un classico esempio che ci viene di aiuto è quello della bicicletta.
La bicicletta fa parte di un insieme a cui appartengono oggetti dello stesso tipo (altre biciclette) dotati di caratteristiche, quali attributi (colore, marce, ecc..) e metodi (metti in movimento la bicicletta, ferma la bicicletta, ecc...) che permettono di definirne le "capacità".
Quindi l'uso della classe permette di raccogliere informzioni per oggetti dello stesso tipo in un unico insieme.
Python integra il paradigma a classi la sintassi con cui una classe viene scritta è la seguente (legata all'esempio sopra descritto per renderla più leggibile):
class Bici:
pedali = 2
manubrio =1
sellino = 1
colore = ''
marce = 1
#costruttore della classe
def __init__(self,col,nmar):
self._colore = col
self._marce = nmar
#Metodo per mettere la bici in movimento
def parte(self):
self._pedala();
# Metodo per pedalare
def _pedala(self):
"algoritmo del processo di pedalata"
miaBici = Bici('bianca',12)
Come si vede la miaBici appartiene all'insieme delle Bici ed è bianca a 12 marce.
A questo punto posso farla partire in questo modo:
miaBici.parte()
I metodi preceduti da "_" sono metodi interni alla classe, i così detti metodi privati, non possono quindi essere richiamati da istanze ("miaBici" è un'istanza della classe "Bici") della classe, ma solo da metodi interni alla classe stessa; ad esempio il metodo _pedala viene richiamato dal metodo parte dentro la classe.
Etichette:
attributi,
classi python,
esempio classe python,
metodi,
python
Escaping per importazione su Mysql
Quasi sempre, quando si desidera inserire dei dati in formato stringa su un database, ci si trova ad affrontare l'escaping della stringa stessa.
Python permette di fare un escaping totale dei caratteri non alfanumerici utilizzando il modulo re e la sua funzione escape.
Per rendere più semplice gli step, riportiamo da linea di comando, dopo aver digitato il comando "python", la serie di comandi che permettono di trasformare la stringa in una stringa inseribile nel database, senza perdita di consistenza.
# python
>>> import re
>>> stringa = "pip&_tr"
>>> stringaEscaped = re.escape(stringa)
>>> stringaEscaped
pip\\&\\_tr
Come si può vedere python fa l'escape sia del carattere alfanumerico presente che del carattere "\" che serve per l'escaping, questo è molto importante e da tenere da conto.
Potrebbe, infatti, servire che alcuni caratteri non alfanumerici non debbano essere escappati, quindi la sintassi per rimuovere l'escape deve tenere conto di questa metodologia usata da Python .
Per far questo si può usare re.sub() con la seguente sintassi, ad esempio per rimuovere l'escaping a "_":
>>> stringaFinale = re.sub("\\\_","_",stringaEscaped)
>>> stringaFinale
pip\\&_tr
re.sub() come primo parametro riceve una regular expression, quindi è possibile in OR aggiungere tutte le combinazioni o caratteri (intal caso) che si vogliono togliere da un escaping.
Python permette di fare un escaping totale dei caratteri non alfanumerici utilizzando il modulo re e la sua funzione escape.
Per rendere più semplice gli step, riportiamo da linea di comando, dopo aver digitato il comando "python", la serie di comandi che permettono di trasformare la stringa in una stringa inseribile nel database, senza perdita di consistenza.
# python
>>> import re
>>> stringa = "pip&_tr"
>>> stringaEscaped = re.escape(stringa)
>>> stringaEscaped
pip\\&\\_tr
Come si può vedere python fa l'escape sia del carattere alfanumerico presente che del carattere "\" che serve per l'escaping, questo è molto importante e da tenere da conto.
Potrebbe, infatti, servire che alcuni caratteri non alfanumerici non debbano essere escappati, quindi la sintassi per rimuovere l'escape deve tenere conto di questa metodologia usata da Python .
Per far questo si può usare re.sub() con la seguente sintassi, ad esempio per rimuovere l'escaping a "_":
>>> stringaFinale = re.sub("\\\_","_",stringaEscaped)
>>> stringaFinale
pip\\&_tr
re.sub() come primo parametro riceve una regular expression, quindi è possibile in OR aggiungere tutte le combinazioni o caratteri (intal caso) che si vogliono togliere da un escaping.
Etichette:
python,
re python,
regular expression
Iscriviti a:
Post (Atom)