在这里找到一个相关问题在SO本身。

Python开发人员更喜欢不检查类型，而是执行特定于类型的操作并捕获TypeError异常。但是如果你不知道类型，那么你有以下内容。

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

如果你必须这么做那就做吧

isinstance(<var>, int)

除非你在Python 2. x中，在这种情况下你想要

isinstance(<var>, (int, long))

不要使用type。它在Python中几乎从来都不是正确的答案，因为它阻止了多态性的所有灵活性。例如，如果你是int的子类，你的新类应该注册为int，而type不会这样做：

class Spam(int): passx = Spam(0)type(x) == int # Falseisinstance(x, int) # True

这符合Python强大的多态性：您应该允许任何行为像int的对象，而不是强制要求它是一个。

但是

然而，经典的Python心态是它是请求原谅比请求许可容易。换句话说，不要检查x是否是整数；假设它是，如果不是，则捕获异常结果：

try:x += 1except TypeError:...

这种心态正在慢慢被抽象基类的使用所取代。通过使对象继承自一个特殊构造的类，它可以让你准确地注册你的对象应该有什么属性（添加？乘法？加倍？）。这将是最好的解决方案，因为它将允许完全那些具有必要和足够属性的对象，但你必须阅读有关如何使用它的文档。

>>> isinstance(3, int)True

查看这里了解更多。

请注意，如果您正在寻找类似int的属性，这并没有帮助。在这种情况下，您可能还需要检查long：

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

我在Python源代码中看到过针对数组/索引类型的这种检查，但我认为在C之外看不到。

代币SO回复：你确定你应该检查它的类型吗？要么不要传递你无法处理的类型，要么不要试图智取你的潜在代码重用者，他们可能有充分的理由不向你的函数传递int。

从来没有。检查。类型。

做这个。永远。

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

如果你需要检查真的，那么最好使用抽象基类而不是具体的类。对于一个整数，这意味着：

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

这不会将检查限制为仅int或仅int和long，但也允许其他行为为整数的用户定义类型工作。

到目前为止，所有提出的答案似乎都忽略了一个事实，即双精度（python中的浮点数实际上是双精度）也可以是整数（如果它在小数点后没有任何内容）。

示例（在for循环中每隔x次做某事）：

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

编辑：

在调用此方法之前，您始终可以转换为浮点数。三种可能性：

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

否则，您可以像Agostino所说的那样先检查它是否是int：

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

如果变量像字符串一样输入（例如'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.

在使用这个之前，我使用try/except并检查(int(variable))，但它是更长的代码。我想知道资源使用或速度是否有任何差异。

为什么不直接检查你要检查的值是否等于它本身转换为如下所示的整数？

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

如果您想检查字符串是否仅由数字组成，但转换为int无济于事，您可以始终使用regex。

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

在这种情况下，如果x是“hello”，则将其转换为数字类型会引发ValueError，但在此过程中数据也会丢失。使用正则表达式并捕获属性错误将允许您确认字符串中的数字字符，例如，前导0。

如果你不想让它抛出一个属性错误，而只是想寻找更具体的问题，你可以改变正则表达式并检查匹配：

import rex = "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"

在不使用异常的情况下，这实际上向您显示了问题发生的位置。同样，这不是用于测试类型，而是用于测试字符本身。这为您提供了比简单检查类型更大的灵活性，特别是当类型之间的转换可能会丢失重要的字符串数据时，例如前导0。

使用int函数来帮助

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

我正在编写一个程序来检查一个数字是否是平方，我遇到了这个问题我使用的代码是：

import mathprint ("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!")

为了判断这个数字是否是整数，我将用户输入的浮点数从平方根转换为四舍五入的整数（存储为值），如果这两个数字相等，那么第一个数字必须是整数，允许程序响应。这可能不是最短的方法，但它对我有效。

为什么不尝试一下：

if x%1 == 0:

你可以这样做：

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

它会返回'this works'…但是如果你将名称更改为int（1），那么它会返回'this not work'，因为它现在是一个字符串…你也可以试试：

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

同样的事情也会发生

还有另一个选项来进行类型检查。

例如：

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

如果你只需要值，在我看来operator.index（__index__特殊方法）是可行的。因为它应该适用于所有可以安全地转换为整数的类型。即浮点数失败，整数，甚至是不实现整数抽象类的花哨整数类通过鸭子类型工作。

operator.index用于列表索引等，在我看来，它应该用于更多/提升。

事实上，我认为这是获得整数值的唯一正确方法，如果你想确定浮点数，由于截断问题等被拒绝，它适用于所有整数类型（即numpy等），即使它们可能（还）不支持抽象类。

这就是__index__是介绍的原因！

看到这样一个基本的，有效的，我相信，平凡的问题被问到时，出现了如此激烈的讨论，真是令人震惊。

有些人指出，对int（和long）进行类型检查可能会丢失遇到大十进制数的情况。

有些人指出，你应该只做x + 1，看看它是否失败。嗯，一方面，这也适用于浮点数，另一方面，很容易构造一个绝对不是数字的类，但以某种方式定义了+运算符。

好吧，GvR曾经说过一些话，大意是在纯理论上，这可能是正确的，但在实践中，isinstance通常有一个有用的目的（那是一段时间以前，没有链接；你可以阅读GvR在像这样的帖子中对相关问题的看法）。

有趣的是，有多少人似乎认为OP的目的是检查给定x的类型是否是数字整数类型——我所理解的是我在使用OP的话时通常的意思：x是否代表整数。这可能非常重要：比如问某人他们想选择多少项目，你可能想检查你是否得到了一个非负整数。

在我看来，重要的是要看到（1）类型检查只是程序正确性的一个衡量标准，而且通常相当粗糙，因为（2）通常是有界值有意义，而越界值没有意义。有时只是一些间歇性的值有意义——比如考虑所有数字，只有那些真实的（非复杂的）整数在给定的情况下才有可能。

如果这应该给一些大的十进制类一个错误，好吧，那么也许是时候重新思考OOP范式了。还有PEP 357考虑如何使用不那么明显的int-但肯定-类似整数的值作为列表指示。不确定我是否喜欢这个解决方案。

我在所有软件中使用的一个简单方法是这样的。它检查变量是否由数字组成。

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

如果你想在不考虑Python版本（2. x vs 3. x）的情况下进行检查，请使用#0（PyPI）和它的integer_types属性：

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

在six（一个非常轻量级的单文件模块）中，它只是这样做：

import sysPY3 = sys.version_info[0] == 3
if PY3:integer_types = int,else:integer_types = (int, long)

你能做到的。

if type(x) is int:

考虑x=n**（1.0/m）的情况，其中n=10**5，m=5。在Python中，x将是10.000000000000002，这只是因为浮点算术运算而不是整数。

所以我查了一下

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

我用这段代码测试了它：

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')

它为所有a和b输出True。

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

调用此函数：

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

我可以检查数字是否为整数，包括7.0之类的数字

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

#!/usr/bin/env python
import re
def is_int(x):
if(isinstance(x,(int,long))):
return TruematchObj = 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)

而不是复杂的事情，为什么不只是一个简单的

if type(var) is int:

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

这将检查数字是否是整数

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

如果你没有int，你可以这样做：

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

一个简单的方法是直接检查除以1的余数是否为0。

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

您可以使用此功能：

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

测试：

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

如果你想写一个Python 2-3兼容的代码

要测试一个值是否是整数（任何类型），您可以这样做：

# Python 2 and 3:import sysif 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):...

来源：http://python3porting.com/differences.html

尝试检查整数和以字符串形式给出的整数的更通用方法将是

def isInt(anyNumberOrString):try:int(anyNumberOrString) #to check float and int use "float(anyNumberOrString)"return Trueexcept ValueError :return False
isInt("A") #FalseisInt("5") #TrueisInt(8) #TrueisInt("5.88") #False *see comment above on how to make this True

在存在numpy检查喜欢…

isinstance(var, numbers.Integral)

…（慢）或…

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

…为了匹配所有类型变体，如np.int8、np.uint16、…

（在PY3中下降long）

从任何地方识别任何类整数对象都是一个棘手的猜谜游戏。检查

var & 0 == 0

对于真理和非例外可能是一个不错的选择。类似地，检查有符号整数类型独占：

var ^ -1 ==  -var - 1

下面是一个简单的例子，如何确定一个整数

def is_int(x):print round(x),if x == round(x):print 'True',else:print 'False'
is_int(7.0)   # Trueis_int(7.5)   # Falseis_int(-1)    # True

我以前遇到过这个问题，如果你的类型在if语句中使用它，假设你想让它return true，你会把它输入一行，（所有真正需要查看的底线）：

In [1]: test = 1
In [2]: test2 = 1.0
In [3]: type(test) == intOut[3]: True
In [4]: type(test2) == intOut[4]: False
In [5]: if type(x) == int is True:

你可以做同样的事情来检查它是否是float，如果它是true或false，并用于分配一个名称（如x，如果你知道我的意思）。

如果您正在从文件中读取并且您有一个具有多个数据类型值的数组或字典，则以下内容将很有用。只需检查变量是否可以类型转换为int（或您想要强制执行的任何其他数据类型）。

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

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

将工作。

以下是此处提到的不同方法的摘要：

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

以下是它们如何应用于具有整数值的各种数字类型：

你可以看到它们不是100%一致的。Fraction和Rational在概念上是相同的，但是一个提供了.index()方法，另一个没有。复杂类型不喜欢转换为int，即使实部是整数而虚部是0。

（np.int8|16|32|64(5)表示np.int8(5)、np.int32(5)等都表现相同）

在python中检查非常简单。你可以这样做：

假设您要检查变量是否为整数！

## 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")

测试，如果对象是字符串（适用于Python 2.*和Python 3.*）

text = get_text()
try:text = text+""except:return "Not a string"
do_something(text)

最简单的方法是：

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

其中n是变量

您也可以使用str.isdigit。尝试查找help(str.isdigit)

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