Accademia:Log 2011 03 20

Da Guide@Debianizzati.Org.

Su IRC

[21:47:49] <Stemby> allora, iniziamo?
[21:47:55] <Stemby> ci sono domande?
[21:47:56] <amosse> certo
[21:48:00] <spirit> vai
[21:48:10] <amosse> no
[21:48:24] <spirit> no
[21:48:24] <amosse> ah si una
[21:49:24] <amosse> come si fa in un loop ad parrase al prossimo elemento al verificarsi di una condizione, esiste qualcosa del tipo next?
[21:49:49] <groll> continue
[21:50:08] <amosse> continue riparte da capo
[21:50:27] <amosse> non dal prossimo elemento
[21:50:32] <groll> no va al prossimo elemento del ciclo
[21:50:45] <Stemby> amosse: non ho capito la domanda
[21:51:01] <amosse> esempio:
[21:52:07] <Stemby> amosse: se è lungo, scriviamolo su gobby
[21:53:00] <amosse> ho un dict non n elementi, devo verificare che l' utente abbia caricato tutti i .values, scorrendoli se mi accorgo che ne ha caricato uno passo al successivo, non all'iniziale
[21:53:33] <Stemby> continuo a non capire
[21:53:38] <Stemby> andiamo su gobby?
[21:53:46] <amosse> ok
[21:53:57] <groll> comunque con continue non riparti dall'inizio
[21:54:21] <groll> vai all'inizio del ciclo con l'elemento successivo
21:56:31 < |Wolf|> c'è il corso?
21:56:59 < amosse> si siamo su gobby
21:57:05 < Ernestus> arrivo su gobby
21:57:26 < Ernestus> Stemby, ma il tuo indirizzo di gobby è sempre attivo?
21:57:36 < Stemby> sì Ernestus
21:57:58 < Ernestus> ottimo
21:58:07 < Stemby> questo non ti autorizza ad usarlo impropriamente... :p
21:58:17 < Stemby> (altrimenti adotterò contromisure severe)
22:08:01 < Ernestus> nono tranquillo, l'ho usato per fare una pagina del wiki
22:40:34 < Stemby> ok, dopo il programmino, cerchiamo di riprendere la lezione
22:40:48 < Ernestus> eccomi
22:40:53 < Stemby> riguardo a quanto fatto finora, ci sono domande?
22:41:00 < amosse> ok funziona benissimo
22:41:16 < spirit> per ora no..
22:41:39 < amosse> il codice che avete scritto non é facilissimo, me lo devo un po' masticare
22:41:46 < Stemby> vi siete esercitati con le liste?
22:41:55 < amosse> si
22:42:05 < groll> amosse: beh ask finchè non sai le eccezioni lascialo perdere
22:42:15 < amosse> ok
22:42:31 < Stemby> if __name__ == '__main__':
22:42:37 < Stemby> quella riga è chiara?
22:42:41 < Stemby> immagino di no
22:42:43 < amosse> non
22:42:52 < Stemby> è un trucchetto
22:43:03 < Stemby> __name__ è una variabile speciale
22:43:03 < amosse> puoi spiegare
22:43:24 < Stemby> (tutti gli oggetti che sono circondati da __ sono oggetti speciali)
22:43:43 < Ernestus> e che vantaggi hanno?
22:43:54 < Stemby> non hanno vantaggi
22:43:59 < Stemby> son creati dall'interprete
22:44:18 < Stemby> se avete usato il debugger, li dovreste aver visti
22:44:28 < Stemby> avete provato il debigger?
22:44:34 < Stemby> *debugger
22:44:48 < amosse> no io non ho letto il capitolo
22:44:50 < spirit> Si.Solo oggi. Ma cercavo di capire il cap.8. Il diagramma di flusso. Cioè la creazione di un idea.
22:44:56 < Stemby> male amosse
22:44:59 < Ernestus> esatto quello dell'impiccato
22:45:02 < amosse> lo faccio per la prox
22:45:08 < Stemby> spirit: quello non l'abbiamo ancora fatto
22:45:13 < Stemby> è per la prossima volta
22:45:17 < spirit> Ah..
22:45:33 < Stemby> tra l'altro dovevo dirvi un po' di cosucce a riguardo
22:45:39 < Stemby> tornando a __name__
22:46:00 < Stemby> come dicevo, è una variabile creata dall'interprete
22:46:25 < Stemby> quando vale '__main__', significa che si sta eseguendo quel modulo
22:46:35 < Stemby> è una semplice stringa
22:46:40 < Stemby> con quel contenuto
22:47:07 < Stemby> quindi se eseguite quel modulo (come al solito), la variabile __name__ assumerà quel valore
22:47:35 < Stemby> dunque il blocco di codice che segue l'if, verrà eseguito SOLO quando si esegue il modulo
22:47:55 < spirit> Bello comunque, per quel poco che ho fatto, il debugger.
22:47:56 < Stemby> se invece il modulo viene importato, quel blocco verrà ignorato
22:48:19 < Stemby> chiaro, amosse?
22:48:33 < groll> notte
22:48:37 < Stemby> per chiarire
22:48:41 < amosse> se eseguiamo il modulo mortgage2.py?
22:48:46 < Stemby> ciao groll, e grazie
22:48:49 -!- groll [~groll@Azzurra=1779B648.48-151.net24.it] has quit [Read/Dead Error: Input/output error]
22:48:51 < Ernestus> notte 
22:48:53 < Stemby> ?
22:49:07 < Ernestus> non viene ignorato
22:49:12 < Stemby> il modulo l'hai chiamato mutuo.py
22:49:30 < Ernestus> se importa il modulo, ignora l'oggetto
22:49:36 < Stemby> no
22:49:38 < amosse> si scusa intendevo quello
22:49:40 < Stemby> ignora il blocco
22:49:48 < Stemby> allora
22:50:03 < Stemby> quando importate un modulo, per prima cosa quel modulo viene eseguito
22:50:06 < Stemby> ovvero:
22:50:19 < Stemby> se scrivete un modulo pippo.py
22:50:27 < Stemby> contenente solo:
22:50:33 < Stemby> print('pippo')
22:50:40 < Stemby> e lo importate con
22:50:44 < Stemby> import pippo
22:51:05 < Stemby> vedrete che quella riga viene eseguita
22:51:15 < Stemby> e quindi verrà stampato 'pippo'
22:51:41 < Stemby> però in genere, quando si importa un modulo, si vuole evitare questo comportamento
22:51:53 < Stemby> si vuole avere a disposizione i vari oggetti
22:52:02 < Stemby> e nient'altro
22:52:32 < Stemby> le funzioni ormai dovreste sapere che non vengono mai eseguite
22:52:47 < Stemby> per eseguirle, bisogna chiamarle
22:53:03 < Stemby> in mutuo.py abbiamo alcune funzioni
22:53:24 < Stemby> se importiamo quel modulo, le funzioni vengono definite, ma non vengono eseguite
22:53:36 < Stemby> perché le chiamate sono protette da quel trucchetto
22:53:46 < Stemby> la riga if __name__ == '__main__':
22:53:53 < Stemby> chiaro ora?
22:54:26 < Stemby> Ernestus: ?
22:54:28 < Stemby> amosse: ?
22:54:31 < amosse> quindi con quel sistema
22:54:33 < Stemby> spirit: ?
22:54:51 < spirit> cercavo di capire..
22:54:54 < Ernestus> sisi
22:55:13 < amosse> le funzioni vengono automaticamente chiamate...?
22:55:25 < amosse> giusto?
22:55:53 < Stemby> no
22:55:54 < amosse> quando faccio girare mutuo.py
22:56:13 < Stemby> quando fai girare mutuo.py è come se l'if non esistesse
22:56:22 < Stemby> e il blocco seguente non fosse indentato
22:56:42 < Stemby> quando invece importi il modulo, è come se non esistesse niente
22:56:43 < amosse> ah..
22:57:05 < Stemby> né l'if, né il blocco
22:57:29 < amosse> ok
22:57:37 < Stemby> ottimo
22:57:48 < Stemby> è un trucchetto usatissimo
22:57:54 < Stemby> direi praticamente sempre
22:58:13 < Stemby> in questo modo le funzioni possono essere usate anche da altri programmi
22:58:17 < Stemby> senza interferenze
22:58:23 < spirit> ok
22:58:34 < Stemby> basta importare il modulo
22:58:43 < Ernestus> e mettere la variabile
22:58:47 < Ernestus> in mezzo ai trattini
22:58:50 < Ernestus> giusto?
22:58:50 < Stemby> ?
22:58:51 < Stemby> no
22:59:08 < Stemby> Ernestus: mi sa che non hai capito...
22:59:19 < Ernestus> facciamo un esempio con il modulo pippo
22:59:20 < Ernestus> ?
22:59:24 < Stemby> ok
22:59:27 < Ernestus> import pippo
22:59:31 < Ernestus> print("pippo")
22:59:43 < Stemby> allora
22:59:51 < amosse> ma scusa anche con import possono essere usate anche da altri utenti...?
22:59:54 < Stemby> tutti voi avete IDLE installato?
23:00:05 < amosse> si
23:00:10 < Stemby> ottimo
23:00:14 < Ernestus> si
23:00:20 < Stemby> facciamo così
23:00:24 < Stemby> doodle
23:00:27 < Stemby> no, sorry
23:00:32 < Stemby> volevo dire: gobby
23:16:01 -!- Ernestus [~ernesto@Azzurra-667A47D2.25-79-r.retail.telecomitalia.it] has quit [Quit: Ex-Chat]

Su Gobby

[23:17:50] <Ernestus> io adesso vado. stemby per mercoledì faccio il 7 capito e nel forum faccio eventuali domani
[23:18:06] <Ernestus> *domande. buona notte e proseguimento di corso
[23:18:13] <Stemby> Ernestus: non solo
[23:18:19] <Ernestus> più l'8?
[23:18:22] <Stemby> devi fare anche i compiti per la prossima volta
[23:18:28] <Stemby> esatto
[23:18:29] <amosse> ciao Ern
[23:18:37] <Stemby> guarda anche il log irc
[23:18:48] <Ernestus> sarà fatto. ciao!
[23:18:51] Ernestus è uscito
[23:19:06] <Stemby> amosse: hai risolto?
[23:19:07] <amosse> spirit: e allora come faccio ad uscire?
[23:19:22] <Stemby> non ho capito in che situazione ti trovi
[23:19:28] <spirit> devi chiudere il debugger non idle
[23:19:44] <amosse> ho chiuso prima idle, 
[23:20:11] <spirit> va bene lo stesso..anche a me è successo oggi
[23:20:12] <Stemby> il bottone Quit 
[23:20:21] <Stemby> nel debigger
[23:20:25] <Stemby> *debugger
[23:20:33] <amosse> non funziona
[23:20:46] <Stemby> killalo brutalmente
[23:21:11] <spirit> guarda le finestre aperte..
[23:21:18] <Stemby> killall python3
[23:21:30] <amosse> ok
[23:21:37] <amosse> fatto
[23:21:49] <Stemby> ok
[23:22:03] <amosse> ok
[23:22:04] <Stemby> allora, abbiamo capito perché non cambia quasi niente?
[23:22:39] <spirit> non tanto
[23:22:39] <Stemby> perché la variabile __name__ vale proprio '__main__'
[23:22:52] <amosse> ok
[23:22:53] <Stemby> l'hai visto, nel debugger, no?
[23:23:08] <spirit> ok
[23:23:17] <Stemby> __name__ == '__main__' è dunque vero
[23:23:29] <Stemby> quindi il blocco viene eseguito
[23:23:37] <Stemby> e si torna nella situazione precedente
[23:23:43] <spirit> già, è vero.
[23:23:51] <Stemby> ora:
[23:24:07] <Stemby> torniamo alla situazione di prima
[23:24:10] <Stemby> ci siete?
[23:24:17] <amosse> si
[23:24:21] <spirit> si
[23:24:27] <Stemby> provate ad importare il modulo
[23:24:34] <Stemby> anche dalla shell interattiva
[23:24:59] <Stemby> >>> import pippo
[23:24:59] <Stemby> pippo
[23:24:59] <Stemby> ciao
[23:24:59] <Stemby> 
[23:25:07] <Stemby> giusto?
[23:25:46] <spirit> a me non dà niente
[23:25:54] <Stemby> hai fatto import pippo?
[23:26:02] <Stemby> e, soprattutto, hai salvato il file
[23:26:03] <spirit> si 
[23:26:05] <Stemby> pippo.py
[23:26:09] <Stemby> all'ultima versione
[23:26:10] <spirit> si
[23:26:13] <Stemby> con if commentato
[23:26:17] <Stemby> e senza indentazione
[23:26:28] <spirit> aspetta..lo risalvo
[23:26:32] <Stemby> eh...
[23:27:02] <spirit> nada..
[23:27:06] <Stemby> cosa nada
[23:27:09] <Stemby> impossibile
[23:27:13] <Stemby> sbagli qualcosa
[23:28:02] <spirit> faccio import pippo e non restituisce niente
[23:28:17] <Stemby> impossibile
[23:28:24] <amosse> anche a me
[23:28:33] <Stemby> anche a te non restituisce niente?
[23:28:39] <amosse> ho copiato pippo.py
[23:28:46] <amosse> poi import pippo
[23:28:49] <Stemby> a che versione?
[23:28:52] <amosse> si ferma
[23:29:06] <Stemby> si ferma... in che senso?
[23:29:17] <spirit> ho anche pippo.pyc..che avevamo visto come bytecode
[23:29:32] <Stemby> allora, rifacciamo da capo
[23:29:37] <Stemby> cancellate quel file
[23:29:49] <Stemby> risalvate il file
[23:29:55] <Stemby> quello che c'è qui
[23:30:09] <Stemby> poi, dalla directory in cui si trova il nuovo file:
[23:30:18] <Stemby> python3
[23:30:25] <Stemby> >>> import pippo
[23:30:49] <Stemby> fatto?
[23:30:54] <spirit> si è ok
[23:31:07] <Stemby> amosse?
[23:31:40] <amosse> scusa
[23:31:48] <amosse> ho salvato il file
[23:31:58] <amosse> entro della dir del file
[23:33:02] <amosse> ok
[23:33:06] <Stemby> alleluia
[23:33:13] <Stemby> ora:
[23:33:26] <Stemby> fate la stessa cosa
[23:33:46] <spirit> ..niente
[23:33:50] <Stemby> esatto
[23:33:58] <amosse> import pippo
[23:34:05] <Stemby> non dovrebbe dare niente
[23:34:23] <Stemby> però il modulo è importato
[23:34:28] <Stemby> infatti:
[23:34:30] <amosse> Traceback (most recent call last):
[23:34:30] <amosse>   File "<stdin>", line 1, in <module>
[23:34:30] <amosse> ImportError: No module named pippo
[23:34:30] <amosse> 
[23:34:43] <Stemby> >>> pippo.ciao()
[23:34:43] <Stemby> 'ciao'
[23:34:43] <Stemby> 
[23:35:00] <Stemby> amosse: sei nella directory giusta?
[23:35:04] <amosse> si
[23:35:06] <spirit> vero
[23:35:25] <Stemby> amosse: evidentemente no
[23:35:34] <Stemby> rifai da capo
[23:35:39] <amosse> ok
[23:35:40] <Stemby> chiudi la shell interattiva
[23:35:46] <Stemby> cancella il file
[23:35:50] <Stemby> risalva il file
[23:35:55] <Stemby> rientra in python3
[23:36:00] <Stemby> import pippo
[23:36:22] <amosse> riprovo
[23:37:15] Stemby has created a new document: test_pippo.py
[23:38:13] <Stemby> amosse: ce l'hai fatta?
[23:38:50] <Stemby> ohhh!!!!
[23:38:59] <Stemby> (vorrei anche andare a nanna,,,)
[23:40:08] <amosse> ok
[23:40:12] <amosse> ci sono
[23:40:16] <Stemby> fatto?
[23:40:23] <amosse> impot pippo ok
[23:40:27] <Stemby> ok
[23:40:41] <Stemby> chiaro il funzionamento di quella riga, ora?
[23:40:58] <amosse> ok
[23:41:05] <Stemby> quando importate il modulo, __name__ non vale '__main__'
[23:41:22] <Stemby> quindi quelle righe del blocco vengono ignorate
[23:41:29] <Stemby> ho appena scritto un nuovo modulo
[23:41:34] <Stemby> test_pippo.py
[23:41:36] <spirit> ok..
[23:41:46] <amosse> ok
[23:41:51] <Stemby> che in pratica fa quello che avete provato nella shell
[23:42:08] <Stemby> provate ad analizzare quel modulo col debugger
[23:42:23] <Stemby> ovviamente mettetelo nella stessa directory di pippo.py
[23:42:46] <Stemby> fatelo uno step alla volta
[23:42:56] <Stemby> così finirete dentro al modulo pippo
[23:43:11] <Stemby> alla chiamata di pippo.ciao()
[23:43:24] <Stemby> e potrete verificare il valore della variabile main
[23:43:31] <Stemby> __name__, volevo dire
[23:44:24] <Stemby> avete visto?
[23:44:37] <Stemby> qual è il valore di __name__?
[23:45:03] <spirit> main
[23:45:06] <Stemby> no
[23:45:23] <Stemby> quando entrate nel modulo pippo
[23:45:32] <Stemby> allora, rifacciamo da capo
[23:45:41] <Stemby> avete salvato test_pippo.py?
[23:45:45] <spirit> si
[23:45:52] <Stemby> apriamolo con idle
[23:45:58] <spirit> fatto
[23:45:59] <Stemby> col deugger aperto
[23:46:04] <Stemby> *debugger
[23:46:08] <spirit> fatto
[23:46:17] <Stemby> un secondo che lo faccio anch'io
[23:46:43] <Stemby> eccomi
[23:47:00] <Stemby> dovrebbe essere evidenziata la riga import pippo
[23:47:03] <Stemby> giusto=
[23:47:04] <Stemby> ?
[23:47:11] <spirit> si
[23:47:17] <amosse> si
[23:47:29] <Stemby> __name__ ovviamente vale '__main__'
[23:47:43] <amosse> ok
[23:47:46] <Stemby> perché quella è la variabile del modulo test_pippo.py
[23:47:50] <spirit> ah aspetta che ho sbagliato..
[23:48:06] <Stemby> quando ci sei fammi un fischio
[23:48:24] <amosse> _name_  '_main_'
[23:48:32] <amosse> questo?
[23:48:39] <Stemby> esatto
[23:48:43] <Stemby> ma con 2 trattini per lato
[23:48:48] <Stemby> __name__
[23:48:50] <Stemby> e
[23:48:52] <amosse> ok
[23:48:54] <Stemby> '__main__'
[23:49:07] <spirit> ci sono
[23:49:10] <Stemby> ok
[23:49:15] <Stemby> ora se premiamo step
[23:49:17] <Stemby> cosa succede?
[23:49:38] <Stemby> si finisce dentro al modulo pippo.py
[23:50:00] <Stemby> perché, come vi avevo detto, quando si importa un modulo, per prima cosa il modulo viene eseguito
[23:50:04] <Stemby> ci siete?
[23:50:08] <spirit> si
[23:50:10] <amosse> ImportError: no module named pippo
[23:50:27] <Stemby> amosse: hai salvato pippo.py nella stessa direcrory?
[23:50:37] <amosse> si
[23:50:40] <Stemby> pippo.py e test_pippo.py devono stare nella stessa dir
[23:50:54] <Stemby> amosse: evidentemente non l'hai fatto
[23:50:59] <Stemby> visto che non lo trova
[23:51:18] <amosse> moment
[23:52:44] <amosse> ok ora funziona
[23:52:48] <Stemby> bene
[23:53:00] <Stemby> qual è il valore di __name__?
[23:53:19] <amosse> __main__
[23:53:21] <Stemby> no!
[23:53:25] <Stemby> hai fatto step
[23:53:29] <amosse> si
[23:53:32] <Stemby> sei dentro pippo.py?
[23:54:03] <Stemby> dovresti essere alla riga def ciao():
[23:55:22] <Stemby> amosse...
[23:55:31] <amosse> mi sono arenato, sono un po' fuso
[23:55:41] <Stemby> sì, però non puoi bloccarci
[23:55:49] <Stemby> tieni duro 2 minuti che abbiamo finito
[23:56:04] <spirit> mala variabile name non deve essere definita con il nuovo oggetto?
[23:56:07] <amosse> andate avanti, cerco di seguire
[23:56:25] <Stemby> spirit: no
[23:56:37] <Stemby> le variabili speciali non vengono dichiarate
[23:56:46] <Stemby> vengono create automaticamente dall'interprete
[23:57:02] <Stemby> infatti mica l'abbiamo dichiarata, se noti
[23:57:04] <Stemby> però c'è
[23:57:13] <spirit> già infatti..
[23:57:16] <Stemby> spirit: dai tu la soluzione
[23:57:25] <Stemby> cosa vale __name__ in pippo.py
[23:57:33] <Stemby> (durante l'importazione)
[23:57:40] <Stemby> ?
[23:57:43] <spirit> con main
[23:57:53] <Stemby> ???
[23:58:03] <Stemby> non è difficile
[23:58:11] <Stemby> basta guardare il debugger
[23:58:16] <Stemby> cosa ti dice?
[23:58:23] <spirit> di pippo?
[23:58:31] <Stemby> ?
[23:58:36] <Stemby> non ho capito la domanda
[23:58:44] <spirit> pippo.py o te
[23:58:51] <spirit> scusa..
[23:58:53] <Stemby> rifacciamo da capo
[23:59:03] <Stemby> apriamo con idle test_pippo.py
[23:59:11] <Stemby> col debugger aperto
[23:59:13] <spirit> ci sono
[23:59:19] <Stemby> siamo alla riga import...
[23:59:23] <Stemby> giusto?
[23:59:26] <spirit> ok
[23:59:39] <Stemby> ora, se clicchiamo step, dove finiamo?
[23:59:52] <Stemby> finiamo dentro al modulo pippo.py
[23:59:59] <Stemby> perché viene importato
[00:00:03] <Stemby> e quindi eseguito
[00:00:05] <Stemby> giusto?
[00:00:19] <Stemby> dovremmo essere alla riga def ciao(): di pippo.py
[00:00:23] <Stemby> ci siamo?
[00:00:26] <spirit> ok ... ecco perchè non capivo..
[00:00:42] <Stemby> cosa vale __name__?
[00:01:02] <spirit> pippo
[00:01:06] <Stemby> 'pippo'
[00:01:10] <Stemby> è una stringa
[00:01:17] <spirit> ok
[00:01:18] <Stemby> ok?
[00:01:24] <Stemby> non vale '__main__'
[00:01:29] <Stemby> (sempre una stringa)
[00:01:33] <Stemby> ma 'pippo'
[00:01:38] <Stemby> sono 2 stringhe diverse
[00:01:55] <Stemby> quindi, se clicchiamo ancora step, dove finiamo?
[00:02:09] <spirit> a main
[00:02:24] <Stemby> torniamo al modulo test_pippo.py
[00:02:30] <Stemby> perché?
[00:02:58] <spirit> abbiamo fatto import pippo
[00:03:22] <Stemby> sì, ma il modulo pippo.py ha tante righe
[00:03:28] <Stemby> perché non sono state lette?
[00:03:41] <Stemby> è stata letta solo la riga 3
[00:03:48] <Stemby> def ciao():
[00:03:52] <Stemby> e tutte le altre?
[00:03:59] <Stemby> perché la 4 non è stata letta?
[00:04:45] <spirit> perchè richiama def
[00:04:53] <Stemby> ?
[00:05:04] <Stemby> cosa vuol dire "richiama def"?
[00:05:21] <spirit> l'  oggetto funzione
[00:05:21] <Stemby> la 4 non viene letta perché fa parte della funzione
[00:05:45] <Stemby> i blocchi delle funzioni vengono _sempre_ saltati
[00:05:50] <Stemby> non vengono mai letti
[00:05:54] <spirit> ok..
[00:06:06] <Stemby> le funzioni vengono definite, e nient'altro
[00:06:19] <Stemby> il contenuto verrà letto solo quando la funzione verrà chiamata
[00:06:25] <Stemby> e _se_ verrà chiamata
[00:06:31] <spirit> ok
[00:06:53] <Stemby> se noi scriviamo una funzione, ma non la chiamiamo mai, il contenuto della funzione non verrà mai letto
[00:07:01] <spirit> giusto
[00:07:13] <Stemby> (potrebbero anche esserci dei bug, e non ce ne accorgeremmo)
[00:07:38] <Stemby> allora, ricapitolando, la 4 viene saltata
[00:07:48] <Stemby> va alla 5
[00:08:13] <spirit> main
[00:08:21] <Stemby> ?
[00:08:28] <Stemby> va all 5
[00:08:38] <Stemby> ma anche la 5 viene saltata
[00:08:40] <Stemby> perché?
[00:09:14] <Stemby> guarda qui su gobby la riga 5 di pippo.py
[00:09:26] <spirit> vuota
[00:09:45] <Stemby> esatto
[00:09:50] <Stemby> quindi viene saltata
[00:09:53] <Stemby> allora va alla 6
[00:10:10] <Stemby> e?
[00:10:19] <spirit> torna main
[00:10:23] <Stemby> perché?
[00:10:35] <spirit> richima il modulo
[00:10:38] <Stemby> ?
[00:11:05] <spirit> è vera la condizione
[00:11:10] <Stemby> no!!!
[00:11:13] <amosse> io vi lascio, vado a dormire
[00:11:19] <amosse> ci vediamo mercoledi
[00:11:25] <spirit> 'notte amosse
[00:11:28] <Stemby> la condizione è FALSA
[00:11:32] <amosse> notte
[00:11:44] <Stemby> cosa abbiamo detto che vale __name__?
[00:12:01] amosse è uscito
[00:12:25] <Stemby> spirit
[00:12:28] <Stemby> me l'hai detto prima
[00:12:34] <Stemby> cosa vale __name__?
[00:12:37] <spirit> main
[00:12:42] <Stemby> no!!!!!!!!!!!!!!!!!!!!!!!
[00:12:50] <Stemby> l'hai letto sul debugger
[00:13:06] <Stemby> alle 00:01
[00:13:14] <Stemby> 12 minuti fa
[00:13:22] <Stemby> mi hai dato la risposta corretta
[00:13:33] <spirit> ah il modulo 'pippo'
[00:13:37] <Stemby> no!
[00:13:40] <Stemby> non è un modulo
[00:13:49] <Stemby> è il valore della variabile __name__
[00:13:56] <Stemby> __name__ vale 'pippo'
[00:14:03] <spirit> ..stringa
[00:14:06] <Stemby> sì
[00:14:11] <Stemby> una stringa
[00:14:21] <Stemby> per la precisione questa stringa: 'pippo'
[00:14:25] <Stemby> chiaro????
[00:14:31] <spirit> ok chiaro
[00:14:56] <Stemby> se facessi print(__name__), in quel punto otterresti 'pippo'
[00:15:42] <spirit> sulla shell mi da __main__
[00:15:52] <Stemby> certo!
[00:16:09] <Stemby> perché quando esegui il modulo, vale '__main__'
[00:16:13] <Stemby> sempre con gli apici
[00:16:18] <Stemby> (è una stringa)
[00:16:45] <Stemby> prova così
[00:16:53] <Stemby> dalla console
[00:17:04] <Stemby> python3 pippo.py
[00:17:07] <Stemby> e
[00:17:21] <Stemby> python3 test_python.py
[00:17:48] <spirit> aspetta che elimino e risalvo i file che se nò non dà..
[00:18:31] <Stemby> mmm, non mi funziona
[00:18:34] <Stemby> non so perché
[00:19:26] <Stemby> strano
[00:19:27] <spirit> faccio da root..
[00:19:31] <Stemby> vabbé, poco importa
[00:19:36] <Stemby> no, che c'entra
[00:19:55] <Stemby> allora
[00:20:00] <Stemby> torniamo al nostro discorso
[00:20:19] <Stemby> siamo durante l'importazione del modulo
[00:20:26] <Stemby> siamo arrivati alla riga 6
[00:20:28] <spirit> ok
[00:20:40] <Stemby> __name__ cosa abbiamo detto che vale?
[00:20:51] <spirit> 'pippo'
[00:21:01] <Stemby> quindi l'espressione cosa dà?
[00:21:14] <Stemby> 'pippo' == '__main__'
[00:21:33] <spirit> ok
[00:21:39] <Stemby> cosa ok?
[00:21:45] <Stemby> cosa dà?
[00:21:48] <spirit> ti seguivo...
[00:22:18] <spirit> ma nel debugger?
[00:22:42] <Stemby> no
[00:22:49] <Stemby> non c'è nel debugger
[00:22:55] <Stemby> il debugger salta tutto
[00:23:02] <Stemby> e stiamo cercando di capire perché
[00:23:12] <Stemby> cosa diavolo dà quell'espressione?
[00:23:26] <Stemby> 'pippo' == '__main__'
[00:23:30] <Stemby> cosa dà?????
[00:23:37] <spirit> name 
[00:23:45] <Stemby> ???????????
[00:23:54] <Stemby> provalo nell'interfaccia interattiva
[00:24:07] <Stemby> >>> 'pippo' == '__main__'
[00:24:33] <spirit> errore
[00:24:37] <Stemby> no
[00:24:41] <Stemby> non dà alcun errore
[00:24:51] <Stemby> dà un valore ben preciso
[00:25:26] <Stemby> che valore dà???
[00:25:35] <spirit> nulla
[00:25:42] <Stemby> ma come nulla!!!
[00:25:52] <spirit> da errore..non sò
[00:25:58] <Stemby> che errore ti dà?
[00:26:08] <spirit> IndentationError: unexpected indent
[00:26:14] <Stemby> spirit...
[00:26:26] <Stemby> ma ancora con questi errori???
[00:26:33] <Stemby> cosa vuol dire?
[00:26:42] <Stemby> leggi...
[00:26:48] <Stemby> IndentationError
[00:26:54] <Stemby> cosa mai vorrà dire?
[00:27:17] <Stemby> ti dà anche la spiegazione: unexpected indent
[00:27:22] <spirit> errore di identazione
[00:27:26] <Stemby> quindi?
[00:27:37] <Stemby> hai messo degli spazi all'inizio della riga
[00:28:14] <spirit> cavoli affogare in un bicchire di acqua............
[00:28:21] <Stemby> basta leggere...
[00:28:35] <spirit> risolto
[00:28:38] <Stemby> cosa ti dà?
[00:28:46] <spirit> False
[00:28:50] <Stemby> ovvio no?
[00:29:01] <Stemby> ti sembra che le due stringhe siano uguali tra loro?
[00:29:07] <spirit> certo che no
[00:29:10] <Stemby> ok
[00:29:26] <Stemby> quindi la riga 6 si rifuce a:
[00:29:29] <Stemby> if False:
[00:29:31] <Stemby> giusto?
[00:29:47] <Stemby> e quindi?
[00:29:50] <spirit> giusto
[00:29:51] <Stemby> cosa succede?
[00:30:06] <spirit> una condizione
[00:30:11] <Stemby> ?
[00:30:24] <Stemby> come funziona if?
[00:30:36] <Stemby> if espressione:
[00:30:41] <Stemby> seguito da un blocco
[00:30:56] <Stemby> se l'espressione è vera, il blocco viene eseguito
[00:31:07] <Stemby> se l'espressione è falsa, il blocco viene saltato
[00:31:09] <Stemby> giusto?
[00:31:15] <spirit> giusto
[00:31:19] <Stemby> dunque?
[00:31:27] <Stemby> l'espressione è vera o falsa?
[00:31:34] <spirit> falsa
[00:31:40] <Stemby> quindi?
[00:31:45] <spirit> return
[00:31:48] <Stemby> no!!
[00:31:53] <Stemby> dove'è return?
[00:32:16] <spirit> niente...ho sbagliato
[00:32:23] <Stemby> quindi?
[00:32:37] <Stemby> te l'ho detto qualche riga fa
[00:32:46] <Stemby> [00:31:10] <Stemby> se l'espressione è falsa, il blocco viene saltato
[00:32:59] <spirit> pensavo come..
[00:33:14] <Stemby> tu mi hai detto che l'espressione è falsa, giusto?
[00:33:17] <spirit> si
[00:33:20] <Stemby> quindi?
[00:33:38] <Stemby> quindi?
[00:33:40] <spirit> not
[00:33:42] <Stemby> ?????
[00:33:48] <Stemby> [00:31:10] <Stemby> se l'espressione è falsa, il blocco viene saltato
[00:33:55] <Stemby> tu mi hai detto che l'espressione è falsa
[00:33:58] <Stemby> quindi?
[00:34:20] <Stemby> spirit...
[00:34:34] <Stemby> [00:31:10] <Stemby> se l'espressione è falsa, il blocco viene saltato
[00:34:37] <Stemby> tu mi hai detto che l'espressione è falsa
[00:34:39] <Stemby> quindi?
[00:35:02] <spirit> da errore...
[00:35:13] <Stemby> ma che errore???????????!!!!!!!!!!!!!
[00:35:20] <Stemby> [00:31:10] <Stemby> se l'espressione è falsa, il blocco viene saltato
[00:35:27] <Stemby> tu mi hai detto che l'espressione è falsa, giusto?
[00:35:42] <spirit> si
[00:35:43] <Stemby> quindi?
[00:35:56] <Stemby> cacchiarola, leggi la mia frase!
[00:36:05] <Stemby> la risposta è lì
[00:36:06] <spirit> salta il blocco
[00:36:11] <Stemby> alleliuia!!!!
[00:36:21] <Stemby> qual è il blocco?
[00:36:26] <spirit> cercavo di capire il dopo..
[00:36:34] <Stemby> qual è il blocco?
[00:36:43] <spirit> riga 6-8
[00:36:49] <Stemby> righe 7 e 8
[00:36:56] <Stemby> la 6 non fa parte del blocco
[00:36:59] <spirit> ok
[00:37:02] <Stemby> viene letta, ma non fa niente
[00:37:07] <Stemby> quindi, ricapitolando
[00:37:13] <Stemby> legge la 3
[00:37:21] <Stemby> definisce la funzione
[00:37:25] <spirit> ok
[00:37:33] <Stemby> salta il contenuto della funzione (4)
[00:37:38] <Stemby> salta la 5 (vuota)
[00:37:44] <Stemby> legge la 6
[00:37:55] <spirit> che è falsa
[00:37:57] <Stemby> visto che l'espressione è falsa, salta la 7 e la 8
[00:38:03] <Stemby> il modulo è finiti
[00:38:06] <Stemby> *finito
[00:38:17] <spirit> ok ci sono 
[00:38:17] <Stemby> torna all'altro modullo
[00:38:24] <Stemby> *modulo
[00:38:27] <Stemby> ok
[00:38:46] <Stemby> a quel punto finisce alla riga 5 di test_pippo,py
[00:39:12] <Stemby> chiama la funzione pippo.ciao()
[00:39:27] <spirit> ho capito
[00:39:36] <Stemby> che restituisce 'ciao'
[00:39:56] <Stemby> la stringa 'ciao' viene passata alla funzione print()
[00:40:08] <Stemby> che viene eseguita e quindi la stringa viene stampata
[00:40:11] <Stemby> tutto lì
[00:40:31] <spirit> ok
[00:40:40] <Stemby> un attimo su irc e poi a nanna
[00:40:47] Stemby è uscito
[00:41:29] spirit è uscito

Da IRC

00:10:00 -!- amosse [~Mibbit@Azzurra-788D7337.252-95-r.retail.telecomitalia.it] has quit [Quit: http://www.mibbit.com ajax IRC Client]
00:39:06 < Stemby> allora
00:39:27 < Stemby> abbiamo spiegato su gobby il funzionamento del trucchetto:
00:39:39 < Stemby> if __name__ == '__main__'
00:39:45 < Stemby> spero che ora sia chiaro
00:39:54 < spirit> si 
00:39:54 < Stemby> se non lo fosse: cercate in rete
00:40:10 < Stemby> al limite lo riprendiamo la prossima volta
00:40:24 < Stemby> per la prossima volta vi darei solo il capitolo 8
00:40:27 < Stemby> è molto semplice
00:40:58 < Stemby> ma putroppo per scrivere i diagrammi non segue gli standard
00:41:14 < Stemby> vi ricordate le letture che vi avevo indicato ad inizio corso?
00:41:46 < spirit> sui diagrammi di flusso?
00:41:48 < Stemby> una delle prime lezioni, in cui abbiamo trattato il concetto di algoritmo
00:41:52 < Stemby> sì, esatto spirit
00:42:05 < Stemby> erano 2 presentazioni
00:42:14 < Stemby> (pdf di slide)
00:42:32 < Stemby> se non ve le ricordate, riprendetele
00:42:54 < Stemby> spiegavano in modo semplice come si scrive un diagramma di flusso "standard"
00:43:22 < Stemby> altra cosa: qualcuno di voi ha problemi ad utilizzare flash?
00:43:56 < Stemby> spirit: ?
00:44:01 < Stemby> risca: ?
00:44:02 < spirit> no.. non credo
00:44:09 < Stemby> ok
00:44:20 < Stemby> ho trovato una webapp molto carina
00:44:44 < Stemby> che permette di disegnare (tra le altre cose) diagrammi di flusso
00:44:53 < Stemby> purtroppo è scritta in flash
00:45:09 < Stemby> oggi abbiamo fatto una prova con gnash e non va
00:45:42 < Stemby> quindi per usarla, con ogni probabilità occorre usare il flashplayer proprietario di adobe
00:45:53 < spirit> con firefox non c'è problema, ma su konqueror fa dannare..
00:46:05 < Stemby> ok, usa firefox :)
00:46:23 < Stemby> quello che dicevo io è se hai problemi etici ad utilizzarlo
00:46:35 < spirit> in che senso?
00:46:47 < Stemby> che c'è gente che non usa software proprietario
00:46:53 < Stemby> per scelta
00:46:56 < spirit> non io
00:47:00 < Stemby> io quasi
00:47:09 < Stemby> però purtroppo il flashplayer lo uso
00:47:23 < Stemby> è uno dei pochissimi compromessi a cui scendo
00:47:40 < Stemby> (anche se mi piacerebbe riuscire a farne a meno)
00:48:07 < spirit> io provo sempre l'alternativa libera..
00:48:24 < Stemby> bon, l'applicazione è questa: http://www.gliffy.com/
00:48:32 < Stemby> prendete confidenza
00:48:47 < spirit> però flash su x86_64 non sempre va..
00:48:51 < Stemby> così la prossima volta disegnamo il diagramma del capitolo 8 come si deve
00:49:00 < Stemby> spirit: prova a vedere
00:49:09 < spirit> adesso?
00:49:12 < Stemby> no
00:49:15 < Stemby> in questi giorni
00:49:44 < spirit> bè buonanotte Stemby. Grazie per la lezione. Ciao
00:49:53 < Stemby> per provare non serve altro che il flashplayer
00:50:13 < spirit> proverò anche gnash
00:50:22 < Stemby> poi per salvare, esportare immagini, ecc. occorre indicare un indirizzo e-mail
00:50:46 < Stemby> se non si vuole passare un indirizzo vero, si può usare mailinator
00:50:54 < Stemby> oggi l'ho provato e funziona
00:51:02 < Stemby> tutto qui
00:51:04 < spirit> Va bene
00:51:07 < Stemby> riassumendo:
00:51:29 < Stemby> per la prossima volta, capitolo 8 e prendere confidenza con gliffy
00:51:33 < Stemby> notte
00:51:43 < spirit> ciao
00:52:40 < hoax> Stemby: hai mica salvato il log della chat su gobby per metterlo eventualmente sul forum?
00:52:54 -!- spirit [~root@Azzurra-C3C291C.104-82-b.business.telecomitalia.it] has quit [Quit: leaving]
00:52:55 < hoax> io mi ero disconnesso e ne ho così solo una parte
00:53:11 < hoax> http://sprunge.us/QRDi
00:54:08 < Stemby> hoax: la parte su gobby è un po' incasinata
00:54:44 < Stemby> eviterei di pubblicarla
00:55:07 < hoax> ok
00:55:15 < Stemby> all'inizio abbiamo scritto un po' meglio uno script per amosse
00:55:32 < Stemby> lì è venuto fuori il trucchetto
00:55:42 < Stemby> if __name__ == '__main__'
00:56:08 < Stemby> il resto della lezione abbiamo provato a spiegarlo
00:56:27 < Stemby> hoax: l'hai capito?
00:57:11 < Stemby> [s/n]
00:57:23 < hoax> no Stemby, non badare a me, purtroppo non sto seguendo attivamente e soprattutto non dall'inizio
00:57:36 < hoax> per questo sono particolarmente interessato ai log
00:57:53 < Stemby> quello non vale molto
00:58:14 < Stemby> perché abbiamo speso un mucchio di tempo in cose che dovevano essere già state apprese
00:58:24 < Stemby> e ormai sicure
00:58:31 < Stemby> mentre non si sono dimostrate tali...
00:58:44 < Stemby> quindi non è una buona spiegazione
00:58:53 < Stemby> se lo cerchi in rete è meglio
00:59:03 < Stemby> al limite lo riprenderemo più avanti
00:59:14 < Stemby> hoax: a che punto sei?
00:59:18 < hoax> mah, per uno che non ha proprio mai fatto python è utile, credimi
00:59:40 < Stemby> hoax: guarda, piuttosto te lo rispiego da capo
00:59:47 < Stemby> quel log non vale proprio niente
01:00:02 < Stemby> hoax: stai cercando di recuperare?
01:00:20 < hoax> non ora, ora per l'uni devo studiare C
01:00:34 < hoax> e non riesco ad essere multitasking
01:00:41 < hoax> sono molto limitato
01:01:17 < hoax> ma per il futuro è comunque una base
01:01:24 < Stemby> beh, il python è molto più semplice
01:01:33 < hoax> se volessi occuparmi di studiare Python
01:01:36 < Stemby> farai in fretta a recuperare
01:01:43 < hoax> mah, per certi versi forse
01:01:52 < hoax> per altri mi sembra più incasinato
01:02:00 < hoax> in particolare la programmazione ad oggetti
01:02:11 < hoax> mi semvra molto più facile quella procedurale
01:02:16 < Stemby> non l'abbiamo ancora affrontata
01:02:27 < Stemby> e ci vorrà ancora un po' prima che ci arriviamo
01:03:07 < Stemby> finché non è abbastanza solida la programmazione procedurale, è inutile complicarsi la vita
01:03:28 < Stemby> la programmazione orientata agli oggetti è senz'altro molto più difficile
01:03:44 < Stemby> perché bisogna decidere come implementare questi oggetti
01:04:29 < hoax> beh sì, in C c'è un qualcosa di simile agli oggetti nelle strutture, ma proprio un accenno
01:04:57 < Stemby> beh, insomma
01:05:05 < hoax> cioè tipi di dati con attributi
01:05:20 < Stemby> sì, ma non è programmazione orientata algi oggetti, quella
01:05:26 < hoax> no
01:05:30 < Stemby> gli oggetti li stiamo usando anche noi
01:05:34 < Stemby> fin dall'inizio
01:05:52 < Stemby> ma con un approccio assolutamente procedurale
01:05:59 < hoax> oo sarebbe l'uso dei metodi?
01:06:08 < Stemby> classi e metodi, sì
01:06:11 < hoax> cioè che interagiscono con gli oggetti
01:06:16 < Stemby> (e istanze, ovviamente)
01:06:19 < hoax> i quali offrono servizi
01:06:41 < Stemby> sì
01:06:47 < hoax> avevo visto qualcosa di java, ma non ci avevo capito molto
01:07:04 < Stemby> esatto, java è assolutamente orientato agli oggetti
01:07:28 < Stemby> mentre con python si può fare anche dell'ottima programmazione procedurale
01:08:05 < hoax> poi java non è di scripting mentre Python sì
01:08:25 < Stemby> diciamo di sì :)
01:08:29 < hoax> ma essere linguaggio di scripting significa solo che non è compilato?
01:09:05 < Stemby> bah, diciamo che ai programmatori python non piace molto la definizione di python come linguaggio di scripting
01:09:33 < Stemby> tra l'altro python È compilato
01:09:48 < Stemby> (anche se il programmatore quasi non se ne accorge)
01:10:02 < hoax> leggo che usate un interprete, o dico sbagliato?
01:10:09 < Stemby> sì
01:10:20 < hoax> sarebbe le shell interattiva?
01:10:23 < Stemby> ma in realtà l'interprete è più che un interprete
01:10:24 < Stemby> sì
01:10:52 < Stemby> la shell interattiva è l'interfaccia utente per dialogare direttamente con l'interprete
01:11:15 < Stemby> ma l'interprete (python3) in realtà è molto di più
01:11:27 < Stemby> è un compilatore
01:11:36 < Stemby> e anche una macchina virtuale
01:11:58 < hoax> un po' come la java virtual machine
01:12:06 < Stemby> (compila in bytecode, e poi la macchina virtuale trasforma il bytecode in linguaggio macchina)
01:12:14 < Stemby> hoax: sì, è molto simile
01:12:20 < Stemby> solo che è del tutto trasparente
01:12:33 < Stemby> il programmatore non deve compilare manualmente
01:12:44 < Stemby> e la compilazione avviene in tempo reale
01:12:58 < Stemby> quindi per il programmatore è come se fosse un linguaggio interpretato
01:13:17 < hoax> in che senso in tempo reale?
01:13:29 < hoax> Cioè istruzione per istruzione
01:13:36 < Stemby> esatto
01:13:43 < hoax> non tutto il sorgente in blocco come in C
01:13:48 < Stemby> esatto
01:14:05 < Stemby> è per quello che puoi usare l'interfaccia interattiva
01:14:25 < Stemby> lì in pratica si scrive un'istruzione alla volta
01:15:10 < hoax> capito
01:15:18 < Stemby> http://it.diveintopython.org/getting_to_know_python/testing_modules.html
01:15:42 < Stemby> qui la prima spiegazione che ho trovato online riguardo al trucchetto che abbiamo provato stasera
01:17:05 < Stemby> dai, hoax, cerca di recuperare
01:17:13 < Stemby> stiamo andando davvero tranquilli
01:18:32 < Stemby> notte
Strumenti personali
Varianti
Azioni
Navigazione
Risorse
Strumenti