conventions/requirements for 'is' vs '==', 'not vs '!=', etc

[destroooooy]

I'm wondering what is the canonical usage of the keywords 'is' and
'not' when you're writing conditionals and loops. The one I've been
following is completely arbitrary--I use the symbols '==', '!=' for
numerical comparisons and the words 'is', 'not' for everything else.

Thanks in advance!

[Marc 'BlackJack' Rintsch]

On Mon, 19 May 2008 12:39:36 -0700, destroooooy wrote:

I'm wondering what is the canonical usage of the keywords 'is' and
'not' when you're writing conditionals and loops. The one I've been
following is completely arbitrary--I use the symbols '==', '!=' for
numerical comparisons and the words 'is', 'not' for everything else.

That's wrong. Use ``==`` and ``!=`` for testing equality/inequality and
``is`` and ``is not`` for identity testing. And testing for identity is
quite rare. Rule of thumb: Use it only for known singletons like `None`.

Ciao,
Marc 'BlackJack' Rintsch

[Luis Zarrabeitia]

On Monday 19 May 2008 03:39:36 pm destroooooy wrote:

I'm wondering what is the canonical usage of the keywords 'is' and
'not' when you're writing conditionals and loops. The one I've been
following is completely arbitrary--I use the symbols '==', '!=' for
numerical comparisons and the words 'is', 'not' for everything else.

It's not arbitrary, and you shouldn't be using that convention.

The question is really about "equality" versus "identity". Two identical sized
cubes may be equal, but they are certainly not the same cube. The main
concept here: identity [usually] implies equality, but equality almost never
implies identity (two objects that are equal may be distinct nonetheless).

More practical example, two angles with the same measure are equal by every
mathematical concept, but opposing angles on a parallelogram are not the same
one.

Sometimes, you need to test for equality, as in "is this user input equal
to '1'?". Sometimes, you need to test for identity "is this user input
this '1' that I have here?" (note: the second answer should be 'no', unless
that by some dark magic the user manages to get that same '1' that is in your
code).

The most common use case is equality. You test for equality with == and!=.
The darker case is identity. You test for identity with "is" and "is not".
Whenever you use "is", ask yourself a question: does a negative answer makes
sense if the objects are equal?

Personally, I like to use "is" with singletons. I find it easier to type and
read "if param is None" than "if param == None", but some python developers
dislike the first one because of the "dark magic" involved in knowing that
None is a singleton.

When in doubt, test for equality. Use "is" only when you are certain that you
know the difference. Python does some optimizations that may it seem like it
is working with 'is' at first, but it really isn't:

In: a="hi"
In: b="hi"
In: a is b
Out: True <-- dark magic here, python optimized the string storage,
In: a is "h"+"i" <-- by using the same object instead of creating a new one
Out: False <-- but even that won't always work, so


In: a="a very long string, at least longer than 'hi'"
In: b="a very long string, at least longer than 'hi'"
In: a is b
Out: False <-- never, never rely on magic.

I hope I was useful.

Cheers,

--
Luis Zarrabeitia (aka Kyrie)
Fac. de Matemática y Computación, UH.
http://profesores.matcom.uh.cu/~kyrie

[bruno.desthuilliers]

On 19 mai, 22:29, Luis Zarrabeitia <[e-mail] te:
(snip)

The main
concept here: identity [usually] implies equality,

I really enjoyed the "usually" disclaimer !-)

[Christian Heimes]

Luis Zarrabeitia schrieb:

Personally, I like to use "is" with singletons. I find it easier to type and
read "if param is None" than "if param == None", but some python developers
dislike the first one because of the "dark magic" involved in knowing that
None is a singleton.

Testing for None is the only common case where you should *not* use ==
comparison. If you want to check if something is None then do "if
something is None". Easy, isn't it? :]

Look, what Python does for the various way (simplified):

"if a == None:" -"if a.__cmp__(None) "

"if a is None" -"if id(a) == id(None)"

"if a:" -"if a.__nonzero__() " / "if a.__len__()"

Christian

[Gabriel Genellina]

En Mon, 19 May 2008 17:58:48 -0300, br************* ****@gmail.com
<br************ *****@gmail.com escribió:

On 19 mai, 22:29, Luis Zarrabeitia <[e-mail] te:
(snip)

>The main
concept here: identity [usually] implies equality,

I really enjoyed the "usually" disclaimer !-)

In some *rare* cases, identity does not imply equality:

pyinf = 1e300*1e300
pynan = inf-inf
pynan
-1.#IND
pynan is nan
True
pynan == nan
False

--
Gabriel Genellina

[Asun Friere]

On May 20, 6:58 am, "bruno.desthuil [e-mail] "
<bruno.desthuil [e-mail] wrote:

On 19 mai, 22:29, Luis Zarrabeitia <[e-mail] te:
(snip)

The main
concept here: identity [usually] implies equality,

I really enjoyed the "usually" disclaimer !-)

Well you have to be careful in case some smartarse comes back with a
class with something like this in it:

def __eq__ (self, other) :
if self is other : return False

%)

[notnorwegian]

i am confused.

x=5
y=5

x==y -True
x is y -True

shouldnt x is y return False since they shouldnt(dont?) point to the
same place in memory, they just store an equal value?

[John Salerno]

On Mon, 19 May 2008 20:34:22 -0700 (PDT)
no**********@ya hoo.se wrote:

i am confused.

x=5
y=5

x==y -True
x is y -True

shouldnt x is y return False since they shouldnt(dont?) point to the
same place in memory, they just store an equal value?

For some immutable values (such as numbers and strings), Python will have separate variables reference the same object, as an optimization. This doesn't affect anything, since the numbers are immutable anyway and a shared reference won't create any unexpected changes.

It also works with small, but not large, strings:

>>x = 'hello'
y = 'hello'
x == y

True

>>x is y

True

>>a = 'this is longer'
b = 'this is longer'
a == b

True

>>a is b

False

>>>

In the above example, Python has created only one string called 'hello' and both x and y reference it. However, 'this is longer' is two completely different objects.

[Bruno Desthuilliers]

no**********@ya hoo.se a écrit :

i am confused.

x=5
y=5

x==y -True
x is y -True

shouldnt x is y return False since they shouldnt(dont?) point to the
same place in memory, they just store an equal value?

Python's "variable" do not "store values", they are name to object
bindings. x = 5 is a shortand for globals()['x'] = int(5), which means
"create an int instance with value 5 and bind it to the name 'x' in the
global namespace'. wrt/ the identity test yielding true, it's the result
of a CPython specific optimisation for small integer objects, that are
cached and reused. Since Python integers are immutable, they can safely
be shared. Now since it's an implementation specific thing, you should
by no mean rely on it.