Checking whether a variable is an integer or not [duplicate]

Answer 1

All proposed answers so far seem to miss the fact that a double (floats in python are actually doubles) can also be an integer (if it has nothing after the decimal point). I use the built-in is_integer() method on doubles to check this.

Example (to do something every xth time in a for loop):

for index in range(y): 
    # do something
    if (index/x.).is_integer():
        # do something special

Edit:

You can always convert to a float before calling this method. The three possibilities:

>>> float(5).is_integer()
True
>>> float(5.1).is_integer()
False
>>> float(5.0).is_integer()
True

Otherwise, you could check if it is an int first like Agostino said:

def is_int(val):
    if type(val) == int:
        return True
    else:
        if val.is_integer():
            return True
        else:
            return False

Answer 2

If you just need the value, operator.index (__index__ special method) is the way to go in my opinion. Since it should work for all types that can be safely cast to an integer. I.e. floats fail, integers, even fancy integer classes that do not implement the Integral abstract class work by duck typing.

operator.index is what is used for list indexing, etc. And in my opinion it should be used for much more/promoted.

In fact I would argue it is the only correct way to get integer values if you want to be certain that floating points, due to truncating problems, etc. are rejected and it works with all integral types (i.e. numpy, etc.) even if they may not (yet) support the abstract class.

This is what __index__ was introduced for!

Answer 3

You can also use str.isdigit. Try looking up help(str.isdigit)

def is_digit(str):
      return str.isdigit()

Answer 4

If you want to check with no regard for Python version (2.x vs 3.x), use six (PyPI) and it's integer_types attribute:

import six

if isinstance(obj, six.integer_types):
    print('obj is an integer!')

Within six (a very light-weight single-file module), it's simply doing this:

import sys
PY3 = sys.version_info[0] == 3

if PY3:
    integer_types = int,
else:
    integer_types = (int, long)

Answer 5

Consider the case x = n**(1.0/m), where n=10**5, m=5. In Python, x will be 10.000000000000002, which is only not integer because of floating point arithmetic operations.

So I'd check

if str(float(x)).endswith('.0'): print "It's an integer."

I've tested it with this code:

for a in range(2,100):
    for b in range(2,100):
        x = (a**b)**(1.0/b)
        print a,b, x, str(float(x)).endswith('.0')

It outputs True for all a and b.

Answer 6

it's really astounding to see such a heated discussion coming up when such a basic, valid and, i believe, mundane question is being asked.

some people have pointed out that type-checking against int (and long) might loose cases where a big decimal number is encountered. quite right.

some people have pointed out that you should 'just do x + 1 and see whether that fails. well, for one thing, this works on floats too, and, on the other hand, it's easy to construct a class that is definitely not very numeric, yet defines the + operator in some way.

i am at odds with many posts vigorously declaring that you should not check for types. well, GvR once said something to the effect that in pure theory, that may be right, but in practice, isinstance often serves a useful purpose (that's a while ago, don't have the link; you can read what GvR says about related issues in posts like this one).

what is funny is how many people seem to assume that the OP's intent was to check whether the type of a given x is a numerical integer type—what i understood is what i normally mean when using the OP's words: whether x represents an integer number. and this can be very important: like ask someone how many items they'd want to pick, you may want to check you get a non-negative integer number back. use cases like this abound.

it's also, in my opinion, important to see that (1) type checking is but ONE—and often quite coarse—measure of program correctness, because (2) it is often bounded values that make sense, and out-of-bounds values that make nonsense. sometimes just some intermittent values make sense—like considering all numbers, only those real (non-complex), integer numbers might be possible in a given case.

funny non-one seems to mention checking for x == math.floor( x ). if that should give an error with some big decimal class, well, then maybe it's time to re-think OOP paradigms. there is also PEP 357 that considers how to use not-so-obviously-int-but-certainly-integer-like values to be used as list indices. not sure whether i like the solution.