21:49:11] <Stemby> 'sera
[21:49:20] <Stemby> ciao weirdo
[21:49:45] <weirdo> ciao :)
[21:49:52] <Stemby> ok
[21:50:01] <Stemby> dobbiamo uscire tutti, quindi?
[21:50:11] <amosse> Ciao Stemby
[21:50:16] <Stemby> ciao amosse
[21:50:30] <weirdo> stasera magari, non necessariamente ora
[21:50:35] <weirdo> quando finite
[21:50:42] <Stemby> ok, dai, allora stanotte :)
[21:50:47] <Stemby> alle 3 tutti fuori
[21:50:50] <Stemby> :p
[21:51:10] <amosse> ok
[21:51:46] <Stemby> siamo pochini stasera...
[21:52:18] <amosse> si
[21:52:57] <Stemby> che famo? aspettiamo qualche minuto?
[21:53:02] <Stemby> è già tardino
[21:53:06] <weirdo> è scemato l'entusiasmo o èer via della domenica?
[21:53:20] <weirdo> *è per
[21:53:20] <Stemby> boh
[21:53:55] <Stemby> mercoledì scorso c'erano forse tutti
[21:53:56] <amosse> aspettiamo un po'.. come vuoi
[21:53:58] <weirdo> cambiare giorno magari? la gente la domenica va al mare
[21:54:15] <Stemby> il sabato è peggio
[21:54:23] <amosse> si in effetti da ora in poi
[21:54:23] <weirdo> lunedì e giovedì
[21:54:34] <Stemby> ci pensiamo
[21:54:38] <Stemby> sentiamo anche gli altri
[21:54:44] <amosse> potrebbe esser un'idea
[21:54:53] <weirdo> per carità era solo un'idea, non mi intrometto :)
[21:55:03] <weirdo> passavo di qui per caso e ho visto il canale scaduto
[21:55:15] <Stemby> weirdo: ormai sei qui e ci resti
[21:55:16] <Stemby> :p
[21:55:56] <Stemby> cià, spieghiamo questo beneamato input-output su file
[21:56:54] <Stemby> allora, fino ad ora abbiamo visto come elaborare i dti in molti modi diversi
[21:57:20] <Stemby> resta ancora molto da fare, ma abbiamo già un sacco di strumenti con cui si possono fare tante belle cosucce
[21:57:29] <amosse> ok
[21:57:44] <Stemby> il problema è che l'elaborazione dei dati è solo una fase della programmazione
[21:57:51] <Stemby> (senz'altro la più importante)
[21:58:11] <amosse> file di testo?
[21:58:32] <Stemby> altri passaggi però molto importanti sono però la raccolta di questi dati e la loro restituzione
[21:58:41] <Stemby> al momento come abbiamo fatto?
[21:58:49] <Stemby> *finora
[21:59:01] <amosse> input()
[21:59:17] <amosse> per ricevere i dati
[21:59:21] <Stemby> ok
[21:59:50] <Stemby> e sostanzialmente print() per restituire quelli elaborati
[21:59:53] <Stemby> giusto?
[22:00:02] <amosse> chiaro
[22:00:16] <Stemby> qual è il limite?
[22:00:37] <amosse> dimenzioni?
[22:00:45] <Stemby> beh, indirettamente
[22:00:56] <Stemby> diciamo che questo schema va bene per piccole cose
[22:01:12] <Stemby> l'utente inserisce a manina i dati, e legge i risultati
[22:01:31] <Stemby> ovviamente se i dati sono tanti, il sistema non funziona
[22:01:45] <Stemby> è tutto troppo "labile"
[22:02:02] <Stemby> per questo molto spesso ci si appoggia al disco rigido
[22:02:15] <Stemby> per tenere i dati (voluminosi) da parte
[22:02:24] <amosse> ok
[22:02:29] <Stemby> sia dati grezzi, che dati elaborati
[22:02:48] <Stemby> sul disco rigido i dati possono essere salvati in vari modi
[22:02:58] <Stemby> stasera vediamo il più semplice:
[22:03:09] <Stemby> input/output su file di testo puro
[22:03:12] <Stemby> ok?
[22:03:16] <amosse> ok
[22:04:07] --> spirit (~spirit@Azzurra-C3C291C.104-82-b.business.telecomitalia.it) has joined #debianizzati-corsi
[22:04:08] <Stemby> allora
[22:04:13] <Stemby> ciao spirit
[22:04:20] <spirit> ciao a tutti
[22:04:21] <Stemby> bene arrivato :)
[22:04:26] <Stemby> stiamo iniziando or ora
[22:04:29] <amosse> Ciao spirit
[22:04:32] <spirit> ah bene
[22:04:35] <spirit> ciao
[22:04:40] <Stemby> ho solo fatto una piccola introduzione sull'argomento di stasera
[22:05:00] <Stemby> i giorni scorsi ho dato un'occhiata alla documentazione ufficiale
[22:05:11] <Stemby> le cose migliori le si trovano nel tutorial
[22:05:20] <Stemby> http://docs.python.org/release/3.1.3/tutorial/index.html
[22:06:05] <Stemby> in particolare, come si vede dall'indice generale, capitolo 7
[22:06:26] <Stemby> quello che ci interessa è qui: http://docs.python.org/release/3.1.3/tutorial/inputoutput.html#reading-and-writing-files
[22:06:50] <Stemby> alcuni dettagli forse vi sfuggiranno, al momento
[22:07:05] <Stemby> capirete meglio quando faremo la programmazione orientata agli oggetti
[22:07:16] <Stemby> comunque è relativamente semplice
[22:07:39] <Stemby> anche perché i metodi li abbiamo già trovati con altri oggetti predefiniti
[22:07:43] <Stemby> vi ricordate?
[22:07:49] <Stemby> spirit: cos'è un metodo?
[22:07:54] <amosse> ok
[22:08:32] <Stemby> spirit: ti ricordi?
[22:08:37] <spirit> un attimo
[22:09:35] <spirit> qualcosa appartenente ad una classe..ma non ricordo bene
[22:10:03] <Stemby> :)
[22:10:21] <Stemby> è giusto, ma le classi non le abbiamo ancora fatte
[22:10:37] <Stemby> amosse: in parole semplici?
[22:10:52] <amosse> funzione applicata ad un oggetto?
[22:11:06] <Stemby> sì, più o meno
[22:11:26] <Stemby> è simile ad una funzione, ma agisce SU un oggetto
[22:11:47] <Stemby> spirit: ti ricordi ora?
[22:12:01] <spirit> si
[22:12:09] <Stemby> ne abbiamo visti a bizzeffe, quando abbiamo fatto gli oggetti predefiniti
[22:12:25] <Stemby> spirit: com'è la sintassi generale?
[22:12:55] <spirit> def()
[22:13:12] <Stemby> eh, quello non lo sai ancora fare
[22:13:23] <Stemby> sai scrivere una funzione, non un metodo
[22:13:28] <Stemby> chiedevo invece:
[22:13:40] <Stemby> come si chiama (con che sintassi si chiama) un metodo?
[22:13:54] <Stemby> ti ricordi?
[22:14:12] <Stemby> per chiamare una funzione, semplicemente:
[22:14:15] <Stemby> nomefunzione()
[22:14:19] <Stemby> giusto?
[22:14:25] <Stemby> invece, per chiamare un metodo?
[22:14:58] <Stemby> amosse?
[22:15:18] <amosse> oggetto.metodo()
[22:15:23] <Stemby> esatto
[22:15:30] <Stemby> per fortuna che c'è amosse
[22:15:37] <Stemby> spirit: ti ricordi ora?
[22:15:44] <spirit> si stavo per dirlo
[22:15:54] <spirit> :)
[22:15:54] <Stemby> allora fammi un esempio reale
[22:16:01] <Stemby> di un metodo che ti ricordi
[22:16:17] <Stemby> *della chiamata di un metodo che ti ricordi
[22:17:23] <spirit> nome_metodo = xy
[22:17:28] <Stemby> no
[22:17:37] <Stemby> un metodo predefinito
[22:17:51] <Stemby> uno tra i millemila che sono presenti nella libreria standard
[22:18:30] <Stemby> ad esempio: ti ricordi cos'è una lista?
[22:18:44] <spirit> una sequenza di caratteri
[22:18:49] <Stemby> no...
[22:18:54] <spirit> ah no la stringa
[22:18:58] <Stemby> quella è una stringa
[22:19:00] <Stemby> esatto
[22:19:06] <Stemby> va bene anche una stringa
[22:19:21] <Stemby> ti ricordi un metodo predefinito per le stringhe?
[22:20:07] <Stemby> io pensavo alle liste, perché c'è un metodo che si usa molto spesso
[22:20:20] <spirit> str.format() per esempio?
[22:20:31] <Stemby> sì, quello è un metodo
[22:20:32] <Stemby> ok
[22:20:34] <Stemby> :)
[22:20:42] <Stemby> ti sei salvato in extremis :p
[22:21:08] <Stemby> io pensavo a:
[22:21:13] <Stemby> lst.append()
[22:21:22] <Stemby> direi che è il metodo che si usa più spesso
[22:21:30] <spirit> ricordo si
[22:21:36] <Stemby> oppure, per le stringhe:
[22:21:40] <Stemby> str.split()
[22:22:00] <Stemby> amosse, te ne ricordi qualcun altro?
[22:22:28] <amosse> str.upper()
[22:22:32] <Stemby> ok
[22:22:34] <Stemby> ottimo
[22:22:37] <Stemby> e così via
[22:22:44] <Stemby> ce ne sono a bizzeffe
[22:23:01] <Stemby> diciamo che la cosa più difficile di Python è proprio sapere cosa si ha a disposizione
[22:23:13] <Stemby> perché c'è già _tutto_
[22:23:31] <Stemby> per sapere dove... occorre scartabellare nella doc
[22:23:32] <Stemby> :)
[22:23:37] <amosse> ok
[22:23:50] <Stemby> allora, tornando ai file
[22:24:12] <Stemby> diciamo che tutto ruota attorno all'oggetto che si genera con
[22:24:16] <Stemby> open()
[22:24:19] <Stemby> ok?
[22:24:26] <amosse> ok
[22:24:35] <spirit> (a fine lezione vi indico un tutoria carino fatto dall' università)
[22:24:44] <Stemby> come dicevo, vi sarà più chiaro quando faremo la programmazione orientato agli oggetti
[22:25:01] <Stemby> per il momento prendetelo come se fosse una funzione
[22:25:13] <Stemby> che restituisce un oggetto
[22:25:17] <Stemby> ok?
[22:25:21] <amosse> ok
[22:25:46] <Stemby> come vedete nella doc, questa "funzione" prende 2 parametri
[22:26:09] <Stemby> ricordatevi, e fissatevelo in testa indelebilmente:
[22:26:22] <Stemby> questi due parametri sono due STRINGHE
[22:26:24] <Stemby> ok?
[22:26:37] <amosse> ok
[22:26:50] <Stemby> in questo modo vi ricordate a memoria la sintassi
[22:27:04] <Stemby> il nome della funzione è semplice: open()
[22:27:09] <Stemby> i parametri sono 2
[22:27:14] <Stemby> sono 2 stringhe
[22:27:23] <Stemby> ok?
[22:27:32] <amosse> ok
[22:27:37] <Stemby> spirit?
[22:28:03] <spirit> stavo leggendo il tutorial
[22:28:09] <Stemby> segui me
[22:28:16] <Stemby> poi lo leggerai con calma :=
[22:28:18] <Stemby> :)
[22:28:22] <spirit> ok
[22:28:28] <Stemby> fin lì ci sei?
[22:28:45] <spirit> si
[22:28:49] <Stemby> cosa fa questa funzione?
[22:29:11] <Stemby> (chiamiamola funzione, per questa sera, anche se è improprio)
[22:29:27] <Stemby> abbiamo detto che restituisce un...
[22:29:33] <spirit> oggetto
[22:29:35] <Stemby> ok
[22:29:44] <Stemby> allora vediamo cos'è questo oggetto
[22:29:56] <Stemby> l'oggetto è una modellizzazione del nostro file
[22:30:07] <Stemby> del file che stiamo aprendo
[22:30:28] <Stemby> è una rappresentazione pitonesca del file in questione, ok?
[22:30:39] <amosse> ok
[22:31:04] <Stemby> in altre parole, tutte le operazioni che vengono fatte su questo oggetto, in realtà vengono fatte sul file
[22:31:29] <Stemby> l'oggetto tecnicamente è un oggetto di tipo file
[22:31:37] <Stemby> http://docs.python.org/release/3.1.3/glossary.html#term-file-object
[22:31:51] <Stemby> è un nuovo tipo predefinito
[22:32:07] <Stemby> ne abbiamo già visti tanti: stringhe, liste, dizionari, range, ecc.
[22:32:28] <Stemby> ora aggiungiamo al nostro bagaglio tecnico gli oggetti di tipo file
[22:33:03] <Stemby> aprite la console
[22:33:16] <amosse> ok
[22:33:57] <Stemby> >>> open('/tmp/workfile', 'w')
[22:33:57] <Stemby> <_io.TextIOWrapper name='/tmp/workfile' mode='w' encoding='UTF-8'>
[22:34:02] <Stemby> visto?
[22:34:18] <spirit> si
[22:34:32] <Stemby> vediamo cosa abbiamo fatto
[22:35:01] <Stemby> fate così
[22:35:12] <Stemby> dal terminale di sistema (bash):
[22:35:19] <Stemby> ls /tmp
[22:35:53] <Stemby> vedrete che c'è un file che si chiama workfile
[22:35:56] <Stemby> visto?
[22:36:02] <spirit> si
[22:36:07] <amosse> ok
[22:36:17] <Stemby> quello è il file che abbiamo creato poco fa
[22:36:30] <Stemby> in realtà il contenuto è vuoto
[22:36:36] <Stemby> potete provare, se volete
[22:36:45] <Stemby> cat /tmp/workfile
[22:36:50] <Stemby> (sempre da bash)
[22:37:05] <Stemby> visto?
[22:37:19] <spirit> è vuoto
[22:37:24] <Stemby> esatto
[22:37:27] <Stemby> infatti:
[22:37:30] <Stemby> ls -l /tmp/
[22:37:36] <Stemby> vedrete che occupa 0 byte
[22:37:58] <Stemby> ok?
[22:38:05] <spirit> ok
[22:38:18] <amosse> ok
[22:38:19] <Stemby> bon, allora analizziamo un po' meglio quello che abbiamo digitato
[22:38:32] <Stemby> intanto i 2 parametri
[22:38:41] <Stemby> (le 2 stringhe)
[22:38:50] <Stemby> la prima stringa è chiara, no?
[22:39:01] <amosse> si
[22:39:10] <amosse> scusa
[22:39:31] <amosse> se il file era presente, con lo stesso comando lo aprivo?
[22:39:39] <Stemby> no
[22:39:44] <Stemby> lo vediamo tra un attimo
[22:39:49] <amosse> ok
[22:40:04] <Stemby> intanto, spirit, ti è chiaro il primo parametro?
[22:40:53] <Stemby> spirit... un po' più svelto, per favore, altrimenti impieghiamo le ore
[22:41:02] <Stemby> se non ti è chiaro dillo, che rispiego
[22:41:11] <spirit> si
[22:41:17] <Stemby> ok
[22:41:23] <Stemby> è semplicemente il nome del fine
[22:41:26] <Stemby> *file
[22:41:33] <Stemby> come STRINGA
[22:41:40] <Stemby> (ricordatevi le virgolette)
[22:41:50] <amosse> incluso il percorso
[22:42:03] <Stemby> cosa importante: accetta percorsi sia assoluti che relativi
[22:42:25] <Stemby> quindi se non anteponete il percorso, verrà creato un file nella directory in cui vi trovate
[22:42:40] <amosse> ok
[22:42:40] <Stemby> il concetto di percorso assoluto o relativo è chiaro per tutti?
[22:42:57] <Stemby> amosse?
[22:42:57] <spirit> non tanto
[22:43:12] <Stemby> weirdo: lo vuoi spiegare tu?
[22:43:19] <amosse> meglio rispiegare un attimo
[22:43:30] <Stemby> così mi riposo un attimo
[22:44:16] <Stemby> http://it.wikipedia.org/wiki/Percorso
[22:44:21] <Stemby> lì c'è qualcosa
[22:44:33] <Stemby> ma mi sembra un po' troppo win-centrico
[22:44:37] <Stemby> non che cambi molto
[22:44:44] <Stemby> cià, lo spiego a parole mie
[22:44:49] <Stemby> percorso assoluto:
[22:44:56] <Stemby> su Unix è molto semplice
[22:45:03] <weirdo> :P
[22:45:09] <Stemby> TUTTO il filesistem ha un'origine
[22:45:12] <Stemby> quale?
[22:45:23] <amosse> root
[22:45:27] <Stemby> ("filesystem" è chiaro?)
[22:45:31] <Stemby> amosse: esatto
[22:45:38] <Stemby> /
[22:45:46] <amosse> ok
[22:45:48] <Stemby> quella è l'origine del filesystem
[22:45:57] <Stemby> spirit: ci sei?
[22:46:00] <weirdo> non sono bravo a spiegare le cose
[22:46:02] <spirit> si ci sono
[22:46:16] <Stemby> quello lo sapevi?
[22:46:21] <spirit> si
[22:46:25] <Stemby> ok
[22:46:36] <Stemby> dicevo che su Unix è tutto più semplice proprio per quel motivo
[22:46:52] <Stemby> TUTTI i file di sistema avranno un percorso assoluto che parte da lì
[22:46:55] <Stemby> dalla radice
[22:47:07] <Stemby> non importa fisicamente dove si trovino
[22:47:18] <Stemby> (disco fisso, chiavetta USB, rete, ecc.)
[22:47:45] <Stemby> tutto viene montato in un unico filesystem, che ha appunto questa struttura ad albero che parte dalla radice
[22:48:14] <Stemby> dunque, se vogliamo trovare un file, basta conoscere questo percorso
[22:48:17] <Stemby> esempio:
[22:48:33] <Stemby> /home/pippo/Documenti/TopSecret.txt
[22:48:36] <Stemby> ok?
[22:48:46] <amosse> ok
[22:48:48] <spirit> ok
[22:48:51] <weirdo> mi sarei limitato forse a: prova cat /tmp/workfile e poi prova cd / && cat ../tmp/workfile
[22:48:59] <weirdo> un po' criptico
[22:49:02] <Stemby> :)
[22:49:19] <weirdo> e ho pure sbagliato
[22:49:20] <Stemby> bon, quello è il percorso assoluto
[22:49:39] <weirdo> cat /tmp/workfile e cd /media/ && cat ../tmp/workfile
[22:49:49] <Stemby> il percorso relativo invece, come dice il nome stesso, è un percorso che parte da dove ci si trova
[22:50:21] <amosse> ok
[22:50:36] <Stemby> ad esempio, se ci si trova in /home/pippo/, il percorso relativo del file di prima quale sarà?
[22:51:23] <spirit> /home/pippo/Documenti/TopSecret.txt
[22:51:32] <Stemby> no, quello è il percorso assoluto
[22:51:37] <Stemby> amosse?
[22:52:12] <spirit> cd home
[22:52:17] <Stemby> ?
[22:52:21] <Stemby> sono già lì
[22:52:28] <Stemby> in home/pippo/
[22:52:33] <Stemby> *
[22:52:36] <Stemby> /home/pippo
[22:52:42] <Stemby> ok?
[22:52:57] <amosse> ok
[22:53:04] <Stemby> se io sono l'utente pippo, avrò il prompt fatto così, con ogni probabilità:
[22:53:31] <Stemby> pippo@miamacchina:~$
[22:53:38] <Stemby> giusto?
[22:53:43] <amosse> ok
[22:53:43] <spirit> giusto
[22:53:46] <Stemby> con ~ che significa?
[22:53:57] <amosse> home
[22:54:05] <Stemby> /home/pippo/
[22:54:11] <Stemby> la home dell'utente
[22:54:14] <Stemby> ok?
[22:54:17] <amosse> ok
[22:54:21] <spirit> ok
[22:54:21] <Stemby> bon
[22:54:25] <Stemby> io sono lì
[22:54:32] <Stemby> se faccio
[22:54:34] <Stemby> ls
[22:54:41] <Stemby> vedrò tanti file e cartelle
[22:54:47] <Stemby> tra cui:
[22:54:52] <Stemby> Documenti/
[22:54:54] <Stemby> giusto?
[22:55:00] <amosse> ok
[22:55:01] <spirit> giusto
[22:55:10] <Stemby> e sappiamo che dentro a quella cartella c'è il nosto file
[22:55:18] <Stemby> come lo visualizziamo?
[22:55:40] <spirit> con cat o less file
[22:55:52] <Stemby> fammi l'esempio concreto
[22:55:56] <amosse> il nostro file é in /temp
[22:56:02] <Stemby> il nome del file lo conosci
[22:56:07] <spirit> less /tmp/workfile
[22:56:13] <Stemby> no
[22:56:16] <amosse> non in /home
[22:56:26] <Stemby> il file TopSecret.txt dell'esempio precedente
[22:56:33] <Stemby> (è un file inventato)
[22:56:41] <Stemby> ma ne conoscete il percorso assoluto
[22:56:49] <Stemby> e sapete dove vi trovate
[22:56:50] <spirit> less /home/pippo/Documenti/TopSecret.txt
[22:56:58] <Stemby> ok
[22:57:06] <Stemby> così hai usato il percorso assoluto
[22:57:15] <Stemby> ma si possono risparmiare tanti caratteri
[22:57:16] <Stemby> come?
[22:57:30] <Stemby> ricordatevi: siete in ~
[22:57:38] <Stemby> amosse?
[22:57:49] <weirdo> che pazienza :)
[22:57:59] <amosse> less /Documenti/TopSecret.txt
[22:58:13] <Stemby> no
[22:58:21] <Stemby> se fai così dà errore
[22:58:31] <amosse> less Documenti/TopSecret.txt
[22:58:39] <Stemby> oh
[22:58:41] <Stemby> esatto
[22:58:51] <Stemby> quello è il percorso relativo!
[22:59:00] <spirit> ok
[22:59:09] <Stemby> attenzione a non anteporre la barra
[22:59:17] <amosse> mettiamo che TopSecret é in '/'
[22:59:19] <Stemby> altrimenti avrete il percorso ASSOLUTO
[22:59:30] <amosse> e noi ci troviamo in /home
[22:59:30] <Stemby> amosse: c'è qualcosa che non va
[22:59:48] <Stemby> in i file di testo non bisogna metterli :p
[22:59:50] <Stemby> in /
[23:00:10] <Stemby> però facciamo finta di aver disobbedito a tutte le regole di buonsenso
[23:00:23] <amosse> ok
[23:00:27] <Stemby> e abbiamo: /TopSecret.txt
[23:00:29] <Stemby> ok?
[23:00:38] <spirit> ok
[23:00:41] <amosse> ok
[23:00:45] <weirdo> ok
[23:00:47] <Stemby> un dannatissimo file di testo nella directory root
[23:00:56] <Stemby> e ci troviamo in /home/
[23:01:00] <Stemby> come visualizzarlo?
[23:01:06] <amosse> esatto
[23:01:11] <Stemby> entrano in gioco delle directory speciali
[23:01:15] <Stemby> (vistuali)
[23:01:29] <Stemby> che vedete sempre ogni volta che fate ls
[23:01:32] <Stemby> sono 2
[23:01:36] <Stemby> una si chiama .
[23:01:41] <Stemby> l'altra si chiama ..
[23:01:46] <Stemby> ok?
[23:01:55] <amosse> ok
[23:01:56] <spirit> ok
[23:02:05] <Stemby> . è la dir corrente
[23:02:26] <Stemby> infatti per lanciare uno script che avete reso eseguibile come fate?
[23:02:34] <Stemby> ./mioscript.py
[23:02:36] <Stemby> giusto?
[23:02:41] <amosse> ok
[23:02:41] <Stemby> cosa significa?
[23:03:01] <Stemby> ./ significa proprio "qui"
[23:03:09] <Stemby> la directory corrente
[23:03:26] <amosse> ok
[23:03:29] <Stemby> invece .. che cos'è?
[23:03:37] <Stemby> è la directory precedente
[23:03:44] <amosse> ok
[23:03:51] <Stemby> quella che viene subito prima, partendo da /
[23:04:05] <Stemby> quindi se siamo in /home/pippo/
[23:04:12] <Stemby> ../ sarà /home(
[23:04:17] <Stemby> /home/
[23:04:20] <Stemby> ok?
[23:04:36] <amosse> ok
[23:04:37] <spirit> ok
[23:04:38] <Stemby> se siamo in /home/, ../ sarà /
[23:04:43] <Stemby> infatti:
[23:04:52] <Stemby> andate in ~
[23:04:58] <Stemby> (nella vostra home)
[23:05:05] <Stemby> basta fare:
[23:05:09] <Stemby> cd <invio>
[23:05:11] <Stemby> ok?
[23:05:23] <Stemby> ci siete?
[23:05:35] <spirit> si
[23:05:41] <amosse> quindi per passare alla dir precedente:
[23:05:46] <amosse> ../
[23:05:46] <Stemby> cd ..
[23:06:06] <spirit> ok
[23:06:09] <Stemby> e dove siete finiti?
[23:06:19] <spirit> in home
[23:06:23] <Stemby> esatto
[23:06:26] <Stemby> se fate di nuovo
[23:06:29] <Stemby> cd ..
[23:06:32] <Stemby> ?
[23:06:43] <amosse> '/'
[23:06:47] <Stemby> esatto
[23:06:51] <Stemby> in root
[23:06:55] <Stemby> ok?
[23:06:59] <amosse> ok
[23:07:03] <Stemby> ora torniamo all'esempio di amosse
[23:07:08] <Stemby> siete in /home/
[23:07:13] <Stemby> volete vedere:
[23:07:38] <Stemby> /TopSecret.txt
[23:07:41] <Stemby> come fate?
[23:07:47] <Stemby> (usando il percorso relativo)
[23:08:00] <amosse> ../TopSecret.txt
[23:08:13] <Stemby> cat ../TopSecret.txt
[23:08:17] <amosse> ok
[23:08:18] <Stemby> o less
[23:08:21] <amosse> sorry
[23:08:29] <Stemby> d'accordo?
[23:08:33] <amosse> ok
[23:08:37] <spirit> si
[23:08:40] <Stemby> credevo queste cose fossero assodate
[23:08:55] <amosse> ok
[23:09:02] <weirdo> e invece tornando all'esmpio iniziale del file /tmp/workfile, come ci arrivate da /home/pippo ? :)
[23:09:03] <Stemby> vabbé, un piccolo ripassino di concetti di base sulla nostra shell :)
[23:09:09] <spirit> io no sapevo dei ../
[23:09:26] <amosse> solo per chiarire
[23:09:31] <Stemby> allora:
[23:09:35] <Stemby> percorso assoluto:
[23:09:53] <Stemby> less /tmp/workfile
[23:10:00] <Stemby> percorso relativo:
[23:10:15] <Stemby> less ../../tmp/workfile
[23:10:15] <amosse> cat ../../TopSecret.txt
[23:10:33] <Stemby> ok?
[23:10:42] <amosse> si volevo dire la stessa cosa, ok.
[23:10:42] <spirit> ok
[23:10:49] <Stemby> bon
[23:10:56] <Stemby> ora sapete TUTTO :p
[23:11:21] <Stemby> vantaggi/svantaggi
[23:11:25] <Stemby> pensateci un attimo
[23:12:03] <amosse> percorso assoluto: si digita più testo
[23:12:09] <Stemby> non è detto
[23:12:13] <amosse> ma é più chiaro
[23:12:22] <amosse> é vero
[23:12:29] <Stemby> però è più rigido
[23:12:33] <Stemby> nel senso:
[23:12:55] <Stemby> è più "sicuro" perché non dipende da dove ci si trova al momento
[23:13:20] <Stemby> quindi, ad esempio, per aiutare qualcuno in chat o sul forum, in genere si preferisce usare i percorsi assokuti
[23:13:23] <Stemby> *assoluti
[23:13:46] <Stemby> perché almeno si è sicuri di beccare quei file, ovunque l'utente da aiutare si trovi
[23:14:02] <Stemby> però fate attenzione su python:
[23:14:13] <Stemby> python è nato come linguaggio multipiattaforma
[23:14:24] <Stemby> i percorsi assoluti funzionano su Unix
[23:14:36] <Stemby> ma sono ben diversi dai percorsi assoluti su win
[23:14:52] <Stemby> inceve i percorsi relativi funzionano ovunque allo stesso modo
[23:14:55] <amosse> ok
[23:14:56] <Stemby> ok?
[23:15:11] <amosse> ok
[23:15:12] <Stemby> piccola parentesi
[23:15:24] <Stemby> su win le barre delle directory sono al contrario
[23:15:32] <amosse> si
[23:15:35] <Stemby> C:\dir\altradir
[23:15:39] <Stemby> ok?
[23:15:46] <amosse> ok
[23:15:48] <Stemby> su Unix invece sono diritte
[23:15:53] <Stemby> /root/pippo/
[23:15:58] <amosse> ok
[23:16:05] <spirit> ok
[23:16:15] <Stemby> quando usate i percorsi in python, usate la sintassi Unix
[23:16:25] <amosse> ok
[23:16:35] <Stemby> se il programma viene eseguito su win, penserà python stesso a girare le barre
[23:16:42] <Stemby> ovvero:
[23:16:52] <Stemby> l'interfaccia di programmazione segue lo stile Unix
[23:17:03] <amosse> ok
[23:17:18] <Stemby> poi sarà l'interprete a trovare i file al posto giusto, indipendentemente dal sistema su cui gira
[23:17:28] <Stemby> bon
[23:17:46] <spirit> (io uso solo linux)
[23:17:50] <Stemby> con questo abbiamo esaurito il primo parametro di open()
[23:18:15] <Stemby> spirit: sì, ma non è detto che i tuoi programmi non vengano fatti girare altrove
[23:18:24] <Stemby> su questo bisogna stare molto attenti
[23:18:38] <spirit> vero hai ragione
[23:18:41] <Stemby> tutti noi siamo portati a pensare: chissenefrega degli altri
[23:18:50] <Stemby> che usino Debian anche loro
[23:19:00] <Stemby> però è un atteggiamento a mio avviso sbagliato
[23:19:24] <Stemby> dunque la prima regola del buon pitonista è: scrivi SEMPRE codice multipiattaforma
[23:19:43] <amosse> a tale proposito dove suggerisci di salvare i moduli?
[23:19:44] <Stemby> anche solo per te stesso: è una buona palestra comunque
[23:19:53] <Stemby> dove volete
[23:20:08] <Stemby> al momento comunque in un ramo di /home
[23:20:13] <Stemby> es:
[23:20:23] <Stemby> /home/pippo/python
[23:20:25] <Stemby> oppure
[23:20:33] <Stemby> /home/pippo/script
[23:20:36] <Stemby> oppure
[23:20:47] <Stemby> /home/pippo/prove
[23:20:50] <Stemby> dove vi pare
[23:20:52] <amosse> ok
[23:21:01] <Stemby> solo evitate di sporcare il filesystem
[23:21:11] <Stemby> nella vostra home fate le schifezze che volete
[23:21:20] <Stemby> evitate di andare altrove :)
[23:22:07] <Stemby> poi, per fare le cose per bene, i programmi finiti andrebbero impacchettati
[23:22:29] <Stemby> ma questo è molto lontano ancora :)
[23:22:35] <Stemby> allora
[23:22:41] <Stemby> secondo parametro
[23:23:09] <Stemby> http://docs.python.org/release/3.1.3/library/functions.html#open
[23:23:19] <Stemby> ecco, lì trovate la sintassi completa
[23:23:41] <Stemby> come vedete ci sono molti altri parametri, ma hanno già tutti un valore di default
[23:23:52] <Stemby> il parametro che ci interessa è mode
[23:23:58] <Stemby> (il secondo)
[23:24:08] <Stemby> come vedete ha anc'esso un valore di default
[23:24:10] <Stemby> quale?
[23:24:32] <Stemby> *anch'esso
[23:24:40] <amosse> r
[23:24:54] <Stemby> 'r'
[23:24:58] <Stemby> è una stringa!
[23:25:02] <Stemby> :)
[23:25:05] <Stemby> ok?
[23:25:07] <amosse> sorry
[23:25:12] <Stemby> questo cosa significa?
[23:25:20] <amosse> lettura
[23:25:25] <amosse> solo lettura
[23:25:34] <Stemby> che se non indichiamo il secondo parametro, il file verrà solo letto
[23:25:43] <Stemby> quindi:
[23:25:45] <amosse> ok
[23:25:55] <Stemby> open('pippo.txt', 'r')
[23:26:01] <Stemby> è del tutto equivalente a:
[23:26:12] <Stemby> open('pippo.txt')
[23:26:16] <Stemby> d'accordo?
[23:26:31] <amosse> ok
[23:26:43] <Stemby> agli altri parametri dateci un'occhiata, ma alla fine non li userete mai
[23:26:49] <Stemby> invece il secondo è importante
[23:26:56] <Stemby> guardate la tabellina
[23:26:59] <Stemby> tutto chiaro?
[23:27:19] <Stemby> un attimo
[23:27:33] <Stemby> della tabella, vi interessano in realtà solo le prime 3 righe
[23:27:45] <Stemby> 'r', 'w', 'a'
[23:27:58] <Stemby> le altre possibilità credo che non le userete mai
[23:28:10] <Stemby> o comunque, se vi servissero, sapete dove trovarle
[23:28:13] <Stemby> ok?
[23:28:18] <amosse> ok
[23:28:21] <spirit> ok
[23:28:27] <Stemby> 'r', 'w', 'a' son chiari?
[23:28:54] <amosse> 'a' -> scrive alla file del file?
[23:28:58] <Stemby> esatto
[23:29:04] <amosse> ok
[23:29:07] <Stemby> e come quando in bash si fa >>
[23:29:11] <Stemby> hai presente?
[23:29:21] <Stemby> aggiunge al file
[23:29:33] <amosse> ah
[23:29:47] <Stemby> è come 'w', solo che non cancella il contenuto, se esiste
[23:29:56] <amosse> ok
[23:30:01] <Stemby> aggiunge nuovo contenuto in coda al file
[23:30:10] <Stemby> d'accordo?
[23:30:16] <amosse> ok
[23:30:19] <Stemby> quindi, riassumendo:
[23:30:24] <Stemby> sappiamo aprire un file
[23:30:30] <Stemby> quale funzione si usa?
[23:30:41] <Stemby> (anche la doc la chiama funzione, quindi mi allineo :) )
[23:30:49] <amosse> open()
[23:30:52] <Stemby> esatto
[23:31:06] <Stemby> abbiamo visto che il primo parametro è il percorso
[23:31:23] <Stemby> abbiamo visto il secondo parametro: la modalità di apertura
[23:31:30] <amosse> ok
[23:31:31] <Stemby> lettura o scrittura
[23:31:42] <Stemby> per la scrittura: 'w' o 'a'
[23:31:52] <Stemby> abbiamo visto la differenza tra le 2
[23:32:01] <Stemby> bon, direi che il grosso è fatto
[23:32:08] <Stemby> ora dobbiamo fare un po' di pratica
[23:32:16] <Stemby> tornando al tutorial:
[23:32:54] <Stemby> come vedete come esempio introduttivo dice questo:
[23:32:57] <Stemby> >>> f = open('/tmp/workfile', 'w')
[23:33:00] <Stemby> visto?
[23:33:20] <amosse> ok
[23:33:40] <Stemby> questo perché come dicevo, con open otteniamo un oggetto
[23:34:01] <Stemby> e come tutti gli oggetti, se vogliamo elaborarli spesso conviene raccoglierli in una variabile
[23:34:11] <Stemby> altrimenti, una volta ottenuto, lo si perde
[23:34:13] <Stemby> ok?
[23:34:19] <amosse> ok
[23:34:29] <Stemby> nella prova che abbiamo fatto prima, abbiamo creato un file vuoto
[23:34:41] <Stemby> ora non possiamo fare altro
[23:34:48] <Stemby> peché quell'oggetto è andato perduto
[23:36:04] <amosse> perché perduto...
[23:36:12] <amosse> il file é ancora la
[23:36:18] <Stemby> sì
[23:36:27] <Stemby> ma non hai più loggetto
[23:36:32] <Stemby> è come quando fai:
[23:36:39] <Stemby> >>> 3 + 1
[23:37:05] <amosse> devi ricreare l' oggetto per collegarti al file
[23:37:16] <Stemby> sì
[23:37:21] <Stemby> ma tanto vale farlo subito
[23:37:40] <Stemby> è inutile creare un file vuoto
[23:37:44] <Stemby> no?
[23:37:50] <amosse> chiaro
[23:38:11] <Stemby> bon
[23:38:22] <Stemby> allora
[23:38:29] <Stemby> adesso recupero un file
[23:38:35] <Stemby> e proviamo a giocarci
[23:41:07] <Stemby> http://paste.debian.net/115701/
[23:41:21] <Stemby> credo che i diritti siano scaduti :p
[23:41:24] <Stemby> bon
[23:41:33] <Stemby> salvatelo da qualche parte
[23:41:55] <Stemby> anzi, lo carico su gobby
[23:42:01] <Stemby> poi salvatelo
[23:42:15] <amosse> ok
[23:42:46] <Stemby> salvato?
[23:43:53] <amosse> ok
[23:43:57] <Stemby> spirit?
[23:44:01] <spirit> si, ma non da gobby, che non lo trovo
[23:44:07] <Stemby> ?
[23:44:12] <Stemby> basta salvare
[23:44:22] <Stemby> comuque poco importa
[23:44:25] <spirit> ah trovato..
[23:44:30] <Stemby> basta che tu ce l'abbia
[23:44:51] <spirit> ok
[23:44:52] <Stemby> dante.txt
[23:44:55] <Stemby> ok
[23:45:03] <amosse> ok
[23:45:19] <Stemby> dalla directory in cui si trova il file, accedete all'interfaccia interattiva
[23:45:46] <Stemby> fatto?
[23:46:24] <amosse> ok
[23:46:26] <spirit> si
[23:47:04] <Stemby> bon
[23:47:06] <Stemby> allora
[23:47:32] <Stemby> create un oggetto file che rappresenti il file che avete salvato, in lettura
[23:48:14] <Stemby> fatto?
[23:48:49] <Stemby> spirit?
[23:48:54] <Stemby> amosse?
[23:49:06] <amosse> un min
[23:49:18] <Stemby> è una riga di codice...
[23:50:05] <Stemby> ci siete?
[23:50:21] <spirit> ...
[23:50:21] <amosse> f = open('dante.txt') Traceback (most recent call last): File "<stdin>", line 1, in <module> IOError: [Errno 2] No such file or directory: 'dante.txt'
[23:50:38] <Stemby> non trova il file
[23:50:42] <amosse> eppure il file c'è...
[23:50:47] <Stemby> 1) hai usato un altro nome
[23:51:02] <Stemby> 2) hai lanciato python3 da un'altra directory
[23:51:09] <Stemby> non vedo altre possibilità
[23:51:16] <spirit> a me lo trova
[23:51:38] <amosse> un minuto
[23:51:59] <amosse> in Documenti della mia home ho
[23:52:03] <amosse> dante.txt
[23:52:06] <Stemby> ok
[23:52:08] <Stemby> quindi:
[23:52:15] <Stemby> cd ~/Documenti
[23:52:17] <Stemby> python3
[23:52:25] <amosse> fatto
[23:52:36] <amosse> non capisco
[23:52:45] <Stemby> scusa
[23:52:46] <Stemby> esci
[23:52:49] <Stemby> cd ~/Documenti
[23:52:51] <Stemby> ci sei
[23:52:52] <Stemby> ?
[23:53:20] <amosse> ok
[23:53:20] <amosse> funziona
[23:53:26] <Stemby> oh
[23:53:28] <Stemby> bon
[23:53:33] <Stemby> spirit: chiaro fin qui?
[23:53:44] <Stemby> la sintassi usata da amosse è la più sintetica possibile
[23:53:58] <Stemby> se fate:
[23:54:01] <Stemby> >>> f
[23:54:13] <Stemby> dovreste vedere il vostro oggetto
[23:54:15] <Stemby> giusto?
[23:54:16] <spirit> si
[23:54:26] <amosse> ok
[23:54:35] <Stemby> ricapitolando
[23:54:52] <Stemby> spirit: mi spieghi quella riga di codice?
[23:55:06] <Stemby> f = open('dante.txt')
[23:55:22] <Stemby> ci son tanti concetti in quei pochi caratteri
[23:55:44] <spirit> 1) variabile f
[23:55:53] <Stemby> ok
[23:55:56] <Stemby> =
[23:56:32] <Stemby> assegnazione del valore di un oggetto alla variabile
[23:56:34] <Stemby> ok?
[23:56:45] <spirit> si
[23:56:49] <Stemby> poi, la parte pià succosa, è quella dopo l'=
[23:56:49] <amosse> ok
[23:57:01] <Stemby> spiegamela
[23:57:41] <spirit> poi ci dovrebbe esssere la funzione open con il nostro oggetto
[23:58:00] <Stemby> no, è proprio la funzione open che genera l'oggetto
[23:58:27] <Stemby> <_io.TextIOWrapper name='dante.txt' mode='r' encoding='UTF-8'>
[23:58:38] <spirit> ok (mi spiego male...)
[23:58:45] <Stemby> questo è il prodotto della funzione che abbiamo lanciato
[23:58:56] <Stemby> d'accordo?
[23:59:01] <spirit> si
[23:59:04] <Stemby> poi?
[23:59:11] <Stemby> dimmi 2 parole sui parametri
[23:59:52] <spirit> abbiamo la stringa 'dante.txt' che è l'oggetto
[23:59:57] <Stemby> no
[00:00:00] - {Day changed to lun mag 2 00:00:00 2011}
[00:00:05] <Stemby> non è l'oggetto
[00:00:21] <spirit> è il file
[00:00:22] <Stemby> o meglio, essendo una stringa è sì un oggetto, ma come tutte le cose in python
[00:00:25] <Stemby> esatto
[00:00:30] <Stemby> è il nome del file
[00:00:36] <Stemby> scritto come?
[00:00:45] <Stemby> come percorso...
[00:00:54] <spirit> giusto
[00:00:57] <Stemby> come percorso...
[00:01:00] <Stemby> ...
[00:01:08] <spirit> assoluto
[00:01:11] <Stemby> no!
[00:01:21] <Stemby> relativo!
[00:01:28] <spirit> scusa
[00:01:30] <Stemby> assoluto sarebbe stato:
[00:01:47] <Stemby> '/home/spirit/Documenti/dante.txt'
[00:01:51] <Stemby> o quel che l'è
[00:02:00] <spirit> ok
[00:02:03] <Stemby> ricordati:
[00:02:16] <Stemby> i percorsi assoluti iniziano SEMPRE con una barra
[00:02:21] <Stemby> (almeno su Unix)
[00:02:37] <spirit> ok
[00:02:42] <Stemby> perché bisogna partire dalla radice e risalire l'albero, seguendo i rami corretti
[00:03:10] <Stemby> bon
[00:03:12] <Stemby> poi?
[00:03:17] <Stemby> hai da aggiungere altro?
[00:03:36] <Stemby> <_io.TextIOWrapper name='dante.txt' mode='r' encoding='UTF-8'>
[00:03:38] <spirit> poi il 2° parametro mode = 'r'
[00:03:42] <Stemby> esatto
[00:03:48] <Stemby> non è stato specificato
[00:03:52] <spirit> che ci indica la sola lettura
[00:03:58] <Stemby> esatto
[00:04:09] <Stemby> poi, come vedete, l'encoding è UTF-8
[00:04:17] <Stemby> è lo standard su Debian
[00:04:25] <amosse> ok
[00:04:34] <spirit> che è la codifica giusto?
[00:04:39] <Stemby> fate attenzione ai file provenienti da altri sistemi, che potrebbero essere codificati in altro modo
[00:04:46] <Stemby> sì, esatto
[00:05:11] <Stemby> comunque, di default la codifica è UTF-8
[00:05:26] <Stemby> se vi arrivassero file codificati in modo barbaro:
[00:05:34] <Stemby> 1) ve lo fate rispedire come si deve
[00:05:45] <Stemby> 2) lo convertite in UTF-8
[00:06:08] <amosse> come si convertono in file?
[00:06:12] <Stemby> 3) scrivete un programma che gestisca la codifica del tizio che vi ha mandato il file
[00:06:32] <Stemby> amosse: mah, immagino ci siano degli script
[00:06:42] <Stemby> in ogni caso apri con l'editor che vuoi
[00:07:03] <Stemby> imposti la codifica
[00:07:28] <amosse> ok
[00:07:34] <Stemby> controlli che accenti e caratteri strani siano a posto
[00:07:50] <Stemby> e salvi a questo punto una copia usando questa volta UTF-8 come codifica
[00:07:58] <amosse> ok
[00:08:02] <Stemby> gedit, kate, ecc. fanno tranquillamente questa cosa
[00:08:12] <amosse> ok
[00:08:38] <Stemby> la terza opzione la eviterei
[00:08:53] <Stemby> (credo sia un parametro di open(), se vi interessa)
[00:08:55] <amosse> chiaro
[00:09:09] <Stemby> però sarebbe ora di passare tutti a UTF-8
[00:09:27] <Stemby> quindi appoggerei soprattutto le opzioni 1 e 2
[00:09:29] <Stemby> ok?
[00:09:36] <amosse> ok
[00:10:08] <Stemby> bon, allora giochiamo un po' col nostro oggetto
[00:10:25] <Stemby> come vi dicevo, lo abbiamo tenuto da parte in una variabile
[00:10:41] <Stemby> altrimenti a questo punto sarebbe già morto, e non potremmo più farci niente
[00:10:43] <Stemby> ok?
[00:10:51] <amosse> ok
[00:10:52] <Stemby> f è il nosto oggetto
[00:10:52] <spirit> ok
[00:11:04] <Stemby> possiamo farci un po' di cosucce.
[00:11:18] <Stemby> http://docs.python.org/release/3.1.3/tutorial/inputoutput.html#reading-and-writing-files
[00:11:40] <Stemby> come d'abitudine, abbiamo a disposizione un bel po' di metodi già belli e pronti
[00:11:57] <Stemby> ad esempio il metodo read()
[00:12:10] <Stemby> mi sembra abbastanza autoesplicativo
[00:12:14] <Stemby> provatelo
[00:12:37] <amosse> >>> f.read()
[00:12:44] <Stemby> esatto
[00:12:46] <Stemby> visto?
[00:12:51] <amosse> 'Nel mezzo del cammin di nostra vita\nmi ritrovai per una selva oscura,\nché la diritta via era smarrita.\n'
[00:12:57] <Stemby> esatto
[00:13:02] <amosse> non va a capo
[00:13:10] <Stemby> legge tutto il contenuto del file e lo caccia in una stringa
[00:13:14] <Stemby> sì che va a capo
[00:13:18] <Stemby> a modo suo
[00:13:22] <Stemby> ma va a capo
[00:13:24] <Stemby> leggi bene
[00:13:25] <Stemby> :)
[00:13:32] <amosse> con \n
[00:13:35] <Stemby> esatto
[00:13:45] <Stemby> se fai print(.....)
[00:13:52] <Stemby> vedrai il risultato come vuoi tu
[00:13:53] <amosse> giusto
[00:14:15] <Stemby> però attento
[00:14:20] <Stemby> ora non funziona più
[00:14:27] <amosse> infatti
[00:14:31] <Stemby> perché è arrivato in fondo al file
[00:14:50] <Stemby> se ripeti f.read() vedrai che otterrai una stringa vuota
[00:15:27] <Stemby> dobbiamo riportare il "cursore" all'inizio
[00:15:36] <Stemby> per far questo si usa il metodo seek()
[00:15:36] <amosse> vero
[00:16:01] <Stemby> attenzione che vuole un parametro
[00:16:06] <amosse> oppure ricreo l'oggetto?
[00:16:07] <Stemby> il parametro è un intero
[00:16:12] <Stemby> nooo!!!
[00:16:18] <Stemby> che sprecone!
[00:16:20] <Stemby> :)
[00:16:25] <Stemby> dicevo
[00:16:27] <amosse> ok
[00:16:28] <Stemby> il parametro è un intero
[00:16:50] <Stemby> che rappresenta il byte del file a cui andare
[00:17:00] <amosse> 1 -> riga 1?
[00:17:04] <Stemby> byte
[00:17:07] <Stemby> cos'è un byte?
[00:17:10] <Stemby> ...
[00:17:14] <Stemby> ta dam...
[00:17:32] <Stemby> qui casca il pitonista
[00:17:33] <amosse> un numero int
[00:17:41] <Stemby> in informatica
[00:17:42] <amosse> 0 - 255
[00:17:43] <Stemby> cos'è un byte?
[00:17:59] <amosse> non lo so
[00:18:09] <Stemby> grossolanamente è un carattere
[00:18:27] <Stemby> usando la tabella ascii questo è senz'altro vero
[00:18:43] <Stemby> usando unicode non è proprio così vero
[00:18:51] <Stemby> non sempre, per lo meno
[00:18:53] <Stemby> comunque
[00:19:08] <Stemby> noi dobbiamo tornare a prima della prima lettera
[00:19:10] <Stemby> quindi?
[00:19:23] <spirit> (un byte è formato da 8 bit se non sbaglio)
[00:19:34] <Stemby> quasi sempre sì
[00:19:39] <amosse> f.seek(0)
[00:19:39] <Stemby> scolasticamente sì
[00:19:43] <Stemby> esatto!
[00:19:56] <Stemby> a questo punto possiamo rilanciare read()
[00:20:00] <Stemby> fate delle prove
[00:20:06] <Stemby> con read()
[00:20:14] <Stemby> print(f.read())
[00:20:21] <Stemby> con seek()
[00:20:28] <Stemby> mettendo vari numeri
[00:20:30] <Stemby> ok?
[00:20:40] <Stemby> giocate qualche minuto con questi metodi
[00:20:48] <Stemby> spirit: tu ci sei?
[00:21:04] <spirit> si ci sono
[00:21:37] <spirit> con seek basta un qualsiasi numero'
[00:21:44] <spirit> giusto?
[00:21:46] <Stemby> 0 per tornare all'inizio
[00:21:52] <Stemby> 1 per saltare la prima lettera
[00:22:03] <Stemby> 2 per saltare le prime 2
[00:22:04] <Stemby> ecc.
[00:22:10] <spirit> ok
[00:22:12] <amosse> chiaro
[00:22:27] <Stemby> è come riavvolgere un nastro
[00:22:28] <Stemby> :)
[00:22:45] <amosse> slicing
[00:22:49] <amosse> non esiste
[00:23:06] <amosse> riavvolgo una fetta
[00:23:11] <amosse> ?
[00:23:27] <Stemby> beh, puoi fare tutti gli affettamenti che vuoi sulla stringa che ottieni
[00:23:45] <Stemby> ricordati: read() restituisce una stringa
[00:23:57] <Stemby> poi su quella stringa puoi farci tutto cià che vuoi
[00:24:07] <amosse> ok
[00:24:11] <Stemby> ormai dovreste essere in grado di farci parecchie cosucce
[00:24:26] <Stemby> bon
[00:24:31] <Stemby> altro metodo:
[00:24:49] <Stemby> readline()
[00:24:51] <Stemby> provate
[00:25:32] <Stemby> provate ovviamente a lanciarlo più volte
[00:25:45] <spirit> errore
[00:25:49] <Stemby> quale?
[00:26:04] <spirit> readline(2)
[00:26:08] <spirit> Traceback (most recent call last): File "<stdin>", line 1, in <module>
[00:26:17] <Stemby> senza parametri
[00:27:02] <Stemby> soprattutto: è un metodo
[00:27:05] <Stemby> non una funzione
[00:27:13] <Stemby> altrimenti ovviamente non lo trova
[00:27:25] <Stemby> spirit: ci sei?
[00:27:32] <spirit> readline(2) errore
[00:27:36] <spirit> ops
[00:27:38] <Stemby> è un metodo
[00:27:40] <spirit> da errore
[00:27:42] <Stemby> spirit: ci sei?
[00:27:45] <Stemby> è un metodo
[00:27:46] <Stemby> è un metodo
[00:27:46] <Stemby> è un metodo
[00:27:47] <Stemby> è un metodo
[00:27:48] <Stemby> è un metodo
[00:27:55] <amosse> l'argomento di read() indica il n° del carettere..
[00:27:55] <spirit> ok
[00:28:02] <Stemby> che cos'è un metodo?
[00:28:10] <Stemby> amosse: sì, anche di readline()
[00:28:29] <amosse> >>> f.readline(4)
[00:28:34] <Stemby> oh!
[00:28:39] <amosse> 'Nel '
[00:28:43] <Stemby> esatto
[00:28:46] <Stemby> rilancialo
[00:29:10] <Stemby> magari con un numero un po' più grande
[00:29:14] <Stemby> tipo:
[00:29:20] <Stemby> f.readline(10)
[00:29:24] <Stemby> ok?
[00:29:29] <amosse> ok
[00:29:35] <Stemby> comunque, di solito lo si usa senza parametri
[00:29:39] <Stemby> f.readline()
[00:29:42] <amosse> lette i primi 10 caratteri
[00:29:51] <amosse> *legge
[00:29:55] <Stemby> ...e poi altri 10, se lo rilandi
[00:29:55] <amosse> ok
[00:30:01] <Stemby> *rilanci
[00:30:06] <amosse> ok
[00:30:15] <Stemby> senza parametri restituisce una riga alla volta
[00:30:40] <Stemby> poi, arrivato in fondo al file, come read() restiutuisce una stringa vuota
[00:30:44] <Stemby> seak()
[00:30:49] <Stemby> e riavvolgi :)
[00:30:51] <Stemby> ok?
[00:30:55] <Stemby> provate ancora un po'
[00:30:56] <amosse> chiaro
[00:31:12] <Stemby> con/senza parametri
[00:32:20] <Stemby> spirit: ci sei?
[00:32:29] <spirit> si provavo
[00:32:32] <Stemby> ok
[00:32:36] <Stemby> tutto chiaro?
[00:32:49] <spirit> si credo di si
[00:32:52] <Stemby> ultimo metodo:
[00:32:55] <Stemby> readlines()
[00:32:55] <amosse> ok
[00:33:00] <Stemby> con la s
[00:33:25] <Stemby> chiaro?
[00:33:37] <Stemby> spirit: spiega
[00:33:47] <spirit> spezza
[00:33:48] <Stemby> che cosa fa il metodo readlines()?
[00:33:54] <Stemby> restituisce...
[00:34:03] <Stemby> la...
[00:34:06] <Stemby> l...
[00:34:10] <Stemby> i...
[00:34:10] <spirit> lista
[00:34:15] <Stemby> delle
[00:34:19] <amosse> righe
[00:34:21] <Stemby> ok!
[00:34:23] <Stemby> :)
[00:34:29] <Stemby> tutto chiaro?
[00:34:35] <amosse> una domanda
[00:34:40] <Stemby> arrivati in fondo → lista vuota
[00:34:45] <Stemby> seek()
[00:34:49] <Stemby> e da capo :)
[00:34:59] <Stemby> dimmi amosse
[00:35:09] <amosse> voglio estrapolare i primi 5 caratteri di ogni riga?
[00:35:22] <Stemby> mah, ci son varie soluzioni
[00:35:35] <Stemby> la più banale:
[00:35:54] <Stemby> for line in f.readlines():
[00:36:21] <Stemby> print(line[6])
[00:36:29] <Stemby> o quel che vuoi, al posto di print
[00:36:40] <amosse> ok
[00:36:40] <Stemby> non son sicuro che sia molto efficiente
[00:36:48] <Stemby> comunque senz'altro funziona
[00:37:31] <Stemby> sorry
[00:37:42] <Stemby> print(line[:6])
[00:37:45] <Stemby> ovviamente :)
[00:38:03] <amosse> ok
[00:38:07] <Stemby> anzi
[00:38:10] <Stemby> print(line[:5])
[00:38:20] <Stemby> ok, questo è quello giusto :)
[00:38:46] <Stemby> bon, sulla lettura dei file non c'è molto altro
[00:38:48] <Stemby> provate
[00:39:01] <Stemby> per la scrittura, speravo di fare stasera ma è tardi
[00:39:07] <amosse> ok
[00:39:10] <spirit> ok
[00:39:12] <Stemby> direi che potete provare autonomamente
[00:39:16] <Stemby> seguite il tutorial
[00:39:22] <amosse> ok
[00:39:26] <Stemby> se ci son problemi, vediamo la prossima volta
[00:39:29] <Stemby> ATTENZIONE
[00:39:41] <Stemby> quando scrivete un file che esiste, LO CANCELLATE
[00:39:51] <amosse> ok
[00:39:54] <Stemby> quindi non fate stupidate
[00:40:07] <Stemby> usate solo file che potete buttare senza pensieri
[00:40:14] <amosse> ok
[00:40:33] <Stemby> ok spirit?
[00:40:39] <Stemby> esercitati, mi raccomando
[00:40:42] <spirit> si
[00:40:45] <Stemby> notte
[00:40:54] <amosse> Notte e grazie.
[00:41:05] <spirit> ciao grazie buonanotte
[00:41:18] <amosse> Ciao spirit
[00:41:24] <amosse> Notte.
[00:41:27] <spirit> notte amosse
[00:41:40] <spirit> notte