Accademia:Log 2011 02 27

Da Guide@Debianizzati.Org.

22:14:43 < amosse> scusate quali erano i compiti?, io l'ultima volta sono mancato
22:15:06 < |Wolf|> esercitarsi su quello che avete fatto l'ultima volta?
22:15:19 < amosse> ok
22:15:49 < |Wolf|> se volete imparare qualcosa dovete giocare tanto con l'interprete e scrivere tanto codice
22:16:07 < |Wolf|> e se l'avete fatto dovreste avere qualche domanda
22:16:29 < amosse> una domanda: lo script TrovaPepita, non é proprio facilino.. qualcuno saprebbe spiegarlo?
22:16:52 < |Wolf|> link?
22:17:30 < amosse> http://guide.debianizzati.org/index.php/Accademia:TrovaPepita.py
22:17:57 < |Wolf|> c'è qualcosa di specifico che non ti è chiaro?
22:18:24 < JumX> io non ho capito come si rende eseguibile.
22:18:54 < amosse> if elif, else che richiamano le funzioni
22:19:12 < |Wolf|> JumX, basta fare python nomescript.py
22:19:38 < |Wolf|> amosse, sai come funzionano if/elif/else?
22:20:30 < amosse> sii, ma cosa vuol dire: len(sys.argv) == 3:?
22:20:37 < JumX> ok grazie
22:20:47 < |Wolf|> sai cos'è sys.argv?
22:20:59 < |Wolf|> sono gli argomenti passati quando richiami lo script
22:21:26 < amosse> gli argomenti di cosa? delle funzioni?
22:21:48 < |Wolf|> ad esempio se fai "python trovapepita.py 5 8", in sys.argv dovresti avere ['trovapetita.py', '5', '8']
22:22:08 < |Wolf|> metti un print(sys.argv) prima dell'if per controllare
22:22:23 < |Wolf|> amosse, gli argomenti che passi allo script quando lo esegui dal terminale
22:22:39 < amosse> ah ok
22:24:09 < |Wolf|> risca!
22:25:09 < amosse> ah ho capito i due numeri da passare al game, li puoi passare alla funzione in fase di caricamento "python trovapepita.py 5 8"
22:26:43 <@GipPasso> È il modo con cui usi, dentro la funzione, i parametri che hai aggiunto alla chiamata da riga di comando.
22:27:06 < |Wolf|> amosse, qualcosa del genere
22:27:12 <@GipPasso> Se una funzione la richiami dal codice stesso devi fare (a quanto so) in altro modo.
22:27:26 <@GipPasso> Scusa, ho scritto in modo confuso.
22:27:49 < amosse> ma perché "if len(sys.argv) == 3:" se i parametri da passare sono due numeri
22:27:59 <@GipPasso> Non confondere "funzione" (come mi scuso ho fatto io or ora) con script python.
22:28:12 <@GipPasso> sys.argv è una lista
22:28:25 <@GipPasso> Come ti ha scritto prima |Wolf| il primo membro della lista è
22:28:28 <@GipPasso> ...? 
22:28:32 <@GipPasso> Rispondi un po'.
22:28:42 <@GipPasso> Ti è stato detto alle 22:23.
22:28:43 <@GipPasso> Lo leggi?
22:29:16 < amosse> 5 8
22:30:12 <@GipPasso> No.
22:30:37 <@GipPasso> Ti ha detto che se metti un print(sys.argv) ottieni
22:30:42 <@GipPasso> ['trovapetita.py', '5', '8']
22:31:14 <@GipPasso> L'elemento 0 (vale a dire il numero 1 in, da me odiatissimo, "informatichese") è la stringa del nome
22:31:16 < amosse> ah scusa il primo elmento della lista é il nome delloo script
22:31:22 <@GipPasso> In questo caso trovapepita.py.
22:31:36 < amosse> ok ho capito
22:31:47 <@GipPasso> Esatto. Se tu esegui da terminale uno script che è in un'altra directory il primo elemento sarebbe
22:31:58 <@GipPasso> '/percorso/fino/allo/script.py'.
22:32:00 <@GipPasso> Chiaro?
22:32:17 < amosse> ok chiaro
22:32:58 < |Wolf|> GipPasso, "primo elemento" o "elemento in posizione 0"
22:33:38 < amosse> scusate protreste anche spiegare: 
22:33:55 < amosse> elif len(sys.argv) == 2 and sys.argv[1] == '-h':     
22:33:55 < amosse> print (trovaPepita.__doc__)
22:34:07 < JumX> io invece non ho capito dove va a prendere 0 e 1 (i valori tra le graffe) : Hai {0} cariche di esplosivo e {1}
22:34:12 < |Wolf|> len(sys.argv) secondo te cosa fa?
22:34:14 <@GipPasso> |Wolf|: certo. Io però ho costruito la frase con "elemento numero" così da far risaltare il contrasto tra l'ordinale degli elementi e il cardinale della posizione.
22:34:43 < amosse> conta gli elemneti della lista
22:34:45 <@GipPasso> Io purtroppo non ho preparato una lezione come faceva Stemby quindi se fate domande va benissimo.
22:34:54 < |Wolf|> JumX, print(benvenuto.format(tent,campo*campo))
22:34:58 <@GipPasso> Rispondere a domande è mooolto più facile che fare una lezione come faceva lui.
22:35:02 <@GipPasso> Quindi chiedete!
22:35:16 < |Wolf|> amosse, e == 2?
22:36:27 < amosse> se sys.argv ha due elementi?
22:36:27 < |Wolf|> JumX, in pratica quando dichiara la stringa li lascia lì come segnaposto, più avanti chiama il metodo .format() per sostiuirli con i valori di tent e campo*campo rispettivamente
22:36:34 < |Wolf|> amosse, giusto
22:36:53 < |Wolf|> in pratica len(sys.argv) == 2 serve per controllare se sys.argv ha 2 elementi
22:37:15 < |Wolf|> sys.argv[1] serve per prendere l'elemento in posizione 1, cioè il secondo elemento
22:37:30 < amosse> ed il secondo elemento == '-h'?
22:37:35 < |Wolf|> esatto
22:37:45 < |Wolf|> le due condizioni sono combinate con un and
22:37:47 < amosse> cosa é?
22:38:00 < amosse> '-h?
22:38:03 < |Wolf|> quindi devono essere vere entrambe
22:38:05 < |Wolf|> una stringa
22:38:30 < |Wolf|> quindi elif len(sys.argv) == 2 and sys.argv[1] == '-h': vuol dire
22:38:32 < amosse> che stringa, scusa
22:38:43 < Stemby> eccomi
22:38:52 < Stemby> scusate il ritardo
22:38:59 < Stemby> mi aggiurno, datemi 2 minuti
22:39:08 < |Wolf|> se sys.argv ha 2 elementi *e* il secondo elemento è ugale alla stringa '-h', allora esegui print (trovaPepita.__doc__)
22:39:13 < |Wolf|> hello Stemby
22:39:40 < |Wolf|> amosse, secondo te in quale caso questa condizione si verifica?
22:40:09 < amosse> non capisco che striga é '-h'?
22:40:13 < |Wolf|> abbiamo visto che facendo "python trovapepita.py 5 8", sys.argv ha 3 elementi
22:40:24 < |Wolf|> amosse, semplicemente una stringa
22:40:57 < |Wolf|> amosse, in len(sys.argv) == 2 vuoi verifericare se la lunghezza è uguale al numero 2, quindi metti == 2
22:41:24 < |Wolf|> amosse, in sys.argv[1] == '-h' vuoi verificare se il secondo argomento è uguale alla stringa '-h', quindi metti == '-h'
22:41:30 < |Wolf|> capito?
22:41:31 < amosse> ok qui é chiaro
22:41:58 < amosse> ok
22:42:17 < |Wolf|> quindi dicevamo
22:42:25 < |Wolf|> abbiamo visto che facendo "python trovapepita.py 5 8", sys.argv ha 3 elementi
22:42:34 <@GipPasso> Ho una domanda io: se avessi voluto porre la condizione sulla lunghezza == 2 congiunta con è all'or tra altre due condizioni
22:42:35 < amosse> ok
22:42:43 < |Wolf|> quindi cosa devo fare per fare in modo che ne abbia 2, e che il secondo sia -h?
22:42:55 <@GipPasso> avrei potuto mettere: if len..==2 and ( xxx or yyy) ?
22:43:07 < |Wolf|> GipPasso, sì
22:43:26 <@GipPasso> La domanda era sulla necessità logica delle parentesi.
22:43:42 < |Wolf|> GipPasso, ad esempio se vuoi che accetti sia -h che --help
22:43:47 <@GipPasso> In matematica lo so, mi chiedevo in python (chiarisco perché la domanda risulti chiara a tutti)
22:43:57 <@GipPasso> |Wolf|: quella era l'idea.
22:44:20 -!- Ernestus [~ernesto@Azzurra=3EBE8D91.44-79-r.retail.telecomitalia.it] has quit [Client closed connection]
22:44:23 < |Wolf|> GipPasso, ci sono regole sulle priorità degli operatori, in caso di dubbio è sempre meglio essere espliciti ed aggiungere un paio di ()
22:44:36 < amosse> -h = help
22:44:51 < amosse> ?
22:44:55 < |Wolf|> nel caso di and e or la priorità è la stessa, quindi le parentesi ci vogliono
22:45:04 < Stemby> amosse: sì
22:45:10 <@GipPasso> |Wolf|: chiarissimo.
22:45:14 < Stemby> è l'opzione per stampare la documentazione
22:45:19 < |Wolf|> amosse, l'idea è quella, ma il fatto di usare -h è una cosa decisa da chi ha scritto il programma
22:45:27 < Stemby> esatto
22:45:29 -!- Ernestus [~ernesto@Azzurra=3EBE8D91.44-79-r.retail.telecomitalia.it] has joined #debianizzati-corsi
22:45:33 < |Wolf|> amosse, potevi anche mettere == 'aiuto'
22:45:35 < Stemby> (abbastanza standard, direi)
22:45:48 < amosse> ah ok
22:46:09 < |Wolf|> amosse, quindi come faresti per vedere l'help?
22:46:36 < |Wolf|> Stemby, stanotte poi la connessione è morta ed è tornata pomeriggio
22:46:45 < Stemby> |Wolf|: ho visto
22:46:46 < Stemby> np
22:46:47 < |Wolf|> dopo se vuoi continuiamo con il discorso sui test
22:46:59 < Stemby> magari un altro giorno...
22:47:02 < amosse> sys.argv[1]
22:47:04 < Stemby> qui si finisce sul tardino
22:47:09 < |Wolf|> ok
22:47:46 < Ernestus> eccomi scusate
22:47:48 < |Wolf|> amosse, intendo il comando che dai quando esegui lo script, ad esempio "python trovapepite.py 5 8"
22:48:07 < |Wolf|> amosse, che comando daresti per vedere l'help?
22:49:30 < Stemby> mentre amosse pensa alla risposta, ci sono altre domande?
22:49:37 < Stemby> altrimenti inizierei
22:50:29 < Stemby> c'è nessuno?
22:50:46 < |Wolf|> io ci sono
22:51:01 <@GipPasso> Io sguazzo fuori e dentro.
22:51:03 < Stemby> beh, tu non hai bisogno delle mie lezioni...
22:51:09 < spirit> vai
22:51:17 < Stemby> ok
22:51:18 < amosse> python trovapepite.py [-h]
22:51:25 < Stemby> senza parentesi
22:51:26 < amosse> non ci riesco
22:51:40 < Stemby> python3 trovapepite.py -h
22:51:55 < Stemby> oppure
22:51:55 < amosse> ah ok
22:52:05 < Stemby> chmod u+x trovapepite.py
22:52:15 < Stemby> ./trovapepite.py
22:52:22 < Stemby> soddy
22:52:24 < Stemby> sorry
22:52:28 < Stemby> ./trovapepite.py -h
22:52:38 < amosse> ok
22:52:39 < Stemby> (credo almeno)
22:52:47 < Stemby> (non l'ho provato)
22:53:15 < |Wolf|> giusto, "python3 trovapetite.py", non "python trovapetite.py"
22:53:40 < Stemby> allora
22:53:56 < |Wolf|> (ci sarebbero un paio di cose da fixare in quello script cmq)
22:54:03 < Stemby> per l'altra volta avevo intenzione di iniziare ad approfondire le stringhe
22:54:12 < Stemby> |Wolf|: non l'ho guardato
22:54:23 < Stemby> dicevo
22:54:27 < |Wolf|> sì, la massimo vedo dopo con risca, procedi pure con la lezione
22:54:38 < |Wolf|> al*
22:54:54 < Stemby> però c'era poca gente, c'erano tanti dubbi, e quindi abbiamo più che altro fatto un altro ripassone
22:55:11 < Stemby> ora è tutto chiaro quello che è stato fatto finora?
22:55:24 < amosse> ok
22:55:33 < Stemby> bon
22:55:45 < spirit> si
22:55:46 < Stemby> chi NON ha letto i capitoli del libro che c'erano da leggre?
22:55:58 < Stemby> 1 e 2 per l'altra volta
22:56:03 < Stemby> 3 (se non erro) per oggi
22:56:38 < Stemby> ottimo :)
22:56:45 < Stemby> tutto chiaro o ci sono dubbi?
22:57:02 < amosse> ok
22:57:14 < Stemby> sono argomenti che ormai dovremmo avere digerito a fondo
22:57:21 < spirit> in riferimento ai 2 cap. no
22:57:42 < Stemby> spirit: per il 3?
22:57:55 < Stemby> (confesso di averlo solo sfogliato, per il momento)
22:58:06 < Stemby> mentre i primi 2 li ho letti a fondo
22:58:14 < spirit> io lo sto leggendo adesso
22:58:35 < Stemby> va beh, leggilo per la prossima volta
22:58:42 < Stemby> assieme al 4 :)
22:58:52 < spirit> perdonami, ma ho avuto da fare..
22:58:59 < Stemby> np
22:59:11 < Stemby> dal 4 si inizia a fare un po' più sul serio
22:59:17 < Stemby> primo giochino :)
22:59:21 < Stemby> (pure carino)
22:59:32 < Stemby> comunque: per la prossima volta
22:59:44 < Stemby> l'argomento del capitolo 3 erano le stringhe
22:59:54 < Stemby> ma in modo molto generico
22:59:57 <@GipPasso> Scusate, che libro?
23:00:20 < Stemby> invent your own computer games with python
23:00:33 < Stemby> il libro che abbiamo adottato come libro di testo
23:00:40 < Stemby> trovi i riferimenti sul wiki
23:00:43 <@GipPasso> Grazie.
23:01:00 < Stemby> dicevo: stringhe
23:01:06 <@GipPasso> Sì ricordo che fu citato e l'andai a vedere. Non sapevo che fosse stato adottato sistematicamente.
23:01:09 < Stemby> cos'è una stringa?
23:01:39 < Stemby> GipPasso: è bello, gratis, divertente, aggiornato a py3
23:01:48 < Stemby> meglio di così non potevamo sperare
23:01:58 < spirit> un oggetto
23:02:05 < Stemby> spirit: ok
23:02:06 < Stemby> poi?
23:02:21 < amosse> lista
23:02:24 < Stemby> no!
23:02:28 < amosse> sequenza
23:02:32 < Stemby> ok
23:02:32 < amosse> di lettere
23:02:38 < Stemby> non solo
23:02:40 < spirit> espressione
23:02:44 < Stemby> spirit: no
23:02:53 < Stemby> sequenza di... ?
23:03:09 < Stemby> spirit: beh, volendo sì
23:03:31 < Stemby> ma non è la definizione di stringa
23:03:38 < Stemby> sequenza di... ?
23:03:58 < Stemby> angurie?
23:04:13 < Stemby> amosse ha detto lettere
23:04:17 < Stemby> ma non è corretto
23:04:24 < amosse> caratteri
23:04:26 < JumX> Sequenza di caratteri
23:04:30 < Stemby> ok!
23:04:33 < Stemby> caratteri
23:04:39 < Stemby> '1' è una stringa
23:04:43 < JumX> si
23:05:03 < Stemby> 'ç!"£' anche
23:05:14 < Stemby> sono tutti caratteri
23:05:15 < amosse> ok
23:05:16 < JumX> tutto ciò che si racchiude tra apici 'sdfsf'   '123'
23:05:22 < Stemby> ok
23:05:36 < Stemby> link alla doc ufficiale: oggi chi me lo passa?
23:05:50 < Stemby> (libreria standard)
23:05:58 < amosse> http://docs.python.org/release/3.1.3/library/string.html7
23:06:08 < |Wolf|> http://docs.python.org/py3k/library/stdtypes.html
23:06:36 < Stemby> non c'era bisogno di far scomodare |Wolf|...
23:06:38 < Stemby> pigroni!
23:06:49 < Stemby> amosse: verifica i link, prima di postarli...
23:06:50 < JumX> per la precisione possono essere racchiuse tra apici '   e virgolette  "  "  per python sono la stessa cosa
23:06:59 < amosse> ops
23:07:11 < Stemby> JumX: esatto
23:07:29 < Stemby> se devi usare apici singoli nella stringa, userai quelli doppi per racchiuderla
23:07:34 < Stemby> e viceversa
23:07:55 < JumX> ok
23:08:01 < Stemby> "l'arancia"
23:08:19 < Stemby> 'il libro "XYZ"'
23:08:25 < amosse> ok
23:08:36 < Stemby> allora
23:08:49 < Stemby> sulla doc ufficiale eravamo arrivati al paragrafo 4.4
23:08:54 < Stemby> tutto chiaro fin lì?
23:09:13 < Stemby> 4.4.1 saltiamo
23:09:25 < spirit> ok
23:09:28 < Stemby> 4.4.2 saltiamo
23:09:35 < Stemby> (o rimandiamo, per lo meno)
23:09:48 < Stemby> 4.4.3 idem
23:10:11 < Stemby> 4.4.4 idem
23:10:24 < Stemby> 4.5 idem
23:10:35 < Stemby> andiamo al 4.6
23:10:45 < Stemby> http://docs.python.org/py3k/library/stdtypes.html#sequence-types-str-bytes-bytearray-list-tuple-range
23:11:25 < Stemby> tenete presente che queti operatori funzionano su tutte le senquenze
23:11:33 < Stemby> oggi li usiamo sulle stringhe
23:11:53 < Stemby> quando faremo liste e tuple, il lavoro sarà già fatto :)
23:12:03 < Stemby> primo operatore: in
23:12:09 < Stemby> secondo voi cosa fa?
23:12:36 < amosse> verifica se n é in list
23:12:51 < Stemby> non stiamo facendo le liste...
23:12:54 < Stemby> stringhe
23:13:00 < Stemby> True if an item of s is equal to x, else False
23:13:07 < amosse> scusa
23:13:10 < Stemby> traduzione, please
23:13:20 < Stemby> completa e corretta
23:13:33 < Stemby> e stilisticamente accettabile, possibilmente
23:13:38 < |Wolf|> notare che 'in' funziona in modo un po' diverso per le stringhe rispetto alle altre sequenze
23:13:41 < JumX> Verifica l'esistenza in una stringa di un valore ben preciso e restituisce True sè è vero
23:13:48 < amosse> vero se un elemento di s é uguale a x, altrimenti falso
23:13:52 < Stemby> JumX: no
23:13:57 < JumX> ?
23:13:59 < Stemby> amosse: esatto
23:14:12 < Stemby> adattamento al concetto di stringa?
23:14:19 < Stemby> cos'è l'elemento, in una stringa?
23:14:27 < amosse> carattere
23:14:30 < Stemby> esatto
23:14:40 < spirit> (1, 2, '3')
23:14:46 < Stemby> spirit: stringhe
23:14:48 < Stemby> non tuple
23:15:04 < Stemby> ovvero:
23:15:41 < Stemby> restituisce True se uno dei caratteri è quello cercato
23:15:50 < Stemby> in realtà è un po' più generale
23:16:08 < Stemby> perché può essere una stringa cercata, non solo un carattere singolo
23:16:20 < Stemby> comunque un esempio è più chiarificatore di qualsiasi spiegazione
23:16:34 < Stemby> chi mi fa un'espressione con una stringa e l'operatore in?
23:16:51 < amosse> am in amosse == True
23:16:58 < Stemby> (provatelo nella shell interattiva)
23:17:03 < Stemby> amosse: no
23:17:13 < Stemby> che c'entra ==?
23:17:28 < |Wolf|> è quasi giusto
23:17:34 < amosse> uguale nel senso True
23:17:34 < |Wolf|> amosse, provalo e vedi
23:18:03 < Stemby> tra l'altro ti darebbe una scatervata di errori
23:18:15 < Stemby> am non è una stringa, ma una variabile
23:18:18 < JumX>  "1" in "'1' '2' '3'"   da True
23:18:24 < Stemby> (non assegnata)
23:18:38 < Stemby> JumX: sì
23:18:47 < Stemby> qualcosa di meglio?
23:18:53 < Stemby> e più utile/semplice?
23:19:01 < Stemby> >>> "a" in "pippo"
23:19:01 < Stemby> False
23:19:01 < Stemby> >>> "i" in "pippo"
23:19:01 < Stemby> True
23:19:17 < amosse> 'am' in 'amosse'
23:19:17 < amosse> True
23:19:23 < Stemby> ok
23:19:32 < Stemby> chiaro?
23:19:40 < amosse> ok
23:19:42 < Ernestus> si
23:19:47 < spirit> ok
23:19:53 < Stemby> bon, andiamo avanti
23:20:05 < Stemby> il secondo è banale
23:20:15 < Stemby> (è semplicemente il contrario)
23:20:20 < JumX> Ho notato che non fa alcuna differenza tra maiuscole e minscole  ... me lo confermate?
23:20:42 < Stemby> come no
23:20:45 < Stemby> >>> "I" in "pippo"
23:20:45 < Stemby> False
23:20:59 < Stemby> >>> "i" in "pippo"
23:20:59 < Stemby> True
23:21:02 < JumX> Scusate  volevo dire il contrario fa daifferenza
23:21:08 < Stemby> giustamente
23:21:19 < Stemby> "i" e "I" son stringhe diverse
23:21:32 < Stemby> verificatelo con un'espressione che conoscete benissimo
23:21:32 < JumX> si si ok
23:21:55 < Stemby> chi mi dimostra che "i" e "I" son stringhe diverse?
23:22:08 < Stemby> JumX: ti sei offerto volontario
23:22:13 < JumX> 'X' in 'jumx'    False
23:22:25 < JumX> 'X' in 'jumx'  True
23:22:28 < Stemby> qualcosa di più convincente
23:22:32 < Stemby> hai 2 stringhe
23:22:39 < Stemby> "i" e "I"
23:22:56 < Stemby> usa un operatore che abbiamo fatto per dimoostrarmi che non sono uguali
23:23:10 < Ernestus> is not
23:23:10 < Stemby> *dimostrarmi
23:23:16 < JumX> 'i' in 'pippo'    true
23:23:16 < Stemby> Ernestus: no
23:23:23 < Stemby> JumX: e va beh
23:23:28 < Stemby> caspita
23:23:40 < Stemby> l'avrete usato 1000 volte ormai...
23:24:01 < amosse> 'i' == 'I'
23:24:07 < Stemby> bravo amosse
23:24:11 < Stemby> provate
23:24:18 < amosse> False
23:24:31 < Stemby> ok?
23:24:45 < Stemby> se dovete fare un confronto, usate un operatore di confronto...
23:24:51 < Stemby> mi sembra lapalissiano
23:25:01 < Stemby> :)
23:25:13 < Stemby> JumX: hai provato?
23:25:28 < JumX> si
23:25:32 < Stemby> sei convinto?
23:25:38 < JumX> si
23:25:42 < Stemby> ok, andiamo avanti
23:25:46 < JumX> vai
23:25:58 < Stemby> l'operatore + l'abbiamo già visto
23:26:01 < Stemby> in che contesto?
23:26:39 < Stemby> oh fanciulli...
23:26:51 < Stemby> +
23:27:05 < JumX> operatori
23:27:09 < Stemby> quali
23:27:18 < amosse> 'am'+'osse'
23:27:30 < Stemby> non l'abbiamo ancora fatto, quello
23:27:36 < Stemby> ci stavo per arrivare
23:27:42 < JumX> 2+2     4
23:27:47 < Stemby> alleluia
23:27:54 < Stemby> operatori aritmetici
23:27:57 < Stemby> giusto?
23:27:59 < JumX> + con le stringhe fa una concatenazione
23:28:03 < Stemby> esatto
23:28:11 < Stemby> che è quello che sto per fare
23:28:25 < Stemby> concatenare è un concetto banale
23:28:34 < |Wolf|> che non si usa molto spesso
23:28:37 < Stemby> significa mettere 2 sequenze una in fila all'altra
23:28:39 < JumX>  'a'+'b'   'ab'
23:28:47 < Stemby> esatto
23:29:05 < JumX>  'a '+' b'   'a  b'
23:29:13 < Stemby> tenete però presente che la concatenazione con le stringhe in genere si evita di farla
23:29:30 < Stemby> cosa si usa per concatenare 2 stringhe?
23:29:38 < Stemby> (preferibilmente)
23:29:53 < Stemby> (già fatto...)
23:29:53 < amosse> format
23:29:58 < Stemby> oppure?
23:30:25 < amosse> ,
23:30:38 < Stemby> amosse: no
23:30:43 < Stemby> si evita anche quello
23:30:53 < |Wolf|> con print va bene usare la ,
23:31:19 < Stemby> va beh, lo dico io
23:31:25 < Stemby> %
23:31:43 < Stemby> '%s%s' % ('a', 'b')
23:32:08 < Stemby> o format(), o %
23:32:15 < |Wolf|> meglio format
23:32:17 < Stemby> comunque la formattazione delle stringhe :)
23:32:27 < Stemby> |Wolf|: son della vecchia scuola
23:32:44 < Stemby> e finora non ho trovato niente di convincente per farmi cambiare idea
23:33:07 < Stemby> comunque, o uno o l'altro
23:33:16 < Stemby> ok?
23:33:23 < spirit> ok
23:33:24 < JumX> per immediatezza preferire il + a meno che non ci siano controindicazioni
23:33:27 < amosse> ok
23:33:47 < Stemby> JumX: le controindicazioni sono una più bassa prestazione
23:33:50 < Stemby> (teorica)
23:33:52 < |Wolf|> JumX, potrebbe esplodere se uno dei 2 operatori non è una stringa
23:34:03 < |Wolf|> (e a volte va anche bene che esploda)
23:34:16 < JumX> boom !
23:34:22 < Stemby> vero
23:34:33 < Stemby> ricordiamo che %s trasforma tutto in stringa
23:34:44 < Stemby> (quel che si può trasformare in stringa)
23:34:54 < |Wolf|> (cioè tutto)
23:35:04 < Stemby> beh, non proprio
23:35:11 < Stemby> gli oggetti predefiniti sì
23:35:34 < Stemby> le istanze delle classi... no, a meno che non sia previsto
23:35:41 < Stemby> (dal programmatore)
23:35:46 < |Wolf|> >>> class Foo: pass
23:35:46 < |Wolf|> ... 
23:35:46 < |Wolf|> >>> str(Foo)
23:35:46 < |Wolf|> "<class '__main__.Foo'>"
23:35:46 < |Wolf|> >>> str(Foo())
23:35:47 < |Wolf|> '<__main__.Foo object at 0xb748cccc>'
23:36:04 < Stemby> mmmm, interessante
23:36:06 < Stemby> hai ragione
23:36:23 < Stemby> probabilmente non è quello che si vorrebbe, comunque è vero, non esplode mai
23:36:27 < JumX> ci spiegate ?
23:36:31 < |Wolf|> (il programmatore però può prevedere che non sia previsto e fare esplodere str)
23:36:53 < |Wolf|> JumX, semplicemente che puoi usare str() su qualsiasi oggetto e funziona sempre
23:36:53 < Stemby> JumX: più avanti :)
23:37:10 < |Wolf|> JumX, o operazioni di string formatting che convertono in stringa
23:37:24 < JumX> ok grazie
23:37:36 < Stemby> quindi: formattazione stringhe SEMPRE
23:37:46 < Stemby> (a meno che non si vogliano comportamenti strani)
23:37:56 < Stemby> concatenzazione stringhe MAI
23:37:57 < Stemby> (a meno che non si vogliano comportamenti strani)
23:38:04 < Stemby> :)
23:38:08 < Stemby> proseguiamo
23:38:18 < JumX> si
23:38:32 < amosse> ok
23:39:03 < Stemby> eccomi, scusate
23:39:05 < Stemby> allora
23:39:12 < Stemby> ripetizione
23:39:22 < Stemby> è simile alla concatenazione
23:39:52 < Stemby> solo che invece di concatenare 2 sequenze, concatena la stessa sequenza tante volte quante si chiede
23:40:01 < Stemby> operatore: *
23:40:11 < Stemby> (quello della moltiplicazione)
23:40:21 < Stemby> esempi:
23:40:24 < Stemby> prego :)
23:40:51 < Stemby> (con le stringhe, ovviamente)
23:41:00 < JumX> 'a' * 6   aaaaaa
23:41:03 < Stemby> ok
23:41:08 < Stemby> chiaro?
23:41:16 < amosse> ok
23:41:27 < Stemby> avanti
23:41:29 < JumX> ops tra apici ....  'aaaaaa'
23:41:35 < JumX> ok 
23:41:36 < |Wolf|> questo si usa quando vuoi fare print('-'*80)
23:41:38 < Stemby> sì, ovviamente
23:41:46 < Stemby> ad esempio
23:41:47 < |Wolf|> per fare una bella fila di -----------
23:41:55 < Stemby> esatto
23:41:59 < |Wolf|> altrimenti non capita spesso di usare neanche quello
23:42:04 < JumX> ps con le donne non vale :)
23:42:11 < Stemby> ?
23:42:46 < amosse> scusa potreste spiegare end='' all'interno di print()?
23:43:08 < Stemby> mmm, sì
23:43:13 < Stemby> è una novità di py3
23:43:25 < Stemby> come tutta la funzione print(), a dire il vero
23:43:30 < Stemby> amosse: trova la doc
23:43:35 < Stemby> così la commentiamo :)
23:43:39 < |Wolf|> help(print)
23:44:21 < Stemby> print(...)
23:44:21 < Stemby>     print(value, ..., sep=' ', end='\n', file=sys.stdout)
23:44:47 < Stemby> la prima riga della doc è l'invocazione della funzione
23:44:58 < Stemby> print('pippo')
23:45:16 < Stemby> la seconda ci mostra come è implementata questa funzione
23:45:23 < Stemby> vi ricordate def?
23:45:30 < JumX> no
23:45:37 < Stemby> JumX: male
23:45:43 < Ernestus> neanche io...
23:45:50 < Stemby> Ernestus: malissimo
23:45:50 < JumX> lo so ma perchè mentire
23:45:57 < Stemby> :)
23:46:05 < spirit> crea un nuovo oggett funzione
23:46:15 < Stemby> non vi ricordate che abbiamo scritto una libreria intera
23:46:16 < Stemby> ?
23:46:20 < Stemby> spirit: bravo
23:46:28 < Stemby> l'unico alunno diligente
23:46:36 < spirit> non esagerare..
23:46:51 < JumX> bravo spirit
23:46:57 < Stemby> def è l'istruzione che serve per scrivere nuove funzioni
23:47:06 < JumX> ok
23:47:29 < Stemby> la libreria standard è scritta in C (credo tutta quanta), quindi in realtà non è così
23:47:36 < Stemby> però è come se fosse:
23:48:09 < Stemby> def print(value, sep=' ', end='\n', file=sys.stdout):
23:48:09 < Ernestus> si, ricordo
23:48:22 < |Wolf|> Stemby, la maggior parte è scritta in python
23:48:36 < Stemby> e poi il blocco con tutte le istruzioni eseguite dalla funzione
23:48:40 < Stemby> |Wolf|: ah, ok
23:48:53 < Stemby> print() comunque scommetterei che è scritta in C
23:48:54 < |Wolf|> (print è in C molto probabilmente)
23:49:44 < Stemby> noi finora abbiamo visto come scrivere funzioni molto semplici
23:50:03 < Stemby> def nomefunzione(par1, par2):
23:50:08 < Stemby> o cose del genere
23:50:14 < JumX> Stemby io non l'ho capita --->  def print(value, sep=' ', end='\n', file=sys.stdout)
23:50:24 < Stemby> JumX: sto spiegando...
23:50:38 < Stemby> def nomefunzione(par1, par2):
23:50:50 < Stemby> significa che ci sono 2 parametri obbligatori
23:50:55 < Stemby> ok?
23:51:16 < amosse> ok
23:51:28 < Stemby> ovvero: per invocare la funzione BISOGNA per forza passarle 2 parametri
23:51:44 < Stemby> alcuni parametri però possono essere opzionali
23:52:15 < spirit> ok
23:52:22 < Stemby> quelli opzionali sono previsti proprio attraverso l' =
23:52:37 < Stemby> e il valore di default è indicato dopo l' =
23:53:05 < Stemby> ovvero: se non vengono passati durante l'invocazione, vengono usati i valori di default
23:53:16 < Stemby> in questo caso i valori di default sono:
23:53:26 < Stemby> sep=' '
23:53:35 < Stemby> end='\n'
23:53:44 < Stemby> file=sys.stdout
23:53:56 < Stemby> ok?
23:54:03 < amosse> ok
23:54:08 < Stemby> quindi, scrivere:
23:54:15 < Stemby> print('pippo')
23:54:18 < Stemby> equivale a:
23:54:32 < JumX> 'pippo'
23:54:50 < Stemby> print('pippo', sep=' ', end='\n', file=sys.stdout)
23:54:53 < Stemby> ok?
23:55:03 < amosse> ok
23:55:18 < JumX> sys.stdout   che significa?
23:55:32 < Stemby> significa che la stringa viene stampata a monitor
23:55:37 < Stemby> (di default)
23:55:44 < amosse> quali altri parametri per sys.stdout?
23:55:47 < Stemby> potresti volerla stampare su file
23:55:50 < Stemby> o su carta
23:55:51 < Stemby> ecc.
23:55:53 < Stemby> come?
23:56:01 < Stemby> lo vedremo tra qualche lezione
23:56:09 < amosse> ok
23:56:19 < Stemby> end mi sembra evidente
23:56:34 < Stemby> significa che di default, dopo aver stampato la stringa va a capo
23:56:42 < amosse> si é chiaro
23:57:00 < Stemby> sep: provate a leggere la doc
23:57:11 < Stemby> e ditemi una vostra spegazione :)
23:57:17 < Stemby> (così almeno ve la ricordate)
23:57:28 < Stemby> *datemi
23:57:46 < JumX> print('pippo', sep=' ', end='\n', file=sys.stdout)   .. l'ho provata nel terminale ma da errore
23:58:06 < spirit> anche a me
23:58:09 < Stemby> che errore?
23:58:22 < Stemby> ah,ok
23:58:26 < JumX> Traceback (most recent call last):   File "<stdin>", line 1, in <module> NameError: name 'sys' is not defined
23:58:28 < Stemby> non avete importato sys
23:58:33 < Stemby> import sys
23:58:41 < spirit> ah, giusto
23:58:53 < JumX> si ok ora va
23:58:56 < Stemby> leggete gli errori...
23:59:13 < Stemby> comunque file e end non ci interessano
23:59:23 < Stemby> stiamo cercando di capire il parametro sep
23:59:28 < Stemby> era questa la domanda...
00:00:07 < Stemby> cosa dice la doc?
00:00:32 < Stemby>     sep:  string inserted between values, default a space.
00:00:58 < amosse> print('pippo','pluto', sep='-', end='\n', file=sys.stdout)
00:01:10 < Stemby> amosse: end e file non ci interessano
00:01:16 < Stemby> riduciamo ai minimi termini
00:01:17 < amosse> pippo-pluto
00:01:21 < |Wolf|> amosse, end e file puoi anche non specificarli se ti va bene il valore di default
00:01:32 < amosse> ok
00:01:42 < Stemby> chiaro?
00:02:11 < Stemby> se invece volessimo concatenare le due stringe 'foo' e 'bar' senza separazioni?
00:02:16 < Stemby> usando solo print()
00:03:21 < amosse> print('foo','bar', sep='')
00:03:24 < Stemby> ok
00:03:31 < Stemby> chiaro per tutti?
00:04:15 < spirit> si
00:04:19 < Stemby> Ernestus: ?
00:04:25 < amosse> io ragazzi vi devo lasciare, seguirò il log, ci vediamo mercoledì
00:04:26 < Stemby> JumX: ?
00:04:32 < Ernestus> buonanotte amosse 
00:04:34 < Stemby> amosse: ok, ciao
00:04:39 < spirit> ciao
00:04:40 < amosse> grazie a tutti
00:04:41 < amosse> notte
00:04:45 < JumX> un attimo sto provando
00:04:56 < JumX> notte 
00:05:03 -!- amosse [~Mibbit@Azzurra=79182BF9.45-79-r.retail.telecomitalia.it] has quit [Quit: http://www.mibbit.com ajax IRC Client]
00:05:13 < Ernestus> scusa un attimo Stemby 
00:05:51 < Ernestus> ora è chiaro
00:05:58 < JumX> non va
00:06:22 < Stemby> JumX: errore=
00:06:23 < Stemby> ?
00:06:47 < Stemby> JumX: se non leggi gli errori, o almeno non ce li fai leggere, non risolvi
00:06:56 < Stemby> è inutile dire "non va"
00:06:56 < JumX> SyntaxError: EOL while scanning string literal
00:07:20 < Stemby> cos'è che ti dà quell'errore?
00:07:48 < JumX> print('foo','bar',sep=")
00:07:59 < Stemby> non è un doppio apice
00:08:05 < Stemby> sono 2 singoli apici attaccati
00:08:11 < Stemby> (una stringa vuota)
00:08:15 < JumX> un attimo
00:08:30 < JumX> ok 
00:08:46 < Stemby> ti ricordi qual è il valore di default?
00:08:52 < Stemby> (per il parametro sep)
00:09:16 < Stemby> JumX: ↑
00:09:19 < |Wolf|> l'errore vuol dire che ha trovato la fine della riga (EOL - end of line) mentre stava leggendo uno string literal (cioè un coso  tra '...' o "...")
00:09:33 < JumX> non lo so
00:09:41 < Stemby> come non lo sai
00:09:43 < Stemby> leggi la doc
00:10:43 < Stemby> JumX: ↑
00:10:52 < Stemby> help(print)
00:11:16 < JumX> =' ' 
00:11:21 < Stemby> esatto
00:11:26 < Stemby> uno spazio singolo
00:11:32 < Stemby> infatti:
00:11:40 < Stemby> print('foo','bar')
00:11:45 < Stemby> equivale a
00:11:54 < Stemby> print('foo','bar',sep=' ')
00:12:12 < Stemby> e stampa:
00:12:14 < Stemby> foo bar
00:12:16 < Stemby> ok?
00:12:29 < JumX> ok
00:12:40 < Stemby> JumX: modifica quell'invocazione
00:12:52 < Stemby> per fare in modo che le 2 stringhe siano separate dal carattere |
00:13:09 < Stemby> in modo che la funzione stampi:
00:13:12 < Stemby> foo|bar
00:13:32 < JumX> print('foo','bar',sep='|')
00:13:35 < Stemby> ok
00:13:42 < Stemby> mi sembra che ci siamo
00:13:50 < JumX> yes
00:14:00 < spirit> ok
00:14:06 < Stemby> direi di fermarci qui
00:14:10 < Stemby> peccato
00:14:26 < Stemby> perché non sono ancora riuscito a fare quello che prevedevo per 2 lezioni fa
00:14:27 < JumX> mamma stasera è volata
00:14:36 < Stemby> va beh, sarà per la prossima
00:14:44 < JumX> cosa volevi fare?
00:14:48 < Stemby> perché l'operatore successivo è proprio quello che volevo trattare
00:14:53 < Stemby> []
00:15:19 < JumX> ?
00:15:59 < Stemby> indicizzazione e affettamento
00:16:09 < Stemby> sarà il primo argomento della prossima lezione
00:16:28 < Stemby> bon, per la prossima volta, leggete il capitolo 4
00:16:36 < Stemby> e divertitevi col primo videogioco
00:16:49 < Stemby> (tutte cose già fatte, credo)
00:16:56 < Stemby> (ma il giochino è divertente)
00:17:05 < JumX> quale videogioco?
00:17:15 <@GipPasso> Vi saluto e cerco di leggere un po' quello che avete fatto.
00:17:18 <@GipPasso> Buonanotte.
00:17:21 < Stemby> quello presentato nel capitolo 4
00:17:34 < JumX> ok
00:17:42 < spirit> Buonanotte Gip
00:17:49 < Stemby> notte
00:17:59 -!- GipPasso [~gipo@Azzurra=6E064DDF.clienti.tiscali.it] has left #debianizzati-corsi []
00:18:26 < JumX> Buonanotte a mercoledì
00:18:41 < Ernestus> buonanotte
00:18:45 -!- Ernestus [~ernesto@Azzurra=3EBE8D91.44-79-r.retail.telecomitalia.it] has quit [Quit: Ex-Chat]
00:18:46 < spirit> vado anch'io allora, grazie.Buonanotte.
00:18:55 < JumX> notte
Strumenti personali
Varianti
Azioni
Navigazione
Risorse
Strumenti