Accademia:Log 2011 03 13

[21:38:27] <|Wolf|> avete fatto i compiti?
[21:38:53] <amosse> si qualcosa
[21:39:00] <|Wolf|> avete domande?
[21:39:50] <amosse> ma ci sono dei metodi sulle stringhe non troppo chiari
[21:39:58] <|Wolf|> tipo?
[21:40:40] <amosse> tipo str.count()
[21:40:54] <|Wolf|> cosa non hai capito di str.count()?
[21:41:37] <amosse> non ho capito a cosa serve
[21:41:50] <|Wolf|> help(str.count) cosa dice?
[21:42:37] <amosse> Return the number of non-overlapping occurrences of substring sub in the range [start, end].
[21:42:55] <amosse> in pratica quando si usa?
[21:43:23] <amosse> cosa intende per 'non-overlapping occurrences'
[21:44:17] <|Wolf|> ad esempio se cerchi 'aaa'.count('aa')
[21:44:24] <|Wolf|> cosa ti dà?
[21:45:00] <amosse> 1
[21:45:04] --> JumX (~Mibbit@Azzurra-40E97FA1.247-95-r.retail.telecomitalia.it) has joined #debianizzati-corsi
[21:45:34] <|Wolf|> perché?
[21:45:52] <groll> beh innanzitutto sai cosa vuol dire overlapping?
[21:46:06] <amosse> vuol dire che 'aa' è presente una volta in 'aaaa'
[21:46:27] <|Wolf|> 'aaa', non 'aaaa'
[21:46:32] <|Wolf|> con 'aaaa' quanto ti dà?
[21:46:47] <amosse> sovrapporre
[21:46:59] <groll> si sovrapposte
[21:47:24] <JumX> Buonasera a tutti scusate il ritardo :) avete cominciato da molto ?
[21:47:33] <amosse> 2
[21:47:34] <groll> un paio di ore :|
[21:47:53] <JumX> si si .. sei proprio un "grollo"
[21:47:53] <amosse> ho capito 'aa' é presente 2 volte in 'aaaa'
[21:48:07] <|Wolf|> amosse, tutto chiaro?
[21:48:18] <amosse> ok
[21:48:36] <Stemby> eccomi
[21:48:53] <amosse> ciao Stemby
[21:49:11] <spirit> ciao
[21:49:11] <|Wolf|> hello Stemby
[21:49:20] <|Wolf|> Stemby, conosci i python koans?
[21:49:52] <Stemby> |Wolf|: no
[21:50:07] <Stemby> cosa sono?
[21:50:20] <|Wolf|> degli esercizietti per imparare python
[21:50:31] <|Wolf|> potreste proporli
[21:50:45] <Stemby> a fine lezione guardiamo :)
[21:50:55] <Stemby> altre domande?
[21:50:56] <amosse> dove si trovano?
[21:51:24] <groll> http://python-koans.appspot.com/
[21:51:48] <amosse> quali sono gli string methods più importanti (o usati)?
[21:52:00] <|Wolf|> amosse, split, strip
[21:52:10] <|Wolf|> lower
[21:52:15] <|Wolf|> groll, quelli
[21:52:29] <amosse> ok
[21:52:30] <groll> amosse: comunque è inutile guardarseli tutti li guardi quando ti servono
[21:52:44] <groll> l'importante è che impari a leggere la documentazione
[21:52:59] <|Wolf|> anche sapere che esistono è importante
[21:53:01] <amosse> ok
[21:53:08] <|Wolf|> poi i dettagli di come funzionano te li vai a vedere man mano
[21:53:21] <amosse> ok
[21:54:53] <Stemby> il capitolo 6 era chiaro?
[21:55:03] --> gnomo (~gnomob@151.56.Azzurra-A01DC50) has joined #debianizzati-corsi
[21:55:05] <Stemby> (confesso che mi mancano da leggere le ultime pagine)
[21:55:18] <Stemby> niente di nuovo, no?
[21:55:31] <-- gnomo (~gnomob@151.56.Azzurra-A01DC50) has left #debianizzati-corsi
[21:55:42] <Stemby> tranne forse il concetto di variabile globale e locale spiegato un po' meglio di quanto avevamo fatto
[21:55:53] <Stemby> ci sono dubbi?
[21:56:44] <amosse> me lo devo ancora leggere, lo guardo per la prossima volta
[21:56:58] <Stemby> mmm
[21:57:15] <Stemby> tutto sto silenzio mi fa pensare che anche gli altri non abbiano fatto i compiti...
[21:57:31] <spirit> anch'io li devo leggere...
[21:57:36] <Stemby> male
[21:57:43] <Stemby> è lunghetto
[21:57:53] <Stemby> se rimanete indietro poi è difficile recuperare
[21:58:23] <Stemby> chi ha letto il capitolo 6, oltre a me?
[21:58:29] <Stemby> (tranne le ultime pagine)
[21:59:18] <Stemby> come temevo...
[21:59:35] <amosse> lo rimettiamo per mercoledi?
[21:59:38] <Stemby> facciamo così: per la prossima volta TASSATIVAMENTE il capitolo 6 deve essere fatto
[21:59:50] <amosse> ok
[21:59:53] <spirit> ok
[21:59:57] <Stemby> e d'ora innanzi si prosegue a un capitolo alla volta
[22:00:16] <Stemby> altrimenti non andiamo da nessuna parte
[22:00:42] <Stemby> direi di iniziare la lezione
[22:00:48] <Stemby> a meno che ci siano dubbi
[22:00:50] <amosse> ok
[22:00:56] <spirit> va bene
[22:01:01] <Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#old-string-formatting-operations
[22:01:28] <Stemby> effettivamente si dice che la vecchia sintassi per la formattazione stringhe è obsoleta
[22:01:53] <Stemby> quindi cerchiamo di usare .format()
[22:02:02] <Stemby> (io per primo)
[22:03:02] <Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#mutable-sequence-types
[22:03:12] <Stemby> bon, direi che è ora di introdurre le liste
[22:03:21] <Stemby> qualcuno ha già iniziato ad usarle
[22:03:32] <Stemby> che cos'è una lista?
[22:04:20] <Stemby> amosse: aiutaci
[22:04:27] <Stemby> (visto che le hai già usate)
[22:04:30] <spirit> sequenza elenco
[22:04:45] <Stemby> più o meno
[22:04:51] <amosse> si liste o array
[22:04:58] <amosse> liste ordine di elementi
[22:05:04] <Stemby> allora
[22:05:16] <Stemby> innanzitutto, in generale, è un tipo predefinito
[22:05:18] <|Wolf|> liste e array son due cose diverse (anche se in qualche maniera simile)
[22:05:39] <Stemby> abbiamo già visto altri tipi predefiniti
[22:05:45] <Stemby> (o oggetti predefiniti)
[22:05:50] <Stemby> li ripassiamo?
[22:06:07] <spirit> ok
[22:06:10] <Stemby> forza
[22:06:19] <Stemby> 1)
[22:06:23] <Stemby> ...
[22:06:26] <Stemby> dai!
[22:06:40] <Stemby> osate
[22:06:55] <amosse> stringhe
[22:06:59] <Stemby> ok
[22:07:08] <Stemby> quello è l'ultimo che abbiamo visto
[22:07:09] <amosse> interi
[22:07:11] <Stemby> ok
[22:07:20] <Stemby> poi?
[22:07:36] <spirit> operazioni booleane
[22:07:39] <Stemby> spirit: no
[22:07:53] <Stemby> le operazioni booleane sono espressioni
[22:07:54] <amosse> float (numeri con decimali)
[22:07:58] <Stemby> amosse: ok
[22:08:05] <Stemby> poi?
[22:08:11] <amosse> tuple
[22:08:13] <amosse> liste
[22:08:22] <amosse> dizionari
[22:08:23] <Stemby> le tuple non le abbiamo ancora fatte
[22:08:28] <Stemby> i dizionari neppure
[22:08:35] <Stemby> le liste ufficialmente stasera
[22:08:43] <Stemby> i booleani
[22:08:50] <Stemby> (True/False)
[22:08:58] <amosse> si vero
[22:08:59] <Stemby> quelli li abbiamo fatti
[22:09:05] <Stemby> complex
[22:09:10] <Stemby> solo accennatu
[22:09:13] <Stemby> *accennati
[22:09:24] <Stemby> (sappiamo che esistono)
[22:09:33] <Stemby> credo nient'altro
[22:09:43] <Stemby> raggruppiamoli
[22:09:52] <Stemby> 1) booleani
[22:10:11] <Stemby> 2) interi, float e complex
[22:10:23] <Stemby> 3) stringhe, liste e tuple
[22:10:28] <Stemby> 4) dizionari
[22:10:41] <Stemby> direi che questa possa essere una buona suddivisione
[22:11:02] <amosse> ok
[22:11:03] <Stemby> perché i 2) sono insieme?
[22:11:18] <groll> 5) insiemi
[22:11:31] <groll> visto che li hai elencati quasi tutti :P
[22:11:36] <Stemby> ok :)
[22:11:46] <Stemby> perché i 2) sono insieme?
[22:11:47] <amosse> perche sono numerici
[22:11:51] <Stemby> esatto
[22:11:57] <Stemby> sono tutti tipi numerici
[22:12:02] <Stemby> e i 3)?
[22:12:19] <amosse>  sono sequenze
[22:12:24] <Stemby> bravo
[22:12:42] <Stemby> le stringhe sono sequenze di...?
[22:12:51] <spirit> caratteri
[22:12:54] <Stemby> ok
[22:12:59] <amosse> caratteri
[22:13:03] <Stemby> mentre le liste sono sequenze di...?
[22:13:15] <Stemby> (se non lo sapete va bene lo stesso)
[22:13:16] <amosse> elementi
[22:13:20] <Stemby> oggetti
[22:13:26] <Stemby> oggetti vari
[22:13:33] <amosse> ok
[22:13:49] <spirit> elementi etereogenei
[22:13:49] <Stemby> c'è u'altra differenza tra stringa e lista
[22:13:59] <Stemby> *un'altra
[22:14:12] <Stemby> la stringa è inalterabile
[22:14:19] <Stemby> la lista invece lo è
[22:14:20] <|Wolf|> immutabile
[22:14:28] <Stemby> giusto |Wolf|
[22:14:35] <Stemby> non mi veniva il termine corretto
[22:14:49] <Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#mutable-sequence-types
[22:15:03] <Stemby> qui vediamo un po' di cosucce che si possono fare con le liste
[22:15:07] <Stemby> ma non con le stringhe
[22:15:17] <Stemby> proprio perché le stringhe sono immutabili
[22:15:54] <Stemby> tronando un attimo indietro: http://docs.python.org/release/3.1.3/library/stdtypes.html#sequence-types-str-bytes-bytearray-list-tuple-range
[22:16:02] <Stemby> ci ricordiamo la prima tabella?
[22:16:24] <Stemby> [S/N]
[22:16:50] <Stemby> c'è nessuno?????
[22:17:00] <amosse> si
[22:17:25] <Stemby> spirit, JumX, Ernestus?
[22:17:33] <spirit> ora si, scusa
[22:17:41] <JumX> Ci siamo
[22:17:49] <Stemby> vi ricordate quella tabella?
[22:18:04] <Ernestus> io ci sono
[22:18:10] <spirit> grosso modo..
[22:18:16] <Ernestus> veramente no
[22:18:21] <Stemby> male...
[22:18:34] <Stemby> non c'eri quando abbiamo fatto le stringhe?
[22:18:36] <Ernestus> io non ero presente lo scorso e l'altro incontro
[22:19:02] <Stemby> però ci sono i log IRC per recuperare
[22:19:30] <Stemby> se dobbiamo ogni volta riprendere 2 o 3 lezioni indietro, non ce la sbrighiamo più
[22:19:41] <amosse> a proposito l' ultimo non é caricato
[22:19:46] <Ernestus> hai ragione Stemby, mea culpa
[22:19:56] <Stemby> amosse: ricordalo a risca
[22:20:03] <Stemby> segnalalo sul forum
[22:20:03] <JumX> Stavo per dire lo stesso.
[22:20:04] <amosse> ok
[22:20:15] <Stemby> al massimo lo carico io
[22:20:23] <Stemby> comunque dovete essere più attivi
[22:20:32] <amosse> ok
[22:20:39] <Stemby> non potete aspettare che vi si spinga come i bambini
[22:20:39] <JumX> Hai ragione ...
[22:21:19] <Stemby> allora, chi ripassa quella tabella?
[22:21:28] <Stemby> intanto: che cos'è?
[22:21:30] <amosse> io
[22:22:04] <Stemby> vai amosse
[22:22:41] <amosse> é la lista delle operazioni che si possono fare con le sequences type
[22:23:02] <Stemby> sì, diciamo che è una raccolta di espressioni e metodi
[22:23:14] <Stemby> applicabili alle sequenze
[22:23:33] <amosse> 1) x in s -> Vero se 'x' é presente in 's'
[22:23:41] <Stemby> sono dunque validi per tutte le sequenze
[22:23:50] <Stemby> per ora avevamo visto solo le stringhe
[22:24:03] <Stemby> ma oggi proviamo ad applicarli anche alle liste
[22:24:16] <Stemby> amosse: ok
[22:24:26] <Stemby> prova a costruire un'espressione con una lista
[22:24:32] <Stemby> (con in)
[22:24:45] <Stemby> nella shell interattiva, ovviamente
[22:24:53] <amosse> ok
[22:25:45] <Stemby> amosse: ce l'hai fatta?
[22:25:48] <amosse> io = ['amos','marzuoli']
[22:25:57] <Stemby> senza variabili
[22:26:17] <Stemby> quando costruiamo espressioni nella shell interattiva, cerchiamo di evitare le variabili
[22:26:27] <amosse> ok
[22:26:28] <Stemby> (non servono allo scopo)
[22:26:52] <amosse> amos in io['amos','marzuoli']
[22:26:53] <amosse> True
[22:27:06] <amosse> ops
[22:27:06] <amosse> *'amos'
[22:27:07] <Stemby> io?
[22:27:25] <Stemby> faccio io
[22:27:33] <amosse> io 'la lista' io[]
[22:27:42] <Stemby> >>> 1 in [1,2,3]
[22:27:42] <Stemby> True
[22:28:00] <Stemby> >>> 5 in [1,2,3]
[22:28:00] <Stemby> False
[22:28:04] <Stemby> ok?
[22:28:13] <amosse> ok
[22:28:16] <Stemby> [1,2,3] è una lista
[22:28:29] <Stemby> una lista contenente 3 interi
[22:28:41] <amosse> ok
[22:29:00] <Stemby> l'operatore in confronta l'oggetto che gli si passa con la sequenza successiva
[22:29:06] <Stemby> (nel nostro caso la lista)
[22:29:22] <Stemby> e restituisce vero se l'elemento è presente nella sequenza
[22:29:31] <Stemby> 1 è presente → dà vero
[22:29:37] <Stemby> 5 non lo è → dà falso
[22:29:53] <Stemby> amosse: fammi un'altra espressione simile
[22:30:06] <Stemby> ma con la lista contenente altri oggetti
[22:30:09] <Stemby> (non interi)
[22:30:22] <amosse> 'amos' in ['amos','marzuoli']
[22:30:25] <amosse> True
[22:30:27] <Stemby> ok
[22:30:40] <Stemby> per chi non c'era le altre volte,
[22:30:52] <Stemby> un'espressione con una stringa come sequenza
[22:31:03] <Stemby> (al posto della lista)
[22:31:10] <Stemby> sempre con in
[22:31:14] <Stemby> come operatore
[22:31:19] <JumX> 'g' in ('g','h','l') True
[22:31:28] <Stemby> JumX: no
[22:31:35] <Stemby> quella non è una stringa
[22:31:36] <JumX> ?
[22:31:40] <Stemby> quella è una tupla
[22:31:48] <Stemby> (che non abbiamo ancora fatto)
[22:32:04] <groll> 'g' in 'ghl'
[22:32:11] <JumX> ok
[22:32:15] <Stemby> groll: non vale :p
[22:32:22] <Stemby> tu sei escluso dal gioco :)
[22:32:23] <groll> :p
[22:32:26] <groll> uffa
[22:32:44] <Stemby> >>> 'i' in 'pippo'
[22:32:44] <Stemby> True
[22:32:54] <Stemby> JumX: è chiaro cos'è una stringa?
[22:32:56] <Ernestus> Stemby, tranquillo recupererò
[22:32:58] <JumX> (grazie groll)
[22:33:01] <Ernestus> comunque ho capito
[22:33:16] <JumX> si anch'io
[22:33:34] <Stemby> però ora è chiaro che cos'è una stringa?
[22:33:40] <spirit> si
[22:33:48] <Stemby> non ci dovrebbero essere più dubbi, a questo punto...
[22:34:03] <spirit> per me ora è chiaro
[22:34:05] <Stemby> bon, andiamo avanti
[22:34:16] <Stemby> proviamo la concatenazione
[22:34:30] <Stemby> (ricordo: con le stringhe da evitare, quando possibile)
[22:34:43] <Stemby> prima un'espressione con 2 stringhe
[22:34:50] <Stemby> e poi con 2 liste
[22:34:52] <Stemby> forza
[22:35:04] <Stemby> (terza linea della tabella)
[22:35:55] <amosse> 'all'+'ora'
[22:36:02] <Stemby> ok
[22:36:06] <amosse> 'allora'
[22:36:10] <Stemby> esatto
[22:36:21] <Stemby> spirit: ci fai tu un'espressione con 2 liste?
[22:36:34] <JumX> 'a'+'b' 'ab'
[22:36:34] <Stemby> la concatenazione di 2 liste
[22:36:39] <spirit> ma senza variabili?
[22:36:46] <Stemby> senza variabili
[22:36:56] <Stemby> per favore
[22:37:04] <Stemby> facciamolo sempre nella shell interattiva
[22:37:08] <Stemby> e incolliamo tutto
[22:37:11] <Stemby> >>> compresi
[22:37:31] <spirit> 'pippo' + 'clarabella'
[22:37:40] <Stemby> non vedi i >>>
[22:37:50] <Stemby> e quelle sono 2 stringhe
[22:37:54] <Stemby> non 2 liste
[22:38:01] <spirit> ah scusa
[22:38:01] <Stemby> spirit: sei nella shell interattiva?
[22:38:08] <spirit> si
[22:38:13] <Stemby> incolla da lì
[22:38:16] <Stemby> :)
[22:38:32] <Stemby> l'operatore è quello giusto
[22:38:34] <JumX> >>> 'il cacio' + 'cavallo è buono' 'il caciocavallo è buono'
[22:38:48] <Stemby> quelle son sempre 2 stringhe
[22:38:57] <Stemby> e manca un a capo
[22:39:27] <Stemby> >>> 'il cacio' + 'cavallo è buono'
[22:39:27] <Stemby> 'il caciocavallo è buono'
[22:39:30] <amosse> >>> ['io','mia moglie'] + ['mio figlio']
[22:39:34] <Stemby> questo è l'output corretto
[22:39:42] <Stemby> amosse: ok
[22:39:49] <Stemby> incolla anche l'output
[22:39:56] <amosse> ['io', 'mia moglie', 'mio figlio']
[22:40:08] <Stemby> ok
[22:40:16] <Stemby> spirit: ora fanne una tu
[22:40:27] <Stemby> con liste un po' diverse
[22:40:33] <Stemby> contenenti ad esempio dei float
[22:40:47] <Stemby> per chiarezza:
[22:41:00] <Stemby> non è stato detto prima e nessuno me l'ha chiesto
[22:41:12] <Stemby> comunque la sintassi di una lista è questa:
[22:41:34] <Stemby> [oggetto, altro_oggetto, altro_oggetto_ancora, ecc.]
[22:41:40] <Stemby> ovvero
[22:41:44] <Stemby> []
[22:41:52] <Stemby> con in mezzo i vari oggetti
[22:41:59] <Stemby> separati tra loro da virgole
[22:42:11] <Stemby> una lista può essere anche vuota
[22:42:20] <Stemby> vi ricordate com'è una stringa vuota?
[22:42:27] <spirit> ''
[22:42:30] <Stemby> ok
[22:42:39] <JumX> ""
[22:42:43] <Stemby> ok
[22:42:49] <Stemby> mentre una lista vuota è
[22:42:51] <Stemby> []
[22:43:25] <Stemby> ora, spirit: mi fai l'espressione che ti avevo chiesto?
[22:43:36] <Stemby> 2 liste contenenti quanti float vuoi
[22:43:40] <Stemby> e concatenate tra loro
[22:43:59] <spirit> mi sono infrenato..
[22:44:06] <Stemby> un passo alla volta
[22:44:12] <Stemby> chiaro cos'è una lista?
[22:44:22] <Stemby> spirit: ↑
[22:44:24] <spirit> si
[22:44:33] <Stemby> chiato cos'è un float?
[22:44:42] <spirit> decimale
[22:44:54] <Stemby> chiaro cos'è una lista di float?
[22:45:02] <spirit> lista di decimali
[22:45:07] <Stemby> esempio
[22:45:15] <JumX> una lista sono due o più stringhe . Giusto?
[22:45:20] <Stemby> JumX: no
[22:45:32] <Stemby> è una sequenza di oggetti
[22:45:40] <groll> notte
[22:45:41] <Stemby> questi oggetti possono essere del tipo che vuoi
[22:45:45] <Stemby> notte groll
[22:45:45] <JumX> ok
[22:45:49] <-- groll (~groll@Azzurra=64EE12F.48-151.net24.it) has quit (Read/Dead Error: Input/output error)
[22:46:07] <Stemby> spirit: fammi una lista contenente 2 float
[22:46:27] <spirit> un attimo
[22:46:57] <spirit> float(0.5) + float(0.5)
[22:47:02] <Stemby> ....
[22:47:14] <Stemby> perché usi la funzione float?
[22:47:14] <spirit> 1.0
[22:47:31] <Stemby> che cosa fa la funzione float()?
[22:47:44] <Ernestus> trasforma stringa in float
[22:47:50] <Ernestus> ?
[22:47:55] <Stemby> non necessariamente una stringa
[22:48:03] <Ernestus> trasforma l'argomento in float
[22:48:03] <Stemby> trasforma un oggetto in float
[22:48:08] <Stemby> esatto
[22:48:16] <Stemby> ma 0.5 che tipo è?
[22:48:24] <spirit> decimali
[22:48:31] <Stemby> è un float
[22:48:35] <Ernestus> '2.3' + '3.0'
[22:48:36] <Ernestus> ?
[22:48:42] <Stemby> allora perché trasformarlo in float?
[22:48:44] <Stemby> Ernestus: no
[22:48:51] <Stemby> quelle sono 2 stringhe
[22:48:56] <Stemby> aiuto!!!
[22:49:00] <|Wolf|> gh
[22:49:09] <Stemby> allora
[22:49:14] <Stemby> calma e sangue freddo
[22:49:24] <Stemby> (anche se sto iniziando ad inquietarmi)
[22:49:32] <Stemby> prima cosa
[22:49:46] <Stemby> c'è una funzione che permentte di sapere il tipo di qualunque oggetto
[22:49:50] <Stemby> qual'è?
[22:49:59] <Stemby> senza apostrofo
[22:50:02] <Stemby> qual è?
[22:50:04] <spirit> type()
[22:50:05] <JumX> type
[22:50:07] <Stemby> ok!
[22:50:11] <JumX> type()
[22:50:24] <Stemby> type('2.3')
[22:50:29] <Stemby> che cacchi ci dà?
[22:50:34] <Stemby> *cacchio
[22:50:38] <JumX> string
[22:50:40] <Ernestus> stringa
[22:50:50] <Stemby> appunto
[22:50:56] <Ernestus> la stringa è qualcosa dentro le virgolette
[22:50:56] <Stemby> io cos'ho chiesto?
[22:51:01] <Stemby> Ernestus: sì
[22:51:13] <Ernestus> lista di 2 float
[22:51:16] <Stemby> appunto
[22:51:31] <Stemby> cosa c'entrano le stringhe?
[22:51:35] <Stemby> niente
[22:51:58] <Stemby> prima spirit ha usato la funzione float
[22:52:02] <spirit> ('2.3') + ('1')
[22:52:03] <Stemby> float()
[22:52:08] <Stemby> spirit: no!!!!!!!!!
[22:52:12] <JumX> no
[22:52:13] <Ernestus> sempre stringhe
[22:52:21] <Stemby> scusa
[22:52:23] <JumX> >>> (0.2) + (0.5)
[22:52:30] <Stemby> JumX: senza parentesi
[22:52:38] <JumX> è lo stesso
[22:52:41] <Stemby> lo so
[22:52:46] <Stemby> ma le parentesi sono inutili
[22:52:49] <Stemby> e confondono
[22:52:51] <JumX> ok
[22:53:03] <JumX> >>> 0.2 + 0.5
[22:53:05] <spirit> sono affogato in un bicchier d'acqua
[22:53:10] <Stemby> ora abbiamo la somma di 2 float
[22:53:13] <JumX> :D
[22:53:17] <Stemby> il che non è quello che avevo chiesto
[22:53:27] <Stemby> comunque abbiamo 2 float
[22:53:32] <Stemby> che è già qualcosina
[22:53:41] <Stemby> 0.2 e 0.5 sono float
[22:53:47] <Stemby> controllate con type()
[22:54:12] <Stemby> forza!
[22:54:20] <amosse> [0.2] + [0.5]
[22:54:21] <JumX> <class 'float'>
[22:54:28] <Stemby> no amosse
[22:54:34] <JumX> amosse senza parentesi
[22:54:40] <Stemby> fate quello che chiedo
[22:54:48] <amosse> ok
[22:54:53] <Stemby> verificate che 0.5 e 0.2 sono float
[22:55:23] <spirit> type(0.5)
[22:55:27] <amosse> type(0.5)
[22:55:37] <amosse> type(0.2)
[22:55:37] <Stemby> incollate tutto...
[22:55:42] <Stemby> >>> compresi
[22:55:52] <Stemby> e ovviamente anche l'output
[22:55:57] <spirit> >>> type(0.4)
[22:55:59] <spirit> <class 'float'>
[22:56:09] <Stemby> ok
[22:56:22] <Stemby> 0.4 non era quello di prima, ma poco importa
[22:56:29] <JumX> E' possibile fare con un solo type() ?
[22:56:36] <spirit> ops
[22:56:46] <Stemby> JumX: ?
[22:57:06] <Ernestus> si
[22:57:20] <JumX> contemporaneamente con in una solo riga trovare il type di più dati?
[22:57:30] <Stemby> sì, ma non è molto utile
[22:57:41] <Stemby> in realtà type() non lo si usa praticamente mai
[22:57:51] <JumX> per curiosità
[22:57:54] <amosse> type((0.5) and (0.2))
[22:57:59] <Stemby> amosse: no
[22:58:04] <amosse> <class 'float'>
[22:58:23] <Stemby> amosse: quello che hai fatto è una cosa diversa da quello che pensi
[22:58:29] <Stemby> ti ricordi come funziona and?
[22:58:33] <|Wolf|> prova  type('0.5' and 0.2)
[22:58:44] <Stemby> amosse: http://docs.python.org/release/3.1.3/library/stdtypes.html#boolean-operations-and-or-not
[22:58:50] <JumX> >>> type(0.5 and 0.2)
[22:58:59] <JumX> <class 'float'>
[22:59:02] <Stemby> prova
[22:59:07] <Stemby> >>> 0.5 and 0.2
[22:59:17] <JumX> E' giust ?
[22:59:22] <Stemby> no
[22:59:29] <Stemby> nel senso che non è quello che pensate
[22:59:33] <Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#boolean-operations-and-or-not
[22:59:38] <Stemby> lì c'è la spiegazione
[22:59:49] <Stemby> ma l'avevamo visto in dettaglio diverse lezioni fa
[22:59:58] <amosse> ok , hai ragione
[22:59:59] <Stemby> e non mi sembra il caso di riprenderlo
[23:00:17] <Stemby> in pratica fare
[23:00:23] <Stemby> >>> type(0.5 and 0.2)
[23:00:28] <Stemby> equivale esattamente a fare
[23:00:34] <Stemby> >>> type(0.2)
[23:00:45] <Stemby> perché
[23:00:50] <Stemby> 0.5 and 0.2
[23:00:53] <Stemby> dà
[23:00:55] <Stemby> 0.2
[23:01:10] <Stemby> quindi non è quello che cercavate
[23:01:49] <Stemby> quello che volete fare si può fare ad esempio con un for
[23:02:04] <Stemby> ma, ripeto, è inutile
[23:02:34] <Stemby> torniamo alla mia domanda
[23:02:47] <Stemby> abbiamo chiarito (spero!) cos'è un float
[23:02:55] <Stemby> ora mi fate una lista contenete 2 float?
[23:03:18] <amosse> ma qual'é la sintassi per passare due arg. a type()?
[23:03:33] <Stemby> amosse: lo vediamo dopo?
[23:03:40] <spirit> [0.5, 0,8]
[23:03:41] <amosse> ok
[23:03:46] <Stemby> spirit: no
[23:03:57] <Stemby> hai fatto una lista contenente 3 oggetti
[23:04:02] <Stemby> un float e 2 interi
[23:04:19] <Stemby> i 3 oggetti sono:
[23:04:22] <Stemby> 0.5
[23:04:23] <Stemby> 0
[23:04:24] <Stemby> 8
[23:04:32] <spirit> ho visto..
[23:04:33] <|Wolf|> spirit, l'hai provato nell'interprete?
[23:04:42] <spirit> sto provando
[23:04:49] <|Wolf|> dovete sempre provare tutto
[23:05:02] <Stemby> prima di postare
[23:05:12] <|Wolf|> nella maggior parte dei casi python vi dirà se avete fatto qualcosa di sbagliato
[23:05:22] <JumX> >>> (0.5,0.8,0.7)+ (0.5,0.5)
[23:05:30] <Stemby> JumX: no
[23:05:30] <JumX> (0.5, 0.8, 0.7, 0.5, 0.5)
[23:05:40] <Stemby> appunto!
[23:05:50] <Stemby> tu stai usando le tuple
[23:05:55] <Stemby> che non abbiamo ancora fatto
[23:06:02] <JumX> azz...
[23:06:05] <Stemby> cacchiarola, facciamo quello che chiedo?
[23:06:11] <Stemby> una lista contenente 2 float
[23:06:13] <Stemby> punto
[23:06:18] <spirit> [0.5, 0.8]
[23:06:19] <|Wolf|> Stemby, posso insegnargli del _ nell'interprete?
[23:06:30] <Stemby> spirit: alleluia
[23:06:34] <Stemby> |Wolf|: vai
[23:06:42] <spirit> è che mi infreno..
[23:06:52] <|Wolf|> _ si riferisce all'ultima espressione printata nell'interprete
[23:06:54] <|Wolf|> quindi:
[23:07:06] <|Wolf|> >>> 3 + 5
[23:07:06] <|Wolf|> 8
[23:07:06] <|Wolf|> >>> _
[23:07:06] <|Wolf|> 8
[23:07:16] <|Wolf|> può essere utile per fare:
[23:07:44] <|Wolf|> >>> (0.5,0.8,0.7)+ (0.5,0.5)
[23:07:44] <|Wolf|> (0.5, 0.8, 0.7, 0.5, 0.5)
[23:07:44] <|Wolf|> >>> type(_)
[23:07:44] <|Wolf|> <class 'tuple'>
[23:08:09] <Stemby> bello, non lo conoscevo
[23:08:13] <|Wolf|> in questo modo il _ si riferisce all'ultima espressione (cioè (0.5, 0.8, 0.7, 0.5, 0.5) )
[23:08:27] <Stemby> comunque esiste anche l'hisory
[23:08:28] <|Wolf|> e con type() puoi controllare cos'è senza star lì a fare copia incolla
[23:08:32] <Stemby> *history
[23:08:51] <Stemby> basta usare la freccia in su
[23:08:54] <Stemby> e modificare
[23:09:00] <Stemby> però _ è più comodo
[23:09:06] <Stemby> grazie |Wolf|
[23:09:12] <Stemby> allora. proseguiamo
[23:09:22] <|Wolf|> quindi se Stemby chiede una lista, e voi dopo un po' di esperimenti arrivate a qualcosa che vi sembra una lista, potete provare a fare type(_)  per vedere se è veramente una lista o un'altra cosa
[23:09:27] <Stemby> funalmente abbiamo una lista con 2 float
[23:09:39] <Stemby> *finalmente
[23:09:54] <Stemby> ora me la concatenate ad un'altra lista?
[23:10:00] <Stemby> (contenente quel che volete)
[23:10:48] <spirit> >>> [0.5, 0.8] + ['pink']
[23:10:54] <|Wolf|> quindi partite con 2 liste, le concatenate e ottenete una terza lista
[23:10:56] <Stemby> spirit: ok
[23:11:03] <Stemby> posta anche l'output
[23:11:06] <|Wolf|> spirit, hai provato nell'interprete e verificato che esce una lista?
[23:11:11] <spirit> [0.5, 0.8, 'pink']
[23:11:18] <spirit> si
[23:11:23] <Stemby> ok
[23:11:34] <Stemby> spirit: descrivi quello che hai fatto
[23:11:36] <Stemby> a parole
[23:11:39] <spirit> ora è chiaro il concetto di lista
[23:11:44] <Stemby> in modo sintetico ma esauriente
[23:12:09] <spirit> lista contenente 2 float ed una con oggetto
[23:12:17] <|Wolf|> che oggetto?
[23:12:19] <Stemby> spirit: che oggetto?
[23:12:23] <Stemby> asd
[23:12:30] <spirit> 'pink'
[23:12:34] <Stemby> che è?
[23:12:34] <JumX> quindi la differenza sono le parentesi ?
[23:12:46] <spirit> stringa
[23:12:47] <|Wolf|> JumX, differenza con cosa?
[23:12:58] <JumX> un attimo
[23:13:09] <spirit> lista..
[23:13:10] <Stemby> spirit: ok
[23:13:17] <|Wolf|> spirit, stringa o lista?
[23:13:28] <|Wolf|> spirit, se non sei sicuro chiedi a python
[23:13:29] <Stemby> spirit: da capo
[23:13:31] <spirit> lista perchè []
[23:13:38] <|Wolf|> e cosa c'è nella lista?
[23:13:48] <Stemby> soggetto, verbo, complementi
[23:13:54] <Stemby> altrimenti non ci capiamo
[23:14:02] <JumX> >>> [0.5,0.6]     facendo type(_)   =  <class 'list'>
[23:14:14] <|Wolf|> JumX, sì
[23:14:27] <|Wolf|> puoi anche fare type([0.5, 0.6]) direttamente
[23:14:29] <JumX> ma se lo stesso lo faccio con le parentesi tonde mi da   <class 'tuple'>
[23:14:37] <|Wolf|> il _ serve quando vuoi fare qualcosa dopo che l'hai printato
[23:14:54] <|Wolf|> JumX, sì, le liste usano le [] e le tuple le ()
[23:14:59] <Stemby> JumX: infatti ho detto che una lista è fatta così
[23:15:01] <Stemby> []
[23:15:10] <Stemby> con in messo i vari oggetti separati da virgole
[23:15:41] <|Wolf|> spirit, come fai con python a verificare che ['pink'] è una lista?
[23:15:41] <JumX> scusa stemby ma non capivo [] che erano parentesi quadre
[23:16:11] <Stemby> ah
[23:16:18] <Stemby> beh, è così
[23:16:19] <spirit> da errore
[23:16:34] <Stemby> pre 22:41
[23:16:35] <|Wolf|> spirit, cosa dà errore e che errore dà?
[23:16:43] <Stemby> *ore
[23:16:53] <spirit> typeError: 'type' object is not subscriptable
[23:17:03] <|Wolf|> spirit, cosa hai fatto?
[23:17:23] <spirit> type['pink']
[23:17:30] <|Wolf|> non manca qualcosa?
[23:17:38] <JumX> ()
[23:17:47] <|Wolf|> giusto
[23:17:52] <Stemby> spirit: è una funzione...
[23:18:03] <Stemby> le funzioni vogliono _sempre_ le parentesi
[23:18:04] <|Wolf|> type è una funzione, e quando chiami una funzione fai nomefunzione(argomenti)
[23:18:17] <|Wolf|> in questo caso l'argomento è ['pink']
[23:18:43] <spirit> cavolo..
[23:18:53] <Stemby> >>> type(['pink'])
[23:18:53] <Stemby> <class 'list'>
[23:18:54] <spirit> che frana
[23:19:03] <Stemby> le tonde fan parte della funzione
[23:19:12] <Stemby> le quadre sono la lista
[23:19:20] <Stemby> e gli apici sono quelli della stringa
[23:19:24] <Stemby> contenuta nella lista
[23:19:27] <spirit> ok
[23:19:39] <|Wolf|> quindi hai sempre type(...)
[23:19:52] <|Wolf|> e di volta in volta al posto dei ... ci metti l'oggetto di cui vuoi verificare il tipo
[23:20:10] <spirit> ci sono grazie
[23:20:13] <Stemby> >>> type([])
[23:20:23] <Stemby> quella è una lista vuota
[23:20:35] <Stemby> verifichi che [] sia una lista
[23:20:52] <Stemby> come:
[23:20:55] <Stemby> >>> type('')
[23:21:02] <spirit> ok
[23:21:03] <Stemby> verifichi che quella è una stringa
[23:21:07] <Stemby> (vuota)
[23:21:25] <Stemby> bon, continuiamo
[23:21:33] <Stemby> ah, no
[23:21:46] <Stemby> eravamo rimasti alla non-spiegazione si spirit
[23:21:55] <Stemby> provo a spiegare io quel che ha fatto
[23:22:08] <|Wolf|> dove?
[23:22:09] <Stemby> >>> [0.5, 0.8] + ['pink']
[23:22:13] <|Wolf|> ok
[23:22:18] <Stemby> ha concatenato 2 liste
[23:22:25] <Stemby> la prima contenente 2 float
[23:22:35] <Stemby> la seconda contenente solo 1 stringa
[23:23:02] <Stemby> il risultato della concatenazione, ottenuta tramite l'operatore + messo tra le 2 liste, è una nuova lista
[23:23:28] <Stemby> [0.5, 0.8, 'pink']
[23:23:34] <Stemby> contenente 3 oggetti
[23:23:37] <Ernestus> capito Stemby... lo steso anche tra interi e float, interi e stringhe?
[23:23:41] <Ernestus> *stesso
[23:23:45] <|Wolf|> Ernestus, prova
[23:23:45] <Stemby> stesso
[23:23:54] <Stemby> comunque, come dice |Wolf|, prova
[23:23:58] <|Wolf|> *sempre* provare
[23:24:05] <Stemby> la shell interattiva è lì per quello
[23:24:23] <|Wolf|> 1) perché fai prima; 2) perché è l'unico modo per avere la risposta giusta;
[23:24:36] <Ernestus> type([1, 0.8] + ['0.9'])<class 'list'>
[23:24:37] <|Wolf|> se chiedi a Stemby potrebbe anche sbagliare o potresti non capire la risposta
[23:24:57] <|Wolf|> Ernestus, yep
[23:24:58] <Stemby> Ernestus: hai capito quello che hai fatto?
[23:25:19] <Ernestus> ho concatenato un intero e un float con un altro float
[23:25:23] <Ernestus> in una lista
[23:25:26] <Stemby> non solo
[23:25:39] <Ernestus> ho concatenato due liste
[23:25:44] <Stemby> per far quello bastava:
[23:25:54] <Stemby> >>> [1, 0.8] + ['0.9']
[23:25:57] <Stemby> (prova)
[23:26:18] <Stemby> altra cosa:
[23:26:21] <JumX> ma ['0.9'] non è stringa
[23:26:27] <Stemby> JumX: infatti
[23:26:27] <Ernestus> una lista
[23:26:32] <Stemby> sotavo per dirlo
[23:26:35] <Stemby> Ernestus: calma
[23:26:45] <Stemby> [1, 0.8] + ['0.9']
[23:26:53] <Stemby> questa è la concatenazione di 2 liste
[23:27:03] <Stemby> la prima contiente un intero e un float
[23:27:12] <Stemby> la seconda non contiene un float!
[23:27:15] <Stemby> ma una stringa
[23:27:33] <Stemby> Ernestus però ha fatto un'altra cosa
[23:27:41] <Stemby> type([1, 0.8] + ['0.9'])
[23:27:55] <Stemby> che non è uguale a
[23:27:57] <Stemby> [1, 0.8] + ['0.9']
[23:28:03] <Stemby> giusto?
[23:28:10] <Ernestus> ho chiesto a type di dirmi cos'è
[23:28:14] <|Wolf|> c'è il type() in più
[23:28:15] <Stemby> ok
[23:28:20] <Ernestus> quindi credo sia la stessa cosa
[23:28:22] <Stemby> no
[23:28:32] <Stemby> tu hai chiamato una funzione
[23:28:43] <Stemby> la funzione type()
[23:28:49] <|Wolf|> il concatenare le liste è uguale
[23:29:09] <|Wolf|> il risultato del concatenamento è poi andato a finire in type() che ne ha determinato il tipo
[23:29:24] <Stemby> Ernestus: nella spiegazione dovevi dirmelo
[23:29:57] <Stemby> tra l'altro c'era il dettaglio non trascurabile che il terzo oggetto è una stringa, e non un altro float
[23:30:10] <Stemby> quindi la spiegazione era sbagliata comunque
[23:30:25] <|Wolf|> quindi i passi che ha fatto python sono : type([1, 0.8] + ['0.9']) -> concatena le liste -> type([1, 0.8, '0.9']) -> determina il tipo di [1, 0.8, '0.9'] -> printa <class 'list'>
[23:30:30] <Stemby> cerchiamo di essere sintetici, ma esaurienti e per quanto possibile corretti
[23:31:00] <Stemby> ok?
[23:31:08] <amosse> ok
[23:31:15] <spirit> ok
[23:31:16] <Stemby> questo per dire: usiamo il terminale
[23:31:25] <Stemby> ma cerchiamo di capire anche cosa stiamo facendo
[23:31:30] <Stemby> altrimenti è inutile
[23:31:41] <Stemby> una cosa può funzionare
[23:31:45] <Stemby> (dare un risultato)
[23:32:01] <Stemby> ma è gravissimo se questo risultato non c'entra niente con quello che vogliamo noi
[23:32:09] <Stemby> è il tipo di bug più insidioso
[23:32:27] <Stemby> "il programma gira, quindi funziona"
[23:32:31] <Stemby> niente di più falso
[23:32:43] <JumX> infatti . ma è un bug  ?
[23:32:48] <Stemby> certo
[23:33:10] <Stemby> se noi vogliamo ottenere mele e otteniamo cavolfiori, è un bug
[23:33:23] <Stemby> ben peggiore di un syntax error
[23:33:47] <Stemby> (quello te lo mostra l'interprete)
[23:33:49] <JumX> JumX sta avendo serie perplessità su python ?!?!?!?
[23:33:56] <Stemby> ?
[23:34:08] <Stemby> in che senso?
[23:34:19] <JumX> Significa che non ti puoi fidare.
[23:34:26] <Stemby> è un computer
[23:34:31] <Stemby> mica un cristiano
[23:34:39] <Stemby> è un oggetto stupido
[23:34:51] <|Wolf|> JumX, di cosa non ti puoi fidare?
[23:34:52] <JumX> si ma uno + 1 deve dare 2 non asso per fischi
[23:34:54] <Stemby> lui fa quel che tu gli dici di fare
[23:35:19] <|Wolf|> appunto, bisogna fidarsi di python, non dell'umano che lo usa
[23:35:26] <|Wolf|> gli umani sbagliano, python no
[23:35:34] <|Wolf|> python fa quello che gli dice l'umano
[23:35:36] <JumX> no un attimo
[23:35:46] <JumX> wolf è il contraio
[23:35:52] <|Wolf|> se l'umano gli dice la cosa sbagliata python fa esattamente quello che l'umano gli ha detto, cioè una cosa sbagliata
[23:35:56] <Stemby> no, ha ragione
[23:36:13] <Stemby> se tu gli dici di fare una cosa sbagliata, lui la fa
[23:36:22] <Stemby> mica ti sa dire che la cosa è sbagliata
[23:36:27] <Stemby> è stupido
[23:36:32] <|Wolf|> JumX, se tu gli dici 1 + 1 lui ti darà sempre 2
[23:36:41] <|Wolf|> ma se tu gli dici '1' + '1', non ti dà 2
[23:36:45] <|Wolf|> ti dà '11'
[23:36:49] <|Wolf|> è questo è corretto
[23:36:51] <JumX> è stato un esempio ....
[23:36:53] <|Wolf|> ma non è quello che volevi tu
[23:37:06] <JumX> mi riferivo al type() ecc.ecc. vedi prima
[23:37:15] <Stemby> JumX: cioè?
[23:37:48] <JumX> l'hai detto tu:  <Stemby>: ma è gravissimo se questo risultato non c'entra niente con quello che vogliamo noi <Stemby>: è il tipo di bug più insidioso
[23:37:56] <Stemby> infatti!
[23:38:09] <Stemby> se tu per calcolare l'area di un triangolo gli dici:
[23:38:12] <Stemby> base * altezza
[23:38:20] <Stemby> lui ti darà un risultato
[23:38:30] <Stemby> solo che quella è l'area di un rettangolo
[23:38:35] <Stemby> non di un triangolo
[23:38:38] <JumX> ok
[23:38:47] <Stemby> mica ti sa dire:
[23:38:57] <Stemby> pirlone! devi dividere per 2!
[23:39:14] <Stemby> nessun linguaggio di programmazione è in grado di farlo
[23:39:28] <Stemby> è questo il bug più grave
[23:39:35] <Stemby> quando ottieni un risultato
[23:39:38] <Stemby> che è verosimile
[23:39:43] <Stemby> ma che è sbagliato
[23:39:54] <Stemby> se tu facessi:
[23:40:02] <Stemby> base * altezzu / 2
[23:40:07] <Stemby> lui ti direbbe:
[23:40:12] <Stemby> syntax error
[23:40:21] <Stemby> perché la variabile si chiama altezza
[23:40:24] <Stemby> e non altezzu
[23:40:32] <Stemby> correggi ed è fatta
[23:40:42] <Stemby> capisci la differenza?
[23:40:45] <JumX> ok mi hai chiarito la cosa.
[23:41:45] <Stemby> bon
[23:41:54] <Stemby> allora, se non ci sono domande direi di finire qui
[23:42:16] <Stemby> per la prossima volta:
[23:42:20] <Stemby> capitolo 6 fatto
[23:42:34] <spirit> ok
[23:42:35] <|Wolf|> gli lasciamo i koan?
[23:42:36] <Stemby> studiate i log, per mettervi in pari
[23:42:40] <amosse> io una domanda ce l'avrei:
[23:42:48] <Stemby> un attimo
[23:42:53] <Stemby> finiamo coi compiti
[23:42:57] <Stemby> ripeto:
[23:43:00] <Stemby> capitolo 6 fatto
[23:43:02] <Stemby> studiate i log, per mettervi in pari
[23:43:25] <Stemby> finite di applicare la tabella http://docs.python.org/release/3.1.3/library/stdtypes.html#sequence-types-str-bytes-bytearray-list-tuple-range
[23:43:41] <Stemby> alle liste, oltre che alle stringhe come avevamo già fatto (ripassare!)
[23:43:51] <Ernestus> si, maestro
[23:44:03] <Stemby> poi la prossima volta vedremo insieme l'altra tabella che volevo vedere oggi
[23:44:09] <Stemby> |Wolf|: proponi :)
[23:44:14] <JumX> capitolo 6 del libro Invent Your Own Computer Games with Python ?
[23:44:21] <Stemby> JumX: sì
[23:44:24] <|Wolf|> https://bitbucket.org/gregmalcolm/python_koans/wiki/Home
[23:44:28] <Stemby> più tutti i precedenti, ovviamente
[23:45:07] <|Wolf|> in pratica c'è un programmino che lanciate (quello che si vede nello screenshot) che vi dice quanti esericizi avete completato
[23:45:17] <|Wolf|> e poi ci sono diversi esercizi su diversi file
[23:45:50] <|Wolf|> e in ogni esercizio bisogna per esempio inserire la risposta giusta, sostituire una stringa, aggiungere una funzione e robe così
[23:46:02] <Stemby> mmmm, lo vediamo la prossima volta insieme=
[23:46:04] <Stemby> ?
[23:46:12] <|Wolf|> ok
[23:46:35] <Stemby> dai, per questa volta non vi do altro
[23:46:43] <Stemby> così avete tempo per mettervi in pari
[23:46:50] <Stemby> (ultima volta!)
[23:46:51] <JumX> grazie :D
[23:46:54] <Ernestus> fin troppo buono Stemby
[23:47:11] <Stemby> ovviamente script da sottoporci son sempre benvenuti
[23:47:11] <|Wolf|> btw, se avete dubbi potete venire su #python a chiedere
[23:47:24] <JumX> La nostra faccia sotto i tuoi piedi ... e ti puoi anche muovere !
[23:47:26] <Ernestus> |Wolf|, cosa significa btw?
[23:47:38] <|Wolf|> quindi se vi bloccate con qualcosa non aspettate mercoledì
[23:47:43] <|Wolf|> Ernestus, by the way
[23:47:53] <Ernestus> Grazie |Wolf|
[23:48:07] <Stemby> http://lmgtfy.com/?q=btw
[23:48:11] <spirit> ma sei lì |Wolf|?
[23:48:26] <spirit> su #python ?
[23:48:36] <|Wolf|> sì
[23:48:40] <|Wolf|> c'è sempre qualcuno
[23:48:54] <Stemby> anche qui su #debianizzati-corsi
[23:49:00] <spirit> ok grazie per la tua disponibilità
[23:49:00] <|Wolf|> in genere ci sono 30-40 persone
[23:49:08] <Stemby> comuqnue su #python c'è più gente
[23:49:10] <Stemby> :)
[23:49:12] <|Wolf|> e qualcuno può rispondere
[23:49:50] <amosse> come si fa a: 1) passare un file .txt ad uno script, 2) leggere il contenuto di tutte le righe, 3) raggruappare il contenuto in base ad alcuni valori, 4) restituire il file .txt modificato.
[23:49:53] <Stemby> per i log mancanti: per favore segnalatelo sul forum
[23:50:03] <Stemby> così per ogni altra cosa
[23:50:12] <Stemby> non restate imbambolati una settimana intera
[23:50:19] <Ernestus> segnalo io
[23:50:42] <Ernestus> sono i log del 9 marzo?
[23:50:48] <Stemby> amosse: 1) prossima volta
[23:50:51] <Stemby> 2) pure
[23:50:58] <Stemby> 3) ?
[23:51:04] <Stemby> 4) prossima volta
[23:51:23] <|Wolf|> amosse, hint: usando open() e i file object
[23:51:24] <amosse> ok
[23:51:24] <Stemby> input/output su file è un argomento di lezione
[23:51:34] <Stemby> è inutile spiegarlo ora solo per te
[23:51:54] <amosse> ok hai ragione
[23:52:23] <amosse> wolf: hint:?
[23:52:37] <JumX> ok notte a tutti
[23:52:50] <JumX> e grazie per la pazienza
[23:52:52] <|Wolf|> hint == suggerimento
[23:52:56] <Ernestus> io vado... buonanotte a tutti
[23:52:57] <Ernestus> a mercoled'
[23:53:02] <Ernestus> mercoledì
[23:53:04] <Stemby> fate i compiti!
[23:53:11] <|Wolf|> e usate l'interprete!
[23:53:15] <|Wolf|> tutti i giorni!
[23:53:16] <JumX> ok stemby ciao
[23:53:17] <Stemby> così possiamo accelerare un po'
[23:53:21] <Stemby> notte
[23:53:25] <amosse> ah.. ok