How do I represent minimum and maximum values for integers in Python? In Java, we have Integer.MIN_VALUE and Integer.MAX_VALUE.
See also: What is the maximum float in Python?.
12 Answers
Python 3
In Python 3, this question doesn't apply. The plain int type is unbounded.
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 # on my system, 2**63-1 9223372036854775807 You can calculate the minimum value with -sys.maxint - 1 as shown in the docs.
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.
24 Comments
NullUserException
This number may appear to be arbitrary, but it isn't. 9223372036854775807 is exactly
2^63 - 1, so you've got a 64-bit int. In general, an n-bit integer has values ranging from -2^(n-1) to 2^(n-1) - 1.
Scott Stafford
Note that if you're using a 32-bit Python runtime, sys.maxint will return
2^31 - 1, even though Python will jump to 64-bit seamlessly with the long datatype.
0 _
Use
sys.maxsize instead, as suggested by @Akash Rana. It is present also in Python 2, as sys docs say. This will make the code more compatible with both Python versions.
senderle
You and I have different interpretations of that line from the docs. The replacement in
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 need sys.maxint in Python 2, you won't need it anymore in Python 3, and it should really be removed entirely, not changed to sys.maxsize.
om471987
minsize - Multiplying with Bitwise min operator gives minsize ~sys.maxsize
|
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.
9 Comments
Scre
Just a note tho (as irrelevant it is, but still): float('inf') > float('inf') results in 'false'. Infinite number should be bigger than another infinite number :-D ... mind snaps
jamesdlin
@Scre What else would you expect?
x > x is usually False, and infinity should be no exception. (float('NaN), on the other hand...)Leighton
This actually doesn't apply for
int cauze cannot convert infinite float to int...but works for most cases
Nathan
@Scre "In comparison operations, positive infinity is larger than all values except itself and NaN, and negative infinity is smaller than all values except itself and NaN." gnu.org/software/libc/manual/html_node/Infinity-and-NaN.html
Eggcellentos
This is not an answer to the OP question
|
The sys.maxint constant has been removed from Python 3.0 onward, instead use sys.maxsize.
Integers
- PEP 237: Essentially,
longrenamed toint. That is, there is only one built-in integral type, namedint; but it behaves mostly like the oldlongtype....
- The
sys.maxintconstant was removed, since there is no longer a limit to the value of integers. However,sys.maxsizecan 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 assys.maxintin previous releases on the same platform (assuming the same build options).
2 Comments
Marco Sulla
Correct. Indeed, from
help(sys): maxsize -- the largest supported length of containers. This should be the accepted answer.
Francesco Marchetti-Stasi
I guess that the correct answer depends on the use case: in my casa (a default for a limiting parameter in a function) this was indeed the best answer, YMMV.
For Python 3, there is no maximum or minimum value for the int type.
You might be interested in sys.maxsize instead. According to the documentation:
sys.maxsize
An integer giving the maximum value a variable of type
Py_ssize_tcan take. It’s usually2**31 - 1on a 32-bit platform and2**63 - 1on a 64-bit platform.
import sys max_size = sys.maxsize min_size = -sys.maxsize - 1 
9 Comments
michael
well, python 3 does exist , thankfully(!); but
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." )
netskink
Look up 2’s compliment binary
Andrew
min = ~sys.maxsize
Steven Rumbalski
This answer is false. If it were true
sys.maxsize ** 2 would not return a valid and correct value, yet it does. You should delete this answer.
Abhijit Sarkar
These would work great as sentinel values in algorithms, which is a common usage. Please don’t delete this answer, just make it clear that it’s the most practical one, even if not the most mathematically correct one.
|
In Python 2, 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 2.7 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 because1llooks 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 
4 Comments
NullUserException
To add to the confusion, Python's
long isn't like Java's long - it's rather closer to BigInteger.
Eric
In python3, seems there is no
L suffix, and it's just int, not long, no matter how large the number is.
Coder
may i suggest editing your answer showing
type(...) instead on relying on an L at the end which an have ambiguous meaning?
John Kugelman
@JohnD What is the ambiguity?
You may use 'inf' like this:
import math bool_true = 0 < math.inf bool_false = 0 < -math.inf 
3 Comments
Georgy
Note that
math.inf is equivalent to float('inf')
Gilberto Albino
The author questioned how to obtain the MAX and MIN int values. How does this answer relates to the question, since the results are True and False, not MAX and MIN?
Matt
Be aware that
math.inf and -math.inf cannot be converted into int, e.g. this will fail: a = math.inf; b = int(a). It will throw OverflowError: cannot convert float infinity to integer. You can use it, but be aware it is outside the number range of int. So you can't use it as a sentinel value.On CPython 3.11 on a 64-bit system, the maximum and minimal integers are
2 ** ((2 ** 63 - 1) * 30) - 1 -(2 ** ( 2 ** 63 * 30) - 1) You will need 40 exabytes of memory to create one, which would cost $70 billion at today's (July 2023) prices of $57 per 32GB on NewEgg, so in practice Python's maximum integer is limited by how much memory you have in your computer.
CPython 3.11 stores integers like this (I simplified the actual code by taking out all the macros):
struct PyLongObject { Py_ssize_t ob_refcnt; /* Metadata for garbage collection */ PyTypeObject* ob_type; /* Metadata for type() */ Py_ssize_t ob_size; /* Number of items in ob_digit */ uint32_t ob_digit[1]; /* Array of 32-bit integers */ }; So on a 64-bit system, Python integers are implemented as an array of 32-bit integers storing the absolute value of the integer (but 2 of the bits of each integer aren't used) and a 64-bit signed two's complement integer stores the length of that array as well as the sign of the Python integer, so a negative integer has a negative "size".
Comments
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.
1 Comment
Contango
e.g. for the maximum 32-bit int use:
np.iinfo(np.int32).maxsys.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.
Comments
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
1 Comment
Tony Suffolk 66
No - maxsize is simply the largest possible container index. Python will happily work with 100 digit integers and more
As other answers point out, unlike float (which has the maximum value of sys.float_info.max), int type is unbounded in Python; it is really bounded by the memory limit of your machine. That said, there are some limits related to integers.
For example, since Python 3.10.7, converting str to int or printing int is limited to 4300 digits, a consequence of which is writing a very long integer to a file is limited by default (which can be turned off by running sys.set_int_max_str_digits(0)). You can get information about the internal representation of integers in Python using sys.int_info.
Also since float is bounded, you can't perform calculations where the output would become a float that is outside float bound (e.g. 2**1025/2 raises an OverflowError).
Also, int in popular data analysis libraries such as numpy and pandas etc. are bound by their type, e.g. numpy.uint64 can hold the largest positive integer in numpy, which can be checked by np.iinfo('uint64'). This means we can't perform vectorized computations involving too large integers, e.g. we can't take log2 of 2**64 (in fact, np.log2(2**64) raises a TypeError).
sys.maxsize is the size of the largest possible list. You can check that by using range().
len(range(sys.maxsize)) == sys.maxsize # 9223372036854775807 len(range(sys.maxsize+1)) # OverflowError 
Comments
code given below will help you. for maximum value you can use sys.maxsize and for minimum you can negate same value and use it.
import sys ni=sys.maxsize print(ni) 
inttype is basically the same as thelongtype in Python 2, so the idea of a maximum or minimumintdisappears completely. It's basically irrelevant even on Python 2.sys.maxintsince it's only the maximum for theinttype on Python 2, which Python will silently promote to along.float('inf')orfloat('-inf')can be quite helpful.Literalin type hints. So you can't say that a list can containUnion[int, Literal[-inf]]even though that might be exactly what might be needed for a given application :/