Two variables in Python have same id, but not lists or tuples

by

Immutable objects don’t have the same id, and as a mater of fact this is not true for any type of objects that you define separately. Generally speaking, every time you define an object in Python, you’ll create a new object with a new identity. However, for the sake of optimization (mostly) there are some exceptions for small integers (between -5 and 256) and interned strings, with a special length –usually less than 20 characters–* which are singletons and have the same id (actually one object with multiple pointers). You can check this like following:

>>> 30 is (20 + 10)
True
>>> 300 is (200 + 100)
False
>>> 'aa' * 2 is 'a' * 4
True
>>> 'aa' * 20 is 'a' * 40
False

And for a custom object:

>>> class A:
...    pass
... 
>>> A() is A() # Every time you create an instance you'll have a new instance with new identity
False

Also note that the is operator will check the object’s identity, not the value. If you want to check the value you should use ==:

>>> 300 == 3*100
True

And since there is no such optimizational or interning rule for tuples or any mutable type for that matter, if you define two same tuples in any size they’ll get their own identities, hence different objects:

>>> a = (1,)
>>> b = (1,)
>>>
>>> a is b
False

It’s also worth mentioning that rules of “singleton integers” and “interned strings” are true even when they’ve been defined within an iterator.

>>> a = (100, 700, 400)
>>>
>>> b = (100, 700, 400)
>>>
>>> a[0] is b[0]
True
>>> a[1] is b[1]
False


* A good and detailed article on this: http://guilload.com/python-string-interning/

More Related Contents:

  1. The `is` operator behaves unexpectedly with non-cached integers
  2. python is operator behaviour with string [duplicate]
  3. how to unpack a tuple in this form (‘abc’, [20, 20])? [closed]
  4. Why is “1000000000000000 in range(1000000000000001)” so fast in Python 3?
  5. “is” operator behaves unexpectedly with integers
  6. Are dictionaries ordered in Python 3.6+?
  7. Accessing class variables from a list comprehension in the class definition
  8. Why does id({}) == id({}) and id([]) == id([]) in CPython?
  9. How does swapping of members in tuples (a,b)=(b,a) work internally?
  10. How are tuples unpacked in for loops?
  11. How does asyncio actually work?
  12. Are tuples more efficient than lists in Python?
  13. Why can tuples contain mutable items?
  14. How is tuple implemented in CPython?
  15. Is there anything faster than dict()?
  16. Accessing dictionary items by position in Python 3.6+ efficiently
  17. Identifier normalization: Why is the micro sign converted into the Greek letter mu?
  18. What does *tuple and **dict mean in Python? [duplicate]
  19. Why is a class __dict__ a mappingproxy?
  20. lambda arguments unpack error
  21. Using a function defined in an exec’ed string in Python 3 [duplicate]
  22. Integer File Descriptor “0” in open()
  23. How is super() in Python 3 implemented?
  24. list comprehension filtering – “the set() trap”
  25. Sort a list of tuples depending on two elements [duplicate]
  26. Are list comprehensions syntactic sugar for `list(generator expression)` in Python 3?
  27. Confused about Python’s id() [duplicate]
  28. How does str.startswith really work?
  29. ‘is’ operator behaves unexpectedly with floats
  30. Converting string to tuple without splitting characters

Leave a Comment