[21:51:28] <amosse> Buona sera a tutti
[22:27:21] <Stemby> 'sera
[22:27:31] <amosse> sera
[22:27:31] <Stemby> scusate per l'ora ma ho finito tardissimo
[22:27:39] <Stemby> che folla
[22:27:54] <amosse> si in effetti..
[22:27:55] <Stemby> fatemi un po' di spazio che non respiro
[22:28:13] <Stemby> amosse: sei l'ultimo superstite?
[22:28:17] <Stemby> che famo?
[22:28:33] <amosse> boh
[22:28:36] <Stemby> vediamo l'output su file, va
[22:28:40] <Stemby> gli altri si attaccano
[22:28:41] <amosse> ok
[22:28:45] <amosse> ok
[22:28:49] <Stemby> dammi 2 minuti che mi sistemo
[22:28:54] <amosse> ok
[22:29:19] <Stemby> tu hai guardato qualcosa?
[22:29:34] <amosse> a dire il vero non tanto
[22:29:51] <amosse> sto cercando di aggiornare il wikiu
[22:29:56] <amosse> *wiki
[22:30:46] <amosse> se hai un minuto dacci un occhiata, 'sequenze'
[22:31:11] <Stemby> vedrò
[22:31:17] <Stemby> non subito, comunque
[22:31:26] <amosse> ok
[22:31:32] <amosse> no problem
[22:31:51] <Stemby> eccomi
[22:31:58] <amosse> ok
[22:32:01] <Stemby> allora, riprendiamo da dove eravamo rimasti
[22:32:07] <Stemby> ti ricordi?
[22:32:09] <amosse> vai pure
[22:32:12] <amosse> si
[22:32:25] <Stemby> tutorial, capitolo 7 se non erro
[22:32:45] <amosse> http://docs.python.org/release/3.1.3/tutorial/inputoutput.html#reading-and-writing-files
[22:33:02] <Stemby> esatto
[22:33:23] <Stemby> i metodi fatti son chiari?
[22:33:36] <amosse> si, solo una domanda
[22:33:49] <Stemby> dimmi
[22:33:51] <Stemby> ah, ecco
[22:33:53] <Stemby> aspetta
[22:34:00] <Stemby> l'altra volta ti avevo detto:
[22:34:10] <Stemby> for line in f.readlines():
[22:34:14] <Stemby> ti ricordi?
[22:34:19] <amosse> si
[22:34:28] <Stemby> mi ricordavo che non era performante
[22:34:31] <Stemby> è così
[22:34:33] <Stemby> non usarlo
[22:34:43] <Stemby> puoi fare direttamente come sul wiki
[22:34:51] <Stemby> for line in f:
[22:34:52] <Stemby> ok?
[22:35:02] <amosse> ok
[22:35:07] <Stemby> perché gli oggetti di tipo file sono già iterabili
[22:35:13] <amosse> ok
[22:35:14] <Stemby> inutile creare una lista
[22:35:17] <Stemby> bon
[22:35:36] <Stemby> la tua domanda?
[22:36:14] <amosse> il secondo argomento di open(), quando è 'a' cosa significa esattamente
[22:36:43] <amosse> 'opens the file for appending'
[22:36:48] <amosse> ?
[22:36:52] --> groll (~groll@Azzurra-195E4683.48-151.net24.it) has joined #debianizzati-corsi
[22:37:07] <Stemby> adesso lo vediamo
[22:37:08] <amosse> ciao groll
[22:37:12] <amosse> ok
[22:37:15] <groll> ciao
[22:37:21] <Stemby> l'avevo spiegato già l'altra volta, comunque lo riprendiamo
[22:37:25] <Stemby> ciao groll
[22:37:41] <Stemby> bon
[22:37:52] <Stemby> allora vediamo come scrivere un file
[22:38:01] <amosse> ok
[22:38:10] <Stemby> primo passaggio: creare un oggetto di tipo file, in scrittura
[22:38:24] <Stemby> come dicevo, è una fase delicata
[22:38:40] <Stemby> se scrivi su un file esistente, lo cancelli!
[22:38:56] <Stemby> quindi posizionati in una cartella che sia sicura
[22:39:03] <Stemby> poi fammi vedere come faresti
[22:39:08] <Stemby> (nell'interprete)
[22:39:13] <amosse> ok
[22:41:07] <Stemby> forza
[22:41:08] <amosse> >>> f = open('prova.txt', 'w')
[22:41:13] <Stemby> ok
[22:41:25] <Stemby> fammi vedere se posso farlo anch'io
[22:41:27] <Stemby> un attimo
[22:41:50] <Stemby> ok, non ho nessun file che si chiama così
[22:42:18] <Stemby> bene
[22:42:31] <Stemby> secondo passaggio: dobbiamo scriverci i contenuti
[22:42:33] <Stemby> come fare?
[22:42:42] <Stemby> qui entra in gioco il metodo write()
[22:42:52] <amosse> ok
[22:42:53] <amosse> provo
[22:43:05] <Stemby> hai visto sul tutorial?
[22:43:16] <amosse> no
[22:43:28] <Stemby> guarda
[22:43:43] <Stemby> la sintassi è banale
[22:43:50] <Stemby> f.write(string)
[22:44:07] <Stemby> dove al posto di string ci metti una stringa
[22:44:14] <amosse> >>> f.write('ciao questa è una prova') 23
[22:44:18] <Stemby> ottimo
[22:44:28] <amosse> perchè 23?
[22:44:34] <Stemby> secondo te?
[22:44:43] <amosse> n° caratteri
[22:44:47] <Stemby> esatto
[22:45:10] <Stemby> in realtà hai dimenticato un carattere
[22:45:13] <Stemby> o meglio...
[22:45:23] <Stemby> vediamo cosa succede se aggiungi un altra stringa
[22:45:26] <Stemby> forza
[22:45:35] <Stemby> scrivi un'altra stringa
[22:46:31] <amosse> >>> f.write('\nla seconda riga\n') 17
[22:46:41] <Stemby> eh, così non vale :p
[22:46:47] <Stemby> comunque ok
[22:46:50] <Stemby> hai capito
[22:47:01] <amosse> si '\n'
[22:47:27] <Stemby> \n è un unico carattere, ti è chiaro questo, vero?
[22:47:39] <amosse> si si
[22:47:51] <Stemby> infatti se vedi ci sono 15 caratteri nella tua stringa
[22:47:56] <Stemby> più i 2 \n
[22:48:00] <Stemby> in totale 17
[22:48:04] <Stemby> conta :)
[22:48:15] <amosse> si esatto
[22:48:24] <Stemby> ok
[22:48:30] <Stemby> ora ti spiego un altro metodo
[22:48:34] <Stemby> close()
[22:48:38] <Stemby> prova
[22:49:05] <amosse> ok
[22:49:44] <amosse> chiude l'oggetto?
[22:49:59] <Stemby> diciamo di sì
[22:50:05] <Stemby> f.close()
[22:50:06] <Stemby> ok?
[22:50:10] <amosse> ok
[22:50:13] <Stemby> prova a scrivere una riga
[22:50:56] <amosse> ValueError: I/O operation on closed file.
[22:50:59] <Stemby> esatto
[22:51:02] <Stemby> però:
[22:51:10] <Stemby> >>> f
[22:51:10] <Stemby> <_io.TextIOWrapper name='prova.txt' mode='w' encoding='UTF-8'>
[22:51:12] <Stemby> ok?
[22:51:20] <Stemby> l'oggetto esiste ancora
[22:51:24] <Stemby> non è stato distrutto
[22:51:30] <Stemby> però è chiuso
[22:51:37] <Stemby> ovvero non ci si può operare sopra
[22:51:43] <Stemby> ok?
[22:51:46] <amosse> a cosa serve chiuderlo
[22:52:01] <Stemby> ad esempio:
[22:52:09] <Stemby> devi leggere e scrivere sullo stesso file
[22:52:30] <Stemby> chiudi la lettura
[22:52:34] <Stemby> lo riapri in scrittura
[22:52:38] <Stemby> e viceversa
[22:52:47] <amosse> ok
[22:52:56] <Stemby> diciamo che in realtà close() lo si potrebbe anche non usare praticamente mai
[22:53:19] <amosse> quindi diciamo per una questione di sicurezza dei dati
[22:53:20] <Stemby> nel senso che quando il processo finisce, python distrugge automaticamente tutti gli oggetti
[22:53:23] <weirdo> "ne resterà solo uno"
[22:53:44] <amosse> quale?
[22:53:48] <Stemby> e quando un oggetto file viene distrutto, per prima cosa in automatico viene chiuso
[22:54:04] <Stemby> però per chiarezza nei sorgenti non è mai male aggiungere un close()
[22:54:22] <amosse> scusa sorgenti?
[22:54:28] <Stemby> diciamo che io tendenzialmente lascio aperto in scrittura un file lo stretto indispensabile
[22:54:41] <Stemby> sorgenti = listato
[22:54:52] <Stemby> il codice dei tuoi script
[22:54:58] <amosse> ok
[22:55:14] <Stemby> appena posso chiudo
[22:55:25] <amosse> ok
[22:55:30] <Stemby> in questo modo, se dovesse spegnersi il pc, non dovrebbero succedere danni
[22:55:37] <Stemby> apro → scrivo → chiudo
[22:55:42] <Stemby> se serve, riapro
[22:55:50] <amosse> ok
[22:55:54] <Stemby> poi ognuno si regola come crede
[22:56:14] <amosse> quindi un file close() può essere solo letto?
[22:56:22] <Stemby> ?
[22:56:30] <Stemby> no, neppure
[22:56:36] <Stemby> se è chiuso è chiuso
[22:56:43] <Stemby> devi riaprirlo in lettura
[22:56:53] <amosse> hai ragione scusa
[22:57:02] <amosse> ok
[22:57:02] <Stemby> >>> f.read()
[22:57:02] <Stemby> Traceback (most recent call last):
[22:57:02] <Stemby> File "<stdin>", line 1, in <module>
[22:57:02] <Stemby> ValueError: I/O operation on closed file.
[22:57:12] <Stemby> basta provare...
[22:57:13] <Stemby> :)
[22:57:31] <amosse> ok i/o -> scrivi/leggi
[22:57:50] <Stemby> su file sì
[22:57:58] <amosse> ok
[22:58:10] <Stemby> input = ingresso
[22:58:20] <Stemby> (dei dati grezzi)
[22:58:32] <Stemby> output = iscita dei dati elaborati dal programma
[22:58:35] <Stemby> *uscita
[22:58:45] <amosse> ok
[22:58:53] <Stemby> possiamo fare:
[22:59:03] <Stemby> tastiera → script → monitor
[22:59:09] <Stemby> (come abbiamo fatto finora)
[22:59:11] <Stemby> oppure
[22:59:19] <Stemby> file → script → monitor
[22:59:22] <Stemby> oppure
[22:59:27] <Stemby> file → script → file
[22:59:32] <Stemby> oppure...
[22:59:46] <Stemby> tastiera → script → file
[22:59:57] <Stemby> oppure... tante altre possibilità
[23:00:06] <amosse> ok
[23:00:16] <Stemby> ma con gli strumenti che abbiamo ora direi che le possibilità son quelle
[23:00:35] <amosse> ok
[23:00:37] <Stemby> bene
[23:00:45] <Stemby> compito per la prossima volta:
[23:00:53] <Stemby> scrivere un convertitore di encoding
[23:01:09] <amosse> spiegati meglio
[23:01:21] <Stemby> input: file con codifica barbara
[23:01:29] <Stemby> → il tuo script
[23:01:40] <Stemby> → file codificato UTF-8
[23:01:45] <Stemby> ok?
[23:01:51] <Stemby> quello che mi hai chiesto l'altra volta
[23:01:57] <Stemby> di sicuro esiste già
[23:02:13] <Stemby> però riscrivilo tu da 0 in Python
[23:02:22] <Stemby> vedrai che ti basteranno poche righe
[23:02:31] <amosse> scusa ma non ho capito
[23:03:24] <amosse> mi puoi fare un esempio?
[23:03:25] <Stemby> sai cos'è la codifica di un file?
[23:03:39] <amosse> si e no
[23:03:47] <Stemby> mmmm
[23:03:52] <Stemby> weirdo: spieghi tu?
[23:03:54] <Stemby> :)
[23:04:11] <Stemby> groll?
[23:05:04] <groll> io vado a dormire ora
[23:05:04] <Stemby> http://it.wikipedia.org/wiki/File_di_testo#Codifica
[23:05:09] <weirdo> mica lo so spiegare, sono capace soltanto a litigarci con il charset
[23:05:17] <amosse> la codifica , per esempio UTF-8, ma in pratica cosa vuol dire
[23:05:25] <Stemby> :)
[23:05:32] <Stemby> hai presente la tabella ascii?
[23:05:55] <amosse> purtroppo no
[23:05:59] <Stemby> http://it.wikipedia.org/wiki/ASCII
[23:06:14] <Stemby> qui siamo all'informatica degli anni '70-'80
[23:06:27] <weirdo> ma anche se lo sai resta comunque una jungla
[23:06:33] <Stemby> la tabella ASCII dovrebbe essere impressa nella mente del programmatore
[23:07:09] <groll> notte
[23:07:11] <Stemby> in pratica è una tabella che fa corrispondere ad ogni numero un carattere
[23:07:13] <Stemby> notte groll
[23:07:23] <amosse> notte
[23:07:32] <amosse> ok
[23:07:47] <amosse> i numeri sono da 0 a 255?
[23:08:04] <Stemby> ad esempio, il carattere \n è il carattere numero 10 della tabella ASCII
[23:08:07] <Stemby> trovato?
[23:08:11] <Stemby> in realtà no
[23:08:22] <Stemby> la tabella ASCII è a 7 bit
[23:08:24] <Stemby> non a 8
[23:08:43] <Stemby> quindi hai giusto la metà dei caratteri a disposizione
[23:08:45] <amosse> 000 1010 012 10 0A LF ␊ ^J \n Line feed
[23:08:50] <Stemby> esattp
[23:08:55] <Stemby> 10 in decimale
[23:09:02] <Stemby> 1010 in binario
[23:09:12] <amosse> ok
[23:09:18] <-- groll (~groll@Azzurra-195E4683.48-151.net24.it) has quit (Read/Dead Error: Input/output error)
[23:09:33] <Stemby> A in esadecimale
[23:09:35] <Stemby> :)
[23:09:42] <amosse> ok
[23:09:46] <Stemby> è lo stesso numero in diverse basi
[23:10:03] <amosse> ok
[23:10:14] <Stemby> comuque, quel che conta è che il carattere numero 10 (decimale) è \n
[23:10:17] <Stemby> e così via
[23:10:24] <weirdo> basta lezioni noiose ma da oggi siamo tutti programmatori ! http://hackertyper.net/
[23:10:48] <Stemby> il carattere che significa '5' me lo trovi nella tabella ASCII?
[23:11:19] <Stemby> amosse: ↑
[23:11:31] <amosse> 53
[23:11:52] <Stemby> esatto
[23:12:05] <Stemby> quello che significa 'Y'?
[23:12:24] <amosse> 89
[23:12:47] <Stemby> esatto
[23:12:52] <Stemby> vedo che hai capito
[23:13:06] <amosse> quindi, per tornare all'esercizio
[23:13:10] <Stemby> in totale hai a disposizione 7 bit, quindi che numeri hai disponibili?
[23:13:13] <Stemby> un attimo
[23:13:37] <amosse> la metà
[23:13:40] <Stemby> ovvero?
[23:13:51] <Stemby> quanti e quali
[23:14:34] <Stemby> soluzione
[23:14:52] <Stemby> il numero più grande (in binario) con 7 bit quale sarà?
[23:15:05] <Stemby> amosse: sai cos'è un numero binario?
[23:15:08] <Stemby> (in base 2)
[23:15:15] <amosse> 99
[23:15:19] <Stemby> no
[23:15:39] <Stemby> in binario che cifre hai a disposizione?
[23:15:47] <Stemby> (binario = base 2)
[23:16:01] <amosse> eh qui casca l' asino..
[23:16:04] <amosse> la matematica
[23:16:08] <Stemby> hai solo 2 cifre
[23:16:24] <Stemby> 0 e 1
[23:16:27] <Stemby> ok?
[23:16:34] <amosse> 10
[23:16:42] <Stemby> cos'è 10?
[23:16:48] --> groll (~groll@Azzurra-195E4683.48-151.net24.it) has joined #debianizzati-corsi
[23:16:49] <Stemby> (e in che base?)
[23:17:04] <Stemby> allora
[23:17:07] <amosse> se hho a disposizione due cifre 0 e 1
[23:17:15] <Stemby> sì...?
[23:17:34] <amosse> il numero più grande sarà 11
[23:17:39] <Stemby> non direi
[23:17:51] <Stemby> in base 10 quante cifre hai disponibili?
[23:18:14] <amosse> 10 -> da 0 a 9
[23:18:25] <Stemby> e il numero più grande che puoi scrivere?
[23:18:40] <amosse> 99
[23:18:54] <Stemby> non esiste un numero più grande di 99???
[23:18:58] <Stemby> :)
[23:19:05] <Stemby> forse in seconda elementare
[23:19:13] <Stemby> ma ti assicuro che 100 esiste
[23:19:16] <Stemby> ma anche 101
[23:19:22] <Stemby> ma anche 102
[23:19:28] <Stemby> ma anche 100000000000000000
[23:19:34] <Stemby> ma anche 10000000000000000000000000000000000000000000000000000000000000000000000000000
[23:19:37] <Stemby> ecc.
[23:19:42] <Stemby> non esiste limite
[23:19:47] <Stemby> i numeri interi sono infiniti
[23:19:55] <amosse> ok
[23:19:57] <Stemby> questo in qualunque base
[23:20:15] <Stemby> però ho detto che hai a disposizione solo 7 bit
[23:20:29] <Stemby> il bit in base 2 corrisponde al carattere
[23:20:33] <Stemby> (in base 2!)
[23:20:44] <Stemby> quindi 7 bit = 7 cifre binarie
[23:20:59] <Stemby> quindi quale sarà il più grande numero in base 2 a 7 bit?
[23:21:30] <Stemby> facciamo un parallelo in base 10
[23:21:30] <amosse> 2222222
[23:21:34] <Stemby> no!
[23:21:40] <Stemby> il 2 non è una cifra disponibile
[23:21:45] <Stemby> hai solo 0 e 1
[23:21:59] <Stemby> dicevo
[23:22:05] <Stemby> è come se ti avessi chiesto:
[23:22:21] <amosse> 9999999
[23:22:21] <Stemby> in base 10, qual è il numero più grande che puoi scrivere usanto 7 caratteri?
[23:22:25] <Stemby> esatto
[23:22:42] <Stemby> invece usando 7 bit in base 2?
[23:22:57] <Stemby> *usando
[23:23:16] <Stemby> hai a disposizione solo 7 cifre
[23:23:26] <amosse> 2222222
[23:23:27] <Stemby> e le cifre possono essere solo o 0 oppure 1
[23:23:33] <Stemby> no!
[23:23:39] <Stemby> 2 non lo puoi usare!!!!
[23:23:50] <amosse> 1111111
[23:23:52] <Stemby> oh!
[23:24:05] <Stemby> in base 10 la cifra più grande è il 9
[23:24:15] <Stemby> poi si scavalla alle decinee
[23:24:22] <Stemby> o dalle decine alle centinaia
[23:24:24] <Stemby> ecc.
[23:24:27] <Stemby> ti è chiaro?
[23:24:37] <amosse> ok
[23:24:39] <Stemby> in base 2 la cifra più grande è 1
[23:24:51] <Stemby> poi, passi alle decine, centinaia, ecc.
[23:24:52] <amosse> ah ok
[23:24:56] <Stemby> proprio allo stesso modo
[23:25:11] <Stemby> 1111111 è il numero più grande a 7 bit
[23:25:18] <Stemby> che numero è?
[23:25:21] <Stemby> (in base 10)
[23:25:44] <amosse> 9999999
[23:25:47] <Stemby> come si converte da binario a decimale?
[23:25:50] <Stemby> nooooooooooooooooooooooo!
[23:25:53] <Stemby> scusa
[23:26:05] <Stemby> 0 binario = 0 decimale
[23:26:11] <Stemby> 1 binario = 1 decimale
[23:26:18] <Stemby> 10 binario = ?
[23:26:36] <Stemby> 3 decimale
[23:26:48] <Stemby> sorry
[23:26:50] <Stemby> 2 decimale
[23:26:58] <Stemby> 11 binario = 3 decimale
[23:27:08] <Stemby> 100 binario = 4 decimale
[23:27:10] <amosse> quindi:
[23:27:15] <Stemby> 101 binario = 5 decimale
[23:27:24] <Stemby> 110 binario = 6 decimale
[23:27:25] <amosse> binario -> 0, 1
[23:27:34] <Stemby> 111 binario = 7 decimale
[23:27:45] <Stemby> 1000 binario = 8 decimale
[23:27:55] <Stemby> 1001 binario = 9 decimale
[23:28:05] <Stemby> 1010 binario = 10 decimale
[23:28:09] <Stemby> ok?
[23:28:18] <Stemby> quindi?
[23:28:19] <amosse> ok
[23:28:29] <Stemby> come si trasforma un numero binario in decimale?
[23:28:55] <Stemby> ti consiglio di dare un'occhiata ai seguenti numeri binari:
[23:29:01] <Stemby> 1
[23:29:02] <Stemby> 10
[23:29:03] <Stemby> 100
[23:29:05] <Stemby> 1000
[23:29:16] <Stemby> e vedere a cosa corrispondono in decimale
[23:29:31] <amosse> dove lo trovo
[23:29:33] <Stemby> da lì dovresti essere in grado di capire qual è l'algoritmo
[23:29:39] <Stemby> te li ho scritti...
[23:29:50] <-- groll (~groll@Azzurra-195E4683.48-151.net24.it) has quit (Read/Dead Error: Input/output error)
[23:29:54] <amosse> ok
[23:30:31] <amosse> per la matematica é un problema....
[23:30:40] <amosse> *me
[23:30:48] <Stemby> è un problema da risolvere
[23:30:55] <Stemby> queste cose sono importantine
[23:31:12] <Stemby> soprattutto se ci si vuole abbassare di livello
[23:31:20] <Stemby> (in C è inimmaginabile non saperle)
[23:31:39] <amosse> ma scusa, quale mat c'é da sapere
[23:31:44] <Stemby> comuque quei numeri te li ho scritti
[23:31:59] <amosse> per la programmazione
[23:32:03] <amosse> ok
[23:32:27] <Stemby> mah, a dire il vero niente di trascendentale
[23:32:37] <amosse> tipo
[23:32:41] <Stemby> la matematica delle medie
[23:32:54] <amosse> se mi dai degli argomenti, me li guardo
[23:33:04] <Stemby> cambio di base
[23:33:19] <Stemby> poi non saprei, man mano vediamo
[23:33:32] <Stemby> comunque il cambio di base te lo sto spiegando ora
[23:33:43] <amosse> ok
[23:33:54] <Stemby> passare da binario a decimale è davvero semplice
[23:33:54] <amosse> am quei numeri che mi hai dato
[23:34:09] <amosse> tu li conosci a memoria o ci sono delle formule7
[23:34:10] <Stemby> e
[23:34:18] <Stemby> è come in base 10
[23:34:29] <Stemby> solo che hai solo 2 cifre a disposizione
[23:34:34] <Stemby> 0
[23:34:34] <Stemby> 1
[23:34:36] <Stemby> 10
[23:34:36] <Stemby> 11
[23:34:40] <Stemby> 100
[23:34:42] <Stemby> 101
[23:34:44] <Stemby> 110
[23:34:45] <Stemby> 111
[23:34:49] <Stemby> 1000
[23:34:50] <amosse> scusa
[23:34:51] <Stemby> 1001
[23:34:57] <amosse> ripeto
[23:35:01] <Stemby> sto contando in base 2
[23:35:16] <amosse> ok
[23:35:19] <Stemby> 0
[23:35:22] <Stemby> niente
[23:35:29] <Stemby> 1: unità piene
[23:35:39] <Stemby> 10: decine piene, unità vuote
[23:35:47] <Stemby> 11: decine e unità piene
[23:36:01] <Stemby> quindi se aumenti di uno, devi passare alla centinaia
[23:36:04] <Stemby> 100
[23:36:11] <Stemby> + 1?
[23:36:13] <Stemby> 101
[23:36:18] <Stemby> + 1?
[23:36:20] <Stemby> 110
[23:36:27] <Stemby> +1?
[23:36:30] <Stemby> fammelo tu
[23:36:34] <amosse> 111
[23:36:37] <Stemby> oh
[23:36:42] <Stemby> vedi che hai capito
[23:36:46] <Stemby> +1?
[23:36:56] <Stemby> passi alle migliaia
[23:36:57] <amosse> 1000
[23:36:59] <Stemby> esatto
[23:37:02] <Stemby> chiaro?
[23:37:06] <amosse> ok
[23:37:08] <weirdo> tranquillo, lo scorderai tanto in fretta quanto lo hai imparato
[23:37:22] <Stemby> adesso guarda a cosa corrispondono quei numeri in base 10
[23:37:26] <Stemby> in particolare:
[23:37:27] <Stemby> 1
[23:37:28] <Stemby> 10
[23:37:29] <Stemby> 100
[23:37:30] <Stemby> 1000
[23:37:41] <Stemby> 1 → 1
[23:37:45] <Stemby> 10 → 2
[23:37:49] <Stemby> 100 → 4
[23:37:55] <Stemby> 1000 →
[23:37:57] <Stemby> ?
[23:38:37] <amosse> 11 -> 3
[23:38:46] <Stemby> sì
[23:38:51] <Stemby> 1000 →
[23:38:53] <amosse> ok
[23:38:56] <Stemby> ?
[23:39:21] <amosse> 16
[23:39:26] <Stemby> no
[23:39:30] <Stemby> 8
[23:39:39] <amosse> ok *2
[23:39:43] <Stemby> esatto
[23:40:17] <amosse> quindi
[23:40:27] <Stemby> in pratica la formula per passare da binario a decimale è questa
[23:40:36] <Stemby> 100101010101111001
[23:40:43] <Stemby> non so che numero sia
[23:40:47] <Stemby> comunque si fa così
[23:40:51] <Stemby> si parte da destra
[23:41:01] <Stemby> prima cifra: 1
[23:41:29] <Stemby> la base è 2, quindi 2^0 = 1
[23:41:46] <Stemby> la seconda cifra è 0 → 0
[23:41:52] <Stemby> la terza è 0 → 0
[23:42:01] <Stemby> la quarta è 1
[23:42:24] <Stemby> quindi, 2^3 → 8
[23:42:33] <Stemby> la quinta è 1
[23:42:38] <Stemby> quindi:
[23:42:47] <Stemby> 2^4 → 16
[23:43:01] <Stemby> la sesta è 1
[23:43:16] <Stemby> 2^5 → 32
[23:43:20] <Stemby> eccetera
[23:43:27] <Stemby> poi fai la somma di tutti
[23:43:41] <amosse> scusa, cosa vuol il segno che usi
[23:43:48] <Stemby> 1+0+0+8+16+32+ ....
[23:43:55] <Stemby> elevamento a potenza
[23:44:08] <amosse> ok
[23:44:17] <Stemby> alla 0, alla prima, alla seconda, alla terza, ecc.
[23:44:26] <Stemby> qualsiasi numero elevato alla 0 dà 1
[23:44:34] <Stemby> qualsiasi numero elevato alla 1 dà se stesso
[23:44:35] <amosse> ok
[23:44:49] <Stemby> questo vale per tutte le basi
[23:44:55] <Stemby> (per passare a decimale)
[23:45:19] <Stemby> in base 2 eviti di moltiplicare la cifra per la base elevata alla posizione-1
[23:45:28] <Stemby> perché moltiplicare per 1 è inutile
[23:45:45] <Stemby> quindi ti basta fare l'elevamento a potenza
[23:45:50] <Stemby> per ogni cifra
[23:45:53] <Stemby> ok?
[23:46:00] <amosse> ok
[23:46:02] <Stemby> torniamo al discorso di prima
[23:46:05] <Stemby> 1111111
[23:46:11] <Stemby> trasformamelo in base 10
[23:46:32] <Stemby> partendo da destra:
[23:46:42] <Stemby> 2^0 +
[23:46:50] <Stemby> 2^1 +
[23:46:52] <Stemby> 2^2 +
[23:46:56] <Stemby> 2^3 +
[23:46:58] <Stemby> 2^4 +
[23:47:00] <Stemby> 2^5 +
[23:47:05] <Stemby> 2^6
[23:47:09] <Stemby> ------
[23:47:11] <Stemby> totale?
[23:47:57] <Stemby> 1 + 2 + 4 + 8 + 16 + 32 + 64
[23:48:01] <Stemby> quanto fa?
[23:48:29] <amosse> 127
[23:48:32] <Stemby> ok
[23:48:47] <Stemby> quello è il numero più grande disponibile nella tabella ASCII
[23:48:56] <Stemby> in totale quanti numeri hai a disposizione?
[23:49:22] <amosse> 128
[23:49:25] <Stemby> esatto!
[23:49:33] <Stemby> perché devi aggiungere lo 0
[23:49:37] <Stemby> 0 -- 127
[23:49:45] <Stemby> ottimo
[23:49:59] <amosse> da 0 a 255 / 2
[23:50:10] <Stemby> esatto
[23:50:20] <Stemby> 255 in binario come sarà?
[23:51:03] <amosse> ?
[23:51:17] <Stemby> 255 (base 10) → ? (base 2)
[23:51:34] <Stemby> trasforma 255 in base 2
[23:51:37] <Stemby> :)
[23:51:43] <Stemby> non serve fare conti
[23:51:50] <Stemby> è evidente
[23:52:16] <Stemby> 1111111 → 127
[23:52:26] <Stemby> 255 → ?
[23:53:06] <Stemby> amosse, dai
[23:53:13] <Stemby> non servono conti
[23:53:34] <amosse> 1 per 14 volte
[23:53:39] <Stemby> (è più facile passare da binario a decimale che il contrario)
[23:53:42] <Stemby> no!
[23:53:44] <Stemby> 8
[23:53:47] <Stemby> 8 bit
[23:53:51] <Stemby> 11111111
[23:54:07] <Stemby> infatti
[23:54:21] <Stemby> 127 + 2^7 cosa fa?
[23:54:33] <Stemby> 2^7 → ?
[23:54:52] <Stemby> due alla settima quanto fa?
[23:55:01] <amosse> 128
[23:55:03] <Stemby> esatto
[23:55:12] <Stemby> quella è la cifra che abbiamo aggiunto a sinistra
[23:55:16] <Stemby> (l'ottavo bit)
[23:55:26] <Stemby> gli altri 7 bit sono quelli di prima
[23:55:31] <Stemby> 128 + 127 = ?
[23:55:53] <amosse> 255
[23:55:56] <Stemby> et voilà
[23:56:03] <Stemby> 1111111 → 255
[23:56:14] <Stemby> per un totale di 256 numeri a disposizione
[23:56:19] <Stemby> ok?
[23:56:26] <amosse> si
[23:56:31] <Stemby> sorry
[23:56:36] <Stemby> ho dimenticato un bit
[23:56:42] <Stemby> 11111111 → 255
[23:56:47] <Stemby> ora è giusto
[23:56:51] <Stemby> 8 bit
[23:57:05] <Stemby> tornando alla tabella ASCII
[23:57:12] <Stemby> ha solo 7 bit
[23:57:17] <Stemby> quindi solo 128 numeri
[23:57:26] <Stemby> pochini...
[23:57:43] <Stemby> infatti in pratica permette di contenere solo i caratteri della tastiera americana
[23:57:48] <Stemby> niente accentate
[23:57:59] <Stemby> niente caratteri strani vari
[23:58:01] <Stemby> ok?
[23:58:04] <amosse> ok
[23:58:16] <Stemby> la tabella ASCII è tuttora valida
[23:58:19] <Stemby> ma limitatissima
[23:58:32] <Stemby> (pensa ai caratteri cinesi, tanto per dire)
[23:58:45] <Stemby> sono nate quindi delle estensioni
[23:58:53] <Stemby> a 8 bit
[23:59:15] <Stemby> passare da 7 bit a 8 bit significa raddoppiare i numeri disponibili
[23:59:25] <Stemby> (e dunque i caratteri utilizzabili)
[23:59:31] <amosse> ok
[23:59:45] <Stemby> problema: ASCII è uno standard riconosciuto universalmente
[23:59:53] <Stemby> le varie estensioni a 8 bit molto meno
[23:59:58] <Stemby> ce ne sono numerose
[00:00:00] - {Day changed to gio mag 5 00:00:00 2011}
[00:00:03] <Stemby> nessuna ha il predominio
[00:00:14] <Stemby> da qui nascono i problemi di encoding
[00:00:48] <Stemby> il carattere numero 210 di una certa tabella sarà probabilmente diverso dal 210 di un'altra
[00:00:50] <Stemby> chiaro?
[00:01:08] <amosse> ok
[00:01:13] <Stemby> i primi 128 (da 0 a 127) sono uguali per tutte le tabelle
[00:01:28] <Stemby> da 128 in poi è un caos
[00:01:35] <Stemby> tu scrivi è
[00:01:39] <Stemby> "è"
[00:01:44] <amosse> ok
[00:01:48] <Stemby> una tabella capisce "è"
[00:01:54] <Stemby> un'altra capisce un'altra roba
[00:02:15] <Stemby> UTF-8 è un'ulteriore evoluzione
[00:02:35] <amosse> ok
[00:02:50] <Stemby> http://it.wikipedia.org/wiki/UTF-8
[00:03:02] <Stemby> è uno standard che fa parte di unicode
[00:03:16] <amosse> ok
[00:03:21] <Stemby> è il tentativo più riuscito per cercare di tornare ad avere un'unica tabellona universale
[00:03:29] <Stemby> che contenga tutti i caratteri del mondo
[00:03:50] <Stemby> (e anche molti simboli di fantasia, caratteri di lingue inventate, ecc.)
[00:04:07] <Stemby> 1 byte = 8 bit
[00:04:25] <Stemby> unicode usa da 1 a 4 byte
[00:04:33] <Stemby> (per ogni carattere)
[00:04:37] <Stemby> scusa
[00:04:40] <Stemby> non unicode
[00:04:43] <Stemby> UTF-8
[00:04:47] <Stemby> ok?
[00:04:51] <amosse> ok
[00:05:11] <Stemby> ovviamente tutti i caratteri più importanti saranno nel primo byte
[00:05:12] <amosse> quindi fino a 32 bit
[00:05:17] <Stemby> in pratica sì
[00:05:27] <Stemby> che è un numero impressionante
[00:06:04] <amosse> ma scusa, questo cosa centra con i processori a 32 - 64?
[00:06:14] <amosse> niente
[00:06:53] <Stemby> >>> 2**32
[00:06:53] <Stemby> 4294967296
[00:07:03] <Stemby> hai tutti quei numeri a disposizione
[00:07:19] <Stemby> 4 miliardi e rotti
[00:07:21] <Stemby> :)
[00:07:29] <Stemby> ben altra rova rispetto a 128
[00:07:35] <Stemby> *roba
[00:07:41] <Stemby> dicevo
[00:08:19] <Stemby> le lettere accentate, caratteri tipo →øç eccetera saranno nel primo byte
[00:08:39] <Stemby> per questo non è ancora del tutto sbagliato dire che 1 byte = 1 carattere
[00:08:53] <Stemby> (in ASCII e in ASCII esteso è verissimo, invece)
[00:09:18] <Stemby> però se scrivi in cinese, senz'altro ogni carattere occuperà più di un byte
[00:09:22] <Stemby> non so dirti quanto
[00:09:26] <Stemby> *quanti
[00:09:36] <Stemby> ma sucuramente almeno 2 byte
[00:09:40] <Stemby> *sicuramente
[00:09:46] <Stemby> ok?
[00:09:52] <amosse> ok
[00:10:11] <Stemby> windows di default non usa ancora UTF-8, a quanto ne so
[00:10:41] <amosse> debian?
[00:10:42] <Stemby> (ma non ne sono certo, mi son perso gli ultimi 10 anni di sviluppi)
[00:10:51] <Stemby> debian assolutamente sì
[00:11:17] <amosse> ok
[00:11:27] <Stemby> $ locale
[00:11:27] <Stemby> LANG=it_IT.UTF-8
[00:11:27] <Stemby> LC_CTYPE="it_IT.UTF-8"
[00:11:27] <Stemby> LC_NUMERIC="it_IT.UTF-8"
[00:11:27] <Stemby> LC_TIME="it_IT.UTF-8"
[00:11:27] <Stemby> LC_COLLATE="it_IT.UTF-8"
[00:11:27] <Stemby> LC_MONETARY="it_IT.UTF-8"
[00:11:27] <Stemby> LC_MESSAGES="it_IT.UTF-8"
[00:11:27] <Stemby> LC_PAPER="it_IT.UTF-8"
[00:11:27] <Stemby> LC_NAME="it_IT.UTF-8"
[00:11:27] <Stemby> LC_ADDRESS="it_IT.UTF-8"
[00:11:27] <Stemby> LC_TELEPHONE="it_IT.UTF-8"
[00:11:27] <Stemby> LC_MEASUREMENT="it_IT.UTF-8"
[00:11:27] <Stemby> LC_IDENTIFICATION="it_IT.UTF-8"
[00:11:27] <Stemby> LC_ALL=
[00:11:34] <Stemby> controlla :)
[00:12:12] <Stemby> hai a disposizione una copia di win?
[00:12:28] <amosse> si
[00:12:48] <Stemby> ok
[00:12:54] <Stemby> allora l'esercizio è questo
[00:13:00] <Stemby> scrivi un file di testo in win
[00:13:16] <Stemby> son quasi certo che sarà codificato con una codifica diversa da UTF-8
[00:13:28] <Stemby> file di testo puro, eh, mi raccomando!
[00:13:41] <amosse> notepad
[00:13:44] <Stemby> quindi niente word
[00:13:46] <Stemby> esatto!
[00:13:51] <amosse> ok
[00:13:54] <Stemby> niente OOo, ecc.
[00:14:17] <Stemby> devi usare dei caratteri FUORI dalla tabella ASCII
[00:14:24] <Stemby> altrimenti non serve a niente
[00:14:39] <Stemby> come ti dicevo, per tutte le codifiche i primi 128 caratteri sono uguali
[00:14:47] <amosse> ok
[00:14:52] <Stemby> lettere accentate
[00:14:56] <Stemby> €
[00:15:01] <Stemby> ç
[00:15:05] <Stemby> ecc.
[00:15:17] <amosse> ok
[00:15:19] <Stemby> ovviamente puoi mischiali a caratter ASCII
[00:15:31] <Stemby> l'importante è che non ci siano solo caratteri ASCII
[00:15:39] <amosse> ok
[00:15:52] <Stemby> poi scrivi uno script
[00:16:30] <Stemby> che apra il file, cambi la codifica a UTF-8, e salvi un nuovo file secondo la nuova codifica
[00:16:38] <Stemby> ok?
[00:16:45] <Stemby> cosa ti serve?
[00:16:45] <amosse> ok
[00:16:52] <Stemby> 1) conoscere la codifica usata da win
[00:17:00] <Stemby> (Google è amico)
[00:17:29] <Stemby> 2) direi quasi senz'altro il parametro encoding della funzione open()
[00:17:45] <Stemby> http://docs.python.org/release/3.1.3/library/functions.html#open
[00:18:04] <Stemby> 3) quello che abbiamo appreso la volta scorsa e all'inizio di questa lezione
[00:18:31] <Stemby> ovvero: i metodi degli oggetti di tipo file
[00:18:35] <Stemby> nient'altro
[00:18:52] <Stemby> ok?
[00:19:01] <amosse> ci provo, anche se non é proprio banale
[00:19:10] <Stemby> no è così difficile, secondo me
[00:19:16] <Stemby> *non
[00:19:28] <amosse> provo
[00:19:28] <Stemby> mi aspetto una decina di righe o poco più
[00:19:53] <Stemby> poi il parametro encoding probabilmente non ti servirà mai più
[00:19:53] <amosse> ok
[00:20:08] <amosse> ok
[00:20:12] <Stemby> ma per lo meno avrai capito a fondo cos'è la codifica di un file
[00:20:14] <Stemby> :9
[00:20:20] <Stemby> notte