iniziare con python

[^TiGeRShArK^]

Originariamente inviato da marco.r

Nel caso di foo, il risultato delle tre chiamate a foo e' la stampa di [1],[2] e [3].
Nel caso di foo2, y viene inizializzata una unica volta nel corso della prima chiamata, e il valore permane. Quindi foo2 ha il risultato di stampare rispettivamente [1],[1,2] e [1,2,3]. Non so se in questo caso abbia senso parlare di variabile temporanea

Qua onestamente mi sfugge come fai a chiamare un metodo che accetta due parametri passandogliene solo 1
Spero che non sia davvero possibile fare una cosa del genere in python perchè altrimenti non mi spiego proprio come faccia l'interprete a scegliere quale signature della funzione utilizzare quando si lancia una funzione

[Th3 Kn0wl3dg3]

Qua onestamente mi sfugge come fai a chiamare un metodo che accetta due parametri passandogliene solo 1
Spero che non sia davvero possibile fare una cosa del genere in python perchè altrimenti non mi spiego proprio come faccia l'interprete a scegliere quale signature della funzione utilizzare quando si lancia una funzione

???????

Allora mi sfugge proprio il significato di quell'esempio che restituisce 0.0

sfugge anche a me

Una variabile temporanea può essere ad esempio:

private void something(String a) {
   String b = a;
   // do something
   String b = null;
   //do anything else
}

quindi x me b è una variabile locale temporanea perchè non esiste per tutta il ciclo di vita del metodo ma viene posta a null ad un certo punto (Ad esempio può essere una grossa cache che necessita di essere ripulita dal garbage collector perchè ad un certo punto diventa obsoleta).
La variabile a invece è una variabile locale, il che implica che è valida solo fintanto che ci si trova all'interno di quel metodo.
Estendendo un pò questo concetto si può dire che:

int a = 1;
int b = 2;
int temp = a;
a = b;
b = temp;

temp ad esempio si può considerare una variabile temporanea dato che, all'interno di un contesto maggiore, essa è utile solo per un periodo limitato di tempo, terminato il quale può essere tranquillamente eliminata avendo concluso la sua funzione, ovvero quando il suo valore è stato assergnato a b.
Ma cmq io potrei anche avere variabili globali temporanee, xkè il concetto di "località" di una variabile e di "temporaneità" sono proprio due cose diverse.
Nel caso di cui sopra quella imho era un variabile locale.
Spero di aver spiegato il mio concetto di "temporaneità"

scusa, ma mi sono confuso solo di più.poi mi dite come dovrei fare ad essere ottimista se ancora a 19anni non capisco queste cose?e poi vorrei diventare chissà chi...sono sempre più convinto di essere un illuso....

[marco.r]

Originariamente inviato da ^TiGeRShArK^

E' implicito nella definizione di variabile locale il fatto che sia temporanea all'interno della funzione.

Basta che ti decidi , prima hai detto una cosa un po' diversa:

non sono variabili temporanee.
Sono variabili locali della funzione.

Al che io ho specificato che sono due cose distinte e possibili contemporaneamente.
Anche se probabilmente abbiamo due idee diverse sul significato di "variabile temporanea"

[marco.r]

Originariamente inviato da ^TiGeRShArK^

Qua onestamente mi sfugge come fai a chiamare un metodo che accetta due parametri passandogliene solo 1
Spero che non sia davvero possibile fare una cosa del genere in python perchè altrimenti non mi spiego proprio come faccia l'interprete a scegliere quale signature della funzione utilizzare quando si lancia una funzione

Scusa, ho fatto le cose un po' di corsa
nella definizione di foo2:

def foo2(x,y=[]):
  y.append(x)
  print y

Il parametro y ha un valore di default, che viene utilizzato se non ne specifico altri.
Ad esempio foo2(5) equivale a foo2(5,[]), in quanto nella definizione di funzione ho scritto y=[]. Nulla mi vieta ovviamente di specificare esplicitamente il secondo parametro, ad esempio foo2(1,['x']).
La cosa da fare attenzione e' che il valore di default viene calcolato solo all'inizio e non ad ogni chiamata. Quindi quando scrivo

foo2(1)
foo2(2)

alla prima chiamata y ha valore [], mentre alla seconda ha valore [1], ovvero il valore che aveva y alla fine della chiamata precedente. In pratica passo informazioni da una chiamata di funzione alla successiva, ed era il mio esempio di variabile locale, ma non temporanea.

In ogni caso l'inteprete non deve scegliere assolutamente la signature della funzione da utilizzare: in python non esiste l'overloading delle funzioni. Se definisco due funzioni con lo stesso nome (anche se con signature differente) la prima "sparisce" e rimane valida solo la seconda.
Se scrivo

def f(x):
  return x

def f(x,y):
  return x+y

f(1)

l'interprete mi ritorna un errore in quanto quando chiamo f(1) l'unica definizione valida di f e' la seconda.

[marco.r]

Originariamente inviato da Th3 Kn0wl3dg3

oggi mi sono bloccato di nuovo.ecco dove:
PARAGRAFO 5.2

def DistanzaTraDuePunti(x1, y1, x2, y2):
  dx = x2 - x1
  dy = y2 - y1
  DistQuadrata = dx**2 + dy**2
  print "DistQuadrata vale ", DistQuadrata
  return 0.0

perchè deve restituire 0.0 alla fine?

Infatti secondo me non dovrebbe.
O l'autore decide che deve tornare la distanza (oltre che stamparlo) e allora l'ultima riga dovrebbe essere return DistQuadrata (o meglio ancora la sua radice, ma questo e' un altro discorso), oppure stabilisce che invece che una funzione e' una procedura, e il risultato viene solo stampato; in quest'ultimo caso il return proprio non ci dovrebbe essere.

[Th3 Kn0wl3dg3]

def DistanzaTraDuePunti(x1, y1, x2, y2):
  dx = x2 - x1
  dy = y2 - y1
  DistQuadrata = dx**2 + dy**2
  print "DistQuadrata vale ", DistQuadrata
  return 0.0

perchè deve restituire 0.0 alla fine?

Infatti secondo me non dovrebbe.
O l'autore decide che deve tornare la distanza (oltre che stamparlo) e allora l'ultima riga dovrebbe essere return DistQuadrata (o meglio ancora la sua radice, ma questo e' un altro discorso), oppure stabilisce che invece che una funzione e' una procedura, e il risultato viene solo stampato; in quest'ultimo caso il return proprio non ci dovrebbe essere.

io credo che non dovrebbe restituirlo in nessun cas.forse c'è stato un errore nella traduzione della guida?come il \linebreak di qualche paragrafo fa che non c'entrava niente e nella guida originale non c'era

[Th3 Kn0wl3dg3]

voi che dite?

[Th3 Kn0wl3dg3]

up

[Th3 Kn0wl3dg3]

up

[Th3 Kn0wl3dg3]

up

[Th3 Kn0wl3dg3]

up

[Th3 Kn0wl3dg3]

e non ho capito nemmeno l'esempio di foo

[Th3 Kn0wl3dg3]

up

[marco.r]

Originariamente inviato da Th3 Kn0wl3dg3

e non ho capito nemmeno l'esempio di foo

Non preoccuparti troppo, e' un caso abbastanza particolare che avevo usato per mostrare come in un caso (il primo) ad ogni chiamata y viene inizializzato a lla lista vuota, mentre nel secondo le modifiche alla lista vengono conservate tra una chiamata e l'altra.

def foo(x,y):
  y = []
  y.append(x)
  print y

def foo2(x,y=[]):
  y.append(x)
  print y

[Th3 Kn0wl3dg3]

[Th3 Kn0wl3dg3]

leggendo documenti su documenti credo che invece che python mi convenga iniziare da C o meglio ancora da java...voi che dite?

[wisher]

Originariamente inviato da Th3 Kn0wl3dg3

Che problema c'è?
Quando uppi, quota il tuo problema, almeno è più semplice rispondere

[wisher]

Originariamente inviato da Th3 Kn0wl3dg3

leggendo documenti su documenti credo che invece che python mi convenga iniziare da C o meglio ancora da java...voi che dite?

Dato che hai iniziato con python ti consiglio di continuare, è un ottimo linguaggio.

[marco.r]

Originariamente inviato da Th3 Kn0wl3dg3

Allora mi sono accorto che l'ultimo codice che ho postato non e' corretto, lo riscrivo qui per chiarezza, togliendo il secondo argomento a foo:

def foo(x):
  y = []
  y.append(x)
  print y

def foo2(x,y=[]):
  y.append(x)
  print y

In foo, la lista vuota [] viene associata ad y ad ogni chiamata
per cui se io scrivo

foo(1,1)
foo(2,2)
foo(3,3)

Ogni volta y riparte da [], per cui dopo che con y.append(x) ho aggiunto un elemento alla lista, ottengo sempre una lista di un elemento ( rispettivamente [1], [2] e [3] )
Con foo2 invece, y viene inizializzato ogni volta con la stessa lista, che pero' nel frattempo cresce.
Con

foo2(1)
foo2(2)
foo2(3)

La prima volta che chiamo foo2, y viene inizializzato con la lista vuota [], a prescindere da qualsiasi valore io abbia passato come secondo argomento. A questa lista viene aggiunto l'elemento 1, e quindi la lista diventa [1]. Alla seconda chiamata, ad y viene associata la stessa lista di prima, [1], a cui viene aggiunto il valore 2, rendendola di due elementi, [1,2]. Similmente alla terza chiamata la lista e' [1,2] e diventa [1,2,3].
come dicevo sopra non crucciarti piu' di tanto per questo esempio, e' uno dei rari casi in cui python un po' strano.

[marco.r]

Originariamente inviato da Th3 Kn0wl3dg3

io credo che non dovrebbe restituirlo in nessun cas.forse c'è stato un errore nella traduzione della guida?come il \linebreak di qualche paragrafo fa che non c'entrava niente e nella guida originale non c'era

Potrebbe essere. Non avendo sottomano l'originale, e' difficile dire se l'autore voleva o meno ritornare il valore. Di sicuro non voleva tornare 0.0 (o perlomeno spero ).