[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Explanation of list reference

On Sat, 15 Feb 2014 18:29:59 +0200, Marko Rauhamaa wrote:

> Steven D'Aprano <steve+comp.lang.python at pearwood.info>:
>> On Sat, 15 Feb 2014 14:07:35 +0200, Marko Rauhamaa wrote:
>>> Steven D'Aprano <steve+comp.lang.python at pearwood.info>:
>>>> On Sat, 15 Feb 2014 12:13:54 +0200, Marko Rauhamaa wrote:
>>>>>    5. id(x) == id(y) iff x is y
>>>> # Counter-example
>>>> py> x = 230000
>>>> py> idx = id(x)
>>>> py> del x
>>>> py> y = 420000
>>>> py> idy = id(y)
>>>> py> idx == idy
>>>> True
>>> I don't accept that as a counterexample.
>> Why?
> Nowhere do I see the violating "x is y".

Do you truly think that there is even the tiniest, most microscopic 
chance that the int 230000 which has been garbage-collected and no longer 
exists, and the int 420000, are the same object?

>> All I need to do is show a case where two distinct objects have the
>> same ID.
> How do you know objects are "distinct"? Myself, I would use the "is"
> test.

I know objects are distinct if they are objects with different values, 
such as 230000 and 420000, due to the fundamental fact that ints cannot 
have the value 230000 and 420000 at the same time. I leverage my 
knowledge that ints are intended to model the mathematical integers, and 
while that model is not perfect, it is not so bad as to have 230000 and 
420000 be the same number.

I also know that objects are distinct if one of them has been garbage 
collected, on the account of it no longer existing.

>>> That's the point. I don't think id() and "is" have any abstract
>>> meaning on top of the formal axioms.
>> Who is talking about "abstract meaning"?
> I am. I mean, "implementation-independent".

"Abstract meaning" does not mean "implementation independent". The 
definition of identity given in the documentation is both implementation 
independent and concrete: identity is tied concretely to the creation of 
the object, while still leaving implementations free to choose exactly 
how they tie identity to creation.

>> Object identity is simple and well-defined in Python. I don't know why
>> you are so resistant to this. Read the documentation.
> It is not defined at all:
>    Every object has an identity, a type and a value. An object?s
>    identity never changes once it has been created; you may think of it
>    as the object?s address in memory. The ?is? operator compares the
>    identity of two objects; the id() function returns an integer
>    representing its identity.
> Thus "x and y are identical" *means* "x is y" and nothing else.

You are correct, "x and y are identical" does mean that "x is y". That is 
exactly the point.

However, the `is` operator is not necessarily the same as the English 
word "is". Is some languages, the `is` operator is a synonym for the 
equals operator. That is not the case in Python. In Python, the 
*expression* `x is y` has the same meaning as the English sentence "x is 
y" in the strong sense of testing identity, rather than the weak sense of 
merely testing similarities (or metaphor). So the Python docs don't 
merely give a circular definition, they distinguish between two different 
and competing possibilities:

(1) The `is` operator means the same as the == operator. (NO)

(2) The `is` operator tests for object identity. (YES)

Please also see my response to Roy Smith's message.

Every object has a unique (during the lifetime of the object) identity. 
The specific nature of that identity is implementation-dependent, and 
strictly irrelevant. The `is` operator tests whether the two operands are 
the same object, that is, whether they have the same identity. That's all 
it does.