24 dicembre 2008

Auguri di Buone Feste a Tutti!

Augurissimi di Buon Natale.

Perle della Bash[23-12]

Il comando alias non è altro che una abbreviazione di un dato comando, i comandi alias ci vengono in nostro aiuto in quanto la natura dei sistemi di tipo Unix, ci porta frequentemente a battere sulla tastiera lunghi comandi.

ad esempio un alias è un comando come questo.
# con il comando off ci permette di fare lo spegnimento di sistema invece di shutdown -h now
:~$ alias off='shutdown -h now'

ecco altri esempi di comandi assegnati ad un alias.
questi i semplici comandi.
:~$ cat /proc/cpuinfo
:~$ cat /proc/meminfo

e questi sono gli alias settati.
:~$ alias me='grep memfree /proc/meminfo'
:~$ alias p='grep cpuinfo  /proc/cpuinfo'

se non ricordiamo più tutti i nostri alias settati in nostro aiuto ce il semplice comando alias senza argomenti.
# visualizza tutti gli alias settati
:~$ alias

Se decidessimo di non volere più alias settati sul nostro sistema basta semplicemente il comando (unalias comando='settato -argomento').

ecco l'esempio concreto per rimuovere gli alias creati in precedenza.
# rimuove l'alias
:~$ unalias me='grep memfree /proc/meminfo
:~$ unalias p='shutdown -h now'

una chicca per gli amici che provengono da anni di sistemi windows(e di conseguenza dal Prompt dei comandi), se con una shell vi trovate spaesati con delle alias potrete ricreare i vostri comandi che divergono dalle vostre abitudini.

ecco un esempio.
:~$ alias copy='cp'
:~$ alias dir='ls'
:~$ alias rd='rmdir'

e cosi via con tutti i comandi che volete. Credo vi sentirete più a casa vostra.

E questo e quanto, credo che una volta capito il sistema creare alias sia un modo più veloce e efficiente per essere padroni della nostra shell.

23 dicembre 2008

[PYTHON]Il Tipo List

Le liste sono il tipo di oggetti più flessibili tra quelli disponibili in Python.
Questo significa che le liste possono contenere più tipi di oggetti: stringhe, numeri,
e altre liste(annidate)all'interno di altre liste. Tra l'altro le liste possono essere
modificate sul posto tramite sezionamenti, cancellazione, assegnamenti indicizzati, ecc.

Ecco alcuni esempi di lista

list = [] #lista vuota
list = [0,1,2] #lista con tre elementi
list = ['Python', ['Perl', 'Php']] #lista annidata


E qui le liste al lavoro tramite assegnamento, che come detto qualche riga più su il tipo list è modificabile sul posto ecco un esempio che tramite assegnamento [2] modifica
'Ruby' con 'Haskell'.

>>> lista = ['Java','Jython','Ruby','Javascript','Python']
>>> lista[2] = 'Haskell'
>>> lista
['Java', 'Jython', 'Haskell', 'Javascript', 'Python']

possiamo anche sostituire tramite assegnamento un pezzo di lista con un altra eliminando 'Java' e aggiungendo 'Css' e 'Xhtml'.

>>> lista[0:1] = ['Css','Xhtml']
>>> lista
['Css', 'Xhtml', 'Jython', 'Haskell', 'Javascript', 'Python']


possiamo rimuovere completamente la lista.

>>> del(lista)
>>> lista
Traceback (most recent call last):
File "", line 1, in
NameError: name 'lista' is not defined



adesso per osservare il meglio delle liste ne creiamo una ex novo contenente i quattro elementi della terra.

>>> newLista = ['Acqua','Terra','Aria','Fuoco']
>>> newLista
['Acqua', 'Terra', 'Aria', 'Fuoco']


possiamo invertire la lista appena creata.

>>> newLista.reverse()
>>> newLista
['Fuoco', 'Aria', 'Terra', 'Acqua']


come avevamo detto in precedenza, le liste sono mutabili ecco che con il metodo append aggiungiamo un elemento in coda alla lista.

>>> newLista.append('Animali')
>>> newLista
['Fuoco', 'Aria', 'Terra', 'Acqua', 'Animali']



>>> newLista[0:2] = ['Pesci','Vulcano']
>>> newLista
['Pesci', 'Vulcano', 'Terra', 'Acqua', 'Animali']


se vogliamo inserire un oggetto in una particolare posizione insert e il metodo che fa per noi,
che inserisce nel terzo indice(in Python si inizia a contare da zero) 'Ippopotamo'.

>>> newLista.insert(3,'Ippopotamo')
>>> newLista
['Pesci', 'Vulcano', 'Terra', 'Ippopotamo', 'Acqua', 'Animali']


ecco il metodo extend che aggiunge sempre 'Ippopotamo' ma nel modo seguente

>>> newLista.extend('Ippopotamo')
>>> newLista
['Pesci', 'Vulcano', 'Terra', 'Ippopotamo', 'Acqua', 'Animali', 'I', 'p', 'p', 'o', 'p', 'o', 't', 'a', 'm', 'o']


il metodo remove ovviamente rimuove un indice esattamente 'Pesci'.

>>> newLista.remove('Pesci')
>>> newLista
['Vulcano', 'Terra', 'Ippopotamo', 'Acqua', 'Animali', 'I', 'p', 'p', 'o', 'p', 'o', 't', 'a', 'm', 'o']


il metodo pop rimuove un elemento tramite indice e nello stesso tempo restituisce il valore dell'elemento che viene cancellato in questo caso 'Vulcano'.

>>> newLista.pop(0)
'Vulcano'


qui tramite il metodo index viene riconosciuta la posizione dell'indice passato come argomento
in questo caso Acqua che ha 2 come indice.

>>> newLista
['Terra', 'Ippopotamo', 'Acqua', 'Animali', 'I', 'p', 'p', 'o', 'p', 'o', 't', 'a', 'm', 'o']
>>> newLista.index('Acqua')
2

e qui il metodo count che indicizza come 1(ovviamente si inizia la conta da zero)'Ippopotamo'.

>>> newLista.count('Ippopotamo')
1
>>>

18 dicembre 2008

Perle della Bash [18-12]

Man mano che nel sperimentare(spero con meno danni di quelli già fatti) la shell in particolare la bash e imparo comandi o trucchetti nuovi, sarò felice di condividerlo con tutti quelli che lo vorranno. Questo è anche un modo per motivare me stesso a imparare la shell, che di Gnu/Linux come io ritengo, è la stanza dei bottoni.

Scrivere uno script in bash è molto semplice basta aprire il vostro editor che usate di solito e iniziare a scrivere del codice come il seguente
#!/bin/bash

echo 'Ciao sono la shell sarò sempre al tuo fianco!'

ps ax | wc -l

echo 'bye.'

e salvare il listato con nome_script.sh, poi rendere lo script eseguibile con
:~$ chmod 755 nome_script.sh

e eseguirlo in questo modo
:~$ ./nome_script.sh.

Ma possiamo eseguire la stessa porzione di codice anche in un modo diverso che è quello interattivo. Cioè eseguire il tutto da shell senza scrivere una riga di testo nel nostro editor. esattamente scriviamo lo script senza #!/bin/bash nella shell cosi
:~$ echo 'Ciao sono la shell sarò sempre al tuo fianco!'

:~$ ps ax | wc -l

:~$ echo 'bye.'

e avremo l'output di quanto scritto nel Terminale stesso, niente di difficile vero?

Bene adesso continuiamo nel testare la nostra shell sempre in modo interattivo.




Se abbiamo l'esigenza di rimuovere tutte le righe bianche in un file di testo o in un nostro script sed e nostro amico.
:~$ cat poema.txt | sed /^$/d

tutt'altra cosa è quando non sappiamo dove si trova un determinato file(o anche più di uno) possiamo usare un comando che lo cerca nel sistema è una volta trovato lo elimina.



tipo questo comando che trova e rimuove tutti i file con estensione .bak(bakup).
:~$ rm $(find . -name '*.bak')

se invece abbiamo una directory piena zeppa di file e vogliamo trovare una certa stringa o parola che sia contenuta in ognuno di questi file, ecco quello che fa per noi.

:~$ ls | grep open | wc -l

cerca la stringa open in tutti i file contenuti nella directory corrente.

Certo sicuramente non ce niente di impegnativo in questi comandi, ma iniziare dalle cose piccole
è sempre il modo migliore per sperimentare e approfondire, soprattuto nei riguardi della shell.

10 dicembre 2008

Installare Django per la Prima Volta

Questo mini-tutorial su l' installazione del Framework django presume che tu
non abbia mai installato e usato il Framework. In poche parole che tu sia un vero "Dummies",
di conseguenza la via per installare e mettere in "funzione" django sarà la più semplice
possibile, quindi niente installazioni "esotiche" tipo SVN o via Setuptools.
Il mio consiglio e di installare django direttamente dal pacchetto ufficiale quindi niente apt-get(lo so che non se ne può fare a meno) al momento opportuno vi spieghero perché è forse mi ringrazierete.

Nonostante al momento la release più recente sia la 1.0.2 la versione che noi installeremo è la 1.0. Armiamoci di wget e scarichiamo il tar.gz [wget http://www.djangoproject/download/Django-1.0.tar.gz] o se preferite aprite il vostro browser preferito(spero che sia tra Firefox e Opera ;-)) e collegatevi sul sito http://www.djangoproject.com/download e scaricate il file Django-1.0.tar.gz.

Una volta scaricato il file Django-1.0.tar.gz lo scompattiamo(il termine spacchettare non mi piace)con il comando tipico tar, entriamo nella directory che si e venuta a creare col comando cd e installiamolo con setup.py install.

Ecco l'esempio pratico
:~$ tar xzvf Django-1.0.tar.gz

:~$ cd Django-1.0

:~$ sudo python setup.py install

adesso per avere la conferma che tutto sia andato per il verso giusto aprite una shell Python
e digitate il classico import di Python come da esempio


>>> import django
>>> django.VERSION
riceverete in output una tupla con la versione installata
(1,0, 'official')


ok siamo già a un buon punto(siete eccitati? eh!)adesso che django e installato, e arrivato il momento di sapere perché abbiamo preferito il .tar.gz all'amichevole apt-get. Installando django con setup.py install possiamo creare la directory del nostro progetto dove meglio
ci aggrada al contrario di apt-get che ci costringe(provare per credere)ad una lunga ricerca tra il filesystem per capire dove ha posizionato la directory giusta che contiene django.admin.py.

Ma non solo, installare con setup.py install dovrebbe permetterci di lanciare django.admin.py startproject pommy anche da più parti nel filesystem visto che il setup.py, ci setta django.admin.py già nel path Python e cosi facendo non dovremo creare link simbolici.

Però visto che stiamo operando al computer,(e certe volte accadono cose che non riusciamo
a comprendere), nell'eventualità che non vi funzioni a dovere, allora creiamo un link simbolico, rendiamo eseguibile il file con un bel chmod 755 django-admin.py e siamo a posto.

Invece il link simbolico lo creiamo in questa maniera

ln -s /usr/lib/python2.5/site-packages/django/bin/django-admin.py /home/archie
(logicamente voi mettete il vostro utente).

Quindi adesso con il comando cd entriamo nella /home/archie(vostro utente) e diamo il comando che crea la nostra directory per l'applicazione django-admin.py startproject pommy(voi chiamatelo come volete) che ci crea la directory pommy più quattro file per settare il nostro progetto che sono __init__.py, manage.py, settings.py, e urls.py.

Adesso spiego brevemente la funzione che questi file hanno. Il file __init__.py altro non è che un file vuoto che permette a python di identificare la directory come packages,
il file menage.py contiene una serie di utility per il progetto corrente mentre Settings.py e urls.py non sono altro che dei file di configurazione del progetto Django creato. Esattamente il primo si occupa della configurazione globale del progetto, e il secondo consente di settare gli url del progetto creato in un modo molto pulito e elegante.

Come ho menzionato all'inizio del mini-tutorials, questa è una guida "for Dummies" quindi dei quattro files appena descritti(__init__.py, manage.py, settings.py, e urls.py)ne toccheremo solo uno, e faremo in modo da rendere disponibile un database minimo(sqlite3).

Bene aprite con il vostro editor il file settings.py troverete queste righe di codice


DEBUG = True
TEMPLATE_DEBUG = DEBUG
ADMINS = ( )
MANAGERS = ADMINS
DATABASE_ENGINE = ''
DATABASE_NAME = ''
DATABASE_USER = ''
DATABASE_PASSWORD = ''
DATABASE_HOST = ''
DATABASE_PORT = ''


le uniche aggiunte che dovrete fare sono quelle che vediamo sotto. Sono le stesse righe di codice che vedete sopra ma con le nostre aggiunte che sono il DATABASE_ENGINE con "sqlite3" e il nome da dare al vostro database DATABASE_NAME con "pommydb", ma voi potete chiamarlo come vi pare.


DEBUG = True
TEMPLATE_DEBUG = DEBUG
ADMINS = ( )
MANAGERS = ADMINS
DATABASE_ENGINE = 'sqlite3' #1°aggiunta
DATABASE_NAME = 'pommydb' #2°aggiunta
DATABASE_USER = ''
DATABASE_PASSWORD = ''
DATABASE_HOST = ''
DATABASE_PORT = ''


adesso aprite una shell ricercate la directory dove risiede manage.py e avviamo il database con

:~$ python manage.py syncdb

e per finire diamo un bel avvio al nostro server interno del nostro progetto con

:~$ python manage.py runserver


e aprite il vostro browser(rispero Firefox o Opera)e scriviamo http://localhost:8000 diamo INVIO e ammirate la pagina di benvenuto in tutto il suo splendore(eh..eh!!)per terminare il server Control-C.















Spero che sia stato chiaro, ciao.

6 dicembre 2008

Il Python Apprezzato Sempre di più


Python supera il Perl come linguaggio usato nell'anno 2007.

Ecco uno screenshot della classifica di Tiobe riguardo Novembre del 2007. Non mi resta che augurare lunga vita al Python e a Guido Van Rossum.

E Arrivato PYTHON 3.0 per gli Amici Py3K!

Dopo Python 2.6 il 3 Dicembre è arrivata a vedere la luce anche la tanto "chiacchierata" versione 3.0 di Python. Per chi mastica il linguaggio, sa che questa release porta con se importanti novità, e cambiamenti che per la prima volta rompe la compatibilita all'indietro ( backwards incompatible). Tra le novità più importanti ci sono, la nuova formattazione delle stringhe.

Print diventa una funzione invece di una istruzione, e di conseguenza implementa più funzionalità.



Old: print "The answer is", 2*2
New: print("The answer is", 2*2)

Old: print x, # Trailing comma suppresses newline
New: print(x, end=" ") # Appends a space instead of a newline

Old: print # Prints a newline
New: print() # You must call the function!

Old: print >>sys.stderr, "fatal error"
New: print("fatal error", file=sys.stderr)

Old: print (x, y) # prints repr((x, y))
New: print((x, y)) # Not the same as print(x, y)!



adesso esiste un solo tipo intero vale a dire int.

Sparisce del tutto l'espressione <> (fino ad ora deprecato) si deve usare !=

la funzione precostruita raw_input(), diventa input()

as, with e nonlocal sono parole riservate.

Le funzioni apply() e reduce() non esistono più, la derivazione delle classi class func(object) non e più richiesta, cambia anche l'istruzione try except. Cambiano anche i metodi per i dizionari dict.keys(), dict.items() e dict.values() che adesso
restituiscono degli oggetti iterabili, per le liste adesso bisogna usare list().




Con Python 3.0 adesso ce un nuovo approccio allo standard Unicode, non si usa più u'....'
adesso tutto il testo è unicode, il "vecchio" metodo è utilizzabile solo per letterali binari b"....".

Cambiano anche le meta classi in questo modo:

vecchio stile

class C:
__metaclass__ = M

in nuovo stile

class C(metaclass = M):

sicuramente la nuova versione non sarà usata nell'immediato(soprattuto in produzione)da una larghissima base di sviluppatori(la 2.5 e la 2.6 hanno tanto da dire ancora)ma sicuramente sono state gettate le basi per rendere il linguaggio(già eccellente) sempre più dinamico e pulito da permettere di scrivere codice migliore e sempre più leggibile che in un linguaggio Open Source non guasta.

ora per non annoiarvi mi fermo qui,ma ce ancora tanta carne al fuoco. Quindi se la cosa vi ha
incuriositi un pochettino e volete approfondire l'argomento vi rimando al What's New e alla
nuova e corposa documentazione.

Happy Coding

1 dicembre 2008

Una Scuola e un Professore da Lodare

Ecco un Istituto da cui dovrebbero prendere esempio gli altri Istituti Scolastici. Grazie al coraggio di osare di un Docente Prof. Cantaro Antonio (da lodare) per aver scelto software Open Source per il suo Istituto, ma non solo, è anche il creatore di una (bella) serie di tutorials su GIMP (ma non solo)il nostro amato editor di file grafici.