Accademia:Log 2011 02 23

21:28:06 < JumX> Buonasera  a tutti
21:29:12 < Ernestus> sera JumX 
21:29:58 < JumX> ciao Ernestus come va ?
21:30:31 < Ernestus> io bene, tu?
21:31:10 < JumX> tutto ok  grazie .... Domenica com'è andata ? 
21:31:19 < Ernestus> è andata bene!
21:31:25 < Ernestus> abbiamo visto qualcosina di nuovo
21:31:35 < JumX> ho visto il log 
21:31:45 < Ernestus> hai dato un'occhiata alle letture per oggi?
21:32:52 < JumX> purtroppo ho avuto poco tempo , ti riferisci al libro  Invent...ecc.ecc. .
21:33:11 < JumX> i primi due capitoli era già familiari
21:34:00 < Ernestus> http://guide.debianizzati.org/index.php/Accademia:Letture_consigliate_Lezione_7_%26_8?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed:+DebianizzatiGuide+(Debianizzat.Org+-+Guide)
21:34:58 < JumX> ho letto solo i Primi due capitoli del libro che abbiamo adottato (inventwithpython) 
21:35:50 -!- brunology [~brunology@Azzurra=64C72B29.9-79-r.retail.telecomitalia.it] has joined #debianizzati-corsi
21:36:22 < JumX> ... sto vedendo ...
21:36:44 < |Wolf|> non l'ho mai sentito quel libro
21:36:47 < |Wolf|> di chi è?
21:37:33 < Ernestus> |Wolf|, http://inventwithpython.com/about.html
21:37:44 < |Wolf|> thanks
21:38:19 -!- spirit [~spirit@Azzurra-C3C291C.104-82-b.business.telecomitalia.it] has joined #debianizzati-corsi
21:39:56 < JumX> quindi stasera algoritmi e diagrammi di flusso.
21:41:25 < |Wolf|> non sembra male il libro
21:42:39 < JumX> l'hai già letto ? :s
21:43:00 < |Wolf|> ho dato un'occhiata veloce e non ho visto cose troppo brutte
21:43:43 < JumX> wolf tu già lo conosci Python ?
21:44:20 < |Wolf|> sì
21:45:03 < JumX> Che tu sappia per un gestionale come lo vedi?
21:45:22 < |Wolf|> non saresti il primo a fare gestionali in python
21:45:36 < |Wolf|> c'era uno su #python un po' di tempo fa che ne aveva fatto uno
21:46:48 < JumX> Ma tu cosa pensi ? Quela database usare?
21:47:24 < |Wolf|> con python in genere postgres per cose grosse, sqlite per cose piccole
21:48:24 < JumX> E se poi le cose "piccole" diventano "grosse" diventerebbe traumatica la migrazione
21:49:38 < JumX> sono andato su #python credo stanno discutendo proprio su questo.
21:50:33 < |Wolf|> già
21:50:40 < |Wolf|> sei capitato a proposito
21:51:42 < JumX> ... fortuna che mi hai dato il link :)
21:53:33 < JumX> Solo che sono mooooolto avanti rispetto a me .:s
21:53:53 < JumX> Io ho cominciato con questo corso.
21:54:36 < |Wolf|> conosci altri linguaggi?
21:56:06 < JumX> mi vergogno a dirlo... vba .... quello di msaccess per intenderci lo uso a lavoro ci ho creato un gestionale completo .
21:57:29 < |Wolf|> quindi lo conosci bene?
21:58:51 < JumX> Diciamo che se ho un problema ne esco fuori :)
21:59:29 < |Wolf|> in vba gli indici partivano da 1?
21:59:30 < JumX> abbastanza velocemente
21:59:41 < JumX> io non uso indici
21:59:58 < JumX> automatici
22:01:10 < JumX> mi sono creato una stringa formato anno/npostazione/numeroprogressivo per gestirlo anche in replica
22:01:23 < JumX> e sincronizzare un set di db
22:02:26 -!- nodo [~andrea@Azzurra-3E987B79.0-87-r.retail.telecomitalia.it] has quit [Quit: Sto andando via]
22:10:35 -!- weirdo [~H2O2@Azzurra-26C3D234.clienti.tiscali.it] has joined #debianizzati-corsi
22:10:38 < brunology> ci siete? cosa facciamo oggi?
22:10:49 < weirdo> ah esistete
22:11:00 < JumX> Pronti
22:11:36 < Ernestus> Problemi, Algoritmi, Diagrammi di flusso
22:13:19 < JumX> Sicuramente c'è qualche tifoso dell'inter. :) dovremo aspettare il termine della partita
22:13:36 < weirdo> checculo
22:15:00 -!- Jinko [Jinko@helper.azzurra.org] has joined #debianizzati-corsi
22:15:03 -!- mode/#debianizzati-corsi [+o Jinko] by ChanServ
22:16:28 < Ernestus> vabbè... allora usiamo questi minuti per chiarire le cose della scorsa lezione
22:16:44 -!- Jinko changed the topic of #debianizzati-corsi to: Canale dedicato ai corsi organizzati dalla comunità italiana utenti debian di Debianizzati.org | info: www.debianizzati.org , #debianizzati | Accademia Python3: http://frm.li/6WeXTX
22:23:38 -!- Stemby_ is now known as Stemby
22:23:41 < Stemby> eccomi
22:23:48 < Stemby> scusate il ritardo
22:24:03 < Stemby> datemi 5 min per vedere cosa state combinando
22:24:14 < brunology> niente :)
22:24:42 < Ernestus> per ora niente
22:27:15 < Stemby> letto tutto
22:27:20 < Stemby> avete fatto troppo
22:27:21 < Stemby> :)
22:27:29 < Stemby> allora, vogliamo iniziare?
22:27:35 < brunology> pronti
22:27:49 < Ernestus> via
22:27:52 < Stemby> fatemi aprire il browser
22:27:56 < Stemby> ok
22:28:14 < Stemby> allora, chi mi passa il link alla documentazione ufficiale di py3?
22:28:25 < Stemby> (non sempre i soliti, magari)
22:29:29 < Stemby> faccio io, se no arriviamo alla finale di champions
22:29:32 < spirit> http://docs.python.org/py3k/whatsnew/3.0.html
22:29:36 < Stemby> http://docs.python.org/release/3.1.3/
22:29:43 < spirit> ops
22:29:58 < Stemby> ok?
22:30:34 < Stemby> nelle ultime 3 lezioni in particolare abbiamo iniziato ad analizzare a fondo la documentazione sulla libreria standard
22:30:44 -!- Ernestus [~ernesto@Azzurra=30BF8CCD.44-79-r.retail.telecomitalia.it] has quit [Quit: Ex-Chat]
22:30:54 < Stemby> quindi cliccate su Library Reference
22:31:02 < Stemby> ci siete?
22:31:13 < JumX> Si ciao Stemby
22:31:17 < brunology> sì
22:31:43 < Stemby> andiamo al capitolo 5
22:31:46 < Stemby> (come al solito)
22:31:49 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html
22:32:04 < Stemby> proviamo a riprendere da capo
22:32:43 < Stemby> l'introduzione è chiara per tutti?
22:33:17 < Stemby> che tipi abbiamo visto, finora?
22:33:45 < JumX> int, float, boolean
22:33:57 < brunology> string
22:33:58 < Stemby> bene quelli, giosto
22:34:02 < Stemby> intravisti?
22:34:13 < Stemby> *giusto
22:34:28 < Stemby> che altri tipi abbiamo intravisto?
22:34:34 < Stemby> uno almeno...
22:35:05 < spirit> ==
22:35:15 < Stemby> spirit: ???
22:35:28 < Stemby> tipi, oggetti predefiniti
22:35:30 < Stemby> non operatori
22:35:45 < Stemby> interi, float, booleani, e poi?
22:35:52 < JumX> string
22:36:03 < Stemby> bravo JumX
22:36:09 < JumX> complex se non sbaglio li abbiamo saltati
22:36:15 < brunology> l'avevo detto io! :P
22:36:18 < Stemby> JumX: esatto: solo citati
22:36:24 < Stemby> brunology: sorry
22:36:27 < Stemby> non avevo visto
22:36:28 < Stemby> :)
22:36:41 < Stemby> ottimo
22:36:50 < Stemby> oggi approfondiremo un po' le stringhe
22:37:11 < Stemby> guardiamo il paragrafo introduttivo
22:37:14 < Stemby> The principal built-in types are numerics, sequences, mappings, classes, instances and exceptions.
22:37:43 < Stemby> quelli elencati sono dei "raggruppamenti" di oggetti
22:37:57 < Stemby> numerics: interi, float e complessi
22:38:14 < Stemby> le stringhe rientrano tra... secondo voi?
22:38:29 < brunology> sequence
22:38:29 < JumX> apici
22:38:35 < Stemby> brunology: esatto
22:38:49 < Stemby> sono sequenze di caratteri
22:39:19 < Stemby> le cose che vedremo stasera si applicano in gran parte anche ad altri tipi
22:39:56 < Stemby> classi, istanze ed eccezioni fan parte della programmazione orientata agli oggetti, che vedremo tra un po'
22:40:14 < Stemby> mapping... sinceramente non saprei
22:40:21 < Stemby> |Wolf|: sai aiutarmi?
22:40:47 < Stemby> intanto passiamo al paragrafo 5.1
22:41:05 < Stemby> nzi, saltiamolo
22:41:08 < Stemby> *anzi
22:41:10 < Stemby> 5.2
22:41:14 < Stemby> vi ricordate?
22:41:27 < Stemby> operatori booleani
22:41:36 < JumX> True False
22:41:40 < Stemby> sono i primi che abbiamo visto sistematicamente
22:41:48 < Stemby> chi ha dubbi, li tiri fuori ora
22:42:22 < Stemby> JumX: gli operatori booleani sono or, and e not
22:43:12 < Stemby> se è tutto chiaro, vorrei che vi soffermaste sul sistema che usa l'interprete per calcolare le espressioni che fanno uso di questi operatori
22:43:27 < Stemby> l'algoritmo è spiegato nella tabella
22:43:43 < Stemby> guardiamo il primo
22:43:54 < Stemby> x or y	if x is false, then y, else x
22:44:01 < Stemby> chiaro?
22:44:36 < JumX> ok
22:44:50 < Stemby> finora abbiamo usato solo dei booleani
22:44:56 < Stemby> (True/False)
22:45:10 < Stemby> proviamo a vedere se or funziona anche con altri tipi
22:45:44 -!- Ernestus [~ernesto@Azzurra=534E8D49.37-79-r.retail.telecomitalia.it] has joined #debianizzati-corsi
22:45:48 < Ernestus> piantato
22:45:58 < Ernestus> scusate, il modem mi aveva piantato
22:46:05 < Stemby> il paragrafo 5.1 vi dice quando altri tipi vengono interpretati come veri, e quando come falsi
22:46:10 < Stemby> Ernestus: mi spiace...
22:46:20 < Stemby> siamo al paragrafo 5.2
22:46:32 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#boolean-operations-and-or-not
22:46:42 < Stemby> (un ripasso)
22:46:50 < Ernestus> eccomi
22:46:57 < Ernestus> sono sulla doc
22:47:18 < Stemby> ripeto l'invito: aprite l'interfaccia interattiva, e provate a verificare il funzionamento di or usando vari tipi
22:47:30 < Stemby> è chiaro quello che ho scritto?
22:47:39 < Stemby> faccio io la prima espressione
22:47:57 < Stemby> >>> False or True
22:47:57 < Stemby> True
22:48:23 < Stemby> vediamo perché ci dà True (che è la cosa che ci aspettiamo, in effetti)
22:48:33 < Stemby> x or y        if x is false, then y, else x
22:48:47 < Stemby> in questo caso x è False, y è True
22:49:17 < Stemby> quindi, visto che x è False, l'interprete restituisce x
22:49:32 < Stemby> mmm strano
22:49:42 < Stemby> sorry
22:49:47 < Stemby> restituisce y
22:49:48 < JumX> sempre True
22:49:50 < Stemby> giustamente
22:49:54 < Stemby> che è True
22:50:21 < Stemby> ripeto perché ho fatto confusione
22:50:39 < Stemby> l'algoritmo dice: se x è falso, allore dai y
22:50:50 < Stemby> questa è la situazione
22:51:10 < Stemby> x è False, quindi restituisce y (che è True)
22:51:12 < Stemby> ok?
22:51:32 < Stemby> fatemi ora voi un'espressione
22:51:39 < Stemby> con l'operatore or
22:51:39 < JumX> Nel terminale: True or False da True  ma anche Fasle or True restituisce sempre True ..non mi trovo?
22:51:51 < Stemby> ok vediamola
22:52:03 < Stemby> >>> False or True
22:52:03 < Stemby> True
22:52:09 < Stemby> è ciò che ci aspettiamo, no?
22:52:13 < Stemby> vediamo perché
22:52:21 < Stemby> qual è la x, e quale la y?
22:52:30 < JumX> False x  True y
22:52:37 < Stemby> esatto
22:52:44 < Stemby> x → False
22:52:52 < Stemby> y → True
22:53:00 < Stemby> siete tutti d'accordo?
22:53:13 < JumX> si 
22:53:19 < Stemby> cosa prevede l'algoritmo?
22:53:31 < Stemby>  if x is false, then y, else x
22:53:43 < Stemby> prima domanda: x è vero o falso?
22:54:01 < JumX> False
22:54:05 < Stemby> False
22:54:14 < Stemby> quindi cosa deve restituire?
22:54:23 < JumX> True
22:54:28 < Stemby> e così è
22:54:52 < Stemby> questo è il caso che abbiamo visto prima
22:54:59 < Stemby> il tuo invece è questo:
22:54:59 -!- Ernestus [~ernesto@Azzurra=534E8D49.37-79-r.retail.telecomitalia.it] has quit [Quit: Ex-Chat]
22:55:13 < Stemby> >>> True or False
22:55:13 < Stemby> True
22:55:19 < Stemby> x → True
22:55:23 < Stemby> y → False
22:55:26 < Stemby> giusto?
22:55:36 < JumX> si
22:55:45 < Stemby>  if x is false, then y, else x
22:55:50 < Stemby> x è vero o falso?
22:55:58 -!- Ernestus [~ernesto@Azzurra=534E8D49.37-79-r.retail.telecomitalia.it] has joined #debianizzati-corsi
22:56:01 < JumX> True
22:56:07 < Stemby> quindi deve restituire?
22:56:12 < Stemby> x o y?
22:56:27 < JumX> x
22:56:30 < Stemby> che vale?
22:56:35 < JumX> True
22:56:41 < Stemby> visto che è giusto?
22:57:11 < Stemby> JumX: capito?
22:57:53 < JumX> si se x è falso dai vere altrimenti dai falso
22:58:05 < Stemby> questo è or
22:58:08 < JumX> giusto?
22:58:19 < Stemby> no
22:58:21 < Stemby> non è così
22:58:48 < Stemby> se il primo valore è falso allora dai il secondo (indipendentemente se è vero o falso), altrimenti dai il primo
22:59:08 < Stemby> >>> False or False
22:59:08 < Stemby> False
22:59:27 < Stemby> il primo è falso, quindi restituisce il secondo, che è falso
22:59:28 < JumX> ok
22:59:58 < Stemby> è chiaro per tutti?
23:00:10 < brunology> sì
23:00:11 < Stemby> verifichiamolo con dei tipi diversi dai booleani
23:00:25 < Stemby> 5 è vero o falso?
23:00:46 < brunology> falso
23:00:51 < Stemby> no, è vero
23:00:54 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#truth-value-testing
23:01:03 < Stemby> tutti i numeri diversi da 0 sono veri
23:01:11 < Stemby> proviamolo anche così:
23:01:14 < Stemby> bool(5)
23:01:30 < Stemby> visto?
23:01:33 < JumX> True
23:01:35 < brunology> allora perché dice:
23:01:45 < brunology> The following values are considered false:
23:01:52 < brunology> zero of any numeric type, for example, 0, 0.0, 0j.
23:01:57 < Stemby> appunto
23:02:02 < Stemby> quelli sono falsi
23:02:04 < Stemby> 0 intero
23:02:14 < Stemby> 0.0 float
23:02:16 < Stemby> ma sempre zero
23:02:25 < Stemby> oj è lo zero complesso
23:02:33 < Stemby> ma sempre zero è
23:02:36 < brunology> scusa ho letto 'or' al posto di 'of'
23:02:45 < Stemby> ah :)
23:02:49 < Stemby> leggere bene!
23:02:51 < brunology> ho il booleano in testa :)
23:02:55 < Stemby> 5.245 è vero
23:03:01 < Stemby> -12 è vero
23:03:03 < Stemby> eccetera
23:03:10 < Stemby> tutti i numeri diversi da zero
23:03:11 < |Wolf|> Stemby, eccomi
23:03:44 < |Wolf|> se i mapping fanno parte dell'OOP?
23:03:55 < Stemby> no: cosa sono?
23:04:14 < |Wolf|> i dict sono mapping
23:04:20 < Stemby> ah, ok
23:04:24 < |Wolf|> in genere qualsiasi cosa che associa coppie di valori
23:04:25 < Stemby> altri esempi?
23:04:39 < Stemby> di predefiniti quindi solo dizionari
23:04:39 < |Wolf|> in altri linguaggi sono chiamati anche array associativi
23:04:50 < |Wolf|> sì, dict e derivati
23:04:56 < Stemby> ok, grazie
23:05:04 < Stemby> allora, torniamo alle nostre prove
23:05:27 < Stemby> if x is false, then y, else x
23:05:40 < Stemby> 0 or 234
23:05:43 < Stemby> cosa darà?
23:05:56 < JumX> 234
23:05:58 < brunology> True
23:06:02 < Stemby> chiaro perché?
23:06:05 < Stemby> brunology: no
23:06:07 < Stemby> prova
23:06:10 < |Wolf|> rileggo un po' il log e vedo di seguire adesso
23:06:18 < Stemby> ok :)
23:06:34 < Stemby> chiaro perché dà 234?
23:06:39 < Stemby> if x is false, then y, else x
23:06:47 < Stemby> x è falso
23:06:49 < Stemby> giusto?
23:06:54 < Stemby> perché 0 è falso
23:06:59 < JumX> 0 è False quindi dai True che corrisponde a 234
23:07:06 < Stemby> no
23:07:09 < Stemby> non dai True
23:07:09 < JumX> *da
23:07:12 < Stemby> dai il secondo
23:07:19 < Stemby> qualsiasi sia il suo valore
23:07:22 < |Wolf|> quello che ha detto brunology non è del tutto sbagliato
23:07:23 < Stemby> 0 or 0
23:07:34 < Stemby> dà 0
23:07:36 < Stemby> non False
23:07:37 < |Wolf|> concettualmente 0 or 234 dà true
23:07:41 < brunology> ok, perché 234 è un intero, non un bool
23:07:45 < JumX> il secondo a prescindere
23:07:58 < Stemby> brunology: il secondo, anche se è falso
23:08:01 < Stemby> 0 or 0
23:08:05 < |Wolf|> il fatto che dia 234 è solo perché gli operatori booleani in python ritornano sempre uno dei 2 valori
23:08:06 < Stemby> restituisce il secondo 0
23:08:09 < Stemby> anche se è falso
23:08:19 < Stemby> |Wolf|: non è così
23:08:26 < Stemby> l'algoritmo è questo:
23:08:31 < Stemby> if x is false, then y, else x
23:08:52 < Stemby> quindi nell'espressione usa True e False
23:09:01 < |Wolf|> uhm?
23:09:03 < Stemby> (o False, gli altri numeri True=
23:09:07 < Stemby> )
23:09:17 < Stemby> ma poi il valore restituito non è un booleano
23:09:23 < Stemby> ma il primo o il secondo valore
23:09:29 < Stemby> qualsiasi tipo sia
23:09:32 < |Wolf|> se hai x or y python semplicemente guarda a x, se è un valore true allora restituisce x perché indipendentemente dal valore di x il risultato sarà true
23:09:37 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#boolean-operations-and-or-not
23:09:51 < |Wolf|> se invece x è false deve vedere y
23:09:58 < Stemby> esatto
23:10:13 < Stemby> anzi no
23:10:16 < Stemby> non p così
23:10:26 < Stemby> se x è false restituisce automaticamente y
23:10:29 < |Wolf|> e allo stesso modo, se y è true ritorna y, se y è falso lo ritorna lo stesso
23:10:32 < Stemby> qualsiasi sia il valore di y
23:10:48 < Stemby> ovvero:
23:10:55 < Stemby> 0.0 or "pippo"
23:10:57 < |Wolf|> (questo si chiama short-circuiting)
23:11:02 < Stemby> restituisce 'pippo'
23:11:10 < Stemby> perché x è falso
23:11:21 < |Wolf|> (il fatto di fermarsi al primo se basta per determinare il risultato)
23:11:27 < Stemby> allo stesso modo
23:11:30 < Stemby> 0.0 or ''
23:11:41 < Stemby> restituisce ''
23:11:54 < Stemby> chiaro per tutti?
23:12:01 < spirit> si
23:12:02 < |Wolf|> questo perché in entrambi i casi il primo è falso, quindi per determinare il risultato dell'operazione deve vedere il secondo
23:12:10 < Stemby> |Wolf|: no
23:12:11 < JumX> ok
23:12:17 < |Wolf|> Stemby, perché no?
23:12:18 < Stemby> il secondo non lo guarda proprio
23:12:22 < Stemby> lo restituisce direttamente
23:12:25 < Stemby> qualsiasi cosa sia
23:12:37 < Stemby> valuta solo il primo
23:12:45 < Stemby> sempre e solo il primo
23:12:49 < Stemby> il primo è falso?
23:12:55 < |Wolf|> no, il secondo è valutato, e poi restituito indipendentemente dal suo valore
23:12:57 < Stemby> allora restituisce il secondo
23:13:04 < Stemby> |Wolf|: no
23:13:08 < |Wolf|> Stemby, prova
23:13:10 < Stemby> perché lo deve valutare?
23:13:18 < Stemby> |Wolf|: ho provato
23:13:31 < |Wolf|> def foo(): print 'foo'; return False
23:13:38 < |Wolf|> 0 or foo()
23:13:45 < |Wolf|> e poi prova 1 or foo()
23:14:29 < Stemby> print('foo')
23:14:34 < Stemby> py3...
23:14:38 < Stemby> adesso provo
23:14:38 < |Wolf|> sì
23:15:04 < Ernestus> scusatemi, ma vado adesso. mi leggerò i log
23:15:07 < Ernestus> buonanotte a tutti
23:15:23 < |Wolf|> cioè, quello che dici non è del tutto sbagliato, perché alla fine il valore del secondo è restituito così com'è, il fatto è che prima di restituirlo deve ridurlo ai minimi termini
23:15:25 < JumX> Ciao Ernestus
23:15:25 < Stemby> |Wolf|: appunto, è quello che ho detto
23:15:30 -!- Ernestus [~ernesto@Azzurra=534E8D49.37-79-r.retail.telecomitalia.it] has quit [Quit: Ex-Chat]
23:15:36 < Stemby> ok
23:16:04 < |Wolf|> quindi se ad esempio è una funzione o un'espressione la evaluta per ottenere un risultato che poi viene restituito
23:16:14 < Stemby> ok
23:16:18 < Stemby> questo è chiaro
23:16:23 < |Wolf|> :)
23:16:30 < Stemby> chiaro per tutti?
23:16:41 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#truth-value-testing
23:16:58 < Stemby> guardiamoci nei vari tipi quando questi sono considerati veri, e quando falsi
23:17:13 < Stemby> None è un tipo particolare...
23:17:27 < Stemby> significa "nessun valore", "assenza di valore"
23:17:42 < Stemby> >>> type(None)
23:17:42 < Stemby> <class 'NoneType'>
23:17:58 < Stemby> è proprio un tipo a sé stante
23:18:18 < Stemby> ci ricordiamo che valori booleani sono solo 2?
23:18:23 < Stemby> True/False
23:18:33 < Stemby> None è invece addirittura unico
23:18:39 < Stemby> c'è solo lui
23:18:48 < Stemby> ed è considerato falso
23:19:00 < Stemby> secondo punto: tipo booleano
23:19:00 < brunology> che vita grama
23:19:04 < brunology> :)
23:19:20 < Stemby> quale è falso?
23:19:26 < Stemby> (nei booleani)
23:19:41 < brunology> False
23:19:44 < Stemby> ovviamente
23:19:55 < Stemby> terzo punto: tipi numerici
23:19:56 -!- Jinko [Jinko@helper.azzurra.org] has quit [Quit: J]
23:20:06 < Stemby> noi abbiamo visto bene 2 tipi numerici
23:20:13 < Stemby> qual è l'intero falso?
23:20:19 < JumX> 0
23:20:21 < Stemby> ok
23:20:26 < Stemby> tutti gli altri sono veri
23:20:37 < Stemby> un esempio un po' interessante?
23:20:42 < Stemby> (di intero vero)
23:21:11 < Stemby> spirit: vai
23:21:20 < Stemby> fammelo tu un esempio di intero vero
23:21:29 < |Wolf|> (Stemby, cmq c'è un imprecisione anche nella doc che hai linkato)
23:21:36 < spirit> sto pensando
23:21:49 < Stemby> spirit: non è difficile
23:21:52 < Stemby> 0 è falso
23:22:00 < spirit> int(o)
23:22:03 < Stemby> dimmi un qualsiasi altro intero
23:22:05 < Stemby> no
23:22:12 < Stemby> un intero!
23:22:20 < Stemby> quali sono i numeri interi?
23:22:27 < Stemby> sono quelli delle elementari
23:22:29 < spirit> 1 2 3
23:22:30 < JumX> 123....   -123...
23:22:33 < Stemby> esatto!
23:22:41 < Stemby> ma anche i negativi, effettivamente
23:22:48 < Stemby> quindi -123 è vero
23:22:55 < Stemby> come facciamo a verificarlo?
23:23:07 < brunology> bool(-123)
23:23:16 < Stemby> esatto
23:23:17 < JumX> type()
23:23:20 < Stemby> chiaro spirit?
23:23:25 < Stemby> JumX: no
23:23:34 < spirit> si
23:23:38 < Stemby> non dobbiamo verificare il tipo
23:23:43 < JumX> si scusa 
23:23:46 < Stemby> lo sappiamo già che è un intero
23:24:13 < Stemby> che cos'è bool()
23:24:14 < Stemby> ?
23:24:21 < Stemby> così ripassiamo...
23:24:31 < spirit> operatore
23:24:34 < Stemby> noooo
23:24:52 < brunology> una funzione?
23:24:55 < Stemby> le parentesi... cosa ci fanno pensare?
23:24:59 < Stemby> brunology: esatto
23:25:02 < Stemby> è una funzione
23:25:04 < JumX> serve per verificare se è true o false
23:25:21 < Stemby> diciamo che "trasforma" un oggetto in booleano
23:25:40 < Stemby> e quindi può assumere valore True o Falso
23:25:48 < |Wolf|> restituisce True se l'oggetto è vero o False se l'oggetto è falso
23:25:48 < JumX> ok
23:26:02 < JumX> bool(0)  è False
23:26:07 < Stemby> esatto
23:26:11 < JumX> bool(1234)  è True
23:26:14 < Stemby> bool(0.0) pure
23:26:23 < Stemby> è falso
23:26:28 < Stemby> ok
23:26:33 < Stemby> proseguiamo
23:26:41 < JumX> ok
23:26:46 < Stemby> terzo punto
23:26:49 < Stemby> any empty sequence, for example, '', (), [].
23:27:01 < Stemby> ogni sequenza vuota è falsa
23:27:15 < Stemby> noi per ora abbiamo intravisto decentemente solo un tipo di sequenza
23:27:22 < Stemby> quale, spirit?
23:27:30 < Stemby> (già detto all'inizio della serata)
23:27:57 < spirit> ad oggetti
23:28:00 < Stemby> ?
23:28:08 < Stemby> chi risponde?
23:28:11 < spirit> espressioni
23:28:15 < Stemby> nooo
23:28:21 < Stemby> non spariamo nomi a caso
23:28:31 < spirit> stringhe
23:28:35 < Stemby> esatto
23:28:37 < Stemby> :)
23:28:42 < Stemby> le stringhe
23:28:53 < Stemby> quindi, una stringa vuota è falsa
23:29:04 < Stemby> ci sono 2 modi per scrivere una stringa vuota
23:29:07 < Stemby> come?
23:29:26 < spirit> cosi ""
23:29:31 < Stemby> oppure?
23:29:35 < spirit> ''
23:29:38 < Stemby> ottimo
23:29:49 < Stemby> verifichiamo che la stringa vuota è falsa
23:29:50 < Stemby> come?
23:29:51 < |Wolf|> (anche str())
23:30:02 < brunology> la risposta è sempre ''
23:30:17 < Stemby> brunology: verifichiamo che '' è falso
23:30:26 < Stemby> con la funzione che abbiamo visto prima
23:30:35 < Stemby> che trasforma un oggetto in booleano
23:30:38 < brunology> bool('')
23:30:40 < brunology> False
23:30:42 < Stemby> ok
23:30:55 < Stemby> l'altra espressione?
23:31:29 < brunology> espressione?
23:31:30 < Stemby> >>> bool("")
23:31:30 < Stemby> False
23:31:38 < brunology> ok
23:31:43 < brunology> >>> bool(str())
23:31:45 < brunology> False
23:31:50 < Stemby> ci siamo?
23:32:04 < Stemby> ora verifichiamo che una stringa non vuota è vera
23:32:30 < spirit> bool(str(23)) 
23:32:40 < spirit> no è vera
23:32:46 < Stemby> infatti
23:32:51 < JumX> serve per verificare se è true o false
23:32:54 < Stemby> "23" è vero
23:32:56 < JumX> ops
23:33:12 < Stemby> altro esempio senza usare str()?
23:33:23 < JumX> bool("a")    True
23:33:30 < Stemby> esatto
23:33:45 < Stemby> >>> bool('pippo')
23:33:45 < Stemby> True
23:34:00 < Stemby> visto che |Wolf| l'ha tirata in ballo...
23:34:10 < Stemby> che cos'è str(), spirit?
23:34:26 < Stemby> è una... ?
23:34:38 < spirit> funzione
23:34:38 < Stemby> f... ?
23:34:40 < Stemby> ok
23:34:49 < Stemby> e che cosa fa, quella funzione?
23:35:11 < spirit> istruisce un inizio
23:35:15 < Stemby> ???
23:35:23 < JumX> specifica che si tratta di una stringa
23:35:24 < Stemby> trasforma un oggetto in... ?
23:35:30 < spirit> stringa
23:35:34 < Stemby> esatto
23:35:43 < Stemby> trasforma un oggetto in stringa
23:35:54 < Stemby> come bool() trasforma un oggetto in booleano
23:36:04 < JumX> ok
23:36:10 < Stemby> o come int() trasforma un oggetto (quando possibile) in intero
23:36:13 < Stemby> ecc.
23:36:22 < spirit> ok
23:36:35 < Stemby> str() senza parametri cosa farà?
23:36:51 < spirit> ''
23:37:02 < Stemby> restituisce una stringa vuota
23:37:05 < spirit> si
23:37:09 < Stemby> invece è interessante questo:
23:37:17 < |Wolf|> e int() senza arg?
23:37:20 < Stemby> >>> str(None)
23:37:20 < Stemby> 'None'
23:37:39 < Stemby> (uno potrebbe aspettarsi che restituisce '')
23:37:44 < JumX> erore
23:37:49 < JumX> *erroer
23:38:05 < Stemby> no, int() restituisce 0
23:38:10 < Stemby> non dà errore
23:38:25 < JumX> anche None va sempre scritto con la N maiuscola :)
23:38:34 < Stemby> certo
23:38:36 < JumX> ok da None
23:38:54 < Stemby> dà 'None'
23:38:57 < JumX> ok da 'None' 
23:39:10 < Stemby> che non è così intuitivo
23:39:14 < Stemby> ma tant'è
23:39:44 < |Wolf|> per la cronaca, con True/False con la maiuscola si intendono i 2 oggetti booleani, con true/false con la minuscola in genere si intende qualsiasi valore che è considerato vero o falso
23:39:48 < JumX> None funziona sia con le stringhe che con i numeri?
23:40:02 < Stemby> JumX: inche senzo?
23:40:11 < Stemby> *in che
23:40:16 < Stemby> *senso
23:40:20 < |Wolf|> quindi si può dire che 0 è false e 15 è true, ma 15 non è True
23:40:39 < Stemby> ok, grazie |Wolf| per la precisazione
23:40:49 < Stemby> oppure, semplicemente lo si può dire in italiano
23:40:56 < Stemby> vero/falso :)
23:40:58 < |Wolf|> yep
23:41:07 < |Wolf|> nella doc di python però capita questa distinzione
23:41:32 < Stemby> JumX: cosa intendevi con la tua domanda?
23:41:35 < Stemby> non l'ho capita
23:41:54 < JumX> Nel senso che potrei anche avere un campo numerico vuoto
23:42:13 < Stemby> sì, allora puoi usare l'oggetto None
23:42:19 < Stemby> che è diverso da 0
23:42:22 < Stemby> o da ''
23:42:31 < Stemby> vuol proprio dire "vuoto"
23:42:41 < Stemby> 0 invece è un numero preciso
23:42:49 < JumX> e ma non funziona lo 0 è comunque un numero
23:42:56 < Stemby> ?
23:43:05 < Stemby> 0 è un numero
23:43:05 < |Wolf|> cosa non funziona?
23:43:10 < Stemby> Non non è un numero
23:43:16 < Stemby> è un tipo a sé stante
23:43:20 < Stemby> *None
23:43:40 < JumX> che funziona solo con le stringhe
23:43:50 < Stemby> no
23:44:02 < Stemby> in che senso "funziona con le stringhe"?
23:44:24 < JumX> Se scrivo str(None) 
23:44:35 < JumX> da 'None'
23:44:37 < JumX> giusto?
23:44:45 < Stemby> sì
23:44:54 < JumX> se invece scrivo int(None)
23:44:59 < Stemby> dà errore
23:45:00 < Stemby> vero
23:45:13 < Stemby> ma quella è una caratteristica della funzione int
23:45:27 < Stemby> che non accetta oggetti di tipo None
23:45:40 < spirit> type(None)
23:45:41 < |Wolf|> str in genere funziona sempre con qualsiasi oggetto
23:45:45 < Stemby> così ha sceto Guido... se non sei d'accordo, protesta con lui
23:45:45 < JumX> ah ecco!
23:45:57 < spirit> class Nonetype
23:46:07 < |Wolf|> tutti gli oggetti possono essere rappresentati come stringhe, ma non tutti come un semplice numero
23:46:11 < Stemby> JumX: se per quello dà errore anche
23:46:16 < Stemby> int("pippo")
23:46:31 < JumX> ok chiaro
23:46:37 < Stemby> sono pochi gli oggetti che puoi trasformare in interi
23:46:45 < Stemby> int("5")
23:46:54 < Stemby> int(3.0)
23:47:11 < Stemby> anche int(3.7)
23:47:29 < Stemby> che si comporta in modo diverso da quando magari ci si aspetta
23:47:39 < Stemby> semplicemente tronca la parte decimale
23:47:45 < Stemby> non fa un arrotondamento
23:47:58 < Stemby> ci sono altre funzioni per quello
23:48:09 < JumX> float
23:48:09 < Stemby> ok, finita la divagazione, proseguiamo
23:48:16 < Stemby> float()?
23:48:20 < Stemby> è analogo
23:48:28 < Stemby> trasforma un oggetto in float
23:48:46 < Stemby> ma anche lì, non tutti gli oggetti possono essere trasformati in float
23:49:05 < Stemby> float('pippo') dà errore
23:49:12 < Stemby> analogamente a int()
23:49:17 < Stemby> proseguiamo
23:49:22 < Stemby> torniamo al 5.2
23:49:29 < JumX> intendevo che float non arrotonda e fa vedere anche i decimali
23:50:04 < Stemby> guardiamo il secondo operatore, and, sotto l'ottica di stasera
23:50:13 < Stemby> (dell'algoritmo che ci sta dietro)
23:50:26 < Stemby> ((e non dell'algebr booleana, come avevamo fatto l'altra volta)
23:50:27 < Stemby> )
23:50:31 < Stemby> x and y	if x is false, then x, else y
23:50:46 < Stemby> è il contrario di or
23:50:47 < |Wolf|> (non è meglio farlo con l'algebra booleana e la tabella di verità?)
23:50:56 < Stemby> |Wolf|: già fatto
23:51:08 < Stemby> alcune lezioni fa... :)
23:51:15 < |Wolf|> se lo ricordano?
23:51:20 < Stemby> spero
23:51:35 < Stemby> abbiamo scritto anche una libreria
23:51:44 < Stemby> con tutte le funzioni dell'algebra booleana
23:51:50 < Stemby> NAND, XNOR, ecc
23:51:56 < |Wolf|> ok
23:52:23 < Stemby> allora, chi mi scrive qualche espressione con and
23:52:30 < Stemby> usando i tipi che preferite
23:52:35 < Stemby> ?
23:53:14 < JumX> def AND(val1, val2):     return val1 and val2
23:53:30 < Stemby> quello è tratto dalla nostra libreria
23:53:37 < Stemby> lasciamola lì
23:53:48 < JumX> E' quello che ho studiato
23:53:53 < Stemby> una banale espressione con and
23:53:59 < brunology> >>> False and 0
23:54:02 < brunology> False
23:54:07 < Stemby> ok
23:54:10 < Stemby> chiaro perché?
23:54:14 < brunology> >>> 0 and False
23:54:17 < brunology> 0
23:54:20 < Stemby> chiaro perché?
23:54:23 < JumX> sono entrambe false
23:54:30 < Stemby> cosa è falso?
23:54:38 < brunology> restituisce il primo perché il primo è falso
23:54:42 < Stemby> esatto
23:54:56 < Stemby> x and y      if x is false, then x, else y
23:55:12 < Stemby> a questo punto della serata, immagino che sia chiaro per tutti
23:55:21 < spirit> si
23:55:24 < Stemby> ora, senza provare nell'interfaccia testuale:
23:55:43 < Stemby> "pippo" and 0.0
23:55:47 < Stemby> cosa darà?
23:56:21 < Stemby> troppo tempo...
23:56:39 < spirit> False
23:56:39 < brunology> "pippo" è vero
23:56:42 < Stemby> ok
23:56:49 < Stemby> quindi cosa dà l'espressione?
23:56:57 < JumX>  quindi o.o
23:56:58 < brunology> l'altro: 0.0
23:57:02 < Stemby> esatto!
23:57:05 < Stemby> proviamo
23:57:07 -!- |Wolf| [~quassel@Azzurra=F3DC3C2.yok.fi] has quit [Client closed connection]
23:57:19 < Stemby> >>> "pippo" and 0.0
23:57:19 < Stemby> 0.0
23:57:37 < Stemby> spirit: tutto ok?
23:57:38 -!- |Wolf| [~quassel@Azzurra=F3DC3C2.yok.fi] has joined #debianizzati-corsi
23:57:58 < spirit> si più o meno
23:58:09 < Stemby> guardiamo ora il terzo operatore
23:58:10 < Stemby> not
23:58:18 < JumX> o.o and "pippo" cosa restituira?
23:58:32 < Stemby> o.o o 0.0?
23:58:42 < JumX> zero.zero
23:58:54 < Stemby> secondo te?
23:59:10 < Stemby> 0.0 è vero o falso?
23:59:19 < JumX> falso
23:59:25 < Stemby> quindi?
23:59:38 < JumX> 0.0
23:59:41 < Stemby> x and y         if x is false, then x, else y
23:59:47 < Stemby> il primo
23:59:49 < Stemby> 0.0
23:59:51 < Stemby> :)
23:59:55 < Stemby> ok
00:00:00 < Stemby> dicevo, guardiamo not
00:00:03 < Stemby> come vedete:
00:00:03 < JumX> ok
00:00:12 < Stemby> not x	if x is false, then True, else False
00:00:21 < Stemby> not restituisce un booleano
00:00:28 < Stemby> questa è una bella differenza
00:01:04 < brunology> perché not ha solo due possibili risultati
00:01:04 < Stemby> mentre and e or restituiscono il primo o il secondo valore dell'espressione, indipendentemente dal tipo, not invece restituisce un booleano
00:01:14 < Stemby> quindi:
00:01:22 < Stemby> not 0.000
00:01:24 < Stemby> cosa darò?
00:01:25 < JumX> not 0  da True
00:01:30 < Stemby> esatto
00:01:36 < Stemby> e
00:01:38 < Stemby> not ''
00:01:38 < Stemby> ?
00:01:50 < brunology> true
00:01:54 < Stemby> True
00:01:59 < Stemby> con la maiuscola
00:02:03 < brunology> sì
00:02:07 < Stemby> e
00:02:14 < Stemby> not 'pippo'
00:02:14 < Stemby> ?
00:02:23 < brunology> False
00:02:32 < Stemby> e
00:02:35 < Stemby> not None
00:02:36 < JumX> Restituisce il contrario di quello che è ... detto in maniera terra terra
00:02:37 < Stemby> ?
00:02:58 < spirit> niente
00:02:58 < Stemby> not None
00:03:02 < Stemby> no!
00:03:11 < spirit> avevo scritto None
00:03:17 < JumX> None è False di natura quindii True
00:03:24 < Stemby> paragrafo 5.1
00:03:27 < Stemby> esatto
00:03:33 < Stemby> not None dà True
00:03:50 < Stemby> come anche not False
00:03:55 < Stemby> (ovviamente)
00:03:57 < Stemby> bon
00:04:13 < Stemby> mangari in questi giorni riprendete l'algebra booleana
00:04:26 < Stemby> e provate a guardarla anche in quest'ottica
00:04:34 < Stemby> (degli algoritmi che ci stanno dientro)
00:04:52 < Stemby> ora, se avete un attimo di pazienza, vorrei introdurre un argomento importante
00:05:17 < Stemby> allora: 5.3 l'abbiamo già visto bene
00:05:28 < Stemby> 5.4 la volta scorsa
00:05:37 < Stemby> vi ricordate?
00:05:42 < |Wolf|> (cmq imho è più importante capire la logica booleana che l'algoritmo che ci sta dietro, visto che il fatto che viene restituito uno dei 2 raramente è utile)
00:06:00 < Stemby> |Wolf|: son d'accordo
00:06:12 < Stemby> ma il discorso era venuto fuori in quell'occasione
00:06:30 < Stemby> in quanto non avevamo capito perché venivano restituiti dei valori strani
00:06:36 < Stemby> invece di True o False
00:06:51 < Stemby> ora spero che sia chiaro una volta per tutte
00:06:57 < brunology> già, ora abbiamo capito
00:07:13 < Stemby> dicevo, il paragrafo 5.4
00:07:45 < Stemby> la prima tabellona l'abbiamo affrontata in dettaglio la volta scorsa
00:07:49 < Stemby> ci son dubbi?
00:07:57 < spirit> no
00:08:06 < Stemby> divisione, divisione intera, modulo, ecc.
00:08:09 < Stemby> tutto chiaro?
00:08:12 < brunology> sì
00:08:29 < Stemby> domandina: cos'è l'operatore modulo?
00:08:47 < Stemby> (e qual è, in python)?
00:08:51 < brunology> %
00:08:56 < Stemby> giusto
00:08:59 < brunology> mi dà il resto di una divisione
00:09:02 < Stemby> ok
00:09:12 < Stemby> tutti avreste saputo rispondere?
00:09:19 < Stemby> non barate...
00:09:24 < spirit> no
00:09:37 < Stemby> allora, spirit
00:09:47 < Stemby> 6 % 2
00:09:52 < Stemby> cosa significa?
00:10:05 < JumX> 6 diviso 2
00:10:06 < Stemby> intanto, si legge: "sei modulo 2"
00:10:07 < spirit> da uno 0
00:10:19 < Stemby> perché dà 0
00:10:20 < Stemby> ^
00:10:21 < Stemby> ?
00:10:50 < spirit> lo tratta come modulo?
00:10:52 < Stemby> risposta: perché sei diviso due dà tre con resto di 0
00:10:54 < Stemby> no
00:10:59 < Stemby> è il resto
00:11:09 < spirit> che frana
00:11:15 < Stemby> sei modulo due è il resto della divisione tra 6 e 2
00:11:19 < Stemby> ovvero zero
00:11:20 < Stemby> :)
00:11:31 < Stemby> è un termine informatico
00:11:41 < Stemby> in matematica "modulo" ha un significato diverso
00:11:50 < Stemby> ovvero: valore assoluto di un numero
00:12:01 < Stemby> ovvero: quel numero senza il segno
00:12:10 < Stemby> per far questo c'è una funzione: quale?
00:12:27 < spirit> int()
00:12:39 < Stemby> come faccio ad ottenere il valore assoluto di -35.78?
00:12:40 < JumX> abs
00:12:42 < Stemby> spirit: no
00:12:44 < Stemby> JumX: sì
00:13:04 < Stemby> il valore assoluto di -35.78 è 35.78
00:13:09 < Stemby> siamo d'accordo?
00:13:17 < Stemby> provate a fare
00:13:25 < Stemby> abs(-35.78)
00:13:35 < Stemby> e verificate che dia il valore corretto
00:13:51 < Stemby> ora provate
00:13:56 < Stemby> int(-35.78)
00:13:58 < JumX> da errore
00:14:01 < Stemby> cosa restituisce?
00:14:05 < Stemby> JumX: no
00:14:11 < Stemby> che errore ti dà^
00:14:12 < Stemby> ?
00:14:16  * |Wolf| non ha segno
00:14:34 < Stemby> JumX: non dovrebbe darti errore
00:15:08 < Stemby> da me funziona correttamente
00:15:11 < JumX> abs(-35,78)    Traceback (most recent call last):
00:15:22 < Stemby> prosegui
00:15:25 < Stemby> ah!!!
00:15:28 < JumX> File "<stdin>", line 1, in <module>
00:15:35 < Stemby> attenzione al separatore decimale!!!!!
00:15:40 < JumX> TypeError: abs() takes exactly one argument (2 given)
00:15:42 < Stemby> non è la virgola
00:15:45 < Stemby> è il punto
00:15:52 < Stemby> non confondetevi!!!!
00:15:58 < JumX> porca mis.... faccio sempre lo stesso errore , per .
00:16:05 < Stemby> mettendo una virgola, stai scrivendo una tupla
00:16:17 < Stemby> ovvero una sequenza di vari oggetti
00:16:25 < Stemby> (in quel caso una sequenza di 2 interi)
00:16:28 < JumX> si 
00:16:45 < Stemby> ovviamente non  può trasformare 2 interi in 1 valore assoluto
00:16:50 < JumX> abs restituisce il valore 35.78   int solo 35
00:17:01 < Stemby> esatto
00:17:08 < Stemby> ripeto di nuovo
00:17:16 < Stemby> int tronca la parte decimale
00:17:17 < JumX> no
00:17:26 < Stemby> cosa n
00:17:29 < Stemby> *no?
00:17:42 < JumX> per me è chiaro abs
00:17:51 < Stemby> ok
00:17:52 < JumX>  % un po meno
00:17:55 < Stemby> ok
00:18:00 < Stemby> un secondo
00:18:07 < Stemby> dicevo
00:18:15 < Stemby> int() è chiarissimo per tutti?
00:18:21 < JumX> si
00:18:21 < Stemby> tronca la parte decimale
00:18:38 < Stemby> >>> int(-35.78)
00:18:38 < Stemby> -35
00:18:44 < Stemby> non è un arrotondamento
00:18:53 < JumX> ok
00:18:58 < spirit> ok
00:18:58 < Stemby> (altrimenti avremmo dovuto avere -36)
00:19:11 < Stemby> tornando al modulo
00:19:23 < Stemby> non è altro che il RESTO di una divisione
00:19:29 < Stemby> 10 % 2
00:19:41 < Stemby> è il resto della divisione tra 10 e 2
00:19:44 < Stemby> ovvero 0
00:19:53 < Stemby> perchè 10/2 non ha resto
00:20:00 < Stemby> se invece facciamo
00:20:06 < Stemby> 5 % 3
00:20:22 < Stemby> "cinque modulo tre"
00:20:27 < spirit> 2
00:20:29 < Stemby> che cosa otteniamo?
00:20:31 < JumX> 2
00:20:35 < Stemby> spirit: perché?
00:20:42 < spirit> il resto
00:20:45 < Stemby> ovvero?
00:20:56 < spirit> la differenza
00:20:58 < JumX> 1 * 3 = 3 al 5 è 2
00:20:59 < Stemby> no
00:21:11 < JumX> cosa no
00:21:16 < Stemby> spirit: devi fare 5/3
00:21:20 < brunology> devo scappare, mi leggerò i log... grazie e a domenica
00:21:21 < Stemby> come alle elementari
00:21:23 < spirit> ah
00:21:36 < JumX> Ciao brunology notte
00:21:43 < Stemby> cinque diviso tre fa uno con resto di...
00:21:46 -!- brunology [~brunology@Azzurra=64C72B29.9-79-r.retail.telecomitalia.it] has left #debianizzati-corsi []
00:22:12 < Stemby> spirit: ↑
00:22:18 < Stemby> cinque diviso tre fa uno con resto di...
00:22:22 < spirit> 666
00:22:29 < spirit> 1,666
00:22:32 < Stemby> no....
00:22:36 < Stemby> cinque diviso tre fa uno con resto di...
00:22:44 < spirit> 2
00:22:47 < Stemby> quante volte ci sta il 3 nel 5?
00:22:50 < Stemby> una volta
00:22:53 < Stemby> con che resto?
00:22:53 < Stemby> 2!
00:22:56 < Stemby> è chiaro???
00:23:02 < spirit> ok..
00:23:04 < Stemby> come alle elementari
00:23:07 < Stemby> non ci sono decimali
00:23:32 < Stemby> l'operatore modulo restituisce il resto di una divisione
00:23:54 < Stemby> non confondiamo il resto con la parte decimale
00:23:58 < Stemby> ora è chiaro?
00:24:03 < spirit> ok
00:24:06 < Stemby> JumX: ?
00:24:12 < JumX> si ok
00:24:45 < Stemby> purtroppo stasera non riusciamo a fare quello che avevo in mente
00:24:52 < Stemby> abbiamo allungato troppo
00:24:59 < Stemby> spero che il ripasso sia servito
00:25:10 < Stemby> solo un'ultima cosa:
00:25:23 < Stemby> diamo un'occhiata alla seconda tabella del par. 5.4
00:25:35 < Stemby> cosa vediamo?
00:25:52 < spirit> operatori
00:25:56 < Stemby> no
00:25:58 < Stemby> math.trunc(x)	
00:26:11 < spirit> ah, ok
00:26:16 < Stemby> che cos'è?
00:26:42 < JumX> tratta arrotondamenti
00:26:49 < Stemby> sì
00:26:51 < JumX> se ho capito bene
00:26:59 < Stemby> ma math.trunc(x) che cos'è?
00:27:10 < JumX> tronca integralmente
00:27:13 < Stemby> una variabile?
00:27:17 < Stemby> un operatore?
00:27:20 < Stemby> una stringa?
00:27:24 < Stemby> un'espressione?
00:27:28 < spirit> un integrale
00:27:28 < Stemby> una funzione?
00:27:32 < Stemby> ????
00:27:35 < JumX> funzione
00:27:39 < Stemby> quasi
00:27:45 < Stemby> è simile ad una funzione
00:27:54 < Stemby> infatti vedete che ci sono le parentesi
00:28:00 < Stemby> si chiama "metodo"
00:28:04 < Stemby> è un metodo
00:28:26 < Stemby> ah, no, scusate
00:28:30 < Stemby> ho sbagliato
00:28:33 < Stemby> è proprio una funzione
00:28:40 < |Wolf|> gh
00:28:46 < Stemby> mi ha confuso la sintassi punto
00:28:52 < Stemby> (e l'ora tarda)
00:28:59 < Stemby> è una funzione, come non detto
00:29:09 < Stemby> solo che non fa parte della libreria standard
00:29:21 < Stemby> ovvero: è una funzione che si trova in un modulo esterno
00:29:34 < |Wolf|> non è una funzione builtin
00:29:41 < Stemby> in particolare nel modulo math
00:29:49 < |Wolf|> quindi bisogna importare il modulo math per poterla usare
00:30:05 < |Wolf|> (e il modulo math fa parte della libreria standard di python)
00:30:17 < Stemby> ci ricordiamo come si fa a collegare nel nostro modulo gli oggetti di un modulo esterno?
00:30:27 < Stemby> |Wolf|: ah, ok
00:30:30 < spirit> import
00:30:31 < Stemby> poco cambia
00:30:33 < Stemby> spirit: bravo
00:30:53 < Stemby> quindi, per poter chiamare quella funzione, prima dobbiamo fare
00:30:56 < Stemby> import math
00:31:02 < Stemby> e poi possiamo usarla
00:31:17 < Stemby> possiamo farlo anche nell'interfaccia interattiva
00:31:18 < Stemby> proviamo
00:31:31 < Stemby> >>> import math
00:31:55 < Stemby> >>> math.trunc(17.98)
00:31:55 < Stemby> 17
00:31:58 < Stemby> fatto?
00:32:24 < Stemby> in sostanza è una funzione abbastanza inutile
00:32:25 < JumX> si
00:32:34 < Stemby> visto che possiamo ottenere la stessa cosa come?
00:32:50 < JumX> int
00:32:54 < Stemby> ovvero?
00:33:07 < JumX> int(17.98)   ...  17
00:33:10 < Stemby> >>> int(17.98)
00:33:10 < Stemby> 17
00:33:12 < Stemby> esatto
00:33:33 < Stemby> passiamo alla seconda funzione
00:33:39 < Stemby> questa è più interessante
00:33:48 < JumX> round dovrebbe arrotondare in base ad una nostra scelta 
00:34:02 < JumX> se vogliamo arrotondare per eccesso o per difetto
00:34:03 < Stemby> JumX: prova e facci vedere
00:34:23 < JumX> tra il dire il fare c'è di mezzo il mare ... accontentatevi della teroia
00:34:28 < Stemby> :)
00:34:41 < Stemby> allora, vedete che prende 2 parametri?
00:34:45 < JumX> *teoria
00:34:52 < Stemby> il secondo però è opzionale
00:35:03 < Stemby> iniziamo quindi a provare la funzione con un solo parametro
00:35:09 < Stemby> chi vuole iniziare?
00:35:27 < Stemby> usiamo lo stesso numero di prima, magari
00:35:43 < Stemby> inizio io, via
00:35:45 < Stemby> >>> round(17.98)
00:35:45 < Stemby> 18
00:35:49 < Stemby> oh!!!
00:35:58 < Stemby> finalmente abbiamo un arrotondamento vero
00:36:20 < Stemby> >>> round(17.39)
00:36:20 < Stemby> 17
00:36:38 < Stemby> >>> round(-17.7)
00:36:38 < Stemby> -18
00:36:41 < Stemby> ok?
00:36:48 < JumX> ok
00:36:50 < spirit> ok
00:37:07 < Stemby> attenzione:
00:37:09 < Stemby> >>> round(5.5)
00:37:09 < Stemby> 6
00:37:20 < Stemby> ok?
00:37:31 < Stemby> se il decimale è
00:37:40 < Stemby> 0 o 1 o 2 o 3 o 4
00:37:44 < Stemby> arrotonda per difetto
00:37:47 < Stemby> se è
00:37:53 < Stemby> 5 o 6 o 7 o 8 o 9
00:37:58 < Stemby> arrotonda per eccesso
00:38:07 < Stemby> chiaro?
00:38:09 < spirit> ok
00:38:17 < JumX> ok
00:38:35 < Stemby> ora cerchiamo di capire cosa fa il secondo parametro
00:38:39 < Stemby> secondo voi?
00:38:58 < Stemby> x rounded to n digits
00:39:01 < spirit> da in para
00:39:05 < spirit> ops
00:39:19 < Stemby> mi sembra chiaro...
00:39:20 < |Wolf|> >>> round(2.5)
00:39:20 < |Wolf|> 2
00:39:29 < Stemby> "digit" cos'è in inglese?
00:39:36 < |Wolf|> cifra
00:39:39 < Stemby> ok
00:39:45 < Stemby> "to round"?
00:39:56 < |Wolf|> cmq arrotonda alla cifra pari più vicina
00:39:58 < JumX> arrotonda
00:40:02 < Stemby> arrotondare
00:40:05 < Stemby> quindi
00:40:09 < Stemby> x rounded to n digits
00:40:13 < Stemby> come lo si traduce?
00:40:28 < Stemby> rounded è il p.p. di to round...
00:40:42 < Stemby> dai!
00:40:52 < Stemby> quello scarso in inglese dovrei essere io...
00:41:08 < Stemby> come si traduce in italiano "x rounded to n digits"
00:41:11 < Stemby> ???
00:41:32 < Stemby> in italiano, qual è il participio passato di "arrotondare"?
00:41:42 < spirit> arrotondato
00:41:45 < Stemby> oh
00:41:51 < Stemby> quindi?
00:41:54 < Stemby> x → z
00:41:57 < JumX> alla cifra scelta
00:41:57 < Stemby> soddy
00:42:00 < Stemby> sorry
00:42:27 < Stemby> "x arrotondato a tot cifre"
00:42:33 < Stemby> è letterale...
00:42:47 < Stemby> chiaro?
00:43:06 < spirit> ok
00:43:10 < Stemby> >>> round(5.4234523563451345, 2)
00:43:10 < Stemby> 5.42
00:43:26 < Stemby> arrotonda a 2 cifre decimali il numero del primo parametro
00:43:57 < JumX> Ci spieghi la sintassi della doc    round(x[, n]) ?
00:44:01 < Stemby> >>> round(5.4217523563451345, 3)
00:44:01 < Stemby> 5.422
00:44:09 < |Wolf|> le cose tra [] sono opzionali
00:44:15 < Stemby> arrotonda a 3 cifre decimali il numero precedente
00:44:22 < Stemby> JumX: esatto
00:44:27 < |Wolf|> quindi puoi fare sia round(x) che round(x, n)
00:44:35 < |Wolf|> la n è opzionale
00:44:53 < Stemby> JumX: chiaro?
00:44:54 < spirit> chiaro
00:45:11 < JumX> come l'acqua che sto benvendo :)
00:45:22 < Stemby> è una funzione che prende come argomento 2 parametri; il secondo è opzionale
00:45:31 < |Wolf|> cmq adesso nella doc si cerca di usare round(x, n=0)
00:46:07 < Stemby> sì, che è equivalente
00:46:24 < Stemby> ma chiarisce che il secondo parametro è 0 per default
00:47:00 < |Wolf|> sì, che se non lo specifichi usa il valore di default che in questo caso è 0 (cioè 0 decimali)
00:47:05 < Stemby> quindi, se non si inserisce il secondo parametro, questi assume per default valore 0
00:47:13 < Stemby> esatto
00:47:28 < Stemby> chiaro per tutti?
00:47:45 < JumX> si
00:47:49 < spirit> si ma io..vado,'notte e grazie
00:47:49 < Stemby> >>> round(5.4217523563451345, 0)
00:47:49 < Stemby> 5.0
00:47:54 < Stemby> ok
00:48:05 < Stemby> le ultime due funzioni le vediamo la prossima volta
00:48:09 < JumX> ok
00:48:10 -!- spirit [~spirit@Azzurra-C3C291C.104-82-b.business.telecomitalia.it] has quit [Quit: leaving]
00:48:12 < Stemby> notte
00:48:18 < |Wolf|> quali sono?
00:48:23 < JumX> le accenniamo ? 
00:48:30 < |Wolf|> (e quand'è la prossima volta?)
00:48:37 < Stemby> http://docs.python.org/release/3.1.3/library/stdtypes.html#numeric-types-int-float-complex
00:48:44 < JumX> Domenica
00:48:45 < Stemby> seconda tabella
00:49:00 < Stemby> |Wolf|: sempre mercoledì e domenica
00:49:05 < JumX> floor e ceil
00:49:16 < Stemby> non le conosco
00:49:23 < Stemby> e la doc non mi chiarisce molto...
00:49:27 < Stemby> adesso le provo
00:49:37 < |Wolf|> arrotondano per eccesso e difetto
00:49:44 < JumX> floor <= x   ceil >= x
00:50:00 < |Wolf|> cmq round normale su py3 arrotanda alla cifra pari
00:50:04 < |Wolf|> tonda*
00:50:26 < |Wolf|> >>> round(1.5)
00:50:26 < |Wolf|> 2
00:50:26 < |Wolf|> >>> round(2.5)
00:50:26 < |Wolf|> 2
00:50:50 < Stemby> >>> math.floor(5.4217523563451345)
00:50:50 < Stemby> 5
00:50:50 < Stemby> >>> math.floor(5.7217523563451345)
00:50:50 < Stemby> 5
00:50:54 < Stemby> chiaro
00:51:13 < |Wolf|> floor e ceil infatti vogliono dire pavimento e soffitto
00:51:15 < Stemby> >>> math.ceil(5.7217523563451345)
00:51:15 < Stemby> 6
00:51:15 < Stemby> >>> math.ceil(5.1217523563451345)
00:51:15 < Stemby> 6
00:51:21 < Stemby> chiarissimo
00:51:26 < |Wolf|> floor sempre verso il basso, ceil verso l'alto
00:51:29 < Stemby> ok
00:51:47 < JumX> ok
00:52:18 < Stemby> bon, buona notte
00:52:24 < JumX> Ora credo che possiamo andare a nanna ... che ditre?
00:52:28 < Stemby> ah, JumX
00:52:39 < Stemby> ovviamente bisogna prima importare math
00:52:46 < |Wolf|> a me sono esplosi i test e devo sistemarli
00:52:50 < Stemby> ma se l'hai già fatto, è già fatto
00:52:55 < JumX> si l'avevo capito
00:53:02 < JumX> facendo le prove
00:53:10 < Stemby> ok
00:53:19 < Stemby> notte
00:53:25 < JumX> inizialmente non mi funzionava poi con import math tutto ok
00:53:27 < Stemby> aspetta
00:53:36 < Stemby> i compiti per la prossima volta...
00:53:44 < Stemby> va beh, son scappati tutti
00:53:48 < JumX> tu tu tu tu è caduta la linea
00:53:55 < Stemby> niente
00:53:57 < JumX> dai dimmi
00:54:10 < Stemby> chi non l'ha ancora fatto, che legga i 2 capitoli iniziali del libro
00:54:36 < Stemby> e magari quelle slide sugli algoritmi e sui diagrammi di flusso
00:54:39 < JumX> li ho già letti ma non dicono molto di nuovo o sbaglio?
00:54:45 < Stemby> non sbagli
00:55:01 < Stemby> solo che per leggere il cap. 3 volevo prima introdurre un argomento
00:55:07 < JumX> Quindi ripetizione .. :)
00:55:09 < Stemby> solo che oggi non abbiamo fatto in tempo
00:55:25 < Stemby> già, mi spiace
00:55:33 < Stemby> un po' ho fatto tardi io
00:55:36 < risca> buona sera