Accademia:Log 2011 02 20

21:38:06 < risca_> dai, siamo già in otto
21:38:16 < risca_> due minuti ed iniziamo?
21:38:17 < amosse> dobbiamo passare su gobby
21:38:31 -!- NoxDaFox [~nox@Azzurra=1F33399E.243-28.fastweb.fw] has joined #debianizzati-corsi
21:38:38 < groll> mi sembra più ben fatto kobby comunque
21:38:44 < groll> almeno a giudicare dagli screenshot
21:39:32 < Stemby> risca_: http://guide.debianizzati.org/index.php/Accademia:Log_2011_02_16
21:40:12 < Stemby> posso cancellare prova.c su gobby?
21:40:17 < risca_> Stemby, ma manca quindi gobby, giusto?
21:40:26 < Stemby> ?
21:40:29 < risca_> io non ho ancora copiato nulla da gobby
21:40:31 < Stemby> ah, per il log
21:40:37 < Stemby> sì, quello è spacciato
21:40:44 < risca_> voi avete gli script della scorsa lezione?
21:40:50 < Stemby> ce li ho io
21:40:53 < Stemby> li carico
21:41:24 < risca_> ok
21:41:39 < Stemby> cancello prova.c
21:41:49 < Ernestus> ragazzi a cose serve "break"?
21:42:22 < Stemby> Ernestus: cerchiamolo insieme sulla documentazione ufficiale
21:42:39 < Stemby> almeno impariamo a navigarci dentro (fondamentale!)
21:42:46 < risca_> impaginato: http://guide.debianizzati.org/index.php/Accademia:Log_2011_02_16
21:42:51 < Stemby> forza, passatemi il link giusto
21:43:34 < Ernestus> http://docs.python.org/release/3.1.3/
21:43:46 < Stemby> grazie risca_
21:44:03 < Ernestus> http://docs.python.org/release/3.1.3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops
21:44:06 < Ernestus> eccolo
21:44:10 < Stemby> ottimo
21:44:17 < Stemby> prova a leggere
21:44:25 < Stemby> così intanto aspettiamo i ritardatari
21:45:11 [Users #debianizzati-corsi]
21:45:11 [ amosse  ] [ esulu] [ hoax    ] [ risca_] [ Stemby] 
21:45:11 [ Ernestus] [ groll] [ NoxDaFox] [ spirit] 
21:45:11 -!- Irssi: #debianizzati-corsi: Total of 9 nicks [0 ops, 0 halfops, 0 voices, 9 normal]
21:45:17 < Stemby> tieni presente che for non l'abbiamo ancora fatto
21:45:30 < Stemby> while però sì
21:45:31 < risca_> le librerie sono chiare a tutti?
21:45:58 < groll> che avete fatto l'ultima volta?
21:46:24 < risca_> funzioni e librerie, giusto?
21:46:25 < Stemby> groll: tanto...
21:46:26 < Ernestus> break, a quanto ho capito, ferma il ciclo while/for
21:46:36 < Stemby> Ernestus: esatto
21:46:36 < risca_> Giusto
21:46:46 < Stemby> continue l'hai capito?
21:46:47 [Users #debianizzati-corsi]
21:46:47 [ amosse  ] [ esulu] [ hoax    ] [ risca_] [ Stemby] 
21:46:47 [ Ernestus] [ groll] [ NoxDaFox] [ spirit] 
21:46:47 -!- Irssi: #debianizzati-corsi: Total of 9 nicks [0 ops, 0 halfops, 0 voices, 9 normal]
21:46:59 < risca_> esulu: ci sei?
21:47:33 < amosse> si protrebbe spiegare un  po continue?
21:47:34 < esulu> io si
21:47:35 < esulu> io
21:47:37 < esulu> si
21:47:39 < risca_> ok
21:47:42 < spirit> fa ripartire la funzione dall' inizio, mi sembra
21:47:58 < esulu> scusatemi ma ci saranno in futuro anche dei corsi sul C per caso
21:47:58 < esulu> ?
21:48:11 < esulu> ok
21:48:12 < Stemby> spirit: usiamo i termini appropriatamente
21:48:21 < Stemby> "funzione" ha un significato preciso
21:48:32 < spirit> dal testo iniziale
21:49:01 < risca_> esulu: perché no?
21:49:17 < risca_> dopo aver finito con python dovremmo pure trovare qualcos'altro
21:49:27 < Stemby> spirit: forza il ciclo a riprendere dall'inizio del blocco
21:49:31 < esulu> bene io non vedo l'ora direi
21:49:37 < Stemby> "blocco" è chiaro come termine?
21:49:38 < spirit> ok 
21:49:49 < groll> con il C sarà il delirio :D
21:50:01 -!- brunology [~brunology@Azzurra=7110FBA7.51-82-r.retail.telecomitalia.it] has joined #debianizzati-corsi
21:50:01 < risca_> ^.^
21:50:04 < Stemby> groll: beh, però avremo delle basi di programmazione
21:50:18 < risca_> ciao brunology, stiamo iniziando proprio ora
21:50:18 < Stemby> ripeto:
21:50:20 < Stemby> "blocco" è chiaro come termine?
21:50:32 < risca_> sì
21:50:39 < Stemby> risca_: non a te :)
21:50:39 < spirit> si
21:50:49 < Stemby> spirit: spiega
21:51:00 < Stemby> (per i timidi che non hanno detto no)
21:51:40 < amosse> blocco, "tutto quelloc che sta all'interno di un ciclo"?
21:51:46 -!- GipPasso [~webchat@Azzurra-2BE4CFCE.clienti.tiscali.it] has joined #debianizzati-corsi
21:51:49 -!- mode/#debianizzati-corsi [+o GipPasso] by ChanServ
21:51:50 < Stemby> più in generale?
21:51:58 < Stemby> (non è detto che si tratti di un ciclo)
21:52:00 <@GipPasso> Salve. Scusate il ritardo. Mauro Moretti ha dato il suo contributo.
21:52:01 < spirit> un blocco è una suite in certosenso
21:52:06 < amosse> di istruzioni..
21:52:13 < Stemby> spirit: suite???
21:52:26 < Stemby> su, una definizione semplice semplice
21:52:40 < Stemby> (pensate anche alla sintassi python, che aiuta molto)
21:52:51 < spirit> è un istruzione che dai 
21:53:06 < amosse> un insieme di istruzioni
21:53:10 < groll> descrivetela graficamente
21:53:22 < amosse> ?
21:53:27 < spirit> ?
21:53:47 < Stemby> amosse: sì, è un'insieme di istruzioni
21:54:00 < Stemby> io direi: "un pezzo di codice indentato"
21:54:02 < Stemby> :)
21:54:10 < Stemby> ok?
21:54:37 < spirit> hai spiegato bene Stemby, si
21:54:45 < Stemby> invece "funzione" è un altro termine preciso, che abbiamo affrontato la volta scorsa
21:54:59 < Stemby> chi mi dice cos'è una funzione?
21:56:04 < Stemby> nessuno???
21:56:14 < Stemby> chi è che ha bigiato la lezione scorsa?
21:56:19 < brunology> io
21:56:31 < Stemby> brunology è giustificato
21:56:35 < Stemby> gli altri no...
21:56:36 < brunology> e ho visto solo ora il log sul wiki, prima non c'era
21:56:47 < Stemby> brunology: sì, l'abbiamo appena messo su
21:56:52 < brunology> ok
21:56:57 < Stemby> mi spiace, ma gli impegni son tanti
21:57:03 < brunology> no problem :)
21:57:24 < Stemby> allora, cos'è una finzione?
21:57:32 < Stemby> Ernestus: ci aiuti tu?
21:57:36 < spirit> nelle funzioni ci sono operatori e variabili
21:57:50 < Stemby> definizione
21:58:18 < Stemby> (tra l'altro non è detto che ci siano né operatori, né variabili)
21:58:30 < Stemby> anzi:
21:58:45 < Stemby> vi faccio un esempio di una funzione senza né operatori né variabili
21:58:54 < Stemby> andiamo su gobby
21:59:10 < Ernestus> porta e indirizzo?
21:59:52 < spirit> una funzione perchè esista deve avere un argomento
22:00:30 < risca_> solito
22:00:54 < risca_> stemby.dyndns.org:6522
22:01:10 < Stemby> sì
22:04:41 < Stemby> allora, chi mi analizza esempio.py?
22:04:52 < Stemby> riga per riga
22:05:41 < Ernestus> io
22:06:06 < Ernestus> vado?
22:06:28 < Stemby> vai
22:06:50 < Ernestus> riga 1; invoca python2
22:06:54 < Stemby> 3
22:06:59 < Ernestus> riga 2,4 e 6: niente
22:07:07 < Ernestus> riga 3: commento
22:07:28 < Stemby> intendevo: py3
22:07:45 < Stemby> hai detto py2, ma è py3 che viene invocato
22:07:48 < Ernestus> riga 5: con la funzione def creiamo una nostra funzione "separator" che stampa .*-*20
22:08:06 < Stemby> analizziamo bene
22:08:17 < Stemby> ah, a dire il vero lì ci ho messo dentro un operatore
22:08:20 < Stemby> lo tolgo
22:08:40 < Stemby> fatto
22:08:47 < Stemby> è esattamente equivalente
22:08:51 < Stemby> :)
22:09:16 < Ernestus> stampa una seriee di trattini
22:09:20 < Stemby> esatto
22:09:30 < Stemby> però quella è la riga 6, da me
22:09:37 < Stemby> come mai sei sfalsato di una riga?
22:09:40 < Ernestus> si scusa
22:09:56 < Stemby> ah, no, ho letto male io
22:10:05 < Stemby> hai speigato le righe 5 e 6
22:10:07 < Stemby> ok
22:10:12 < Stemby> poi?
22:10:22 < Ernestus> riga 8 e 10: stampa la funzione separator quindi i trattini e in mezzo stampa la parola "titolo"
22:10:34 < Stemby> non proprio
22:10:38 < Stemby> riga 8
22:10:40 < Stemby> cosa fa?
22:10:57 < amosse> invoca la funzione
22:11:02 < Stemby> esatto
22:11:08 < Stemby> attenzione che non è la stessa cosa
22:11:20 < Stemby> alla riga 8 non c'è la funzione print()
22:11:31 < Ernestus> alla 9
22:11:34 < Stemby> la funzione print() la si trova all'interno della nostra funzione
22:11:39 < Stemby> prosegui
22:11:43 < Ernestus> alla 9 la funzione print stampa la stringa "title"
22:12:02 < Stemby> ok
22:12:20 < Stemby> poi?
22:12:34 < Stemby> riga 10
22:12:40 < Ernestus> riga 10: invoca separator che stampa i trattini
22:12:43 < Stemby> ok
22:12:50 < Stemby> chiaro per tutti?
22:12:54 < amosse> ok
22:12:58 < brunology> sì
22:13:03 < Stemby> allora torniamo alla domanda iniziale
22:13:07 < Stemby> cos'è una funzione?
22:13:20 < Ernestus> è un costrutto
22:13:40 < Stemby> mmm
22:13:41 < spirit> è una istruzione
22:13:46 < Stemby> spirit: no
22:13:52 < Stemby> cos'è un'istruzione?
22:14:15 < Ernestus> una serie di istruzioni?
22:14:23 < spirit> blocco
22:14:24 < Stemby> Ernestus: sì
22:14:29 < Stemby> spirit: no di nuovo
22:14:32 < Stemby> aspettate
22:14:39 < Stemby> cos'è un'istruzione?
22:15:25 < Stemby> definizione grossolana accettata :)
22:15:28 < Ernestus> un comando di python
22:15:28 < brunology> ogni riga di esempio.py è un'istruzione (a parte i commenti)?
22:15:32 < Stemby> Ernestus: no
22:15:37 < Stemby> brunology: esatto
22:15:48 < Stemby> grosso modo un'istruzione è una riga di codice
22:16:01 < amosse> possiamo usare anche i termini in inglese, per facilitare la lettura della documentazione ufficiale?
22:16:12 < Stemby> mmm
22:16:27 < Ernestus> si, meglio
22:16:33 < amosse> intendevo insieme
22:16:41 < Stemby> sto consultando wikipedia
22:16:42 < amosse> es: blocco (suite)
22:16:44 < Stemby> :)
22:17:14 < Stemby> facile
22:17:19 < Stemby> instruction
22:17:31 < Stemby> "suite" non ne sono convinto
22:17:37 < Stemby> secondo me è "block"
22:17:42 < Ernestus> statement: dichiarazione
22:17:56 < Ernestus> ma cos'è una dichiarazione?
22:17:57 < amosse> ok
22:19:01 < Stemby> Ernestus: in python non c'è
22:19:07 < brunology> http://en.wikipedia.org/wiki/Block_%28programming%29
22:19:21 < Stemby> o meglio: si fa in contemporanea con l'assegnazione
22:19:34 < Stemby> myvariable = "foo"
22:19:49 < Stemby> questa istruzione è un'assegnazione di variabile
22:20:06 < Stemby> e al contempo (anzi, immediatamente prima" la variabile viene dichiarata
22:20:23 < Stemby> però se ne occupa python stesso, quindi non ti interessa
22:20:32 < Stemby> ci interesserà invece nel corso C :)
22:20:45 < Stemby> allora
22:20:55 < Stemby> torniamo al glossario
22:21:08 < Stemby> istruzione: riga di codice
22:21:14 < Stemby> espressione?
22:21:32 < amosse> operando + operatore
22:21:47 < Stemby> ok
22:21:51 < Stemby> chiaro per tutti?
22:22:00 < Stemby> oggetti mischiati a operatori
22:22:08 < brunology> ok
22:22:12 < Stemby> ne abbiamo già viste molte
22:22:18 < Stemby> nelle ultime lezioni:
22:22:25 < Stemby> tutte le espressioni booleane
22:22:35 < Stemby> correggo
22:22:43 < Stemby> tutte le espressioni con operatori booleani
22:22:53 < Stemby> e tutte le espressioni con operatori di confronto
22:22:58 < Stemby> vi ricordate?
22:23:09 < amosse> si
22:23:14 < Stemby> ok
22:23:19 < risca_> ok
22:23:23 < Stemby> blocco: codice indentato
22:23:30 < Stemby> funzione?
22:23:54 < risca_> funzione: set di istruzioni
22:24:12 < Stemby> cosa differenzia la funzione da un blocco?
22:24:47 < amosse> la funzione é una parte di programma a se e può essere richiamata (invocata)
22:24:56 < Stemby> esatto
22:25:00 < Stemby> bravo amosse
22:25:09 < Stemby> invece un blocco?
22:25:29 < risca_> un blocco è molto generico
22:25:34 < amosse> in blocco é insiemne di istruzioni
22:25:44 < Stemby> risca_: non troppo generico
22:25:45 -!- ernesto [~ernesto@Azzurra=5C301E82.45-79-r.retail.telecomitalia.it] has joined #debianizzati-corsi
22:25:56 < Stemby> amosse: che...
22:25:58 < risca_> giusto
22:26:09 < ernesto> eccomi scusate
22:26:16 < amosse> é giusto?
22:26:25 < Stemby> amosse: sì, continua
22:26:31 < risca_> un blocco di istruzioni che...
22:26:35 < Stemby> un insieme di istruzioni che...
22:26:49 < Stemby> proseguo io, altrimenti
22:27:04 < Stemby> ...fanno parte di una struttura di controllo
22:27:05 < Stemby> ok?
22:27:09 < amosse> ok
22:27:21 < risca_> ma quindi la funzione è una struttura di controllo?
22:27:22 < brunology> una struttura di controllo?
22:27:27 < Stemby> risca_: no
22:27:27 < brunology> cos'è? :)
22:27:32 < Stemby> brunology: ok
22:27:39 < Stemby> non avete fatto i compiti...
22:27:58 < Stemby> avevate da leggere una paginetta su wikipedia, per settimana scorsa
22:28:07 < Stemby> la recuperiamo ora
22:28:26 < risca_> allora il blocco è semplicemente un insieme di istruzioni eseguito in subordine a qualcosa
22:28:36 < Stemby> http://it.wikipedia.org/wiki/Programmazione_strutturata
22:28:49 < Stemby> qui ci sono le strutture di controllo
22:28:52 < risca_> siccome anche la funzione ha in genere almeno un blocco
22:28:58 < Stemby> vediamole più approfonditamente
22:29:06 < Stemby> risca_: no
22:29:22 < Stemby> risca_: l'esempio che ho portato non aveva alcun blocco
22:29:33 < Stemby> aveva dentro solo un'unica istruzione
22:29:43 < risca_> ma a volte c'è
22:29:46 < Stemby> che stampava i trattini
22:29:49 < Stemby> risca_: a volte
22:29:54 < Stemby> ma non è un discriminante
22:30:17 < risca_> però una unica riga può essere anch'essa un blocco
22:30:37 < Stemby> direi di no
22:31:15 < Stemby> perché prima deve esserci almeno un'altra riga per inserire la struttura di controllo
22:31:20 < Stemby> if...
22:31:23 < Stemby> while...
22:31:27 < Stemby> ecc.
22:31:36 < Stemby> tornando alle strutture di controllo: avete aperto quella paginetta?
22:31:47 < amosse> ok
22:31:51 < Stemby> http://it.wikipedia.org/wiki/Programmazione_strutturata#La_strutturazione_del_controllo
22:32:01 < Stemby> come vediamo ci sono 3 grosse strutture
22:32:28 < Stemby> mischiandole insieme possiamo implementare _qualsiasi_ algoritmo
22:32:37 < Stemby> algoritmo?
22:33:07 < spirit> codice
22:33:12 < Stemby> spirit: mmm
22:33:17 < brunology> sequenza di istruzioni
22:33:22 < Stemby> brunology: mmmm
22:33:29 < Stemby> qualcosa di meglio?
22:34:04 < Stemby> qualche lezione fa me l'avete detto...
22:34:11 < Stemby> (non ricordo chi)
22:34:16 < amosse> soluzione ad un problema
22:34:23 < Stemby> amosse: mi sa che eri tu :)
22:34:40 < Stemby> è il procedimento logico che permette di risolvere un problema
22:34:42 < Stemby> tutto qui
22:34:54 < Stemby> chiaro?
22:35:01 < brunology> sì
22:35:12 < amosse> ok
22:35:17 < Stemby> allora vediamo queste strutture di controllo
22:35:20 < Stemby> 1) sequenza
22:35:25 < Stemby> è la più semplice
22:35:39 < Stemby> una serie di istruzioni una dietro l'altra
22:35:46 < Stemby> come si fa in python?
22:36:17 < brunology> senza indentare?
22:36:22 < Stemby> brunology: sì
22:36:27 < Stemby> è semplice semplice
22:36:32 < Stemby> basta andare a capo :)
22:36:36 < amosse> si fanno delle righe di codice
22:36:46 < Stemby> e scrivere l'istruzione successiva
22:37:02 < Stemby> 2) selezione
22:37:23 < Stemby> in realtà ci sono vari tipi di selezione
22:37:31 < Stemby> in generale: come si fa in python?
22:37:46 < amosse> il costrutto if o while
22:37:50 < Stemby> if
22:37:55 < Stemby> while no
22:38:05 < Stemby> o almeno... si può usare ma è una forzatura
22:38:12 < amosse> ok
22:38:23 < Stemby> in generale if
22:38:39 < Stemby> vedete che ci sono 2 diagrammi di flusso per la selezione?
22:38:47 < Stemby> (ne esistono anche altri)
22:39:05 < Stemby> http://it.wikipedia.org/wiki/Programmazione_strutturata#Selezione
22:39:13 < Stemby> ci siete?
22:39:14 < spirit> cioè condizione e poi S/N
22:39:55 < Stemby> come si implementano in python quei 2 diagrammi?
22:40:19 < Stemby> fatemeli su gobby
22:47:30 -!- Ernestus [~Mibbit@Azzurra=5C301E82.45-79-r.retail.telecomitalia.it] has quit [Quit: http://www.mibbit.com ajax IRC Client]
22:49:27 < Stemby> tutto chiaro finora?
22:49:32 < amosse> okok
22:49:44 < brunology> ok
22:49:54 < Stemby> bene
22:50:24 < Stemby> ultima struttura di controllo: http://it.wikipedia.org/wiki/Programmazione_strutturata#Iterazione
22:50:57 < Stemby> in python il secondo diagramma non si può fare
22:51:03 < Stemby> esiste solo il primo
22:51:33 < ernesto> se capita una situazione del secondo?
22:51:33 < Stemby> ma non ha grande importanza: si può rigirare il secondo in modo che diventi il primo
22:51:45 < Stemby> appena risposto :)
22:51:59 < Stemby> è sufficiente il primo
22:52:34 < Stemby> la situazione del secondo può essere risolta comunque con le altre strutture di controllo esistenti
22:52:54 < Stemby> come si realizza il primo diagramma?
22:53:12 < Stemby> facciamolo su gobby
23:06:02 < amosse> ok
23:06:32 < Stemby> eccomi
23:06:35 < Stemby> dicevamo?
23:06:47 < ernesto> python è orientato agli oggetti
23:06:50 < Stemby> la programmazione orientata agli oggetti la vedremo tra un po'
23:06:57 < ernesto> cos'è un oggetto e osa significa quell'affermazione?
23:07:08 < Stemby> non è che python è orientato agli oggetti
23:07:18 < groll> python è puramente ad oggetti
23:07:26 < groll> tutto è un oggetto
23:07:30 < Stemby> è la programmazione che può essere orientata agli oggetti
23:07:41 < amosse> ma anche procedurale?
23:07:46 < Stemby> è un paradigma di programmazione
23:07:56 < groll> amosse: si 
23:07:59 < Stemby> amosse: è il paradigma che stiamo seguendo
23:08:07 < amosse> ok
23:08:09 < Stemby> programmazione procedurale strutturata
23:08:28 < groll> nel codice che avete scritto ci sono due oggetti print e C
23:08:47 < groll> ma poi li vedrete più avanti cosa sono quando farete le classi
23:08:47 < Stemby> ah, sì, è vero
23:08:52 < Stemby> anche print
23:09:01 < groll> ora fareste solo confusione
23:09:07 < Stemby> comunque non ci interessa al momento
23:09:08 < groll> dovete almeno imparare le funzioni
23:09:21 < groll> a meno che non ve le spieghiamo a mo delle struct del C :D
23:09:22 < Stemby> groll: le funzioni le abbiamo fatte
23:09:29 < groll> ah pensavo doveste ancora farle
23:09:36 < Stemby> torniamo al glossario
23:09:45 < Stemby> dov'eravamo rimasti?
23:10:02 < Stemby> ah, strutture di controllo
23:10:05 < Stemby> chiare?
23:10:13 < amosse> ok
23:10:18 < spirit> si
23:10:24 < Stemby> con quelle strutture, si può implementare _qualsiasi_ algoritmo
23:10:36 < Stemby> vedremo che while lo useremo pochino
23:10:49 < Stemby> useremo soprattutto for al suo posto
23:10:55 < Stemby> ma i concetti sono quelli
23:11:07 < groll> non vi servirebbero neppure le funzioni per implementare i vari algoritmi
23:11:37 < Stemby> groll: stiamo parlando delle strutture di controllo
23:11:51 < Stemby> http://it.wikipedia.org/wiki/Programmazione_strutturata
23:12:02 < Stemby> abbiamo appena finito di vederle in python
23:12:05 < Stemby> bene
23:12:19 < groll> era per rafforzare la tua affermazione si può implementare qualsiasi algoritmo :P
23:12:43 < Stemby> direi che per qualche minuto possiamo proseguire nella trattazione degli operatori
23:13:02 < amosse> le funzione servono, alla fine, per una migliore leggibilità e portabilità del codice?
23:13:11 < Stemby> brunology: nelle scorse due lezioni abbiamo visto tutti gli operatori booleani e di confronto
23:13:40 < Stemby> amosse: comodità, sintesi, chiarezza, abbattimento di bug potenziali, ecc.
23:13:46 < amosse> ok
23:13:48 < groll> amosse: si la mia frase era solo teorica nessuno programma senza
23:13:57 < amosse> ok
23:14:14 < Stemby> chi mi passa il link alla documentazione degli operatori?
23:14:20 < Stemby> lo fai tu, brunology?
23:14:25 < Stemby> :)
23:15:33 < Stemby> brunology dorme, lo faccio io
23:15:36 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html
23:15:53 < Stemby> scorse 2 lezioni: paragrafi 5.2 e 5.3
23:16:08 < Stemby> oggi facciamo il successivo
23:16:31 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#numeric-types-int-float-complex
23:16:36 < Stemby> operatori aritmetici
23:16:51 < Stemby> in generale si usano con i numeri
23:17:05 < Stemby> chi si ricorda i tipi numerici in python3?
23:17:32 < Stemby> nessuno?
23:17:46 < Stemby> ma cosa li scriviamo a fare gli appunti risca_ ed io???
23:17:55 < amosse> +,-,/,*,//,%
23:17:59 < Stemby> no
23:18:01 < spirit> int,float
23:18:07 < Stemby> spirit: sì
23:18:09 < Stemby> e?
23:18:14 < Stemby> ce n'è un altro
23:18:17 < spirit> complex
23:18:19 < Stemby> ok
23:18:22 < Stemby> ottimo
23:18:34 < Stemby> i numeri complessi li tralasciamo
23:18:48 < spirit> sono belli però
23:18:53 < Stemby> se qualcuno di voi volesse/dovesse usarli, si documenterà autonomamente
23:19:04 < brunology> (sono tornato)
23:19:33 < Stemby> allora entriamo nell'interfaccia interattiva
23:19:44 < Stemby> pronti?
23:19:53 < brunology> via
23:19:55 < amosse> ok
23:19:59 < ernesto> sisi
23:20:05 < Stemby> primo operatore: +
23:20:15 < Stemby> scrivetemi un paio di espressioni
23:20:20 < Stemby> anche 3
23:21:14 < Stemby> forza
23:21:15 < brunology> >>> 3 + 2
23:21:17 < brunology> 5
23:21:19 < brunology> >>> 300 +235
23:21:20 < Stemby> ok
23:21:21 < brunology> 535
23:21:23 < brunology> >>> 3+3+9+23
23:21:25 < brunology> 38
23:21:30 < Stemby> sì
23:21:38 < Stemby> quelle sono tutte espressioni con interi
23:21:44 < Stemby> che danno?
23:22:01 < ernesto> la somma degli interi
23:22:04 < Stemby> e?
23:22:16 < Stemby> cosa restituisce l'interprete?
23:22:19 < spirit> un intero
23:22:22 < Stemby> ok
23:22:32 < Stemby> se volete, verificatelo con la solita funzione
23:22:36 < Stemby> vi ricordate quale?
23:22:47 < brunology> >>> type(2+3)
23:22:49 < brunology> <class 'int'>
23:22:51 < Stemby> ok
23:23:10 < Stemby> chi mi passa qualche espressione più interessante?
23:23:10 < brunology> >>> type(2.0+3.0)
23:23:12 < brunology> <class 'float'>
23:23:18 < Stemby> ottimo
23:23:27 < Stemby> e ancora più interessante?
23:23:36 < amosse> 7%3
23:23:40 < Stemby> no
23:23:47 < Stemby> siamo ancora al primo operatore
23:23:50 < Stemby> +
23:23:54 < amosse> ok
23:24:23 < Stemby> >>> 7.0 + 3
23:24:23 < Stemby> 10.0
23:24:29 < Stemby> perché è interessante?
23:24:45 < brunology> perché prevale il float
23:24:58 < Stemby> quindi cosa succede?
23:25:16 < brunology> la somma di un intero e un float restituisce un float
23:25:23 < brunology> in italiano come si dice?
23:25:29 < amosse> sempre
23:25:32 < amosse> decimale
23:25:54 < Stemby> significa che con ogni probabilità python in automatico fa questo:
23:26:04 < Stemby> 7.0 + float(3)
23:26:16 < Stemby> ovvero trasforma l'intero in float
23:26:22 < Stemby> ok?
23:26:27 < amosse> ok
23:26:33 < ernesto> ok
23:26:35 < Stemby> bene.
23:27:05 < Stemby> il secondo operatore è banaler
23:27:07 < Stemby> *banale
23:27:11 < Stemby> il terzo pure
23:27:17 < Stemby> guardiamo il quarto
23:27:30 < Stemby> questa è una delle novità di py3
23:27:37 < Stemby> fatemi un po' di espressioni
23:28:13 < brunology> qual è il quarto operatore?
23:28:24 < ernesto> quoziente
23:28:29 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#numeric-types-int-float-complex
23:28:41 < Stemby> forza
23:29:09 < amosse> 7/3 -> 2
23:29:15 < Stemby> no
23:29:26 < brunology> i risultati sono sempre col decimale...
23:29:27 < Stemby> amosse: prova con l'interfaccia interattiva
23:29:31 < amosse> ops
23:29:41 < amosse> scusa intendevo 7//3
23:29:54 < Stemby> siamo a /
23:29:58 < amosse> ok
23:30:04 < ernesto>  /
23:30:18 < Stemby> questa è una grossa differenza rispetto a py2
23:30:40 < Stemby> in py3, qualsiasi sia il tipo dei 2 oggetti, vengono sempre prima trasformati in float
23:30:51 < Stemby> quindi avremo come risultato un float
23:31:14 < Stemby> in py2 non era così
23:31:24 < Stemby> un intero diviso un intero dava un intero
23:31:39 < brunology> e per avere i decimali come si faceva?
23:31:52 < Stemby> si doveva usare almeno un float
23:31:54 < Stemby> es:
23:32:03 < Stemby> 10.0/2
23:32:05 < Stemby> oppure
23:32:09 < Stemby> 10 / 2.0
23:32:26 < Stemby> ed era molto importante
23:32:42 -!- esulu [~esulu@Azzurra-2E257C8D.ip77.fastwebnet.it] has quit [Ping timeout]
23:32:48 < Stemby> vediamo il siccessivo
23:32:56 < Stemby> *successivo
23:33:02 < Stemby> /
23:33:07 < Stemby> sorry
23:33:12 < Stemby>  //
23:33:31 < Stemby> in italiano: "divisione intera"
23:33:37 < Stemby> fatemi un po' di espressioni
23:33:38 < ernesto> quoziente senza resto
23:33:50 < Stemby> ernesto: non proprio
23:33:57 < Stemby> almeno... adesso provo e ti dico
23:34:20 < Stemby> esatto: è come pensavo
23:34:28 < Stemby> è l'analogo del / di py2
23:34:31 < Stemby> >>> -5//2
23:34:31 < Stemby> -3
23:34:36 < Stemby> visto?
23:34:47 < ernesto> si
23:34:48 < Stemby> non è il quoziente senza resto
23:34:56 < Stemby> altrimenti avrebbe dovuto dare -2
23:35:16 < Stemby> arrotonda sempre all'intero inferiore
23:35:33 < ernesto> floored che significa?
23:35:33 < Stemby> quindi OCIO quando si usano i numeri negativi
23:35:56 < amosse> type(7.0//3)
23:36:08 < amosse> <class 'float'>
23:36:26 < Stemby> ernesto: potrebbe essere un refuso
23:36:40 < Stemby> chi è forte in inglese?
23:37:02 < ernesto> io no di certo
23:37:06 < Stemby> no, esiste
23:37:09 < Stemby> http://www.thefreedictionary.com/floored
23:37:54 -!- esulu [~esulu@Azzurra-2E257C8D.ip77.fastwebnet.it] has joined #debianizzati-corsi
23:38:47 < Stemby> ok
23:38:50 < Stemby> andiamo avanti
23:39:00 < Stemby> operatore modulo
23:39:07 < Stemby> %
23:39:11 < Stemby> cosa fa?
23:39:45 < Stemby> provate...
23:40:06 < amosse> restituisce il resto 7%3 -> 1
23:40:07 < ernesto> 5 % 2
23:40:08 < ernesto> 1
23:40:14 < Stemby> ok
23:40:18 < ernesto> resto della divisione
23:40:20 < Stemby> che tipo restituisce?
23:40:32 < ernesto> intero
23:40:36 < Stemby> dipende
23:40:47 < Stemby> >>> 7.0 % 2
23:40:47 < Stemby> 1.0
23:40:50 < brunology> se c'è un float dà float
23:40:58 < Stemby> e ne basta uno
23:41:07 < Stemby> float % intero
23:41:10 < Stemby> o viceversa
23:41:16 < Stemby> danno float
23:41:31 < Stemby> avanti
23:41:39 < Stemby> il segno immagino che sia chiaro
23:41:50 -!- groll [~groll@Azzurra-77C64D4B.48-151.net24.it] has quit [Read/Dead Error: Input/output error]
23:42:11 < Stemby> poi ci sono un po' di funzioni
23:42:23 < ernesto> -x +x
23:42:24 < Stemby> le abbiamo già viste tutte le principali
23:42:57 < Stemby> ernesto: hai dubbi sul segno?
23:43:01 < Stemby> è come in algebra
23:43:03 < ernesto> no scusate
23:43:21 < ernesto> sbagliato a copiancollare; volevo dire power è potenza?
23:43:25 < Stemby> guardiamo le funzioni
23:43:29 < Stemby> ernesto: sì
23:43:47 < Stemby> non sono operatori, ma già che chi siamo affrontiamole
23:43:52 < Stemby> abs()
23:43:56 < Stemby> cosa fa?
23:44:12 < ernesto> il valore assoluto del .... di x
23:44:34 < Stemby> ovvero?
23:44:40 < Stemby> (magari non è chiaro per tutti)
23:45:11 < amosse> esatto?
23:45:16 < brunology> non è chiaro
23:45:21 < Stemby> amosse: cosa?
23:45:27 < amosse> non é chiaro
23:45:27 < Stemby> non è chiaro
23:45:45 < Stemby> cos'è un numero assoluto?
23:45:49 < Stemby> in matematica
23:45:52 < spirit> per assoluto è semmpre +
23:45:59 < ernesto> il numero senza il segno
23:46:06 < Stemby> esatto
23:46:06 < ernesto> | -2 | = 2 
23:46:20 < Stemby> più che numero assoluto, valore assoluto
23:46:24 < Stemby> ok
23:46:31 < amosse> ok
23:46:32 < Stemby> quindi:
23:46:32 < spirit> va bè.
23:46:41 < Stemby> >>> abs(-2.5)
23:46:41 < Stemby> 2.5
23:46:46 < Stemby> chiaro?
23:46:49 < brunology> ok
23:46:51 < amosse> ok
23:46:52 < Stemby> semplicemente toglie il segno
23:47:08 < Stemby> ok, andiamo avanti
23:47:36 < Stemby> le successive 2 funzioni le abbiamo già viste bene
23:47:38 < Stemby> dubbi?
23:47:46 < amosse> no
23:47:50 < risca_> tutto chiaro
23:48:05 < Stemby> ok
23:48:14 < Stemby> complex() la saltiamo
23:48:27 < Stemby> anche il metodo successivo
23:48:39 < Stemby> (riguarda sempre i numeri complessi)
23:48:52 < Stemby> la funzione dopo è inutile
23:48:59 < Stemby> e anche la penultima
23:49:06 < Stemby> siamo all'ultimo operatore
23:49:08 < Stemby> **
23:49:13 < Stemby> chiaro?
23:49:30 < Stemby> >>> 2 ** 3
23:49:30 < Stemby> 8
23:49:46 < Stemby> elevamento a potenza
23:49:54 < brunology> ok
23:49:54 < Stemby> base ** esponente
23:50:01 < amosse> ok
23:50:16 < ernesto> ok
23:50:24 < spirit> ok
23:50:28 < Stemby> bene
23:50:38 < Stemby> che facciamo ora?
23:50:41 < Stemby> accetto proposte
23:50:54 < Stemby> però prima di scappare vi do i compiti
23:50:55 < ernesto> cos'è divmod?
23:51:10 < Stemby> ernesto: una funzione inutile
23:51:20 < Stemby> ah, no
23:51:28 < Stemby> guardandola bene non è così inutile
23:51:31 < Stemby> prova :=
23:51:34 < Stemby> :)
23:52:17 < ernesto> divmod(3,2)
23:52:19 < ernesto> (1,1)
23:52:24 < Stemby> chiaro?
23:52:35 < Stemby> >>> divmod(-5, 2)
23:52:35 < Stemby> (-3, 1)
23:52:42 < Stemby> ernesto: capito?
23:52:44 < ernesto> quoziente e resoto
23:52:46 < ernesto> *resto
23:52:54 < Stemby> non è proprio un quoziente
23:53:00 < Stemby> è il risultato della divisione intera
23:53:01 < Stemby> /
23:53:04 < Stemby> sorry
23:53:06 < Stemby>  //
23:53:09 < Stemby> ok?
23:53:14 < ernesto> okay
23:53:17 < amosse> ok
23:53:20 < brunology> sì
23:53:21 < spirit> si
23:53:48 < brunology> parliamo di compiti?
23:53:58 < Stemby> attenzione che è diversa rispetto alla parte intera di una divisione vera
23:53:58 < Stemby> ok
23:54:30 < Stemby> direi che per la prossima volta possiamo iniziare a leggere il libro
23:54:39 < Stemby> risca_: hai il link a portata di mano?
23:55:02 < Stemby> vi faccio presente che ormai le basi le abbiamo messe
23:55:24 < amosse> qual'é il prossimo passo
23:55:24 < Stemby> ci sono ancora tante cosucce, ma già con gli strumenti che conoscete potete fare tante cosucce
23:55:42 < Stemby> amosse: direi di seguire il testo
23:55:49 < Stemby> così non mi devo inventare niente :)
23:55:51 < risca_> Stemby: quale libro?
23:55:57 < Stemby> quello dei giochi
23:56:02 < brunology> http://inventwithpython.com/chapters/
23:56:08 < amosse> quale testo?
23:56:15 < Stemby> ottimo
23:56:18 < risca_> http://inventwithpython.com/chapters/
23:56:36 < Stemby> allora, per chi non l'avesse ancora sfogliato, è un bel libricino
23:56:45 < Stemby> dedicato al py3
23:56:51 < Stemby> (cosa notevole)
23:57:26 < Stemby> per la prossima volta sfogliate il primo capitolo
23:57:45 < Stemby> per noi debianisti in realtà è tutto molto più semplice
23:57:52 < Stemby> # aptitude install python3
23:57:54 < Stemby> :P
23:58:19 < risca_> ok
23:58:22 < Stemby> però ci sono un po' di cose interessanti
23:58:27 < risca_> solo il capitolo 1 quindi?
23:58:57 < Stemby> anche il secondo, direi
23:59:04 < Stemby> di cose nuove ce ne sono poche
23:59:09 < Stemby> però è un bel ripassone
23:59:18 < risca_> ok 1 e 2
23:59:40 < ernesto> partiam dal paragrafo How to Use This Book
23:59:42 < ernesto> del cap. 1?
23:59:49 < Stemby> ernesto: leggi tutto
23:59:52 < Stemby> male non fa
00:00:07 < Stemby> tieni presente che alcune cose non sono debian-centriche
00:00:17 < Stemby> e quindi sono un po' da adattare alla nostra realtà
00:00:46 < Stemby> mi spiace per chi ha difficoltà con l'inglese
00:00:49 < Stemby> ma:
00:01:03 < ernesto> si impara ;)
00:01:05 < Stemby> 1) è inglese tecnico, molto leggibile
00:01:10 < ernesto> esistono vocabolari
00:01:20 < Stemby> 2) con quanto fatto finora, si intuisce tutto benissimo
00:01:23 < risca_> wordreference.com
00:01:39 < Stemby> 3) prendetelo come un esercizio linguistico, oltre che informatico :)
00:02:06 < Stemby> risca_: vuoi aggiungere qualcosa?
00:02:34 < amosse> per quanto riguarda la documentazione ufficiale cosa consigliate di leggere, se uno velesse fare un po' di teoria?
00:03:14 < risca_> no no
00:03:18 < risca_> direi che va bene così
00:03:22 < Stemby> amosse: niente
00:03:33 < Stemby> le cose importanti le vediamo insieme man mano
00:03:39 < amosse> ok
00:03:45 < Stemby> ovviamente: approfittate per provare quanto fatto finora
00:04:01 < amosse> ok
00:04:04 < risca_> ottimo
00:04:13 < Stemby> allora buona notte
00:04:20 < ernesto> buonanotte
00:04:21 < ernesto> a mercoledì
00:04:36 < amosse> buonanotte atutti e grazie anche per stasera
00:04:38 < risca_> a mercoledì
00:04:43 < risca_> buona notte a tutti
00:04:47 -!- ernesto [~ernesto@Azzurra=5C301E82.45-79-r.retail.telecomitalia.it] has quit [Quit: Ex-Chat]
00:04:48 < spirit> grazie, 'notte
00:05:10 -!- spirit [~spirit@Azzurra-C3C291C.104-82-b.business.telecomitalia.it] has quit [Quit: leaving]
00:05:23 < brunology> grazie a tutti, a mercoledì (il primo che non bigerò...spero)