How do I represent minimum and maximum values for integers in Python? In Java, we have Integer.MIN_VALUE
and Integer.MAX_VALUE
.
int
type is basically the same as the long
type in Python 2, so the idea of a maximum or minimum int
disappears completely. It's basically irrelevant even on Python 2.
sys.maxint
since it's only the maximum for the int
type on Python 2, which Python will silently promote to a long
.
float('inf')
or float('-inf')
can be quite helpful.
Literal
in type hints. So you can't say that a list can contain Union[int, Literal[-inf]]
even though that might be exactly what might be needed for a given application :/
Python 3
In Python 3, this question doesn't apply. The plain int
type is unbound.
However, you might actually be looking for information about the current interpreter's word size, which will be the same as the machine's word size in most cases. That information is still available in Python 3 as sys.maxsize
, which is the maximum value representable by a signed word. Equivalently, it's the size of the largest possible list or in-memory sequence.
Generally, the maximum value representable by an unsigned word will be sys.maxsize * 2 + 1
, and the number of bits in a word will be math.log2(sys.maxsize * 2 + 2)
. See this answer for more information.
Python 2
In Python 2, the maximum value for plain int
values is available as sys.maxint
:
>>> sys.maxint
9223372036854775807
You can calculate the minimum value with -sys.maxint - 1
as shown here.
Python seamlessly switches from plain to long integers once you exceed this value. So most of the time, you won't need to know it.
If you just need a number that's bigger than all others, you can use
float('inf')
in similar fashion, a number smaller than all others:
float('-inf')
This works in both python 2 and 3.
x > x
is usually False
, and infinity should be no exception. (float('NaN)
, on the other hand...)
int
cauze cannot convert infinite float to int
...but works for most cases
The sys.maxint
constant has been removed from Python 3.0 onward, instead use sys.maxsize
.
Integers PEP 237: Essentially, long renamed to int. That is, there is only one built-in integral type, named int; but it behaves mostly like the old long type. PEP 238: An expression like 1/2 returns a float. Use 1//2 to get the truncating behavior. (The latter syntax has existed for years, at least since Python 2.2.) The sys.maxint constant was removed, since there is no longer a limit to the value of integers. However, sys.maxsize can be used as an integer larger than any practical list or string index. It conforms to the implementation’s “natural” integer size and is typically the same as sys.maxint in previous releases on the same platform (assuming the same build options). The repr() of a long integer doesn’t include the trailing L anymore, so code that unconditionally strips that character will chop off the last digit instead. (Use str() instead.) Octal literals are no longer of the form 0720; use 0o720 instead.
Refer : https://docs.python.org/3/whatsnew/3.0.html#integers
help(sys)
: maxsize -- the largest supported length of containers. This should be the accepted answer.
For Python 3, it is
import sys
maxSize = sys.maxsize
minSize = -sys.maxsize - 1
sys.maxint
doesn't exist in python 3 (tl;dr: "sys.maxint
constant was removed (in python3), since there is no longer a limit to the value of integers. However, sys.maxsize
can be used as an integer larger than any practical list or string index." )
min()
and max()
?
min = ~sys.maxsize
In Python integers will automatically switch from a fixed-size int
representation into a variable width long
representation once you pass the value sys.maxint
, which is either 231 - 1 or 263 - 1 depending on your platform. Notice the L
that gets appended here:
>>> 9223372036854775807
9223372036854775807
>>> 9223372036854775808
9223372036854775808L
From the Python manual:
Numbers are created by numeric literals or as the result of built-in functions and operators. Unadorned integer literals (including binary, hex, and octal numbers) yield plain integers unless the value they denote is too large to be represented as a plain integer, in which case they yield a long integer. Integer literals with an 'L' or 'l' suffix yield long integers ('L' is preferred because 1l looks too much like eleven!).
Python tries very hard to pretend its integers are mathematical integers and are unbounded. It can, for instance, calculate a googol with ease:
>>> 10**100
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000L
long
isn't like Java's long
- it's rather closer to BigInteger
.
L
suffix, and it's just int
, not long
, no matter how large the number is.
type(...)
instead on relying on an L
at the end which an have ambiguous meaning?
You may use 'inf' like this:
import math
bool_true = 0 < math.inf
bool_false = 0 < -math.inf
Refer: math — Mathematical functions
math.inf
is equivalent to float('inf')
If you want the max for array or list indices (equivalent to size_t
in C/C++), you can use numpy:
np.iinfo(np.intp).max
This is same as sys.maxsize
however advantage is that you don't need import sys just for this.
If you want max for native int on the machine:
np.iinfo(np.intc).max
You can look at other available types in doc.
For floats you can also use sys.float_info.max
.
np.iinfo(np.int32).max
I rely heavily on commands like this.
python -c 'import sys; print(sys.maxsize)'
Max int returned: 9223372036854775807
For more references for 'sys' you should access
https://docs.python.org/3/library/sys.html
https://docs.python.org/3/library/sys.html#sys.maxsize
sys.maxsize
is not the actually the maximum integer value which is supported. You can double maxsize and multiply it by itself and it stays a valid and correct value.
However, if you try sys.maxsize ** sys.maxsize
, it will hang your machine for a significant amount of time. As many have pointed out, the byte and bit size does not seem to be relevant because it practically doesn't exist. I guess python just happily expands it's integers when it needs more memory space. So in general there is no limit.
Now, if you're talking about packing or storing integers in a safe way where they can later be retrieved with integrity then of course that is relevant. I'm really not sure about packing but I know python's pickle
module handles those things well. String representations obviously have no practical limit.
So really, the bottom line is: what is your applications limit? What does it require for numeric data? Use that limit instead of python's fairly nonexistent integer limit.
Success story sharing
2^63 - 1
, so you've got a 64-bit int. In general, an n-bit integer has values ranging from-2^(n-1)
to2^(n-1) - 1
.2^31 - 1
, even though Python will jump to 64-bit seamlessly with thelong
datatype.sys.maxsize
instead, as suggested by @Akash Rana. It is present also in Python 2, assys
docs say. This will make the code more compatible with both Python versions.2to3
is a fine quick-and-dirty heuristic that won't break anything most of the time -- but the difference between these two values matters. The best practice is to use the value you actually mean to use. If you truly needsys.maxint
in Python 2, you won't need it anymore in Python 3, and it should really be removed entirely, not changed tosys.maxsize
.