Accademia:Log 2011 03 16

21:31:00 -!- risca [~risca@Azzurra-7C994BBC.clienti.tiscali.it] has joined #debianizzati-corsi
21:31:00 -!- Topic for #debianizzati-corsi: Canale dedicato ai corsi organizzati dalla comunità italiana utenti debian di Debianizzati.org | info: www.debianizzati.org , #debianizzati | Accademia Python3: http://frm.li/6WeXTX
21:31:00 -!- Topic set by Jinko [] [Wed Feb 23 22:17:42 2011]
21:31:00 [Users #debianizzati-corsi]
21:31:00 [ amosse] [ groll] [ risca] [ Stemby] [ |Wolf|] 
21:31:00 -!- Irssi: #debianizzati-corsi: Total of 5 nicks [0 ops, 0 halfops, 0 voices, 5 normal]
21:31:00 -!- Channel #debianizzati-corsi created Wed Mar 16 20:23:12 2011
21:31:01 -!- Irssi: Join to #debianizzati-corsi was synced in 1 secs
21:31:14 [Users #debianizzati-corsi]
21:31:14 [ amosse] [ groll] [ risca] [ Stemby] [ |Wolf|] 
21:31:14 -!- Irssi: #debianizzati-corsi: Total of 5 nicks [0 ops, 0 halfops, 0 voices, 5 normal]
21:32:22 < Stemby> buonase
21:32:24 < Stemby> ra
21:32:42 < Stemby> mmm, aspettiamo ancora un attimo
21:32:46 < Stemby> ciao risca
21:33:11 < amosse> Ciao stamby risca
21:33:55 < Stemby> il wiki è stato sistemato?
21:35:21 -!- Ernestus [~ernesto@Azzurra-5453E698.44-79-r.retail.telecomitalia.it] has joined #debianizzati-corsi
21:35:31 < Ernestus> sera
21:35:43 < amosse> Ciao Ernestus 
21:35:53 -!- spirit [~spirit@Azzurra-C3C291C.104-82-b.business.telecomitalia.it] has joined #debianizzati-corsi
21:36:09 < spirit> Buonasera
21:36:13 < risca> buona sera a tutti
21:36:15 < risca> come va?
21:36:16 < Ernestus> sera spirit risca 
21:36:24 < spirit> ciao risca
21:36:42 < risca> ho appena finito con qualche modifica al wiki
21:36:46 < Stemby> oh, ci siam quasi tutti
21:36:49 < risca> però non sono ancora soddisfatto
21:36:50 < Stemby> adesso guardo
21:36:58 < Stemby> le pagine dei log?
21:37:14 < risca> solo alcuni
21:37:54 < risca> ho solo quello del 9, gli altri mi mancano. Voi?
21:38:34 < Stemby> se mi preparate le pagine, poi li incollo io
21:38:44 < risca> ok
21:40:01 < Stemby> allora, butto giù un boccone e vi raggiungo
21:40:01 < Ernestus> risca, ho i permessi?
21:42:22 < risca> i permessi li hanno tutti quelli che sono iscritti al wiki
21:42:28 < risca> se sei iscritti hai i permessi
21:43:02 < Ernestus> sono iscritto
21:44:07 < risca> allora puoi editare qualsiasi pagina senza problemi
21:44:42 < Ernestus> confermo
21:44:55 < risca> perfetto!
21:45:21 < |Wolf|> qual è il programma della serata?
21:46:13 < spirit> il cap 6 del libro poi non sò..
21:46:43 < |Wolf|> di cosa parla il capitolo 6?
21:47:18 < amosse> funzioni 
21:47:24 < amosse> namespaces
21:48:01 < spirit> è un gioco in cui si creano oggetti con def
21:48:52 < amosse> si..., credo di si
21:49:39 < spirit> oggetti funzioni
21:49:42 < amosse> oltre che parametri e argomenti
21:49:48 < spirit> si
21:50:40 < spirit> poi bool
21:50:45 < risca> ragazzi, torno tra un'oretta
21:50:50 < Stemby> eccomi
21:50:57 < amosse> ok
21:51:00 < risca> tranquilli che poi leggo tutto ciò che avete scritto
21:51:14 < risca> Stemby, ragazzi, buon lavoro
21:51:26 < amosse> grazie
21:51:36 < spirit> a dopo
21:51:39 < Stemby> allora iniziamo
21:51:42 < risca> (p.s.: se avete consigli su come migliorare il wiki, nella funzionalità e layout, scrivetemi!)
21:51:44 < risca> a dopo
21:51:46 < risca> ciauz
21:51:58 < Stemby> l'ultima lezione abbiamo introdotto le liste
21:52:10 < Stemby> il capitolo 6 l'avete fatto tutti?
21:52:19 < amosse> si
21:52:21 < spirit> si
21:52:30 < Stemby> dubbi?
21:52:45 < amosse> no
21:52:55 < spirit> a grandi linee, no
21:52:56 < Ernestus> no
21:53:05 < Stemby> spirit: e a linee piccole?
21:53:27 < Stemby> chiaro il concetto di scopo di una variabile?
21:53:32 < spirit> bè, non sò risponderti
21:53:41 < |Wolf|> scope?
21:53:45 < Stemby> sì
21:53:54 < Stemby> variabili locali e globali
21:54:06 < |Wolf|> è un typo o una traduzione approssimativa? :P
21:54:34 < Stemby> credo che il manualone della o'really usi questa traduzione
21:54:35 < Stemby> controllo
21:54:47 < Stemby> *o'reilly
21:54:53 < |Wolf|> la traduzione sarebbe qualcosa tipo "visibilità"
21:55:05 < |Wolf|> scopo vuol dire un'altra cosa
21:55:47 < Stemby> confermo: scopi
21:55:54 < |Wolf|> credo abbia la stessa radice di -scopio in periscopio (che dovrebbe voler dire vedere intorno)
21:57:02 < |Wolf|> i.e. lo scope è quella "zona" del codice dove una variabile è visibile
21:57:30 < Stemby> anche a me sembra una traduzione grossolana
21:57:34 < Stemby> comunque basta capirsi
21:57:37 < amosse> va bene anche namespaces?
21:57:43 < Stemby> sì, va bene
21:57:47 < |Wolf|> il namespace è un concetto più generale
21:57:47 < Stemby> spazio dei nomi
21:58:10 < |Wolf|> cmq sono simili
21:58:18 < amosse> ok
21:59:29 < Stemby> se nessuno ha domande...
21:59:31 < Stemby> allora
21:59:38 < spirit> un esempio di namespace?
22:00:05 < Stemby> è l'ambito di validità di una variabile
22:00:17 < spirit> ah, ok.
22:00:21 < |Wolf|> ogni modulo ha un suo namespace
22:00:36 < |Wolf|> es. quando fai math.qualcosa
22:00:40 < Stemby> e ogni funzione all'interno del modulo ha il sui
22:00:42 < Stemby> *suo
22:00:55 < |Wolf|> stai accedendo all'oggetto 'qualcosa' definito nel namespace/modulo math
22:01:16 < |Wolf|> quando fai "import math" sta importando il nome/modulo math nel namespace locale
22:01:23 < spirit> math l'ho studiato...
22:01:36 < |Wolf|> e quando fai "x = 10" stai definendo il nome 'x' nel namespace locale
22:02:01 < spirit> chiaro grazie
22:02:33 < Stemby> ok
22:02:39 < Stemby> allora proseguiamo
22:02:44 < Stemby> iniziamo col dare i compiti
22:02:51 < Stemby> capitolo 7
22:03:47 < Stemby> guarda caso, si parla di un argomento saltato fuori settimana scorsa
22:04:34 < Stemby> i bug
22:05:02 < Stemby> viene affrontato l'argomento usando un debugger
22:05:15 < Stemby> |Wolf| vi dirà che in python è inutile
22:05:32 < |Wolf|> già
22:05:42 < Stemby> però dateci una lettura, secondo me è carino per capire bene come gira il programma
22:05:57 < Stemby> utilizza il debugger integrato in IDLE
22:06:09 < Stemby> IDLE è usato in tutto il libro
22:06:20 < Stemby> non so se avete provato ad installarlo
22:06:27 < Stemby> aptitude install idle3
22:06:51 < amosse> é migliore di Geany?
22:06:53 < Stemby> credo che sia usato solo dal nostro benevolo dittatore
22:07:04 < Stemby> tutti gli altri lo detestano
22:07:17 < Stemby> però il debugger è bellino
22:07:30 < |Wolf|> mi sa che neanche Guido lo usa
22:07:35 < |Wolf|> e come debugger usa pdb :P
22:08:02 < Stemby> comunque, per seguire il libro, installatelo
22:08:04 < Stemby> non costa niente
22:08:14 < Stemby> poi probabilmente non lo userete mai
22:08:27 < spirit> ok
22:08:38 < Stemby> questo per domenica
22:08:53 < Stemby> ora riprendiamo le liste
22:08:56 < amosse> ok
22:09:01 < Stemby> tutto chiaro quanto fatto finora?
22:09:13 < spirit> abbastanza
22:09:17 < amosse> si
22:10:23 < Stemby> spirit: abbastanza?
22:10:34 < Stemby> intanto: cos'è una lista?
22:10:56 < spirit> è un elenco ordinato
22:11:07 < Stemby> mmm
22:11:15 < Stemby> in termini molto generali
22:11:20 < Stemby> è un o...
22:11:33 < spirit> oggetto
22:11:37 < Stemby> pre...
22:11:42 < spirit> definito
22:11:45 < Stemby> :)
22:12:07 < Stemby> più precisamente, lo possiamo classificare tra le s..
22:12:21 < spirit> stringhe
22:12:24 < Stemby> no!!!
22:12:27 < Stemby> se...
22:12:37 < Stemby> seq...
22:12:38 < spirit> ah sequenze
22:12:40 < Stemby> :)
22:12:47 < Stemby> assieme a:
22:12:47 < spirit> mi sono fritto da solo
22:12:55 < spirit> caratteri
22:13:00 < Stemby> ?
22:13:14 < Stemby> quali sono le altre sequenze predefinite?
22:13:28 < Stemby> una l'abbiamo vista piuttosto a fondo
22:13:44 < Stemby> l'altra la faremo prossimamente (l'abbiamo solo sentita di nome)
22:13:50 < Stemby> 1) st...
22:13:55 < Stemby> 2) l...
22:13:57 < spirit> type str
22:13:59 < Stemby> 3) tu...
22:14:03 < spirit> tuple
22:14:08 < spirit> dzionari
22:14:08 < Stemby> ok
22:14:10 < Stemby> no
22:14:17 < Stemby> i dizionari non sono sequenze
22:14:27 < Stemby> solo stringhe, liste e tuple
22:14:32 < spirit> ok
22:14:51 < amosse> anche range?
22:15:00 < Stemby> range è una funzione
22:15:51 < amosse> no perché troviamo "Sequence Types — str, bytes, bytearray, list, tuple, range"
22:16:04 < Stemby> ah sì?
22:16:09 < Stemby> non so cosa sia
22:16:13 < Stemby> dove l'hai trovato?
22:16:24 < Stemby> nella doc
22:16:29 < Stemby> adesso guardo
22:16:42 < amosse> anche io non ho capito
22:17:20 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#sequence-types-str-bytes-bytearray-list-tuple-range
22:17:26 < Stemby> |Wolf|: sai aiutarci?
22:18:11 < Stemby> comunque, la tabella subito lì sotto avete provato ad applicarla alle liste?
22:18:47 < Stemby> amosse, spirit, Ernestus?
22:19:10 < Stemby> [s/n]
22:19:26 < spirit> solo alla lez. prec, m
22:19:43 < Ernestus> si, l'ho vista
22:19:47 < spirit> in questi giorni no
22:20:00 < |Wolf|> riguardo a range?
22:20:05 < Stemby> |Wolf|: sì
22:20:22 < |Wolf|> tecnicamente è un oggetto a sé stante
22:20:31 < |Wolf|> però è un po' particolare
22:20:56 < |Wolf|> potete continuare a considerarlo una funzione normale
22:21:23 < Stemby> ok
22:22:01 < Stemby> intanto allora, visto che spirit non l'ha fatto (male...):
22:22:17 < Stemby> Ernestus: puoi farci un esempio di indirizzamento con un lista?
22:22:36 < Stemby> la lista falla composta da un po' di oggetti vari a scelta tua
22:22:57 < Stemby> tra stringhe, float e booleani
22:23:04 < Ernestus> va bene
22:23:37 < Stemby> fallo nell scell
22:23:41 < Stemby> *shell
22:23:58 < Ernestus> lista = ["carne" , "pesce" , 10 , "uova" , 4.5]
22:23:59 < Stemby> e incolla sia l'espressione che l'output
22:24:00 < Ernestus> questa è la lista
22:24:03 < Ernestus> (della spesa)
22:24:07 < Stemby> Ernestus: senza variabili
22:24:22 < Stemby> 10 è un intero
22:24:31 < Stemby> avevo detto:
22:24:33 < Stemby> tra stringhe, float e booleani
22:24:51 < Ernestus> hai ragione
22:25:21 < Ernestus> lista = ["carne" , "pesce" , True , "uova" , 4.5]
22:25:26 < Stemby> senza variabili
22:25:26 < Ernestus> così il booleano?
22:25:34 < Ernestus> ["carne" , "pesce" , True , "uova" , 4.5]
22:25:36 < Stemby> come cos'è un booleano...
22:25:41 < Stemby> esatto
22:25:50 < Stemby> True è un booleano
22:25:50 < Ernestus> così non cos'è
22:26:01 < Stemby> ok
22:26:02 < Ernestus> prima avevo scritto x = True 
22:26:05 < Ernestus> ed ero indeciso
22:26:17 < Stemby> no, no, è giusto l'ultimo
22:26:28 < Stemby> però non ti avevo chiesto una lista
22:26:38 < Stemby> ti avevo chiesto un esempio di indirizzamento
22:26:58 < Stemby> (indexing in inglese)
22:27:32 < Stemby> Ernestus: chiara la richiesta?
22:27:45 < Ernestus> si, ma non credo di essere in grado di soddisfarla
22:27:57 < Stemby> allora non è chiara la richiesta
22:28:05 < Stemby> perché è facilissimo
22:28:10 < Stemby> spirit: sai aiutare Ernestus?
22:28:17 < spirit> 1 in [1, 2, '3', 'pink', 0.10]
22:28:21 < Stemby> no
22:28:29 < Stemby> cos'è l'indirizzamento?
22:28:35 < Stemby> l'abbiamo visto con le stringhe
22:28:44 < Stemby> la lezione l'aveva fatta risca
22:28:51 < Stemby> perché io ero arrivato tardi
22:28:58 < spirit> con slice?
22:29:05 < Stemby> quasi
22:29:10 < Stemby> slice è l'affettamento
22:29:18 < Stemby> indexing è l'indirizzamento
22:29:29 < Stemby> una è una fetta
22:29:31 < Ernestus> Stemby, mi confondevo anche io
22:29:46 < Stemby> l'altro è un singolo elemento estratto
22:30:14 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#sequence-types-str-bytes-bytearray-list-tuple-range
22:30:18 < Stemby> la solita tabella
22:30:33 < Ernestus> sisi ce l'avevo sotto mano dapprima
22:30:36 < Stemby> la quinta riga è l'indirizzamento
22:30:53 < Stemby> la sesta e la settima sono l'affettamento
22:31:13 < Stemby> io avevo chiesto un esempio di indirizzamento con la lista che mi hai fatto
22:31:25 < Stemby> chiaro?
22:31:35 < Stemby> Ernestus: ↑
22:31:38 < Stemby> chiaro ora?
22:31:39 < amosse> ok
22:31:45 < Stemby> amosse: non tu
22:31:47 < Stemby> :)
22:31:49 < Stemby> fermo
22:31:54 < Stemby> che so che sai rispondere
22:31:54 < Ernestus> sisi chiaro spirit 
22:32:03 < Ernestus> volevo dire Stemby 
22:32:05 < Stemby> Ernestus: forza
22:32:16 < Stemby> com'è la sintassi?
22:32:20 < Stemby> leggi la doc
22:32:31 < Stemby> s[i]
22:32:36 < Stemby> s sta per?
22:32:37 < Ernestus> elemento in Lista
22:32:44 < Stemby> ?
22:32:56 < Stemby> s cosa indica?
22:33:01 < Ernestus> stringa
22:33:02 < Ernestus> ?
22:33:04 < Stemby> no
22:33:08 < Stemby> è più generale
22:33:20 < spirit> funzione
22:33:26 < Stemby> s fi funzione?
22:33:31 < Stemby> *di
22:33:40 < Stemby> sarebbe stata una f, no?
22:33:43 < Stemby> invece è s
22:33:52 < Stemby> che cosa stiamo trattando?
22:34:08 < Stemby> le s...
22:34:14 < Stemby> se...
22:34:17 < Stemby> seq...
22:34:21 < spirit> uenze
22:34:26 < Stemby> alleluia
22:34:42 < Stemby> quindi al posto della s ci puoi mettere una stringa, o anche una lista
22:34:47 < Stemby> (o una tupla, ecc.)
22:34:49 < Stemby> ok?
22:35:05 < Stemby> Ernestus: ↑
22:35:14 < spirit> ok
22:35:21 < Stemby> ["carne" , "pesce" , True , "uova" , 4.5]
22:35:21 < Ernestus> si Stemby 
22:35:32 < Stemby> allora estraimi un elemento da quella lista
22:36:20 < Ernestus> [2]
22:36:27 < Stemby> fai l'espressione
22:36:30 < Stemby> nella shell
22:36:35 < Stemby> voglio vedere tutto
22:36:38 < Stemby> >>> compresi
22:37:01 < Ernestus> >>> ["carne" , "pesce" , True , "uova" , 4.5]
22:37:01 < Ernestus> ['carne', 'pesce', True, 'uova', 4.5]
22:37:01 < Ernestus> >>> [2]
22:37:01 < Ernestus> [2]
22:37:31 < Stemby> che roba è quella?
22:37:36 < Stemby> quella è una lista
22:37:44 < Stemby> contenente solo un intero (2)
22:37:56 < Stemby> com'è la sintassi?
22:38:02 < Stemby> s[i]
22:38:47 < Stemby> abbiamo detto che al posto della s ci mettiamo la lista
22:38:58 < Stemby> e al posto di [i] ci mettiamo [2]
22:39:04 < Stemby> forza
22:40:24 < Stemby> Ernestus: ...
22:40:32 < Stemby> hai tutti fli
22:40:37 < Stemby> *gli elementi
22:40:56 < Stemby> spirit: tu hai capito?
22:41:02 < Ernestus> >>> ["carne" , "pesce" , True , "uova" , 4.5][2]
22:41:02 < Ernestus> True
22:41:10 < Stemby> Ernestus: oh!
22:41:12 < Stemby> esatto
22:41:32 < Stemby> ora, spirit, estaimi le uova
22:43:07 < spirit> ["carne" , "pesce" , True , "uova", 4.5][3]
22:43:16 < spirit> 'uova' 
22:43:19 < Stemby> ottimo
22:43:28 < Stemby> ora proviamo un esempio di affettamento
22:43:46 < Stemby> spirit: estraimi tutti gli elementi dal pesce fino alla fine della lista
22:44:12 < Stemby> ("pesce" compreso)
22:44:12 < spirit> ["carne" , "pesce" , True , "uova", 4.5][0]
22:44:23 < Stemby> spirit: no
22:44:34 < Stemby> così ti dà 'carne', no?
22:44:48 < Stemby> ti ho chiesto all'incira il contrario
22:45:11 < spirit> [["carne" , "pesce" , True , "uova", 4.5]][0] 
22:45:20 < Stemby> ?
22:45:26 < Stemby> incolla anche l'output...
22:45:26 < groll> quella è una lista dentro una lista
22:45:34 < spirit> ['carne', 'pesce', True, 'uova', 4.5]
22:45:39 < Stemby> visto?
22:45:44 < Stemby> non hai estratto niente
22:45:48 < spirit> già
22:45:56 < Stemby> o, meglio, hai estratto tutta la lista dento alla lista
22:46:05 < Stemby> spirit: è chiaro cos'è l'affettamento?
22:46:12 < Stemby> (slicing, in inglese)
22:46:26 < spirit> più o meno
22:46:34 < Stemby> è simile all'indirizzamento, ma è un'altra cosa
22:46:49 < Stemby> guarda la sesta riga della tabella
22:46:57 < spirit> lo mette sempre tra []
22:47:11 < Stemby> com'è la sintassi?
22:47:18 < Stemby> (copiala dalla tabella)
22:47:33 < spirit> s[i:j]
22:47:42 < Stemby> esatto
22:47:45 < Stemby> s sta per?
22:47:56 < spirit> sequenza
22:48:11 < Stemby> quindi al posto di s cosa ci possiamo mettere?
22:48:51 < Stemby> spirit: ...
22:48:58 < spirit> ["carne" , "pesce" , True , "uova", 4.5]
22:49:02 < Stemby> ad esempio
22:49:08 < Stemby> e poi?
22:49:13 < Stemby> [i:j]
22:49:20 < spirit> [2:5]
22:49:21 < Stemby> cosa ci mettiamo, lì?
22:49:23 < Ernestus> i: intero?
22:49:31 < Stemby> sì
22:49:33 < Stemby> anche j
22:50:15 < Stemby> prova con [2:5]
22:50:25 < Stemby> e vedi cosa viene fuori
22:50:41 < spirit> solito err
22:50:47 < Stemby> che errore?
22:50:56 < spirit> [True, 'uova', 4.5]
22:51:11 < Stemby> ok, niente errore
22:51:19 < Stemby> o, meglio, errore tuo
22:51:31 < Stemby> nel senso che il risultato non è coerente con le mie richieste
22:51:43 < Stemby> suggerimento: python inizia a contare da 0...
22:52:05 < Stemby> (io ti avevo chiesto anche il pesce)
22:52:34 < spirit> ["carne" , "pesce" , True , "uova", 4.5][0:5]    
22:52:57 < Stemby> ok, quasi giusto
22:52:59 < spirit> ['carne', 'pesce', True, 'uova', 4.5] 
22:53:09 < Stemby> no
22:53:17 < Stemby> la carne non la volevo
22:53:25 < spirit> ah..
22:53:27 < Stemby> dal pesce alla fine
22:53:34 < Stemby> pesce compreso
22:53:42 < spirit> ["carne" , "pesce" , True , "uova", 4.5][1:5]    
22:53:56 < Stemby> ok
22:54:03 < Stemby> rimane solo una cosina
22:54:26 < Stemby> "fino alla fine" ha una sintassi particolare
22:54:38 < Stemby> Ernestus: sai aiutare spirit?
22:55:06 < spirit> risultato senza [] ?
22:55:16 < Ernestus> [1:-5]
22:55:21 < Stemby> no
22:55:47 < Stemby> ["carne" , "pesce" , True , "uova", 4.5][1:]
22:55:56 < Stemby> questo è ciò che avevo chiesto
22:56:14 < Stemby> se non si specifica j, si intente "fino alla fine"
22:56:31 < Stemby> come se non si specifica i, si intende "dall'inizio"
22:56:43 < spirit> iesimo  a jota
22:57:00 < Ernestus> un momento
22:57:08 < Ernestus> il meno conta da sinistra?
22:57:15 < Stemby> ad esempio, provate, con la stessa lista, ad estrarre tutti gli elementi dall'inizio alle uova
22:57:19 < Stemby> uova escluse
22:57:25 < Stemby> il meno conta dal fondo
22:57:32 < Stemby> -1 è l'ultimo elemento
22:57:35 < Stemby> -2 il penultimo
22:57:37 < Stemby> ecc.
22:57:50 < Stemby> in questo caso non serviva
22:58:09 < Stemby> fate l'espressione che ho chiesto
22:58:29 < Stemby> tutti gli elementi dall'inizio alle uova. uova escluse
22:58:59 < spirit> ["carne" , "pesce" , True , "uova", 4.5][:3] 
22:59:00 < amosse> ["carne" , "pesce" , True , "uova", 4.5][:-2]
22:59:19 < Stemby> ok tutte e due
22:59:34 < Stemby> sono tutte e due espressioni valide
22:59:36 < Ernestus> compreso
23:00:03 < Stemby> tutto questo era spiegato nella nota 4
23:00:13 < Stemby> (sotto alla tabella)
23:00:23 < Stemby> che avreste dovuto leggere per compito...
23:00:54 < Stemby> infatti tutte le prove che abbiamo fatto ora insieme vi avevo chiesto di farle a casa in autonomia
23:01:27 < Stemby> così ci resta poco tempo per spiegare cose nuove
23:01:30 < Stemby> allora
23:01:44 < Stemby> le altre cose presenti in quella tabella, guardatele da soli
23:02:00 < Stemby> se ci sono dubbi, chiedete e le riprendiamo la prossima volta
23:02:15 < amosse> ok
23:02:27 < Stemby> ora andiamo qui: http://docs.python.org/release/3.1.3/library/stdtypes.html#mutable-sequence-types
23:02:46 < Stemby> l'altra volta abbiamo detto che sia le strighe che le liste sono...
23:04:03 < Stemby> c'è nessuno???
23:04:24 < Ernestus> ci sono
23:04:24 < spirit> si un attimo..
23:04:28 < Stemby> che cosa sono sia le stringhe che le liste?
23:04:59 < spirit> ok
23:05:04 < Stemby> ok?
23:05:06 < Stemby> ok cosa
23:05:13 < spirit> ci sono..
23:05:20 < Stemby> allora?
23:05:34 < Stemby> qual è la risposta alla domanda?
23:05:41 < Stemby> che cosa sono sia le stringhe che le liste?
23:05:50 < amosse> sono sequenze
23:06:04 < Stemby> ok
23:06:20 < amosse> non modificabili le prime, modificabili le seconde
23:06:36 < Stemby> dunque la tabella che abbiamo visto l'altra volta e stasera è valida per entrambi
23:06:42 < Stemby> *entrambe
23:06:48 < Stemby> amosse: esatto
23:07:15 < Stemby> infatti la tabella che vediamo ora (l'ultimo link), per le stringhe non vale
23:08:13 < Stemby> vediamo la prima riga
23:08:28 < Stemby> s[i] = x
23:08:44 < Stemby> al posto di s ci mettiamo una lista vuota
23:09:02 < Stemby> al posto di x ci mettiamo un oggetto a scelta
23:09:19 < Stemby> 'pippo', ad esempio
23:09:33 < Stemby> forza
23:09:35 < Stemby> proviamo
23:10:15 -!- hoax [[U2FsdGVkX@Azzurra=374EC107.chello.nl] has joined #debianizzati-corsi
23:10:39 < Stemby> no, così non funziona
23:10:42 < Stemby> un secondo
23:11:15 < Stemby> niente, dobbiamo per forza usare una variabile
23:11:28 < Stemby> e la lista deve avere almeno un elemento
23:11:35 < Stemby> fate così:
23:11:53 < Stemby> >>> prova = ['ciao']
23:12:10 < Stemby> ora usate quella sintassi per modificare il contenuto
23:12:21 < Stemby> e mettere 'pippo' al posto di 'ciao'
23:12:31 < Stemby> al posto di s ovviamente mettiamo prova
23:12:43 < Stemby> (la variabile che rappresenta la nostra lista)
23:12:50 < Ernestus> un attimo
23:13:19 < Ernestus> lista vuota []?
23:13:24 < Stemby> no
23:13:30 < Stemby> >>> prova = ['ciao']
23:14:36 < Stemby> fatto?
23:14:58 < Ernestus> prova = ['ciao'][0] = 
23:15:02 < Stemby> no
23:15:05 < Stemby> >>> prova = ['ciao']
23:15:09 < Stemby> quello e basta
23:15:30 < Stemby> poi usiamo la sintassi della prima linea della tabella
23:16:02 < Stemby> s[i] = x
23:16:11 < Stemby> al posto di s ci mettiamo prova
23:16:24 < Stemby> (la variabile che contiene la nostra lista)
23:16:37 < Stemby> al posto di i ci mettiamo... ovviamente 0
23:16:45 < Stemby> (è l'unico elemento della lista)
23:16:55 < Stemby> al posto di x ci mettiamo 'pippo'
23:16:58 < Stemby> fatto?
23:17:14 < spirit> si.
23:17:19 < Stemby> Ernestus: ?
23:17:30 < Stemby> amosse: ?
23:17:35 < amosse> ok
23:17:38 < Ernestus> devo capire le cose: non posso farle e basta
23:17:50 < Stemby> ora se fate:
23:17:56 < Stemby> >>> prova
23:17:57 < amosse> ok fubziona
23:18:01 < Stemby> cosa ottenente?
23:18:05 < amosse> *funziona
23:18:21 < amosse> ['pippo']
23:18:38 < Stemby> spirit: anche per te?
23:18:49 < spirit> si.
23:18:52 < Stemby> Ernestus: ?
23:18:55 < Ernestus> >>> prova = ['ciao']
23:18:55 < Ernestus> >>> prova[0] = "pippo"
23:18:55 < Stemby> hai capito?
23:19:04 < Ernestus> non restituisce niente
23:19:09 < Stemby> >>> prova
23:19:19 < Stemby> certo che non restituisce niente
23:19:34 < Stemby> tu gli chiedi di sostituire l'elemento 0 della lista con 'pippo'
23:19:35 < Stemby> punto
23:19:40 < Stemby> lo fa e basta
23:19:41 -!- weirdo [~H2O2@Azzurra-79429305.clienti.tiscali.it] has joined #debianizzati-corsi
23:19:44 -!- mode/#debianizzati-corsi [+o weirdo] by ChanServ
23:19:50 < Stemby> se fai
23:19:53 < Stemby> >>> prova
23:19:59 <@weirdo> o/
23:20:03 < Stemby> vedrai che il contenuto è cambiato
23:20:10 < Stemby> ciao weirdo
23:20:15 < Stemby> ricapitolando:
23:20:28 < Stemby> >>> prova = ['ciao']
23:20:28 < Stemby> >>> prova[0] = 'pippo'
23:20:28 < Stemby> >>> prova
23:20:28 < Stemby> ['pippo']
23:20:34 < Stemby> Ernestus: chiaro?
23:20:43 < Ernestus> >>> prova
23:20:43 < Ernestus> ['pippo']
23:20:44 < Ernestus> si
23:20:50 < Stemby> ora facciamo così
23:21:28 < Stemby> prova = ['mirtilli', 'lamponi', 'zucchine', 'fragole']
23:21:39 < Stemby> sostituitemi le zucchine con delle fragole
23:21:45 < Stemby> sorry
23:21:53 < Stemby> non con delle fragole, ma con delle more
23:21:57 < Stemby> le fragole ci son già
23:22:33 < Ernestus> prova[02] = "more"
23:22:37 < Ernestus> *2
23:22:42 < Ernestus> c'è uno zero in piu
23:22:55 < Stemby> Ernestus: incolla dalla shell
23:22:59 < Stemby> >>> compresi
23:23:04 < Stemby> così non ci si sbaglia
23:23:38 < Stemby> >>> prova = ['mirtilli', 'lamponi', 'zucchine', 'fragole']
23:23:38 < Stemby> >>> prova[2] = 'more'
23:23:38 < Stemby> >>> prova
23:23:38 < Stemby> ['mirtilli', 'lamponi', 'more', 'fragole']
23:23:39 < Ernestus> >>> prova = ['mirtilli', 'lamponi', 'zucchine', 'fragole']
23:23:39 < Ernestus> >>> prova[2] = "more"
23:23:39 < Ernestus> >>> prova
23:23:39 < Ernestus> ['mirtilli', 'lamponi', 'more', 'fragole']
23:23:44 < Ernestus> fregato in velocità
23:23:47 < Stemby> :)
23:24:00 < Stemby> spirit: chiaro?
23:24:07 < spirit> si
23:24:09 < Stemby> amosse: ?
23:24:28 < amosse> ok chiaro
23:24:45 < Stemby> abbiamo detto che le stringhe invece non sono modificabili
23:24:52 < Stemby> quindi quella sintassi non dovrebbe funzionare
23:24:54 < Stemby> proviamo
23:25:11 < Stemby> prova = 'cavoro'
23:25:25 < Stemby> proviamo a correggere 'cavoro' in 'cavolo'
23:25:49 < groll> sera
23:26:05 < amosse> ciao groll 
23:26:06 < Stemby> >>> prova = 'cavoro'
23:26:06 < Stemby> >>> prova[4] = 'l'
23:26:06 < Stemby> Traceback (most recent call last):
23:26:06 < Stemby>   File "<stdin>", line 1, in <module>
23:26:06 < Stemby> TypeError: 'str' object does not support item assignment
23:26:09 < Stemby> ciao groll
23:26:21 < Stemby> visto che non funziona?
23:26:28 < amosse> ok
23:26:51 < Stemby> spirit, Ernestus, ci siete anche voi?
23:26:55 < groll> uhm ho un esercizio da proporgli
23:27:03 < spirit> si, cercavo di capire
23:27:03 < Ernestus> io ci sono sempre
23:27:07 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#mutable-sequence-types
23:27:21 < Stemby> quella tabella è applicabile alle liste, che sono modificabili
23:27:29 < Stemby> non alle stringhe, che non sono modificabili
23:27:51 < spirit> chiaro.
23:27:56 < Stemby> mentre la tabella che abbiamo visto l'altra volta e all'inizio di questa serata è valida per entrambe
23:28:29 < amosse> pk
23:28:35 < amosse> *ok
23:28:37 < Stemby> lo slice lo vedete da soli
23:28:54 < Stemby> guardiamo il mettodo append, che è molto utile
23:29:29 < Stemby> same as s[len(s):len(s)] = [x]
23:29:35 < Stemby> non so se è chiarissimo
23:30:49 < risca> buona sera...
23:30:56 < risca> ho appena finito di leggere i LOG
23:31:04 < risca> adesso mi accodo al maestro
23:31:18 < Stemby> >>> prova = ['mirtilli', 'lamponi', 'more', 'fragole']
23:31:18 < Stemby> >>> prova[5:5] = ['ribes']
23:31:18 < Stemby> >>> prova
23:31:18 < Stemby> ['mirtilli', 'lamponi', 'more', 'fragole', 'ribes']
23:31:18 < Ernestus> cosa serve il metodo append?
23:31:25 < Ernestus> same as
23:31:34 < Stemby> Ernestus: fa in pratica quello che ho appena fatto
23:31:47 < Stemby> same as s[len(s):len(s)] = [x]
23:32:28 < Stemby> in pratica, in una lista possiamo inserire un'altra lista
23:32:35 < Stemby> fondendole insieme
23:32:51 < spirit> ok
23:32:55 < Stemby> guardate l'esempio che ho fatto
23:33:08 < Stemby> all'inizio c'è una lista
23:33:22 < Stemby> con 4 elementi
23:33:43 < Stemby> scusate, ho sbagliato a contare
23:33:49 < Stemby> ecco l'esempio corretto:
23:33:59 < Stemby> >>> prova = ['mirtilli', 'lamponi', 'more', 'fragole']
23:33:59 < Stemby> >>> prova[4:4] = ['ribes']
23:33:59 < Stemby> >>> prova
23:33:59 < Stemby> ['mirtilli', 'lamponi', 'more', 'fragole', 'ribes']
23:34:15 < Stemby> dicevo, all'inizio abbiamo una lista di 4 elementi
23:34:40 < Stemby> poi ci agganciamo in fondo, dopo l'ultimo elemento (l'elemento 3), una nuova lista
23:34:46 < Stemby> che contiene un solo elemento
23:35:01 < Stemby> il risultato è una lista di 4 elementi
23:35:10 < Stemby> *5
23:35:20 < Stemby> 5 elementi
23:35:26 < Stemby> da 0 a 4
23:35:30 < Ernestus> prova[4_4] perchè?
23:35:37 < Ernestus> visto che l'agganciamo tutta
23:35:44 < Stemby> significa da 4 a 4
23:35:47 < Ernestus> sarebbe [0:4]
23:35:50 < Stemby> no
23:35:58 < Ernestus> mi sto confondendo
23:36:00 < Stemby> noi agganciamo un unico elemento
23:36:06 < Stemby> allora
23:36:13 < Stemby> mirtilli è l'elemento 0
23:36:17 < Stemby> lamponi 1
23:36:19 < Ernestus> sisi
23:36:20 < Stemby> more 2
23:36:27 < Stemby> fragole 3
23:36:39 < Stemby> ci aggiungiamo come elemento 4 ribes
23:37:04 < Stemby> quindi la sintassi è questa: incolla la lista che ti dico dalla posizione 4 alla posizione 4
23:37:13 < Stemby> per chiarire faccio un altro esempio
23:37:16 < Stemby> un attimo
23:37:38 < groll> Stemby: aspetta hai detto " in pratica, in una lista possiamo inserire un'altra lista fondendole insieme" il che non è corretto append aggiunge un elemento non una "lista" di elementi
23:37:50 < Stemby> groll: un attimo
23:37:55 < Stemby> append lo spiego dopo
23:38:21 < amosse> scusate: 
23:38:42 < Stemby> >>> prova = ['mirtilli', 'lamponi', 'more', 'fragole']
23:38:42 < Stemby> >>> prova[1:3] = ['ribes', 'uva spina', 'aronia']
23:38:42 < Stemby> >>> prova
23:38:42 < Stemby> ['mirtilli', 'ribes', 'uva spina', 'aronia', 'fragole']
23:38:43 < amosse> ma non era più corretto: prova[4:5] = ['ribes']
23:39:07 < Stemby> amosse: no
23:39:35 < amosse> ok
23:39:59 < groll> Stemby: ah si scusa ho letto male pensavo intendessi che era un equivalente di append
23:40:09 < Stemby> >>> prova = ['mirtilli', 'lamponi', 'more', 'fragole']
23:40:09 < Stemby> >>> prova[1:1] = ['ribes', 'uva spina', 'aronia']
23:40:09 < Stemby> >>> prova
23:40:09 < Stemby> ['mirtilli', 'ribes', 'uva spina', 'aronia', 'lamponi', 'more', 'fragole']
23:40:54 < Stemby> come vedete, nel secondo caso ho inserito gli elementi della nuova lista
23:41:07 < Stemby> mentre nell'esempio precedente, ho sostituito 2 elementi
23:41:29 < risca> però
23:42:12 < Stemby> risca: dimmi
23:42:29 < risca> *era una affermazione di compiacimento
23:42:36 < Stemby> ah, ok
23:42:52 < Stemby> amosse, Ernestus, spirit: chiaro fino a qui?
23:43:07 < Ernestus> sisi
23:43:10 < Ernestus> oraho capito
23:43:22 < spirit> ok
23:43:28 < Stemby> ora dovrebbe essere chiaro anche il metodo append
23:43:38 < Stemby> same as s[len(s):len(s)] = [x]
23:43:49 < Stemby> len(s) cosa fa?
23:44:02 < groll> Stemby: guarda su gobby l'esercizio che ho scritto per loro se va bene
23:44:07 < spirit> lunghezza in byte
23:44:14 < Ernestus> inserisce una lista dentro un'altra
23:44:23 < Stemby> Ernestus: ...
23:44:27 < Stemby> len(s)
23:44:35 < risca> groll, cambia colore!
23:44:35 < Stemby> con s una sequenza qualsiasi
23:44:41 < groll> *coff*
23:45:13 < Stemby> cosa fa la funzione len()?
23:45:26 < Stemby> provate
23:45:31 < Stemby> len('pippo')
23:45:53 < amosse> numero elementi di 'pippo'
23:46:18 < Stemby> ok
23:46:31 < Stemby> len([1,2,3,])
23:46:37 < Stemby> scusate
23:46:38 < Stemby> len([1,2,3])
23:47:27 < Stemby> oh!! c'è nessuno???
23:47:35 < Ernestus> qual era il comando?
23:47:37 < risca> 3
23:47:37 < spirit> 3
23:47:38 < amosse> ok
23:47:40 < Ernestus> help(len())
23:47:49 < Ernestus> ?
23:48:05 < |Wolf|> help(len)
23:48:16 < Ernestus> grazie |Wolf| 
23:49:20  * risca scopre le matrici
23:49:21 < risca> >>> len([[1,2,3], [4,5,6,7]])
23:49:21 < risca> 2
23:50:13 < Stemby> risca: un attimo, che volevo farle stasera
23:50:22 < Stemby> ok, quindi in sinstesi:
23:50:28 < Stemby> len(s) che fa?
23:50:30 < |Wolf|> son sempre liste
23:50:37 < Stemby> con s una sequenza qualsiasi
23:50:59 < Stemby> amosse: ci aiuti tu?
23:51:24 < amosse> len(s) -> numero lementi della sequenza 's'
23:51:54 < Stemby> ottimo
23:52:08 < Stemby> il numero è il numero come lo intendiamo noi
23:52:18 < spirit> ok
23:52:35 < Stemby> quindi sarà sempre di un'unità superiore al numero dell'ultimo elemento
23:52:59 < Stemby> same as s[len(s):len(s)] = [x]
23:53:15 < Stemby> chiaro?
23:53:31 < spirit> si 
23:53:37 < Stemby> in pratica aggiunge un elemento come ultima posizione
23:53:50 < Ernestus> non mi è tanto chiara
23:53:55 < Ernestus> chiaro; esempio?
23:54:36 < Stemby> >>> prova = ['mele','pere']
23:54:36 < Stemby> >>> prova.append('carote')
23:54:36 < Stemby> >>> prova
23:54:36 < Stemby> ['mele', 'pere', 'carote']
23:55:04 < |Wolf|> s[len(s):len(s)] = [x] in effetti non è tanto chiaro, lo slicing a sinistra dell'= non si usa praticamente mai
23:55:20 < Stemby> è per questo che l'ho spiegato prima
23:55:43 < Stemby> ovviamente al posto di x ci si possono mettere quanti elementi si vogliono
23:56:02 < Stemby> ah, no
23:56:07 < Stemby> ho provato ora
23:56:11 < Stemby> solo un elemento
23:56:14 < |Wolf|> con append solo uno
23:56:18 < |Wolf|> per tanti c'è extend
23:56:27 < Stemby> ok
23:56:52 < Stemby> Ernestus: chiaro?
23:56:57 < |Wolf|> qual è la differenza tra prova.append('carote') e prova + ['carote']?
23:56:58 < Ernestus> sisi
23:57:07 < spirit> vero, solo uno
23:57:35 < Stemby> |Wolf|: bella domanda
23:57:40 < Stemby> chi risponde?
23:58:04 < Stemby> suggerimento: append è nella tabella che stiamo vedendo ora
23:58:15 < Stemby> mentre la concatenazione è nella prima tabella
23:58:48 < amosse> la prima aggiunge l'oggetto str 'carote' alla lista prova
23:59:02 < |Wolf|> e la seconda?
23:59:36 < amosse> mi sa che é lo stesso...?
23:59:43 < groll> no
23:59:44 < Stemby> il risultato sì
23:59:46 < Stemby> il come no
23:59:57 < |Wolf|> c'è una differenza sostanziale
00:00:05 < amosse> intendevo il risultato
00:00:15 < |Wolf|> e la differenza qual è?
00:00:21 < amosse> somma due liste
00:00:23 < Stemby> però a noi interessa anche il come si ottiene
00:00:34 < Stemby> amosse: mmm
00:00:37 < groll> dipende da cosa intendi per risultato
00:00:49 < Stemby> groll: vero
00:01:02 < groll> provatelo sulla shell interattiva
00:01:09 < groll> dovreste capirlo subito
00:01:44 < Stemby> vero :)
00:02:02 < groll> intanto stemby e wolf voi provate a capire la nerdata che ho scritto in fondo all'esempio su gobby :P
00:02:12 < groll> con quella la shelli interattiva non vi salverà :D
00:02:15 < Stemby> >>> prova = ['mele','pere']
00:02:15 < Stemby> >>> prova.append('carote')
00:02:15 < Stemby> >>> prova
00:02:15 < Stemby> ['mele', 'pere', 'carote']
00:02:15 < Stemby> >>> prova = ['mele','pere']
00:02:16 < Stemby> >>> prova + ['carote']
00:02:18 < Stemby> ['mele', 'pere', 'carote']
00:02:20 < Stemby> >>> prova
00:02:23 < Stemby> ['mele', 'pere']
00:02:25 < Stemby> amosse: prova a capire
00:03:07 < spirit> non è appare il valore aggiunto
00:03:16 < amosse> concatena due liste
00:03:34 < groll> amosse: e quindi?
00:03:34 < Stemby> + concatena 2 liste, esatto
00:03:41 < Stemby> quindi?
00:04:24 < groll> entrambi concatenano due liste però c'è una differenza
00:06:32 < groll> amosse: perchè nel primo caso la stringa finisce dentro prova mentre dopo sembra proprio che prova non venga toccata?
00:06:58 < Stemby> append non è quello che in genere si intende con concatenazione
00:07:01 < Stemby> soluzione:
00:07:18 < Stemby> con la concatenazione (+) otteniamo una nuova lista
00:07:28 < Ernestus> io vado...
00:07:30 < Ernestus> buonanotte
00:07:34 < Stemby> con append, MODIFICHIAMO la lista già esistente
00:07:35 < Ernestus> guarderò i log
00:07:45 < spirit> ciao Ernestus.
00:07:47 < risca> buona notte
00:07:51 < risca> ciao Ernestus
00:07:53 < Stemby> la differenza è sostanziale
00:07:54 < amosse> Ciao Ernestus 
00:07:59 -!- Ernestus [~ernesto@Azzurra-5453E698.44-79-r.retail.telecomitalia.it] has quit [Quit: Ex-Chat]
00:08:02 < amosse> chiaro
00:08:14 < Stemby> per questo la concatenazione fa parte della prima tabella
00:08:25 < Stemby> mentre il metodo append della seconda
00:08:36 < Stemby> ovviamente append è decisamente più performante
00:08:47 < Stemby> (non si va a creare un nuovo oggetto)
00:08:59 < amosse> ok
00:11:55 < Stemby> allora, le matrici le vediamo la prossima volta
00:12:05 < Stemby> (in realtà è molto semplice)
00:12:09 < risca> va bene
00:12:18 < Stemby> per la prossima volta: capitolo 7
00:12:18 < amosse> ok
00:12:24 < Stemby> esercitarsi con le liste
00:12:25 < risca> tanto non è niente di più di quello che abbiamo fatto oggi
00:12:30 < Stemby> (con entrambe le tabelle)
00:12:43 < amosse> ok
00:12:43 < spirit> ok..non ci vedo quasi più..