Objeto miembro de una lista.

[Instru]

Buen día a todos.

Tengo un problema con un código en python 3.
Me explico.

Tengo una clase:

Código:

class LRItem(object):

    def __init__(self):
        self.rule = None
        self.dot = 0
        self.lookAhead = ''

    def __eq__(self, other):
        return self.__dict__ == other.__dict__

    def show(self):
        if self.rule is None:
            print("Empty LR(1) item")
        text = self.rule.leftHand.text
        text += " -> "
        for tokens in self.rule.rightHands[:self.dot]:
            text += ' ' + tokens.text
        text += ' .'
        for tokens in self.rule.rightHands[self.dot:]:
            text += ' ' + tokens.text

        text += ' ||' + self.lookAhead
        print(text)

Como se puede observar, uso __eq__ para hacer comparaciones de igualdad. No se que tan correcto sea esto.

Dentro de una función tengo una lista donde voy agregando objetos de la clase especificada.
El problema es que llega un momento en que hago lo siguiente:

Código:

itemsList = []
.
.
for la in lookAheads:
    newItem.lookAhead = la
    if newItem not in itemsList:
        itemsList.append(newItem)
.
.

lookAheads es una lista de strings.
Por cada objeto string en la lista cambio mi objeto tipo LRItem, es decir, newItem.
Después intento agregar ese nuevo item a mi lista de objetos.

Lo curioso es que aunque noItem.lookAhead contenga un valor diferente, ya no me agrega el nuevo item a la lista. Parece ser que la condución

Código:

newItem not in itemsList:

falla de alguna manera.

Alguien me podría explicar que sucede? O que estor haciendo mal?
Por que el operador in no esta dando el resultado correcto??

Saludos

[carbon]

Si en itemsList tenés instancias de LRItem, no debería ser:

Código Python:

if newItem.lookAhead not in itemsList:
 

Ademas, que tendria que ver __eq__ en todo esto?

[Instru]

Iniciado por carbon

Si en itemsList tenés instancias de LRItem, no debería ser:

Código Python:

if newItem.lookAhead not in itemsList:
 

Ademas, que tendria que ver __eq__ en todo esto?

Perdón. No comprendí tu respuesta.

itemList es una lista de instancias de LRItem.
newItem.lookAhead es solo un string.

No comprendo cual es el punto de:

Código:

if newItem.lookAhead not in itemsList:

Saludos

[CalgaryCorpus]

Creo que estas reciclando el mismo objeto,

Que tal cambiar a:

Código Python:

for la in lookAheads:
    newItem = LRItem()    # un objeto nuevo cada vez?
    newItem.lookAhead = la
 

[Instru]

Iniciado por CalgaryCorpus

Creo que estas reciclando el mismo objeto,

Que tal cambiar a:

Código Python:

for la in lookAheads:
    newItem = LRItem()    # un objeto nuevo cada vez?
    newItem.lookAhead = la
 

Si. al parecer esa es la explicación.

No lo puse dentro del código. Lo que pasa es que busco que los demás campos sean los mismos. Solo cambio el lookAhead.
Supongo que tendre que hacer un nuevo objeto y copiar todos los campos.

No se si sea la manera más elegante..

Por cierto carbon, no soy un experto, pero pensé que el operador in usaba el __eq__ para buscar dentro de la lista. Corrigeme si estoy equivocado.

Saludos

[carbon]

Claramente yo tampoco, me equivoqué yo, disculpa!

[razpeitia]

Bueno chavo, por favor trata de darnos un código que podamos correr porque esta difícil andar adivinando de donde sale looksAhead, newItem u otras variables que vayan saliendo.

Si estas reusando el objeto newItem, obviamente vas a tener problemas porque, tu objeto es mutable y ademas siempre es una referencia al mismo objeto.

Asumi que estabas haciendo esto

Código Python:

class LRItem(object):
 
    def __init__(self):
        self.rule = None
        self.dot = 0
        self.lookAhead = ''
 
    def __eq__(self, other):
        return self.__dict__ == other.__dict__
 
    def __str__(self):
        return self.lookAhead
 
    def __repr__(self):
        return '"%s"' % self.__str__()
 
 
lookAheads = ['a', 'b', 'c', 'd', 'a', 'd', 'c']
itemsList = []
newItem = LRItem()
for la in lookAheads:
    newItem.lookAhead = la
    if newItem not in itemsList:
        itemsList.append(newItem)
print(itemsList)
 

Cuando tu querias:

Código Python:

class LRItem(object):
 
    def __init__(self):
        self.rule = None
        self.dot = 0
        self.lookAhead = ''
 
    def __eq__(self, other):
        return self.__dict__ == other.__dict__
 
    def __str__(self):
        return self.lookAhead
 
    def __repr__(self):
        return '"%s"' % self.__str__()
 
 
lookAheads = ['a', 'b', 'c', 'd', 'a', 'd', 'c']
itemsList = []
for la in lookAheads:
    newItem = LRItem()
    newItem.lookAhead = la
    if newItem not in itemsList:
        itemsList.append(newItem)
print(itemsList)
 

Para la construcción de una clase sencilla como la que tienes al menos deberías de plantearte los siguientes puntos: ¿Es mutable o inmutable el objeto? Definir algún tipo de ID o ID compuesto (Que atributos harán a este objeto único). Saber al menos de referencias a objetos. Trata de trabajar con métodos como __str__ en lugar de métodos como show.

[Instru]

Hola razpeitia. Gracias por tu respuesta.

Tienes razón, no puse el suficiente código.

Lo que pasa, es que es un poco mas complicado.

Aunque lo qu tu pusiste es un buen reusmen de lo que necesito hacer:

Código:

for nt in grammar:
            if nt.leftHand == currentNT:
                newItem = LRItem()
                newItem.rule = nt
                newItem.dot = 0
                newItem.lookAhead = lrItem.lookAhead
                newItem.show()
                lookAheads = getLookAheads(grammar, newItem)
               
                for la in lookAheads:
                    newItem.lookAhead = la

                    if newItem not in itemsList:
                        itemsList.append(newItem)

Sin embargo, sustituyendo newItem.lookAhead = la por:

Código:

 tempItem = LRItem()
                    tempItem.rule = newItem.rule
                    tempItem.dot = newItem.dot
                    tempItem.lookAhead = la

funciona de manera correcta.

Todavía me confunde la manera en que python maneja algunas cosas, como el caso de los objetos mutables y no mutables.
Me surge una duda aqui.

Si tengo 2 objetos que fueron creados, pero con el mismo contenido. ¿Cómo los toma el operador in?

Código:

class Foo(object):
    def __init__(self):
        self.data=0

objA = Foo()
objA.data = 1

objB = Foo()
objB.data = 1

mylist = [objA]

Como se evaluaría

Código:

objB in mylist

Supongo que daría falso porque son objetos diferentes apesar de que el contenido es el mismo.

Alguien que me despeje esta duda?
Como lo haría para que esa condicion evalue verdadero?

SAludos

[razpeitia]

Efectivamente evaluaría falso el código que pusiste. Y es que por default checa con el operador is.

Código Python:

class Foo(object):
    def __init__(self):
        self.data=0
    def __eq__(self, other):
        if self is other:
            return True
        else:
            return self.data == data
 
objA = Foo()
objA.data = 1
 
objB = Foo()
objB.data = 1
 
mylist = [objA]
 

Puede ser que tu objeto tenga algun tipo de id, entonces solo necesitarías checar el id. Porque tal vez los otros campos son irrelevantes para determinar la igualdad. Pero eso lo defines tu.