You're probably already familiar with equality: that's the
Identity uses the
Let's say we have two variables,
y pointing to two lists:
>>> x = [1, 2, 3] >>> y = [1, 2, 3]
If we say
x == y we're asking about equality:
>>> x == y True
Equality is about whether these two objects represent the same value, whether they're essentially the same thing.
== operator delegates to one of these objects and asks it, "do you represent the same value as the other object?"
That's up to the actual objects to answer.
is operator asks about identity.
>>> x is y False
is operator doesn't even look at the objects that
y point to.
is asks if the variables
y are pointing to the same object.
is operator answers the question do two object references actually point to the same object?
x is y checks the memory location that
y are pointing to (by their
id) and checks to see if those locations are the same.
>>> id(x) 139957046343296 >>> id(y) 139957046343488
y have the same
id in memory, that means we're referencing the same object in two places:
y are actually referring to the same exact object.
In Python, assignment points a variable to an object.
If we assign
>>> x = y
We're now pointing the variable
x to the same object that
y is currently pointing to.
>>> id(x) 139957046343488 >>> id(y) 139957046343488
If we call the
append method on the list that
x points to
We've mutated that list object, but we've also mutated the object that
y points to because both
y point to exactly the same object.
>>> x [1, 2, 3, 4] >>> y [1, 2, 3, 4]
These two objects are equal:
>>> x == y True
But they're also identical (which means they point to the same object):
>>> x is y True
Just as we have equality (
==) and inequality (
>>> x == y True >>> x != y False
we also have is for identity (
is) and unidentity (
is not)... or is it inidentity.
How about non-identity.
>>> x is y True >>> x is not y False
is not operator is one of the few operators in Python that actually has a space inside it.
You really don't see identity used very often.
This is really the most important takeaway about identity and equality: you'll use
== all the time, but you'll almost never use
When comparing two objects, you'll almost always want to check for equality instead of identity.
The place you'll most commonly see
is used is with
>>> x is None False >>> x is not None True
, there are other places you might see it used, the one place you'll most commonly see it used
There's only one
None value in memory in Python.
We're asking the question "is
x pointing to the one and only
You'll only see
is used with special values where there's only one of them in memory.
I call these sentinel values.
Sentinel objects are considered completely unique.
There's only one of them floating in the memory.
Sentinel values are pretty much the one place you'll see identity used and
None is by far the most common sentinel value in Python.
PEP 8, the Python style guide, says you should use identity to compare with
So you should never
x == None, but instead type
x is None.
That's the convention that we use with
None in Python.
When you want to ask the question "does one object represent the same data as another object", you pretty much always want to use equality (with the
You'll almost never need to ask the question "is one pointer referencing literally the same object as another pointer".
If you do want to ask that question though, you'll check identity (with the
is not operators).
The one time that you really should rely on identity is when comparing to
x is None).
Need to fill-in gaps in your Python skills?
Sign up for my Python newsletter where I share one of my favorite Python tips every week.
Python's variables aren't buckets that contain things; they're pointers that reference objects.
The way Python's variables work can often confuse folks new to Python, both new programmers and folks moving from other languages like C++ or Java.
Need to fill-in gaps in your Python skills? I send weekly emails designed to do just that.