Accademia:Log 2011 02 16

[21:24:38] <Stemby> cia f0rbid
[21:24:56] <f0rbid> ciao
[21:24:59] <f0rbid> vi leggo volentieri
[21:25:52] <Stemby> non esitare neanche a domandare, eh!
[21:26:14] <Stemby> intanto: gobby l'avete installato tutti?
[21:27:10] --> JumX (~Mibbit@95.234.Azzurra=AE341FA) has joined #debianizzati-corsi
[21:28:25] <Stemby> ripeto: gobby l'avete installato tutti?
[21:29:17] <JumX> si
[21:29:51] <f0rbid> Stemby siccome non vi leggo in real-time si puo' sostare per sola lettura senza interagire? Senno' parto al volo per non creare disturbi ;)
[21:30:29] <Stemby> ma non disturbi mica, eh!
[21:30:32] <GipPasso> f0rbid: che disturbi puoi creare se leggi?!?
[21:30:33] <Stemby> siam qui per questo
[21:30:38] <f0rbid> ;)
[21:31:05] <GipPasso> Anch'io sto litigando con i motori di ricerca per trovare una libreria per plot in python3.
[21:31:17] --> Ernestus (~ernesto@Azzurra-34FAD62E.25-79-r.retail.telecomitalia.it) has joined #debianizzati-corsi
[21:31:30] <JumX> Ciao Stemby non riesco a collegarmi con gobby i parametri sono sempre gli stessi ( risca.no-ip.info ) ?
[21:31:31] <Ernestus> buona sera pitony
[21:31:33] <GipPasso> Sto facendo i salti mortali per non dovermi imparare anche python2 e non usare nulla che lo usi (e in almeno un caso fallisco).
[21:31:39] <Stemby> JumX: no
[21:31:47] <JumX> Buonasera ernestus
[21:32:12] <Stemby> GipPasso: difficile (impossibile, direi) far a meno di py2, al momento
[21:32:25] <JumX> Stemby puoi comunicare i parametri . Grazie
[21:32:25] <Stemby> ma non è un grosso problema passare dall'uno all'altro
[21:32:31] <Stemby> JumX: un secondo
[21:32:42] <JumX> ok
[21:32:47] <GipPasso> Gobby o gobby-0.5?
[21:33:06] <Stemby> gobby
[21:33:16] <Ernestus> cosa cambia?
[21:33:23] <GipPasso> Stemby: ti ringrazio dell'incoraggiamento. Sto solo cercando di ridurre al minimo i pezzy py2.
[21:33:31] <GipPasso> Ernestus:  non sono compatibili.
[21:34:10] <GipPasso> Stemby: se dovessi fare qualcosa di grosso, scientificamente parlando, non potrei desimermi dall'immergermi in scipy (solo py2) e matplotlib.
[21:34:17] <Ernestus> grazie GipPasso ho installato gobby
[21:34:48] <-- risca (~risca@Azzurra=4ED2A8FC.clienti.tiscali.it) has quit (Ping timeout)
[21:34:51] <GipPasso> Scrivendo io l'intera libreria che fa (forse farà, almeno spero, entro non troppo) quello che mi serve, mi posso un po' basare su quello che voglio.
[21:35:10] <GipPasso> Ho trovato pyla, che ha una parte per gnuplot. È puro py3k, ma ancora alpha.
[21:35:26] <Stemby> allora, parametri per gobby:
[21:35:37] <Stemby> URL: stemby.dyndns.org
[21:35:49] <Stemby> porta: 6522
[21:35:58] <GipPasso> Ernestus: sì, penso che metterò anch'io gobby. Scusate, ma sono su un fisso dei miei. Da un po' cambio pc a ogni connessione (mannaggia a me che ho lasciato l'alimentatore del portatile in montagna!)
[21:37:01] <GipPasso> Stemby: datemi il minuto per installare e arrivo.
[21:37:30] <JumX> Ai ai come ti capisco... è capitato anche a me.
[21:37:36] <Stemby> aspettiamo ancora 5 minuti per i ritardatari
[21:38:27] <Ernestus> quindi la lezione sarà interamente su gobby?
[21:38:41] <Stemby> no, direi solo qualcosina
[21:39:04] <Stemby> il grosso lo faremo in modalità interattiva
[21:40:37] <GipPasso> Per la parte interattiva si chiacchiera qui e ognuno scrive le sue cose sul suo terminale?
[21:40:44] --> spirit_ (~spirit@Azzurra-C3C291C.104-82-b.business.telecomitalia.it) has joined #debianizzati-corsi
[21:41:02] <GipPasso> Intanto che aspettiamo, può servire un terminale con uno screen per condividere la sessione?
[21:41:38] --> NoxDaFox (~nox@Azzurra=1F33399E.243-28.fastweb.fw) has joined #debianizzati-corsi
[21:41:57] <Stemby> GipPasso: la prima
[21:42:06] <Stemby> no, per ora non ne abbiamo avuto bisogno
[21:42:20] <Stemby> ok, dai, 2 minuti e partiamo
[21:42:51] <-- spirit_ (~spirit@Azzurra-C3C291C.104-82-b.business.telecomitalia.it) has quit (Quit: leaving)
[21:42:53] <GipPasso> Stemby: bene, grazie.
[21:43:54] <Stemby> andiamo
[21:44:00] <Stemby> ci siam tutti?
[21:44:25] <Stemby> Primo argomento della serata: LE FUNZIONI
[21:44:38] <Stemby> cos'è una funzione?
[21:45:30] <Stemby> ...è una legge che associa ogni elemento di A ad uno e un solo elemento di B
[21:45:33] <Stemby> no :)
[21:45:36] <Stemby> non in matematica
[21:45:41] <Stemby> in informatica
[21:45:50] <Stemby> nessuno ha un'idea?
[21:46:03] <GipPasso> Stemby: ...mi freghi anche le battute che ho solo appena pensato?!?! :-P
[21:46:24] <GipPasso> Una routine, un pezzo di codice che può prendere degli argomenti
[21:46:39] <Stemby> sì, routine è un sinonimo
[21:46:41] <GipPasso> (ma non è necessario) e che fa una serie di operazioni.
[21:46:53] <GipPasso> Stemby: lo sospettavo.
[21:46:57] <Stemby> e in effetti è più intuitivo, come termine
[21:47:21] <Stemby> in certi linguaggi si parla di (sub)routine, in altri di procedure, ecc.
[21:47:31] <Stemby> sempre della stessa roba si tratta
[21:47:35] <GipPasso> Diciamo così: un pezzo di codice che può essere richiamato sinteticamente richiamando la funzione anzi che riscriverlo interamente.
[21:47:43] <Stemby> è proprio quello che dice GipPasso:
[21:48:05] <Stemby> è una serie di ISTRUZIONI che svolgono un compito preciso
[21:48:24] <Stemby> che vantaggi ci sono ad utilizzarli?
[21:48:28] <Stemby> sono molteplici
[21:48:39] <Stemby> innanzitutto, il codice diventa più chiaro
[21:48:54] --> risca (~risca@Azzurra=A0C88C1.clienti.tiscali.it) has joined #debianizzati-corsi
[21:49:00] <Stemby> il nome stesso della funzione aiuta (se scelto con cura) a chiarire cosa si vuol fare
[21:49:10] <Stemby> ciao risca
[21:49:17] <Stemby> siam partiti da pochissimo
[21:49:48] <Stemby> poi, permette di rendere il codice più compatto, nel caso in cui la stessa operazione dovesse essere svolta più volte
[21:49:51] <GipPasso> Stemby: e mi raccomando, il nome di funzione deve essere pieno di accenti e segni d'interpunzione! Altrimenti si rischia di sceglierlo bene...
[21:49:58] <Stemby> :)
[21:50:32] <Stemby> inoltre, una volta che la funzione è scritta e funzionante, non bisogna più debuggare quel pezzo di codice
[21:50:41] <Stemby> la si chiama, e lei funziona
[21:50:43] <GipPasso> Nella mia piccola esperienza, un buon nome di funzione rende il codice molto più semplice da leggere.
[21:50:50] <Stemby> infatti
[21:51:07] <Stemby> nelle scorse lezioni abbiamo chiamato diverse funzioni
[21:51:13] <Stemby> ve ne ricordate qualcuna?
[21:51:20] <Ernestus> input
[21:51:21] <Ernestus> print
[21:51:26] <Ernestus> chr
[21:51:31] <Stemby> int
[21:51:37] <Stemby> bool
[21:51:38] <Ernestus> float
[21:51:38] <Ernestus> str
[21:51:45] <Stemby> ottimo!
[21:52:08] --> spirit_ (~root@Azzurra-C3C291C.104-82-b.business.telecomitalia.it) has joined #debianizzati-corsi
[21:52:13] <Stemby> in realtà sarebbe meglio aggiungere sempre le parentesi, così è subito chiaro che si tratta di una funzione
[21:52:17] --> gnomob (~gnomob@151.56.Azzurra-7D1B7379) has joined #debianizzati-corsi
[21:52:22] <Stemby> input(), print(), ecc.
[21:52:45] <Stemby> quelle son tutte funzioni predisposte dal linguaggio
[21:52:56] <Stemby> ovvero sono inserite nella libreria standard di python
[21:53:15] <Stemby> una libreria, per chi non lo sapesse, è semplicemente una raccolta di funzioni
[21:53:20] <Stemby> ok?
[21:53:30] <-- gnomob (~gnomob@151.56.Azzurra-7D1B7379) has left #debianizzati-corsi
[21:53:38] <Stemby> oggi impareremo a scrivere le nostre funzioni
[21:53:50] <Stemby> andiamo su Gobby
[21:54:09] <Stemby> risca: l'indirizzo lo sai, vero?
[21:54:20] <Stemby> stemby.dyndns.org
[21:54:56] --> amosse (~Mibbit@Azzurra=2DFA978B.246-95-r.retail.telecomitalia.it) has joined #debianizzati-corsi
[21:55:00] --> lablinux (~Mibbit@Azzurra=55F9963E.ip51.fastwebnet.it) has joined #debianizzati-corsi
[21:55:21] <amosse> Ciao a tutti
[21:55:38] <amosse> é qui la festa?
[21:55:38] <Ernestus> ciao amosse
[21:55:42] <Ernestus> siamo su gobby
[21:55:52] <amosse> ok
[21:55:55] <amosse> ip?
[21:56:06] <Ernestus> stemby.dyndns.org orta: 6522
[21:56:10] <Ernestus> *porta
[21:56:21] <Stemby> esatto
[21:57:32] <lablinux> il corso di python ... è più sfuggente di un rettile...
[22:03:35] <lablinux> mmmhhh con xchat gnome come aggiungo il  canale stemby.dyndns.org (sto dicendo una stupidata?)
[22:03:55] <Stemby> siamo su golly
[22:03:59] <Stemby> sorry
[22:04:03] <Stemby> *gobby
[22:04:09] <Stemby> aptitude install gobby
[22:04:19] <Stemby> lablinux: ↑
[22:04:29] <lablinux> grazie, installo e vi raggiungo
[22:04:36] <Stemby> ok, ti aspettiamo
[22:35:47] <-- lablinux (~Mibbit@Azzurra=55F9963E.ip51.fastwebnet.it) has quit (Quit: http://www.mibbit.com ajax IRC Client)
[22:41:53] <Ernestus> eccomi
[22:41:57] <Stemby> eccoci
[22:42:04] <JumX> vai
[22:42:05] <Stemby> chi non c'era l'ultima volta?
[22:42:07] <amosse> ok
[22:42:23] <Stemby> c'eravamo tutti?
[22:42:52] <Stemby> meglio
[22:42:59] <Stemby> chi si ricorda cosa abbiamo fatto?
[22:43:12] <JumX> tipi booleani
[22:43:24] <Stemby> non i tipi
[22:43:31] <JumX> operatori
[22:43:34] <Stemby> esatto
[22:43:58] <Stemby> oggi vediamo gli operatori di confronto
[22:44:05] <Stemby> e poi ci esercitiamo con le funzioni
[22:44:17] <Stemby> chi mi trova la documentazione ufficiale?
[22:45:03] <Stemby> siete leeeeeeeenti....
[22:45:17] <JumX> http://docs.python.org/dev/py3k/library/index.html
[22:45:24] <Stemby> dobbiamo organizzare un corso di "ricerche in rete"
[22:45:42] <JumX> http://docs.python.org/dev/py3k/library/stdtypes.html#comparisons
[22:45:45] <Stemby> JumX: il paragrafo giusto me lo trovi?
[22:45:48] <Stemby> esatto, bravissimo
[22:46:04] <Stemby> gli ultimi 2 li saltiamo
[22:46:08] <Stemby> (son poco utili)
[22:46:13] <Stemby> gli altri son molto semplici
[22:46:25] <Stemby> entriamo in python3
[22:46:29] <Stemby> ci siamo?
[22:46:35] <amosse> ok
[22:47:00] <Stemby> costruitemi un'espressione con il primo operatore di confronto proposto
[22:47:06] <Stemby> (<)
[22:47:10] <Stemby> minore
[22:47:43] <JumX> True < False
[22:47:45] <JumX> False
[22:47:49] <Stemby> no
[22:47:57] <Stemby> scusate
[22:48:02] <amosse> 1 - 2
[22:48:07] <amosse> True
[22:48:07] <JumX> :D
[22:48:15] <Stemby> in genere gli operatori di confronto si usano con i numeri
[22:48:22] <Stemby> amosse: ?
[22:48:24] <amosse> 1 < 2
[22:48:28] <amosse> True
[22:48:30] <Stemby> ok
[22:48:40] <Stemby> 2 < 1
[22:48:41] <JumX> esatto
[22:48:44] <Stemby> cosa dà?
[22:48:55] <JumX> False
[22:48:59] <spirit_> True
[22:49:03] <Stemby> semplice, no?
[22:49:05] <Stemby> spirit_: no
[22:49:11] <Stemby> 2 non è minore di 1
[22:49:28] <spirit_> scusa..
[22:49:39] <Stemby> capito?
[22:49:56] <Stemby> <= cosa significherà?
[22:49:57] <spirit_> stasero sono mongolo
[22:50:09] <JumX> minore o uguale
[22:50:10] <Stemby> in italiano
[22:50:13] <Stemby> esatto
[22:50:30] <Stemby> fatemi un'espressione che dà vero, e una che dà falso
[22:50:53] <Stemby> (con <=)
[22:50:57] <JumX> 3 < 1 = false
[22:51:03] <Stemby> con <=
[22:51:28] <Stemby> JumX: il secondo operatore di confronto nella documentazione
[22:51:31] <JumX> 2 <= 2    d
[22:51:40] <JumX> True
[22:51:45] <Stemby> ok
[22:52:03] <Stemby> una che dà falso?
[22:52:17] <Stemby> Ernestus: me la fai tu?
[22:52:29] <Stemby> spirit_: ?
[22:52:37] <Ernestus> va bene Stemby
[22:52:40] <Stemby> vai
[22:52:50] <Ernestus> un'espressione vera
[22:52:54] <JumX> 4 <= 1  da False
[22:53:02] <Stemby> bene
[22:53:10] <Stemby> però doveva farmela Ernestus
[22:53:15] <Stemby> la prossima espressione è sua
[22:53:32] <Stemby> scendendo giù le successive sono banali
[22:53:36] <Stemby> > e >=
[22:53:52] <Ernestus> allora 3 > 1.6
[22:54:02] <Stemby> cosa dà?
[22:54:05] <Ernestus> 3 >= 2
[22:54:11] <Ernestus> True
[22:54:14] <Stemby> provala nell'interfaccia interattiva
[22:54:15] <Stemby> ok
[22:54:29] <Stemby> passiamo alla successica
[22:54:32] <Stemby> *successiva
[22:54:36] <Stemby> ==
[22:54:39] <Stemby> cosa vuol dire?
[22:54:45] <Ernestus> uguale
[22:54:47] <JumX> Un attimo
[22:54:52] <Stemby> dimmi JumX
[22:55:38] <Stemby> JumX: ...
[22:55:45] <JumX> Ho scritto per errero 1,6 con la virgola , mi restituisce (True, 6) perchè?
[22:55:59] <Stemby> perché hai scritto una tupla
[22:56:05] <Stemby> 1,6 sono 2 interi
[22:56:07] <Stemby> 1 e 6
[22:56:18] <Ernestus> cos'è una tupla?
[22:56:26] <Stemby> non le abbiamo ancora fatte
[22:56:36] <Stemby> è una raccolta di oggetti
[22:56:46] <Ernestus> float(1,6) bisogna usare?
[22:56:50] <Stemby> no
[22:56:51] <JumX> Con quella risposta mi dice che è True solo il valore 6 ?
[22:57:15] <Stemby> non lo so esattamente, ma direi di no
[22:57:27] <Stemby> dice che una tupla vale più di un intero
[22:57:37] <Stemby> ma in questo momento non so dare una spiegazione
[22:57:45] <JumX> vabbè approfondiremo meglio quando studieremo le tuple
[22:58:05] <Stemby> ok
[22:58:07] <spirit_> sarebbero funzioni con element?
[22:58:12] <Stemby> ?
[22:58:18] <Stemby> cos'è element?
[22:58:26] <spirit_> (1,2,5)
[22:58:40] <Stemby> quella è una tupla
[22:58:46] <Stemby> con dentro 3 interi
[22:58:50] <spirit_> ok
[22:58:54] <amosse> sono serie di dati indicizzati, non modificabili
[22:58:54] <Stemby> comunque non divaghiamo
[22:59:07] <Stemby> eravamo rimasti a ==
[22:59:17] <Stemby> mi avete detto che significa uguale
[22:59:19] <Stemby> giusto
[22:59:25] <JumX> Ma non basta un solo segno ?
[22:59:27] <Stemby> attenzione a non confondersi con =
[22:59:29] <Stemby> no!
[22:59:38] <Stemby> JumX: perché no, secondo te?
[22:59:51] <Ernestus> sennò è come assegnare una variabile
[22:59:55] <Stemby> esatto
[22:59:57] <Ernestus> a = 0
[23:00:03] <JumX> Giusto
[23:00:11] <Stemby> = è l'operatore che assegna una variabile
[23:00:17] <JumX> si ok
[23:00:26] <Stemby> == è l'operatore di confronto "uguale"
[23:00:28] <Stemby> ok?
[23:00:35] <Ernestus> sisi
[23:00:40] <amosse> ok
[23:00:48] <Stemby> gli esempi sono ovvi
[23:00:52] <Stemby> passiamo al successivo
[23:00:59] <Stemby> !=
[23:01:06] <Stemby> in italiano?
[23:01:12] <JumX> il mistero è il non uguali  !=   io credevo che fosse <>
[23:01:28] <Stemby> sì, è il "diverso"
[23:01:36] <Stemby> <> era accettato in py2
[23:01:39] <Stemby> ma deprecato
[23:01:45] <Stemby> in py3 è stato levato
[23:01:51] <Stemby> quindi solo !=
[23:01:53] <Stemby> ok?
[23:02:01] <amosse> ok
[23:02:02] <Stemby> chi mi fa un'espressione falsa?
[23:02:08] <Ernestus> io
[23:02:10] <Stemby> vai
[23:02:21] <JumX> ok .. non voglio neanche chiedere il perchè
[23:02:24] <Ernestus> un'espressione falsa con !=
[23:02:25] <Ernestus> ?
[23:02:29] <Stemby> sì
[23:02:52] <Ernestus> 3 != 3
[23:03:02] <JumX>  2 != 2  da false perche sono uguali
[23:03:19] <JumX> si scusate la sovrapposizione
[23:03:30] <Stemby> esatto
[23:03:31] --> lablinux (~Mibbit@Azzurra=55F9963E.ip51.fastwebnet.it) has joined #debianizzati-corsi
[23:03:45] <Stemby> bon
[23:03:58] <Stemby> fatti anche gli operatori di confronto
[23:04:11] <Stemby> lablinux: mi spiace che ti sia perso questi minuti
[23:04:16] <Stemby> niente di troppo complesso
[23:04:27] <Stemby> abbiamo analizzato gli operatori di confronto
[23:04:37] <Stemby> http://docs.python.org/py3k/library/stdtypes.html#comparisons
[23:04:51] <Stemby> tranne gli ultimi 2, che sono di trascurabile importanza
[23:05:13] <JumX> 2 is 2    è True ----  2 is 3 è False
[23:05:40] <Stemby> sì, ma in genere è meglio usare ==
[23:05:55] <Stemby> perché ci interessa confrontare il valore, non l'oggetto
[23:06:24] <JumX> 2 is not 2  è False    2 is not 3 True
[23:06:27] <Stemby> esempio: se 2 variabili contengono lo stesso valore, ci interessa sapere che il valore è uguale, non che i 2 oggetti sono diversi
[23:06:47] <JumX> si era solo per provare.
[23:07:11] <Stemby> ok, provate, a lezione finita, a confrontare delle variabili
[23:07:25] <Stemby> così vi accorgerete che is non lo userete quasi mai
[23:07:41] <Stemby> ora torniamo su Gobby
[23:08:35] <GipPasso> Stemby: is funziona con le variabili con interi.
[23:08:46] <Stemby> ?
[23:08:51] <GipPasso> a=1
[23:08:52] <GipPasso> b=1
[23:08:57] <GipPasso> a is b
[23:08:58] <GipPasso> True
[23:09:02] <Stemby> ah sì?
[23:09:08] <GipPasso> Da morire usare is al posto di ==
[23:09:26] <Stemby> mmm, interessante
[23:09:33] <Stemby> devo ragionarci un attimo
[23:09:34] <GipPasso> A me tornava più quello che dicevi tu: che non essendo lo stesso oggetto avrebbe dato FAlse.
[23:09:38] <GipPasso> Anch'io.
[23:09:40] <Stemby> aspetta
[23:09:43] <GipPasso> Te lo dicevo per questo.
[23:09:45] <Stemby> credo di capire
[23:10:02] <Stemby> con ogni probabilità entrambi gli oggetti puntano allo stesso valore
[23:10:08] <lablinux> [ot]se usare is al posto di == dovresti provare  ruby[/ot]
[23:10:37] <Stemby> vabbé, farò delle prove
[23:10:42] <GipPasso> Sono due variabili diverse, che puntano a due zone di memoria diversa.
[23:10:50] <Stemby> andiamo su Gobby
[23:10:54] <GipPasso> Che ci sia lo stesso valore non dovrebbe vederlo se non le legge.
[23:10:57] <GipPasso> Sì.
[23:11:00] <GipPasso> Ci pensiamo poi.
[23:39:34] <lablinux> by
[23:40:23] <-- lablinux (~Mibbit@Azzurra=55F9963E.ip51.fastwebnet.it) has quit (Quit: http://www.mibbit.com ajax IRC Client)
[23:57:36] <GipPasso> Buonanotte