+10  A: 

No, these aren't the same. is is a check for object identity - ie, checking if a and b are exactly the same object. Example:

a = 100.5
a is 100.5  # => False
a == 100.5  # => True

a = [1,2,3]
b = [1,2,3]
a == b  # => True
a is b  # => False
a = b
a == b  # => True
a is b  # => True, because if we change a, b changes too.

So: use == if you mean the objects should represent the same thing (most common usage) and is if you mean the objects should be in identical pieces of memory (you'd know if you needed the latter).

Also, you can overload == via the __eq__ operator, but you can't overload is.

Peter
the exact opposite of java
hhafez
Java doesn't have `is`, so it's hard to say how this is the exact opposite of it.
Pavel Minaev
in java, `==` tests memory address
hasen j
good answer, but doesn't answer the part about `a is 1` returning true.
hasen j
yep, that was an edit after the fact. this is interpreter-dependent, and reflects the fact that small integers are cached for speed. thus things equal to `1` will point to the same address for performance reasons. you can't rely on this, though.
Peter
@hasen j I'm not sure about the underlying engine, but if `a = [1,2,3]` and `b = [1,2,3]`, then wouldn't `a == b` evaluate to true regardless of memory address?
Jeremy Seghi
@Jeremy, in Java `a = [1,2,3]` is not valid code
hasen j
@hasen j I was focusing more on the `==` operator; you could use `a=1; b=1` for syntactical correctness. I think I am simply misinterpreting your comment though.
Jeremy Seghi
+5  A: 

As already very clearly explained above.

is : used for identity testing (identical 'objects')

== : used for equality testing (~~ identical value)

Also keep in mind that Python uses string interning (as an optimisation) so you can get the following strange side-effects:

>>> a = "test"
>>> b = "test"
>>> a is b
True
>>> "test_string" is "test" + "_" + "string"
True

>>> a = 5; b = 6; c = 5; d = a
>>> d is a
True  # --> expected
>>> b is a
False # --> expected
>>> c is a
True  # --> unexpected
ChristopheD
For numbers, it only works for integers that take on byte (e.g. `<= 256`)
hasen j
And for strings, it doesn't "detect" similar strings magically. Consider: `>>> a = "test">>> b = "test">>> a is bTrue>>> a = "test_string">>> c = b + "_string">>> a == cTrue>>> a is cFalse`
hasen j
this is due to the length of the strings / integers, and is **interpreter dependent**: don't rely on this behaviour.
Peter