Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →is checks whether two names refer to the same object; == checks whether their values are equal. The familiar result that 256 is 256 is true while 257 is 257 is false can occur in CPython, but it is not a Python-language guarantee. Compare integers with ==, never with is.
What the expression is really testing
Consider this illustrative code:
a = 256
b = 256
print(a is b)
c = 257
d = 257
print(c is d)In some CPython sessions, the output is True followed by False. The first result does not mean that the integer value 256 has a special status in the Python language, and the second does not mean that 257 can never be shared. The expression uses identity, so it asks whether each pair refers to one object in memory.
is: object identity
x is y is true only when x and y are references to the same object. It does not perform a numeric comparison.
==: value equality
x == y asks whether the objects represent equal values. For integers, this is the operation that expresses the programmer’s intent:
#1 Best Overall
257 == 257 # TrueWhy some integers appear to be reused
Integers are immutable. An implementation may therefore keep one object for a value and return another reference to it whenever that value is requested again. Reusing immutable objects can reduce allocation work and memory use, but Python’s data model treats this as implementation-dependent behavior, not as a promise programs may depend on.
CPython documents an internal array of integer objects. The Python 3.15.0rc2 C API documentation describes cached objects for every integer from -5 through 1024 and explicitly labels the mechanism a CPython implementation detail. That range belongs to that implementation and documentation version; it is not a cross-Python contract.
Why the “256/257 boundary” is misleading
The Python FAQ uses the 256/257 example to warn that identity tests must not be used for constants such as integers and strings. It is a useful demonstration of surprising behavior, not a specification that 256 is permanently the largest cached value.
Observed identity can also vary with how code is compiled and how constants are stored. Two equal literals in one compiled code object may be reused, while values created separately at runtime may not be. A result seen in a short REPL experiment therefore cannot establish a universal boundary.
Free tools Windows power users keep installed
One-click scans. No signup required.
Version and implementation matter
- CPython, PyPy, and other Python implementations may make different reuse decisions.
- Even within CPython, implementation details and documented ranges can change between versions.
- A statement such as “Python caches integers through 256” is too broad. Say which implementation and version produced the observation.
The rule to use in real programs
Compare numeric values with ==
count = 257
if count == 257:
handle_count()This remains correct regardless of object allocation, integer size, Python implementation, or compiler behavior.
Reserve is for identity-sensitive cases
Identity checks are appropriate when the object itself is the signal. Common examples include the singleton None and a private sentinel created by your code:
if result is None:
use_default()
_MISSING = object()
value = mapping.get("name", _MISSING)
if value is _MISSING:
report_missing()These checks work because the program deliberately relies on one specific object, not merely on a value that happens to compare equal.
Identity versus equality at a glance
| Question | Operator | Use it when | Integer example |
|---|---|---|---|
| Are these the same object? | is |
Identity is part of the program’s logic | x is y |
| Do these objects have equal values? | == |
Comparing numbers or other values | x == y |
How to interpret a surprising result
- Check the operator. If the code uses
is, it is testing identity rather than numeric equality. - Check the runtime. Record the Python implementation and version before drawing conclusions.
- Check how the values were produced. Literals compiled together, conversions, and separately created objects can lead to different identity results.
- Replace the comparison with
==if the requirement is that the numbers have the same value.
The reliable conclusion is simple: Python permits implementations to reuse immutable integer objects, and CPython documents one such cache as an internal detail. The apparent 256/257 cutoff is therefore an observation, not a language rule. Use == for integer comparisons and is only when your logic requires the very same object.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
