Как проверить, является ли переменная целой?
Проверка того, является ли переменная целой или нет
Ответ 1
Если вам нужно это сделать, сделайте
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, вместо того, чтобы указывать, что он один.
НО
Однако классический менталитет Питона состоит в том, что легче просить прощения, чем разрешения. Другими словами, не проверяйте, является ли x целым числом; предположим, что это и поймать результаты исключения, если это не так:
try:
x += 1
except TypeError:
...
Этот менталитет постепенно преодолевается использованием абстрактных базовых классов, которые позволяют вам точно регистрировать, какие свойства должен иметь ваш объект (добавив "умножение? Удвоение?"), Заставив его наследовать от специально созданного класса. Это было бы лучшим решением, так как оно позволит точно этим объектам с необходимыми и достаточными атрибутами, но вам придется прочитать документы о том, как их использовать.
Ответ 2
Все предлагаемые ответы до сих пор, похоже, не учитывают тот факт, что двойной (float in python фактически удваивает) также может быть целым числом (если после десятичной точки он ничего не имеет). Для проверки этого я использую встроенный метод is_integer() для двойников.
Пример (делать что-то каждый раз в цикле for):
for index in range(y):
# do something
if (index/x.).is_integer():
# do something special
Edit:
Вы можете всегда конвертировать в float перед вызовом этого метода. Три возможности:
>>> float(5).is_integer()
True
>>> float(5.1).is_integer()
False
>>> float(5.0).is_integer()
True
В противном случае вы можете проверить, является ли он первым, как сказал Агостино:
def is_int(val):
if type(val) == int:
return True
else:
if val.is_integer():
return True
else:
return False
Ответ 3
Если вам действительно нужно проверить, лучше использовать абстрактные базовые классы, а не конкретные классы. Для целого числа, которое будет означать:
>>> import numbers
>>> isinstance(3, numbers.Integral)
True
Это не ограничивает проверку только int или просто int и long, но также позволяет другим пользовательским типам вести себя как целые числа.
Ответ 4
Здесь приведено описание различных методов, упомянутых здесь:
-
int(x) == x -
try x = operator.index(x) -
isinstance(x, int) -
isinstance(x, numbers.Integral)
и здесь, как они применяются к множеству числовых типов, которые имеют целочисленное значение:
Вы можете видеть, что они не соответствуют 100%. Фракция и Rational концептуально одинаковы, но один поставляет метод .index() а другой - нет. Сложные типы не любят преобразовывать в int, даже если действительная часть является интегральной, а мнимая часть равна 0.
(np.int8|16|32|64(5) означает, что np.int8(5), np.int32(5) и т.д. все ведут себя одинаково)
Ответ 5
>>> isinstance(3, int)
True
Подробнее см. здесь.
Обратите внимание, что это не помогает, если вы ищете атрибуты int -like. В этом случае вы также можете проверить long:
>>> isinstance(3L, (long, int))
True
Я видел проверки такого рода против типа массива/индекса в источнике Python, но я не думаю, что это видно за пределами C.
Ответ Token SO: Вы уверены, что вам нужно проверить его тип? Либо не пропустите тип, который вы не можете обработать, либо не пытайтесь перехитрить потенциальные повторители кода, у них может быть хорошая причина не передавать int в вашу функцию.
Ответ 6
Почему бы не попробовать что-то вроде:
if x%1 == 0:
Ответ 7
Вместо того, чтобы усложнять вещи, почему не просто
if type(var) is int:
Ответ 8
Простым методом, который я использую во всем своем программном обеспечении, является это. Он проверяет, состоит ли переменная из чисел.
test = input("Enter some text here: ")
if test.isdigit() == True:
print("This is a number.")
else:
print("This is not a number.")
Ответ 9
действительно поразительно видеть такую горячую дискуссию, когда возникает вопрос о таком базовом, действительном и, верьте, мирском вопросе.
некоторые люди указали, что проверка типов на int (и long) может привести к сбоям в случаях, когда встречается большое десятичное число. совершенно правильно.
некоторые люди указали, что вы должны "просто сделать x + 1 и посмотреть, не сработает ли это. хорошо, во-первых, это работает и на поплавках, и, с другой стороны, легко построить класс, который определенно не очень числен, но каким-то образом определяет оператор +.
Я не согласен со многими сообщениями, решительно заявляющими, что вы не должны проверять типы. ну, GvR однажды сказал что-то о том, что в чистой теории это может быть правильно, но на практике isinstance часто служит полезной цели (что некоторое время назад не было ссылки, вы можете прочитать, что говорит GvR о связанных с этим проблемах в сообщениях, подобных этому).
Что смешно, так это то, как многие люди полагают, что целью OP было проверить, является ли тип заданного x числовым целым типом - то, что я понял, - это то, что я обычно имею в виду при использовании слов OP: x представляет собой целое число. и это может быть очень важно: например, спросите кого-нибудь, сколько предметов они захотят выбрать, вы можете проверить, что вы вернули неотрицательный целочисленный номер. таких случаев много.
это также, на мой взгляд, важно видеть, что проверка типа (1) - это только ОДИН - и часто довольно грубая мера правильности программы, потому что (2) часто ограниченные значения имеют смысл и выходят из - значения, которые делают вздор. иногда только некоторые прерывистые значения имеют смысл, например, учитывая все числа, только реальные (не сложные), целые числа могут быть возможны в данном случае.
Смешной не-один, кажется, упоминает проверку для x == math.floor( x ). если это должно дать ошибку с некоторым большим десятичным классом, ну, может быть, пора передумать парадигмы ООП. существует также PEP 357, в котором рассматриваются как использовать значения не так явно - int -but-sure-integer-like, которые будут использоваться в качестве индексов списка. не уверен, нравится ли мне решение.
Ответ 10
Нашел связанный вопрос здесь, на самой SO.
Разработчики Python предпочитают не проверять типы, а выполнять операцию типа и улавливать исключение TypeError. Но если вы не знаете тип, то у вас есть следующее.
>>> i = 12345
>>> type(i)
<type 'int'>
>>> type(i) is int
True
Ответ 11
Если вы хотите проверить, что строка состоит только из цифр, но преобразование в 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 были "привет", преобразование его в числовой тип вызовет 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.
Ответ 12
Почему бы просто не проверить, действительно ли значение, которое вы хотите проверить, равно самому литому как целое число, как показано ниже?
def isInt(val):
return val == int(val)
Ответ 13
Если переменная вводится как строка (например, '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)), но это был более длинный код. Интересно, есть ли разница в использовании ресурсов или скорости.
Ответ 14
Вот простой пример того, как вы можете определить целое число
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
Ответ 15
Если вы читаете из файла, и у вас есть массив или словарь со значениями нескольких типов данных, будет полезно следующее. Просто проверьте, может ли переменная быть введена в тип int (или любой другой тип данных, который вы хотите применить) или нет.
try :
int(a);
#Variable a is int
except ValueError :
# Variable a is not an int
Ответ 16
используйте функцию 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')
Ответ 17
Если вам просто нужно значение, operator.index (__index__ специальный метод) - это путь, на мой взгляд. Так как он должен работать для всех типов, которые можно безопасно отличить от целого. То есть float fail, целые числа, даже причудливые целые классы, которые не реализуют работу абстрактного класса Integral с помощью утиного ввода.
operator.index - это то, что используется для индексации списков и т.д. И, на мой взгляд, оно должно использоваться для гораздо большего/продвинутого.
На самом деле я бы сказал, что это единственный правильный способ получить целочисленные значения, если вы хотите быть уверенным, что плавающие точки из-за усечения проблем и т.д. отвергаются и работают со всеми интегральными типами (т.е. numpy и т.д.), даже если они не могут (пока) поддерживать абстрактный класс.
Это то, что было введено __index__ для!
Ответ 18
Если вы хотите проверить, не учитывая версию 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)
Ответ 19
Простой способ сделать это - проверить, остается ли остаток в делении на 1 равным 0 или нет.
if this_variable % 1 == 0:
list.append(this_variable)
else:
print 'Not an Integer!'
Ответ 20
При наличии numpy проверьте, как..
isinstance(var, numbers.Integral)
.. (медленный) или..
isinstance(var, (int, long, np.integer))
.., чтобы соответствовать всем типам типа np.int8, np.uint16,...
(Drop long в PY3)
Признание ЛЮБОГО целочисленного объекта из любой точки - это сложная игра с угадыванием. Проверка
var & 0 == 0
для истины и не исключение может быть хорошей ставкой. Аналогично, проверка только целочисленного типа со знаком:
var ^ -1 == -var - 1
Ответ 21
Я писал программу, чтобы проверить, является ли число квадратным, и я столкнулся с этой проблемой, код, который я использовал, был:
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 a square number, and its root is")
print (num)
else:
print ("It not a square number, but its root is")
print (num)
else:
print ("That not a positive number!")
Чтобы узнать, было ли число целочисленным, я преобразовал число с плавающей точкой, которое вы получаете от квадратного корневого ввода пользователя в округленное целое (хранится как значение), если эти два числа были равны, то первое число должно было быть целым числом, что позволяет программе реагировать. Это может быть не самый короткий способ сделать это, но это сработало для меня.
Ответ 22
#!/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)
Ответ 23
Если у вас нет int, вы можете сделать только это:
var = 15.4
if(var - int(var) != 0):
print "Value is not integer"
Ответ 24
Более общий подход, который попытается проверить как целые числа, так и целые числа, заданные как строки, будет
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
Ответ 25
Самый простой способ:
if n==int(n):
--do something--
Где n - переменная
Ответ 26
Вы также можете использовать str.isdigit. Попробуйте найти help(str.isdigit)
def is_digit(str):
return str.isdigit()
Ответ 27
вы можете сделать это:
name = 'Bob'
if type(name) == str:
print 'this works'
else:
print 'this does not work'
и он вернет "это работает"... но если вы измените имя на int (1), тогда он вернет "это не работает", потому что теперь это строка... вы также можете попробовать:
name = int(5)
if type(name) == int:
print 'this works'
else:
print 'this does not work'
и то же самое произойдет
Ответ 28
Существует еще одна опция проверки типа.
Например:
n = 14
if type(n)==int:
return "this is an int"
Ответ 29
Вы можете это сделать.
if type(x) is int:
Ответ 30
Рассмотрим случай x = n ** (1,0/m), где n = 10 ** 5, m = 5. В Python x будет 10.000000000000002, который не является целым числом из-за арифметических операций с плавающей запятой.
Итак, я бы проверил
if str(float(x)).endswith('.0'): print "It 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')
Он выводит True для всех a и b.