Semantics of ==

[Axel Boldt]

Still trying to understand "=="... It appears as if two equal objects
can become unequal if you perform the same operations on them:

l=[1]
s=l
l.append(s)
w=[1]
r=[1,w]
w.append(r)
s [1, [...]] w [1, [1, [...]]] s==w True

Note that they're equal, yet are printed differently.
s[0]=2
w[0]=2
s==w

False

All of a sudden they have become unequal.

Axel

[John Roth]

"Axel Boldt" <ax*******@yaho o.com> wrote in message
news:40******** *************** ***@posting.goo gle.com...

Still trying to understand "=="... It appears as if two equal objects
can become unequal if you perform the same operations on them:

>>> l=[1]
>>> s=l
>>> l.append(s)
>>> w=[1]
>>> r=[1,w]
>>> w.append(r)
>>> s [1, [...]] >>> w [1, [1, [...]]] >>> s==w True

Note that they're equal, yet are printed differently.
>>> s[0]=2
>>> w[0]=2
>>> s==w

False

All of a sudden they have become unequal.

Axel

You've got a recursive structure! I originally thought
that the [...] was something you'd done to the printout,
but it isn't.

I think the original True is a bug. It's getting confused
by the recursion.

John Roth

[Erik Max Francis]

Axel Boldt wrote:

Still trying to understand "=="... It appears as if two equal objects
can become unequal if you perform the same operations on them:

>>> l=[1]
>>> s=l
>>> l.append(s)
>>> w=[1]
>>> r=[1,w]
>>> w.append(r)
>>> s [1, [...]] >>> w [1, [1, [...]]] >>> s==w True
You're creating recursive lists (which is extremely rare in the real
world; I've never seen anyone create a self-referencing list in
real-life code. Tree structures and even recursive data structures are
one thing, but you're considering a very weird corner case here.
Note that they're equal, yet are printed differently.

That's fine. 1 and 1.0 are printed differently (and even are of
different types) but they're equal. If you try running through the
element-wise algorithm that Python uses to determine equality of lists,
you'll see that they are in fact equal at this point. The first element
is 1, the second element is a list whose first element is 1, the second
element of that list is a list whose first element is 1, ad infinitum.

>>> s[0]=2
>>> w[0]=2
>>> s==w False

All of a sudden they have become unequal.

Because now they really are not equal. Show them:

s [2, [...]] w [2, [1, [...]]]

The [...] doesn't indicate which sublist is recursively contained, so
you have to dig deeper:
s[1] [2, [...]] w[1][1]

[2, [1, [...]]]

So s is

[2, [2, [2, [2, ...]]]]

but w is

[2, [1, [2, [1, ...]]]]

Despite both recursing, it's clear that these lists are not element-wise
equal, and so Python is completely right in saying they're not.

Again, though, real-world creation of self-referencing lists is
extremely rare at best.

--
__ Erik Max Francis && ma*@alcyone.com && http://www.alcyone.com/max/
/ \ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
\__/ Here day fights with night.
-- (the last words of Victor Hugo)

[Erik Max Francis]

John Roth wrote:

"Axel Boldt" <ax*******@yaho o.com> wrote in message
news:40******** *************** ***@posting.goo gle.com...

Still trying to understand "=="... It appears as if two equal objects
can become unequal if you perform the same operations on them:

>>> l=[1]
>>> s=l
>>> l.append(s)
>>> w=[1]
>>> r=[1,w]
>>> w.append(r)
>>> s

[1, [...]]

>>> w

[1, [1, [...]]]

>>> s==w

True

Note that they're equal, yet are printed differently.

>>> s[0]=2
>>> w[0]=2
>>> s==w

False

All of a sudden they have become unequal.

Axel

You've got a recursive structure! I originally thought
that the [...] was something you'd done to the printout,
but it isn't.

I think the original True is a bug. It's getting confused
by the recursion.

Nah, Python's completely right here.

That the original s and w have extra finite elements doesn't make them
unequal. Follow Python's elementwise equality algorithm down and you'll
see they must be equal. The original s is

l = [1]
s = l
l.append(s)
s [1, [...]]

so it is

[1, [1, [1, [1, [1, ...]]]]]

The original w is
w = [1]
r = [1, w]
w.append(r)
w [1, [1, [...]]]

so it is also

[1, [1, [1, [1, [1, ...]]]]]

The real weirdness you reach is when the recursive sublists are not
appended, but prepended:
a = [1]
a.insert(0, a)
a

[[...], 1]

Here you could never even resolve a first element for comparison!

--
__ Erik Max Francis && ma*@alcyone.com && http://www.alcyone.com/max/
/ \ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
\__/ Here day fights with night.
-- (the last words of Victor Hugo)

[Greg Ewing (using news.cis.dfn.de)]

John Roth wrote:

>>> l=[1]
>>> s=l
>>> l.append(s)
>>> w=[1]
>>> r=[1,w]
>>> w.append(r)
>>> s [1, [...]]

>>> w

[1, [1, [...]]]

>>> s==w

True
You've created two cyclic data structures. The ==
operator happens to regard them as equal, but they're
not identical, since they have different structures.
The first one is a list which refers directly to
itself, and the second contains another list which
refers back to the first list.

>>> s[0]=2
>>> w[0]=2
>>> s==w

False
If you print out s and w at this point:

s [2, [...]] w [2, [1, [...]]]

They're now different in a way that == can see, so
it says they're not equal.
It appears as if two equal objects
can become unequal if you perform the same operations on them

Since the objects weren't really the same to begin with,
performing "the same operation" on them isn't entirely
possible.

By the way, it's not unusual for two objects that are not
identical to nevertheless compare ==, e.g.
5 == 5.0

True

even though one is an integer and the other is a float.
Generally, == means that the *value* of two objects is
"equivalent " in some sense. What sense that is depends
on the types of the objects.

The == machinery for lists happens to include some
heuristics which attempt to make sense of cyclic
structures. As you've seen, however, the results can be
a bit confusing, and mightn't be what you want in some
cases. Probably it's best to avoid applying == to cyclic
structures if you can.

--
Greg Ewing, Computer Science Dept,
University of Canterbury,
Christchurch, New Zealand
http://www.cosc.canterbury.ac.nz/~greg

[David M. Cooke]

At some point, ax*******@yahoo .com (Axel Boldt) wrote:

Still trying to understand "=="... It appears as if two equal objects
can become unequal if you perform the same operations on them:

>>> l=[1]
>>> s=l
>>> l.append(s)
You're building a cyclic list: l contains a reference to itself.
General advice: don't do that unless you know what you're doing.
>>> w=[1]
>>> r=[1,w]
>>> w.append(r)
>>> s [1, [...]] >>> w [1, [1, [...]]] >>> s==w True

Note that they're equal, yet are printed differently.

Element-by-element, they're equal, yes.

>>> s[0]=2
>>> w[0]=2
>>> s==w

False

All of a sudden they have become unequal.

That's b/c s originally looked like this if we expand out the
recursion a few more levels:
[1, [1, [1, [1, [...]]]]]
where each sub-list is also s.

w also looks like
[1, [1, [1, [1, [...]]]]]
where the *second* sub-list is w.

Set the first elements to 2:

s is now:
[2, [2, [2, [2, ...]]]]
w is now:
[2, [1, [2, [1, ...]]]]

See? The second sub-list of w is not w, so it wasn't changed.

--
|>|\/|<
/--------------------------------------------------------------------------\
|David M. Cooke
|cookedm(at)phy sics(dot)mcmast er(dot)ca

[Andrew Bennetts]

On Tue, Mar 16, 2004 at 07:07:27PM -0500, John Roth wrote:

"Axel Boldt" <ax*******@yaho o.com> wrote in message
news:40******** *************** ***@posting.goo gle.com... [...]

>>> s

[1, [...]]

>>> w

[1, [1, [...]]]

>>> s==w

True

[...]
I think the original True is a bug. It's getting confused
by the recursion.

I don't think it's a bug. In what sense are they unequal? Both variables
are a sequence of two elements, the integer 1, and a sequence that's equal
to the outer sequence (i.e. s==s[1] is True, as Python will tell you).
Every element of the sequence s is equal to the corresponding element of the
sequence w, as far as I can see, even though there is infinite recursion.

Python is behaving exactly as I would expect it to. (Although in the face
of such pathological data structures, I wouldn't mind terribly much if it
didn't...)

-Andrew.

[Terry Reedy]

"Axel Boldt" <ax*******@yaho o.com> wrote in message
news:40******** *************** ***@posting.goo gle.com...

Still trying to understand "=="...
means equal in value as defined be Python and user code
It appears as if two equal objects
can become unequal if you perform the same operations on them:

>>> l=[1]
>>> s=l
>>> l.append(s)
>>> w=[1]
>>> r=[1,w]
>>> w.append(r)
>>> s [1, [...]] >>> w [1, [1, [...]]] >>> s==w True

Note that they're equal, yet are printed differently.

This is routine:

print 0, 0.0, 0==0.0 0 0.0 1 1.0 == .99999999999999 999999999999999 9999999 1

Equal in value != equal in internal structure.
>>> s[0]=2
>>> w[0]=2
>>> s==w False

All of a sudden they have become unequal.

1 == 1.0 but type(1) != type(1.0). Okay, that's cheating, so

1|1 1 1.0|1 Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: unsupported operand type(s) for |: 'float' and 'int'

Doing same thing to equals has different results. Or
a=1234567890987 6
b=float(a)
a*a, b*b (15241578774575 7059730335376L, 1.5241578774575 706e+026)

now unequal to human eye, but
a*a == b*b

1

due to conversion of a*a to float(a*a) for comparison.

Terry J. Reedy

[Max M]

Erik Max Francis wrote:

You're creating recursive lists (which is extremely rare in the real
world; I've never seen anyone create a self-referencing list in
real-life code. Tree structures and even recursive data structures are
one thing, but you're considering a very weird corner case here.

Actually they are not that seldom. I have made several. But off course
when I got my recursive code debugged they where gone
;-)
regards Max M

[Axel Boldt]

Erik Max Francis <ma*@alcyone.co m> wrote

Axel Boldt wrote:

>>> l=[1]
>>> s=l
>>> l.append(s)
>>> w=[1]
>>> r=[1,w]
>>> w.append(r)
>>> s [1, [...]] >>> w [1, [1, [...]]] >>> s==w

True

If you try running through the
element-wise algorithm that Python uses to determine equality of lists,
you'll see that they are in fact equal at this point.

I couldn't find that algorithm in the language reference, only in 5.9:
"Tuples and lists are compared lexicographical ly using comparison of
corresponding elements. This means that to compare equal, each element
must compare equal and the two sequences must be of the same type and
have the same length."

That definition doesn't seem to fully specify equality of list values:
to determine whether s==w, I first note that they both have length 2
and both have 1 as their first element, the second element of s is a
pointer to s, the second element of w is a two-element list, with
first element 1 and second element a pointer to w. So now I have to
determine whether s is equal to the two element list with first
element 1 and second element a pointer to w. They both have two
elements, they both share the first element 1, the second element of s
is a pointer to s, the second element of the other list is a pointer
to w. Now I'm back where I started: I have to test whether s==w. So
the definition in the language reference is circular and both
conclusions s==w and s!=w are consistent with it. I hope that the
actual result received, i.e. s==w, is not implementation dependent?

It now appears to me that there are four levels of equality in Python:

a is b => pickle.dumps(a) ==pickle.dumps( b) => repr(a)==repr(b ) => a==b

and none of the arrows can be reversed in general. I suppose I had
naively assumed the last three to be equivalent. Is there a string
function analogous to pickle.dumps or repr which only takes values
into account, not internal structure? Such a function could be useful
for hashing the values of mutables.

Axel