Hi all, I've been playing around with the identity function id() for different types of objects, and I think I understand its behaviour when it comes to objects like lists and tuples in which case an assignment r2 = r1 (r1 refers to an existing object) creates an alias r2 that refers to the same object as r1. In this case id(r1) == id(r2) (or, if you like: r1 is r2). However for r1, r2 assigned as follows: r1 = [1, 2, 3] and r2 = [1, 2, 3], (r1 is r2) is False, even if r1==r2, etc. ...this is all very well. Therefore, it seems that id(r) can be interpreted as the address of the object that 'r' refers to.
My observations of its behaviour when comparing ints, floats and strings have raised some questions in my mind, though. Consider the following examples: ######################################################################### # (1) turns out to be true a = 10 b = 10 print a is b # (2) turns out to be false f = 10.0 g = 10.0 print f is g # behaviour when a list or tuple contains the same elements ("same" meaning same type and value): # define the following function, that checks if all the elements in an iterable object are equal: def areAllElementsEqual(iterable): return reduce(lambda x, y: x == y and x, iterable) != False # (3) checking if ids of all list elements are the same for different cases: a = 3*[1]; areAllElementsEqual([id(i) for i in a]) # True b = [1, 1, 1]; areAllElementsEqual([id(i) for i in b]) # True f = 3*[1.0]; areAllElementsEqual([id(i) for i in f]) # True g = [1.0, 1.0, 1.0]; areAllElementsEqual([id(i) for i in g]) # True g1 = [1.0, 1.0, 0.5+0.5]; areAllElementsEqual([id(i) for i in g1]) # False # (4) two equal floats defined inside a function body behave differently than case (1): def func(): f = 10.0 g = 10.0 return f is g print func() # True ###################################################### I didn't mention any examples with strings; they behaved like ints with respect to their id properties for all the cases I tried. While I have no particular qualms about the behaviour, I have the following questions: 1) Which of the above behaviours are reliable? For example, does a1 = a2 for ints and strings always imply that a1 is a2? 2) From the programmer's perspective, are ids of ints, floats and string of any practical significance at all (since these types are immutable)? 3) Does the behaviour of ids for lists and tuples of the same element (of type int, string and sometimes even float), imply that the tuple a = (1,) takes (nearly) the same storage space as a = 10000*(1,)? (What about a list, where elements can be changed at will?) Would appreciate your responses... AK -- http://mail.python.org/mailman/listinfo/python-list