I have two user-defined objects, say
Both these objects have the same
id(b) are unequal.
>>> a is b
>>> a == b
From this observation, can I infer the following?
obj1 is obj2 is called, the
id values of both objects is compared, not their
The hash function is used to:
quickly compare dictionary keys during a dictionary lookup
the ID function is used to:
Return the “identity” of an object. This is an integer which is guaranteed to be unique and constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same id() value.
Unequal objects may have the same hash values.
Yes this is true. A simple example is
hash(-1) == hash(-2) in CPython.
Equal objects need to have the same id values.
No this is false in general. A simple counterexample noted by @chepner is that
5 == 5.0 but
id(5) != id(5.0).
obj1 is obj2is called, the id values of both the objects is compared, not their hash values.
Yes this is true.
is compares the
id of the objects for equality (in CPython it is the memory address of the object). Generally, this has nothing to do with the object’s hash value (the object need not even be hashable).
There are three concepts to grasp when trying to understand
hash and the
is operators: identity, value and hash value. Not all objects have all three.
All objects have an identity, though even this can be a little slippery in some cases. The
id function returns a number corresponding to an object’s identity (in cpython, it returns the memory address of the object, but other interpreters may return something else). If two objects (that exist at the same time) have the same identity, they’re actually two references to the same object. The
is operator compares items by identity,
a is b is equivalent to
id(a) == id(b).
Identity can get a little confusing when you deal with objects that are cached somewhere in their implementation. For instance, the objects for small integers and strings in cpython are not remade each time they’re used. Instead, existing objects are returned any time they’re needed. You should not rely on this in your code though, because it’s an implementation detail of cpython (other interpreters may do it differently or not at all).
All objects also have a value, though this is a bit more complicated. Some objects do not have a meaningful value other than their identity (so value an identity may be synonymous, in some cases). Value can be defined as what the
== operator compares, so any time
a == b, you can say that
b have the same value. Container objects (like lists) have a value that is defined by their contents, while some other kinds of objects will have values based on their attributes. Objects of different types can sometimes have the same values, as with numbers:
0 == 0.0 == 0j == decimal.Decimal("0") == fractions.Fraction(0) == False (yep,
bools are numbers in Python, for historic reasons).
If a class doesn’t define an
__eq__ method (to implement the
== operator), it will inherit the default version from
object and its instances will be compared solely by their identities. This is appropriate when otherwise identical instances may have important semantic differences. For instance, two different sockets connected to the same port of the same host need to be treated differently if one is fetching an HTML webpage and the other is getting an image linked from that page, so they don’t have the same value.
In addition to a value, some objects have a hash value, which means they can be used as dictionary keys (and stored in
sets). The function
hash(a) returns the object
a‘s hash value, a number based on the object’s value. The hash of an object must remain the same for the lifetime of the object, so it only makes sense for an object to be hashable if its value is immutable (either because it’s based on the object’s identity, or because it’s based on contents of the object that are themselves immutable).
Multiple different objects may have the same hash value, though well designed hash functions will avoid this as much as possible. Storing objects with the same hash in a dictionary is much less efficient than storing objects with distinct hashes (each hash collision requires more work). Objects are hashable by default (since their default value is their identity, which is immutable). If you write an
__eq__ method in a custom class, Python will disable this default hash implementation, since your
__eq__ function will define a new meaning of value for its instances. You’ll need to write a
__hash__ method as well, if you want your class to still be hashable. If you inherit from a hashable class but don’t want to be hashable yourself, you can set
__hash__ = None in the class body.
I just had an experiment , which assigned same whole number to 2 separated variables , but when I used ‘ is ‘ operator to compare them , then in returned True ; I didn’t expect such a thing , Thought that the variables must be exact same like==>
a = 10
b = a
a is b # output == True