[Python] Pensare da informatico: i miei (e i vostri dubbi)

[~FullSyst3m~]

Salve a tutti, ho deciso di aprire questo topic per postare i dubbi inerenti il libro in questione, può sempre capitare di non capire qualcosa. Ovviamente può postare chiunque, a patto che riguardi il libro altrimenti si fa confusione.
Inizio io:

un pò di chiarimenti sul capitolo 3

1) Paragrafo 3.10, penultima riga: "Anche i parametri sono locali: al dì fuori della funzione StampaUnite2Volte, non esiste alcuna cosa chiamata messaggio."
Ma in quella funzione messaggio non è una variabile locale, è stata creata prima. E' un errore del libro?

2) Paragrafo 3.11. Dove si parla della traccia, io chiamo unione in stampa2volte:
def stampa2volte(valore):
print valore, valore

def stampaunite(parte1, parte2):
unione= parte1 + parte2
stampa2volte(unione)

strofa="nel mezzo "
strofa2="nel mezzo"

stampa2volte(unione)

ma l'errore che mi dà non è come quello della guida, ma diverso:

"Traceback (most recent call last):
File "C:/Documents and Settings/~FullSyst3m~/Desktop/test.py", line 11, in <module>
stampa2volte(unione)
NameError: name 'unione' is not defined"

Dipende dalla versione di python (quella del libro è vecchissima)?

3) Paragrafo 3.12. Funzioni con risultati. Non ho mai capito questa cosa. Cosa si intende per funzione che ritorna un risultato/valore? Stamp2Volte non ritorna la stampa del parametro? Perchè non viene considerata una funzione produttiva?

4) Sempre paragrafo 3.12, la prima delle 3 domande:
una funzione del tipo? Se chiamo stampa2volte e non faccio niente con il risultato che viene restituito non succede niente. Non capisco cosa intende il libro quando dice "restituire un risultato" (si può collegare a quella di prima)

Poi, capitolo 4, paragrafo 4.1: "Inoltre può essere usato per estrarre la cifra più a destra di un numero: x%10 restituisce la cifra più a destra in base 10. Allo stesso modo x%100 restituisce le ultime due cifre". Perchè le ultime due?
Non dovrebbe restituire quella più a destra, cioè 0?

4.9, la ricorsione! Eccoci qua! Allora la cosa è semplice, la funzione ContoAllaRovescia chiama se stessa n volte finchè n non corrisponde a 0. Ora, la cosa che non capisco è questa:

"L'esecuzione di ContoAllaRovescia inizia con il valore di n=0. Dal momento che n è 0, essa stampa il testo "Partenza!" e poi ritorna

"La funzione ContoAllaRovescia che aveva n=1; e poi ritorna
La funzione ContoAllaRovescia che aveva n=2; e poi ritorna
E quindi torna il _main_ (questo è un trucco)

Io non capisco cosa è questo "che aveva n=x e poi ritorna... " e il "_main_ (questo è un trucco)". Quando n arriva ad essere uguale a 0 la funzione non dovrebbe terminare?

Paragrafo 4.7, primo esempio:

x=5
y=10

if x==y:
print x, "e", y, "sono uguali"
else:
if x<y:
print x, "è minore di", y

else:
print x, "è maggiore di", y

Sia l'idle che la command line mi riportano un errore di sintassi nel secondo else. Ora, stando alla guida si dovrebbe inserire una sola istruzione else. Quindi il programma per funzionare dovrebbe essere scritto in questo modo:

x=5
y=10

if x==y:
print x, "e", y, "sono uguali"
elif x<y:
print x, "è minore di", y

else:
print x, "è maggiore di", y


Anche se sembra strano dopo tutte le correzioni che ha avuto, può essere che è un errore del libro?


So che sono tante, ma alla fine non sono dubbi sul linguaggio di per sè, ma su come sono esposte le cose sul libro, se le cose che "non corrispondono" sono dovute a cambiamenti del linguaggio o altro (considerate il fatto che il libro è quasi di 9 anni fa e da allora ci sono stati sicuramente cambiamenti nel linguaggio)

[88MIKI88]

Pure io avevo trovato alcuni errori sul libro....però adesso non ricordo se avevo notato pure i tuoi!!!! Visto che hai scritto un "papiro" adesso prenderò in mano il manuale e starò lì a spulciare tutti i punti......



1) Concordo in pieno messaggio non è una variabile locale
2) Anche a me da lo stesso errore
3-4) quelle 2 domande hanno lasciato perplesso pure me quando ho letto cose del tipo "e se non fai nulla con il risultato che ti restituisce ecc..." . Non mi sembra una cosa al di fuori della realtà.

[cdimauro]

Appena ho un po' di tempo vedo di darvi una mano. Per adesso devo finire di scrivere l'articolo per domani. :D

[~FullSyst3m~]

Pure io avevo trovato alcuni errori sul libro....però adesso non ricordo se avevo notato pure i tuoi!!!! Visto che hai scritto un "papiro" adesso prenderò in mano il manuale e starò lì a spulciare tutti i punti......



1) Concordo in pieno messaggio non è una variabile locale
2) Anche a me da lo stesso errore
3-4) quelle 2 domande hanno lasciato perplesso pure me quando ho letto cose del tipo "e se non fai nulla con il risultato che ti restituisce ecc..." . Non mi sembra una cosa al di fuori della realtà.

Ti riferisci al "se non fai nulla con il risultato ecc ecc"?

Ok, cdimauro. Ora fai pure il giornalista?? :asd:

[banryu79]

Ok, cdimauro. Ora fai pure il giornalista?? :asd:

Scrive ottimi articoli, non lo sapevi?
-> link (http://www.appuntidigitali.it/author/cesare.dimauro/)

[~FullSyst3m~]

Scrive ottimi articoli, non lo sapevi?
-> link (http://www.appuntidigitali.it/author/cesare.dimauro/)

Si, lo sapevo che collaborava con appuntidigitali, ma non sapevo fosse cosi bravo. Sa fare tutto quest'uomo..

[~FullSyst3m~]

Tornando in topic, aggiungo una cosa che ho appena notato.
Partendo dal presupposto che quando si scrive un’istruzione return nell’idle al momento dell’esecuzione non ritorna nulla (si deve mettere un istruzione di stampa) mentre nella command line non ce n’è bisogno (e poi vorrei capire questa cosa), ho notato questo:

import math

def DistanzaTraDuePunti(x1,y1,x2,y2):
dx=x2-x1
dy=y2-y1
DistQuadrata=dx**2+dy**2
Risultato=math.sqrt(DistQuadrata)
print Risultato
return Risultato


def AreaCerchio(Raggio):
math.pi*Raggio**2


def AreaCerchio2(xc,yc,xp,yp):
Raggio=DistanzaTraDuePunti(xc,yc,xp,yp)
Risultato=AreaCerchio(Raggio)
print Risultato
return Risultato


print AreaCerchio(55)
AreaCerchio2(4,9,7,3)


1)AreaCerchio mi ritorna il valore None
2)Se chiamo la funzione AreaCerchio2, mi ritorna il risultato e poi il None
3)Se tolgo il print da AreaCerchio2 mi ritorna il valore, ma il None sparisce
4)Se metto il print davanti alla chiamata di funzione di AreaCerchio2 mi ritorna il valore e due None
Why??

Comunque per fare un pò di ordine riquoto il mio primo post, togliendo i dubbi ai quali si è già trovato risposta

Poi, capitolo 4, paragrafo 4.1: "Inoltre può essere usato per estrarre la cifra più a destra di un numero: x%10 restituisce la cifra più a destra in base 10. Allo stesso modo x%100 restituisce le ultime due cifre". Perchè le ultime due?
Non dovrebbe restituire quella più a destra, cioè 0?

4.9, la ricorsione! Eccoci qua! Allora la cosa è semplice, la funzione ContoAllaRovescia chiama se stessa n volte finchè n non corrisponde a 0. Ora, la cosa che non capisco è questa:

"L'esecuzione di ContoAllaRovescia inizia con il valore di n=0. Dal momento che n è 0, essa stampa il testo "Partenza!" e poi ritorna

"La funzione ContoAllaRovescia che aveva n=1; e poi ritorna
La funzione ContoAllaRovescia che aveva n=2; e poi ritorna
E quindi torna il _main_ (questo è un trucco)

Io non capisco cosa è questo "che aveva n=x e poi ritorna... " e il "_main_ (questo è un trucco)". Quando n arriva ad essere uguale a 0 la funzione non dovrebbe terminare?

Poi, paragrafo 4.7, primo esempio:

x=5
y=10

if x==y:
print x, "e", y, "sono uguali"
else:
if x<y:
print x, "è minore di", y

else:
print x, "è maggiore di", y

Sia l'idle che la command line mi riportano un errore di sintassi nel secondo else. Ora, stando alla guida si dovrebbe inserire una sola istruzione else. Quindi il programma per funzionare dovrebbe essere scritto in questo modo:

x=5
y=10

if x==y:
print x, "e", y, "sono uguali"
elif x<y:
print x, "è minore di", y

else:
print x, "è maggiore di", y


Anche se sembra strano dopo tutte le correzioni che ha avuto, può essere che è un errore del libro?




In attesa di risposta, Valerio Staffeli, hwupgrade forum, a voi la linea :asd:

[cdimauro]

Anche per oggi mi sono salvato in corner. :D

Stasera appena ho un po' di tempo finalmente mi smazzo tutto il thread e vedo cosa posso fare. :)

P.S. Mi fate arrossire così!!! :p

[~FullSyst3m~]

Anche per oggi mi sono salvato in corner. :D

Stasera appena ho un po' di tempo finalmente mi smazzo tutto il thread e vedo cosa posso fare. :)

P.S. Mi fate arrossire così!!! :p

In zona Cesarini! Comunque non c'è molto da smazzettare.. se ti muovi però!

P.S: non arrossire... In cdimauro we trust :ave:

[88MIKI88]

Ti riferisci al "se non fai nulla con il risultato ecc ecc"?




Esatto mi riferisco proprio a quella frase...quelle 3 domande non so perchè ma mi lasciano tuttora molto perplesso.....

[~FullSyst3m~]

Esatto mi riferisco proprio a quella frase...quelle 3 domande non so perchè ma mi lasciano tuttora molto perplesso.....

A me quella che mi lascia più perplesso è la prima, ma se guardi il capitolo 5 e riguardi la domanda si trova una risposta. Cioè, la seconda in pratica non puoi sommare una funzione (ad esempio UnaRigaVuota) ad un numero. Infatti se provi ti dà errore, la terza è nel capitolo 5, cioè le funzioni produttive. return in pratica.

La prima credo che la risposta più logica sia che non succede niente se il risultato non lo assegni a nessuna variabile o non lo inserisci in un'espressione. E come valore di ritorno non si intende il print (che è un'istruzione di stampa), ma il return che ritorna il valore alla funzione chiamante, almeno credo che sia cosi. Comunque aspetteremo conferme da cdimauro e dagli altri utenti

P.S: e comunque un'altra frase "strana" è questa:

"ritorna immediatamente da questa funzione a quella chiamante e usa questa espressione come valore di ritorno"

Non è sempre detto che ci sia una funzione che ne chiama un'altra. return potrebbe significare anche:

"ritorna immediatamente alla funzione chiamante e usa questa espressione come valore di ritorno"

[cdimauro]

Salve a tutti, ho deciso di aprire questo topic per postare i dubbi inerenti il libro in questione, può sempre capitare di non capire qualcosa. Ovviamente può postare chiunque, a patto che riguardi il libro altrimenti si fa confusione.
Inizio io:

un pò di chiarimenti sul capitolo 3

1) Paragrafo 3.10, penultima riga: "Anche i parametri sono locali: al dì fuori della funzione StampaUnite2Volte, non esiste alcuna cosa chiamata messaggio."
Ma in quella funzione messaggio non è una variabile locale, è stata creata prima. E' un errore del libro?
Sì, perché si riferisce alla variabile Unione.
2) Paragrafo 3.11. Dove si parla della traccia, io chiamo unione in stampa2volte:
def stampa2volte(valore):
print valore, valore

def stampaunite(parte1, parte2):
unione= parte1 + parte2
stampa2volte(unione)

strofa="nel mezzo "
strofa2="nel mezzo"

stampa2volte(unione)

ma l'errore che mi dà non è come quello della guida, ma diverso:

"Traceback (most recent call last):
File "C:/Documents and Settings/~FullSyst3m~/Desktop/test.py", line 11, in <module>
stampa2volte(unione)
NameError: name 'unione' is not defined"

Dipende dalla versione di python (quella del libro è vecchissima)?
Potrebbe anche essere, ma comunque la sostanza è la stessa: l'eccezione sollevata è sempre la NameError. Quella tua ti dà molte più informazioni, ma è sempre la stessa.

Quindi o prima Python riportava meno cose, o nel libro hanno preferito semplificare (un po' troppo) l'output.
3) Paragrafo 3.12. Funzioni con risultati. Non ho mai capito questa cosa. Cosa si intende per funzione che ritorna un risultato/valore?
Vuol dire che la funzione elabora i dati, e a chi l'ha chiamata restituisce poi qualcosa che magari gli serve.

Ad esempio se crei la funzione che calcola il fattoriale di un numero n, questa prende in input il numero n, fa tutti i suoi conti e ricava il fattoriale di questo numero. Lo prende e lo ritorna a chi l'ha chiamato che deciderà poi come utilizzarlo (stamparlo a video o farci altro).

Gli operatori classici (+, -, *, /, ecc.) li puoi pensare come funzioni che prendono in input dei valori e restituisco poi il risultato dell'operazione. Con le funzioni è esattamente la stessa cosa.
Stamp2Volte non ritorna la stampa del parametro?
No, non ritorna niente. Al suo interno provvede soltanto a stampare a video quello che le è stato passato, ma poi a chi l'ha chiamato non torna "nulla" (lo metto tra virgolette perché più avanti capirai meglio).
Perchè non viene considerata una funzione produttiva?
Perché non produce nulla come risultato, appunto. A chi l'ha chiamata non torna niente.

Al suo intero può fare quello che vuole, come stampare qualcosa a video ad esempio, ma comunque non ritorna nulla al chiamante.
4) Sempre paragrafo 3.12, la prima delle 3 domande:
una funzione del tipo? Se chiamo stampa2volte e non faccio niente con il risultato che viene restituito non succede niente. Non capisco cosa intende il libro quando dice "restituire un risultato" (si può collegare a quella di prima)
Vedi sopra perché il discorso è quello.

Per farti capire meglio, prova a stampare il risultato di Stampa2Volte e di questa funzione:
def FunzioneCheTornaQualcosa(Valore):
return Valore * 2

print 'Stampa2Volte ha restituito:', Stampa2Volte(10)
print 'FunzioneCheTornaQualcosa ha restituito:', FunzioneCheTornaQualcosa(10)(
Poi, capitolo 4, paragrafo 4.1: "Inoltre può essere usato per estrarre la cifra più a destra di un numero: x%10 restituisce la cifra più a destra in base 10. Allo stesso modo x%100 restituisce le ultime due cifre". Perchè le ultime due?
Non dovrebbe restituire quella più a destra, cioè 0?
Perché si tratta dell'operazione di resto del risultato di una divisione. x % 10 divide x per 10 e ne ritorna il resto, che sarà un valore compreso fra 0 e 9 (quindi 1 cifra).
x % 100 divide x per 100 e ritorna il resto, che stavolta sarà compreso fra 0 e 99 (2 cifre).
4.9, la ricorsione! Eccoci qua! Allora la cosa è semplice, la funzione ContoAllaRovescia chiama se stessa n volte finchè n non corrisponde a 0. Ora, la cosa che non capisco è questa:

"L'esecuzione di ContoAllaRovescia inizia con il valore di n=0. Dal momento che n è 0, essa stampa il testo "Partenza!" e poi ritorna

"La funzione ContoAllaRovescia che aveva n=1; e poi ritorna
La funzione ContoAllaRovescia che aveva n=2; e poi ritorna
E quindi torna il _main_ (questo è un trucco)

Io non capisco cosa è questo "che aveva n=x e poi ritorna... " e il "_main_ (questo è un trucco)". Quando n arriva ad essere uguale a 0 la funzione non dovrebbe terminare?
Infatti termina. Il concetto è il seguente. Tu passi a questa funzione un valore intero che supponiamo essere 3, come nell'esempio.

Appena entrati nella funzione, n avrà valore 3. Poiché c'è subito un controllo per vedere se per caso n è arrivato a 0, il sistema passa a eseguire il blocco dell'else che provvede come prima cosa a stampare n e poi a richiamare la funzione stessa, ma questa volta passandogli n - 1.

Il concetto che devi capire è che a questo punto l'esecuzione della funzione e il valore della variabile n vengono "congelati". Fatto questo, il computer crea una nuova variabile n e gli associa il valore 2 (cioé il valore della variabile n che è stata congelata, meno 1). A questo punto richiama nuovamente la funzione passandogli questa NUOVA variabile n, e sulla quale essa lavorerà.

E così via, fino a quando non verrà richiamata la funzione ma con n = 0. A questo punto la funzione stamperà quella scritta, e ritornerà indietro andando a "scongelare" le precedenti esecuzioni della funzione, fino ad arrivare alla prima esecuzione "congelata" che comporterà poi l'uscita "definitiva" dalla funzione e il ritorno al programma principale.
Paragrafo 4.7, primo esempio:

x=5
y=10

if x==y:
print x, "e", y, "sono uguali"
else:
if x<y:
print x, "è minore di", y

else:
print x, "è maggiore di", y

Sia l'idle che la command line mi riportano un errore di sintassi nel secondo else. Ora, stando alla guida si dovrebbe inserire una sola istruzione else. Quindi il programma per funzionare dovrebbe essere scritto in questo modo:

x=5
y=10

if x==y:
print x, "e", y, "sono uguali"
elif x<y:
print x, "è minore di", y

else:
print x, "è maggiore di", y


Anche se sembra strano dopo tutte le correzioni che ha avuto, può essere che è un errore del libro?
Il libro è corretto se ci fai caso. Sei tu che hai aggiunto una riga vuota prima dell'else. In questo caso con IDLE o con il prompt dei comandi Python ti dà errore, perché non ci possono essere spazi in quanto viene considerato come terminazione del blocco.

Gli spazi li puoi lasciare soltanto se scrivi quel codice in un file e poi lo esegui.
So che sono tante, ma alla fine non sono dubbi sul linguaggio di per sè, ma su come sono esposte le cose sul libro, se le cose che "non corrispondono" sono dovute a cambiamenti del linguaggio o altro (considerate il fatto che il libro è quasi di 9 anni fa e da allora ci sono stati sicuramente cambiamenti nel linguaggio)
E io sono per risponderti, nel limite delle mie possibilità e del mio tempo libero. :)

Spero di averti chiarito tutti i dubbi. ;)

[cdimauro]

Tornando in topic, aggiungo una cosa che ho appena notato.
Partendo dal presupposto che quando si scrive un’istruzione return nell’idle al momento dell’esecuzione non ritorna nulla (si deve mettere un istruzione di stampa) mentre nella command line non ce n’è bisogno (e poi vorrei capire questa cosa),
Nella command line l'interprete è predisposto per stampare eventuali risultati delle espressioni.

Quindi se scrivi ad esempio 3 * 5 ti stamperà 15.
ho notato questo:

import math

def DistanzaTraDuePunti(x1,y1,x2,y2):
dx=x2-x1
dy=y2-y1
DistQuadrata=dx**2+dy**2
Risultato=math.sqrt(DistQuadrata)
print Risultato
return Risultato


def AreaCerchio(Raggio):
math.pi*Raggio**2


def AreaCerchio2(xc,yc,xp,yp):
Raggio=DistanzaTraDuePunti(xc,yc,xp,yp)
Risultato=AreaCerchio(Raggio)
print Risultato
return Risultato


print AreaCerchio(55)
AreaCerchio2(4,9,7,3)


1)AreaCerchio mi ritorna il valore None
Perché non torni nulla, appunto. In Python affinché una funzione ritorni un valore devi utilizzare sempre l'istruzione return. Quindi così:
def AreaCerchio(Raggio):
return math.pi*Raggio**2
2)Se chiamo la funzione AreaCerchio2, mi ritorna il risultato e poi il None
Con quel codice sbagliato deve tornarti None e stampartelo pure a video.
3)Se tolgo il print da AreaCerchio2 mi ritorna il valore, ma il None sparisce
Perché viene omesso dalla command line.
4)Se metto il print davanti alla chiamata di funzione di AreaCerchio2 mi ritorna il valore e due None
Why??
Il primo None lo stampa perché lo fa AreaCerchio2. Il secondo perché gliel'hai chiesto esplicitamente tu.

Questo perché tu stai usando Python dalla command line, che è una speciale modalità utile per "smanettare", provando al volo pezzi di codice.
Comunque per fare un pò di ordine riquoto il mio primo post, togliendo i dubbi ai quali si è già trovato risposta
Troppo tardi, non avevo letto. :( Ho risposto a tutto. :stordita:
In attesa di risposta, Valerio Staffeli, hwupgrade forum, a voi la linea :asd:
:rotfl:

[~FullSyst3m~]

Sì, perché si riferisce alla variabile Unione.

O magari alla variabile messaggio, ma visto il contesto è più probabile che si riferisca ad unione

Potrebbe anche essere, ma comunque la sostanza è la stessa: l'eccezione sollevata è sempre la NameError. Quella tua ti dà molte più informazioni, ma è sempre la stessa.

Quindi o prima Python riportava meno cose, o nel libro hanno preferito semplificare (un po' troppo) l'output.

Io credo che sia una questione di versione di software. Comunque tu che usi python da un pò dovresti saperlo no??

Vuol dire che la funzione elabora i dati, e a chi l'ha chiamata restituisce poi qualcosa che magari gli serve.

Ad esempio se crei la funzione che calcola il fattoriale di un numero n, questa prende in input il numero n, fa tutti i suoi conti e ricava il fattoriale di questo numero. Lo prende e lo ritorna a chi l'ha chiamato che deciderà poi come utilizzarlo (stamparlo a video o farci altro).

Gli operatori classici (+, -, *, /, ecc.) li puoi pensare come funzioni che prendono in input dei valori e restituisco poi il risultato dell'operazione. Con le funzioni è esattamente la stessa cosa.

Capito!

No, non ritorna niente. Al suo interno provvede soltanto a stampare a video quello che le è stato passato, ma poi a chi l'ha chiamato non torna "nulla" (lo metto tra virgolette perché più avanti capirai meglio).

Ok, aspetterò più avanti! Comunque capito tutto il resto!

Per farti capire meglio, prova a stampare il risultato di Stampa2Volte e di questa funzione

Adesso sono fuori, quando torno a casa provo

Perché si tratta dell'operazione di resto del risultato di una divisione. x % 10 divide x per 10 e ne ritorna il resto, che sarà un valore compreso fra 0 e 9 (quindi 1 cifra).
x % 100 divide x per 100 e ritorna il resto, che stavolta sarà compreso fra 0 e 99 (2 cifre).

Capito!

Infatti termina. Il concetto è il seguente. Tu passi a questa funzione un valore intero che supponiamo essere 3, come nell'esempio.

Appena entrati nella funzione, n avrà valore 3. Poiché c'è subito un controllo per vedere se per caso n è arrivato a 0, il sistema passa a eseguire il blocco dell'else che provvede come prima cosa a stampare n e poi a richiamare la funzione stessa, ma questa volta passandogli n - 1.

Il concetto che devi capire è che a questo punto l'esecuzione della funzione e il valore della variabile n vengono "congelati". Fatto questo, il computer crea una nuova variabile n e gli associa il valore 2 (cioé il valore della variabile n che è stata congelata, meno 1). A questo punto richiama nuovamente la funzione passandogli questa NUOVA variabile n, e sulla quale essa lavorerà.

E così via, fino a quando non verrà richiamata la funzione ma con n = 0. A questo punto la funzione stamperà quella scritta, e ritornerà indietro andando a "scongelare" le precedenti esecuzioni della funzione, fino ad arrivare alla prima esecuzione "congelata" che comporterà poi l'uscita "definitiva" dalla funzione e il ritorno al programma principale.

Tutto chiaro! Grazie :ave:

Il libro è corretto se ci fai caso. Sei tu che hai aggiunto una riga vuota prima dell'else. In questo caso con IDLE o con il prompt dei comandi Python ti dà errore, perché non ci possono essere spazi in quanto viene considerato come terminazione del blocco.

Gli spazi li puoi lasciare soltanto se scrivi quel codice in un file e poi lo esegui

Ma io infatti oltre a scrivere nella command line l'ho scritto nel file e l'ho eseguito dall'idle, ma mi dà lo stesso errore. E poi perchè viene considerata come un'interruzione del blocco? Non sono in una funzione. E poi non si dovrebbe poter usare un solo else? Inoltre, un else senza un altra istruzione condizionale prima non si può usare?

Nella command line l'interprete è predisposto per stampare eventuali risultati delle espressioni.

Quindi se scrivi ad esempio 3 * 5 ti stamperà 15.

Questo lo sapevo, ma non sapeva che era predisposto anche per i return (che scemo!) :D

Perché non torni nulla, appunto. In Python affinché una funzione ritorni un valore devi utilizzare sempre l'istruzione return. Quindi così:

Chiaro

Con quel codice sbagliato deve tornarti None e stampartelo pure a video.

Questo perchè ho inserito il print in AreaCerchio (mi riferisco all'idle)?

Perché viene omesso dalla command line.

Perchè viene omesso? Comunque io queste prove le ho fatte nell'idle, non nella command line

Il primo None lo stampa perché lo fa AreaCerchio2. Il secondo perché gliel'hai chiesto esplicitamente tu.

Questo perché tu stai usando Python dalla command line, che è una speciale modalità utile per "smanettare", provando al volo pezzi di codice.

Come ho detto in questo caso lo uso dall'idle. Se lo fa AreaCerchio2, allora perchè quando ho tolto il print mi dà il risultato senza None? E dove gliel'ho chiesto esplicitamente io?

In attesa di risposta, Valerio Staffeli, hwupgrade forum, a voi la linea

In attesa di risposta, Valerio Staffeli, hwupgrade forum, a voi la linea :asd:

[cdimauro]

O magari alla variabile messaggio, ma visto il contesto è più probabile che si riferisca ad unione
E' sicuramente Unione.
Io credo che sia una questione di versione di software. Comunque tu che usi python da un pò dovresti saperlo no??
Mica mi ricordo i dettagli con tutte le differenze fra le varie versioni. :p
Ma io infatti oltre a scrivere nella command line l'ho scritto nel file e l'ho eseguito dall'idle, ma mi dà lo stesso errore.
Idle l'ho usato pochissimo all'inizio, ma che io ricordi dovrebbe comportarsi come la command line (oltre ad aggiungere altre cose).
E poi perchè viene considerata come un'interruzione del blocco? Non sono in una funzione.
Non importa: un blocco lo puoi definire anche fuori dalle funzioni.
E poi non si dovrebbe poter usare un solo else?
Sì, ma tu ne hai messo un altro dopo, separato però da una riga vuota.
Inoltre, un else senza un altra istruzione condizionale prima non si può usare?
No, appunto. Dev'essere legato per forza a un precedente if. Con la riga vuota questo "legame" viene spezzato (tranne se conservi il file e lo esegui poi da prompt dei comandi con Python NomeFile.py).
Questo perchè ho inserito il print in AreaCerchio (mi riferisco all'idle)?
Sì
Perchè viene omesso? Comunque io queste prove le ho fatte nell'idle, non nella command line
Dovrebbe essere lo stesso.

Viene omesso perché se non metti print e una funzione non torna nulla, di default non stampa nulla la command line (o idle).
Come ho detto in questo caso lo uso dall'idle. Se lo fa AreaCerchio2, allora perchè quando ho tolto il print mi dà il risultato senza None?
Vedi sotto. :p
E dove gliel'ho chiesto esplicitamente io?
Se metti print prima stai chiedendo a Python di stampare qualunque cosa venga tornato dalla funzione, quindi anche None (che significa, appunto, niente).
In attesa di risposta, Valerio Staffeli, hwupgrade forum, a voi la linea :asd:
:p

[~FullSyst3m~]

Mica mi ricordo i dettagli con tutte le differenze fra le varie versioni
Vabbè parlavo in linee generali!
Idle l'ho usato pochissimo all'inizio, ma che io ricordi dovrebbe comportarsi come la command line (oltre ad aggiungere altre cose).
Non si comporta proprio come la command line, là i comandi vengono interpretati in tempo reale, nell'idle invece un'istruzione return non viene visualizzata se non si inserisce un print
Non importa: un blocco lo puoi definire anche fuori dalle funzioni. Sì, ma tu ne hai messo un altro dopo, separato però da una riga vuota. No, appunto. Dev'essere legato per forza a un precedente if. Con la riga vuota questo "legame" viene spezzato (tranne se conservi il file e lo esegui poi da prompt dei comandi con Python NomeFile.py).
Si lo so che si può definire anche fuori dalle funzioni, ma non sapevo che mettendo uno spazio python lo interpretava come la fine di un blocco. Comunque resta sempre il fatto che ci sono due else, quando invece li libro dice che ce ne dovrebbe essere solo uno. Come mai?
E per quanto riguarda il "legame", se io conservo il file e lo eseguo dalla shell, che cambia? La sintassi di Python se è questa non può cambiare
Viene omesso perché se non metti print e una funzione non torna nulla, di default non stampa nulla la command line (o idle). Se metti print prima stai chiedendo a Python di stampare qualunque cosa venga tornato dalla funzione, quindi anche None (che significa, appunto, niente).
Su questo siamo d'accordo, ma ad esempio, mettendo il print in DistanzaTraDuePunti e AreaCerchio2, non dovrebbe tornarmi nessun None visto che in AreaCerchio non c'è nessun print, invece mi ritorna il None. Perchè?
import math

def DistanzaTraDuePunti(x1,y1,x2,y2):
dx=x2-x1
dy=y2-y1
DistQuadrata=dx**2+dy**2
Risultato=math.sqrt(DistQuadrata)
print Risultato
return Risultato



def AreaCerchio(Raggio):
math.pi*Raggio**2


def AreaCerchio2(xc,yc,xp,yp):
Raggio=DistanzaTraDuePunti(xc,yc,xp,yp)
Risultato=AreaCerchio(Raggio)
print Risultato
return Risultato



AreaCerchio2 (21,36,5,8)

Se invece tolgo il print ad AreaCerchio2 mi stampa il risultato senza nessun None

Viene omesso perché se non metti print e una funzione non torna nulla, di default non stampa nulla la command line (o idle).
Ma AreaCerchio ritorna qualcosa, eccome. Tutte e tre le funzioni ritornano dei valori

[88MIKI88]

9.4 Numeri casuali

La maggior parte dei programmi fanno la stessa cosa ogni volta che vengono eseguiti e sono detti per questo deterministici. Di solito un programma deterministico è una cosa voluta in quanto a parità di dati in ingresso ci attendiamo lo stesso risultato. Per alcune applicazioni, invece, abbiamo bisogno che l'esecuzione sia imprevedibile: i videogiochi sono un esempio lampante, ma ce ne sono tanti altri.

Creare un programma realmente non deterministico (e quindi imprevedibile) è una cosa piuttosto difficile, ma ci sono dei sistemi per renderlo abbastanza casuale da soddisfare la maggior parte delle esigenze in tal senso. Uno dei sistemi è quello di generare dei numeri casuali ed usarli per determinare i risultati prodotti dal programma. Python fornisce delle funzioni di base che generano numeri pseudocasuali: questi numeri non sono realmente casuali in senso matematico ma per i nostri scopi saranno più che sufficienti.

Il modulo random contiene una funzione chiamata random che restituisce un numero in virgola mobile compreso tra 0.0 (compreso) e 1.0 (escluso). Ad ogni chiamata di random si ottiene il numero seguente di una lunga serie di numeri pseudocasuali. Per vedere un esempio prova ad eseguire questo ciclo:

import random

for i in range(10):
x = random.random()
print x

Per generare un numero casuale (lo chiameremo così d'ora in poi, anche se è sottinteso che la casualità ottenuta non è assoluta) compreso tra 0.0 (compreso) ed un limite superiore Limite (escluso) moltiplica x per Limite.

Esercizio: tenta di generare un numero casuale compreso tra il \linebreak LimiteInferiore (compreso) ed il LimiteSuperiore (escluso).

Esercizio addizionale: genera un numero intero compreso tra il \linebreak LimiteInferiore ed il LimiteSuperiore comprendendo entrambi questi limiti.



Questa parte mi lascia un pò perplesso soprattutto la parte che inizia con "Per Generare....." .

[88MIKI88]

Capitolo 9 Tuple

9.3 Tuple come valori di ritorno

Le funzioni possono ritornare tuple. Per fare un esempio possiamo scrivere una funzione che scambia due valori:

def Scambia(x, y):
return y, x

e in seguito possiamo assegnare il valore di ritorno della funzione ad una tupla di due variabili:

a, b = Scambia(a, b)


Non puoi effettuare un assegnamento del genere o sbaglio??!!!!! a,b=Scambia(a,b)

Genera un'errore: SyntaxError: can't assign to literal

[cdimauro]

Non si comporta proprio come la command line, là i comandi vengono interpretati in tempo reale, nell'idle invece un'istruzione return non viene visualizzata se non si inserisce un print
OK. Passa a un IDE migliore. :D
Si lo so che si può definire anche fuori dalle funzioni, ma non sapevo che mettendo uno spazio python lo interpretava come la fine di un blocco.
In Python l'indentazione è importante.
Comunque resta sempre il fatto che ci sono due else, quando invece li libro dice che ce ne dovrebbe essere solo uno. Come mai?
Hai sbagliato ancora una volta l'indentazione, e hai appioppato anche il secondo else al primo.

Se avessi usato un editor come SPE o Komodo Edit, ti sarebbe stato immediatamente segnalato.
E per quanto riguarda il "legame", se io conservo il file e lo eseguo dalla shell, che cambia? La sintassi di Python se è questa non può cambiare
Da command line Python differisce un po' per quanto riguarda la definizione dei blocchi, perché la prima riga vuota la interpreta come fine del blocco.

La command line di Python NON è fatta per lavorare seriamente, ma soltanto per SPERIMENTARE velocemente pezzi di codice. Da qui l'esigenza di chiudere i blocchi alla prima riga vuota.

Per lavorare seriamente usa un editore decente.
Su questo siamo d'accordo, ma ad esempio, mettendo il print in DistanzaTraDuePunti e AreaCerchio2, non dovrebbe tornarmi nessun None visto che in AreaCerchio non c'è nessun print, invece mi ritorna il None. Perchè?
import math

def DistanzaTraDuePunti(x1,y1,x2,y2):
dx=x2-x1
dy=y2-y1
DistQuadrata=dx**2+dy**2
Risultato=math.sqrt(DistQuadrata)
print Risultato
return Risultato



def AreaCerchio(Raggio):
math.pi*Raggio**2


def AreaCerchio2(xc,yc,xp,yp):
Raggio=DistanzaTraDuePunti(xc,yc,xp,yp)
Risultato=AreaCerchio(Raggio)
print Risultato
return Risultato



AreaCerchio2 (21,36,5,8)

Se invece tolgo il print ad AreaCerchio2 mi stampa il risultato senza nessun None

Ma AreaCerchio ritorna qualcosa, eccome. Tutte e tre le funzioni ritornano dei valori
AreaCerchio non ritorna proprio nulla invece (a parte il None, appunto) perché manca l'istruzione return. In Python una funzione torna qualcosa se viene usata l'istruzione return, altrimenti per default viene sempre tornato None.

Purtroppo fino a quando non userai un editor come si deve avremo problemi di questo tipo.

[~FullSyst3m~]

def FunzioneCheTornaQualcosa(Valore):
return Valore * 2

print 'Stampa2Volte ha restituito:', Stampa2Volte(10)
print 'FunzioneCheTornaQualcosa ha restituito:', FunzioneCheTornaQualcosa(10)(

Il primo mi ritorna: TypeError: Stampa2Volte() takes no arguments (1 given)
Il secondo: FunzioneCheTornaQualcosa ha restituito 20

[cdimauro]

9.4 Numeri casuali

La maggior parte dei programmi fanno la stessa cosa ogni volta che vengono eseguiti e sono detti per questo deterministici. Di solito un programma deterministico è una cosa voluta in quanto a parità di dati in ingresso ci attendiamo lo stesso risultato. Per alcune applicazioni, invece, abbiamo bisogno che l'esecuzione sia imprevedibile: i videogiochi sono un esempio lampante, ma ce ne sono tanti altri.

Creare un programma realmente non deterministico (e quindi imprevedibile) è una cosa piuttosto difficile, ma ci sono dei sistemi per renderlo abbastanza casuale da soddisfare la maggior parte delle esigenze in tal senso. Uno dei sistemi è quello di generare dei numeri casuali ed usarli per determinare i risultati prodotti dal programma. Python fornisce delle funzioni di base che generano numeri pseudocasuali: questi numeri non sono realmente casuali in senso matematico ma per i nostri scopi saranno più che sufficienti.

Il modulo random contiene una funzione chiamata random che restituisce un numero in virgola mobile compreso tra 0.0 (compreso) e 1.0 (escluso). Ad ogni chiamata di random si ottiene il numero seguente di una lunga serie di numeri pseudocasuali. Per vedere un esempio prova ad eseguire questo ciclo:

import random

for i in range(10):
x = random.random()
print x

Per generare un numero casuale (lo chiameremo così d'ora in poi, anche se è sottinteso che la casualità ottenuta non è assoluta) compreso tra 0.0 (compreso) ed un limite superiore Limite (escluso) moltiplica x per Limite.

Esercizio: tenta di generare un numero casuale compreso tra il \linebreak LimiteInferiore (compreso) ed il LimiteSuperiore (escluso).

Esercizio addizionale: genera un numero intero compreso tra il \linebreak LimiteInferiore ed il LimiteSuperiore comprendendo entrambi questi limiti.



Questa parte mi lascia un pò perplesso soprattutto la parte che inizia con "Per Generare....." .
Significa semplicemente tirare fuori = calcolare dei numeri. In questo caso dovrebbero essere numeri casuali.

La prossima volta per favore metti il testo in un blocco quote e soltanto il codice in un blocco code, altrimenti impazzisco a leggere. :cry:
Capitolo 9 Tuple

9.3 Tuple come valori di ritorno

Le funzioni possono ritornare tuple. Per fare un esempio possiamo scrivere una funzione che scambia due valori:

def Scambia(x, y):
return y, x

e in seguito possiamo assegnare il valore di ritorno della funzione ad una tupla di due variabili:

a, b = Scambia(a, b)


Non puoi effettuare un assegnamento del genere o sbaglio??!!!!! a,b=Scambia(a,b)

Genera un'errore: SyntaxError: can't assign to literal
Posta tutto il codice, perché a me funziona perfettamente (da command line):
>>> def Scambia(x, y):
... return y, x
...
>>> a = 1
>>> b = 2
>>> a, b = Scambia(a, b)
>>> a
2
>>> b
1
>>>

[~FullSyst3m~]

OK. Passa a un IDE migliore.
Purtroppo fino a quando non userai un editor come si deve avremo problemi di questo tipo.
Per lavorare seriamente usa un editore decente.
Se avessi usato un editor come SPE o Komodo Edit, ti sarebbe stato immediatamente segnalato

Mi sa che hai ragione, se un altro IDE me lo segnala posso imparare subito ad evitare questi errori da principiante

In Python l'indentazione è importante.

Eh, lo so :D

Hai sbagliato ancora una volta l'indentazione, e hai appioppato anche il secondo else al primo.

Che significa che ho appioppato il secondo else al primo?

Da command line Python differisce un po' per quanto riguarda la definizione dei blocchi, perché la prima riga vuota la interpreta come fine del blocco.

La command line di Python NON è fatta per lavorare seriamente, ma soltanto per SPERIMENTARE velocemente pezzi di codice. Da qui l'esigenza di chiudere i blocchi alla prima riga vuota.

Scusa, se è per questo anche nell'IDLE integrato, da quanto mi hai detto tu e da quanto ho visto, la prima riga vuota la interpreta come la fine del blocco

AreaCerchio non ritorna proprio nulla invece (a parte il None, appunto) perché manca l'istruzione return. In Python una funzione torna qualcosa se viene usata l'istruzione return, altrimenti per default viene sempre tornato None.


Se rileggi il "caso", vedrai che alcune volte i conti non tornano..

[cdimauro]

def FunzioneCheTornaQualcosa(Valore):
return Valore * 2

print 'Stampa2Volte ha restituito:', Stampa2Volte(10)
print 'FunzioneCheTornaQualcosa ha restituito:', FunzioneCheTornaQualcosa(10)(

Il primo mi ritorna: TypeError: Stampa2Volte() takes no arguments (1 given)
Il secondo: FunzioneCheTornaQualcosa ha restituito 20
A me ha funzionato:
>>> def Stampa2Volte(Valore):
... print Valore, Valore
...
>>> def FunzioneCheTornaQualcosa(Valore):
... return Valore * 2
...
>>> print 'Stampa2Volte ha restituito:', Stampa2Volte(10)
Stampa2Volte ha restituito: 10 10
None
>>> print 'FunzioneCheTornaQualcosa ha restituito:', FunzioneCheTornaQualcosa(10)
FunzioneCheTornaQualcosa ha restituito: 20
>>>
:)

[cdimauro]

Mi sa che hai ragione, se un altro IDE me lo segnala posso imparare subito ad evitare questi errori da principiante
Esatto. Io è da quando ho scoperto SPE che non ne faccio. :p
Che significa che ho appioppato il secondo else al primo?
Che il primo if aveva subito dopo l'else che, in teoria, avrebbe dovuto chiudere il blocco condizionale. Poco dopo c'era l'altro else che era allineato al primo if, ma questo è un errore perché l'if aveva già un else e il blocco era stato già chiuso.
Scusa, se è per questo anche nell'IDLE integrato, da quanto mi hai detto tu e da quanto ho visto, la prima riga vuota la interpreta come la fine del blocco
Appunto. Evita di usare IDLE perché sta facendo più danni che altro.
Se rileggi il "caso", vedrai che alcune volte i conti non tornano..
Tu prova con SPE e poi vediamo se i conti tornano o no. ;)

[88MIKI88]

Posta tutto il codice, perché a me funziona perfettamente (da command line):
>>> def Scambia(x, y):
... return y, x
...
>>> a = 1
>>> b = 2
>>> a, b = Scambia(a, b)
>>> a
2
>>> b
1
>>>[/QUOTE]

Ops....mi sa che ho fatto una gaffe...non so perchè ma prima non mi funzionava adesso va...excuse me cdimauro

[~FullSyst3m~]

A me ha funzionato:
>>> def Stampa2Volte(Valore):
... print Valore, Valore
...
>>> def FunzioneCheTornaQualcosa(Valore):
... return Valore * 2
...
>>> print 'Stampa2Volte ha restituito:', Stampa2Volte(10)
Stampa2Volte ha restituito: 10 10
None
>>> print 'FunzioneCheTornaQualcosa ha restituito:', FunzioneCheTornaQualcosa(10)
FunzioneCheTornaQualcosa ha restituito: 20
>>>
:)

Si scusa, io stavo pensando alla funzione che stampa più righe vuote! Si funziona. Il senso di questo "test" è quello di dimostrare che quel None significa che stampa2volte non ritorna nulla giusto?

[~FullSyst3m~]

Esatto. Io è da quando ho scoperto SPE che non ne faccio
:D Cosi per parlare, ma un buon programmatore non dovrebbe fare a meno di questi "aiuti"?
Che il primo if aveva subito dopo l'else che, in teoria, avrebbe dovuto chiudere il blocco condizionale. Poco dopo c'era l'altro else che era allineato al primo if, ma questo è un errore perché l'if aveva già un else e il blocco era stato già chiuso.
Capito, ma dovrei rivedere l'esempio per essere completamente sicuro perchè questa storia della riga vuota e di questo IDLE mi confusionando, maledetto IDLE
Appunto. Evita di usare IDLE perché sta facendo più danni che altro.
Ma il fatto della riga vuota non è un problema dell'IDLE, ma è la sintassi del linguaggio. Che c'entra l'IDLE? Comunque ho capito che devo cambiarlo, ora vedo cosa c'è per linux
Tu prova con SPE e poi vediamo se i conti tornano o no.
Siamo sempre là, il linguaggio è quello. Non è che l'IDLE si inventa i valori che deve tornare!

[~FullSyst3m~]

Posta tutto il codice, perché a me funziona perfettamente (da command line):
>>> def Scambia(x, y):
... return y, x
...
>>> a = 1
>>> b = 2
>>> a, b = Scambia(a, b)
>>> a
2
>>> b
1
>>>

Ops....mi sa che ho fatto una gaffe...non so perchè ma prima non mi funzionava adesso va...excuse me cdimauro

Avrai fatto sicuramente qualche errore di sintassi ;)

[cdimauro]

Ops....mi sa che ho fatto una gaffe...non so perchè ma prima non mi funzionava adesso va...excuse me cdimauro
Per così poco? Ma non ci pensare nemmeno di scusarti! :p

Qui nessuno nasce imparato e la vita è costellata di errori. L'importante è superarli e non farsi abbattere da loro. ;)
Si scusa, io stavo pensando alla funzione che stampa più righe vuote! Si funziona. Il senso di questo "test" è quello di dimostrare che quel None significa che stampa2volte non ritorna nulla giusto?
Esattamente. Se stampa Non è proprio perché non torna nulla. Se metti, invece, un return QualcheCosa noterai la differenza. ;)
:D Cosi per parlare, ma un buon programmatore non dovrebbe fare a meno di questi "aiuti"?
Al contrario: un programmatore deve utilizzare tutti gli strumenti (se può) per risolvere nel migliore dei modi i problemi.

Altrimenti saremmo ancora fermi alle schede perforate e al linguaggio macchina. :p
Capito, ma dovrei rivedere l'esempio per essere completamente sicuro perchè questa storia della riga vuota e di questo IDLE mi confusionando, maledetto IDLE

Ma il fatto della riga vuota non è un problema dell'IDLE, ma è la sintassi del linguaggio. Che c'entra l'IDLE? Comunque ho capito che devo cambiarlo, ora vedo cosa c'è per linux

Siamo sempre là, il linguaggio è quello. Non è che l'IDLE si inventa i valori che deve tornare!
Il linguaggio funziona bene anche con le righe vuote invece, se usi un buon IDE e fai eseguire l'applicazione dall'IDE stesso o da riga di comando scrivendo python NomeProgramma.py.

Io nel mio codice metto delle righe vuote in mezzo ai blocchi degli if, e i blocchi non si chiudono, ma proseguono tranquillamente fino a che non è l'indentazione a cambiare. ;)

[~FullSyst3m~]

Qui nessuno nasce imparato e la vita è costellata di errori. L'importante è superarli e non farsi abbattere da loro.

Sagge parole, sagge parole mio maestro :ave:

Il linguaggio funziona bene anche con le righe vuote invece, se usi un buon IDE e fai eseguire l'applicazione dall'IDE stesso o da riga di comando scrivendo python NomeProgramma.py.

Io nel mio codice metto delle righe vuote in mezzo ai blocchi degli if, e i blocchi non si chiudono, ma proseguono tranquillamente fino a che non è l'indentazione a cambiare. ;)

Quindi è tutto un problema di IDLE? Perchè allora lo fa anche nella cl? Prima hai detto comunque che è Python che interpreta la riga vuota come la fine del blocco

[cdimauro]

E' l'interprete interattivo (intendevo con questo quando mi riferivo a command line in quel preciso contesto) che lo interpreta così.

Se metti il codice su un file e da prompt dei comandi scrivi python NomeApplicazione.py vedrai che le righe vuote verranno ignorate da Python. ;)

Lo ripeto: la modalità interattiva di Python è leggermente diversa da come si comporta il linguaggio normalmente, ma è fatta apposta così per smanettare.

P.S. Hai la mailbox piena: vedi di cancellare un po' di messaggi, perché non ne puoi più ricevere altri. Te l'avevo detto di non usare i PVT: per queste cose c'è il forum. ;)

[~FullSyst3m~]

E' l'interprete interattivo (intendevo con questo quando mi riferivo a command line in quel preciso contesto) che lo interpreta così.

Se metti il codice su un file e da prompt dei comandi scrivi python NomeApplicazione.py vedrai che le righe vuote verranno ignorate da Python. ;)

Lo ripeto: la modalità interattiva di Python è leggermente diversa da come si comporta il linguaggio normalmente, ma è fatta apposta così per smanettare.

P.S. Hai la mailbox piena: vedi di cancellare un po' di messaggi, perché non ne puoi più ricevere altri. Te l'avevo detto di non usare i PVT: per queste cose c'è il forum. ;)

Per interprete interattivo intendi la command line guisto? Comunque non lo fa solo con la command line, ma anche con l'IDLE come ho già detto. Inoltre, so che serve per smanettare la command line, appunto per questo dovrebbe essere meno rigorosa. Alla fine comunque python lo spazio lo associa alla fine del blocco oppure è solo la modalità interattiva che si comporta cosi e il linguaggio ignora le righe vuote?

P.S: cancellati, lo so che devo usare il forum! Lo uso infatti, è solo per le cose cosi che mi passano per la testa che evito di confusionare il 3d ;)

Esattamente. Se stampa Non è proprio perché non torna nulla. Se metti, invece, un return QualcheCosa noterai la differenza.

Se scrivo:
def stampa (valore):
... return valore, valore


chiamandola con 10 come parametro mi torna (10, 10) e il perchè delle parentesi non lo capisco

se invece nella funzione al posto di return valore, valore metto return valore * 2 mi ritorna 20

Poi, una piccola curiosità che ho notato smanettando nella command line:

x = 1
>>> if x > 0:
... if x < 1:
... print "Ok!"
... else:
... print "Sarà per la prossima volta!"


non mi stampa nulla. Lo modifico cosi:

if x > 0:
... if x == 1:
... print "Esatto!"
... else:
... print "Sbagliato!"
...
Esatto!


e mi visualizza la stampa. Per caso fa cosi perchè quei due if dovrebbero essere tutte e due veri? Però se cosi fosse, visto che non sono tutte e due veri, dovrebbe stamparmi l'else

[cdimauro]

E' solo con la modalità interattiva che contano le righe vuote, come ho detto.

Sono differenze di cui si deve tenere conto. Io preferisco un IDE per le applicazioni, e l'interprete interattivo per piccoli pezzi di codice da testare al volo.

P.S. Adesso vado veramente a nanna. :D

[~FullSyst3m~]

E' solo con la modalità interattiva che contano le righe vuote, come ho detto.

Sono differenze di cui si deve tenere conto. Io preferisco un IDE per le applicazioni, e l'interprete interattivo per piccoli pezzi di codice da testare al volo.

P.S. Adesso vado veramente a nanna. :D

Prima avevi detto che Python considera la riga vuota come la fine del blocco, c'è differenza. L'importante è capirsi alla fine comunque., anche se comunque non è solo con la modalità interattiva, ma anche con l'IDLE di serie, si comporta allo stesso modo sotto questo aspetto. I pezzi di codice alla fine li puoi testare pure nell'IDE, soprattutto visto che l'interprete ha le sue regole. Ma le caratteristiche dell'interprete, come questa della riga vuota ad esempio, dove si possono trovare? Nella documentazione ufficiale ci sono?

Comunque vado a nanna pure io, metto a scaricare SPE prima però :D

[cdimauro]

Nel manuale ovviamente sono riportate queste differenze.

Per chiarezza: quando di mezzo c'è l'interattività, Python interpreta le righe vuote come condizione di fine blocco.

Quando invece si realizzano applicazioni da lanciare tramite python NomeApplicazione.py, si seguono le regole standard (le righe vuote non hanno nessun effetto: conta soltanto il livello d'indentazione). ;)

[~FullSyst3m~]

Nel manuale ovviamente sono riportate queste differenze.

Per chiarezza: quando di mezzo c'è l'interattività, Python interpreta le righe vuote come condizione di fine blocco.

Quando invece si realizzano applicazioni da lanciare tramite python NomeApplicazione.py, si seguono le regole standard (le righe vuote non hanno nessun effetto: conta soltanto il livello d'indentazione). ;)

Ora si che è chiaro! ;) Ma comunque questo vuol dire che l'IDLE funziona come l'interprete visto che lo considera pure come fine blocco lo spazio

Riscrivo quello che avevo scritto sopra, casomai non si era letto visto che ho modificato il messaggio:
se scrivo:

def stampa (valore):
... return valore, valore

chiamandola con 10 come parametro mi torna (10, 10) e il perchè delle parentesi non lo capisco

se invece nella funzione al posto di return valore, valore metto return valore * 2 mi ritorna 20

Poi, una piccola curiosità che ho notato smanettando nella command line:

x = 1
>>> if x > 0:
... if x < 1:
... print "Ok!"
... else:
... print "Sarà per la prossima volta!"

non mi stampa nulla. Se lo modifico cosi invece:

if x > 0:
... if x == 1:
... print "Esatto!"
... else:
... print "Sbagliato!"
...
Esatto!

mi visualizza la stampa. Per caso fa cosi perchè quei due if dovrebbero essere tutte e due veri? Però se cosi fosse, visto che non sono tutte e due veri, dovrebbe stamparmi l'else

[cdimauro]

Ora si che è chiaro! ;) Ma comunque questo vuol dire che l'IDLE funziona come l'interprete visto che lo considera pure come fine blocco lo spazio
Appunto. E' ora di passare a un buon IDE. :D
Riscrivo quello che avevo scritto sopra, casomai non si era letto visto che ho modificato il messaggio:
se scrivo:

def stampa (valore):
... return valore, valore

chiamandola con 10 come parametro mi torna (10, 10) e il perchè delle parentesi non lo capisco
Perché stai tornando una coppia di valori, che in Python si chiama tupla. ;)
se invece nella funzione al posto di return valore, valore metto return valore * 2 mi ritorna 20
Esattamente, perché torni UN solo valore.
Poi, una piccola curiosità che ho notato smanettando nella command line:

x = 1
>>> if x > 0:
... if x < 1:
... print "Ok!"
... else:
... print "Sarà per la prossima volta!"

non mi stampa nulla. Se lo modifico cosi invece:

if x > 0:
... if x == 1:
... print "Esatto!"
... else:
... print "Sbagliato!"
...
Esatto!

mi visualizza la stampa. Per caso fa cosi perchè quei due if dovrebbero essere tutte e due veri? Però se cosi fosse, visto che non sono tutte e due veri, dovrebbe stamparmi l'else
Mi sembra normale. In entrambi casi entri nel primo if, ma il problema è nell'if successivo.
Nel primo caso stai dicendo che il numero x dev'essere contemporaneamente maggiore di 0 e minore di 1, ed essendo un intero è una condizione impossibile da soddisfare.
Nel secondo caso stai dicendo che è maggiore di 0 e dev'essere uguale, e quindi la condizione è sempre soddisfatta per x = 1 (si potrebbe anche rimuovere il primo if).

[~FullSyst3m~]

N.B: x=5
y=10

if x==y:
print x, "e", y, "sono uguali"
else:
if x<y:
print x, "è minore di", y

else:
print x, "è maggiore di", y

riguardo questo code cdimauro hai detto che ho appioppato l'else al primo, tralasciando lo spazio, io ho scritto l'esempio che era nel libro e l'else è indentato cosi. Nel libro però c'è messo che è consentito un solo else per ogni istruzione condizionale

[~FullSyst3m~]

Appunto. E' ora di passare a un buon IDE. :D

Perché stai tornando una coppia di valori, che in Python si chiama tupla. ;)

Esattamente, perché torni UN solo valore.

Mi sembra normale. In entrambi casi entri nel primo if, ma il problema è nell'if successivo.
Nel primo caso stai dicendo che il numero x dev'essere contemporaneamente maggiore di 0 e minore di 1, ed essendo un intero è una condizione impossibile da soddisfare.
Nel secondo caso stai dicendo che è maggiore di 0 e dev'essere uguale, e quindi la condizione è sempre soddisfatta per x = 1 (si potrebbe anche rimuovere il primo if).

Lo dicevo che mi sembrava familiare quel (10,10)!:D
Allora, io ho posto x = 1 cosi per prova, ma il punto è che ho inserito l'else. Se non sono veri i due if allora dovrebbe stamparmi il messaggio dell'else, però non lo stampa. Inoltre il primo if del secondo esempio l'ho messo solo per riprodurre l'esempio del libro, in questo caso non ha utilità lo so

P.S: SPE è oeprativo! Quando torno dal lavoro lo provo :D

[cdimauro]

N.B: x=5
y=10

if x==y:
print x, "e", y, "sono uguali"
else:
if x<y:
print x, "è minore di", y

else:
print x, "è maggiore di", y

riguardo questo code cdimauro hai detto che ho appioppato l'else al primo, tralasciando lo spazio, io ho scritto l'esempio che era nel libro e l'else è indentato cosi. Nel libro però c'è messo che è consentito un solo else per ogni istruzione condizionale
Così non funziona in nessun modo. Ecco qui:
x=5
y=10

if x==y:
print x, "e", y, "sono uguali"
else:
if x<y:
print x, "è minore di", y
else:
print x, "è maggiore di", y
la versione corretta. Ci sarà un errore nel libro.
Lo dicevo che mi sembrava familiare quel (10,10)!:D
Allora, io ho posto x = 1 cosi per prova, ma il punto è che ho inserito l'else. Se non sono veri i due if allora dovrebbe stamparmi il messaggio dell'else, però non lo stampa. Inoltre il primo if del secondo esempio l'ho messo solo per riprodurre l'esempio del libro, in questo caso non ha utilità lo so
Nell'else non ci entra perché è legato esclusivamente al primo if. Quindi quando il secondo if fallisce, non c'è nessun else a esso associato che fa scattare una qualche operazione.
P.S: SPE è oeprativo! Quando torno dal lavoro lo provo :D
Benissimo. :)

[~FullSyst3m~]

la versione corretta. Ci sarà un errore nel libro.

Infatti, avevo proprio detto questo io ;) Finora ho trovato 5 errori, però ho provato a contattare chi ha tradotto il libro, ma la mail non è più operativa

Nell'else non ci entra perché è legato esclusivamente al primo if. Quindi quando il secondo if fallisce, non c'è nessun else a esso associato che fa scattare una qualche operazione.

Quindi quell'else è legato al primo if solo, avrei dovuto mettere un altro else sotto il secondo if in pratica. Ma se il primo if non è soddisfatto allora l'else dovrebbe essere eseguito

[88MIKI88]

Infatti, avevo proprio detto questo io ;) Finora ho trovato 5 errori, però ho provato a contattare chi ha tradotto il libro, ma la mail non è più operativa



Quindi quell'else è legato al primo if solo, avrei dovuto mettere un altro else sotto il secondo if in pratica. Ma se il primo if non è soddisfatto allora l'else dovrebbe essere eseguito


E' un problema di indentatura te non puoi mettere il 2° Else sullo stesso piano del primo IF.
La sintassi sarebbe questa:

If condizione:
istruzione1
else:
if condizione2:
istruzione2
else:
istruzione3

[~FullSyst3m~]

E' un problema di indentatura te non puoi mettere il 2° Else sullo stesso piano del primo IF.
La sintassi sarebbe questa:

If condizione:
istruzione1
else:
if condizione2:
istruzione2
else:
istruzione3


Certamente, lo so benissimo questo. Io parlavo dell'altro codice non di questo!

x = 1
>>> if x > 0:
... if x < 1:
... print "Ok!"
... else:
... print "Sarà per la prossima volta!"

[88MIKI88]

Certamente, lo so benissimo questo. Io parlavo dell'altro codice non di questo!

x = 1
>>> if x > 0:
... if x < 1:
... print "Ok!"
... else:
... print "Sarà per la prossima volta!"


Ecco il codice corretto:

if x>0:
if x<1:
print "Ok!"
else:
print "Sarà per la prossima volta"



Problema di indentazione pure questo l'else non può stare sul primo IF ma sul secondo

[~FullSyst3m~]

Ecco il codice corretto:

if x>0:
if x<1:
print "Ok!"
else:
print "Sarà per la prossima volta"



Problema di indentazione pure questo l'else non può stare sul primo IF ma sul secondo

Questo lo so pure! Stavo solamente facendo delle prove e mi ero chiesto quella cosa ;)

[~FullSyst3m~]

Fattoriale di un numero, il codice:

def Fattoriale (n):
if n == 0:
return 1
else:
FattorialeMenoUno = Fattoriale ( n - 1)
Risultato = n * FattorialeMenoUno
return Risultato
print Fattoriale (3)

Non capisco solo una cosa: se passo 3 il valore che dovrebbe tornare alla funzione non dovrebbe essere il fattoriale? Cioè se io calcolo il risultato e poi lo ritorno, perchè mi ritorna il Fattoriale (n-1) invece del Risultato? In questo modo torna 3 risultati e poi non capisco perchè quando n = 0 la funzione lavora ancora e non si ferma visto che la condizione è soddisfatta. Sarò scemo io sicuramente, ma mettendomi nei panni dell'interprete non capisco come ragiona. Spero di essermi spiegato

[cdimauro]

Fattoriale di un numero, il codice:

def Fattoriale (n):
if n == 0:
return 1
else:
FattorialeMenoUno = Fattoriale ( n - 1)
Risultato = n * FattorialeMenoUno
return Risultato
print Fattoriale (3)

Non capisco solo una cosa: se passo 3 il valore che dovrebbe tornare alla funzione non dovrebbe essere il fattoriale? Cioè se io calcolo il risultato e poi lo ritorno, perchè mi ritorna il Fattoriale (n-1) invece del Risultato? In questo modo torna 3 risultati e poi non capisco perchè quando n = 0 la funzione lavora ancora e non si ferma visto che la condizione è soddisfatta. Sarò scemo io sicuramente, ma mettendomi nei panni dell'interprete non capisco come ragiona. Spero di essermi spiegato
Prova a simulare a con carta e penna l'esecuzione del codice, così capirai cosa succede effettivamente.

Se non ci riesci con SPE puoi eseguire passo passo l'esecuzione grazie a SPE: basta lanciare il programma con Tools/Debug with winpdg... e quando sei dentro il debugger premere F7 (Step Into) per vedere cosa succede alle variabili. :cool:

[88MIKI88]

Paragrafi 9.5 - 9.6 - 9.7 del capitolo sulle Tuple

Cdimauro puoi illuminarmi un pò sull'esercizio che viene proposto??? Francamente non ci capisco niente (secondo me è spiegato pure male in quanto mancano pezzi di codice).

[cdimauro]

Immagino che sia questo:

Esercizio: prova questa funzione con liste più lunghe per vedere se il conteggio di valori in ogni intervallo tende o meno a livellarsi (maggiore è il numero di prove più i valori dovrebbero diventare simili).

L'esercizio serve soltanto a dimostrare che la distribuzione di numeri casuali in un intervallo è uniforme, ma... devi conoscere il significato di questi termini.

Se non ti è chiaro, puoi benissimo passare avanti, se il concetto di tupla e delle operazioni che mette a disposizione l'hai acquisito. ;)

[~FullSyst3m~]

Prova a simulare a con carta e penna l'esecuzione del codice, così capirai cosa succede effettivamente.

Se non ci riesci con SPE puoi eseguire passo passo l'esecuzione grazie a SPE: basta lanciare il programma con Tools/Debug with winpdg... e quando sei dentro il debugger premere F7 (Step Into) per vedere cosa succede alle variabili. :cool:

Addirittura?? Comunque io l'ho simulato con carta e penna visto che ero in ufficio e poi ieri l'ho scritto al pc, però ho sempre quelle due cosine che mi lasciano perplesso

Paragrafi 9.5 - 9.6 - 9.7 del capitolo sulle Tuple

Cdimauro puoi illuminarmi un pò sull'esercizio che viene proposto??? Francamente non ci capisco niente (secondo me è spiegato pure male in quanto mancano pezzi di codice).
E io che non vedevo l'ora di arrivare lì.. :muro: Certo che comunque scrivere degli esercizi cosi contorti che non si capiscono non mi sa tanto da libro "per iniziare". E addirittura nell'introduzione c'è messo che viene utilizzato nelle superiori e che è stato corretto in base ai consigli degli alunni se non capivano qualcosa o era espresso male qualche concetto. O siamo scemi o non so cosa...

Immagino che sia questo:

Esercizio: prova questa funzione con liste più lunghe per vedere se il conteggio di valori in ogni intervallo tende o meno a livellarsi (maggiore è il numero di prove più i valori dovrebbero diventare simili).

L'esercizio serve soltanto a dimostrare che la distribuzione di numeri casuali in un intervallo è uniforme, ma... devi conoscere il significato di questi termini.

Se non ti è chiaro, puoi benissimo passare avanti, se il concetto di tupla e delle operazioni che mette a disposizione l'hai acquisito.
Io non credo che sia buono lasciare cose indietro, anche perchè serve pur sempre come allenamento. Inoltre quale significato dei termini deve conoscere? Almeno mi faccio un'idea...

[VICIUS]

Io non credo che sia buono lasciare cose indietro, anche perchè serve pur sempre come allenamento. Inoltre quale significato dei termini deve conoscere? Almeno mi faccio un'idea...
Se proprio vuoi approfondire puoi cercare qualcosa sulle distribuzioni di frequenza, la divisione in classi e le variabili casuali ma puoi tranquillamente continuare a leggere il libro senza conoscerle.

[~FullSyst3m~]

Se proprio vuoi approfondire puoi cercare qualcosa sulle distribuzioni di frequenza, la divisione in classi e le variabili casuali ma puoi tranquillamente continuare a leggere il libro senza conoscerle.

Non credo che ci sia paragone scusa. Quelle sono cose che sono sul libro, quello che hai detto tu invece è subito per farlo adesso. Si dovrebbe finire almeno il libro prima e avere le basi e la preparazione necessaria

[~FullSyst3m~]

EDIT: doppio post

[~FullSyst3m~]

Capitolo 6.5, cerco di spiegarmi il meglio possibile. Questo è il codice del libro:

def StampaMultipli (n):
i = 1
while i <= 6:
print n*i, '\t',
i = i+1
print
i = 1
while i <=6:
StampaMultipli(i)
i = i+1

che mi restituisce:

1 2 3 4 5 6
2 4 6 8 10 12
3 6 9 12 15 18
4 8 12 16 20 24
5 10 15 20 25 30
6 12 18 24 30 36

Siccome non mi piace fermarmi a quello che fa il libro e sperimento sempre (e forse questo è un difetto perchè dovrei fare come ha detto 88MIKI88) ho cambiato la condizione del while cosi:

def StampaMultipli (n):
i = 1
while i <= 10:
print n*i, '\t',
i = i+1
print
i = 1
while i <=6:
StampaMultipli(i)
i = i+1

e mi stampa:

1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60

Infine lo modifico cosi:

def StampaMultipli (n):
i = 1
while i <= 6:
print n*i, '\t',
i = i+1
print
i = 1
while i <= 10:
StampaMultipli(i)
i = i+1

e mi stampa:

1 2 3 4 5 6
2 4 6 8 10 12
3 6 9 12 15 18
4 8 12 16 20 24
5 10 15 20 25 30
6 12 18 24 30 36
7 14 21 28 35 42
8 16 24 32 40 48
9 18 27 36 45 54
10 20 30 40 50 60

Ora, quello che non mi convince sono gli ultimi due esempi. Nel primo, dato che il secondo while ha come condizione 6 non capisco come fa la funzione ad essere eseguita visto che non dovrebbe più essere chiamata. Nel secondo esempio invece non capisco la stessa cosa, solo che il 6 è nella funzione e il 10 nel secondo while. In tutte e due i casi arrivato a 6 l'esecuzione dovrebbe terminare.

P.S: poi non capisco perchè prima li organizza in un modo i numeri e poi in un altro, la tabulazione non cambia nel codice. SPE comunque non me la visualizza cosi evidente, infatti ho dovuto eseguire il codice nell'IDLE.

Ah, riguardo il fattoriale, ho provato a simulare l'esecuzione del programma con carta e penna, però la cosa che non capisco è quando si arriva a FattorialeMenoUno. Arrivato lì la funzione viene richiamata, ma allora il flusso si blocca lì e ricomincia oppure mentre la funzione viene richiamata il flusso del programma continua e quindi passa a Risultato e poi a return? Comunque ho provato anche a usare SPE per guardare il programma da dentro, ma nell'ufficio del computer mi dà errore python. Quando torno a casa provo là

[VICIUS]

Ora, quello che non mi convince sono gli ultimi due esempi. Nel primo, dato che il secondo while ha come condizione 6 non capisco come fa la funzione ad essere eseguita visto che non dovrebbe più essere chiamata. Nel secondo esempio invece non capisco la stessa cosa, solo che il 6 è nella funzione e il 10 nel secondo while. In tutte e due i casi arrivato a 6 l'esecuzione dovrebbe terminare.
Attenzione. La funzione StampaMultipli non comprende tutto il codice presente nell'esempio ma finisce con print. Quindi è solo questa parte del codice:
def StampaMultipli (n):
i = 1
while i <= 6:
print n*i, '\t',
i = i+1
print
La "i" della funzione è una variabile diversa da quella che trovi più sotto per questo motivo il valore della prima non influenza quello della seconda.

Prova a modificare l'esempio dando due nomi diversi alle variabili e vedrai che diventerà più chiaro.

[VICIUS]

Ah, riguardo il fattoriale, ho provato a simulare l'esecuzione del programma con carta e penna, però la cosa che non capisco è quando si arriva a FattorialeMenoUno. Arrivato lì la funzione viene richiamata, ma allora il flusso si blocca lì e ricomincia oppure mentre la funzione viene richiamata il flusso del programma continua e quindi passa a Risultato e poi a return? Comunque ho provato anche a usare SPE per guardare il programma da dentro, ma nell'ufficio del computer mi dà errore python. Quando torno a casa provo là
Il flusso della funzione si interrompe e ritorna in cima alla funzione con il nuovo valore appena calcolato come argomento.

[~FullSyst3m~]

Leggendo più avanti, nel 6.7, si parla più o meno di quello che dico io. Però se la variabile in TabellaMoltiplicazione6x6 è 3 allora deve essere 3 pure in StampaMultipli visto che tutte e due le funzioni partono con lo stesso indice. Altrimenti succederebbe un casino nelle due funzioni perchè ognuna avrebbe una variabile diversa e dovrebbe seguire il suo flusso di esecuzione

[~FullSyst3m~]

Attenzione. La funzione StampaMultipli non comprende tutto il codice presente nell'esempio ma finisce con print

Si lo so questo, mi riferivo in tutto il contesto io non solo alla funzione

La "i" della funzione è una variabile diversa da quella che trovi più sotto per questo motivo il valore della prima non influenza quello della seconda.

Prova a modificare l'esempio dando due nomi diversi alle variabili e vedrai che diventerà più chiaro.

Proverò, ma il punto è quello che ho scritto un post sopra

Il flusso della funzione si interrompe e ritorna in cima alla funzione con il nuovo valore appena calcolato come argomento.

Se fa cosi allora quando lo calcola il Risultato? Facendo cosi la funzione quando arriva a 0 dovrebbe terminare

[~FullSyst3m~]

Allora, ho finito il capitolo 6. Tutto chiaro, tranne per il paragrafo 6.7 che ho già scritto sopra e per il 6.8 che proprio non mi quadra. Non capisco ad esempio perchè StampaMultipli ha due parametri invece di sostituire n con Grandezza e perchè mettendo StampaMultipli (i, i) nella funzione TabellaMoltiplicazioneGenerica stampa i numeri a metà

[VICIUS]

Si lo so questo, mi riferivo in tutto il contesto io non solo alla funzione

Proverò, ma il punto è quello che ho scritto un post sopra
Allora non ho capito quello che non hai capito :D Prova a spiegare meglio che cosa c'è che non dovrebbe andare negli esempi.

Se fa cosi allora quando lo calcola il Risultato? Facendo cosi la funzione quando arriva a 0 dovrebbe terminare
Infatti la funzione continua a chiamarsi finche non raggiunge zero. A quel punto ritorna 1 e la chiamata precedete può continuare il calcolo con il valore.

[~FullSyst3m~]

Allora non ho capito quello che non hai capito :D Prova a spiegare meglio che cosa c'è che non dovrebbe andare negli esempi.


Infatti la funzione continua a chiamarsi finche non raggiunge zero. A quel punto ritorna 1 e la chiamata precedete può continuare il calcolo con il valore.

Cioè, quando torna 1 dovrebbe fermarsi la funzione. Non dovrebbe continuare più niente. Che fa si congela l'esecuzione quando arriva a FattorialeMenoUno?

Comunque ora provo a spiegare meglio quello che non capisco riguardo i paragrafi 6.8 e 6.7.

Allora: leggendo più avanti, nel 6.7, si parla più o meno di quello che dico io. Però se la variabile in TabellaMoltiplicazione6x6 è 3 allora deve essere 3 pure in StampaMultipli visto che tutte e due le funzioni partono con lo stesso indice. Altrimenti succederebbe un casino nelle due funzioni perchè ognuna avrebbe una variabile diversa e dovrebbe seguire il suo flusso di esecuzione con il valore corrispondente. Poi il 6.8 che proprio non mi quadra. Non capisco ad esempio perchè StampaMultipli ha due parametri (n, Grandezza) invece di sostituire n con Grandezza e perchè mettendo StampaMultipli (i, i) nella funzione TabellaMoltiplicazioneGenerica stampa i numeri a metà. Oltre a questo nel 6.8 c'è messo: "Quando abbiamo aggiunto il nuovo parametro abbiamo cambiato la prima riga della funzione ed il posto dove la funzione è chiamata in TabellaMoltiplicazioneGenerica".
A me sembra che la funzione venga chiamata nello stesso punto

[VICIUS]

Cioè, quando torna 1 dovrebbe fermarsi la funzione. Non dovrebbe continuare più niente. Che fa si congela l'esecuzione quando arriva a FattorialeMenoUno?
Si, quella chiamata alla funzione finisce li e ritorna quel valore e tutte le altre sono ancora ferme in attesa di avere un valore da assegnare a FattorialeMenoUno.

Comunque ora provo a spiegare meglio quello che non capisco riguardo i paragrafi 6.8 e 6.7.

Allora: leggendo più avanti, nel 6.7, si parla più o meno di quello che dico io. Però se la variabile in TabellaMoltiplicazione6x6 è 3 allora deve essere 3 pure in StampaMultipli visto che tutte e due le funzioni partono con lo stesso indice. Altrimenti succederebbe un casino nelle due funzioni perchè ognuna avrebbe una variabile diversa e dovrebbe seguire il suo flusso di esecuzione con il valore corrispondente.
Nel capitolo c'è scritto molto chiaramente. NON sono le stessa variabile anche se hanno un nome identico. Dare nomi come "i", "j" ecc è una pessima abitudine perché porta a far confusione ma in questo caso l'autore lo ha fatto di proposito proprio per farti notare questa cosa. Se la funzione TabellaMoltiplicazione6x6 modifica il valore di i questo cambiamento non viene riportato nella i di StampaMultipli.

Poi il 6.8 che proprio non mi quadra. Non capisco ad esempio perchè StampaMultipli ha due parametri (n, Grandezza) invece di sostituire n con Grandezza e perchè mettendo StampaMultipli (i, i) nella funzione TabellaMoltiplicazioneGenerica stampa i numeri a metà. Oltre a questo nel 6.8 c'è messo: "Quando abbiamo aggiunto il nuovo parametro abbiamo cambiato la prima riga della funzione ed il posto dove la funzione è chiamata in TabellaMoltiplicazioneGenerica".
A me sembra che la funzione venga chiamata nello stesso punto
StampaMultipli deve sapere due cose per funzionare. Di quale numero deve stampare i vari multipli e questo glielo dici con la variabile n. Dopo di che gli devi anche dire quanti multipli deve stampare di quel numero e per questo c'è la variabile grandezza.

Capire come funziona StampaMultipli(i,i) è un esercizio quindi non ti do aiuti per ora. una volta capito quello che ti vuole spiegare questo capitolo è piuttosto facile capire come funziona e perché da quell'output.

[~FullSyst3m~]

Si, quella chiamata alla funzione finisce li e ritorna quel valore e tutte le altre sono ancora ferme in attesa di avere un valore da assegnare a FattorialeMenoUno.
Sta ancora ancora non mi convince. Se quando viene eseguito Risultato allora? Quando n == 0 la funziona torna indietro ed esegue Risultato con i vari valori passati in precedenza da FattorialeMenoUno?

Nel capitolo c'è scritto molto chiaramente. NON sono le stessa variabile anche se hanno un nome identico. Dare nomi come "i", "j" ecc è una pessima abitudine perché porta a far confusione ma in questo caso l'autore lo ha fatto di proposito proprio per farti notare questa cosa. Se la funzione TabellaMoltiplicazione6x6 modifica il valore di i questo cambiamento non viene riportato nella i di StampaMultipli.
Si si, questo lo so. Lo avevo capito, ma è proprio questo il punto. Se non sono la stessa variabile sono ognuno per i conti propri? E quando ad esempio io metto 10 in StampaMultipli e 6 in TabellaMoltiplicazione, in quest'ultima quando si arriva a 6 la funzione dovrebbe terminare, come è possibile che StampaMultipli viene chiamata ancora? Inoltre, le tabulazioni in base a come modifico i valori vengono diverse.
P.S: ma dopo '\t' si deve mettere la virgola? Perchè io ho provato in un esercizio a scriverlo senza virgola e funziona, ma in un altro esempio no e la tabulazione non viene


StampaMultipli deve sapere due cose per funzionare. Di quale numero deve stampare i vari multipli e questo glielo dici con la variabile n. Dopo di che gli devi anche dire quanti multipli deve stampare di quel numero e per questo c'è la variabile grandezza.
E TabellaMoltiplicazione non ha bisogno di tutte e due valori pure? Perchè ha solo Grandezza?

Capire come funziona StampaMultipli(i,i) è un esercizio quindi non ti do aiuti per ora. una volta capito quello che ti vuole spiegare questo capitolo è piuttosto facile capire come funziona e perché da quell'output

Il punto è che il capitolo l'ho capito, sono questi paragrafi che mi stanno facendo perdere un sacco di tempo. Sarò io scemo perchè non credo che nessun'altro che abbia letto o leggesse questo libro avrebbe dubbi ai primi capitoli, i più facili, ma a me queste cose non mi quadrano. Sarò proprio io scemo. Non posso nemmeno andare avanti a studiare accidenti :muro:

[cdimauro]

Sta ancora ancora non mi convince. Se quando viene eseguito Risultato allora? Quando n == 0 la funziona torna indietro ed esegue Risultato con i vari valori passati in precedenza da FattorialeMenoUno?
Sì, t'avevo spiegato prima l'esecuzione di funzioni ricorsive. Le chiamate vengono "congelate", e non appena la prima ritorna, a catena si torna indietro fino all'uscita dalla funzione col valore calcolato man mano.

Basta ripercorrere questi passi con carta e penna per capire come funziona il meccanismo.
Si si, questo lo so. Lo avevo capito, ma è proprio questo il punto. Se non sono la stessa variabile sono ognuno per i conti propri? E quando ad esempio io metto 10 in StampaMultipli e 6 in TabellaMoltiplicazione, in quest'ultima quando si arriva a 6 la funzione dovrebbe terminare, come è possibile che StampaMultipli viene chiamata ancora?
Il concetto è che quando assegni un valore a una variabile dentro una funzione, Python ne crea una nuova e usa quella. Che, però, "vive" soltanto all'interno della funzione. Quando si esce da essa si "perde", e non è più visibile da nessuan parte.

Quindi se due funzioni assegna un valore alla variabile "i", ciascuna di esse avrà creato una propria variabile (detta "locale") con questo nome, ma che al di fuori sarà completamente invisibile.

Ovviamente anche i parametri delle funzioni sono variabili locali, quindi "private" e non accessibili dall'esterno.
Inoltre, le tabulazioni in base a come modifico i valori vengono diverse.
P.S: ma dopo '\t' si deve mettere la virgola? Perchè io ho provato in un esercizio a scriverlo senza virgola e funziona, ma in un altro esempio no e la tabulazione non viene
Se metti il \t dentro una stringa, funziona da tabulatore, appunto. Non servono virgole, perché dentro una stringa vengono intese come caratteri e stampate a video assieme al resto.
E TabellaMoltiplicazione non ha bisogno di tutte e due valori pure? Perchè ha solo Grandezza?
Perché per lavorare le basta quella.
Il punto è che il capitolo l'ho capito, sono questi paragrafi che mi stanno facendo perdere un sacco di tempo. Sarò io scemo perchè non credo che nessun'altro che abbia letto o leggesse questo libro avrebbe dubbi ai primi capitoli, i più facili, ma a me queste cose non mi quadrano. Sarò proprio io scemo. Non posso nemmeno andare avanti a studiare accidenti :muro:
Prova a simulare il funzionamento con carta e penna, come ti dicevo io: magari se vedi passo passo l'evolversi dell'esecuzione, capisci meglio i meccanismi che ci stanno dietro. ;)

[~FullSyst3m~]

Sì, t'avevo spiegato prima l'esecuzione di funzioni ricorsive. Le chiamate vengono "congelate", e non appena la prima ritorna, a catena si torna indietro fino all'uscita dalla funzione col valore calcolato man mano.

Basta ripercorrere questi passi con carta e penna per capire come funziona il meccanismo.
Pensavo era riferito solo alla funzione ContoAllaRovescia e non alle funzioni ricorsive in generale, anche perchè il codice di Fattoriale era diverso e dopo la chiamata ricorsiva c'erano altre operazioni. Io ho provato a simularlo in attesa di rendere operativo SPE, forse però sbaglio. Tu come lo simuleresti con carta e penna?

Il concetto è che quando assegni un valore a una variabile dentro una funzione, Python ne crea una nuova e usa quella. Che, però, "vive" soltanto all'interno della funzione. Quando si esce da essa si "perde", e non è più visibile da nessuan parte.

Quindi se due funzioni assegna un valore alla variabile "i", ciascuna di esse avrà creato una propria variabile (detta "locale") con questo nome, ma che al di fuori sarà completamente invisibile.Ovviamente anche i parametri delle funzioni sono variabili locali, quindi "private" e non accessibili dall'esterno.

Questo l'ho capito, non è questo il problema però. Non so come spiegarmi. Cioè le variabili sono diverse, e ci siamo, me il punto è che dato che sono diverse come fa a funzionare il programma sempre? Mi spiego meglio, Se in Tabella6x6 metto come condizione del while il <=6, quando i raggiunge questo valore allora Tabella6x6 dovrebbe finire giusto? Di conseguenza non dovrebbe essere chiamata nemmeno StampaMultipli perchè veniva chiama dentro Tabella6x6 che però è finita. Capito che voglio dire?

Se metti il \t dentro una stringa, funziona da tabulatore, appunto. Non servono virgole, perché dentro una stringa vengono intese come caratteri e stampate a video assieme al resto.

In che senso dentro una stringa scusa? Negli esempi del libro non è dentro le stringhe il '\t, inoltre come ho scritto quando nel codice di StampaMultipli (mi sembra), togliendo la virogla dopo il carattere di tabulazione la griglia non veniva stampata, ma i caratteri erano incolonnati

Perché per lavorare le basta quella.

Non capisco perchè. Comunque ancora non c'ho potuto ragionare visto che sto cercando di fare funzionare SPE, ci ragionerò su il più presto possibile spero perchè voglio andare avanti

Prova a simulare il funzionamento con carta e penna, come ti dicevo io: magari se vedi passo passo l'evolversi dell'esecuzione, capisci meglio i meccanismi che ci stanno dietro. ;)

Leggi sopra ;)

[cdimauro]

Pensavo era riferito solo alla funzione ContoAllaRovescia e non alle funzioni ricorsive in generale, anche perchè il codice di Fattoriale era diverso e dopo la chiamata ricorsiva c'erano altre operazioni. Io ho provato a simularlo in attesa di rendere operativo SPE, forse però sbaglio. Tu come lo simuleresti con carta e penna?
Disegnando una tabella mettendo nella prima colonna un numero che rappresenta il numero di chiamate effettuate alla funzione, nelle altre colonne i valori delle variabili, e un'ultima colonna col valore eventualmente tornato.
Questo l'ho capito, non è questo il problema però. Non so come spiegarmi. Cioè le variabili sono diverse, e ci siamo, me il punto è che dato che sono diverse come fa a funzionare il programma sempre? Mi spiego meglio, Se in Tabella6x6 metto come condizione del while il <=6, quando i raggiunge questo valore allora Tabella6x6 dovrebbe finire giusto? Di conseguenza non dovrebbe essere chiamata nemmeno StampaMultipli perchè veniva chiama dentro Tabella6x6 che però è finita. Capito che voglio dire?
Sì, ma qual è il tuo problema? Non capisco bene. Spiegati meglio, per favore.
In che senso dentro una stringa scusa? Negli esempi del libro non è dentro le stringhe il '\t, inoltre come ho scritto quando nel codice di StampaMultipli (mi sembra), togliendo la virogla dopo il carattere di tabulazione la griglia non veniva stampata, ma i caratteri erano incolonnati
Adesso ho capito. Allora, intanto '\t' è una stringa. Poi la virgola alla fine di print significa che Python deve andare a capo con la stampa.
Non capisco perchè. Comunque ancora non c'ho potuto ragionare visto che sto cercando di fare funzionare SPE, ci ragionerò su il più presto possibile spero perchè voglio andare avanti
Quando avrai SPE col debugger funzionante potrai eseguire passo passo il programma e vedrai che capirai tutto. Anche meglio che con carta e penna. :cool:

[~FullSyst3m~]

Disegnando una tabella mettendo nella prima colonna un numero che rappresenta il numero di chiamate effettuate alla funzione, nelle altre colonne i valori delle variabili, e un'ultima colonna col valore eventualmente tornato.

Ho provato, ma ci sono dei punti dove mi si blocca l'esecuzione. Se non chiedo troppo potresti farmi vedere come la faresti tu questa simulazione?

Sì, ma qual è il tuo problema? Non capisco bene. Spiegati meglio, per favore.
Ci provo a spiegarmi meglio che posso. Allora, partiamo dal presupposto che nella funzione StampaMultipli abbiamo come condizione while i <=10 e che in Tabella6x6 abbiamo come condizione while i <=6. Bene, allora. StampaMultipli viene chiamata da Tabella giusto? Perfetto. Teniamo in conto che le due variabili i non sono la stessa variabile, ma partono tutte e due con lo stesso indice, cioè 1. Quando la variabile i di Tabella6x6 arriva a 6, la funzione dovrebbe terminare e di conseguenza StampaMultipli non dovrebbe essere più chiamato giusto? Ecco il punto, perchè allora quando i=6 StampaMultipli viene chiamato ed eseguito ancora?

Adesso ho capito. Allora, intanto '\t' è una stringa. Poi la virgola alla fine di print significa che Python deve andare a capo con la stampa.
No, non hai capito. La virgola alla fine del print so cosa significa, e so anche che '\t' è una stringa e che \ è il carattere di escape per renderla invisibile. Quello che non mi è chiaro è perchè negli esempi, ad esempio la funzione StampaMultipli nel paragrafo 6.5, il carattere di tabulazione ha la virgola finale. Io l'esercizietto del 6.3 l'ho fatto senza mettere la virgola alla fine di '\t', però in StampaMultipli se tolgo la virgola finale la griglia non viene più stampata e i multipli sono stampati a gruppi in colonna, in verticale in pratica. Capito che voglio dire?

Quando avrai SPE col debugger funzionante potrai eseguire passo passo il programma e vedrai che capirai tutto. Anche meglio che con carta e penna. :cool:

Apparte che vorrei pure imparare a simularlo a mano, perchè ad esempio in ufficio non ho sempre la possibilità di usare il pc, e poi non voglio perdere ancora tempo. Voglio andare avanti. Che rabbia... :muro: :muro:

[~FullSyst3m~]

Finalmente ho avuto 10 minuti di tranquillità per poter analizzare il codice di StampaMultipli e TabellaMoltiplicazioneGenerica e sia a mente sia simulando il programma con carta e penna ho capito come funziona! Come ho fatto a non capirlo prima, avevo l'esecuzione del programma sotto gli occhi in pratica! Che scemo :muro: :muro: :muro: Adesso mi manca solo di svolgere l'ultimo esercizietto del capitolo e posso passare avanti finalmente! :D. Solo una cosa, per chiarezza: il parametro Grandezza della funzione TabellaMoltiplicazioneGenerica viene passato al parametro Grandezza della funzione StampaMultipli? In pratica, sono lo stesso parametro?

Restano però valida dopo altri test questa perplessità:

No, non hai capito. La virgola alla fine del print so cosa significa, e so anche che '\t' è una stringa e che \ è il carattere di escape per renderla invisibile. Quello che non mi è chiaro è perchè negli esempi, ad esempio la funzione StampaMultipli nel paragrafo 6.5, il carattere di tabulazione ha la virgola finale. Io l'esercizietto del 6.3 l'ho fatto senza mettere la virgola alla fine di '\t', però in StampaMultipli se tolgo la virgola finale la griglia non viene più stampata e i multipli sono stampati a gruppi in colonna, in verticale in pratica. Capito che voglio dire?

In pratica, in StampaMultipli, dopo il print n*i, '\t', se tolgo la virgola dopo il carattere di tabulazione i caratteri mi vengono stampati cosi:

1
2
3
4
5
6
7

2
4
6
8
10
12
14

nonostante ci sia il carattere di tabulazione, invece se metto la virgola dopo il carattere di tabulazione mi stampa la griglia correttamente.

Ho notato appena adesso una cosa, smanettando con il codice per capire il perchè delle stampe incolonnate, per sbaglio ho modificato la linea di codice
i = i+1 cosi i = i+1, e il print n*1, sopra sempre con la virgola finale e il risultato è questo:

1
2
3
4
5
6
7

poi al print n*i, ho aggiunto '\t' e mi si visualizza questo:

1

2

3

4

5

6

7

mettendo invece la virgola finale al carattere di tabulazione mi stampa di nuovo i numeri come prima:

1
2
3
4
5
6
7

Come mai? Ora comunque ci ragiono perchè vorrei proprio capire come interpreta il codice Python

Comunque in SPE ho notato che la griglia sia con il carattere di tabulazione sia senza viene stampata allo stesso modo, infatti ho dovuto provare il codice pure sull'IDLE perchè questa cosa non mi convinceva

[~FullSyst3m~]

L'ultimo esercizietto del capitolo 6 l'ho capito pure!! Le altre cose restano valide però eh!:D

[~FullSyst3m~]

Aggiungo una piccola cosa, esercizietto paragrafo 7.3:

"Scrivi una funzione che prende una stringa come argomento e la stampa un caratter per riga partendo dall'ultimo carattere."

Finora ho scritto questo codice:

def StringaAlContrario():
Stringa = raw_input ("Inserisci una parola: ")
Indice = 0
while Indice < len (Stringa):
Lunghezza = len (Stringa)
Lettera = Stringa[-1]
print Lettera
Indice = Indice + 1

ma ovviamente mi restituisce sempre l'ultimo carattere. Se ad esempio come stringa inserisco la parola cab Python mi restituisce:

b
b
b

ho anche notato però che se modifico il codice in questo modo:

def StringaAlContrario():
Stringa = raw_input ("Inserisci una parola: ")
Indice = 0
while Indice < len (Stringa):
Lunghezza = len (Stringa)
Lettera = Stringa[-1]
print Lettera
Indice = Indice + 1
Stringa = Stringa[-1]

non mi stampa tre volte la b, ma una volta sola

[DanieleC88]

"Scrivi una funzione che prende una stringa come argomento e la stampa un caratter per riga partendo dall'ultimo carattere."
Attento, che la tua funzione la riceve in input dalla tastiera, e non come argomento...
def StringaAlContrario():
Stringa = raw_input ("Inserisci una parola: ")
Indice = 0
while Indice < len (Stringa):
Lunghezza = len (Stringa)
Lettera = Stringa[-1]
print Lettera
Indice = Indice + 1
Stai stampando len(Stringa) volte l'ultimo carattere della stringa (Stringa[-1]), per forza. :p

def StringaAlContrario():
Stringa = raw_input ("Inserisci una parola: ")
Indice = 0
while Indice < len (Stringa):
Lunghezza = len (Stringa)
Lettera = Stringa[-1]
print Lettera
Indice = Indice + 1
Stringa = Stringa[-1]

non mi stampa tre volte la b, ma una volta sola
Sì, perché alla fine della prima iterazione "tagli" la stringa assegnandole solo l'ultimo carattere (nel tuo caso, b).

Io ti consiglio di prendere il primo codice e ragionare sugli indici: hai una stringa di una certa lunghezza n, dove l'ultimo carattere è in posizione n-1. Dovendo stampare al contrario, devi andare da n-1 a 0: se vuoi usare un indice che viene incrementato volta per volta, puoi pensare di sottrarlo mentre lui cresce, in modo da far decrescere l'indice del carattere a cui accedi:
void reverse_print(stringa):
n = len(stringa)
indice = 1
while indice <= n:
print stringa[n - indice],
indice += 1
O anche farlo con range()/xrange():
void reverse_print(stringa):
n = len(stringa)
for indice in xrange(1, n+1):
print stringa[n - indice],
Altrimenti puoi sfruttare il fatto che con gli indici negativi puoi indirizzare posizioni relative alla fine della stringa, in Python, e togliere di mezzo la n dal codice prima:
void reverse_print(stringa):
n = len(stringa)
for indice in xrange(1, n+1):
print stringa[-indice],
Dovrebbe funzionare lo stesso. ;)

[VICIUS]

[...]
void reverse_print(stringa):
n = len(stringa)
for indice in xrange(1, n+1):
print stringa[-indice],
Dovrebbe funzionare lo stesso. ;)
Non dovresti risolvergli gli esercizi altrimenti non impara mai. Qualche piccolo suggerimento sulla riga in cui c'era l'errore sarebbe bastato.

[DanieleC88]

Non dovresti risolvergli gli esercizi altrimenti non impara mai. Qualche piccolo suggerimento sulla riga in cui c'era l'errore sarebbe bastato.
Infatti non risolvo quasi mai gli esercizi, e quando lo faccio non è quasi mai per intero... in questo caso ho voluto farlo, per fargli vedere un esempio pratico e chiarirgli del tutto le idee. Mi rendo conto anche che per lui che sta imparando trovare solo i problemi senza avere soluzioni a cui confrontarsi magari è difficile. :)

Il resto chiaramente deve farselo lui, anche perché, pur volendo, non avrei il tempo di mettermi qui a risolvere esercizi. :p

ciao ;)

[~FullSyst3m~]

Attento, che la tua funzione la riceve in input dalla tastiera, e non come argomento...

Stai stampando len(Stringa) volte l'ultimo carattere della stringa (Stringa[-1]), per forza. :p

Sì, perché alla fine della prima iterazione "tagli" la stringa assegnandole solo l'ultimo carattere (nel tuo caso, b).

Io ti consiglio di prendere il primo codice e ragionare sugli indici: hai una stringa di una certa lunghezza n, dove l'ultimo carattere è in posizione n-1. Dovendo stampare al contrario, devi andare da n-1 a 0: se vuoi usare un indice che viene incrementato volta per volta, puoi pensare di sottrarlo mentre lui cresce, in modo da far decrescere l'indice del carattere a cui accedi:
void reverse_print(stringa):
n = len(stringa)
indice = 1
while indice <= n:
print stringa[n - indice],
indice += 1
O anche farlo con range()/xrange():
void reverse_print(stringa):
n = len(stringa)
for indice in xrange(1, n+1):
print stringa[n - indice],
Altrimenti puoi sfruttare il fatto che con gli indici negativi puoi indirizzare posizioni relative alla fine della stringa, in Python, e togliere di mezzo la n dal codice prima:
void reverse_print(stringa):
n = len(stringa)
for indice in xrange(1, n+1):
print stringa[-indice],
Dovrebbe funzionare lo stesso. ;)

L'input da tastiera l'ho voluto fare io cosi. Non cambia nulla se la stringa la metto come argomento o la prendo dalla tastiera.

Comunque io ho scritto cosi, per vedere un pò le vostre idee, come ha detto VICIUS la soluzione la devo trovare solo, altrimenti non imparo e non acuisisco la giusta mentalità. Infatti quando torno in ufficio con calma ci ragiono. Era solo per rendervi partecipi, tutto qua

[~FullSyst3m~]

Esercizio risolto! ;)

[~FullSyst3m~]

Paragrafo 7.3. C'è un esercizio. Il codice è questo:

Prefissi = "JKLMNOPQ"
Suffisso = "ack"

for Lettera in Prefissi:
print Lettera + Suffisso

l'esercizio consiste nel modificare il programma in modo che la parola Oack venga stampata Ouack e Qack venga stampata Quack. Io ho provato a scriverlo cosi:

Prefissi = "JKLMNOPQ"
Suffisso = "ack"
Suffisso2 = "uack"

for Lettera in Prefissi:
if Lettera == "O" and Lettera == "Q":
print Lettera + Suffisso2
else:
print Lettera + Suffisso

ma non va. Per caso dopo un for non si può inserire una condizione?

[VICIUS]

Prefissi = "JKLMNOPQ"
Suffisso = "ack"
Suffisso2 = "uack"
Sicuro che questo Suffisso2 serve? Non è possibile stampare la u in qualche altro modo? ;)

for Lettera in Prefissi:
if Lettera == "O" and Lettera == "Q":
L'errore è qui. Prova ad elencare tutti i casi per cui questa condizione è vera e quelli per cui è false.

[DanieleC88]

Per caso dopo un for non si può inserire una condizione?
No, certo che puoi farlo! :)
Rileggi bene la condizione che hai impostato e cerca di capire cosa significa logicamente... (così faccio contento anche VICIUS). :D

[~FullSyst3m~]

Sicuro che questo Suffisso2 serve? Non è possibile stampare la u in qualche altro modo? ;)


L'errore è qui. Prova ad elencare tutti i casi per cui questa condizione è vera e quelli per cui è false.

Si certo, Suffisso2 potrei toglierlo e stampare la u in questo modo:

print Lettera + "u" + Suffisso

ma dato che mi piace capire le cose vorrei capire perchè in quel modo non va...

:what: Azzo... ho sbagliato l'operatore logico, che fdm! :muro: :muro: :mc: :D :asd:

No, certo che puoi farlo!

Eh infatti, mi sembrava proprio strano che non si poteva. Avrebbe voluto dire che era menomato il linguaggio eh!

[88MIKI88]

Prefissi = "JKLMNOPQ"
Suffisso = "ack"

for Lettera in Prefissi:
if Lettera =='O':
print Lettera +'u'+ Suffisso
elif Lettera =='Q':
print Lettera +'u'+ Suffisso
else:
print Lettera + Suffisso

[VICIUS]

Prefissi = "JKLMNOPQ"
Suffisso = "ack"

for Lettera in Prefissi:
if Lettera =='O':
print Lettera +'u'+ Suffisso
elif Lettera =='Q':
print Lettera +'u'+ Suffisso
else:
print Lettera + Suffisso


La soluzione è corretta ma non è la migliore. Se non fosse per quel piccolo errore di logica quella di FullSyst3m è invece ottima.

Sostanzialmente stai commettendo lo stesso errore in cui è caduto anche FullSyst3m con Suffisso2. Linee di codice ripetute come quelle due print rendono più difficili le modifiche al codice aumentando il rischio di inconsistenze. Potrà sembrare una banalità ma evitare duplicazioni è uno dei principi base da rispettare per scrivere buon codice.

[88MIKI88]

La soluzione è corretta ma non è la migliore. Se non fosse per quel piccolo errore di logica quella di FullSyst3m è invece ottima.

Sostanzialmente stai commettendo lo stesso errore in cui è caduto anche FullSyst3m con Suffisso2. Linee di codice ripetute come quelle due print rendono più difficili le modifiche al codice aumentando il rischio di inconsistenze. Potrà sembrare una banalità ma evitare duplicazioni è uno dei principi base da rispettare per scrivere buon codice.

Guarda che lo so che dovrei tirare via il elif e porre la condizione come:


if Lettera == 'Q' or Lettera=='O' :
.........



sono degli esperimenti che faccio io. Questa era la prima versione del prog. mi sono sbagliato a postarla.

[~FullSyst3m~]

Guarda che lo so che dovrei tirare via il elif e porre la condizione come:


if Lettera == 'Q' or Lettera=='O' :
.........



sono degli esperimenti che faccio io. Questa era la prima versione del prog. mi sono sbagliato a postarla.

Infatti, anche se la soluzione era corretta era troppo lunga. Si deve sempre cercare di scriverlo più in sintesi possibile il codice cosi poi se ci dovrebbero essere modifiche in futuro è più facile da gestire e manutenere e bisogna evitare come la peste le duplicazioni, come ha detto VICIUS e anche come è scritto nel libro ;)

Comunque non so come cavolo ho fatto a scrivere and invece di or.. sarà che studio la maggior parte del tempo a lavoro e ogni secondo il mio principale mi dà qualcosa da fare e perdo il filo :D Ma lo odio quando faccio questi errori banali :muro:

[~FullSyst3m~]

Capitolo 7.5, non mi è chiara un cosa:

if Parola == "BANANA":
print "stai parlando di un frutto!"

if Parola < "BANANA":
print "la tua parola", Parola, "viene prima di BANANA"
elif Parola > "BANANA":
print "la tua parola", Parola, "viene dopo di BANANA"
else:
print "hai inserito la parola BANANA"

"Devi comunque fare attenzione al fatto che Python non gestisce le parole maiuscole e minuscole come facciamo noi in modo intuitivo: in un confronto le lettere maiuscole vengono sempre prima delle minuscole, così che:

"BANANA" < "BAnana" < "Banana" < "bANANA" < "banana"
"ZEBRA" < "banana"

Sta cosa non è che mi sia molto chiara, ho provato a usare parole di diversa lunghezza e sia maiuscole che minuscole, sia miste, ma non ho capito molto come ragiona Python in questo caso. A prima occhiata mi sembra che dia la precedenza alle parole con più lettere maiuscole, in altri casi che dia la precedenza a parole che iniziano con una lettera maiuscola...

P.S: ma che fine ha fatto cdimauro???

[88MIKI88]

Infatti, anche se la soluzione era corretta era troppo lunga. Si deve sempre cercare di scriverlo più in sintesi possibile il codice cosi poi se ci dovrebbero essere modifiche in futuro è più facile da gestire e manutenere e bisogna evitare come la peste le duplicazioni, come ha detto VICIUS e anche come è scritto nel libro ;)

Comunque non so come cavolo ho fatto a scrivere and invece di or.. sarà che studio la maggior parte del tempo a lavoro e ogni secondo il mio principale mi dà qualcosa da fare e perdo il filo :D Ma lo odio quando faccio questi errori banali :muro:

Ma te al lavoro programmi in Python???

[~FullSyst3m~]

Ma te al lavoro programmi in Python???

Ehm... si! :D

[VICIUS]

Capitolo 7.5, non mi è chiara un cosa:

if Parola == "BANANA":
print "stai parlando di un frutto!"

if Parola < "BANANA":
print "la tua parola", Parola, "viene prima di BANANA"
elif Parola > "BANANA":
print "la tua parola", Parola, "viene dopo di BANANA"
else:
print "hai inserito la parola BANANA"

"Devi comunque fare attenzione al fatto che Python non gestisce le parole maiuscole e minuscole come facciamo noi in modo intuitivo: in un confronto le lettere maiuscole vengono sempre prima delle minuscole, così che:

"BANANA" < "BAnana" < "Banana" < "bANANA" < "banana"
"ZEBRA" < "banana"

Sta cosa non è che mi sia molto chiara, ho provato a usare parole di diversa lunghezza e sia maiuscole che minuscole, sia miste, ma non ho capito molto come ragiona Python in questo caso. A prima occhiata mi sembra che dia la precedenza alle parole con più lettere maiuscole, in altri casi che dia la precedenza a parole che iniziano con una lettera maiuscola...

P.S: ma che fine ha fatto cdimauro???

Ha questo strano comportamento perché in realtà 'A' e 'a' sono due caratteri diversi anche se rappresentano la stessa lettera. Ogni carattere ha associato un numero che lo identifica ed è su questi numeri che ragiona python per fare l'ordinamento. Il caso a voluto che tutte le lettere maiuscole abbiano numeri minori di quelle minuscole. Se vuoi approfondire cerca ascii table su Google così puoi controllare dove stanno tutti i caratteri.

[~FullSyst3m~]

Ha questo strano comportamento perché in realtà 'A' e 'a' sono due caratteri diversi anche se rappresentano la stessa lettera. Ogni carattere ha associato un numero che lo identifica ed è su questi numeri che ragiona python per fare l'ordinamento. Il caso a voluto che tutte le lettere maiuscole abbiano numeri minori di quelle minuscole. Se vuoi approfondire cerca ascii table su Google così puoi controllare dove stanno tutti i caratteri.

Quindi l'ordinamento viene effettuato da Python in base al posto che viene occupato in memoria, non come lo facciamo noi umani. Par provo a scaricare una ASCII table e fare qualche prova

Tornando al libro, paragrafo 7.7, ecco il codice:

def Trova(Stringa, Carattere):
Indice = 0
while Indice < len(Stringa):
if Stringa[Indice] == Carattere:
return Indice
Indice = Indice + 1
return -1


e il testo dell’esercizio è:

“modifica la funzione trova per accettare un terzo parametro che rappresenta la posizione dove si deve cominciare a cercare all’interno della stringa”

Io l’ho fatto cosi:

def Trova(Stringa, Carattere, Posizione):
Indice = Posizione
while Indice < len(Stringa):
if Stringa[Indice] == Carattere:
return Indice
Indice = Indice + 1
return -1

a me sembra corretto e funziona. Che ne dite? Credo che più sintetico di cosi non si possa fare :D

[DanieleC88]

Quindi l'ordinamento viene effettuato da Python in base al posto che viene occupato in memoria
:wtf:
No, rileggi bene, che VICIUS non ha detto quello. In pratica c'è una tabella di riferimento dove ogni carattere ha una sua posizione: quelli che sono più vicini all'inizio della tabella vengono prima nell'ordinamento. :)

[88MIKI88]

Corretto...manca l'indentazione

[~FullSyst3m~]

:wtf:
No, rileggi bene, che VICIUS non ha detto quello. In pratica c'è una tabella di riferimento dove ogni carattere ha una sua posizione: quelli che sono più vicini all'inizio della tabella vengono prima nell'ordinamento. :)

Si l'ho capito, io stavo parlando di come Python identifica ogni carattere/numero in memoria con un numero diverso per ogni carattere/numero in base a dove viene collocato in memoria

Corretto...manca l'indentazione

Non manca l'indentazione, per sbaglio l'ho messo nel tag QUOTE inceve che nel tag CODE

[DanieleC88]

in base a dove viene collocato in memoria
Io dicevo che è quello il punto sbagliato... non è in base a dove viene collocato in memoria. :D

[~FullSyst3m~]

Io dicevo che è quello il punto sbagliato... non è in base a dove viene collocato in memoria. :D

Si lo so, io stavo parlando di un'altra cosa! Pensavo mentre scrivevo non farci caso:D

Sarà colpa di SPE che mi sta facendo impazzire su linux :muro:

Secondo esercizio del paragrafo 7.8 http://www.python.it/doc/Howtothink/Howtothink-html-it/chap07.htm

def ContaLettera2():
Stringa = raw_input ("Inserisci la parola desiderata: ")
Lettera = raw_input ("Inserisci la lettera che cerchi: ")
Posizione = raw_input ("Inserisci la posizione da dove iniziare la ricerca: ")
Conteggio = 0
while Posizione < len(Stringa):
if Stringa[Posizione] == Lettera:
Conteggio = Conteggio + 1
Posizione = Posizione + 1
print Conteggio

L'ho fatto cosi, ma il conteggio resta sempre zero.
P.S: il forum lo guardo quando troverò la soluzione da me :D Domani in ufficio ci ragiono, l'ufficio dove lavoro allarga la mente :asd:

[~FullSyst3m~]

Che idiota! Avevo messo l'istruzione raw_input invece di input per l'inserimento del numero nella variabile posizione :muro:

Comunque per curiosità ho modificato il codice e al posto del while ho messo il ciclo for, che però quando inserisco come Posizione numeri maggiori di zero mi dà l'errore out of range. Forse perchè il ciclo for attraversa tutta la stringa e non può partire da un indice a scelta?

[88MIKI88]

Che idiota! Avevo messo l'istruzione raw_input invece di input per l'inserimento del numero nella variabile posizione :muro:

Comunque per curiosità ho modificato il codice e al posto del while ho messo il ciclo for, che però quando inserisco come Posizione numeri maggiori di zero mi dà l'errore out of range. Forse perchè il ciclo for attraversa tutta la stringa e non può partire da un indice a scelta?

Ma xkè prima di iniziare a scrivere paginate di codice non rifletti sul problema e solo dopo inizi a scriverlo??

Secondo me te sbagli completamente l'approccio al problema....continuando a scrivere codice e basta senza riflettere non capirai mai niente e continuerai a postare tutto gli esercizi del libro perchè non ti tornerà mai nulla!

[~FullSyst3m~]

Ma xkè prima di iniziare a scrivere paginate di codice non rifletti sul problema e solo dopo inizi a scriverlo??

Secondo me te sbagli completamente l'approccio al problema....continuando a scrivere codice e basta senza riflettere non capirai mai niente e continuerai a postare tutto gli esercizi del libro perchè non ti tornerà mai nulla!

Scusa dove è il problema? Per prima cosa sul problema, ci rifletto. Seconda cosa, visto la situazione nella quale studio, può capitare fare qualche errore come in questo caso e terza cosa fino ad ora mi è tornato sempre tutto. Non vedo le basi delle tue opinioni dove sono. Tu ti leggi il capitiolo, ti fai gli esercizi e basta. A me invece mi piace variare gli esercizi e sperimentare per capire come ragiona il linguaggio, anche se perdo più tempo a studiare un capitolo.

E un'ultima cosa, gli esercizi li posto per lo stesso motivo per il quale tu posti i tuoi. O per chiedere pareri o per veder se l'esercizio è corretto e magari imparare qualche trucchetto per scrivere codice più sintetico e manutenibile

[VICIUS]

Comunque per curiosità ho modificato il codice e al posto del while ho messo il ciclo for, che però quando inserisco come Posizione numeri maggiori di zero mi dà l'errore out of range. Forse perchè il ciclo for attraversa tutta la stringa e non può partire da un indice a scelta?
Posta il codice del esercizio modificato che non si capisce bene quello che hai fatto.

[~FullSyst3m~]

Posta il codice del esercizio modificato che non si capisce bene quello che hai fatto.

def ContaLettera2():
Stringa = raw_input ("Inserisci la parola desiderata: ")
Lettera = raw_input ("Inserisci la lettera che cerchi: ")
Posizione = input ("Inserisci la posizione da dove iniziare la ricerca: ")
Conteggio = 0
for Carattere in Stringa:
if Stringa[Posizione] == Lettera:
Conteggio = Conteggio + 1
Posizione = Posizione + 1
print Conteggio

comunque il nome che si mette dopo il for può essere un nome qualsiasi vero?

[DanieleC88]

def ContaLettera2():
Stringa = raw_input ("Inserisci la parola desiderata: ")
Lettera = raw_input ("Inserisci la lettera che cerchi: ")
Posizione = input ("Inserisci la posizione da dove iniziare la ricerca: ")
Conteggio = 0
for Carattere in Stringa:
if Stringa[Posizione] == Lettera:
Conteggio = Conteggio + 1
Posizione = Posizione + 1
print Conteggio
Sai che quel for scritto così è pressoché inutile, sì? :D

Va "out of bounds" perché il for seguente:
for Carattere in Stringa:
print Carattere
è uguale al while seguente:
Indice = 0
n = len(Stringa)
while Indice < n:
print Stringa[Indice]
Indice += 1
Come vedi, vengono letti tutti gli n caratteri della stringa, e Carattere è uguale ogni volta a Stringa[Indice].

Ora, dal momento che quel for fa n iterazioni, e tu stai facendo partire l'indice da un valore maggiore di zero, a quanto arriverà l'indice incrementandolo ad ogni iterazione? Sarà sempre nel range 0..(n-1)?

Rileggi bene il codice e cerca di capire cosa stai facendo veramente, e, soprattutto, se il for del Python hai capito bene a che serve (88MIKI88 non aveva tutti i torti, ma è stato un po' brusco! :D).

ciao ;)

[~FullSyst3m~]

Sai che quel for scritto così è pressoché inutile, sì? :D

Va "out of bounds" perché il for seguente:
for Carattere in Stringa:
print Carattere
è uguale al while seguente:
Indice = 0
n = len(Stringa)
while Indice < n:
print Stringa[Indice]
Indice += 1
Come vedi, vengono letti tutti gli n caratteri della stringa, e Carattere è uguale ogni volta a Stringa[Indice].

Ora, dal momento che quel for fa n iterazioni, e tu stai facendo partire l'indice da un valore maggiore di zero, a quanto arriverà l'indice incrementandolo ad ogni iterazione? Sarà sempre nel range 0..(n-1)?

Rileggi bene il codice e cerca di capire cosa stai facendo veramente, e, soprattutto, se il for del Python hai capito bene a che serve (88MIKI88 non aveva tutti i torti, ma è stato un po' brusco! :D).

ciao ;)

In che senso non aveva tutti torti? Comunque ho capito a cosa serve, io mi baso su quello che studio sul libro

[~FullSyst3m~]

Comunque riquoto alcune cose vecchie che riguardandole non mi sono molto chiare:

Tornando in topic, aggiungo una cosa che ho appena notato.
Partendo dal presupposto che quando si scrive un’istruzione return nell’idle al momento dell’esecuzione non ritorna nulla (si deve mettere un istruzione di stampa) mentre nella command line non ce n’è bisogno (e poi vorrei capire questa cosa), ho notato questo:

import math

def DistanzaTraDuePunti(x1,y1,x2,y2):
dx=x2-x1
dy=y2-y1
DistQuadrata=dx**2+dy**2
Risultato=math.sqrt(DistQuadrata)
print Risultato
return Risultato


def AreaCerchio(Raggio):
math.pi*Raggio**2


def AreaCerchio2(xc,yc,xp,yp):
Raggio=DistanzaTraDuePunti(xc,yc,xp,yp)
Risultato=AreaCerchio(Raggio)
print Risultato
return Risultato


print AreaCerchio(55)
AreaCerchio2(4,9,7,3)


1)AreaCerchio mi ritorna il valore None
2)Se chiamo la funzione AreaCerchio2, mi ritorna il risultato e poi il None
3)Se tolgo il print da AreaCerchio2 mi ritorna il valore, ma il None sparisce
4)Se metto il print davanti alla chiamata di funzione di AreaCerchio2 mi ritorna il valore e due None
Why??


No, non hai capito. La virgola alla fine del print so cosa significa, e so anche che '\t' è una stringa e che \ è il carattere di escape per renderla invisibile. Quello che non mi è chiaro è perchè negli esempi, ad esempio la funzione StampaMultipli nel paragrafo 6.5, il carattere di tabulazione ha la virgola finale. Io l'esercizietto del 6.3 l'ho fatto senza mettere la virgola alla fine di '\t', però in StampaMultipli se tolgo la virgola finale la griglia non viene più stampata e i multipli sono stampati a gruppi in colonna, in verticale in pratica. Capito che voglio dire?

In pratica, in StampaMultipli, dopo il print n*i, '\t', se tolgo la virgola dopo il carattere di tabulazione i caratteri mi vengono stampati cosi:

1
2
3
4
5
6
7

2
4
6
8
10
12
14

nonostante ci sia il carattere di tabulazione, invece se metto la virgola dopo il carattere di tabulazione mi stampa la griglia correttamente.

Ho notato appena adesso una cosa, smanettando con il codice per capire il perchè delle stampe incolonnate, per sbaglio ho modificato la linea di codice
i = i+1 cosi i = i+1, e il print n*1, sopra sempre con la virgola finale e il risultato è questo:

1
2
3
4
5
6
7

poi al print n*i, ho aggiunto '\t' e mi si visualizza questo:

1

2

3

4

5

6

7

mettendo invece la virgola finale al carattere di tabulazione mi stampa di nuovo i numeri come prima:

1
2
3
4
5
6
7

Come mai?

[DanieleC88]

In che senso non aveva tutti torti?
Nel senso che ti sei infilato nel codice di un for senza usarlo in modo diverso da un while, ed infilandolo quindi in un bell'errore. :)
Comunque ho capito a cosa serve, io mi baso su quello che studio sul libro
Be' non ne sono certo da quel che ho visto: magari rileggi il mio post di prima e prova a scrivere differenza tra while e for. Avrai anche le idee più chiare dopo. ;)

[grigor91]

In che senso non aveva tutti torti? Comunque ho capito a cosa serve, io mi baso su quello che studio sul libro

gurda qui se vuoi la soluzione:
In Python il for ha un meccanismo diverso dagli altri linguaggi:
praticamente nel tuo caso il for fa tanti cicli quanti ne impiega per scorrere la parola (quindi fa tanti cicli quanto è lunga la parola). Questo fa capire che è indipendente dal carattere da cui parti: "banana", per esempio, ha 6 lettere; se parti dalla terza lettera fai sempre 6 cicli e quindi "sfori". Spero di essere stato chiaro e di averti fatto capire cosa non avevi approfondito.

[~FullSyst3m~]

Nel senso che ti sei infilato nel codice di un for senza usarlo in modo diverso da un while, ed infilandolo quindi in un bell'errore. :)

Be' non ne sono certo da quel che ho visto: magari rileggi il mio post di prima e prova a scrivere differenza tra while e for. Avrai anche le idee più chiare dopo. ;)

Non dovete considerare ogni codice che posto come definitivo, ma come epserimento. A me piace manipolare il codice e provare, tutto qua. Quello che hai visto è quello che spiega il libro riguardo il ciclo for. Se non ne sei convinto vai a leggere tu stesso il paragrafo dove si parla del for.
In che senso prova a scrivere la differenza tra while e for?

[DanieleC88]

Se non ne sei convinto vai a leggere tu stesso il paragrafo dove si parla del for.
Passa un link.
In che senso prova a scrivere la differenza tra while e for?
In cosa sono diversi, intendo... perché usare uno invece dell'altro? :D

[~FullSyst3m~]

Passa un link.

In cosa sono diversi, intendo... perché usare uno invece dell'altro? :D

Infatti, proprio per questo io l'esercizio l'ho risolto con while, perchè for attraversa tutta la stringa a prescindere dall'indice che gli passo, invece con while posso gestire la condizione in modo più flessibile. Proprio come ha detto grigor91, infatti quel codice con il for era un test, come ho già detto io non mi fermo ai semplici esercizietti e basta, a me piace sperimentare ;)

P.S: ecco il link, paragrafo 7.3 http://www.python.it/doc/Howtothink/Howtothink-html-it/chap07.htm

[DanieleC88]

P.S: ecco il link, paragrafo 7.3 http://www.python.it/doc/Howtothink/Howtothink-html-it/chap07.htm
Be' se guardi gli esempio però:
Indice = 0
while Indice < len(Frutto):
Lettera = Frutto[Indice]
print Lettera
Indice = Indice + 1

for Lettera in Frutto:
print Lettera
Non sono la stessa cosa di quel che hai scritto: diciamo che ne hai fatto un miscuglio e perciò non funziona. ;)

[~FullSyst3m~]

Be' se guardi gli esempio però:

Non sono la stessa cosa di quel che hai scritto: diciamo che ne hai fatto un miscuglio e perciò non funziona. ;)

A quale miscuglio ti riferisci scusa?

Attenzione comunque, non si devono scambiare le prove e lo smanettamento sul codice con gli errori veri e propri che si fanno per disattenzione o altro eh! Quel miscuglio l'ho fatto per prova, infatti l'esercizio l'ho svolto con il while proprio perchè il for attraversa tutta la stringa, è questa la differenza tra le due istruzioni (non volevi sapere questo?) ;)

[~FullSyst3m~]

gurda qui se vuoi la soluzione:
In Python il for ha un meccanismo diverso dagli altri linguaggi:
praticamente nel tuo caso il for fa tanti cicli quanti ne impiega per scorrere la parola (quindi fa tanti cicli quanto è lunga la parola). Questo fa capire che è indipendente dal carattere da cui parti: "banana", per esempio, ha 6 lettere; se parti dalla terza lettera fai sempre 6 cicli e quindi "sfori". Spero di essere stato chiaro e di averti fatto capire cosa non avevi approfondito.

Questo for non si riferisce al mio caso come hai detto tu, ma credo che sia proprio la il funzionamento che ha il for in Python, infatti lo dice pure nel libro che il for attraversa la stringa completamente, dall'inizio alla fine. Ci tengo a precisare pure, anche se non so se negli altri linguaggi è la stessa cosa, che il nome dopo il for può essere messo a piacere. Nel mio caso, al posto di for Carattere in Lettera, si sarebbe pure potuto scrivere for Bush in Lettera ad esempio ;)

[~FullSyst3m~]

Sai che quel for scritto così è pressoché inutile, sì? :D

Va "out of bounds" perché il for seguente:
for Carattere in Stringa:
print Carattere
è uguale al while seguente:
Indice = 0
n = len(Stringa)
while Indice < n:
print Stringa[Indice]
Indice += 1
Come vedi, vengono letti tutti gli n caratteri della stringa, e Carattere è uguale ogni volta a Stringa[Indice].

Ora, dal momento che quel for fa n iterazioni, e tu stai facendo partire l'indice da un valore maggiore di zero, a quanto arriverà l'indice incrementandolo ad ogni iterazione? Sarà sempre nel range 0..(n-1)?

Rileggi bene il codice e cerca di capire cosa stai facendo veramente, e, soprattutto, se il for del Python hai capito bene a che serve (88MIKI88 non aveva tutti i torti, ma è stato un po' brusco! :D).

ciao ;)

P.S: non so se in qualche linguaggio questa sintassi è valida, ma in Python non lo è. In Python è corretto scrivere Indice = Indice +1 ;)

[DanieleC88]

A quale miscuglio ti riferisci scusa?
Nel senso che hai usato in for come un while, pur sapendo che lì l'indice aveva poco senso. :)
Attenzione comunque, non si devono scambiare le prove e lo smanettamento sul codice con gli errori veri e propri che si fanno per disattenzione o altro eh!
D'accordo, ma io ti invito a sperimentare con la testa prima che con le mani: "provare per vedere che succede" è una cosa buona, ma ti insegna di più chiederti prima "che cosa succederebbe se...?" e provare a risponderti da solo, utilizzando poi il calcolatore solo per verifica. ;)

[DanieleC88]

P.S: non so se in qualche linguaggio questa sintassi è valida, ma in Python non lo è.
Provala! :p

[variabilepippo]

non so se in qualche linguaggio questa sintassi è valida, ma in Python non lo è.


Se fossi in te la proverei su Python... :rolleyes:

[~FullSyst3m~]

Se fossi in te la proverei su Python... :rolleyes:

Scusate, io avevo provato questa Indice = +1, per vedere che succedeva e mi si è impallato tutto :D

Quella sintassi è valida allora? Mai vista fino ad ora. Significa che incrementa di 1?

Nel senso che hai usato in for come un while, pur sapendo che lì l'indice aveva poco senso. D'accordo, ma io ti invito a sperimentare con la testa prima che con le mani: "provare per vedere che succede" è una cosa buona, ma ti insegna di più chiederti prima "che cosa succederebbe se...?" e provare a risponderti da solo, utilizzando poi il calcolatore solo per verifica

Ma io sperimento con la testa, infatti prima di scrivere codice-prototipo mi chiedo sempre: "e se provo a fare questo? E se provo a fare quello?" ;)

[VICIUS]

Scusate, io avevo provato questa Indice = +1, per vedere che succedeva e mi si è impallato tutto :D

Quella sintassi è valida allora? Mai vista fino ad ora. Significa che incrementa di 1?
Sono entrambe valide. Indice = +1 è equivalente a Indice = 1 quindi è un assegnamento di conseguenza quella variabile ha lo stesso valore. Ti si è impallato python perché ovviamente la condizione di terminazione del ciclo non diventava mai vera.

Indice += 1 invece è una forma abbreviata di Indice = Indice + 1. Questa è una syntactic candy, una finezza per scrivere codice più corto offerta da python e che ti conviene approfondire solo dopo che hai finito il libro.

[variabilepippo]

Quella sintassi è valida allora? Mai vista fino ad ora. Significa che incrementa di 1?


Esatto, esegui questo codice e prova a "tradurre in parole" l'operazione svolta da ogni riga:


indice = 0
indice += 1
indice *= 5
indice -= 1
indice /= 2
print indice

[~FullSyst3m~]

Sono entrambe valide. Indice = +1 è equivalente a Indice = 1 quindi è un assegnamento di conseguenza quella variabile ha lo stesso valore. Ti si è impallato python perché ovviamente la condizione di terminazione del ciclo non diventava mai vera.

Ah, ma è uguale a indice = 1, non incrementa la variabile ad ogni ciclo però

Indice += 1 invece è una forma abbreviata di Indice = Indice + 1. Questa è una syntactic candy, una finezza per scrivere codice più corto offerta da python e che ti conviene approfondire solo dopo che hai finito il libro.


Infatti nel libro non ne se ne parla proprio di questa syntactic candy

Esatto, esegui questo codice e prova a "tradurre in parole" l'operazione svolta da ogni riga

Mi stampa 2... capito. In pratica questa sintassi sarebbe l'equivalente di Indice = Indice + 1, Indice = Indice * 5, Indice = Indice - 1 e Indice = Indice /2


P.S: sto ancora ragionando su queste due cose, ma non mi sono molto chiare. Forse dovrei usare SPE come dice cdimauro, ma al momento mi sta creando problemi nell'installazione:

import math

def DistanzaTraDuePunti(x1,y1,x2,y2):
dx=x2-x1
dy=y2-y1
DistQuadrata=dx**2+dy**2
Risultato=math.sqrt(DistQuadrata)
print Risultato
return Risultato


def AreaCerchio(Raggio):
math.pi*Raggio**2


def AreaCerchio2(xc,yc,xp,yp):
Raggio=DistanzaTraDuePunti(xc,yc,xp,yp)
Risultato=AreaCerchio(Raggio)
print Risultato
return Risultato

AreaCerchio2(4,9,7,3)

1) se chiamo la funzione AreaCerchio2 mi ritorna prima il risultato e poi il None. Perchè?

2) se tolgo il print dalla funzione AreaCerchio2 mi ritorna il valore, ma il None sparisce. Perchè?

3) se metto il print davanti la chiamata della funzione AreaCerchio2 mi ritorna il risultato e due None. Perchè?

4) se tolgo il print dalla funzione DistanzaTraDuePunti viene stampato None. Perchè?

5) se invece tolgo il print dalla funzione AreaCerchio2 e metto il print nella funzione DistanzaTraDuePunti mi stampa solo il risultato. Perchè?

Grazie per la pazienza

[grigor91]

def AreaCerchio(Raggio):
math.pi*Raggio**2


mi sa che qui manca qualcosa...

[~FullSyst3m~]

def AreaCerchio(Raggio):
math.pi*Raggio**2


mi sa che qui manca qualcosa...

Si lo so, manca il return. Ma sul libro è cosi, mi sto attenendo al codice scritto sul libro riguardo questa funzione ;) Le cose che non mi quadrano sono i vari risultati ottenuti modificando i vari print nelle funzioni e nella chiamata delle funzioni

[grigor91]

Si lo so, manca il return. Ma sul libro è cosi, mi sto attenendo al codice scritto sul libro riguardo questa funzione ;) Le cose che non mi quadrano sono i vari risultati ottenuti modificando i vari print nelle funzioni e nella chiamata delle funzioni

nel paragrafo 5.1 è così:
def AreaDelCerchio(raggio):
return math.pi * Raggio**2



2) se tolgo il print dalla funzione AreaCerchio2 mi ritorna il valore, ma il None sparisce. Perchè?


Se AreaCerchio non ha il return ritorna di default None, quindi Risultato vale None, che è quello stampato ;)
il risultato che viene stampato è quello della funzione DistanzaTraDuePunti



3) se metto il print davanti la chiamata della funzione AreaCerchio2 mi ritorna il risultato e due None. Perchè?

Come prima: visto che Risultato è None, il print stampa None.



4) se tolgo il print dalla funzione DistanzaTraDuePunti viene stampato None. Perchè?

Visto che è quello che stampa il risultato se lo togli non lo stampa più :D

Al quinto punto ci puoi arrivare dalle risposte precedenti.

[~FullSyst3m~]

nel paragrafo 5.1 è così:
def AreaDelCerchio(raggio):
return math.pi * Raggio**2

E' vero scusa, il return l'avevo tolto io per vedere che succedeva

Se AreaCerchio non ha il return ritorna di default None, quindi Risultato vale None, che è quello stampato ;)
il risultato che viene stampato è quello della funzione DistanzaTraDuePunti

Questo l'ho capito, non hai capito che volevo dire. E comunque il risultato che ritorna perchè è quello di DistanzaTraDuePunti? Per correttezza dovrebbe essere quello della funzione AreaCerchio2

Come prima: visto che Risultato è None, il print stampa None.

Si, su questo ci siamo. Ma me ne stampa due None, non uno

Visto che è quello che stampa il risultato se lo togli non lo stampa più :D

Al quinto punto ci puoi arrivare dalle risposte precedenti.

Mi sembra logico ;) Comunque rileggendola la quinta è uguale alle altre domande, è una sintesi diciamo delle altre domande :muro: E' stata una settimana difficile scusate :tapiro:

[^TiGeRShArK^]

Ah, ma è uguale a indice = 1, non incrementa la variabile ad ogni ciclo però

Indice += 1 invece è una forma abbreviata di Indice = Indice + 1. Questa è una syntactic candy, una finezza per scrivere codice più corto offerta da python e che ti conviene approfondire solo dopo che hai finito il libro.


Infatti nel libro non ne se ne parla proprio di questa syntactic candy



Mi stampa 2... capito. In pratica questa sintassi sarebbe l'equivalente di Indice = Indice + 1, Indice = Indice * 5, Indice = Indice - 1 e Indice = Indice /2


P.S: sto ancora ragionando su queste due cose, ma non mi sono molto chiare. Forse dovrei usare SPE come dice cdimauro, ma al momento mi sta creando problemi nell'installazione:

import math

def DistanzaTraDuePunti(x1,y1,x2,y2):
dx=x2-x1
dy=y2-y1
DistQuadrata=dx**2+dy**2
Risultato=math.sqrt(DistQuadrata)
print Risultato
return Risultato


def AreaCerchio(Raggio):
math.pi*Raggio**2


def AreaCerchio2(xc,yc,xp,yp):
Raggio=DistanzaTraDuePunti(xc,yc,xp,yp)
Risultato=AreaCerchio(Raggio)
print Risultato
return Risultato

AreaCerchio2(4,9,7,3)

1) se chiamo la funzione AreaCerchio2 mi ritorna prima il risultato e poi il None. Perchè?

2) se tolgo il print dalla funzione AreaCerchio2 mi ritorna il valore, ma il None sparisce. Perchè?

3) se metto il print davanti la chiamata della funzione AreaCerchio2 mi ritorna il risultato e due None. Perchè?

4) se tolgo il print dalla funzione DistanzaTraDuePunti viene stampato None. Perchè?

5) se invece tolgo il print dalla funzione AreaCerchio2 e metto il print nella funzione DistanzaTraDuePunti mi stampa solo il risultato. Perchè?

Grazie per la pazienza

perchè essenzialmente devi tornare indietro di qualche capitolo e comprendere PER BENE l'utilizzo delle funzioni prima di proseguire.

[~FullSyst3m~]

perchè essenzialmente devi tornare indietro di qualche capitolo e comprendere PER BENE l'utilizzo delle funzioni prima di proseguire.

Se non l'avessi compreso non avrei compreso nemmeno la TabellaMoltiplicazioneGenerica e non potrei comprendere le cose che sto facendo ora. E' solo che quelle cose mi hanno lasciato un pò scettico

[^TiGeRShArK^]

Se non l'avessi compreso non avrei compreso nemmeno la TabellaMoltiplicazioneGenerica e non potrei comprendere le cose che sto facendo ora. E' solo che quelle cose mi hanno lasciato un pò scettico
evidentemente non hai capito bene come funzionano dal codice che hai scritto.
E inoltre utilizzare una stampa in una funzione che restituisce qualcosa è di solito sbagliato.
La si può usare per debug o in casi particolari, ma altrimenti non dovrebbe servire a niente dato che la funzione ti restituisce già quello che ti serve e lo puoi stampare tranquillamente al di fuori di essa....

[~FullSyst3m~]

evidentemente non hai capito bene come funzionano dal codice che hai scritto.
E inoltre utilizzare una stampa in una funzione che restituisce qualcosa è di solito sbagliato.
La si può usare per debug o in casi particolari, ma altrimenti non dovrebbe servire a niente dato che la funzione ti restituisce già quello che ti serve e lo puoi stampare tranquillamente al di fuori di essa....

Il codice che ho scritto non è quello del libro, l'ho modificato io perchè mi ero chiesto cosa poteva succedere e ora vorrei capire il perchè del funzionamente. Inoltre l'istruzione di stampa la metto perchè il return non mi visualizza niente se non scrivo il codice nella command line. E' per vedere se il risultato che restituisce return è esatto.

Comunque in che senso "non dovrebbe servire a niente dato che la funzione ti restituisce già quello che ti serve e lo puoi stampare tranquillamente al di fuori di essa"?

[variabilepippo]

Inoltre l'istruzione di stampa la metto perchè il return non mi visualizza niente se non scrivo il codice nella command line. E' per vedere se il risultato che restituisce return è esatto.


Le funzioni andrebbero usate in modo diverso, come suggerito anche da ^TiGeRShArK^.


Comunque in che senso "non dovrebbe servire a niente dato che la funzione ti restituisce già quello che ti serve e lo puoi stampare tranquillamente al di fuori di essa"?


E' legato all'uso che si fa delle funzioni, la stampa non deve avvenire all'interno del corpo della funzione, ma nel codice chiamante.

Sei sicuro di aver capito a cosa serva effettivamente una funzione?

[~FullSyst3m~]

Le funzioni andrebbero usate in modo diverso, come suggerito anche da ^TiGeRShArK^.



E' legato all'uso che si fa delle funzioni, la stampa non deve avvenire all'interno del corpo della funzione, ma nel codice chiamante.

Sei sicuro di aver capito a cosa serva effettivamente una funzione?

Come andrebbero usate? Forse non si è capito, ma io le ho modificate cosi per vedere cosa succedeva, solo per curiosità. Comunque ho capito a cosa serve una funzione, non sono cosi a terra :(

[variabilepippo]

Come andrebbero usate?


Come si usano le funzioni: resituiscono "qualcosa" ad un "chiamante", sarà poi il "chiamante" a gestire quel "qualcosa", per esempio stampandolo...


Comunque ho capito a cosa serve una funzione


Quindi sai anche modificare il codice in modo da far stampare il risultato dal "chiamante"?

[~FullSyst3m~]

Come si usano le funzioni: resituiscono "qualcosa" ad un "chiamante", sarà poi il "chiamante" a gestire quel "qualcosa", per esempio stampandolo...

Infatti, lo so questo. Oltretutto è anche spiegato chiaro e limpido sul libro che sto studiando: "Alcune delle funzioni predefinite che abbiamo usato finora producono dei risultati: la chiamata della funzione con un particolare argomento genera un nuovo valore che viene in seguito assegnato ad una variabile o viene usato come parte di un'espressione."

Quindi sai anche modificare il codice in modo da far stampare il risultato dal "chiamante"?

Se lo devo fare stampare dal chiamante devo mettere il print nella funzione DistanzaTraDuePunti e quando chiamo AreaCerchio2 mi stampa il risultato. Volevi dire questo?

[variabilepippo]

Volevi dire questo?


Posta il codice corretto, così evitiamo ambiguità e vediamo se hai chiaro l'uso delle funzioni. :) Non è un esame, serve soltanto per fugare ogni tuo eventuale dubbio.

[~FullSyst3m~]

Posta il codice corretto, così evitiamo ambiguità e vediamo se hai chiaro l'uso delle funzioni. :) Non è un esame, serve soltanto per fugare ogni tuo eventuale dubbio.

Si si lo so, figurati. Anzi vi ringrazio per la pazienza. Ecco il codice:

import math

def DistanzaTraDuePunti(x1,y1,x2,y2):
dx=x2-x1
dy=y2-y1
DistQuadrata=dx**2+dy**2
Risultato=math.sqrt(DistQuadrata)
print Risultato
return Risultato


def AreaCerchio(Raggio):
return math.pi*Raggio**2


def AreaCerchio2(xc,yc,xp,yp):
Raggio=DistanzaTraDuePunti(xc,yc,xp,yp)
Risultato=AreaCerchio(Raggio)
return Risultato

AreaCerchio2(4,9,7,3)

[grigor91]

Si si lo so, figurati. Anzi vi ringrazio per la pazienza. Ecco il codice:

import math

def DistanzaTraDuePunti(x1,y1,x2,y2):
dx=x2-x1
dy=y2-y1
DistQuadrata=dx**2+dy**2
Risultato=math.sqrt(DistQuadrata)
print Risultato
return Risultato


def AreaCerchio(Raggio):
return math.pi*Raggio**2


def AreaCerchio2(xc,yc,xp,yp):
Raggio=DistanzaTraDuePunti(xc,yc,xp,yp)
Risultato=AreaCerchio(Raggio)
return Risultato

AreaCerchio2(4,9,7,3)

Così stampi dalla funzione chiamata, non dalla chiamante...

[~FullSyst3m~]

Così stampi dalla funzione chiamata, non dalla chiamante...

Allora se devo stampare dalla chiamante basta che metto il print davanti alla chiamata di AreaCerchio2

[grigor91]

Allora se devo stampare dalla chiamante basta che metto il print davanti alla chiamata di AreaCerchio2

Si può fare anche così

[~FullSyst3m~]

Si può fare anche così

C'è qualche altro modo?

[grigor91]

C'è qualche altro modo?

Puoi stampare Risultato da dentro AreaCerchio2

[~FullSyst3m~]

Puoi stampare Risultato da dentro AreaCerchio2

Già provato a fare questo, ma in questo caso non lo stampa dalla funzione chiamante, ma da quella chiamata

[^TiGeRShArK^]

C'è qualche altro modo?

io il codice lo scriverei così:

import math

def DistanzaTraDuePunti(x1, y1, x2, y2):
dx = x2 - x1
dy = y2 - y1
return math.sqrt(dx ** 2 + dy ** 2)


def AreaCerchio (x1, y1, x2, y2):
Raggio = DistanzaTraDuePunti(x1, y1, x2, y2)
return math.pi * Raggio ** 2

print AreaCerchio(4, 9, 7, 3)

[nico159]

io il codice lo scriverei così:

import math

def DistanzaTraDuePunti(x1, y1, x2, y2):
dx = x2 - x1
dy = y2 - y1
return math.sqrt(dx ** 2 + dy ** 2)


def AreaCerchio (x1, y1, x2, y2):
Raggio = DistanzaTraDuePunti(x1, y1, x2, y2)
return math.pi * Raggio ** 2

print AreaCerchio(4, 9, 7, 3)

Senza contare che si potrebbero usare delle tuple per rappresentare ogni punto :D
puntoA = (0, 4)

Semi OT: Python Rulla :D

[~FullSyst3m~]

io il codice lo scriverei così:

import math

def DistanzaTraDuePunti(x1, y1, x2, y2):
dx = x2 - x1
dy = y2 - y1
return math.sqrt(dx ** 2 + dy ** 2)


def AreaCerchio (x1, y1, x2, y2):
Raggio = DistanzaTraDuePunti(x1, y1, x2, y2)
return math.pi * Raggio ** 2

print AreaCerchio(4, 9, 7, 3)


Si certo, cosi è meglio ancora. Io ho scritto il codice in quel modo perchè nel libro è scritto cosi per fare vedere tutti i passaggi. Quello che non mi è chiaro è solo questo: se io metto il print in DistanzaTraDuePunti e chiamo la funzione AreaCerchio2, mi stampa il risultato tranquillamente, se invece il print lo metto nella funzione AreaCerhio2 e poi la chiamo mi stampa None senza nessun risultato. Vero, il print come ha detto variabilepippo si dovrebbe inserire nella chiamata di funzione, ma adesso è solo per capire. Il Risultato dovrebbe essere tornato dalla funzione AreaCerchio2 perchè è lei che viene chiamata. Il Risultato di DistanzaTraDuePunti viene passato poi come valore per la variabile Raggio

Senza contare che si potrebbero usare delle tuple per rappresentare ogni punto
puntoA = (0, 4)

PuntoA = (0, 4)? Cioè? Ancora non sono arrivato alle tuple, mi manca un capitolo...

Semi OT: Python Rulla

E di brutto :D Ne sono innamorato (oltre ad essere innamorato della programmazione in generale!). Stai iniziando ora a studiare Python?

[~FullSyst3m~]

C’è un modo per stampare la lunghezza di un intero? Perché sono arrivato al capitolo 8.3, c’è questa lista: [“Ciao!”, 1, [“mela”, “banana”, “pera”], [1,2,3]] e l’esercizio consiste nel scrivere un ciclo che attraversa questa stringa e stampa la lunghezza di ogni elemento. Il codice che ho scritto è questo:

Lista = ["Ciao!", ["mela", "pera", "banana"], [1,2,3]]
i = 0
while i < len(Lista):
Elemento = Lista[i]
print Lista[i], "-->", len(Elemento)
i = i + 1

e funziona tutto correttamente. Magari direte: “ma l’1 dove è?”.. bè, l’ho tolto perché Python mi dice che non si può stampare la lunghezza di un intero

P.S: mettendo la variabile Elemento fuori dal ciclo, non funziona il codice nonostante la varibile i viene incrementata ad ogni ciclo. Il valore di i nella variabile Elemento resta il primo, cioè 5. Io pensavo che venisse “sostituito” in automatico il valore di i nella variabile Elemento quanto i incrementa di 1 ad ogni ciclo

[nico159]

Alcuni piccoli consigli...per la "lunghezza" di numeri, googlando ho trovato len( str(numero) ) praticamente converte in stringa il numero e poi ne calcola la lunghezza :D
Ma devi stare attento ad applicarla solo per i numeri
Poi ti sei complicato la vita usando while, quando con un for avresti potuto fare
lista = ['Ciao!', ['mela', 'pera', 'banana'], [1,2,3]]

for elemento in lista:
print elemento, '-->', len(elemento)

[~FullSyst3m~]

Alcuni piccoli consigli...per la "lunghezza" di numeri, googlando ho trovato len( str(numero) ) praticamente converte in stringa il numero e poi ne calcola la lunghezza :D

Poi ti sei complicato la vita usando while, quando con il for avresti potuto fare
lista = ['Ciao!', 2, ['mela', 'pera', 'banana'], [1,2,3]]

for elemento in lista:
print elemento, '-->', len( str(elemento) )

Si, str converte in stringa. E' nei primissimi capitoli, io pensavo che l'esercizio si riferisse a quel paragrafo specifico, invece ogni esercizio man mano che si va avanti richiede anche di applicare le conoscenze passate ovviamente.
Riguardo il for, l'ho pure scritto il codice con il for prima di quello con il while ;) Ma tu programmi in Python?

P.S: guardate qua:

for Frutto in ["mela", "pera", "banana"]:
print "Mi piace la" + Frutto + "!"


Questi + non mi sembra che abbiano utilità visto che l'output è questo:

Mi piace lamela!
Mi piace lapera!
Mi piace labanana!

Se al posto dei + si mette la , normalmente allora tutto ok (tranne per il punto escalmativo che è lontano di uno spazio e si dovrebbe mettere direttamente nella lista)

[nico159]

Sì, all'atto pratico cambia niente :D
Usando l'operatore +, in questo caso, concateni più stringhe e stampi il nuovo oggetto stringa così creato.
Invece usando , nell'istruzione print fai sì che python mostri più stringhe su una sola riga separate una dall'altra da uno spazio (ecco perchè il punto esclamativo usando , viene separato anche lui da uno spazio).

In questo caso non c'è differenza, ma vedrai che l'operatore + ti sarà fondamentale :D

[~FullSyst3m~]

Sì, all'atto pratico cambia niente :D
Usando l'operatore +, in questo caso, concateni più stringhe e stampi il nuovo oggetto stringa così creato.
Invece usando , nell'istruzione print fai sì che python mostri più stringhe su una sola riga separate una dall'altra da uno spazio (ecco perchè il punto esclamativo usando , viene separato anche lui da uno spazio).

In questo caso non c'è differenza, ma vedrai che l'operatore + ti sarà fondamentale :D

Si l'ho fatto il concatenamento delle stringhe, ma in questo caso il risultato è identico, anzi è meglio con la virgola perchè con il + l'articolo e il frutto vengono stampati assieme. Comunque è cosi fondamentale l'oepratore + sulle stringhe?
Comunque tu programmi in Python allora. Lo hai studiato nella documentazione ufficiale? Ora con la versione 3 ci saranno un sacco di cambiamenti e la compatibilità diventerà nulla

P.S: ho modificato il ciclo cosi, ma mi dà sempre l'errore che la lunghezza si calcola sulle stringhe:

Lista = ["Ciao!", 1, ["mela", "pera", "banana"], [1,2,3,]]

for elemento in Lista:
if type(elemento) == type(1):
str(elemento)
print elemento, '-->', len(elemento)

[88MIKI88]

Lista = ['ciao!', 1, ['mela', 'pera', 'banana'], [1, 2, 3]]

def Function2(Lista):
for elemento in Lista:
if type(elemento) == int:
print len(str(elemento))
else:
print elemento, len(elemento)

[~FullSyst3m~]

Lista = ['ciao!', 1, ['mela', 'pera', 'banana'], [1, 2, 3]]

def Function2(Lista):
for elemento in Lista:
if type(elemento) == int:
print len(str(elemento))
else:
print elemento, len(elemento)



Questo lo potevo fare pure io, volevo cercare un metodo alternativo per semplificare il codice

[88MIKI88]

Questo lo potevo fare pure io, volevo cercare un metodo alternativo per semplificare il codice

Se te sei capace di fare tutte queste cose perchè non posti il codice corretto??

Non riesco a capire.....dici che il codice non funziona ti posto quello che

funziona e mi dici che eri capace di farlo pure te???

[~FullSyst3m~]

Se te sei capace di fare tutte queste cose perchè non posti il codice corretto??

Non riesco a capire.....dici che il codice non funziona ti posto quello che

funziona e mi dici che eri capace di farlo pure te???

Allora non mi capisci. Che devo postare a fare il codice che funziona? Se posto un codice vuol dire che voglio capire il perchè non funziona o come migliorarlo. Non ha senso che posto un codice che mi funziona

[^TiGeRShArK^]

Se te sei capace di fare tutte queste cose perchè non posti il codice corretto??

Non riesco a capire.....dici che il codice non funziona ti posto quello che

funziona e mi dici che eri capace di farlo pure te???

:asd:

[~FullSyst3m~]

:asd:

Forse non hai letto quello che ho scritto sotto. Se dovete prendere in giro non posto più e la finiamo cosi

[^TiGeRShArK^]

Forse non hai letto quello che ho scritto sotto. Se dovete prendere in giro non posto più e la finiamo cosi

rilassati..
ridevo solo perchè l'avevo notato anch'io questo tuo atteggiamento...
Lo facevi anche quando postavi con i vari cloni, dopo che davamo la soluzione al tuo clone postavi con questo nick per metterti in mostra :rolleyes:
Se permetti io ho trovato il tuo atteggiamento piuttosto offensivo, dato che sembrava che ci volessi prendere x il culo pensando che non se ne accorgesse nessuno dei tuoi cloni :rolleyes:

[~FullSyst3m~]

rilassati..
ridevo solo perchè l'avevo notato anch'io questo tuo atteggiamento...
Lo facevi anche quando postavi con i vari cloni, dopo che davamo la soluzione al tuo clone postavi con questo nick per metterti in mostra :rolleyes:
Se permetti io ho trovato il tuo atteggiamento piuttosto offensivo, dato che sembrava che ci volessi prendere x il culo pensando che non se ne accorgesse nessuno dei tuoi cloni :rolleyes:

Ripeto, io non avevo nessun clone. Ma non devo dimostrare niente a nessuno apparte ai mod con i quali ho già parlato. Oltre a questo io non voglio offendere nessuno, non mi permetterei mai e non mi sono mai voluto mettere in mostra, altrimenti non avrei aperto questo topic. Se posto una cosa mi sembra chiaro che sia per capire, non vado a postare il codice corretto. Ma comuque, l'importante sapere l'idea che vi fate cosi mi posso comportare di conseguenza e stare attento a ciò che scrivo

[^TiGeRShArK^]

Ripeto, io non avevo nessun clone.
ah vabbè..
allora si può chiudere qui.
E' inutile parlare con chi tenta ancora di prendere per il culo dopo tutto questo. :rolleyes:
Guarda che non siamo idioti come tu pensi. :rolleyes:
Adieu.

[~FullSyst3m~]

ah vabbè..
allora si può chiudere qui.
E' inutile parlare con chi tenta ancora di prendere per il culo dopo tutto questo. :rolleyes:
Guarda che non siamo idioti come tu pensi. :rolleyes:
Adieu.

Io non penso nè che siete idioti nè voglio prendere per il culo nessuno. Invece di sparare giudizi ragiona sulle cose. Non è bello essere accusati cosi ed essere aggrediti ogni volta. Se tu o altri siete nati imparati fortunati voi, che vi devo dire

[cdimauro]

Comunque tu programmi in Python allora. Lo hai studiato nella documentazione ufficiale? Ora con la versione 3 ci saranno un sacco di cambiamenti e la compatibilità diventerà nulla
Questo non è vero. Python 3 è abbastanza compatibile con le versioni precedenti. Inoltre viene fornito un tool di conversione automatica alla 3, che fa buona parte del lavoro.
Questo lo potevo fare pure io, volevo cercare un metodo alternativo per semplificare il codice
Lista = ['ciao!', 1, ['mela', 'pera', 'banana'], [1, 2, 3]]
Lunghezze = [len(str(Elemento)) for Elemento in Lista]
print Lunghezze
P.S. Posta sempre il codice.

[~FullSyst3m~]

Questo non è vero. Python 3 è abbastanza compatibile con le versioni precedenti. Inoltre viene fornito un tool di conversione automatica alla 3, che fa buona parte del lavoro.

Lista = ['ciao!', 1, ['mela', 'pera', 'banana'], [1, 2, 3]]
Lunghezze = [len(str(Elemento)) for Elemento in Lista]
print Lunghezze
P.S. Posta sempre il codice.

Bentornato cdimauro. Ok posterò sempre il codce.
Questa sintassi non la conoscevo, però il tuo codice stampa solo la lunghezza dei vari elementi (anche se comunque la lista con la frutta mi stampa 26 e quella con i numeri 9), l'esercizio invece vuole che si stampi sia l'elemento sia la lunghezza. Ma comunque lo avevo fatto sia con il for che con il while, volevo solo rovare a ridurre ancora di più il codice.
Riguardo il Python 3, io ho letto cosi. Anche se il 2.xx verrà ancora sviluppato e che all'inizio non ci sarà completa incopatibilità

[cdimauro]

Lista = ['ciao!', 1, ['mela', 'pera', 'banana'], [1, 2, 3]]
NuovaLista = [(Elemento, len(str(Elemento))) for Elemento in Lista]
print NuovaLista

[88MIKI88]

Allora non mi capisci. Che devo postare a fare il codice che funziona? Se posto un codice vuol dire che voglio capire il perchè non funziona o come migliorarlo. Non ha senso che posto un codice che mi funziona

Allora quando io posto il codice corretto non puoi venire fuori con la frase "questo lo sapevo fare anche io" perchè allora ci stai prendendo in giro!!!


Cdimauro a proposito visto che sei tornato mi daresti una mano su un esercizio?? Avrei bisogno di un input tanto x iniziare poi me la cavo da solo

[~FullSyst3m~]

Lista = ['ciao!', 1, ['mela', 'pera', 'banana'], [1, 2, 3]]
NuovaLista = [(Elemento, len(str(Elemento))) for Elemento in Lista]
print NuovaLista

Devo studiare sulla documentazione ufficiale dopo il libro, non sapevo che si poteva fare pure cosi

Allora quando io posto il codice corretto non puoi venire fuori con la frase "questo lo sapevo fare anche io" perchè allora ci stai prendendo in giro!!!

Guarda evitiamo discussioni che proprio non ho tempo e voglia. Ti dico solo di leggere bene quello che scrivo e non interpretarlo a modo tuo. Grazie

[cdimauro]

Cdimauro a proposito visto che sei tornato mi daresti una mano su un esercizio?? Avrei bisogno di un input tanto x iniziare poi me la cavo da solo
Sono ancora abbastanza incasinato, per cui cercherò di darti una mano quando posso.

Intanto esponi il tuo problema. :)

[~FullSyst3m~]

I due esercizietti del capitolo 9.4:

http://www.hwupgrade.it/forum/showpost.php?p=24600031&postcount=13
http://www.hwupgrade.it/forum/showpost.php?p=24600236&postcount=15

88MIKI88: dove hai letto di quelle funzioni (random.randint e random.uniform)? Nel Pensare da informatico non dice nulla, infatti non li ho risolti questi esercizi

[cdimauro]

Mi pare molto semplice, e riguarda più che altro la matematica.

Pensaci bene: random.random() restituisce un valore compreso fra 0.0 e 1.0 (quest'ultimo escluso; quindi non avrai MAI 1.0).

Si tratta di semplicemente di "espandere" questi valori per fargli abbracciare i due limiti imposti.

Ripeto: è solo la matematica che ti può salvare qui.

[88MIKI88]

Sono ancora abbastanza incasinato, per cui cercherò di darti una mano quando posso.

Intanto esponi il tuo problema. :)

Il mio problema è qua:

http://www.hwupgrade.it/forum/showthread.php?t=1849150

[88MIKI88]

I due esercizietti del capitolo 9.4:

http://www.hwupgrade.it/forum/showpost.php?p=24600031&postcount=13
http://www.hwupgrade.it/forum/showpost.php?p=24600236&postcount=15

88MIKI88: dove hai letto di quelle funzioni (random.randint e random.uniform)? Nel Pensare da informatico non dice nulla, infatti non li ho risolti questi esercizi

Il libro ti serve a capire solo la sintassi e basta

[~FullSyst3m~]

Mi pare molto semplice, e riguarda più che altro la matematica.

Pensaci bene: random.random() restituisce un valore compreso fra 0.0 e 1.0 (quest'ultimo escluso; quindi non avrai MAI 1.0).

Si tratta di semplicemente di "espandere" questi valori per fargli abbracciare i due limiti imposti.

Ripeto: è solo la matematica che ti può salvare qui.

Non credo che sia solo la matematica. Io credevo che essendo un esercizio del libro si riferisse a quello studiato fino ad ora, non c'era nessun riferimento a random.uniform e random.randint. Infatti conoscendo queste due funzioni l'esercizio si risolve velocemente

Il libro ti serve a capire solo la sintassi e basta

Appunto per questo gli esercizi dovrebbero essere basati su quello che si è studiato e non su funzioni che non si conoscono. A te come ti è venuto in mente di cercare quelle funzioni?

[88MIKI88]

Non credo che sia solo la matematica. Io credevo che essendo un esercizio del libro si riferisse a quello studiato fino ad ora, non c'era nessun riferimento a random.uniform e random.randint. Infatti conoscendo queste due funzioni l'esercizio si risolve velocemente



Appunto per questo gli esercizi dovrebbero essere basati su quello che si è studiato e non su funzioni che non si conoscono. A te come ti è venuto in mente di cercare quelle funzioni?

perchè se vuoi imparare a programmare devi uscire dal libro e trovare strade alternative

[~FullSyst3m~]

perchè se vuoi imparare a programmare devi uscire dal libro e trovare strade alternative

E' un libro per chi inizia questo, le strade alternative si devono trovare dopo aver letto il libro, non mentre lo leggi senza che ancora si è in grado di programmare. Per fare un esercizio del genere si doveva essere a conoscenza di quelle funzioni, accennarle almeno. Tu magari hai pensato di andare a cercare nella documentazione delle funzioni, però non tutti ci pensano essendo che stanno studiando sul libro e gli esercizi si suppone riguardino le cose fatte sul libro. Solo questo

[cdimauro]

Non credo che sia solo la matematica. Io credevo che essendo un esercizio del libro si riferisse a quello studiato fino ad ora, non c'era nessun riferimento a random.uniform e random.randint. Infatti conoscendo queste due funzioni l'esercizio si risolve velocemente

Appunto per questo gli esercizi dovrebbero essere basati su quello che si è studiato e non su funzioni che non si conoscono. A te come ti è venuto in mente di cercare quelle funzioni?
Infatti come torno a ripeterti la soluzione è puramente matematica.

Poi è vero che ci sono quelle due funzioni che risolvono tutto (e Python ha TAAANTI moduli di libreria molto utili), ma io sconsiglio di usarle per risolvere gli esercizi.

[~FullSyst3m~]

Infatti come torno a ripeterti la soluzione è puramente matematica.

Poi è vero che ci sono quelle due funzioni che risolvono tutto (e Python ha TAAANTI moduli di libreria molto utili), ma io sconsiglio di usarle per risolvere gli esercizi.

Se ci sono perchè non usarle? Comunque tu come li risolveresti allora quegli esercizi senza usare le funzioni random.uniform e random.randint?

P.S: questo capitolo 9 è abbastanza criptico comunque, ad esempio vengono portati gli esempi senza che le variabili vengano dichiarate e non si capisce su quali valori sta tenendo in considerazione il libro

[88MIKI88]

cdimauro hai già avuto modo di vedere il mio post che ti ho segnalato???

[cdimauro]

Se ci sono perchè non usarle? Comunque tu come li risolveresti allora quegli esercizi senza usare le funzioni random.uniform e random.randint?
Usando moltiplicazione, somma e differenza. ;)
P.S: questo capitolo 9 è abbastanza criptico comunque, ad esempio vengono portati gli esempi senza che le variabili vengano dichiarate e non si capisce su quali valori sta tenendo in considerazione il libro
Hum... Il fatto è che dovresti leggere e seguire i vari esempi procedendo linearmente. Il questo modo non rischi di dimenticare il contesto della discussione.
cdimauro hai già avuto modo di vedere il mio post che ti ho segnalato???
L'ho fatto, ma è abbastanza incasinato. Vediamo cosa s'inventa Ziosilvio, che è un matematico: io è da un pezzo che non mi ci cimento con quelle cose.

Comunque ci penso. Non si sa mai mi possa venire in mente qualche soluzione. :)

[~FullSyst3m~]

Usando moltiplicazione, somma e differenza. ;)

Questo era logico! Intendevo di farmi vedere il codice che scriveresti tu, cosi mi faccio un'idea

Hum... Il fatto è che dovresti leggere e seguire i vari esempi procedendo linearmente. Il questo modo non rischi di dimenticare il contesto della discussione.

Ma infatti io li seguo linearmente, li riscrivo uno per uno linearmente, appunto per questo ti dico che in questo capitolo 9 il libro è proprio criptico

L'ho fatto, ma è abbastanza incasinato. Vediamo cosa s'inventa Ziosilvio, che è un matematico: io è da un pezzo che non mi ci cimento con quelle cose.

Comunque ci penso. Non si sa mai mi possa venire in mente qualche soluzione. :)


ZioSilvio è una matematico/programmatore? Non lo sapevo. Comunque è sorprendente vedere una persona come te che ha anni e anni di esperienza e che ha scritto di tutto che è da un pezzo che non ti cimenti con queste cose "da principianti" :D

Paragrafo 9.7: "Possiamo usare un ciclo per calcolare i limiti inferiore e superiore per ciascun intervallo, usando i come indice del ciclo da 0 a NumIntervalli-1". Perchè NumIntervalli - 1? Se come numero di intervalli inserisco 8 me li calcola tutti ed 8 non me ne calcola 8 -1

[cdimauro]

E' che non ho tempo in questo periodo per andare a rispolverare quelle nozioni.

Comunque il codice preferisco non postartelo: alla soluzione dovresti arrivarci tu da solo, altrimenti se te la passo io non abbiamo concluso niente.

[~FullSyst3m~]

E' che non ho tempo in questo periodo per andare a rispolverare quelle nozioni.

Comunque il codice preferisco non postartelo: alla soluzione dovresti arrivarci tu da solo, altrimenti se te la passo io non abbiamo concluso niente.

Il fatto è che non so nemmeno come procedere visto che il libro di punto in bianco ha lasciato quegli esercizi. Te l'ho detto che sto capitolo è enigmatico

P.S: magari se al liceo avessi studiato matematica a quest'ora lo avrei saputo fare anche se il libro è enigmatico

[~FullSyst3m~]

Paragrafo 9.7: "Possiamo usare un ciclo per calcolare i limiti inferiore e superiore per ciascun intervallo, usando i come indice del ciclo da 0 a NumIntervalli-1". Perchè NumIntervalli - 1? Se come numero di intervalli inserisco 8 me li calcola tutti ed 8 non me ne calcola 8 -1

Scusate, sono un idiota. Mi rispondo solo visto che il ciclo parte da 0, e quindi l'ottavo valore è uguale ad NumIntervalli - 1 :muro:

[~FullSyst3m~]

Ho finito tutto il capitolo 9. Le tuple e ho capite, ho capito come funzionano ecc. Però non ho capito nulla riguardante il codice dei paragrafi più avanzati. Ad esempio i codici dei vari intervalli. C'è tanta matematica in quei paragrafi e io al liceo non ne ho fatta niente. Sono anche stanco visto che è da un giorno che studio, però non credo che risolvo qualcosa anche riposandomi. Il problema è che non so se posso andare avanti anche se non mi è chiara questa cosa.
Oltretutto questo codice mi stampa sempre [0,0,0,0,0,0,0,0]:

NumIntervalli = 8
Conteggio = [0] * NumIntervalli
AmpiezzaIntervallo = 1.0 / NumIntervalli
for i in range(NumIntervalli):
LimiteInferiore = i * AmpiezzaIntervallo
LimiteSuperiore = LimiteInferiore + AmpiezzaIntervallo
Conteggio[i] = NellIntervallo ([0,1,2,3,4,5,6,7], LimiteInferiore, LimiteSuperiore)
print Conteggio

[cdimauro]

Puoi passare avanti lo stesso.

Per l'altro esercizio cerca di ragionarci perché la soluzione matematica è veramente semplice.

[88MIKI88]

Piccola precisazione sulle eccezioni try / except
Esercizio: scrivi una funzione che usa InputNumero per inserire un numero da tastiera e gestisce l'eccezione ErroreNumero quando il numero non è corretto.

def InputNumero():
x = input("Dammi un numero: ")
try:
if x<=17:
print "Ok il numero dato entra nei parametri"
except:
print "Errore inserisci numeri inferiori o uguali a 17!!!"



A me entra solo nell'if e basta come mai?

[cdimauro]

Leggi bene il testo: devi USARE InputNumero, non ridefinirla. ;)

[88MIKI88]

Leggi bene il testo: devi USARE InputNumero, non ridefinirla. ;)

Oh my God....sono veramente fuso dal lavoro oggi non sono nemmeno più in grado di leggere un testo :p

A me viene in mente(al momento) una funzione che chiami subito InputNumero e poi si gestisce l'eccezione con try / except.


def Function1():
InputNumero()
try:
return 1
except:
return 0

[cdimauro]

try/except viene usata per "intrappolare" l'errore, ma se ci fai caso nel codice che hai postato non può essere sollevato alcun errore.

Mentre da una "altra" parte è presente un'istruzione per generare un errore in particolari condizioni, ed è su questa che devi focalizzare la tua attenzione.

[~FullSyst3m~]

Puoi passare avanti lo stesso.

Per l'altro esercizio cerca di ragionarci perché la soluzione matematica è veramente semplice.

Io passo avanti, però per essere un libro per principianti questo capitolo è troppo contorto e troppo matematico. Riguardo l'altro esercizio io domani ci ragiono, però non capisco nemmeno cosa vuole di preciso visto che l'esercizio è spuntato cosi senza nessun esempio o spiegazione prima

[DanieleC88]

Abituati al ritmo, di matematica all'università ne troverai a vagonate. :)

[~FullSyst3m~]

Abituati al ritmo, di matematica all'università ne troverai a vagonate. :)

Eh si lo so, infatti prima di iniziare devo andare da un prof privato a fare un ripasso. Almeno in primo anno comunque ci sono solo due esami di mate. Comunque il punto del mio discorso è che per essere un libro per principianti, almeno nel capitolo 9, gli esempi e le spiegazioni sono troppo matematiche. Considera che ci sono ragazzi che fanno programmi senza che sanno nemmeno fare 2+2 eh. Capito che voglio dire?

[cdimauro]

Io passo avanti, però per essere un libro per principianti questo capitolo è troppo contorto e troppo matematico. Riguardo l'altro esercizio io domani ci ragiono, però non capisco nemmeno cosa vuole di preciso visto che l'esercizio è spuntato cosi senza nessun esempio o spiegazione prima
Non serve una matematica eccezionale per risolvere il problema. Basta conoscere moltiplicazione, somma e sottrazione, come avevo già detto.

Questo problema lo puoi benissimo risolvere con carta e penna, nel seguente modo:

"Dato un qualunque numero compreso fra 0 e 1 (escluso) e due numeri interi A e B, fare in modo che questo numero sia trasformato in un altro che sia maggiore o uguale ad A, e minore B".

Piccolo suggerimento. Se prendiamo 0, dovremo ottenere necessariamente A. Se prendiamo 0.999999 dobbiamo necessariamente ottenere B - 1.

[~FullSyst3m~]

Non serve una matematica eccezionale per risolvere il problema. Basta conoscere moltiplicazione, somma e sottrazione, come avevo già detto.

Questo problema lo puoi benissimo risolvere con carta e penna, nel seguente modo:

"Dato un qualunque numero compreso fra 0 e 1 (escluso) e due numeri interi A e B, fare in modo che questo numero sia trasformato in un altro che sia maggiore o uguale ad A, e minore B".

Piccolo suggerimento. Se prendiamo 0, dovremo ottenere necessariamente A. Se prendiamo 0.999999 dobbiamo necessariamente ottenere B - 1.

Ho capito che non serve una matematica eccezionale, però prova a leggerlo cdimauro, non è che sia molto chiaro eh e la spiegazione che c'è prima dell'esercizio lascia a desiderare. Ora che lo hai spiegato proverò a risolverlo, ma non mi è chiara la cosa

[cdimauro]

L'ho letto il testo, altrimenti non avrei scritto nemmeno una parola sull'argomento. ;)

[DanieleC88]

[...] Almeno in primo anno comunque ci sono solo due esami di mate. [...] Considera che ci sono ragazzi che fanno programmi senza che sanno nemmeno fare 2+2 eh. Capito che voglio dire?
Ho capito che vuoi dire, ma se tu stai cercando di alzarti oltre il livello del comune lamerozzo, pensa da informatico e fatti le ossa sulla matematica appena puoi.
Ah, e ci tengo a ricordarti che con l'impegno si fa tutto, anche la matematica universitaria, ma che se ci sono "solo due esami" sono esami dove si parte con le successioni numeriche, passando per limiti, continuità, derivate, serie, etc..., fino ad integrali, serie di potenze e di Taylor, equazioni differenziali... Non è roba trascendentale, ma vedrai con che velocità faranno tutto! In due mesi di calcolo differenziale ho rivisto due anni di liceo. :asd:

[88MIKI88]

try/except viene usata per "intrappolare" l'errore, ma se ci fai caso nel codice che hai postato non può essere sollevato alcun errore.

Mentre da una "altra" parte è presente un'istruzione per generare un errore in particolari condizioni, ed è su questa che devi focalizzare la tua attenzione.

Una precisazione la funzione InputNumero deve rimanere come descritta nel libro giusto??? Al momento nn mi viene in mente nulla se non chiamare la funzione dopo il try e dopo l'except ma è una c*****a mi sa.....

[~FullSyst3m~]

Ho capito che vuoi dire, ma se tu stai cercando di alzarti oltre il livello del comune lamerozzo, pensa da informatico e fatti le ossa sulla matematica appena puoi.
Ah, e ci tengo a ricordarti che con l'impegno si fa tutto, anche la matematica universitaria, ma che se ci sono "solo due esami" sono esami dove si parte con le successioni numeriche, passando per limiti, continuità, derivate, serie, etc..., fino ad integrali, serie di potenze e di Taylor, equazioni differenziali... Non è roba trascendentale, ma vedrai con che velocità faranno tutto! In due mesi di calcolo differenziale ho rivisto due anni di liceo. :asd:

TI quoto al 101% e io (anche se non sono un lamerozzo eh!) penso da informatico e mi faccio le ossa su tutto quello che c'è bisogno e oltre, voglio sempre aumentare il mio livello, giorno dopo giorno. Infatti non vado avanti nel libro al momento, voglio capire questo capitolo prima

[DanieleC88]

(anche se non sono un lamerozzo eh!)
Infatti ho detto "se tu stai cercando di alzarti oltre il livello del comune lamerozzo"... Quelli che dici che fanno programmi senza saper fare 2+2, nel 99% dei casi lo sono. ;)

[~FullSyst3m~]

Infatti ho detto "se tu stai cercando di alzarti oltre il livello del comune lamerozzo"... Quelli che dici che fanno programmi senza saper fare 2+2, nel 99% dei casi lo sono. ;)

Tu dici? Non so... a me non mi sembrano lamerozzi (parlo di persone che conosco e con le quali ho rapporti)

[88MIKI88]

DANIELEC88 hai qualche input sul mio es.?? Io francamente ho trovato solo quella soluzione che non ha tanto senso mi sa.....

[DanieleC88]

Qual'è il problema?

[cdimauro]

Una precisazione la funzione InputNumero deve rimanere come descritta nel libro giusto??? Al momento nn mi viene in mente nulla se non chiamare la funzione dopo il try e dopo l'except ma è una c*****a mi sa.....
InputNumero numero deve stare fra il try e l'except.

[DanieleC88]

E deve sollevare un'eccezione se necessario, altrimenti il try/except non ha molto senso. :D

[~FullSyst3m~]

Non serve una matematica eccezionale per risolvere il problema. Basta conoscere moltiplicazione, somma e sottrazione, come avevo già detto.

Questo problema lo puoi benissimo risolvere con carta e penna, nel seguente modo:

"Dato un qualunque numero compreso fra 0 e 1 (escluso) e due numeri interi A e B, fare in modo che questo numero sia trasformato in un altro che sia maggiore o uguale ad A, e minore B".

Piccolo suggerimento. Se prendiamo 0, dovremo ottenere necessariamente A. Se prendiamo 0.999999 dobbiamo necessariamente ottenere B - 1.

Che ne pensi?

x = a + (numero tra 0 e 1)*(b - a)

a<= x < b

[cdimauro]

E deve sollevare un'eccezione se necessario, altrimenti il try/except non ha molto senso. :D
Infatti InputNumero ha un raise al suo interno. :)
Che ne pensi?

x = a + (numero tra 0 e 1)*(b - a)

a<= x < b
Che ci siamo finalmente. :)

Adesso però devi calcolare:
a <= x <= b
Non è difficile: basta una semplice modifica al codice. ;)

[DanieleC88]

Infatti InputNumero ha un raise al suo interno. :)
Ah, ok... Non l'avevo guardata la InputNumero(). :D

[M4rk191]

scusate il piccolo OT, ma vorrei sapere se è possibile acquistare "pensare da informatico" in italiano, fà piacere che sia gratuito, in pdf html txt etc, ma io mi stanco molto a leggere su schermo. Esiste una versione cartacea?

[grigor91]

scusate il piccolo OT, ma vorrei sapere se è possibile acquistare "pensare da informatico" in italiano, fà piacere che sia gratuito, in pdf html txt etc, ma io mi stanco molto a leggere su schermo. Esiste una versione cartacea?

Non puoi stamparlo?

[M4rk191]

saranno 200 pagine...
neanche avessi la stampante laser

[VICIUS]

saranno 200 pagine...
neanche avessi la stampante laser
Porta il file in una copisteria e vedrai che te lo stampano tranquillamente per pochi euro.

[M4rk191]

comunque sia, preferire avere un libro invece di 200fotocopie

[~FullSyst3m~]

comunque sia, preferire avere un libro invece di 200fotocopie

Il libro in italiano sono sicuro che non c'è, forse in inglese. In ogni caso porti il pdf in una copisteria te lo fanno bello sistemato

[M4rk191]

peccato, è veramente un buon libro

[88MIKI88]

InputNumero numero deve stare fra il try e l'except.

ok..quindi praticamente io chiamo input numero una volta che entro nel try giusto? Però scusa input numero ha già un raise quindi quando viene chiamato InputNumero e il numero fornito è errato verrà generato il messaggio di errore no?

[cdimauro]

Esattamente. InputNumero genera l'eccezione, e tu la "intrappoli" nel try/except.

x M4rk191: se vai in una copisteria o dove stampano tesi di laurea te ne esci col manuale versione libro. ;)

[M4rk191]

Esattamente. InputNumero genera l'eccezione, e tu la "intrappoli" nel try/except.

x M4rk191: se vai in una copisteria o dove stampano tesi di laurea te ne esci col manuale versione libro. ;)

ok, grazie per il consiglio

[88MIKI88]

Esattamente. InputNumero genera l'eccezione, e tu la "intrappoli" nel try/except.

x M4rk191: se vai in una copisteria o dove stampano tesi di laurea te ne esci col manuale versione libro. ;)

def Function1():
try:
InputNumero()
return "Ok"
except:
return "no"


E' così Cdimauro??

[cdimauro]

Sì. Complimenti. :)

x M4rk191: di nulla. ;)

[~FullSyst3m~]

Infatti InputNumero ha un raise al suo interno. :)

Che ci siamo finalmente. :)

Adesso però devi calcolare:
a <= x <= b
Non è difficile: basta una semplice modifica al codice. ;)

a <= x <= b-1. Può essere?

[cdimauro]

Quella è la strada giusta. Ci sei molto vicino. Fatti qualche conticino a mano e aggiusta l'espressione. ;)

[~FullSyst3m~]

Quella è la strada giusta. Ci sei molto vicino. Fatti qualche conticino a mano e aggiusta l'espressione. ;)

Adesso stiamo parlando dell'esercizio addizionale giusto?

[cdimauro]

Sì

[~FullSyst3m~]

Sì

limiteInf = 1
limiteSup = 6
for i in range(0, 1000):
print random.random() * (limiteSup-limiteInf) + limiteInf


import random
limiteInf = 1
limiteSup = 6
for i in range(0, 1000):
print random.random() * (limiteSup-limiteInf+1) + limiteInf

Questi sono i due esercizi, a me sembrano giusti

[cdimauro]

Bene. Passa avanti. :)

[~FullSyst3m~]

Bene. Passa avanti. :)

Niente complimenti?? No scherzo.. Comunque se non capisco le altre cose non voglio andare avanti

[cdimauro]

Se ci sono cose non alla tua portata (mi riferisco a matematica et similia) è inutile continuare a sbatterci la testa: vai avanti.

[~FullSyst3m~]

Se ci sono cose non alla tua portata (mi riferisco a matematica et similia) è inutile continuare a sbatterci la testa: vai avanti.

La matematica al momento non è proprio alla mia portata, infatti come ti ho detto devo andare a lezioni private prima dell'uni, e poi questo libro alle volte per capirlo è un casino, infatti per capire cosa voleva negli esercizi di prima.... ma non voglio lasciare. Almeno lo rileggo e provo a capire, altrimenti passo avanti dato che è matematica

[cdimauro]

Tranquillo: puoi benissimo imparare a programmare anche saltando gli esercizi che utilizzano matematica ancora non abbordabile.

Man mano che studierai la matematica miglioreranno anche le tue capacità di risolvere problemi informatici che hanno bisogno di questi concetti. ;)

[~FullSyst3m~]

Tranquillo: puoi benissimo imparare a programmare anche saltando gli esercizi che utilizzano matematica ancora non abbordabile.

Man mano che studierai la matematica miglioreranno anche le tue capacità di risolvere problemi informatici che hanno bisogno di questi concetti. ;)

L'importante che questo non comprometta l'esito della mia formazione mentale

[cdimauro]

No.

[~FullSyst3m~]

Ok

[~FullSyst3m~]

Fino al 9.7 mi è chiaro, è la spiegazione con relativo codice ed esercizio dell'ultimo paragrafo che non mi è chiara :muro:

[cdimauro]

E' l'esercizio di cui parlava anche 88MIKI88. Passa avanti.

[~FullSyst3m~]

E' l'esercizio di cui parlava anche 88MIKI88. Passa avanti.

Si si lo so, vorrei solo capirlo. Però è molto matematico...

[VICIUS]

Si si lo so, vorrei solo capirlo. Però è molto matematico...
Alla prima domanda è piuttosto semplice da rispondere. Per il secondo esercizio puoi usare il codice che c'è poco sopra. Di tuo devi aggiungere la generazione dei numeri casuali e la stampa del grafico a barre. Di matematico qui c'è veramente poco basta applicare tutto quello che ti è stato insegnato sui cicli e stringhe.

[~FullSyst3m~]

Alla prima domanda è piuttosto semplice da rispondere. Per il secondo esercizio puoi usare il codice che c'è poco sopra. Di tuo devi aggiungere la generazione dei numeri casuali e la stampa del grafico a barre. Di matematico qui c'è veramente poco basta applicare tutto quello che ti è stato insegnato sui cicli e stringhe.

A quale prima domanda ti riferisci? Comunque non mi sembra ci sia cosi poco di matematico, apparte che la spiegazione lascia un pò a desiderare e poi non spiega nemmeno come stampare il grafico a barre. Quest'ultimo paragrafo è un pò campato in aria IMHO

[VICIUS]

A quale prima domanda ti riferisci?
a questa:
Esercizio: È possibile per questo calcolo produrre un indice che sia fuori dalla gamma di numeri ammessa (negativo o più grande di len(Conteggio)-1)?

Comunque non mi sembra ci sia cosi poco di matematico, apparte che la spiegazione lascia un pò a desiderare e poi non spiega nemmeno come stampare il grafico a barre. Quest'ultimo paragrafo è un pò campato in aria IMHO
Visto che non ci sono requisiti pensa alla soluzione più semplice possibile. Qualcosa di simile a questo insomma:
4 xxxx
2 xx
7 xxxxxxx
5 xxxxx
0
2 xx

[~FullSyst3m~]

a questa:



Visto che non ci sono requisiti pensa alla soluzione più semplice possibile. Qualcosa di simile a questo insomma:
4 xxxx
2 xx
7 xxxxxxx
5 xxxxx
0
2 xx

No no quella domanda non è un problema, credo che la risposta sia che non è possibile. Almeno a prima vista. Riguardo al fatto che non ci sono requisiti, cosa intendi?

P.S: comunque applicare tutto quello che mi è stato insegnato su cicli e stringhe però bisogna pure sapere il "campo" sul quale lavorare e capire il problema. Ecco, il punto è proprio questo. Oltretutto come ho ripetuto più di una volta questo capitolo in generale, apparte la prima parte, è abbastanza confuso e criptico

[VICIUS]

No no quella domanda non è un problema, credo che la risposta sia che non è possibile. Almeno a prima vista. Riguardo al fatto che non ci sono requisiti, cosa intendi?

P.S: comunque applicare tutto quello che mi è stato insegnato su cicli e stringhe però bisogna pure sapere il "campo" sul quale lavorare e capire il problema. Ecco, il punto è proprio questo. Oltretutto come ho ripetuto più di una volta questo capitolo in generale, apparte la prima parte, è abbastanza confuso e criptico
Per requisiti intendo una serie di caratteristiche che l'esercizio deve soddisfare perché la soluzione sia corretta. Per esempio: Devo genrare io i numeri casuali? Quanti devono essere i numeri casuali? Come li devo generare? Devo creare immagini oppure posso stampare sulla console. Le barre devono essere orizzontali o verticali? Devo mostrare dei numeri accanto alle barre? Devo colorare le barre con certi tonalità?

Le domande che tu puoi porre sono tantissime e se non sai le risposte non puoi scrivere il codice. In questi casi la cosa migliore da fare è cercare sempre la soluzione più semplice che si riesce a pensare.

[~FullSyst3m~]

Per requisiti intendo una serie di caratteristiche che l'esercizio deve soddisfare perché la soluzione sia corretta. Per esempio: Devo genrare io i numeri casuali? Quanti devono essere i numeri casuali? Come li devo generare? Devo creare immagini oppure posso stampare sulla console. Le barre devono essere orizzontali o verticali? Devo mostrare dei numeri accanto alle barre? Devo colorare le barre con certi tonalità?

Le domande che tu puoi porre sono tantissime e se non sai le risposte non puoi scrivere il codice. In questi casi la cosa migliore da fare è cercare sempre la soluzione più semplice che si riesce a pensare.

Capisco, ma riguardo quell'esercizio non chiede nulla del genere. Potresti farmi vedere come lo risolveresti tu? Il punto è che come ho detto non è molto chiaro in quei paragrafi (e oltretutto quell'esercizio riguarda proprio poco le tuple, che sarebbe l'argomento del capitolo)

[VICIUS]

Capisco, ma riguardo quell'esercizio non chiede nulla del genere.
Certo il testo dell'esercizio non parla di immagini o barre colorate ma sono tutte domande legittime che ci si può fare quando come in questo caso i requisiti sono praticamente assenti. Volevo farti capire che puoi complicarti la vita quanto vuoi in questi momenti ma che devi sempre rimanere il più semplice possibile.

Potresti farmi vedere come lo risolveresti tu?
La generazione dei numeri casuali non mi deve interessare. Copio pari pari la funzione che ti è già studiato in 9.5.

Poi trasformerei il codice in 9.8 in una funzione che data la lista di numeri casuali e il numero di intervalli conta quanti numeri ci sono per ogni intervallo e ritorna questi dati in una lista.

Il vero esercizio sta nel scrivere la funzione Istogramma che riceve una lista di numeri casuali e il numero di barre da stampare. Per questo uso la lista ritornata dal codice di 9.8 per sapere quanto devono essere lunghe le barre. Alla fine si tratta di un ciclo che scorre questa lista e stampa tante righe piene di x a video.

Il punto è che come ho detto non è molto chiaro in quei paragrafi (e oltretutto quell'esercizio riguarda proprio poco le tuple, che sarebbe l'argomento del capitolo)
Le tuple sono un tipo fondamentale in python, sono un singolo strumento nella tua cassetta degli attrezzi del programmatore. È possibile creare esercizi che richiedono l'uso di un singolo strumento ma hanno poco senso perché nel mondo reale non ci saranno mai problemi di questo tipo. Questo invece ti costringe a combinare tutto quello che hai imparato.

Puoi essere un mago con il martello ed essere in grado di piantare un chiodo con un singolo colpo ma è quando sarai in grado di usarlo assieme a sega, pialla, morsa e tutto il resto che potrai ritenerti un vero falegname.

[~FullSyst3m~]

Certo il testo dell'esercizio non parla di immagini o barre colorate ma sono tutte domande legittime che ci si può fare quando come in questo caso i requisiti sono praticamente assenti. Volevo farti capire che puoi complicarti la vita quanto vuoi in questi momenti ma che devi sempre rimanere il più semplice possibile.


La generazione dei numeri casuali non mi deve interessare. Copio pari pari la funzione che ti è già studiato in 9.5.

Poi trasformerei il codice in 9.8 in una funzione che data la lista di numeri casuali e il numero di intervalli conta quanti numeri ci sono per ogni intervallo e ritorna questi dati in una lista.

Il vero esercizio sta nel scrivere la funzione Istogramma che riceve una lista di numeri casuali e il numero di barre da stampare. Per questo uso la lista ritornata dal codice di 9.8 per sapere quanto devono essere lunghe le barre. Alla fine si tratta di un ciclo che scorre questa lista e stampa tante righe piene di x a video.


Le tuple sono un tipo fondamentale in python, sono un singolo strumento nella tua cassetta degli attrezzi del programmatore. È possibile creare esercizi che richiedono l'uso di un singolo strumento ma hanno poco senso perché nel mondo reale non ci saranno mai problemi di questo tipo. Questo invece ti costringe a combinare tutto quello che hai imparato.

Puoi essere un mago con il martello ed essere in grado di piantare un chiodo con un singolo colpo ma è quando sarai in grado di usarlo assieme a sega, pialla, morsa e tutto il resto che potrai ritenerti un vero falegname.

La tua metafora non lascia dubbi, è azzeccata. Quello che sto dicendo io è che delle tuple si parla davvero poco, si parla molto di più dei numeri casuali. Oltretutto, come ho già ripetuto, gli ultimi paragrafi, almeno per me, sono abbastanza confusionari e non mi è molto chiaro cosa vogliono gli esercizi. Adesso finisco il capitolo 10 e poi guardo di nuovo il 9 seguendo quello che mi hai scritto sopra, magari faccio un pò di chiarezza ;)

[VICIUS]

Adesso finisco il capitolo 10 e poi guardo di nuovo il 9 seguendo quello che mi hai scritto sopra, magari faccio un pò di chiarezza ;)
Bene. Come ti aveva già detto cesare potevi tranquillamente passare avanti perché tanto non devi capire tutto e subito.

[~FullSyst3m~]

Bene. Come ti aveva già detto cesare potevi tranquillamente passare avanti perché tanto non devi capire tutto e subito.

Bè il punto è che l'argomento del capitolo, cioè le tuple, le ho capite. Quegli esercizi non sono esercizi che riguardano le tuple, si deve capire cosa vogliono e sono "matematici". L'importante è capire l'argomento del capitolo, anche se comunque voglio provare a capirli vista anche la tua spiegazione

[~FullSyst3m~]

Per curiosità, mi è venuta in mente una cosa. Nell'ultimissimo "esercizio" del capitolo 8 c'è messo: "descrivi la relazione tra la lista Verso e cosa ottieni da string.join(string.split(Verso)). Sono le stesse per tutte le stringhe o in qualche caso possono essere diverse?".
Che relazione vuole? Questo esercizio per me non è che abbia molto senso, quel codice prima divide una stringa e poi la riunisce. Ecco il link http://www.python.it/doc/Howtothink/Howtothink-html-it/chap08.htm

L'ultima cosa invece riguarda le matrici. Nel capitolo 10 la variabile Matrice è scritta cosi:

Matrice = [ [0,0,0,1,0],
[0,0,0,0,0],
[0,2,0,0,0],
[0,0,0,0,0],
[0,0,0,3,0] ]
Come si fa a scriverla cosi? Dovrei mettermi con la barra spaziatrice o il tab. Forse è stata scritta cosi per fare notare meglio la somiglianza con l'immagine della matrice che è poco sopra

http://www.python.it/doc/Howtothink/Howtothink-html-it/chap10.htm

[cdimauro]

Per curiosità, mi è venuta in mente una cosa. Nell'ultimissimo "esercizio" del capitolo 8 c'è messo: "descrivi la relazione tra la lista Verso e cosa ottieni da string.join(string.split(Verso)). Sono le stesse per tutte le stringhe o in qualche caso possono essere diverse?".
Che relazione vuole? Questo esercizio per me non è che abbia molto senso, quel codice prima divide una stringa e poi la riunisce. Ecco il link http://www.python.it/doc/Howtothink/Howtothink-html-it/chap08.htm
La differenza è che split SENZA PARAMETRI esegue la suddivisione prendendo come riferimento spazi e tab, per cui se poi esegui la join, viene usato soltanto lo spazio per "ricostruire" la stringa.

Quindi il risultato di una split e poi di una join può non portare alla stessa stringa originale.
L'ultima cosa invece riguarda le matrici. Nel capitolo 10 la variabile Matrice è scritta cosi:

Matrice = [ [0,0,0,1,0],
[0,0,0,0,0],
[0,2,0,0,0],
[0,0,0,0,0],
[0,0,0,3,0] ]
Come si fa a scriverla cosi? Dovrei mettermi con la barra spaziatrice o il tab. Forse è stata scritta cosi per fare notare meglio la somiglianza con l'immagine della matrice che è poco sopra

http://www.python.it/doc/Howtothink/Howtothink-html-it/chap10.htm
Sì, è proprio per quello: così visivamente è più leggibile.

[~FullSyst3m~]

La differenza è che split SENZA PARAMETRI esegue la suddivisione prendendo come riferimento spazi e tab, per cui se poi esegui la join, viene usato soltanto lo spazio per "ricostruire" la stringa.

Quindi il risultato di una split e poi di una join può non portare alla stessa stringa originale.

Ma split deve essere usata con dei parametri, altrimenti cosa divide? Nel libro esempi senza parametri non c'è nè. Fa vedere che split utilizza un qualsiasi spazio bianco come punto di interruzione e crea la lista di parole separate e join le ricostruisce

Sì, è proprio per quello: così visivamente è più leggibile.


Capito, ma a scrivere una variabile in quel modo si perde un pò troppo tempo, alla fine l'output è sempre [[liste]]

[cdimauro]

Ma split deve essere usata con dei parametri, altrimenti cosa divide? Nel libro esempi senza parametri non c'è nè. Fa vedere che split utilizza un qualsiasi spazio bianco come punto di interruzione e crea la lista di parole separate e join le ricostruisce
Veramente un esempio di split senza parametri c'è proprio all'inizio del paragrafo:

string.split(Verso)

:D
Capito, ma a scrivere una variabile in quel modo si perde un pò troppo tempo, alla fine l'output è sempre [[liste]]
Certo che l'output è quello, ma ricorda: la leggibilità è importantissima, ed è sempre preferibile un codice più leggibile, anche se bisogna spenderci un po' più di tempo per scriverlo, a uno che non lo è.

[~FullSyst3m~]

Veramente un esempio di split senza parametri c'è proprio all'inizio del paragrafo:

string.split(Verso)

:D


Scusa, ma Verso non è il parametro/argomento?

Certo che l'output è quello, ma ricorda: la leggibilità è importantissima, ed è sempre preferibile un codice più leggibile, anche se bisogna spenderci un po' più di tempo per scriverlo, a uno che non lo è.

Ne farò tesoro, grazie per il consiglio ;)

[~FullSyst3m~]

Tornando al discorso di VICIUS, dovrei incapsulare la funzione ListaCasuale nel codice (trasformato in funzione) del paragrafo 9.8 in pratica.. mhh....

[~FullSyst3m~]

Comunque ho pensato, mi serve studiare Python se poi il prossimo anno all'uni farò altri linguaggi? Mi converrebbe studiare Java o C/C++ visto che all'uni ci saranno questi?

[VICIUS]

Comunque ho pensato, mi serve studiare Python se poi il prossimo anno all'uni farò altri linguaggi? Mi converrebbe studiare Java o C/C++ visto che all'uni ci saranno questi?
Quello che stai imparando puoi usarlo tranquillamente anche con Java e C.

[~FullSyst3m~]

Quello che stai imparando puoi usarlo tranquillamente anche con Java e C.

Speriamo bene. Comunque questo codice funziona:

Precedenti = {0:1, 1:1}

def Fibonacci (n):
if Precedenti.has_key(n):
return Precedenti[n]
else:
NuovoValore = Fibonacci(n-1) + Fibonacci(n-2)
Precedenti [n] = NuovoValore
return NuovoValore

se però al posto dei due return metto due print per vedere se il programma funziona, pyscript mi dà questo errore relativo alla linea NuovoValore = Fibonacci(n-1) + Fibonacci(n-2):

exceptions.TypeError: unsupported operand type(s) for +: "None type" and "None type".

Comunque anche se il codice è semplice devo capire come funziona fibonacci altrimenti non mi è chiaro perchè inserendo come argomento 40 mi restituisce 165580141

[VICIUS]

Precedenti = {0:1, 1:1}

def Fibonacci (n):
if Precedenti.has_key(n):
return Precedenti[n]
else:
NuovoValore = Fibonacci(n-1) + Fibonacci(n-2)
Precedenti [n] = NuovoValore
return NuovoValore

se però al posto dei due return metto due print per vedere se il programma funziona, pyscript mi dà questo errore relativo alla linea NuovoValore = Fibonacci(n-1) + Fibonacci(n-2):

exceptions.TypeError: unsupported operand type(s) for +: "None type" and "None type".
Se togli i return e non ritorni alcun valore è ovvio che poi l'operatore + si lamenta quando gli dici di sommare due cose inesistenti.

Comunque anche se il codice è semplice devo capire come funziona fibonacci altrimenti non mi è chiaro perchè inserendo come argomento 40 mi restituisce 165580141
Come dice sempre cesare. Carta e penna :D
Calcola il risultato per 0, 1, 2, 3 e 4. vedrai che una volta capito come procede la successione è veramente banale.

[~FullSyst3m~]

Se togli i return e non ritorni alcun valore è ovvio che poi l'operatore + si lamenta quando gli dici di sommare due cose inesistenti.


Come dice sempre cesare. Carta e penna :D
Calcola il risultato per 0, 1, 2, 3 e 4. vedrai che una volta capito come procede la successione è veramente banale.

Grazie agli insegnamenti di cesare direi che sto usando più carta e penna che non il pc :D

Quindi anche se la somma è prima del return non viene eseguita finchè non viene ritornato un valore? E' banale la cosa lo so, però è per capire perchè togliendo anche il primo return soltanto mi dà quell'errore

[~FullSyst3m~]

Guardando il capitolo, c’è un bel grafico già bello pronto della funzione Fibonacci con tutti i frame. Il punto che non mi è chiaro è che se chiamo Fibonacci con 4 succede che Fibonacci (3) + Fibonacci (2) fa 5. E già io qua mi fermerei, invece il diagramma va avanti e chiama Fibonacci sia con 3 che con 2 e va avanti fino a quando arriva n = 0. Fibonacci in pratica si richiama n volte fin quando non arriva a 0? E il risultato come lo calcola con tutte queste iterazioni? Mi ha un po’ confuso sta cosa, perché poi alla fine aumentando i numeri c’è sempre più “casino” nel calcolo.

P.S: il paragrafo 10.6 mi sa che è un po’ obsoleto visto che ho provato a chiamare Fibonacci con 110 e me lo ha calcolato tranquillamente, forse con le nuove versioni non c’è più il problema degli interi lunghi