Why does '300 is 301 - 1' return 'True' in Python?

Why does 300 is 301 - 1 return True in Python?

I would have expected Python to do something like store the values 300 and 301 at two distinct memory locations x and y respectively, then apply -1 to the value stored in y. As 300 is not in the special range [-5, 256] of integers which have a unique memory location, I don't see how Python (or CPython) can still understand that it can actually just discard y and add a reference to x.

Maybe what I am describing above would rather correspond to 300 is (lambda x: x - 1)(301), which indeed returns False. But then, what happens during the instruction 300 is 301 - 1?

Things like this are accidents of implementation, and must not be relied on. Here under CPython 3.11.3:

>>> 300 is 301 - 1
True
>>> one = 1
>>> 300 is 301 - one
False

The second in fact works the way you expected. Why doesn't the first? Because it just so happens that this version of the CPython compiler evaluates 301 - 1 at compile time, and finds the same result already in the code object's constant table.

In more detail:

>>> from dis import dis
>>> def f():
...     return 300 is 301 - 1
>>> dis(f)
  1           0 RESUME                   0

  2           2 LOAD_CONST               1 (300)
              4 LOAD_CONST               1 (300)
              6 IS_OP                    0
              8 RETURN_VALUE

See? It loads the same constant object (for the int 300) as the operands for is. While it doesn't go on to do this next thing, it could: evaluate the is at compile-time too, and reduce the entire function to just returning True.

The interpreter is free to optimize immutable built-ins all it wants. There is no "special range", that is an implementation detail. What is going on here is an example of constant folding. When the expression is compiled, Python simply creates references to constants, and caches constants for a given block of code. This is easily introspectable using the disassembler:

>>> import dis
>>> dis.dis("300 is 301 - 1")
<dis>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
  0           0 RESUME                   0

  1           2 LOAD_CONST               0 (300)
              4 LOAD_CONST               0 (300)
              6 IS_OP                    0
              8 RETURN_VALUE

You can see it simply loads the same object for the is_op comparison.

And indeed, if we compile this code, the code object carries the 300 in the 0th position of the constants:

>>> code = compile("300 is 301 - 1", "__main__", "exec")
__main__:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
>>> code.co_consts
(300, None)

Disassemble the byte code of the operation and you'll see that in this case the constant is pre-computed:

>>> def f():
...  return 300 is 301 - 1
...
<stdin>:2: SyntaxWarning: "is" with a literal. Did you mean "=="?
>>> import dis
>>> dis.dis(f)
  1           0 RESUME                   0

  2           2 LOAD_CONST               1 (300)
              4 LOAD_CONST               1 (300)
              6 IS_OP                    0
              8 RETURN_VALUE