Accademia:Log 2011 03 02

Da Guide@Debianizzati.Org.

[21:52:27] <GipPasso> Salve
[21:52:39] <GipPasso> Scusate il ritardo.
[21:52:43] <spirit> Ciao
[21:52:48] <JumX> ciao GipPasso
[21:52:54] <amosse> ciao GipPasso
[21:53:15] <GipPasso> Non so se qualcuno frequenta il canale #python qui su azzurra.
[21:53:42] <GipPasso> Si parla piuttosto poco di python.
[21:53:53] <JumX> io sto vedendo adesso
[21:53:58] <amosse> esiste un canale python?
[21:54:11] <spirit> non sapevo..
[21:54:12] <GipPasso> Azzurra mi sembra complessivamente poco vivo.
[21:54:23] <GipPasso> Rispetto a freenode o simili. Oggi ho faticato a connettermi.
[21:54:32] <risca> eccomi
[21:54:36] <risca> come va?
[21:54:41] <risca> casa avete fatto per ora?
[21:54:47] <GipPasso> Ieri ho fallito tutto il giorno (su crypto.azzurra.org perché ero in un wifi libero e non volevo autenticarmi in chiaro)
[21:55:11] <GipPasso> risca: ciao. Io sono arrivato or ora. Ho visto silenzio e parlavo del tempo (su Azzurra)
[21:55:35] <risca> ottimo, siamo di nuovo una decina
[21:55:47] <spirit> del libro il cap. 4
[21:55:55] <risca> nessun nuovo script per oggi, purtroppo... Giusto?
[21:56:05] <Ernestus> non sapevo esistesse il canale e non credevo si parlasse poco
[21:56:08] <Ernestus> ha poco senso, direi
[21:56:50] <GipPasso> Con la fatica che faccio tutti i gioni per connettermi ad azzurra non mi stupisco che ci siano poche persone.
[21:56:51] <risca> avete visto i capitoli 3 e 4 del libro?
[21:56:58] <GipPasso> Mai prima del terzo tentavivo.
[21:57:05] <GipPasso> Qualche mese fa non era così.
[21:57:07] <amosse> si
[21:57:33] <spirit> si
[21:57:45] <risca> dubbi o curiosità in merito?
[21:58:34] <spirit> io in merito allo script 'Guess the Number', si
[21:58:45] <risca> direi di affrontare questo
[21:58:58] <risca> dato che il 3 è a dir poco banale, giusto?
[21:59:10] <spirit> si
[21:59:20] <amosse> ok
[21:59:32] <risca> dicci spirit
[21:59:51] <spirit> allora
[22:00:13] <spirit> riga 30
[22:00:33] <spirit> anzi 29 e 30
[22:01:14] <risca> cosa c'è di strano?
[22:01:23] <risca> la puoi copiare qui?
[22:01:48] <spirit> l'ho tradotto in italiano per capirlo meglio
[22:01:56] <spirit> incollo questo
[22:01:59] <risca> ok
[22:02:25] <spirit> riga 29 - indovinello == str(indovinello)
[22:02:51] <spirit> riga 30 - print('Ben fatto, ' + mioNome + '! Hai indovinato il mio numero in ' + indovinello + ' ipotesi!')
[22:03:02] <spirit> mi da errore
[22:03:27] <risca> la correzione è:
[22:03:27] <spirit> print('Ben fatto, ' + mioNome + '! Hai indoin ' + indovinello + ' ipotesi!')
[22:03:37] <spirit> ops
[22:03:48] <risca> indovinello = str(indovinello)
[22:04:11] <risca> non deve essere una uguaglianza ma una assegnazione di valore
[22:04:35] <spirit> cioè?
[22:04:39] <risca> in pratica trasformi in numero "indovinello" nella stringa "indovinello"
[22:04:54] <risca> infatti non puoi concatenare numeri e testo, ma puoi
[22:05:02] <risca> concatenare solo testo con testo
[22:05:31] <risca> >>> 'testo' + 'testo'
[22:05:31] <risca> 'testotesto'
[22:05:31] <risca> >>> 'testo' + 2
[22:05:31] <risca> Traceback (most recent call last): File "<stdin>", line 1, in <module>
[22:05:33] <risca> TypeError: Can't convert 'int' object to str implicitly
[22:05:47] <spirit> si proprio quello
[22:06:00] <risca> chiaro adesso?
[22:06:08] <risca> basta trasformare il numero in testo
[22:06:15] <spirit> penso di si..
[22:06:20] <risca> >>> 'testo' + '2'
[22:06:22] <risca> 'testo2'
[22:06:58] <risca> altri dubbi su questo script?
[22:07:18] <amosse> con format() non esiste il problema stringhe + interi?
[22:07:21] <spirit> io no solo questo ora provo a corregere, graie
[22:07:30] <spirit> *grazie
[22:07:43] <risca> no, siccome il tutto viene gestito dal format
[22:07:59] <Ernestus> random.randint vale anche coi float?
[22:08:12] <Ernestus> random.randint(4.5, 8)
[22:08:30] <risca> sì
[22:08:40] <risca> solo testo con testo si concatena
[22:08:42] <Ernestus> un attimo che provo da terminale
[22:09:22] <risca> Ernestus, però c'è un problema in quello che hai scritto
[22:09:24] <risca> random.randint(4.5, 8)
[22:09:38] <risca> trova un po' il link del modulo 'random'
[22:09:53] <Ernestus> non ho capito...
[22:10:38] <risca> la funzione random.randint(4.5, 8) ha argomenti sbagliati
[22:10:42] <risca> o sbaglio?
[22:10:55] <Ernestus> hai ragione
[22:11:05] <risca> cerca su internet il link alla pagina della documentazione per chiarire meglio
[22:12:12] <risca> intanto facciamo un po' il punto della situazione
[22:12:20] <Ernestus> dov'eravamo arrivati
[22:12:22] <Ernestus> capitolo 4?
[22:12:26] <risca> cosa ci ricordiamo delle scorse lezioni?
[22:12:31] <risca> (SÌ)
[22:12:56] <risca> proviamo a fare un elenco di tutto ciò che abbiamo fatto fino ad ora, va bene?
[22:13:06] <amosse> ok
[22:13:11] <Ernestus> http://docs.python.org/release/3.1.3/tutorial/controlflow.html#
[22:13:27] <risca> procediamo così
[22:13:44] <risca> a turno ognu scrive un operatore, oggetto, ... che abbiamo visto
[22:13:47] <risca> inizio io
[22:13:48] <risca> import
[22:14:02] <Ernestus> def
[22:14:07] <risca> (quando non vi ricordate a cosa serve chiedete)
[22:14:08] <JumX> int
[22:14:14] <risca> if
[22:14:23] <Ernestus> is
[22:14:27] <spirit> break
[22:14:30] <amosse> and
[22:14:36] <amosse> or
[22:14:38] <risca> for
[22:14:39] <Ernestus> while
[22:14:46] <amosse> not
[22:14:49] <risca> exit()
[22:14:50] <spirit> in
[22:14:57] <Ernestus> ==
[22:15:03] <JumX> !=
[22:15:08] <spirit> input()
[22:15:10] <JumX> <
[22:15:11] <JumX> >
[22:15:14] <risca> +=
[22:15:17] <Ernestus> int()
[22:15:17] <amosse> <=
[22:15:22] <amosse> >=
[22:15:27] <Ernestus> str()
[22:15:29] <risca> -=
[22:15:33] <JumX> /
[22:15:38] <JumX> %
[22:15:39] <Ernestus> *
[22:15:40] <JumX> /
[22:15:55] <amosse> /
[22:15:55] <amosse> /
[22:16:08] <risca> **
[22:16:19] <amosse> pow()
[22:16:28] <Ernestus> pow cosa serviva?
[22:16:33] <Ernestus> *a cosa
[22:16:37] <amosse> elevare alla potenza
[22:16:49] <risca> grazie del chiarimento
[22:16:55] <spirit> print('')
[22:17:02] <risca> format()
[22:17:04] <Ernestus> grazie
[22:17:15] <amosse> divmod()
[22:17:19] <risca> from
[22:17:21] <amosse> abs()
[22:17:22] <Ernestus> divmod cosa serve?
[22:17:35] <risca> DIVisione MODulo?
[22:17:44] <amosse> dati due argomenti, ritorna la divisione ed il resto
[22:17:54] <Ernestus> invece from?
[22:18:03] <risca> from sys import argv
[22:18:14] <risca> permette di importare solo una funzione da un modulo
[22:18:26] <Ernestus> non ho presente, devo spulciare la documentazione
[22:18:28] <risca> nell'esempio è sufficiente argv invece di sys.argv
[22:18:53] <risca> più chiaro adesso?
[22:19:25] <amosse> with
[22:19:44] <risca> "testo"
[22:19:49] <amosse> puç essere utilizzato in un ciclo?
[22:19:53] <risca> """Testo"""
[22:20:03] <risca> amosse: esempio?
[22:20:27] <amosse> with a in amos:
[22:20:36] <amosse> ect
[22:20:54] <risca> ho un dubbio
[22:20:59] <risca> vediamo la documentazione
[22:21:34] <Ernestus> meglio
[22:21:43] <risca> cerchiamo...
[22:23:21] <amosse> http://docs.python.org/release/3.1.3/reference/compound_stmts.html#the-with-statement
[22:23:23] <risca> qui c'è qualcosa (non quello che cercavo però) http://www.python.org/dev/peps/pep-0343/
[22:24:09] <risca> sto leggendo, voi ci capite qualcosa?
[22:24:38] <amosse> ?
[22:24:44] <amosse> é da leggere bene
[22:26:14] <risca> sembrerebbe una scorciatoia per try ... except ... finally
[22:26:26] <risca> ve lo ricordate questo? try ... except ... finally
[22:26:46] <Ernestus> no
[22:26:54] <Ernestus> non c'ero quella volta
[22:26:55] <amosse> no
[22:27:34] <risca> allora propongo di lasciare stare un attimo questi e di riprenderli alla fine del ripassono
[22:27:38] <risca> ripassone*
[22:27:55] <risca> cos'altro ci siamo dimenticati di python?
[22:28:09] <Ernestus> operatori booleani?
[22:28:12] <nodo> range() :)
[22:28:41] <risca> 'testo'
[22:29:35] <risca> "testo %s, numero %d, variabile grezza %r" % ('testo', 3, bho)
[22:30:16] <risca> a me non viene in mente altro, a voi?
[22:30:27] <amosse> no
[22:30:43] <spirit> variabile grezza %r ? che significa?
[22:30:44] <amosse> slicing, ma non se eé stato fatto...
[22:31:11] <-- JumX (~Mibbit@Azzurra=5829E668.247-95-r.retail.telecomitalia.it) has quit (Quit: http://www.mibbit.com ajax IRC Client)
[22:31:30] <risca> lo slicing possiamo vederlo a breve
[22:31:50] <risca> %r, prende il valore della variabile qualunque esso sia
[22:31:55] <risca> fate una prova su shell
[22:32:24] --> JumX (~Mibbit@Azzurra=5829E668.247-95-r.retail.telecomitalia.it) has joined #debianizzati-corsi
[22:32:29] <risca> >>> "  dvwe f  %r d " % 3
[22:32:29] <risca> '  dvwe f  3 d '
[22:32:29] <risca> >>> "  dvwe f  %r d " % '3'
[22:32:30] <risca> "  dvwe f  '3' d "
[22:32:56] <risca> proviamo ad andare di slicing?
[22:33:08] <nodo> scusate io scappo.. ciao a tutti buona lezione
[22:33:15] <JumX> Scusate ma stasera ho un po di problemi.
[22:33:20] <-- nodo (~andrea@Azzurra=D09CA7B.6-79-r.retail.telecomitalia.it) has quit (Quit: Sto andando via)
[22:33:23] <risca> ok
[22:33:26] <risca> alla prossima
[22:33:29] <amosse> ciao
[22:33:53] <spirit> ciao
[22:34:11] <risca> apriamo anche gobby così gli esempi sono più immediati
[22:34:24] <amosse> canale?
[22:34:50] <risca> il solito
[22:35:00] <GipPasso> Una cosa non capisco di %r:
[22:35:11] <risca> stemby(punto)dyndns(punto) org
[22:35:19] <GipPasso> "  dvwe f  %r d " % "3"
[22:35:34] <GipPasso> dà: "  dvwe f  '3' d "
[22:35:37] <risca> GipPasso?
[22:36:02] <risca> quindi?
[22:36:15] <GipPasso> Sa che avendo iniziato con " per esrimere la stringa "3" che si passa alla fine converte le " date alla stringa in '.
[22:36:59] <risca> per python non c'è differenza tra " e '
[22:37:27] <risca> però, dato che r importa la variabile così com'è, ti evidenza con ' che si tratta di testo
[22:37:33] <GipPasso> Lo so, ma pensavo le trattasse come parti del valore.
[22:37:42] <GipPasso> Niente, mie riflessioni sui valori raw.
[22:37:51] <GipPasso> Esatto.
[22:37:54] <risca> >>> '  dvwe f  %r d ' % '3'
[22:37:54] <risca> "  dvwe f  '3' d "
[22:37:54] <risca> >>> '  dvwe f  %r d ' % "3"
[22:37:54] <risca> "  dvwe f  '3' d "
[22:38:01] <risca> qualche altro esempio
[22:38:10] <risca> cambiano gli apici ma non la sostanza
[22:38:43] <risca> ragazzi, adesso vi faccio a pezzi!
[22:39:43] <risca> vediamo un po' cos'è lo slicing
[22:40:11] <risca> chi mi ritira fuori il link di prima?
[22:40:52] <Ernestus> ra ho un po di problemi.
[22:40:52] <Ernestus> * nodo è uscito (Quit: Sto andando via)
[22:40:52] <Ernestus> <risca> ok
[22:40:52] <Ernestus> <risca> alla prossima
[22:40:52] <Ernestus> <amosse> ciao
[22:40:53] <Ernestus> <spirit> ciao
[22:40:54] <Ernestus> <risca> apriamo anche gobby così gli esempi sono più immediati
[22:40:56] <Ernestus> <amosse> canale?
[22:41:06] <spirit> ciao ernestus
[22:41:11] <Ernestus> no scusate
[22:41:16] <Ernestus> il copia e incolla
[22:41:20] <Ernestus> è impazzito
[22:41:26] <spirit> ah
[22:41:38] <amosse> ciao
[22:41:38] <Ernestus> http://docs.python.org/release/3.1.3/reference/compound_stmts.html#the-with-statement
[22:41:43] <Ernestus> questo era il link?
[22:41:54] <Ernestus> (anzichè incollare il link, aveva incollato un pezzo di irc)
[22:42:02] <risca> cercavo qualcosa di specifico sullo slicing
[22:42:22] <amosse> stemby.dyndns.org
[22:42:50] <risca> sì
[22:43:13] <risca> guardate un po' il file slicing
[22:44:02] <spirit> slice=affettare
[22:44:18] <Ernestus> slice = fetta
[22:44:21] <Ernestus> LoL
[22:44:28] <|Wolf|> hello
[22:44:29] <spirit> era slicing
[22:44:35] <Ernestus> ciao |Wolf|
[22:45:24] <risca> giusto
[22:45:33] <risca> visto l'esempio su gobby?
[22:45:42] <JumX> si
[22:45:44] <amosse> si
[22:46:01] <spirit> si
[22:46:08] <risca> vediamo di analizzare meglio lo slicing
[22:46:17] <risca> cosa succede se tolgo i :?
[22:46:45] <risca> scrivete su gobby l'output
[22:47:15] <risca> allora?
[22:47:24] <risca> chi scrive "maestra"[3]
[22:47:25] <JumX> da la lettera centrale
[22:47:34] <JumX> s
[22:47:47] <risca> e il [4]?
[22:48:18] <JumX> pensavo togliesse tre davanti e tre dietro .
[22:48:29] <risca> no, è molto più semplice
[22:48:38] <risca> indica la posizione nella stringa
[22:48:43] <risca> [0] -> m
[22:48:49] <risca> [1] -> a
[22:48:54] <risca> [2] -> e
[22:48:54] <risca> ...
[22:48:57] <risca> chiaro?
[22:49:02] <Ernestus> si
[22:49:08] <amosse> ok
[22:49:10] <JumX> si
[22:49:11] <spirit> si
[22:49:35] <risca> ora però c'è un problema, come indichiamo l'ultima lettera se non sappiamo la lunghezza della stringa?
[22:50:02] <risca> ...
[22:50:03] <amosse> 'maestra'[-1]
[22:50:07] <risca> giusto!
[22:50:23] <risca> con il - si inizia a contare da dx
[22:50:54] <risca> adesso andiamo un po' avanti
[22:51:08] <risca> se volessimo la 2nda e la 3a lettera?
[22:51:26] <Ernestus> [2:3]
[22:51:29] <Ernestus> ?
[22:51:32] <risca> quasi
[22:51:39] <risca> prova un po' sulla shell
[22:51:41] <amosse> [1:2]
[22:51:44] <risca> quasi
[22:51:48] <risca> prova sulla shell
[22:51:57] <spirit> [1:3]
[22:52:03] <amosse> [1:3]
[22:52:08] <risca> giusto
[22:52:23] <risca> prendi dalla 1 fino alla (esclusa) 3
[22:52:39] <risca> se volessi sempre la 'ae', ma contando da dx?
[22:53:27] <risca> nessuno?
[22:53:51] <amosse> [-3:-1]
[22:53:52] <JumX> [1:-5]
[22:54:31] <risca> provate un po...
[22:55:06] <JumX> "maestra"[1:-4]
[22:55:22] <JumX> avevo sbagliato a contare
[22:55:32] <risca> JumX, ma 1 è a contare da sx, non da dx...
[22:56:26] <risca> allora?
[22:56:30] <JumX> si per la a conto da sx per l e da dx
[22:56:48] <JumX> il risultato è quello
[22:56:55] <risca> >>> len('maestra')
[22:56:55] <risca> 7
[22:56:55] <risca> >>> 7 - 1
[22:56:55] <risca> 6
[22:56:55] <risca> >>> 7 - 3
[22:56:58] <risca> 4
[22:57:00] <risca> >>> 'maestra'[-6:-4]
[22:57:03] <risca> 'ae'
[22:57:05] <risca> >>> 'maestra'[-6]
[22:57:08] <risca> 'a'
[22:57:10] <risca> >>> 'maestra'[-4]
[22:57:13] <risca> 's'
[22:57:15] <risca> contanto per entrambi da dx è [-6:-4]
[22:57:27] <risca> guardate un attimo su gobby
[22:57:31] <risca> come vedete
[22:57:58] <risca> la A è la seconda (quindi uno siccome in python si parte a contare da 0) lettera da sx
[22:58:15] <risca> ed è allo stesso tempo la sestultima lettera
[22:58:33] <risca> non importa come io le indico, basta che io dica
[22:58:44] <risca> di prendere dalla A alla S esclusa
[22:58:52] <risca> sia contando da dx che da sx
[22:59:19] <risca> chiaro?
[22:59:41] <Ernestus> si
[22:59:50] <amosse> si
[22:59:57] <spirit> ok
[23:00:00] <JumX> si
[23:00:15] <risca> quindi, giusto per esercizio, se io volessi la 'str'?
[23:00:36] <risca> (aiutatevi con gobby)
[23:00:54] <risca> (si può scrivere in 4 modi diversi)
[23:01:29] <risca> ragazzi?
[23:01:46] <Ernestus> come stringa?
[23:01:46] <amosse> quale striga?
[23:01:54] <risca> ops...
[23:01:57] <spirit> str('maestra')
[23:01:57] <JumX> "maestra"[-4:-1]
[23:02:09] <risca> di 'maeSTRa' datemi la 'str'
[23:02:20] <risca> ottimo JumX
[23:02:23] <Ernestus> ma maestra è già una string
[23:02:45] <risca> Ernestus, le lettere s, t ed r di maestra!
[23:03:14] <risca> cosa ne dite anche di "maestra"[3:6]?
[23:03:26] <Ernestus> giusto
[23:03:44] <risca> e se contassi per una da dx e per l'altra da sx?
[23:03:51] <risca> Ernastus, come sarebbe?
[23:04:13] <Ernestus> sempre str?
[23:04:37] <risca> sì
[23:04:38] <Ernestus> "maestra"[3: -2]
[23:04:44] <risca> ottimo
[23:04:51] <risca> come vedete è facile
[23:04:55] <JumX> In un'esempio concreto a cosa potrebbe servire quesa "affettazione"
[23:05:10] <Ernestus> per un completamento?
[23:05:15] <risca> la posizione possimo indicarla anche con variabili o operazioni
[23:05:44] <risca> esempi concreti non mi vengono in mente, però a volte è molto utile
[23:05:54] <JumX> ok
[23:05:56] <risca> pensate magari ad avere "nome cognome"
[23:06:03] <risca> e dovete dividerli
[23:06:09] <risca> ecco come fare
[23:06:37] <JumX> si infatti stavo pensando proprio a questo grazie risca
[23:06:49] <risca> proviamo a farlo
[23:07:00] <risca> abbiamo un elenco di nomi e dividiamoli
[23:07:04] <Ernestus> "Giancarlo Rossi"[0:8]
[23:07:23] <Ernestus> "Giancarlo Rossi"[10:-1]
[23:07:36] <risca> sì, però i nomi non sono sempre di 0 caratteri, o sbaglio?
[23:08:08] <Ernestus> intendi il primo zero?
[23:08:08] <JumX> si ma si dovrebbe conoscere dov'è lo spazio
[23:08:15] <risca> giusto
[23:08:23] <risca> come facciamo a trovare lo spazio=?
[23:08:41] <JumX> ==' '
[23:09:00] <risca> idea molto succulente
[23:09:08] <JumX> :D
[23:09:12] <risca> (esiste un modo più semplice ma lo analizziamo dopo)
[23:09:23] <risca> proviamo a scrivere la funzione su gobby
[23:09:24] <risca> ok?
[23:09:40] <risca> creato file 'dividi-nomi'
[23:10:11] <risca> chi mi aiuta?
[23:11:22] <risca> idee?
[23:11:38] <spirit> con sep()
[23:11:52] <risca> troppo facile
[23:12:08] <risca> usiamo solo if, ==, e lo slicing
[23:12:12] <risca> ok?
[23:12:36] <Ernestus> vediamo
[23:13:06] <risca> vai ernestus
[23:14:32] <risca> servono suggerimenti?
[23:15:34] <Ernestus> sto pensando
[23:15:50] <amosse> ma come si fa a dividere in nome + cognome con un solo argomento passato alla funzione?
[23:16:16] <risca> l'unico argomento di cui abbiamo bisogno è la stringa 'nome cognome'
[23:16:27] <risca> tutti gli altri parametri sono frutto del nostro algoritmo
[23:16:47] <Ernestus> non ho idee
[23:16:56] <risca> scritto qualcosa, vi sta dando suggerimenti?
[23:17:28] <Ernestus> cosa serve la funzione len()?
[23:17:41] <JumX> per verificare la  lunghezza
[23:17:54] <risca> giusto
[23:18:01] <JumX> ma non credo serva
[23:18:07] <risca> così sappiamo con quanti caratteri abbiamo a che fare
[23:18:31] <JumX> perchè a prescindere dalla lunghezza dobbiamo trovare il punto di rottura in questo caso lo spazio
[23:18:40] <Ernestus> == " "
[23:18:44] <risca> JumX, in effetti se ne potrebbe fare a meno, ma è più arzigogolato
[23:18:53] <risca> Ernestus, ficcalo dentro
[23:19:03] <JumX> scusate ho sbagliato volevo dire che serve la lunghezza
[23:19:17] <risca> ok
[23:19:22] <Ernestus> giusto?
[23:19:26] <risca> giusto
[23:19:42] <Ernestus> a cosa servono i ----?
[23:19:42] <risca> la variabile di controllo quale è?
[23:19:49] <risca> (da completare)
[23:19:59] <Ernestus> name
[23:20:13] <risca> name è una stringa
[23:20:18] <JumX> spazio==' '
[23:20:26] <risca> non si può utilizzare
[23:20:39] <risca> spazio? e da dove salta fuori?
[23:20:53] <risca> JumX, prova, magari è un buon suggerimento
[23:21:22] --> groll (~groll@Azzurra-346C1E27.48-151.net24.it) has joined #debianizzati-corsi
[23:21:23] <risca> ottimo amosse
[23:21:41] <risca> Ernestus, hai dementicato un '=' !
[23:21:51] <groll> sera (lol mi collego a caso e vi becco sempre durante una lezione)
[23:22:11] <risca> ciao groll
[23:22:17] <risca> stiamo lavorando anche su gobby
[23:22:27] <amosse> ciao groll
[23:22:34] <risca> ragioniamo un attimo
[23:22:49] <risca> con il ciclo appena creato cosa dovremmo fare?
[23:23:27] <amosse> ma non é meglio for<?
[23:23:35] <risca> dovremmo verificare quale, dei caratteri che compongono la variabile (tipo script) name sono uguali allo spazio
[23:23:53] <Ernestus> name==" "
[23:24:02] <risca> no, name è tutta la stringa
[23:24:13] <risca> noi dobbiamo analizzare solo una lettera della stringa
[23:24:22] <risca> vi dice nulla slicing?
[23:24:22] <Ernestus> slicing
[23:24:30] <Ernestus> ci stavo pensando dapprima
[23:24:42] <risca> amosse: sì, potremmo usare anche un for i in range ...
[23:24:45] <risca> modifichi tu?
[23:25:01] <risca> Ernestus, quindi come la scriveresti l'uguaglianza?
[23:25:27] <Ernestus> mm
[23:25:27] <risca> (se altri hanno aiuti non esitino a scrivere)
[23:25:45] <risca> cosa ti turba ernestus?
[23:26:09] <Ernestus> non ho idea di cosa scrivere
[23:26:25] <Ernestus> stavo pensando: se da 0 a fine parola c'è uno spazio, dividi
[23:26:52] <risca> pensa per singola lettera...
[23:26:55] <risca> >>> for i in range(1,4):
[23:26:55] <risca> ...   print('maestr'[i])
[23:26:55] <risca> ...
[23:26:55] <risca> a
[23:26:55] <risca> e
[23:26:57] <risca> s
[23:27:03] <risca> chiaro adesso?
[23:27:28] <risca> (quello che dici è pur sempre fattibile, infatti esistono sia la funzione find che sed, poi proviamo)
[23:28:52] <Ernestus> il costrutto for dove differisce da while?
[23:29:23] <Stemby> buonasera
[23:29:23] <groll> Ernestus: è più rapido, elegante e leggibile
[23:29:25] <risca> già modificato su gobby
[23:29:33] <risca> all'atto pratico nulla cambia
[23:29:37] <risca> ciao Stemby
[23:29:41] <Stemby> scusatemi, ma stasera il vostro docente è in malattia... dannazione
[23:29:49] <risca> li sto facendo a pezzetti
[23:29:50] <amosse> ciao Stamby
[23:29:54] <Stemby> come ve la state cavando?
[23:30:05] <Ernestus> se volessi scriverlo col while?
[23:30:06] <spirit> ciao
[23:30:11] <Stemby> (adesso cerco di aggiornarmi)
[23:30:13] <risca> Ernestus: perchè [0: ?
[23:30:22] <risca> vi propongo la mia soluzione
[23:30:27] <risca> guardate un po'
[23:30:30] <Ernestus> risca, era quello che cercavo di fare
[23:30:56] <risca> ti ho preceduto
[23:31:13] <risca> ora dobbiamo affettare
[23:31:16] <risca> giusto?
[23:31:47] <risca> continuate voi?
[23:32:09] <Ernestus> un momento
[23:32:21] <Ernestus> riga 2: len(nome) dovrebbe essere (name)?
[23:33:04] <risca> giusto
[23:34:26] <risca> proviamo lo script e ditemi l'errore...
[23:34:29] <Ernestus> potrei sostituire + con le virgole, giusto?
[23:34:44] <risca> (c'è, groll l'ha già identificato)
[23:34:44] <Ernestus> (nella funzione print)
[23:34:53] <risca> giusto
[23:35:23] <groll> risca: a dire il vero io più che l'errore volevo puntare il dito sull'esistenza di div
[23:36:06] <groll> anzi div potrebbe avere un senso dipende come viene scritto il codice
[23:36:43] <risca> groll, in effetti si sarebbe dovuto usare, ma non è stato usato
[23:36:51] <risca> avete provato tutti lo script?
[23:36:59] <groll> beh si può fare pure senza
[23:37:15] <risca> non penso proprio
[23:37:23] <risca> anche a voi viene:
[23:37:26] <risca> =================================00
[23:37:29] <risca> $ python3 dividi-nomi.py
[23:37:29] <risca> Nome:  Cognome: Pinco Pallo
[23:37:29] <risca> Nome: P Cognome: inco Pallo
[23:37:29] <risca> Nome: Pi Cognome: nco Pallo
[23:37:29] <risca> Nome: Pin Cognome: co Pallo
[23:37:31] <groll> si che si può :P
[23:37:31] <risca> Nome: Pinc Cognome: o Pallo
[23:37:34] <risca> Nome: Pinco Cognome:  Pallo
[23:37:36] <risca> Nome: Pinco  Cognome: Pallo
[23:37:39] <risca> Nome: Pinco P Cognome: allo
[23:37:41] <risca> Nome: Pinco Pa Cognome: llo
[23:37:44] <risca> Nome: Pinco Pal Cognome: lo
[23:37:47] <risca> Nome: Pinco Pall Cognome: o
[23:37:49] <risca> ================================0
[23:38:00] <risca> groll, no, quel div, o qualcosa di analogo serve
[23:38:18] <risca> infatti l'output non era quello desiderato
[23:38:23] <groll> intendo che non serve creare una variabile in più bastano quelle già esistenti
[23:38:37] <-- esulu (~esulu@Azzurra-5051B194.ip78.fastwebnet.it) has quit (Quit: Sto andando via ci vediamo alla prossima)
[23:39:09] <groll> poi dopo ti faccio vedere cosa intendo ci sono almeno due soluzioni senza usare variabili in più
[23:39:10] <Ernestus> come mai questo comportamento?
[23:39:14] <risca> groll, in effetti sì
[23:39:24] <amosse> manca break
[23:39:31] <risca> però, così si presta a più interpretazioni
[23:39:35] --> esulu (~esulu@Azzurra-5051B194.ip78.fastwebnet.it) has joined #debianizzati-corsi
[23:39:36] <risca> implementazioni*
[23:39:46] <risca> adesso vi mostro cosa avevo in mente io
[23:39:50] <Ernestus> ma lo spazio è tra Pinco e Pallo
[23:39:52] <groll> amosse: prova in effetti così è meno seccante
[23:39:55] <Ernestus> e basta
[23:40:05] <groll> però non risolvi con un break
[23:40:13] <amosse> funziona
[23:40:17] <risca> guardate ora
[23:41:03] <risca> ops..
[23:41:44] <risca> ok
[23:41:50] <risca> visto la mia modifica?
[23:42:14] <Ernestus> hai indentato
[23:42:18] <Ernestus> diversamente
[23:42:22] <Ernestus> non ho capito il senso, però
[23:42:43] <risca> no, la differenza è nel sostituire il div con i al fondo
[23:43:04] <Ernestus> giusto risca
[23:43:56] <risca> ovviamente questa è solo una delle tante possibili soluzioni
[23:44:13] <risca> ho creato un file nuovo così groll ci fa vedere la sua idea
[23:44:19] <groll> ad esempio provate a modificare usando il break
[23:44:26] <risca> (dividi-nomi2.py)
[23:44:30] <groll> non so chi lo aveva messo li prima ma era sbagliato
[23:44:52] <groll> da questa situazione correggete
[23:45:26] <groll> provate anche ad eseguirlo così vedete cosa esce fuori
[23:45:36] <risca> io una idea l'avrei già, voi?
[23:45:57] <risca> posso modificare?
[23:46:09] <groll> volevo vedere se ci arrivavano loro
[23:46:14] <groll> se facciamo tutto noi non imparano
[23:46:16] <risca> giusto
[23:46:22] <risca> hai ragione
[23:46:55] <amosse> a me con il break, funziona (sulla riga 14)?
[23:47:42] <risca> come?
[23:47:48] <groll> amosse: così com'è ora non funziona
[23:48:10] <groll> può "funzionare" per culo se name è fatto in un certo modo
[23:48:14] <risca> siamo sullo script dividi-nomi2.py
[23:48:45] <risca> ragazzi?
[23:48:58] <risca> potete modificare liberamente, dai
[23:49:06] <Ernestus> volevo fare una domanda di chiarimento
[23:49:10] <amosse> io ho provato DividiNomiAmosse.py .. a me funziona
[23:49:17] <groll> devo cambiare colore non si può guardare il mio
[23:50:34] <groll> lavorate su dividi-nomi2
[23:50:58] <groll> provate anche delle soluzioni se sbagliate non vi deallochiamo :P
[23:51:10] <risca> amosse!!!
[23:51:11] <risca> $ python3 dividinomeamosse
[23:51:12] <risca> Nome:  Cognome: Pinco Pallo
[23:51:18] <risca> è diverso da:
[23:51:27] <risca> $ python3 dividi-nomi.py
[23:51:27] <risca> Nome: Pinco Cognome:  Pallo
[23:51:33] <risca> giusto?
[23:52:10] <amosse> hai ragione, ho toppato
[23:52:17] <risca> dai, capita
[23:52:18] <amosse> sorry
[23:52:31] <risca> sei ancora in tempo per correggere lo scipt, no?
[23:52:44] <amosse> provo
[23:52:59] <risca> dai, prova
[23:53:17] <Stemby> ok, più o meno ho letto
[23:53:17] <risca> Ernestus, alcuna idea?
[23:53:36] <Stemby> indirizzamento e affettamento: bravi :)
[23:53:56] <risca> come dicevo, "li ho fatti a fettine"
[23:53:59] <Stemby> comunque nell'elenco a inizio lezione ho visto che avete citato cose che non abbiamo ancora trattato
[23:54:07] <risca> dici?
[23:54:08] <Stemby> with
[23:54:20] <risca> sì, infatti siamo tornati indietro
[23:54:21] <Stemby> (è un bel casino, non ho mai approfondito troppo)
[23:54:24] <risca> manca ancora try
[23:54:26] <Ernestus> io non avevo capito bene la linea 7, risca
[23:54:26] <Stemby> le eccezione
[23:54:30] <Stemby> *eccezioni
[23:54:36] <Stemby> infatti
[23:54:44] <risca> perché Ernestus?
[23:55:02] <Stemby> (tra l'altro le eccezioni sono un argomento che dovrei affrontare più seriamente)
[23:55:04] <spirit> Io vi saluto, rileggerò con calma. Buonanotte.
[23:55:05] <Ernestus> name[i] mi manda un po' in confusioe
[23:55:12] <groll> Ernestus: prendi il carattere i-esimo di name (name[i]) e confrontalo con la stringa " "
[23:55:13] <Stemby> Ernestus: fermo
[23:55:14] <Ernestus> *confusione. notte spirit
[23:55:17] <Stemby> ho la soluzione
[23:55:18] <Stemby> :)
[23:55:22] <-- spirit (~spirit@Azzurra-C3C291C.104-82-b.business.telecomitalia.it) has quit (Quit: leaving)
[23:55:26] <Stemby> risca: dov'è la famosa immagine?
[23:55:36] <risca> ops...
[23:55:39] <Stemby> con quella Ernestussicuramente capirà al volo
[23:55:43] <Ernestus> quella dei diagrammi?
[23:55:50] <Stemby> *Ernestus sicuramente
[23:56:03] <Stemby> Ernestus: no
[23:56:12] <Stemby> (non credo: quali diagrammi?)
[23:56:12] <risca> nel primo file c'è qualcosa di simile però
[23:56:22] <risca> "slicing"
[23:56:27] <Stemby> adesso guardo
[23:56:55] <groll> Ernestus: apri una shell interattiva e scrivi a = "ciao"
[23:57:01] <risca> Ernestus, ti torna con la spiegazione di groll?
[23:57:16] <groll> poi prova a scrivere a[0] a[1] a[213412451]
[23:57:33] <Ernestus> un momento
[23:58:18] <risca> oppure:
[23:58:21] <risca> >>> for i in range(0,len(a)): print(a[i])
[23:58:21] <risca> ...
[23:58:21] <risca> c
[23:58:21] <risca> i
[23:58:21] <risca> a
[23:58:23] <risca> o
[23:58:44] <groll> comunque controllate bene le indentazioni
[23:59:32] <groll> o meglio chiedetevi se quell'if per come lo state usando se ha una qualche utilità
[23:59:53] <Ernestus> okay, dovrei aver capito
[00:00:00] - {Day changed to gio mar 3 00:00:00 2011}
[00:00:01] <Ernestus> devo riguardarmele bene
[00:01:06] <risca> ragazzi, io vi lascio, però vi lascio nelle ottime mani di stemby e groll
[00:01:09] <risca> ;-)
[00:01:15] <Stemby> notte risca
[00:01:27] <risca> mi raccomando i prossimi giorni provate a esercitarvi e scrivere script
[00:01:29] <Ernestus> notte risca
[00:01:37] <Stemby> risca: dove avevi messo il link?
[00:01:41] <Stemby> all'immagine
[00:01:43] <risca> richiede tempo ma è l'unico modo per impare IMHO
[00:01:45] <Stemby> non la trovo più
[00:01:49] <risca> aspé
[00:01:51] <Ernestus> ci vogliono delle tracce, altrimenti ognuno utilizza le proprie conoscenze senza sforzarle
[00:02:39] <risca> http://nltk.googlecode.com/svn/trunk/doc/images/string-slicing.png
[00:02:58] <risca> (allora domani sera guardate il forum, posterò delle tracce)
[00:03:04] <Ernestus> grazie risca
[00:03:06] <JumX> ciao risca
[00:03:12] <risca> http://temporaryland.files.wordpress.com/2011/01/python_indexes.jpg
[00:03:23] <Stemby> danke
[00:03:34] <risca> http://wiki.python-it.org/GuidaAEsempi/Tipi/Stringhe#head-535a7df14bd9345799b4af4e259003342ea55a16
[00:03:38] <risca> bitte
[00:03:53] <risca> auswiedersen!
[00:03:57] <risca> tchuus
[00:03:59] <amosse> ciao risca
[00:03:59] <risca> ciao
[00:04:05] <risca> notte a tutti
[00:04:08] <groll> notte
[00:04:11] <Ernestus> notte
[00:04:26] <groll> si potrebbe provare a fare una cosa propongo un esercizio poi voi tutti provate a risolverlo
[00:04:30] <groll> ognuno per conto suo
[00:05:03] <groll> prima però dovete riuscire a correggere questo :p
[00:05:12] <Stemby> Ernestus: hai visto l'immagine?
[00:05:16] <Stemby> È chiara?
[00:05:18] <Ernestus> si
[00:05:25] <Ernestus> ma quel concetto era chiaro dapprima
[00:05:27] <Stemby> ottimo
[00:05:34] <Stemby> mmm
[00:05:41] <Stemby> allora cos'è che non era chiaro?
[00:05:48] <Ernestus> non capivo l'i in relazione allo 0
[00:05:50] <Stemby> (o non è ancora chiaro)
[00:05:59] <Stemby> i?
[00:06:06] <Stemby> quale i?
[00:06:10] <Stemby> e quale 0?
[00:06:10] <Ernestus> name[i]
[00:06:25] <groll> ma intendi il for?
[00:06:27] <Stemby> in un ciclo?
[00:06:41] <Ernestus> in questo scriot
[00:06:42] <groll> for + uso di name[i]
[00:06:45] <Ernestus> script
[00:06:46] <Ernestus> ecco
[00:06:49] <Ernestus> giusto groll
[00:06:57] <Stemby> for non l'avevamo ancora affrontato
[00:07:05] <Stemby> è stato fatto stasera?
[00:07:05] <groll> beh innanzitutto sai cosa fa quel for?
[00:07:15] <groll> a prescindere da quello che c'è dentro
[00:07:31] <Ernestus> non ero presente quando hanno affrontato il for
[00:07:51] <Stemby> secondo me non è stato ancora fatto
[00:08:01] <|Wolf|> for i in range(0,len(a)): print(a[i])  <-- questo non si fa mai in codice reale
[00:08:29] <groll> in effetti però avete fatto liste, insiemi, tuple?
[00:08:32] <JumX> notte raga vado a nanna,  leggerò il log della lezione in accademia.
[00:08:35] <Stemby> groll: no
[00:08:40] <Ernestus> ancoera no
[00:08:42] <Ernestus> notte JumX
[00:08:42] <groll> meglio evitare allora il for
[00:08:47] <Stemby> infatti
[00:08:48] <JumX> notte
[00:08:50] <groll> visto che si basa su questi concetti
[00:08:56] <-- JumX (~Mibbit@Azzurra=5829E668.247-95-r.retail.telecomitalia.it) has left #debianizzati-corsi
[00:08:57] <groll> notte
[00:09:02] <Ernestus> io avevo proposto di utilizzare il while
[00:09:05] <Stemby> di tuple ne abbiamo viste diverse
[00:09:06] <Ernestus> poi è stato adottato il for
[00:09:11] <Stemby> ma senza formalizzare il concetto
[00:09:21] <amosse> Ciao Jumx
[00:09:37] <Stemby> Ernestus: il for è più elegante
[00:09:48] <Stemby> raramente si usa while
[00:09:55] <groll> comunque quel for in particolare sarebbe equivalente a dire crea la variabile i assegnagli 0 e poi aumentala di uno ad ogni ciclo
[00:10:13] <Ernestus> devo leggermi bene sulla documentazione
[00:10:16] <Ernestus> ora vado anche io
[00:10:29] <Stemby> più che altro basta aspettare che ciarriviamo
[00:10:37] <Ernestus> buonanotte a tutti
[00:10:39] <Stemby> per la prossima volta: capitolo 5!
[00:10:40] <groll> se volete rifatelo usando il while
[00:10:50] <Ernestus> va bene Stemby
[00:10:56] <Ernestus> ciao a tutti, a domenica
[00:11:02] <Stemby> notte
[00:11:02] <groll> notte
Strumenti personali
Varianti
Azioni
Navigazione
Risorse
Strumenti