Guide@Debianizzati.Org

Accademia:Log 2011 03 20: differenze tra le versioni

Accademia Discussione

Accademia:Log 2011 03 20 (visualizza wikitesto)

Versione delle 11:50, 22 mar 2011

19 954 byte aggiunti ,  22 mar 2011
nessun oggetto della modifica
(Creata pagina con '{{Template:Acc_Menu_Python}} <pre width="135" style="font-family:sans-seriffont-size-adjust:none; font-size: 120%; font-stretch:normal; font-style:normal; font-variant:normal; fo...')
 
Nessun oggetto della modifica
Riga 1: Riga 1:
{{Template:Acc_Menu_Python}}
{{Template:Acc_Menu_Python}}
=Su IRC=
<pre width="135" style="font-family:sans-seriffont-size-adjust:none; font-size: 120%; font-stretch:normal; font-style:normal; font-variant:normal; font-weight:normal; line-height:normal; background-color:#fcfcfc; border: 1px solid #ccc">
<pre width="135" style="font-family:sans-seriffont-size-adjust:none; font-size: 120%; font-stretch:normal; font-style:normal; font-variant:normal; font-weight:normal; line-height:normal; background-color:#fcfcfc; border: 1px solid #ccc">
21:56:31 < |Wolf|> c'è il corso?
21:56:31 < |Wolf|> c'è il corso?
Riga 131: Riga 132:
23:00:32 < Stemby> volevo dire: gobby
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]
23:16:01 -!- Ernestus [~ernesto@Azzurra-667A47D2.25-79-r.retail.telecomitalia.it] has quit [Quit: Ex-Chat]
</pre>
=Su Gobby=
<pre width="135" style="font-family:sans-seriffont-size-adjust:none; font-size: 120%; font-stretch:normal; font-style:normal; font-variant:normal; font-weight:normal; line-height:normal; background-color:#fcfcfc; border: 1px solid #ccc">
[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
</pre>
=Da IRC=
<pre width="135" style="font-family:sans-seriffont-size-adjust:none; font-size: 120%; font-stretch:normal; font-style:normal; font-variant:normal; font-weight:normal; line-height:normal; background-color:#fcfcfc; border: 1px solid #ccc">
00:10:00 -!- amosse [~Mibbit@Azzurra-788D7337.252-95-r.retail.telecomitalia.it] has quit [Quit: http://www.mibbit.com ajax IRC Client]
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:06 < Stemby> allora
Risca86
909

contributi

Estratto da "https://guide.debianizzati.org/index.php/Speciale:DiffMobile/24604"