Found a related question here on SO itself.

Python developers prefer to not check types but do a type specific operation and catch a TypeError exception. But if you don’t know the type then you have the following.

>>> i = 12345
>>> type(i)
<type 'int'>
>>> type(i) is int
True

>>> isinstance(3, int)
True

See here for more.

Note that this does not help if you’re looking for int-like attributes. In this case you may also want to check for long:

>>> isinstance(3L, (long, int))
True

I’ve seen checks of this kind against an array/index type in the Python source, but I don’t think that’s visible outside of C.

Token SO reply: Are you sure you should be checking its type? Either don’t pass a type you can’t handle, or don’t try to outsmart your potential code reusers, they may have a good reason not to pass an int to your function.

Never. Check. Types.

Do this. Always.

try:
    some operation that "requires" an integer
except TypeError, e:
    it wasn't an integer, fail.

If you really need to check then it’s better to use abstract base classes rather than concrete classes. For an integer that would mean:

>>> import numbers
>>> isinstance(3, numbers.Integral)
True

This doesn’t restrict the check to just int, or just int and long, but also allows other user-defined types that behave as integers to work.

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

If the variable is entered like a string (e.g. '2010'):

if variable and variable.isdigit():
    return variable #or whatever you want to do with it. 
else: 
    return "Error" #or whatever you want to do with it.

Before using this I worked it out with try/except and checking for (int(variable)), but it was longer code. I wonder if there’s any difference in use of resources or speed.

why not just check if the value you want to check is equal to itself cast as an integer as shown below?

def isInt(val):
    return val == int(val)

If you want to check that a string consists of only digits, but converting to an int won’t help, you can always just use regex.

import re
x = "01234"
match = re.search("^d+$", x)
try: x = match.group(0)
except AttributeError: print("not a valid number")

Result: x == "01234"

In this case, if x were “hello”, converting it to a numeric type would throw a ValueError, but data would also be lost in the process. Using a regex and catching an AttributeError would allow you to confirm numeric characters in a string with, for instance, leading 0’s.

If you didn’t want it to throw an AttributeError, but instead just wanted to look for more specific problems, you could vary the regex and just check the match:

import re
x = "h01234"
match = re.search("D", x)
if not match:
    print("x is a number")
else:
    print("encountered a problem at character:", match.group(0))

Result: "encountered a problem at character: h"

That actually shows you where the problem occurred without the use of exceptions. Again, this is not for testing the type, but rather the characters themselves. This gives you much more flexibility than simply checking for types, especially when converting between types can lose important string data, like leading 0’s.

use the int function to help

intchecker = float(input('Please enter a integer: '))
intcheck = 0
while intcheck != 1:
    if intchecker - int(intchecker) > 0:
        intchecker = float(input("You didn't enter a integer. "
                                 "Please enter a integer: "))
    else:
        intcheck = 1
print('you have entered a integer')

I was writing a program to check if a number was square and I encountered this issue, the
code I used was:

import math
print ("this program will tell you if a number is square")
print ("enter an integer")
num = float(input())
if num > 0:
    print ("ok!")
    num = (math.sqrt(num))
    inter = int(num)
    if num == inter:
            print ("It's a square number, and its root is")
            print (num)
    else:
            print ("It's not a square number, but its root is")
            print (num)
else:
    print ("That's not a positive number!")

To tell if the number was an integer I converted the float number you get from square rooting the user input to a rounded integer (stored as the value ), if those two numbers were equal then the first number must have been an integer, allowing the program to respond. This may not be the shortest way of doing this but it worked for me.

Why not try something like:

if x%1 == 0: 

you can do this by:

name = 'Bob'
if type(name) == str:
    print 'this works'
else:
    print 'this does not work'

and it will return ‘this works’… but if you change name to int(1) then it will return ‘this does not work’ because it is now a string…
you can also try:

name = int(5)
if type(name) == int:
    print 'this works'
else:
    print 'this does not work'

and the same thing will happen

There is another option to do the type check.

For example:

  n = 14
  if type(n)==int:
  return "this is an int"

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!

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.

A simple method I use in all my software is this. It checks whether the variable is made up of numbers.

test = input("Enter some text here: ")
if test.isdigit() == True:
   print("This is a number.")
else:
   print("This is not a number.")

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)

You can do this.

if type(x) is int:

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.

#######################################
# Value_Is_Int
#######################################
def value_is_int(value):
    try:
        tempVal = int(value)
        return True
    except:
        return False

Call this function:

if value_is_int(value):
    print "Integer"
else:
    print "Not integer"

I can check if the number is integer include number like 7.0

def is_int(x):
    if x - round(x) == 0 :
        return True
    else:
        return False

#!/usr/bin/env python

import re

def is_int(x):

    if(isinstance(x,(int,long))):

        return True
    matchObj = re.match(r'^-?d+.(d+)',str(x))

        if matchObj:

        x = matchObj.group(1)

        if int(x)-0==0:

            return True

     return False

print is_int(6)

print is_int(1.0)

print is_int(1.1)

print is_int(0.1)

print is_int(-956.0)

Rather than over complicate things, why not just a simple

if type(var) is int:

if type(input('enter = '))==int:
     print 'Entered number is an Integer'
else:
     print 'Entered number isn't an Integer'

This’ll work to check out whether number is an integer or not

import numpy as np

if (np.floor(x)-x == 0):
  return "this is an int"

If you have not int you can do just this:

var = 15.4
if(var - int(var) != 0):
    print "Value is not integer"

A simple way to do this is to directly check if the remainder on division by 1 is 0 or not.

if this_variable % 1 == 0:
    list.append(this_variable)
else:
    print 'Not an Integer!'

You can use this function:

def is_int(x):    
    if type(x) == int:
       return True
    return False

Test:

print is_int('7.0') # False
print is_int(7.0) # False
print is_int(7.5) # False
print is_int(-1) # True

If you want to write a Python 2-3 compatible code

To test whether a value is an integer (of any kind), you can to do this :

# Python 2 and 3: 
import sys
if sys.version_info < (3,):
    integer_types = (int, long,)
else:
    integer_types = (int,)

>>> isinstance(1, integer_types)
True

# Python 2 only:
if isinstance(x, (int, long)):
     ...

# Python 3 only:
if isinstance(x, int):
    ...

source : http://python3porting.com/differences.html

A more general approach that will attempt to check for both integers and integers given as strings will be

def isInt(anyNumberOrString):
    try:
        int(anyNumberOrString) #to check float and int use "float(anyNumberOrString)"
        return True
    except ValueError :
        return False

isInt("A") #False
isInt("5") #True
isInt(8) #True
isInt("5.88") #False *see comment above on how to make this True

In the presence of numpy check like ..

isinstance(var, numbers.Integral)

.. (slow) or ..

isinstance(var, (int, long, np.integer))

.. in order to match all type variants like np.int8, np.uint16, …

(Drop long in PY3)

Recognizing ANY integer-like object from anywhere is a tricky guessing game. Checking

var & 0 == 0 

for truth and non-exception may be a good bet. Similarly, checking for signed integer type exclusively:

var ^ -1 ==  -var - 1

Here is a simple example how you can determine an integer

def is_int(x):
    print round(x),
    if x == round(x):
        print 'True',
    else:
        print 'False'

is_int(7.0)   # True
is_int(7.5)   # False
is_int(-1)    # True    

I’ve had this problem before, if your type to use it in a if statement, and let’s just say you wanted it to return true, you would enter this into a line, (The bottom line in all that is really needed to be looked at):

In [1]: test = 1

In [2]: test2 = 1.0

In [3]: type(test) == int
Out[3]: True

In [4]: type(test2) == int
Out[4]: False

In [5]: if type(x) == int is True:

You can do the same thing to check if it’s a float, if it’s true or false, and use to assign a name, (like x if you know what I mean.)

If you are reading from a file and you have an array or dictionary with values of multiple datatypes, the following will be useful.
Just check whether the variable can be type casted to int(or any other datatype you want to enforce) or not.

try :
    int(a);
    #Variable a is int
except ValueError : 
    # Variable a is not an int

val=3
>>> isinstance(val,int ) 
True

will work.

Here’s a summary of the different methods mentioned here:

• int(x) == x
• try x = operator.index(x)
• isinstance(x, int)
• isinstance(x, numbers.Integral)

and here’s how they apply to a variety of numerical types that have integer value:

You can see they aren’t 100% consistent. Fraction and Rational are conceptually the same, but one supplies a .index() method and the other doesn’t. Complex types don’t like to convert to int even if the real part is integral and imaginary part is 0.

(np.int8|16|32|64(5) means that np.int8(5), np.int32(5), etc. all behave identically)

It is very simple to check in python. You can do like this:

Suppose you want to check a variable is integer or not!

## For checking a variable is integer or not in python

if type(variable) is int:
     print("This line will be executed")
else:
     print("Not an integer")

Testing, if object is a string (works with Python 2.* and Python 3.* )

text = get_text()

try:
    text = text+""
except:
    return "Not a string"

do_something(text)

The simplest way is:

if n==int(n):
    --do something--    

Where n is the variable

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

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