Accademia:Log 2011 03 09

21:32:18 < spirit> Buonasera
21:32:24 < Stemby> ciao spirit
21:32:31 < Stemby> iniziavo a preoccuparmi
21:32:43 < Stemby> tutto bene?
21:32:43 < spirit> perchè?
21:32:52 < Stemby> perché non c'era nessuno
21:33:23 < Stemby> spirit: cos'hai fatto di bell?
21:33:25 < Stemby> *bello
21:33:30 < spirit> l' altra volta sono uscito dalla chat, perchè avevo mal di testa
21:33:40 < Stemby> l'altra volta... quando?
21:33:43 < Stemby> mercoledì?
21:33:46 < spirit> domenica
21:33:56 < Stemby> domenica è saltata
21:34:23 < Stemby> non si è fatto niente
21:34:53 < spirit> io sto ripassando in questi giorni
21:35:06 < Stemby> cosa?
21:35:29 < spirit> un pò tutta la sintassi
21:35:53 < spirit> sopprattutto il significato di () [] {}
21:36:09 < |Wolf|> Stemby, cmq l'altro giorno c'era qualcuno che si lamentava del libro
21:36:16 < spirit> list, list comprension
21:36:18 < Stemby> sì, ho letto
21:36:38 < Stemby> non so che farci
21:36:47 < Stemby> io sono arrivato al capitolo 6
21:36:52 < Stemby> e non mi sembra malaccio
21:36:59 < Stemby> certo, tutto molto semplice
21:37:18 < Stemby> ma secondo me è quel che ci vuole
21:37:31 < spirit> un libro di base ben fatto, no?
21:38:27 < |Wolf|> imho basterebbe il tutorial
21:38:38 < |Wolf|> e se ci sono cose non chiare basta dirlo che si modifica
21:41:37 < risca> buona sera
21:41:43 < risca> che passa per il cortile?
21:41:51 [Users #debianizzati-corsi]
21:41:51 [ hoax] [ risca] [ spirit] [ Stemby] [ |Wolf|] 
21:41:51 -!- Irssi: #debianizzati-corsi: Total of 5 nicks [0 ops, 0 halfops, 0 voices, 5 normal]
21:41:52 < spirit> ciao risca
21:42:03 < risca> ciao
21:42:15 < Stemby> cià, visto che son stanco, iniziamo
21:42:21 < Stemby> spirit: hai domande?
21:42:21 < risca> ecco lo spirit[o] giusto per iniziare la serata
21:43:00 < spirit> per ora no, grazie...
21:43:13 [Users #debianizzati-corsi]
21:43:13 [ hoax] [ risca] [ spirit] [ Stemby] [ |Wolf|] 
21:43:13 -!- Irssi: #debianizzati-corsi: Total of 5 nicks [0 ops, 0 halfops, 0 voices, 5 normal]
21:43:16 -!- alnuvola [~alex@Azzurra=68BD88FB.cust.dsl.teletu.it] has joined #debianizzati-corsi
21:43:23 < Stemby> oh, che bello
21:43:24 < risca> Stemby, cosa ci presenti stasera?
21:44:06 < Stemby> alnuvola: una new entry?
21:44:16 < Stemby> risca: l'uso dei metodi
21:44:25 < Stemby> usando i metodi stringa
21:44:28 < risca> buona idea
21:44:44 < Stemby> poi |Wolf| ci farà una bella lezione sui test
21:45:01 < Stemby> e poi... tisana e nanna
21:45:11 < risca> ^.^
21:45:12 < |Wolf|> "If it's not tested, it's broken." basta come lezione?
21:45:19 -!- JumX [~Mibbit@Azzurra=3515DFCC.246-95-r.retail.telecomitalia.it] has joined #debianizzati-corsi
21:45:24 < alnuvola> be mi piacerebbe imparare python 
21:45:34 < Stemby> alnuvola: a che punto sei?
21:45:40 < risca> purtroppo però io devo lasciarvi prima, la fidanzata mi aspetta...
21:45:45 [Users #debianizzati-corsi]
21:45:45 [ alnuvola] [ JumX ] [ spirit] [ |Wolf|] 
21:45:45 [ hoax    ] [ risca] [ Stemby] 
21:45:45 -!- Irssi: #debianizzati-corsi: Total of 7 nicks [0 ops, 0 halfops, 0 voices, 7 normal]
21:45:48 < alnuvola> da 0 a 10 
21:45:49 < alnuvola> 1
21:45:52 < Stemby> ok
21:45:57 < risca> allora sei ok
21:45:58 < Stemby> allora non correre troppo
21:46:08 < alnuvola> pero tempo fa programmavo in c
21:46:12 < alnuvola> e vb 
21:46:37 < Stemby> bon, visto che JumX è arrivato direi di partire
21:46:48 < alnuvola> ora sto vedendo il sito 
21:46:54 < JumX> Buonasera
21:47:17 < Stemby> metodo: avete già sentito questa parola?
21:47:30 < Stemby> alnuvola probabilmente no
21:47:37 < risca> no purtroppo
21:47:40 < spirit> chiamate a metodo?
21:47:43 < risca> (somma ignoranza mia)
21:48:08 < Stemby> è un concetto tipico della programmazione orientata agli oggetti
21:48:33 < Stemby> quindi chi programma in C++ o in Java sa già benissimo di che si tratta
21:48:58 < Stemby> in parole povere non è altro che una funzione che agisce su un oggetto
21:49:20 < Stemby> la sintassi in python è la seguente:
21:49:28 < Stemby> oggetto.metodo()
21:49:40 < Stemby> come vedete è molto simile a
21:49:43 < Stemby> funzione()
21:50:00 < Stemby> solo che il metodo agisce sull'oggetto precedente il punto
21:50:05 < Stemby> ok?
21:50:13 < spirit> ok
21:50:16 < Stemby> vediamo qualche esempio che è più semplice
21:51:02 < Stemby> mmm, la versione stabile è 3.2
21:51:13 < Stemby> noi stiamo tutti usando la 3.1, vero?
21:51:22 < risca> giusto
21:51:35 < risca> ma non penso avremo molti problemi in merito
21:51:40 < spirit> io la 3.1.3
21:51:47 < Stemby> non credo neanch'io
21:51:57 < Stemby> vabbé, continuamo ad usare la doc della 3.1
21:52:03 < |Wolf|> la 3.2 è uscita un paio di settimane fa
21:52:15 -!- amosse [~Mibbit@80.116.Azzurra=3EDE9B15] has joined #debianizzati-corsi
21:52:28 < amosse> Ciao a tutti
21:52:35 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#string-methods
21:52:40 < Stemby> ciao amosse
21:52:44 < Stemby> siamo appena partiti
21:52:45 < risca> ciao amosse abbiamo appena iniziato con i metodi
21:52:50 < spirit> ciao
21:52:55 < risca> vedi il link appena postato
21:52:58 < amosse> ok 
21:53:02 < amosse> ok
21:53:26 < Stemby> allora, iniziamo a vedere un po' di metodi inclusi nella libreria standard
21:53:35 < Stemby> quindi tutta roba già premasticata
21:53:45 < Stemby> che possiamo usare anche senza programmare a oggetti
21:54:12 < Stemby> come vedete esistono tantissimi metodi già pronti
21:54:20 < Stemby> che agiscono sulle stringhe
21:54:38 < Stemby> agiscono dunque su stringhe
21:54:41 -!- JumX [~Mibbit@Azzurra=3515DFCC.246-95-r.retail.telecomitalia.it] has quit [Quit: http://www.mibbit.com ajax IRC Client]
21:54:51 < Stemby> nella doc la stringa è indicata con str
21:54:55 < Stemby> chiaro, no?
21:55:02 < risca> sì
21:55:16 < amosse> ok
21:55:22 < Stemby> apriamo la shell
21:55:27 < Stemby> e facciamo qualche prova
21:55:30 < risca> >>> "ciaO belli".capitalize()
21:55:31 < risca> 'Ciao belli'
21:55:52 -!- JumX [~Mibbit@Azzurra=3515DFCC.246-95-r.retail.telecomitalia.it] has joined #debianizzati-corsi
21:56:00 < Stemby> amosse: ad esempio tu potresti fare quello che hai provato a fare col tuo script
21:56:09 < Stemby> amosse: hai visto la mia correzione?
21:56:14 < JumX> rieccomi Scusate 
21:56:27 < Stemby> (devi anche ringraziare |Wolf| che ha ulteriormente ripulito)
21:56:36 < amosse> no ho aperto solo ora il computer da ieri
21:56:51 < Stemby> allora guarda
21:56:57 < amosse> ok
21:56:59 < Stemby> anzi:
21:57:07 < Stemby> carico lo script su gobby
21:58:04 < Stemby> caricato
21:58:13 < Stemby> diamoci tutti un'occhiata
21:58:21 < risca> ok
21:58:41 < Stemby> per i nuovi:
21:58:49 < Stemby> aptitude install gobby
21:58:56 < Stemby> (o un altro client analogo)
21:59:10 < Stemby> server: stemby.dyndns.org
21:59:21 < amosse> ok
21:59:22 < Stemby> porta: 6522
22:05:00 < alnuvola> cosè gobby
22:05:39 < Stemby> risca: http://docs.python.org/release/3.1.3/library/stdtypes.html#truth-value-testing
22:05:51 < Stemby> alnuvola: un editor
22:06:04 < Stemby> che permette di lavorare in simultanea via internet
22:06:34 < Stemby> chi mi riassume come funziona if?
22:06:57 < Stemby> amosse: visto che hai capito, spiegalo a tutti
22:06:57 < amosse> ok
22:07:03 < Stemby> come funziona if?
22:07:36 < Stemby> lo faccio io...
22:07:43 < Stemby> if espressione:
22:07:46 < Stemby>     blocco
22:07:55 < Stemby> giusto?
22:08:11 < Stemby> se l'espressione è vera, il blocco viene eseguito
22:08:14 < Stemby> altrimenti no
22:08:15 < amosse> ok 
22:08:26 < Stemby> word è una stringa
22:08:42 < Stemby> se la stringa è vuota, l'espressione è falsa
22:08:54 < Stemby> (per il link che ho passato a risca poco sopra)
22:09:14 < Stemby> se invece contiene caratteri, il blocco viene eseguito
22:10:26 -!- AzzurraMibbit_701 [~Mibbit@82.84.Azzurra=493CE29E] has joined #debianizzati-corsi
22:11:20 < amosse> ora é più chiaro
22:11:49 -!- AzzurraMibbit_701 [~Mibbit@82.84.Azzurra=493CE29E] has left #debianizzati-corsi []
22:15:12 < Stemby> allora, lo script è semplice
22:15:20 < Stemby> funziona
22:15:26 < Stemby> ma è poco efficiente
22:15:36 < Stemby> a causa del concatenamento delle stringhe
22:15:51 < JumX> chiedo scusa l'editor che usate è geany?
22:15:57 < Stemby> gobby
22:16:02 < amosse> si
22:16:21 < Stemby> JumX: ma scusa, ci sei su gobby...
22:16:28 < JumX> si gobby l'ho capito intendevo l'edito per far eseguire lo script
22:16:39 < Stemby> ?
22:16:54 < Stemby> editor per eseguire lo script...
22:16:57 < Stemby> non capisco
22:17:08 < JumX> vai avanti non preoccuparti
22:17:17 < amosse> ti riferisci al crash?
22:17:19 < Stemby> l'editor serve per scrivere uno script
22:17:28 < Stemby> per eseguirlo si usa l'interprete
22:17:57 < JumX> e che interprete usare?
22:17:59 < Stemby> poi gli IDE possono invocare l'interprete anche dal loro interno, ma questo è un altro discorso
22:18:06 < Stemby> JumX: python3
22:18:11 < Stemby> versione 3.1
22:18:17 < JumX> questo da terminale
22:18:30 < Stemby> JumX: quello è l'interprete
22:18:52 < Stemby> forse è il momento di chiarire 'sta cosa...
22:19:09 < Stemby> è chiara la differenza tra linguaggio compilato e linguaggio interpretato?
22:19:15 < Stemby> (e le analogie)
22:19:29 < amosse> si può ridire?
22:19:33 < amosse> forse é meglio
22:19:47 < Stemby> ok
22:20:00 < Stemby> è un po' un discorso da lezione introduttiva, comunque...
22:20:17 < Stemby> linuaggio macchina: è chiaro cos'è?
22:20:53 < Stemby> chi tace acconsente
22:20:56 < amosse> ?
22:21:04 < Stemby> amosse: ?
22:21:14 < Stemby> *linguaggio
22:21:19 < amosse> non lo so esttamente
22:21:19 < spirit> per me no.
22:21:31 < Stemby> un po' più reattivi, please
22:21:37 < Stemby> altrimenti non vado più a nanna
22:21:39 < Stemby> allora
22:21:49 < Stemby> non è altro che una serie di 0 e di 1
22:22:04 < Stemby> che in pratica funzionano da interruttori
22:22:26 < Stemby> e modificano il funzionamento del processore
22:22:56 < Stemby> a seconda del codice che arriva al processore, questi modificherà il suo comportamento
22:23:08 < Stemby> e butterà fuori altri 0 e 1
22:23:28 < Stemby> grosso modo è così
22:23:36 < amosse> ok
22:23:39 < spirit> ok
22:24:01 < Stemby> quindi il codice macchina dipende innanzitutto dal processore utilizzato
22:24:23 < Stemby> un programma che funziona sul mio cellulare, non funziona sul mio pc
22:24:36 < Stemby> perché il processore è diverso
22:24:44 < amosse> ok
22:24:51 < spirit> ok
22:25:00 < Stemby> e quindi per fare una stessa cosa, la sequenza di 0 e 1 sarà diversa
22:25:11 < Stemby> quello è il codice macchina
22:25:30 < Stemby> ma nessuno programma più in codice macchina da almeno 60 anni
22:26:54 < risca> dai, qualche hobbysta c'è ancora secondo me
22:27:15 < amosse> ok 
22:27:16 < Stemby> http://it.wikipedia.org/wiki/Assembly
22:27:30 < Stemby> il linguaggio a più basso livello che si usi oggigiorno è questo
22:27:47 < Stemby> in realtà pochissimi programmano in assembly
22:27:58 < Stemby> perché?
22:28:04 < Stemby> perché non è portabile
22:28:15 < Stemby> ogni processore ha il suo assembly
22:28:33 < Stemby> quindi il programma che gira su x86, non girerà su ARM
22:28:50 < spirit> chi progetta intel usa assembly?
22:28:56 < Stemby> ?
22:29:17 < spirit> cioè
22:29:39 < Stemby> assembly oggigiorno si usa praticamente solo su dispositivi embedded moooolto limitati
22:29:46 < Stemby> (microcontrollori)
22:30:05 < amosse> ok
22:30:08 < Stemby> ma anche lì ormai si usa più che altro il C
22:30:11 < spirit> ok
22:30:13 < risca> ragazzi, purtroppo devo andare... leggo il log appena torno!
22:30:17 < risca> buon lavoro a tutti
22:30:23 < Stemby> ciao risca
22:30:28 < spirit> ciao 
22:30:29 < amosse> ciao risca 
22:30:53 < Stemby> dicevo
22:31:06 < alnuvola> ragazzi allora metto l autojoi sul canale 
22:31:11 < alnuvola> cosi impariamo paython 
22:31:12 < alnuvola> .d
22:31:45 < Stemby> l'assembly è molto simile al linguaggio macchina
22:32:04 < Stemby> è sostanzialmente la stessa cosa, ma scritta in un modo... leggibile
22:32:23 < amosse> ok
22:32:31 < Stemby> per passare dall'assembly al codice macchina, si usa un compilatore
22:32:45 < Stemby> stessa cosa per tutti i linguaggi compilati
22:33:01 < Stemby> il linguaggio di alto livello di più basso livello è il C
22:33:15 < Stemby> è chiaro il concetto di livello?
22:33:15 < alnuvola> scusate ma io ho paython come faccio a mettere pathon3
22:33:32 < Stemby> amosse: aptitude install python3
22:33:35 < Stemby> e poi
22:33:40 < Stemby> python3
22:33:55 < Stemby> è chiaro il concetto di livello?
22:34:06 < Stemby> alto livello/basso livello
22:34:12 < spirit> più o meno
22:34:13 < amosse> si
22:34:21 < Stemby> amosse: spiega
22:35:05 < amosse> praticamente un linguaggio si dice di alto livello, tanto più vicino é al linguaggio umano
22:35:11 < Stemby> ok
22:35:11 < alnuvola> ragazzi io vado  buonanotte 
22:35:22 < amosse> quindi tanto più distante é dal linguaggio macchina
22:35:28 < Stemby> esatto
22:35:37 < spirit> bel concetto
22:35:38 -!- alnuvola [~alex@Azzurra=68BD88FB.cust.dsl.teletu.it] has quit [Client closed connection]
22:35:39 < Stemby> è il "livello di astrazione"
22:35:58 < Stemby> vantaggi e svantaggi
22:36:38 < Stemby> linguaggio di basso livello:
22:36:43 < Stemby> è altamente performante
22:36:51 < Stemby> l'hardware viene usato al meglio
22:36:58 < amosse> mi assento 5 min
22:37:04 < Stemby> ogni ciclo viene spremuto per tutto quello che può dare
22:37:15 < Stemby> solo che la programmazione è difficilissima
22:37:23 < Stemby> ogni cavolata fa sputare sangue
22:37:36 < Stemby> proprio perché si deve ragionare come una macchina
22:37:50 < Stemby> è più simile all'elettronica che all'informatica come la si intende oggi
22:37:59 < Stemby> linguaggio di alto livello:
22:38:04 < Stemby> programmazione semplice
22:38:09 < Stemby> programmi portabilo
22:38:13 < Stemby> *portabili
22:38:24 < Stemby> scrivi una volta, usi ovunqur
22:38:28 < Stemby> *ovunque
22:38:37 < Stemby> hai un sacco di cose già pronte
22:38:44 < Stemby> scrivi come in inglese o quasi
22:38:54 < Stemby> ok?
22:39:05 < spirit> ok 
22:39:14 < Stemby> il python è un linguaggio di altissimissimo livello
22:39:26 < Stemby> (è decisamente il linguaggio di più alto livello che conosca)
22:39:34 < Stemby> prestazioni schifoselle
22:39:41 < Stemby> ma tutto il resto è una goduria
22:40:05 < Stemby> NON è un linguaggio compilato
22:40:09 < JumX> quindi scusa, lo stesso script funziona anche su windows?
22:40:09 < spirit> bello anche lo zen python
22:40:17 < Stemby> JumX: certo!
22:40:27 < Stemby> JumX: anche su Mac
22:40:38 < JumX> senza cambiare nulla perchè python non va compilato giusto?
22:40:43 < Stemby> o su qualsiasi altro sistema operativo su cui giri python
22:40:59 < Stemby> JumX: sì
22:41:02 < Stemby> più o meno
22:41:04 < amosse> perché schifoselle prestazioni? 
22:41:05 < Stemby> nel senso:
22:41:27 < Stemby> lo script se è scritto come si deve gira ovunque
22:41:36 < Stemby> ovviamente devi avere l'interprete installato
22:41:50 < Stemby> (compilato per quel sistema operativo e per quella architettura)
22:42:11 < Stemby> ovvero: se install python3 su win, poi i tuoi script ci girano sensa problemi
22:42:19 < Stemby> amosse: perché è lento
22:42:22 < Stemby> per 2 ragioni
22:42:34 < Stemby> 1) è di altissimo livello
22:42:41 < Stemby> 2) non è compilato
22:42:52 < Stemby> in realtà le prestazioni non sono nemmeno pessime
22:43:05 < Stemby> (tanto dipende dalla qualità del codice che si scrive)
22:43:15 < Stemby> perché comunque python è scritto in C
22:44:01 < amosse> quindi un buono script può essere veloce come in C?
22:44:10 < Stemby> no
22:44:29 < Stemby> uno script in C sarà sempre di gran lunga più veloce
22:44:41 < Stemby> "script" non si dovrebbe dire
22:44:50 < Stemby> perché C è un linguaggio compilato
22:44:58 < spirit> ma C è a livello Python?
22:45:08 < Stemby> diciamo: un programma in C sarà sempre molto più veloce dell'analogo in python
22:45:16 < spirit> ok
22:45:28 < amosse> una domanda, come mai Java é il più usato?
22:45:30 < Stemby> ma probabilmente richiederà 10 volte il tempo necessario per realizzarlo
22:45:47 < Stemby> amosse: è più veloce
22:45:54 < Stemby> è più antico
22:46:03 < amosse> più del C?
22:46:06 < Stemby> è comunque libero
22:46:08 < |Wolf|> Simplicity is a great virtue but it requires hard work to achieve it and education to appreciate it. And to make matters worse: complexity sells better.
22:46:10 < Stemby> amosse: noooo
22:46:20 < Stemby> più del python
22:46:23 < |Wolf|> python è più vecchio di java
22:46:31 < Stemby> più del C c'è solo l'assembly
22:46:40 < Stemby> |Wolf|: più o meno
22:46:48 < Stemby> diciamo che è più vecchio come anni
22:46:55 < Stemby> ma il Java è popolare da sempre
22:46:56 < |Wolf|> 91 vs 94 iirc
22:47:09 < Stemby> mentre il python è popolare da una decina d'anni
22:47:32 < Stemby> quindi sostanziamente il Java è come se fosse più antico
22:47:45 < amosse> ok
22:48:12 < |Wolf|> c'era un articolo figo che spiegava perché java era popolare
22:48:27 < |Wolf|> quello che ho pastato su lo riassume quasi
22:48:38 < Stemby> comunque python ha avuto un boom
22:49:09 < amosse> una domanda:
22:49:17 < |Wolf|> http://www.paulgraham.com/icad.html
22:49:35 < |Wolf|> "The pointy-haired boss has no idea how this software has to work, and can't tell one programming language from another, and yet he knows what language you should write it in. Exactly. He thinks you should write it in Java."
22:49:35 < |Wolf|> gh
22:49:37 < Stemby> http://forum.debianizzati.org/viewtopic.php?f=60&t=43002
22:49:50 < amosse> per fare girare un script python su url, in che dir va copiato /usr/www.....
22:50:36 < Stemby> amosse: non ho capito
22:50:52 < Stemby> comunque stavamo disquisendo sui vari linguaggi
22:51:20 < amosse> scusa continua pure
22:51:25 < Stemby> abbiamo visto alto livello / basso livello
22:51:41 < Stemby> ora vediamo compilato / interpretato
22:52:15 < Stemby> un linguaggio compilato è un linguaggio che viene trasformato in linguaggio macchina da un programma chiamato compilatore
22:52:35 < Stemby> scrivo il programma nel mio linguaggio (C, ad esempio)
22:52:46 < Stemby> usando un editor di testo
22:52:47 < Stemby> salvo
22:52:55 < Stemby> copilo il programma
22:53:03 < Stemby> ottengo un file binario
22:53:08 < |Wolf|> io mi sa che stacco
22:53:13 < Stemby> (i famosi 0 e 1)
22:53:20 < Stemby> ciao |Wolf|
22:53:27 < spirit> Ciao
22:53:40 < |Wolf|> buon proseguimento
22:53:43 < Stemby> il file binario è il programma da eseguire
22:54:18 < Stemby> un linguaggio interpretato invece si appoggia ad un interprete
22:54:23 < Stemby> cos'è un interprete?
22:54:50 < Stemby> è un programma che trasforma "in diretta" il sorgente in linguaggio macchina
22:55:23 < Stemby> vantaggi: si può modificare il programma e provarlo man mano
22:55:33 < Stemby> senza dover aspettare la fine della copilazione
22:55:52 < Stemby> svantaggi: il programma è meno performante
22:56:21 < Stemby> Java e Python sono una via di mezzo
22:56:29 < Stemby> non sono né compilati né interpretati
22:56:42 < Stemby> Java è più vicino ad un linguaggio compilato
22:56:57 < Stemby> Python è più vicino ad un linguaggio interpretato
22:57:14 < Stemby> entrambi in realtà sono compilati in bytecode
22:57:36 < Stemby> ovvero: il codice sorgente viene trasformato in bytecode
22:57:52 < Stemby> il bytecode è una sorta di codice macchina
22:58:01 < Stemby> ma non per il processore
22:58:07 < Stemby> ma per una macchina virtuale
22:58:26 < Stemby> la macchina virtuale è da installare sul computer
22:58:50 < Stemby> nel caso del python è... python stesso
22:59:06 < Stemby> nel caso di Java, ci sono varie macchine disponibili
22:59:25 < Stemby> (GNU, quella ufficiale della Sun, ecc)
22:59:51 < Stemby> perché dicevo che python è più simile ad un linguaggio interpretato?
23:00:06 < Stemby> perché non avremo mai a che fare con un compilatore
23:00:26 < Stemby> il bytecode viene ottenuto automaticamente
23:00:33 < Stemby> senza che ce ne accorgiamo
23:00:47 < spirit> ok
23:00:53 < Stemby> se avete provato import, vi sarete accorti che viene generato un file .pyc
23:00:59 < Stemby> l'avete notato?
23:01:08 < spirit> no
23:01:36 < Stemby> aptite la shell
23:01:50 < amosse> ci siete?
23:01:54 < Stemby> importate un modulo che avete nella directory corrente
23:02:01 < Stemby> amosse: ?
23:02:19 < Stemby> poi uscite dalla shell
23:02:32 < Stemby> controllate in quella directory
23:02:42 < Stemby> vedrete che c'è ora un file .pyc
23:02:46 < Stemby> oltre al .py
23:02:54 < Stemby> fatto?
23:03:33 < Stemby> ci siete?
23:03:37 < Stemby> amosse?
23:03:41 < Stemby> JumX?
23:03:44 < Stemby> spirit?
23:03:52 < spirit> import sys ma non c'è..
23:04:03 < Stemby> spirit: sys non è nella direcroty corrente
23:04:11 < Stemby> importa un tuo modulo
23:04:17 < Stemby> tipo quello di stasera
23:04:24 < Stemby> import amosse
23:04:49 < Stemby> spirit: dove hai salvato amosse.py?
23:04:57 -!- amosse [~Mibbit@80.116.Azzurra=3EDE9B15] has quit [Quit: http://www.mibbit.com ajax IRC Client]
23:05:00 < spirit> in una usb
23:05:11 < Stemby> ok, mettiti in quella directory
23:05:12 < spirit> perchè ho formattato ...
23:05:26 < Stemby> cd /media/quelchelè
23:05:36 < Stemby> python3
23:05:39 < spirit> aspetta che provo
23:05:40 < Stemby> import amosse
23:05:49 < Stemby> Ctrl+D
23:05:52 < Stemby> ls
23:06:14 < Stemby> e vedrai che ora, oltre ad amosse.py, ci sarà anche amosse.pyc
23:07:09 < Stemby> fatto?
23:07:47 < spirit> no
23:07:59 < Stemby> perché?
23:08:29 < spirit> aspetta..
23:08:35 < Stemby> JumX: tu ci sei?
23:09:28 -!- amos [~Mibbit@Azzurra=5FF7AC3A.116-80-r.retail.telecomitalia.it] has joined #debianizzati-corsi
23:09:38 < Stemby> ciao amos
23:09:50 < Stemby> sei un alter ego di amosse?
23:09:51 < amos> non funzionava più azzurra
23:10:05 < amos> sono amosse
23:10:16 < Stemby> ok
23:10:30 < Stemby> ce l'hai fatta ad importare un tuo modilo?
23:10:34 < Stemby> *modulo
23:10:55 < amos> quale modulo?
23:11:10 < Stemby> quello che vuoi
23:11:10 < spirit> ho il file .pyc
23:11:16 < Stemby> ottimo spirit
23:11:23 < Stemby> JumX l'abbiamo perso
23:11:28 < Stemby> vediamo di recuperare amos
23:11:52 < amos> scusate ma credo ci siano problemi con azzurra
23:11:53 < Stemby> amos: ad esempio, importa quello di stasera
23:12:09 < Stemby> amos: mi leggi?
23:12:20 < amos> si
23:12:23 < Stemby> ok
23:12:28 < amos> su terminale?
23:12:31 < Stemby> sì
23:12:35 < Stemby> import amosse
23:12:42 < Stemby> nella shell interattiva
23:12:46 < amos> ok
23:13:19 < Stemby> ls
23:13:30 < Stemby> vedrai ce c'è un file amosse.pyc
23:13:38 -!- f0rbid [~nnscript@Azzurra-7851F1D7.21-87-r.retail.telecomitalia.it] has joined #debianizzati-corsi
23:13:46 < f0rbid> sera
23:13:47 < Stemby> quello è il famoso bytecode
23:13:51 < f0rbid> vi leggo volentieri ;)
23:13:51 < Stemby> ciao f0rbid
23:14:03 < amos> ciao
23:14:03 < amos> ok
23:14:29 < Stemby> quando noi eseguiamo un modulo, il bytecode viene generato in diretta
23:15:01 < Stemby> però quando il modulo viene importato, il bytecode viene salvato in un file
23:15:23 < Stemby> in questo modo, se il modulo non viene modificato, il bytecode può essere riutilizzato
23:15:40 < spirit> ok
23:15:46 < Stemby> il bytecode è più veloce del sorgente, ovviamente
23:16:00 < amos> ok
23:16:01 < Stemby> e può essere letto direttamente dalla macchina virtuale
23:16:07 < Stemby> su qualsiasi sistema
23:16:13 < Stemby> e su qualsiasi architettura
23:16:44 < Stemby> inoltre (è una cosa che non si dovrebbe dire...), ha delle caratteristiche simili al codice macchina
23:16:58 < Stemby> tra cui la difficoltà nel leggerlo e modificarlo
23:17:20 < amos> quindi il bytecode come é definito?
23:17:22 < Stemby> (quindi può essere sfruttato per distribuire un'applicazione closed scritta in python)
23:17:31 < Stemby> amos: in che senso?
23:17:48 < amos> import amosse (importo il modulo amosse)
23:17:50 < amos> giousto?
23:17:55 < Stemby> sì
23:18:17 < Stemby> quando importi un modulo, per prima cosa viene eseguito
23:18:20 < amos> come si arriva aol bytecode?
23:18:33 < Stemby> lo fa automaticamente l'interprete python
23:18:44 < Stemby> in realtà lo fa sempre
23:18:52 < Stemby> solo che in genere non ci si accorge
23:18:56 < Stemby> anche quando scrivi
23:19:00 < Stemby> >>> 1 + 2
23:19:15 < Stemby> lui trasforma quell'espressione in bytecode
23:19:24 < Stemby> e la legge con la macchina virtuale
23:19:37 < Stemby> la quale poi ti restituisce un risultato
23:19:50 < spirit> ok
23:20:15 < amos> scusate, forse passo dipalo in frasca
23:20:31 < amos> modulo = insieme di funzioni
23:20:33 < Stemby> dal punto di vista del programmatore è comunque sostanzialmente come programmare in un linguaggio interpretato
23:20:37 < Stemby> amos: no
23:20:47 < Stemby> modulo = tutto il file .py
23:20:54 < Stemby> con tutto il suo contenuto
23:21:01 < amos> ok 
23:21:13 < amos> e classe?
23:21:15 < Stemby> funzioni, classi, metodi, chiamate a funzione, ecc.
23:21:36 < Stemby> classe è una roba che vedremo con la programmazione orientata agli oggetti
23:21:49 < amos> e libreria?
23:22:00 < Stemby> libreria è una raccolta di funzioni
23:22:06 < amos> ok
23:22:36 < Stemby> bon
23:22:55 < Stemby> ci sono ancora dubbi?
23:23:26 < Stemby> allora, ora vediamo come sostituire amosse.py con una riga di python
23:23:41 < Stemby> (ottenendo anche prestazioni di gran lunga migliori)
23:24:14 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#string-methods
23:24:19 < Stemby> stavamo vedendo questi
23:24:31 < Stemby> metodo str.split()
23:24:49 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#str.split
23:25:00 < Stemby> è ciò che ha cercato di fare amosse
23:25:31 < amos> incredibile esiste la funzione...
23:25:34 < amos> !
23:25:47 < Stemby> >>> ' a che ora  sei   rientrato ieri?    '.split()
23:25:47 < Stemby> ['a', 'che', 'ora', 'sei', 'rientrato', 'ieri?']
23:25:52 < Stemby> amos: è un metodo
23:26:00 < Stemby> non una funzione
23:26:08 < Stemby> (il concetto è simile)
23:26:35 < amos> scusa un metodo non é una funzione applicata ad un oggetto?
23:26:40 < Stemby> sì
23:26:45 < Stemby> questo è il caso
23:26:51 < Stemby> l'oggetto è la stringa
23:26:53 < amos> ok
23:27:43 < Stemby> ecco ciò che si chiama linguaggio ad altissimisssimisssssssimo livello
23:27:57 < Stemby> _tutto_ è già pronto
23:28:14 < Stemby> la difficoltà sta solo nel trovare il pezzo che ci serve
23:28:35 < Stemby> al contrario un linguaggio di basso livello ha pochissimi costrutti
23:28:55 < Stemby> il C, se lo si studia, lo si conosce _tutto_ a mendadito
23:29:03 < Stemby> son 4 cose in croce
23:29:17 < Stemby> solo che poi si sputa l'anima per fare qualunque cosa
23:29:27 < Stemby> (non ci sono nemmeno le stringhe...)
23:29:58 < amos> perché non da niente help(split) , al contrario di help(print)?
23:30:11 < Stemby> perché split non è una funzione
23:30:36 < amos> non c'è l'help per i metodi
23:30:40 < Stemby> split() non esiste
23:30:45 < Stemby> non lo so
23:30:47 < Stemby> non credo
23:31:04 < Stemby> |Wolf|: sai aiutare amos?
23:31:29 < spirit> help(str.split).
23:32:09 < Stemby> bravo spirit
23:32:18 < spirit> garzie
23:32:20 < amos> ok spirit 
23:32:23 < spirit> *grazie
23:32:51 < JumX> Scusate ma come esco dall'help?
23:32:58 < Stemby> q
23:33:00 < spirit> q
23:33:18 < Stemby> JumX: mi sa che non frequenti molto le manpage...
23:33:35 < Stemby> come esco da man man?
23:33:37 < Stemby> :p
23:33:54 < amos> posso fare una domanda?
23:34:00 < Stemby> amos: certo
23:34:28 < JumX> ok si hai ragione mi scuso ma stasera ho molte distrazioni .:D
23:34:44 < amos> in php uno script che voglio far girare in localhost lo salvo in /var/www, ed in python?
23:35:05 < Stemby> dove vuoi
23:35:30 < Stemby> se lo rendi eseguibile
23:35:40 < Stemby> chmod u+x modulo.py
23:36:03 < Stemby> e lo cacci in una dir che fa parte di $PATH
23:36:09 < Stemby> (o lo linki)
23:36:16 < amos> quindi per far girare amos.py in localhost lo posso salvare in home
23:36:18 < Stemby> è eseguibile ovunque
23:36:37 < Stemby> amos: un attimo
23:36:43 < amos> e poi http://localhost/amos.py
23:36:46 < JumX> Scusa stemby puoi spiegare meglio come rendere un file .py eseguibile?
23:36:49 < amos> ?
23:36:55 < Stemby> amos: no
23:37:06 < Stemby> quello che vuoi fare è una webapp
23:37:10 < Stemby> un attimo
23:37:18 < amos> esatto
23:37:26 < Stemby> JumX: in unix è eseguibile... ciò che è eseguibile
23:37:47 < Stemby> come si fa a rendere una cosa eseguibile?
23:37:55 < Stemby> si danno i permessi di esecuzione
23:38:00 < Stemby> man chmod
23:38:10 < amos> chmod 755?
23:38:23 < JumX> si ma il chmod lo digito all'interno dell'interprete o basta solo dal terminale
23:38:41 < Stemby> JumX: chmod fa parte del sistema operativo
23:38:47 < Stemby> non c'entra niente con pyton
23:38:52 < Stemby> *python
23:38:56 < JumX> faccio una prova
23:39:09 < amos> serve per cambiare i permessi al file .py
23:39:16 < Stemby> esatto
23:39:23 < Stemby> ls -l *.py
23:39:34 < Stemby> e controlli i permessi di tutti i tuoi moduli
23:39:36 < Stemby> man ls
23:39:40 < Stemby> per i dettagli
23:40:07 < Stemby> se non c'è la x, non è eseguibile
23:40:33 < Stemby> -rwxr--r-- 1 carlo carlo 1070  9 mar 18.56 amosse.py
23:40:41 < Stemby> questo è eseguibile dall'utente
23:40:58 < Stemby> (x nella prima tripletta)
23:41:14 < amos> root
23:41:20 < Stemby> amos: no
23:41:22 < Stemby> carlo
23:41:29 < Stemby> (il proprietario è carlo)
23:41:50 < amos> scusa é vero
23:41:55 < Stemby> (poi root può eseguirlo, ovviamente)
23:41:57 < amos> una cavolata
23:42:05 < amos> ok
23:42:29 < JumX> Scusate ma non ho capito :( 
23:42:34 < Stemby> mmmm
23:42:34 < JumX> @lmde ~/Scrivania/CorsoPython $ chmod u+x trovapepita.py
23:42:49 < Stemby> ls -l trovapepita.py
23:43:31 < Stemby> JumX: ↑
23:43:48 < JumX> ls -|  o chmod ?
23:43:59 < Stemby> ls menoelle
23:44:05 < Stemby> è una elle
23:44:07 < Stemby> non |
23:44:09 < Stemby> ma l
23:44:23 < JumX> provo
23:44:38 < Stemby> JumX: comunque tutto ciò c'entra poco/niente con python
23:44:46 < Stemby> sono le basi di unix
23:45:31 < JumX> ls-ltrovapepita.py: command not found
23:45:39 < Stemby> spazio
23:45:51 < Stemby> ls -l trovapepita.py
23:45:54 < JumX> ho provato anche con spazio.
23:46:04 < Stemby> fai un copiaincolla
23:46:10 < Stemby> hai trascritto male...
23:46:10 < JumX> ok
23:47:12 < amos> quindi si può usare python per delle web application?
23:47:26 < JumX> -rwx------ 1 Jumx JumX 4642 27 feb 22.39 trovapepita.py
23:47:28 < Stemby> amos: sì
23:47:33 < Stemby> JumX: esatto
23:47:37 < Stemby> è eseguibile
23:47:43 < Stemby> dall'utente Jumx
23:47:52 < Stemby> (x nella prima tripletta)
23:47:56 < JumX> e adesso come lo eseguo?
23:48:04 < Stemby> ./trovapepita.py
23:48:45 < Stemby> oppure se lo cacci in una directory compresa nella variabile PATH, basta
23:48:50 < Stemby> trovapepita.py
23:48:59 < Stemby> (meglio linkare, secondo me)
23:49:03 < JumX> ok ci sono riuscito ma il dubbio mi è rimasto chmod lo devo sempre fare ?
23:49:15 < Stemby> per dare i permessi di esecuzione
23:49:23 < Stemby> altrimenti il file non è eseguibile
23:49:38 < Stemby> però puoi eseguirlo lo stesso dandolo direttamente in pasto a python
23:49:45 < Stemby> python3 trovapepita.py
23:49:45 < JumX> ma ls -l ache serve allora
23:50:00 < Stemby> ls -l serve a verificare i permessi
23:50:48 < spirit> già in unix è importante.
23:51:21 < Stemby> bon, sono cottino
23:51:30 < Stemby> divertitevi con i metodi stringa
23:51:41 < Stemby> la prossima volta vediamo un po' bene le liste
23:51:48 < Stemby> leggete il capitolo 6 del libro
23:51:56 < Stemby> (è lunghetto, ma semplice)
23:51:58 < JumX> Grazie Stemby per la pazienza 
23:52:04 < Stemby> il 5 non era un problema, no?
23:52:10 < Stemby> era corto e banale
23:52:50 < spirit> io li sto studiando in questi giorni
23:52:59 < Stemby> ok
23:53:01 < Stemby> notte
23:53:12 < spirit> Grazie 'notte.
23:53:21 -!- spirit [~spirit@Azzurra-C3C291C.104-82-b.business.telecomitalia.it] has quit [Quit: leaving]
23:53:28 < amos> Grazie 
23:53:30 < JumX> Domenica come mai è saltato l'incontro ? 
23:53:32 < amos> Ciao a tutti
23:53:38 < Stemby> JumX: io ero malato
23:53:40 < JumX> Ciao amos
23:53:45 < Stemby> nessuno mi ha sostituito...
23:53:52 < JumX> eh no 
23:54:10 < amos> se avete bisogno di un mano, anche per cose semplici....
23:54:26 < JumX> compiti per il prossimo incontro ?
23:54:33 < Stemby> capitolo 6
23:54:35 < amos> che so
23:54:44 < Stemby> e fate pratica con i metodi stringa
23:55:00 < Stemby> o inventatevi problemi da risolvere
23:55:07 < Stemby> e postate le vostre soluzioni
23:55:19 < amos> ok
23:56:12 < Stemby> amos: comuque, riguardo alle webapp
23:56:24 < Stemby> io non ho esperienza, ma la cosa mi interessa
23:56:35 < amos> esatto?
23:56:40 < Stemby> per fare una webapp serve un server web
23:56:50 < amos> io avevo iniziato con php
23:56:51 < Stemby> per php di solito si usa apache
23:56:56 < amos> apache
23:57:00 < amos> esatto
23:57:02 < Stemby> php è un linguaggio
23:57:08 < Stemby> il webserver è apache
23:57:09 < amos> ma anche con perl
23:57:12 < Stemby> anche
23:57:21 < amos> esatto
23:57:33 < Stemby> da quel che ho letto ora apache gestisce benissimo anche python
23:57:40 < Stemby> prova a googlare
23:57:49 < Stemby> un tempo si usava CGI
23:57:56 < Stemby> ma è poco performante
23:58:06 < amos> certo, poi se trovo ti dico...
23:58:06 < Stemby> ma è comunque una strata usabile
23:58:06 < JumX> Vabbè raga buonanotte a domenica
23:58:18 < amos> notte
23:58:24 < Stemby> comunque io proverei con apache
23:58:24 < JumX> note
23:58:30 -!- JumX [~Mibbit@Azzurra=3515DFCC.246-95-r.retail.telecomitalia.it] has left #debianizzati-corsi []
23:58:33 < Stemby> configurato per macinare python
23:58:35 < amos> é il futuro
23:58:50 < amos> cerco qualcosa
23:59:01 < Stemby> in alternativa si può creare un webserver direttamente con python
23:59:05 < Stemby> io l'avevo fatto
23:59:12 < Stemby> son 4 righe in croce di codice
23:59:24 < Stemby> per una cosa al volo è comodo
23:59:28 < amos> ah pensavo fosse un casino
23:59:50 < amos> io volevo fare un piccolo gestionale
23:59:53 < Stemby> e lì le prestazioni sono eccellenti
23:59:55 < amos> avevo già iniziato in php ma poi mi sono arenato
00:00:13 < Stemby> perché il web server è tutt'uno con l'applicazione
00:00:35 < amos> interessante
00:00:45 < Stemby> queste sono le 2 strade
00:00:54 < amos> tu sei un programmatore?
00:00:57 < Stemby> no
00:01:00 < Stemby> dilettante
00:01:18 < amos> bravo, ne sai di cose
00:01:49 < amos> anche io chiaramente
00:03:10 < amos> ti lascio perché immagino che sei stanco, grazie della lezione
00:05:05 < amos> Buona notte
00:05:13 < Stemby> notte