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?
@trinsec It's a lot more likely to need `==`, but the use of `is` does come about when you need to check that two objects are the exact same ones. It's not that uncommon.
Also, some prefer to use `is` with singletons such as `None`
`if stuff is None:`
Although in this case, there's no difference between `==` and `is` as there is only one `None`
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
