Python Tips & Tricks by Italian Python User Group http://www.italianpug.org 26 dicembre 2005 1
Indice 1 Prefazione 5 2 Tipi di dati e oggetti 7 2.1 Un aiuto rapido: help() & dir()................. 7 2.2 Il tipo di dato char (carattere).................. 8 2.3 Numeri e valori booleani..................... 9 2.3.1 Cosa é 0, cosa 1...................... 9 2.3.2 Potenza di un numero.................. 10 2.3.3 Come creare un numero random............. 11 2.3.4 Approssimare un numero................. 12 2.3.5 True o not(true)..................... 14 2.3.6 Operazioni con i numeri complessi............ 17 2.4 Stringhe.............................. 17 2.4.1 Template di stringhe................... 17 2.4.2 Sostituire una stringa con un altra............ 18 2.4.3 Pulizia stringhe...................... 19 2.4.4 Come ordinare una stringa................ 20 2.4.5 Invertire una stringa................... 21 2.5 Liste................................ 22 2.5.1 Iterare all incontrario................... 22 2.6 Funzioni.............................. 22 2.6.1 Creare generatori con yield................ 22 2.6.2 Funzioni semplici al volo: Lambdas........... 24 2.7 Classi, variabili e moduli..................... 25 2.7.1 Variabili globali...................... 25 2.7.2 Accesso dinamico al nome delle variabili........ 26 2.7.3 Inheritance dinamica di classi.............. 28 2.7.4 Importare moduli dinamicamente............ 30 2.7.5 Estendere l assegnazione, lettura e cancellazione di un oggetto........................... 31 2.7.6 Aggiungere la funzionalitá di iteratore ad una classe.. 32 2
3 Console e I/O 36 3.1 Come togliere la newline dalla funzione print()......... 36 3.2 Pulire lo schermo......................... 37 3.3 Come catturare l output di un comando avviato con python. 37 3.4 Misurare un file a crudo.................... 38 4 Sockets 40 4.1 Stream sockets.......................... 40 4.1.1 Listen su piú porte e un unico obiettivo......... 40 4.1.2 Indirizzo in uso e socket chiusa............. 42 4.1.3 IPC con le socket in dominio UNIX........... 42 4.2 World Wide Web......................... 44 4.2.1 Webserver senza files................... 44 4.2.2 Ricavare il nome di un webserver al volo........ 47 4.2.3 Download con urllib................... 48 5 DataBases 50 5.1 Accesso immediato e niente SQL................ 50 6 Interfaccia grafica 52 6.1 GTK................................ 52 6.1.1 Utilizzo dei threads.................... 52 6.1.2 Bottone con immagine.................. 54 6.1.3 Come compilare le pygtk con py2exe.......... 55 6.1.4 Navigazione tab nelle GtkTreeView........... 56 6.2 wxpython............................. 58 6.2.1 Grafica XP con py2exe.................. 58 7 Audio 60 7.1 Beep dall altoparlante...................... 60 8 Compressione 62 8.1 Comprimere con bz2....................... 62 8.2 Comprimere con zlib....................... 63 9 Crittografia 65 9.1 Uso della libreria Crypto..................... 65 10 Programmazione su Windows 68 10.1 Arrestare Windows XP...................... 68 10.2 No more shell........................... 70 3
11 Programmazione su UNIX 71 11.1 Demonizzazione.......................... 71 12 Ottimizzazione, statistica e debug 73 12.1 Libreria profile.......................... 73 12.2 Controllare ogni operazione................... 74 13 Decorazioni e vari trucchetti utili 76 13.1 Aggiungere e togliere elementi da un list con << e >>..... 76 13.2 Da stringa a comando py: eval()................. 78 13.3 Coding delle funzioni....................... 79 13.4 For, non fermiamoci alle apparenze............... 81 13.5 ConfigParser per i propri config files............... 82 13.6 Come identificare il Sistema Operativo............. 83 13.7 Caricamento moduli da una cartella non predefinita...... 84 13.8 Commenti su piú righe...................... 85 13.9 Questione di switch........................ 86 13.10Dividisioni perfette........................ 86 13.11Creare funzioni in runtime.................... 87 14 Stile di programmazione 89 14.1 Incongruenze tra moduli e variabili............... 89 15 Note finali 90 16 Autori 91 17 Indice analitico 92 A The GNU General Public License 95 4
Capitolo 1 Prefazione License This work is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This work is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You can find a copy of the GNU General Public License version 2 at Appendix A. Introduzione al CookBook Questo cookbook fornisce tips & tricks di varia natura, forniti direttamente dagli utenti IPUG (Italian Python User Group). Molti sono i motivi che ci hanno spinto a creare questo genere di documento, a partire dalla forza di collaborazione del nostro gruppo alla passione e alla voglia di far contribuire in un unico progetto ogni persona della community italiana sul Python. Molte volte i programmatori hanno bisogno di effettuare operazioni semplice e veloci che facciano al proprio caso, in modo da aggirare e rendere più chiaro una parte di codice complessa. 5
Ci si trova quindi in condizioni di dover chiedere e ricercare nella rete anche piccolezze che però possono salvare il programmatore da varie complicazioni. Alchè si è deciso di istituire questo progetto, con il quale ogni membro può suggerire dei tips e renderne partecipe l intera community. L intento quindi è quello di provvedere ad uno scambio di idee in modo da fornire un aiuto reciproco tra gli sviluppatori. Ognuno può quindi contribuire alla realizzazione di questo progetto e contribuirne alla sua crescita. Ciò di cui si ha bisogno è semplicemente di qualche minuto di tempo per scrivere qualche riga di codice e una spiegazione semplice e chiara di un qualsiasi problema incontrato e risolto nei propri programmi. L importante è non dare per scontato che i propri tips siano inutili, poichè i nuovi programmatori Python hanno bisogno di tutti i punti di riferimento possibili per risolvere anche piccoli errori e di conseguenza sciogliere dubbi e aumentare di un pizzico l esperienza. Gli articoli possono essere piccoli e scontati ma a volte sono miniere per chi ha bisogno di uno spunto veloce e semplice su come effettuare alcune operazioni. Ora vi lascio alla lettura del cookbook, e spero con questa piccola premessa di avervi indotto a partecipare al progetto. 6
Capitolo 2 Tipi di dati e oggetti 2.1 Un aiuto rapido: help() & dir() by The One Cosa diavolo fa quella data funzione? Come si usa? Qual é la funzione di quel certo metodo? In tutti questi casi Python ci viene in aiuto con dei semplici strumenti che fanno al caso nostro. Provate a digitare help dalla riga di comando: help Type help() for interactive help, or help(object) for help about object. L output dice tutto. Con help potete richiedere aiuto su qualsiasi funzione/classe digitandone semplicemente il nome! help() si basa sulla variabile doc, che restituisce una documentazione breve su di una funzione/classe specifica: import math print math.pow. doc pow(x,y) Return x**y (x to the power of y). 7
Restituisce in pratica la stringa di documentazione della funzione stessa, visualizzabile anche con help(math.pow). Prendiamo in considerazione la seguente funzione f(): def f(): "funzione inutile" pass print f. doc funzione inutile Come vedete la stringa funzione inutile inserita all inizio della funzione viene usata come docstring in doc Ora la funzione help() ha anche altri pregi, ad es. quello di poter visualizzare la documentazione di un modulo senza importarlo, racchiudendo il nome del modulo tra gli apici: help( math ). Infine, mettiamo che abbiate importato un modulo, chessó, mettiamo math, e ipotizziamo che non ricordiate quella data funzione di math che calcola il logaritmo di un numero, e supponiamo pure che non vi vada di cercare nella documentazione (sfaticati)... Bene se da riga di comando digitate: import math dir(math) Vi verranno elencate tutte le funzioni del modulo... mica male eh? 2.2 Il tipo di dato char (carattere) by Lethalman Vi sarete chiesti come mai in Python non vi é il tipo di dato built-in char! A volte puó servire nel momento in cui si ha un carattere e lo si vuole aumentare, ad es. portare s a t facendo s +1, ma questo non é possibile. Bisogna ricorrere alle seguenti operazioni: char = t print chr(ord(char)+1) Con ord si trasforma il carattere nel suo corrispettivo numero, lo si aumenta, 8
ed in seguito lo si trasforma nuovamente in carattere con chr. Una classe potrebbe aiutarci nell intento: class char: def init (self, c): if type(c) is int: self. char = c else: self. char = ord(c) def add (self, i): return char(self. char+i) def sub (self, i): return char(self. char-i) def str (self, i): return chr(self. char) def repr (self, i): return " %c " % self. char def int (self, i): return self. char All inizio viene salvato il carattere in modo numerico, con add e sub specifichiamo l operazione da eseguire rispettivamente in caso di + o -. Con str viene ritornata la stringa in caso si voglia usare la funzione str(), con int il numero del carattere usando int() e repr che ritorna normalmente il valore in stringa. Avendo la suddetta base, possiamo effettuare qualche test con il nostro carattere: c = char( s ) print c+1, c-1, c-2+3, int(c) t r t 115 2.3 Numeri e valori booleani 2.3.1 Cosa é 0, cosa 1 by Fred1 A dispetto del titolo (che é chiaro indice della mia salute mentale), voglio spiegare cosa, in Python, é vero o falso... Tutto ció che é vuoto, é falso. Ma come fare a verificarlo? Si utilizza la funzione built-in bool (che non si legge boooooooool con una quantitá pressoché infinita di o ): 9
bool( ) True Notate anche che non é vuota, perché é comunque uno spazio. Quindi ecco un esempio False: bool([]) False Visto? La lista vuota é falsa. Vorrei farvi notare che False é uguale a 0... Perché nel codice binario (l unico linguaggio che il computer comprende ed elabora) si utilizzano due simboli: 1 e 0; 1 sta per acceso, mentre 0 per spento (corso di informatica per brocchi?)... Quindi: bool(0) False Ed é per questo che per creare un loop infinito (che é il top, se volete la CPU un tantino occupata - quanto basta per farvi perdere tutto il lavoro non salvato... ) si usa: while 1: print a Che tradotto é: finché 1 stampa la stringa a... ovvero: finché 1 risulta vero stampa la stringa a. Infatti il codice sopra potrebbe essere scritto cosí: while 1 == True: print a (Ok, nel caso in cui abbiate disgraziatamente digitato il codice INUTILE riportato sopra citato dovete premere contemporaneamente ctrl + c per bloccare immediatamente il ciclo). Quindi se dovete sapere se la variabile, lista, tupla, ecc. non é vuota, basta fare: [if while] var. Comodo, vero? ;) 2.3.2 Potenza di un numero by The One Per chi muove i primi passi nulla é scontato... Chi di voi non si é mai trovato difronte al dilemma: 10
COME SI CALCOLA LA POTENZA ENNESIMA DI UN NUMERO? Sebbene Python nel modulo math implementi una funzione dedicata: double math.pow(b,exp) con le dovute restrizioni matematiche per la base (b) e l esponente (exp), esiste un mezzo molto piú rapido che non va a scomodare moduli particolari: b**exp dove b sta per la base e exp per l esponente. Prendiamo in considerazione il seguente esempio: import math math.pow(2,4) 16.0 2**4 16 Da notare che in questo caso, a differenza di math.pow, abbiamo un numero intero e non un double, con tutti i vantaggi e le conseguenze derivanti. L operatore ** restituisce numeri reali solo se necessario: (1.3)**4 2.8561000000000005 2.3.3 Come creare un numero random by Fred1 In Python, tra gli infiniti moduli, ne esiste uno con un mucchio di funzioni (la maggior parte delle quali incomprensibili dall uomo medio :) ) per creare numeri a caso: random. Si puó decidere di utilizzare il metodo random(), che crea un float a caso fra 0 e 1: import random random.random() 0.86693578658824788 Io direi che é totalmente inutile, no? Alcuni programmi, come i giochi, richiedono dei numeri random interi e tra 11
un inizio e una fine...... Facciamo un esempio: vogliamo che un mostro salti fuori a n secondi dall inizio del gioco. Che senso avrebbe farlo spuntare a 0.86693578658824788 secondi? Praticamente salterebbe fuori sempre allo stesso momento (a meno che voi non riusciate a distinguere i decimi/centesimi di secondo :) )... Quindi é meglio usare numeri interi. Ci sono due modi per creare numeri interi a caso: randint() e randrange(). import random random.randint(0,10) 9 randint() permette di creare un intero a caso includendo l inizio e la fine. randrange(), invece, da in output un intero appoggiandosi alla funzione built-in range(). 6 import random random.randrange(10) Notate che randint() pretende sia l inizio che la fine, mentre randrange(), proprio come range(), se presente un solo numero, immette come inizio 0. 2.3.4 Approssimare un numero by Luigi Pantano aka bornfreethinker Questo semplice codice é nato dall esigenza di approssimare in modo esatto un numero in python ad una determinata cifra decimale. La funzione accetta 2 paramentri: il primo paramentro num é il valore numerico che si vuole approssimare; il secondo parametro k rappresenta il grado di approssimazione, che per default é stato imposto a 4. Per meglio comprendere il codice mi sembra opportuno dare una rinfrescata al concetto di approssimazione con un breve esempio, ovviamente daró per scontato che conosciate almeno il concetto di approssimazione. Dato x = 1.48794 vogliamo approssimarlo alla 4 cifra decimale, ció significa che tutte le crifre fino alla 3 saranno esatte, cioé non risentiranno del grado di approssimazione; invece la 4 cifra sará inesatta perché approssimata. Ergo 12
se volessi ottenere un numero che prensenti fino alla 5 cifra decimale esatta dovrei approssimare alla 6 cifra decimale. Per approssimare x alla 4 cifra decimale analizziamo prima di tutto il valore della 5 cifra decimale che nella fattispecie vale 4, essendo il valore inferiore a 5 il numero si tronca, ottenendo x = 1.4879. Per approssimare x alla 3 cifra decimale analizziamo il valore della 4 cifra decimale che vale 9, essendo il valore maggiore a 5 il numero si approssima per eccesso ottenendo x = 1.488. Il codice da me proposto contempla anche il caso in cui il valore da approssimare sia uguale a 5. Esempio: x = 1.4565 da approssimare alla 3 cifra decimale. La 4 cifra vale 5, in questo caso si procede contemplando la 3 cifra decimale, quindi se la 3 cifra decimale é dispari si approssima per eccesso, altresí per difetto. def approssima(num, k=4): b = str(num - int(num))[2:2+1+k] h = int(b[-1]) if h > 5 or (h == 5 and divmod(int(b[-2]), 2)[1]!= 0): incremento = (10 - h) * pow(10, -(k+1)) num = num + incremento return str(num).split(. )[0] +. + str(num).split(. )[1][:k] Spulciando tra le numerose librerie del python ho trovato la libreria fpformat che esegue esattamente la stessa operazione della funzione approssima con l unica differenza che la funzione approssima contempla anche il caso in cui la cifra da approssimare é pari a 5. Riporto un semplice esempio per capire l uso e la differenza con la funzione approssima : import fpformat fpformat.fix(1.345, 2) 1.35 approssima(1.345, 2) 1.34 Se la precisione é ció che vi interessa vi consiglio di utilizzare la funzione da me scritta anziché la libreria fpformat. Un altro metodo, recentemente scoperto dal nostro amico FraFra, permetterebbe di effettuare in un altro modo una approssimazione esatta, il tutto con una 13
sola riga di programma! # Numero da arrotondare numero = 12.3456789 # Utilizzo: arrotondiamo alla 3 cifra decimale print %.3f % numero 12.346 Da questo tips si evincono principalmente due concetti importantissimi: 1. Nel mondo della programmazione l unico limite per la risoluzione di un problema é la vostra fantasia. 2. Nel mondo della programmazione open source l unico limite per la risoluzione di un problema é la fantasia della collettivitá! 2.3.5 True o not(true) by Luigi Pantano aka bornfreethinker Leggendo l illuminante tips Cosa e 0, cosa 1 di Fred1 mi é venuto spontaneo scrivere questo tip che metterá in luce un aspetto poco noto del comportamento dell istruzione condizionale if. Tale comportamento che a breve illustreró, tecnicamente chiamato short circuit dei costrutti condizionali e di iterazione, é una importante caratteristica ereditata dal C che invece é assente in altri linguaggi di programmazione come ad esempio il Visual Basic che usa la valutazione complete. Questo tips illustrerá solo il particolare comportamento dell istruzione if, per tale ragione daró per scontanta la conoscenza delle operazioni booleane elementari. Presentiamo da subito il codice che sará alla base del mio tips: def a(k): print funzione A, return, k return k def b(k): print funzione B, return, k return k def c(k): print funzione C, return, k return k if a(true) and b(true) and c(true): # riga PIPPO 14
print la condizione if risulta VERA else: print la condizione if risulta FALSA Il codice in questione é semplice e non necessita grandi spiegazioni di sorta. Abbiamo tre funzioni identiche (per comoditá ne ho prese soltanto tre ma potevo prenderne molte di piú) che accettano come parametro un valore booleano e come valore di return ritornano il parametro accettato. Quindi con il comando a(true) ottengo come risultato True. Vi prego di non sottovalutare la banalitá del codice che una volta compreso nel suo reale utilizzo verranno generalizzati dei concetti particolarmente importanti. Se eseguiamo l esempio cosí come é otteniamo giustamente il seguente output: funzione A return True funzione B return True funzione C return True la condizione if risulta VERA Evviva abbiamo scoperto l acqua calda!. Era un risultato perfettamente attendibile e prevedile, sicuramente non siete rimasti stupiti di ció. Modifichiamo la riga incriminata PIPPO con la seguente: if a(false) and b(true) and c(true): rieseguiamo il codice ed otteniamo come output: funzione A return False la condizione if risulta FALSA Notiamo subito che sia la funzione b() che c() non sono state eseguite, ma di ció non dovremo preoccuparci perché il comportamento del programma é perfettamente logico. La funzione if esegue il salto condizionale solo se la condizione risulta True. Nel primo caso tutte e 3 le funzioni essendo vere ed essendo messe in relazione booleana con un and danno come risultato una condizione True. Nel secondo caso invece la funzione a() restituisce un valore False quindi essendo le tre funzioni correlate da un and e sapendo che and restituisce True SOLO quando tutti i termini di confronto sono veri, il programma non ha avuto bisogno di eseguire il resto delle funzioni b() e c() perché ai fini della verifica della condizione risultavano, in questo specifico caso, ininfluenti i loro valori. 15
Nota: nel caso in cui non fosse molto chiaro il concetto, consiglio innanzi tutto di giocare un pó con la riga PIPPO modificando i valori passati alle funzioni oppure cambiando il tipo di relazione da and a or (rimarrete stupiti dal risultato!) ed inoltre di proseguire con la lettura della guida. Questo risultato ottenuto é eccezionale e mostra un comportamento intelligente da parte dell interprete Python che evita di sprecare cicli macchina e quindi tempo nell esecuzione di istruzioni non necessarie. Adesso é arrivato il momento di generalizzare un concetto abbastanza fondamentale nella vita di ogni buon programmatore che passa gran parte della sua vita non a scrivere i programmi, ma ad eseguire debug e soprattutto ad ottimizzare la velocitá di esecuzione del codice. Supponiamo che le funzioni a(), b(), c() siano molto piú complesse di quella dell esempio e che siano strutturate in modo tale che alla fine diano un risultato dipendente dal parametro immesso ma che ció non sia cosí banale come nell esempio. Una maggiore complessitá della funzione comporta maggiori cicli macchina per eseguirla, quindi un tempo di esecuzione piú lungo. Supponiamo che le funzioni impieghino rispettivamente i tempi: Ta, T b, Tc e che tale tempi siamo posti in relazione Ta>T b >Tc. Quindi la riga PIPPO affinché venga eseguita avrá un tempo sicuramente maggiore della somma dei tempi di esecuzione delle tre funzioni: T pippo > Ta + T b + Tc. Ho supposto che il tempo sia maggiore data la presenza dell if e dell and che sicuramente impiegeranno un loro tempo di esecuzione. Nel primo caso da noi analizzato il tempo T pippo era il piú alto avendo eseguito tutte e tre le funzioni invece nel secondo caso abbiamo ottenuto sicuramente un tempo inferiore rispetto a quanto preventivato, ma lo si puó ridurre ancora con questo semplice trucco. Sotto la precendente ipotesi Ta>T b >Tc per accorciare i tempi di esecuzione basterá modificare la riga PIPPO come segue: if c(valore C) and b(valore B) and a(valore A): in questo modo se la funzione c() risultasse falsa otterrei il tempo T pippo piú basso in assoluto! Volendo procedere in un altro modo si potrebbe verificare quale funzione da piú velocemente un risultato falso e porla come prima funzione da analizzare. Benvenuti nel mondo dell ottimizzazione del codice, un mondo in cui l unico 16
limite é la vostra fantasia ed il vostro ingegno. 2.3.6 Operazioni con i numeri complessi by Luigi Pantano aka bornfreethinker Ho trovato particolarmente interessante constatare che python puó effettuare conteggi sui numeri complessi in modo nativo, senza l utilizzo di particolari accorgimenti. Forse chi non ha affrontato studi universitari di tipo ingengneristico o matematico/fisico sconosce questo insieme numerico, ma vi assicuro che nella teoria circuitale, e non solo, é utilizzatissimo (http://it.wikipedia.org/wiki/numero complesso). Comuque ecco come si crea in python un numero immaginario ed alcuni semplici operazioni algebriche: a = complex(1, -4) b = complex(-8, 5) a + b (-7+1j) a * b (12+37j) a.imag -4.0 a.real 1.0 2.4 Stringhe 2.4.1 Template di stringhe by Lethalman Vi é mai capitato di dover inserire dei valori in una stringa con il normale formatting delle stringhe builtin in Python formato % (dati)? C é un altro metodo, che in base alle proprie esigenze puó anche rivelarsi piú semplice, si tratta di string.template: from string import Template s = Template( Ciao $nome ) 17
print s.substitute(nome= Luca ) Ciao Luca Come vedete, si crea un instanza Template col formato della stringa mettendo $ davanti alle variabili da sostituire. Ma cosa succede se attaccato al nome della variabile volessimo mettere qualcos altro? In questo caso basta mettere agli estremi { e }: from string import Template s = Template( Ciao ${nome}s ) print s.substitute(nome= Luca ) Ciao Lucas Per scrivere il carattere $ senza prenderlo come template basta scrivere $$. In caso si usa un template inesistente, substitute dará un errore per non aver trovato la variabile, in questo caso si puó usare safe substitute: from string import Template s = Template( Ciao $nome $cognome, hai in tasca $$100 ) print s.safe substitute(nome= Luca ) Ciao Luca $cognome, hai in tasca $100 In questo caso non avevamo specificato $cognome, e nonostante tutto non ha dato errore ed ha sorvolato il templating. 2.4.2 Sostituire una stringa con un altra by Fred1 Good morning mister Good night mister In questo esempio ho sostituito morning con night. In python ci sono molteplici modi per farlo, ma il piú semplice é: replace(). print ciao ciao.replace( ao, uf ) ciuf ciuf Come vedete, replace() necessita di 2 argomenti, ma ce n é uno opzionale: maxsplit (ovvero il numero massimo di sostituzioni). Eccone un esempio: print ciao ciao.replace( ao, uf, 1) ciuf ciao 18
Come possiamo vedere, anche se si riscontrano 2 possibili sostituzioni, ne viene effettuata solo 1. Si possono concatenare anche piú replace(), visto che comunque restituiscono una stringa: a = To be or not to be? print a.replace(, ).replace( o, 0 ).replace( i, ) T0 be 0r n0t t0 be? 2.4.3 Pulizia stringhe by Luigi Pantano aka bornfreethinker Essendo una persona estremamente sbadata dimentico spesso di inserire nel codice e nei commenti che posto anziché il carattere accentato da testiera l apostrofo per l accentazione. Per tale ragione ho scritto questo semplicissimo codice che dimostrerá ai novizi del python la flessibilitá che il linguaggio offre. Inoltre per completezza ho aggiunto del codice per ottenere lettere maiuscole dopo ogni punto. Dopo aver aperto il file assegnamo il contenuto letto alla variabile testo e procediamo con la sostituzione delle lettere accentate. Per rendere il codice maggiormente leggibile ho preferito usare un dizionario nel quale ad ogni lettera accentata corrisponde il suo equivalente con apostrofo. Tramite il ciclo for e la funzione replace ottengo la ripetuta sostituzione di tutte le lettere interessate. La seconda parte del codice non fa altro che formattare il testo. Dopo aver diviso il testo in paragrafi, ció lo si ottiene splittato il testo ad ogni. (punto), tramite il ciclo for ad ogni paragrafo vengono eliminati gli spazi iniziali con la funzione lstrip e viene capitalizzato il testo tramite la funzione capitalize (la prima lettera del paragrafo diverrá maiuscola!). Infine ogni paragrafo viene aggiunto alla variabile testo formattato seguito da un punto piú uno spazio. Scrittura del file e print del testo formattato ed il gioco é fatto. Niente di piú semplice. :-D def ordina(filename): f = open(filename) testo = f.read() f.close() # lettere da sostituire 19
d = {"é": "e ", "á": "a ", "ú": "u ", "ó": "o "} for carattere in d: testo = testo.replace(carattere, d[carattere]) # formatta il testo testo formattato = paragrafi = testo.split(. ) for x in xrange(len(paragrafi)): testo formattato += paragrafi[x].lstrip().capitalize() +. f = open(filename, w ) f.write(testo formattato) f.close() print testo formattato ordina( esempio banale.txt ) 2.4.4 Come ordinare una stringa by Luigi Pantano aka bornfreethinker Il metodo sort() non puó essere applicato direttamente ad un oggetto stringa, una possibile soluzione al problema é la seguente: def ordina(string): l = list(string) l.sort() return.join(l) a = questa é una stringa che deve essere ordinata print ordina(a) La stringa viene convertita in una lista l che verrá ordinata tramite il metodo sort() ed infine riconvertita in una stringa con il metodo join(), che non fa altro che concatenerare gli elementi di una lista. Nota: con questo semplice trucco é possibile applicare tutti i metodi applicabili per ler sole liste anche alle stringhe. Ad esempio potreste usare il metodo count per verificare quante sono le occorrenze di un dato carattere in dato testo. def conta(string, carattere): l = list(string) return l.count(carattere) 20
a = quante quante vocali e sono contenute in questa semplice frase? print conta(a, e ) Ci rendiamo subito conto che con queto strataggemma possiamo estendere il numero di metodi applicabili alle stringhe, rendendole un oggetto ancora piú efficace di quello che attualmente sono. 2.4.5 Invertire una stringa by Luigi Pantano aka bornfreethinker Spulciando in internet ho trovato questo simpatico trucchetto che permette di invertire il contenuto di una stringa. Codice valido per tutte le versioni di Python: str = Hello, world! revstr = str[::-1] print revstr!dlrow,olleh Codice specifico per la versione Python 2.4: str = Hello, world! print.join(reversed(str))!dlrow,olleh Nel caso usiate python 2.4 potrete usare indiscriminatamente l uno o l atro codice. Ecco vi illustro un possibile uso di questo codice. Questo esempio permette di ottenere, dato un percorso, il nome del file: fullpath = /home/bornfreethinker/music/prova.txt print fullpath[::-1].split( / )[0][::-1] prova.txt Questo codice puó sembrare un pó crittico inizialmente ma se lo osservate con attenzione é molto semplice. 21
Per chi ama invece divertirsi con le frasi bifronte (http://it.wikipedia.org/wiki/bifronte) troverá grazioso il seguente esempio: str = ANNA AMA BOB print str[::-1] BOB AMA ANNA 2.5 Liste 2.5.1 Iterare all incontrario Una nuova feature in Python 2.4: una funzione che stampa all incontrario una lista! Prima del 2.4, per stampare una lista all incontrario, dovevamo fare: a = [ a, b, c, 8, foo ] a[::-1] [ foo, 8, c, b, a ] Mentre adesso possiamo usare la funzione built-in reversed(), che agisce solo sulle iterazioni (con ovvio risparmio della memoria): a = [ a, b, c, 8, foo ] print reversed(a) <listreverseiterator object at 0x0117BF30> for i in reversed(a): print i, foo 8 c b a b = [f for f in reversed(a)] print b [ foo, 8, c, b, a ] 2.6 Funzioni 2.6.1 Creare generatori con yield by Lethalman Nelle ultime versioni del Python si stanno sempre di piú affermando i generatori 22
che permettono di avere maggiori performance e controllo nelle proprie funzioni: gen = (i for i in abc ) print gen.next(), gen.next(), gen.next() a b c gen.next() Traceback (most recent call last): File "<stdin>", line 1, in? StopIteration Abbiamo appena utilizzato una generator expression per creare un generatore. Quindi un generatore non é altro che un contenitore bufferizzato che ritorna di volta in volta gli oggetti registrati. Come le liste, ha anche una funzione che permette l iterazione con il for per averne un utilizzo piú semplice: gen = (i for i in abc ) for word in gen: print word, a b c print gen.next() Traceback (most recent call last): File "<stdin>", line 1, in? StopIteration Il risultato sará identico, come lo é anche l errore alla fine. Il generatore, una volta terminata la sua iterazione, non ha piú elementi da ritornare. Lo si puó capire meglio utilizzando lo statment yield all interno di una funzione: def fgen(): yield a yield b yield c gen = fgen() print gen.next(), gen.next(), gen.next() a b c Come si puó notare, yield é simile a return. Nel momento in cui si chiama la funzione, non viene eseguito nulla al suo interno e viene solo ritornato un generatore. Infatti quando chiama next() viene eseguito il codice all interno della funzione fino a che non incontra yield, bloccandosi temporaneamente fino all esecuzione nel prossimo next(). E cosí via fino all ultimo yield, il quale codice che lo sussegue verrá eseguito con next() che dará errore poiché 23