id functions of ints, floats and strings

[zillow10 at googlemail.com]

On Apr 3, 11:27 pm, zillo... at googlemail.com wrote:
> 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

Question 1 should read "For example, does a1 == a2 for ints ..."