Accademia:Log 2011 03 23

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