检查变量是否为整数

时间：2010-08-17 10:15:08

标签： python

如何检查变量是否为整数？

41 个答案:

答案 0 :(得分：908)

如果您需要这样做，请执行

isinstance(<var>, int)

除非你在Python 2.x中，否则你需要

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

请勿使用type。它几乎从来都不是Python中的正确答案，因为它阻止了多态性的所有灵活性。例如，如果您继承int，则新类应注册为int，而type将不会执行此操作：

class Spam(int): pass
x = Spam(0)
type(x) == int # False
isinstance(x, int) # True

这符合Python强大的多态性：你应该允许任何行为类似于int的对象，而不是强制它是一个。

BUT

然而，经典的Python心态是，更容易请求宽恕而不是许可。换句话说，不要检查x是否为整数;假设它是并且如果不是，则捕获异常结果：

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

这种心态正逐渐被abstract base classes的使用所取代，这使你可以准确地注册你的对象应该具有哪些属性（添加？倍增？倍增？），使其从特殊构造的类继承。这将是最好的解决方案，因为它将允许完全那些具有必要和充分属性的对象，但您必须阅读有关如何使用它的文档。

答案 1 :(得分：89)

到目前为止，所有提出的答案似乎都错过了一个事实：double（python中的浮点数实际上是双精度数）也可以是一个整数（如果它在小数点后面没有任何内容）。我在双打上使用内置的is_integer()方法来检查它。

示例（在for循环中每隔x次执行一次操作）：

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

编辑：

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

>>> 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 True
    else:
        if val.is_integer():
            return True
        else:
            return False

答案 2 :(得分：58)

如果确实需要检查，那么最好使用abstract base classes而不是具体的类。对于一个意思是：

的整数 
>>> import numbers
>>> isinstance(3, numbers.Integral)
True

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

答案 3 :(得分：45)

以下是这里提到的不同方法的摘要：

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

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

Table of methods for checking whether Python numerical types are integers

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

（np.int8|16|32|64(5)表示np.int8(5)，np.int32(5)等所有行为都相同）

答案 4 :(得分：35)

>>> isinstance(3, int)
True

有关详情，请参阅here。

请注意，如果您正在寻找类似属性的int，这无济于事。在这种情况下，您可能还想检查long：

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

我已经在Python源代码中看到了对这种类型的数组/索引类型的检查，但我不认为这在C语言之外是可见的。

Token SO回复：您确定要检查其类型吗？要么不传递你无法处理的类型，要么不试图超越你潜在的代码重用者，他们可能有充分的理由不将int传递给你的函数。

答案 5 :(得分：20)

为什么不尝试这样的事情：

if x%1 == 0:

答案 6 :(得分：18)

为什么不只是一个简单的

而不是复杂的事情 
TanimotoCoefficientSimilarity

答案 7 :(得分：12)

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

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

答案 8 :(得分：11)

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

有些人指出，对int（和long）进行类型检查可能会导致遇到大十进制数的情况。非常正确。

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

我与很多帖子大肆宣称你不应该检查类型。好吧，GvR曾经说过这样的结果：在纯理论中，这可能是对的，但在实践中，isinstance经常起到一个有用的作用（就在不久之前，没有链接;你可以阅读什么GvR在posts like this one）中谈到相关问题。

有趣的是，有多少人似乎认为OP的意图是检查给定x的类型是否是数字整数类型 - 我理解的是什么我通常是指使用OP的词时：x是否表示整数。这可能非常重要：比如告诉别人他们想要挑选多少项，你可能想要检查一下你得到一个非负整数。像这样的用例比比皆是。

在我看来，重要的是看到（1）类型检查只是一个 - 并且通常是非常粗略地衡量程序的正确性，因为（2）它通常是有意义的有意义的值，并且不属于-bounds值使得废话。有时只是一些间歇性的值有意义 - 考虑到所有数字，在给定的情况下，只有那些真实的（非复杂的）整数才有可能。

有趣的非人似乎提到检查x == math.floor( x )。如果那应该给出一些大的十进制类错误，那么也许是时候重新思考OOP范式了。还有PEP 357考虑​​如何使用不那么明显的 - int - 但肯定是整数的值作为列表索引。不确定我是否喜欢这个解决方案。

答案 9 :(得分：8)

如果你想检查一个字符串只包含数字，但转换为int将无济于事，你可以随时使用正则表达式。

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

Result: x == "01234"

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

如果您不希望它抛出AttributeError，而只是想查找更具体的问题，您可以改变正则表达式并检查匹配：

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"

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

答案 10 :(得分：8)

在SO上找到related question。

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

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

答案 11 :(得分：6)

为什么不检查你要检查的值是否等于自身强制转换为整数，如下所示？

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

答案 12 :(得分：4)

这是一个如何确定整数

的简单示例 
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

答案 13 :(得分：4)

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

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

答案 14 :(得分：4)

如果输入的变量类似于字符串（例如'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))，但代码更长。我想知道资源使用或速度是否存在差异。

答案 15 :(得分：3)

存在 numpy 检查，如.. 

isinstance(var, numbers.Integral)

..（慢）或.. 

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

..以匹配所有类型变体，例如np.int8，np.uint16，...

（在PY3中删除long）

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

var & 0 == 0

对于真相和非例外可能是一个不错的选择。同样，检查有符号整数类型：

var ^ -1 ==  -var - 1

答案 16 :(得分：3)

如果您只需要值，operator.index（__index__特殊方法）就是我认为的方法。因为它应该适用于所有可以安全地转换为整数的类型。即浮动失败，整数，甚至没有通过鸭子输入实现Integral抽象类的花哨整数类。

operator.index是用于列表索引等的内容。在我看来，它应该用于更多/推广。

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

这是__index__为引入的！

答案 17 :(得分：3)

如果您想检查不考虑Python版本（2.x vs 3.x），请使用six（PyPI）及其integer_types属性： 

import six

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

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

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

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

答案 18 :(得分：3)

使用int函数来帮助

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

答案 19 :(得分：2)

#!/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)

答案 20 :(得分：2)

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

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

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

答案 21 :(得分：2)

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

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

答案 22 :(得分：2)

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

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

答案 23 :(得分：1)

最简单的方法是：

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

其中n是变量

答案 24 :(得分：1)

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

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

答案 25 :(得分：0)

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

text = get_text()

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

do_something(text)

答案 26 :(得分：0)

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

答案 27 :(得分：0)

我尝试过了，而且行得通。 

x = 'place_hold' 
num = input("num: ")
try:
   int(num)
   x = 'valid'
except ValueError: 
   x = 'invalid' 
print(x)

答案 28 :(得分：0)

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

会奏效。

答案 29 :(得分：0)

如果要编写Python 2-3兼容代码

要测试值是否为整数（任何类型），您可以执行以下操作：

# 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):
    ...

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

答案 30 :(得分：0)

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

这将用于检查数字是否为整数

答案 31 :(得分：0)

我可以检查数字是否为整数包括数字，如7.0 

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

答案 32 :(得分：0)

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

调用此函数：

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

答案 33 :(得分：0)

考虑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。

答案 34 :(得分：0)

你可以这样做。 

if type(x) is int:

答案 35 :(得分：0)

还有另一种选择来进行类型检查。

例如：

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

答案 36 :(得分：0)

您可以通过以下方式执行此操作：

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

它将返回＆＃39;这有效＆＃39; ...但如果您将名称更改为int（1），那么它将返回＆＃39;这不起作用＆＃39;因为它现在是一个字符串...... 你也可以尝试：

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

同样的事情会发生

答案 37 :(得分：-1)

import numpy as np

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

答案 38 :(得分：-2)

您可以使用此功能：

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

测试：

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

答案 39 :(得分：-3)

之前我遇到过这个问题，如果你的类型在if语句中使用它，我只想说你想要它return true，你可以将它输入一行，（所有真正需要关注的底线）：

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:

你可以做同样的事情来检查它是float，如果它是true还是false，并且用来指定一个名字，（如果你是x知道我的意思。）

答案 40 :(得分：-4)

从不。校验。类型。

这样做。总是

try:
    some operation that "requires" an integer
except TypeError, e:
    it wasn't an integer, fail.
相关问题
最新问题