[Python] Errore dal passato...

[Heretic Curse]

Prima ho deciso di mettere i vecchi codici scritti per esercizio in una cartella. Siccome uno l'avevo cancellato ma l'avevo pure postato qui sul forum, anche se ancora incorretto, sono venuto a prenderlo e l'ho corretto e reso funzionante. Ho però notato una cosa (non lo riposto tutto, solo la parte interessata):

class Mazzo:
[...]
def Mescola(self):
   NumCarte = len(self.Carte)
   for i in range(NumCarte):
    j = random.randrange(i, NumCarte)
    x = j
    self.Carte[j] = self.Carte[i]
    self.Carte[i] = self.Carte[x]

class ManoOldMaid(Mano):

  def RimuoveCoppie(self):
    Conteggio = 0
    CarteOriginali = self.Carte[:]
    for CartaOrig in CarteOriginali:
      CartaDaCercare = Carta(3-CartaOrig.Seme, CartaOrig.Rango)
      if CartaDaCercare in self.Carte:
        self.Carte.remove(CartaOrig)
        self.Carte.remove(CartaDaCercare)
        print "Mano di %s : %s elimina %s" % (self.Nome, CartaOrig, CartaDaCercare)
        Conteggio = Conteggio + 1
    return Conteggio

Tralasciando tutto il resto delle funzioni, che sennò il codice non finisce più, sappiate che l'errore che mi restituisce è ValueError: list.remove(x): x not in list. Spero possiate già da solo ciò che vi ho postato riuscire a spiegarmi il perché non vada, o al limite se riuscite a dirmi quando appare solitamente quel ValueError magari riesco a capirlo da me

In ogni caso, se sostituisco:

x = j
    self.Carte[j] = self.Carte[i]
    self.Carte[i] = self.Carte[x]

con:

self.Carte[i], self.Carte[j] = self.Carte[j], self.Carte[i]

funziona tutto perfettamente.

[banryu79]

Non sono un Pythonista, ma non poso fare a meno di notare che la logica espressa nella prima versione del codice che "mescola" le carte è decisamente bacata, perchè se ci pensi bene (simulando con carta e penna un'esecuzione di quel metodo su una ipotetica lista di carte) vedrai che ti sovvrascrive molte carte e alla fine ti ritrovi con un mazzo con tante carte uguali tra loro (!).

Ecco perchè quando vai a fare il remove dalle carte del mazzo può facilmente succedere che una data CartaDaCercare non ci sia più (!) come invece tu ti aspetteresti.

La seconda versione del codice che "mescola" le carte è corretta perchè non sovvrascrive la carta all'indice j con la carta all'indice i come la precedente versione, ma le scambia.

Comunque fai presto a verificare: dato un metodo che ti stampa la lista di carte del mazzo, invocalo prima e dopo aver chiamato il metodo che mescola il mazzo e verifica l'output prodotto.

[Heretic Curse]

Ok aspetta, mi sa che hai centrato il problema, tuttavia non riesco a capire come mai le due scritture non si equivalgano. In particolare non ho ben capito perché la prima non scambia le carte, ne' cosa faccia in realtà. (io scrivendola mi aspettavo le scambiasse )

[cdimauro]

Non si equivalgono perché il principio su cui si basa l'algoritmo di scambio prevede l'uso di una variabile temporanea in cui si deve memorizzare temporaneamente uno dei due VALORI da scambiare, per poi recuperarlo alla fine e memorizzarlo nell'altro "posto" (variabile, posizione in un array, o altro; storage insomma).

Nel primo caso tu avresti dovuto memorizzare in x (che è la variabile temporanea in oggetto) il valore di self.Carte[j], eseguire la seconda istruzione, e nella terza memorizzare in self.Carte[i] il valore che avevi conservato in x.

La seconda versione è quella Pythonica, che non necessita di una variabile temporanea creata apposta, ma che sfrutta un'utile strumento sintattico di Python la costruzione di una tupla (a destra) e il suo "spacchettamento" (a sinistra), ma il principio è sostanzialmente lo stesso.

Quando hai difficoltà di questo tipo ti consiglio di far ricorso alla classica carta e penna, in cui "visualizzi" lo stato del tuo sistema, un passo alla volta.

In alternativa, visto che usi Python, usa la shell interattiva e fai qualche prova manualmente. Il bello di Python è anche e soprattutto questo: puoi provare velocemente spezzoni di codice, senza doverli conservari su file e poi lanciarli.

[Heretic Curse]

Originariamente inviato da cdimauro

Non si equivalgono perché il principio su cui si basa l'algoritmo di scambio prevede l'uso di una variabile temporanea in cui si deve memorizzare temporaneamente uno dei due VALORI da scambiare, per poi recuperarlo alla fine e memorizzarlo nell'altro "posto" (variabile, posizione in un array, o altro; storage insomma).

Nel primo caso tu avresti dovuto memorizzare in x (che è la variabile temporanea in oggetto) il valore di self.Carte[j], eseguire la seconda istruzione, e nella terza memorizzare in self.Carte[i] il valore che avevi conservato in x.

La seconda versione è quella Pythonica, che non necessita di una variabile temporanea creata apposta, ma che sfrutta un'utile strumento sintattico di Python la costruzione di una tupla (a destra) e il suo "spacchettamento" (a sinistra), ma il principio è sostanzialmente lo stesso.

Quando hai difficoltà di questo tipo ti consiglio di far ricorso alla classica carta e penna, in cui "visualizzi" lo stato del tuo sistema, un passo alla volta.

In alternativa, visto che usi Python, usa la shell interattiva e fai qualche prova manualmente. Il bello di Python è anche e soprattutto questo: puoi provare velocemente spezzoni di codice, senza doverli conservari su file e poi lanciarli.

Grazie mille Tuttavia non ho ben capito, da un punto di vista logico, il perché non possa funzionare nel primo caso. E' un semplice "deve essere così" (cosa che reputo alquanto strana nella programmazione), o c'è un motivo? Se me l'hai già scritto perdonami, ma non l'ho aferrato.
In realtà avevo fatto delle prove, solo che avevo scritto questo

j = 0
i = 1
x = j
j = i
i = x
print i, j

Ed ovviamente funzionava! Ero stra convinto che il fatto che fossero indice di una lista non fosse in alcun modo influente

[banryu79]

Devi esaminare il codice "che non funziona" per capire perchè non funziona, non quello che funziona...
L'errore è qua:

def Mescola(self):
   NumCarte = len(self.Carte)
   for i in range(NumCarte):
    j = random.randrange(i, NumCarte)
    x = j
    self.Carte[j] = self.Carte[i]
    self.Carte[i] = self.Carte[x]

Se imposti il vaore di 'x' uguale al valore di 'j' allora puoi sostituire le occorrenze di 'x con 'j' (e viceversa), tanto hanno lo stesso valore. Cioè dire 'j' e dire 'x' è la stessa cosa.
Prova a farlo nelle due righe in grassetto, dopo la sostituzione viene fuori che:

self.Carte[j] = self.Carte[i]
self.Carte[i] = self.Carte[j]

Et voilà.
Prima riga: sovvrascrivi la 'jesima' carta del mazzo con la 'iesima', ora ti ritrovi con due carte identiche nel mazzo; la carta originariamente presente all'indice 'j' è persa per sempre (all'inizio nel mazzo hai carte distinte, cioè ogni carta è unica). Questo è il bug.
La seconda riga: potrebbe anche non esserci dato che sovvrascrivi la 'iesima' carta con la 'jesima' ovvero con la stessa...

Forse volevi fare:

def Mescola(self):
   NumCarte = len(self.Carte)
   for i in range(NumCarte):
    j = random.randrange(i, NumCarte)
    CartaTmp = self.Carte[j]
    self.Carte[j] = self.Carte[i]
    self.Carte[i] = CartaTmp

[Heretic Curse]

Ah ok, ora ho capito! In pratica in un caso simile non è come se attribuissi ad x un certo valore per poi effettuare lo scambio, è proprio come se x e j fossero la stessa identica cosa, ovvero puntano allo stesso oggetto, e questo genera l'incongruenze seguente

Grazie mille a tutti

[banryu79]

Originariamente inviato da Heretic Curse

Ah ok, ora ho capito! In pratica in un caso simile non è come se attribuissi ad x un certo valore per poi effettuare lo scambio, è proprio come se x e j fossero la stessa identica cosa, ovvero puntano allo stesso oggetto, e questo genera l'incongruenze seguente

Grazie mille a tutti

Ancora non ci sei: il problema è che 'j' e 'x' nel contesto della tua funzione NON sono una Carta ma sono un Intero... Intero che poi usi come indice per recuperare (e assegnare) le singole Carte nell'array/lista di carte del mazzo.

Mi raccomando, non fare confusione, esamina con calma ogni singola istruzione e cerca di capirla bene altrimenti non ne verrai fuori.

[Heretic Curse]

Ok, adesso ho capito davvero,
Infatti ero tornato qui per scrivere che c'era ancora qualcosa che non mi tornava, ma fortunatamente avevi già risposto.
Devo smetterla di inventarmi delle soluzioni e cominciare a cercare quelle giuste.

Comunque, facendo finta di essere al punto del ciclo i=1, j =2 è come se avessi scritto (in quello errato):

self.Carte[2] = self.Carte[1]
self.Carte[1] = self.Carte[2]

il che, ora che ce l'ho bene davanti agli occhi, è palesemente sbagliato. Ed effettivamente me l'avevi già scritto.

[banryu79]

Originariamente inviato da Heretic Curse

Ed effettivamente me l'avevi già scritto.

Sì, ma anche Cesare te l'aveva già scritto, e in modo più esplicito di come avevo fatto io nel mio primo post in questo thread.

Quoto:

Originariamente inviato da cdimauro

Non si equivalgono perché il principio su cui si basa l'algoritmo di scambio prevede l'uso di una variabile temporanea in cui si deve memorizzare temporaneamente uno dei due VALORI da scambiare, per poi recuperarlo alla fine e memorizzarlo nell'altro "posto" (variabile, posizione in un array, o altro; storage insomma).

Nel primo caso tu avresti dovuto memorizzare in x (che è la variabile temporanea in oggetto) il valore di self.Carte[j], eseguire la seconda istruzione, e nella terza memorizzare in self.Carte[i] il valore che avevi conservato in x.

Cioè qui ti stava proprio dicendo di fare:

x = self.Carte[j]

La dove tu invece facevi:

x = j

Sono due cose completamente diverse, è cristallino.
L'importante è che tu abbia capito ma soprattutto che tu abbia imparato una lezione da questa vicenda: occhio ai tipi, specialmente perchè in un linguaggio come Python non sei costretto da un sitema di static typing (e assenza di meccanismi di l'inferenza dei tipi) a ripeterli/dichiarli millemila volte nel codice

[Heretic Curse]

Già, in effetti era chiaro, ma per qualche motivo non avevo ben capito. Scusate se vi ho fatto ripetere la stessa cosa 3 volte