关于python：检查变量是否为整数


Checking whether a variable is an integer or not

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

相关讨论

如果你需要这样做，就去做

1
isinstance(<var>, int)

除非您是在python 2.x中，在这种情况下，您需要

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

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

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

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

但是

然而，传统的Python心态是，请求宽恕比允许更容易。换句话说，不要检查x是否为整数；假设为整数，如果不是，则捕获异常结果：

1
2
3
4
try:
    x += 1
except TypeError:
    ...

这种思想正慢慢被抽象基类的使用所取代，抽象基类使您能够准确地注册对象应该具有的属性(添加？乘法？加倍？)通过使它从一个特殊构造的类继承。这将是最好的解决方案，因为它将允许那些具有必要和足够属性的对象，但是您必须阅读关于如何使用它的文档。

相关讨论

到目前为止，所有建议的答案似乎都忽略了这样一个事实：double(python中的float实际上是double)也可以是整数(如果小数点后没有任何值)。我在double上使用了内置的is_integer()方法来检查这个问题。

示例(每隔x次在for循环中执行某项操作)：

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

编辑：

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

1
2
3
4
5
6
>>> float(5).is_integer()
True
>>> float(5.1).is_integer()
False
>>> float(5.0).is_integer()
True

否则，你可以先检查一下它是不是一个int，就像agostino说的：

1
2
3
4
5
6
7
8
def is_int(val):
    if type(val) == int:
        return True
    else:
        if val.is_integer():
            return True
        else:
            return False
相关讨论

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

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

这不限制检查仅限于int，或仅限于int和long，但也允许其他用户定义的类型以整数的形式工作。

相关讨论

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

  • 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%一致的。分数和有理在概念上是相同的，但一个提供.index()方法，另一个不提供。复杂类型不喜欢转换为int，即使实部是整数，虚部是0。

(np.int8|16|32|64(5)表示np.int8(5)和np.int32(5)等行为相同)

相关讨论

1
2
>>> isinstance(3, int)
True

更多信息请参见此处。

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

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

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

token so reply:您确定应该检查它的类型吗？要么不要传递您无法处理的类型，要么不要试图胜过您潜在的代码重用器，它们可能有一个很好的理由不将int传递给您的函数。

相关讨论

为什么不尝试一下：

1
if x%1 == 0:
相关讨论

与其过于复杂，不如简单一点

1
if type(var) is int:
相关讨论

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

1
2
3
4
5
test = input("Enter some text here:")
if test.isdigit() == True:
   print("This is a number.")
else:
   print("This is not a number.")
相关讨论

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

有人指出，针对int和long的类型检查可能会释放遇到大十进制数的情况。完全正确。

有人指出，你应该"只做x + 1"，看看是否失败。好吧，首先，这也适用于浮点数，另一方面，很容易构造一个绝对不是非常数字的类，但在某种程度上定义了+操作符。

我不同意许多文章大力声明不应该检查类型。好吧，gvr曾经说过这样的话，在纯粹的理论中，这可能是对的，但实际上，isinstance常常起到了一个有用的作用(那是不久前的事了，没有联系；你可以在这篇文章中读到gvr对相关问题的看法)。

有趣的是，有多少人似乎认为op的目的是检查给定x的类型是否为数字整数类型。我理解的是，当使用op的词时，通常的意思是：x是否表示整数。这可能非常重要：就像问某人要挑选多少个项目一样，你可能要检查你是否得到了一个非负整数。像这样的用例比比皆是。

在我看来，同样重要的是要看到：(1)类型检查仅仅是对程序正确性的一个非常粗略的度量，因为(2)它通常是有界值，这是有意义的，而越界值则是无稽之谈。有时，只有一些间断值才有意义，比如考虑所有的数字，在给定的情况下，只有那些实数(非复数)整数才有可能。

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

相关讨论

如果您想检查一个字符串是否只包含数字，但是转换为int并没有帮助，您可以始终使用regex。

1
2
3
4
5
6
7
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，但在此过程中数据也将丢失。使用regex并捕获attributeError将允许您确认字符串中以0开头的数字字符。

如果您不希望它抛出一个attributeError，而是只想寻找更具体的问题，您可以更改regex并检查匹配：

1
2
3
4
5
6
7
8
9
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。

相关讨论

在这里发现了一个相关的问题。

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

1
2
3
4
5
>>> i = 12345
>>> type(i)
<type 'int'>
>>> type(i) is int
True
相关讨论

为什么不检查您要检查的值是否等于其自身，并将其转换为整数，如下所示？

1
2
def isInt(val):
    return val == int(val)
相关讨论

如果变量是以字符串形式输入的(例如'2010'：

1
2
3
4
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))，但它的代码更长。我想知道资源的使用和速度是否有什么不同。

相关讨论

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

1
2
3
4
5
6
7
8
9
10
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
相关讨论

使用int函数帮助

1
2
3
4
5
6
7
8
9
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')

如果不考虑python版本(2.x对3.x)，请使用six(pypi)，它的integer_types属性：

1
2
3
4
import six

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

在six中(一个非常轻的单文件模块)，只需执行以下操作：

1
2
3
4
5
6
7
import sys
PY3 = sys.version_info[0] == 3

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

如果你只需要这个值，我认为operator.index(__index__特殊方法)是可行的。因为它应该适用于可以安全地转换为整数的所有类型。也就是说，浮点数失败，整数，甚至不通过duck类型实现整数抽象类的奇特整数类。

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

事实上，如果您希望确定由于截断问题等导致的浮点被拒绝，并且它与所有整型(即numpy等)一起工作，即使它们可能(还)不支持抽象类，那么这是获取整数值的唯一正确方法。

这就是__index__推出的目的！

相关讨论

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

1
2
3
4
if this_variable % 1 == 0:
    list.append(this_variable)
else:
    print 'Not an Integer!'
相关讨论

在麻木的支票面前…

1
isinstance(var, numbers.Integral)

…(慢)或…

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

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

(PY3中删除long)

从任何地方识别任何类似于整数的物体都是一个复杂的猜测游戏。检查

1
var & 0 == 0

因为事实和非例外可能是一个很好的赌注。同样，以独占方式检查有符号整数类型：

1
var ^ -1 ==  -var - 1

如果您正在从一个文件中读取数据，并且您有一个具有多个数据类型值的数组或字典，那么下面的内容将非常有用。只需检查变量是否可以类型化为int(或者您想要强制的任何其他数据类型)。

1
2
3
4
5
try :
    int(a);
    #Variable a is int
except ValueError :
    # Variable a is not an int
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#!/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)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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!")

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

相关讨论

一种更通用的方法，将尝试检查作为字符串给出的整数和整数。

1
2
3
4
5
6
7
8
9
10
11
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

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

1
2
3
var = 15.4
if(var - int(var) != 0):
    print"Value is not integer"
相关讨论

最简单的方法是：

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

其中n是变量

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

1
2
3
4
5
def is_int(x):
    if x - round(x) == 0 :
        return True
    else:
        return False

您可以通过以下方式完成此操作：

1
2
3
4
5
name = 'Bob'
if type(name) == str:
    print 'this works'
else:
    print 'this does not work'

它会返回"这作品"…但是，如果您将名称更改为int(1)，那么它将返回"这不起作用"，因为它现在是一个字符串…您也可以尝试：

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

同样的事情也会发生

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

例如：

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

你可以这样做。

1
if type(x) is int:
1
2
3
4
5
6
7
8
9
#######################################
# Value_Is_Int
#######################################
def value_is_int(value):
    try:
        tempVal = int(value)
        return True
    except:
        return False

调用此函数：

1
2
3
4
if value_is_int(value):
    print"Integer"
else:
    print"Not integer"

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

1
2
def is_digit(str):
      return str.isdigit()
1
2
3
4
if type(input('enter = '))==int:
     print 'Entered number is an Integer'
else:
     print 'Entered number isn't an Integer'

这将检查数字是否为整数。

如果要编写与python 2-3兼容的代码

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 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

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

会工作。

签入python非常简单。您可以这样做：

假设您想检查一个变量是否为整数！

1
2
3
4
5
6
## 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.*一起使用)

1
2
3
4
5
6
7
8
text = get_text()

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

do_something(text)

考虑情况x=n**(1.0/m)，其中n=10**5，m=5。在python中，x将是10.000000000000000002，由于浮点算术运算，它不是整数。

所以我会检查

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

我用以下代码测试过它：

1
2
3
4
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的真值。

相关讨论

1
2
3
4
import numpy as np

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

您可以使用此功能：

1
2
3
4
def is_int(x):    
    if type(x) == int:
       return True
    return False

测试：

1
2
3
4
print is_int('7.0') # False
print is_int(7.0) # False
print is_int(7.5) # False
print is_int(-1) # True
相关讨论

我以前有过这样的问题，如果你的类型在if语句中使用它，并且假设你想要它在return true语句中使用，那么你将把它输入到一行中，(在所有真正需要查看的内容中的底线)：

1
2
3
4
5
6
7
8
9
10
11
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，如果你知道我的意思的话)。

相关讨论

从未。检查。类型。

这样做。总是。

1
2
3
4
try:
    some operation that"requires" an integer
except TypeError, e:
    it wasn't an integer, fail.
相关讨论