Accademia:Log 2011 03 16
Vai alla navigazione
Vai alla ricerca
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ù..