Have you heard the one about `is`, `==`, and the £5 note that it’s your pocket?
You may have already come across the fact that `is` and `==` are not the same in Python and cannot be used interchangeably… if you haven’t, you heard it now!
But why? Let’s see what the £5 note has got to do with this story
Let’s assume you and I both have a £5 note in our pocket
[replace with currency of choice]
and
[read “bill” instead of “note” if you wish]
We meet up and go to a coffee shop nearby to buy two coffees which cost £5 altogether
Does it matter which £5 note we use to pay?
/1
[this is like a Netflix series you can binge on, no need to wait until next week for the next episode, read on in the next toot in this thread…]
So, does it matter which £5 note we use to pay?
No, all the barista cares about is that `our_payment == 5`
So _you_ can pay. Thank you!
In this case, the *value* of the £5 note is what matters, not which actual physical note we use.
But let’s assume we’re chatting and we spot a £5 note on the floor.
We both check our pockets and we realise we’ve both lost our £5 note.
Is the note on the floor mine or yours?
/2
Its value is no longer what matters now.
We both had a £5 note.
What matters is whether this is the actual physical note that was in my pocket or yours.
Luckily, we’re both geeks and we keep a record of the serial numbers of all the notes we carry with us on our phone.
I know, that’s quite sad.
And quite unlikely, too.
But bear with me.
So, we both get our phones out to check the serial numbers on record against the serial number on the £5 note on the floor.
You can see the serial number in two places on the £5 note.
/3
Sorry, the serial number of the note shows it’s _mine_!
This *is* my note. In this case, it wasn’t `==` that matters but `is`
With a #Python object, the built-in `id()` function gives you the “serial number”, which is unique for each object, just as the serial number on a bank note is unique.
In #programming, as in the case with bank notes, you often care more about the value of an object rather than its identity.
So, you’ll often need `==` just like the barista in the coffee shop didn’t care about the £5 note’s serial number.
/4
But, there are times when you want to know that an object is exactly the same object and not just equal in value.
In these cases, you’ll need to use `is`.
As a general rule, use `==` by default unless you know you need `is`.
But now can we stop squabbling about who the £5 note belongs to?!
/5
@s_gruppetta I actually haven’t really ever encountered ‘is’ myself. I gather it’s probably fairly rare to see this?
Here’s an example:
You have a number of teams of people:
teams = [["Bob", "Mary"], ["James", "Kate"], ["Bob", "Mary"]]
Unfortunately, Bob and Mary are common names and there are two teams that each have a Bob and a Mary. I know, the coincidence of that!
>>> teams[0] == teams[2]
True
But, they’re not the same team! They’re different people!
>>> teams[0] is teams[2]
False
If you want to know whether these are the same teams, you need `is' in this case