Проверка, является ли переменная целым числом или нет
Как проверить, является ли переменная целым числом?
41 ответ
Если вам нужно сделать это, сделайте
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вместо того, чтобы предписывать, что это будет один.
НО
Классический менталитет Python, однако, заключается в том, что проще просить прощения, чем разрешения. Другими словами, не проверяйте, x целое число; предположите, что это так, и поймайте результаты исключения, если это не так:
try:
x += 1
except TypeError:
...
Этот менталитет постепенно преодолевается использованием абстрактных базовых классов, которые позволяют точно регистрировать, какими свойствами должен обладать ваш объект (добавляя "умножение", удвоение "), наследуя его от специально сконструированного класса. Это было бы наилучшим решением, так как оно разрешит именно те объекты с необходимыми и достаточными атрибутами, но вам придется прочитать документы о том, как его использовать.
Вот краткое изложение различных методов, упомянутых здесь:
int(x) == xtry x = operator.index(x)isinstance(x, int)isinstance(x, numbers.Integral)
и вот как они применяются к множеству числовых типов, которые имеют целочисленное значение:
Вы можете видеть, что они не на 100% последовательны. Фракция и Рациональное концептуально одинаковы, но один .index() метод, а другой нет. Сложные типы не любят преобразовывать в int, даже если действительная часть является целой, а мнимая часть равна 0.
(np.int8|16|32|64(5) Значит это np.int8(5), np.int32(5)и т.д. все ведут себя одинаково)
Все предлагаемые ответы до сих пор, кажется, пропускают тот факт, что double (числа с плавающей точкой в python на самом деле являются double) также может быть целым числом (если оно не имеет ничего после десятичной запятой). Я использую встроенный is_integer() метод на удваивается, чтобы проверить это.
Пример (сделать что-то каждый раз в цикле for):
for index in range(y):
# do something
if (index/x.).is_integer():
# do something special
Редактировать:
Вы всегда можете преобразовать в число с плавающей точкой перед вызовом этого метода. Три возможности:
>>> float(5).is_integer()
True
>>> float(5.1).is_integer()
False
>>> float(5.0).is_integer()
True
В противном случае, вы можете проверить, является ли это int первым, как сказал Агостино:
def is_int(val):
if type(val) == int:
return True
else:
if val.is_integer():
return True
else:
return False
Если вам действительно нужно проверить, то лучше использовать абстрактные базовые классы, а не конкретные классы. Для целого числа это будет означать:
>>> import numbers
>>> isinstance(3, numbers.Integral)
True
Это не ограничивает проверку только int, или просто int а также long, но также позволяет работать другим определяемым пользователем типам, которые ведут себя как целые числа.
>>> isinstance(3, int)
True
Смотрите здесь для получения дополнительной информации.
Обратите внимание, что это не поможет, если вы ищете intподобные атрибуты. В этом случае вы также можете проверить long:
>>> isinstance(3L, (long, int))
True
Я видел проверки такого рода на тип массива / индекса в исходном коде Python, но я не думаю, что это видно за пределами C.
Токен ТАК ответ: Вы уверены, что должны проверять его тип? Либо не передавайте тип, который вы не можете обработать, либо не пытайтесь перехитрить ваших потенциальных повторных пользователей кода, у них может быть веская причина не передавать int в вашу функцию.
Вместо того, чтобы усложнять вещи, почему бы не просто
if type(var) is int:
Простой метод, который я использую во всех моих программах, заключается в следующем. Он проверяет, состоит ли переменная из чисел.
test = input("Enter some text here: ")
if test.isdigit() == True:
print("This is a number.")
else:
print("This is not a number.")
Вы также можете использовать str.isdigit, Попробуйте поискать help(str.isdigit)
def is_digit(str):
return str.isdigit()
Нашел связанный вопрос здесь на самом SO.
Разработчики Python предпочитают не проверять типы, а выполнять специфическую для типа операцию и ловить TypeError исключение. Но если вы не знаете тип, то у вас есть следующее.
>>> i = 12345
>>> type(i)
<type 'int'>
>>> type(i) is int
True
Действительно поразительно видеть такую горячую дискуссию, возникающую, когда задают такой простой, действительный и, как мне кажется, обыденный вопрос.
некоторые люди отметили, что проверка типа против int (а также long) может потерять случаи, когда встречается большое десятичное число. Совершенно верно.
некоторые люди отметили, что вы должны "просто сделать x + 1 и посмотрим, не получится ли это. ну, во-первых, это работает и для чисел с плавающей точкой, и, с другой стороны, легко создать класс, который определенно не очень числовой, но определяет + оператор в некотором роде.
я не согласен со многими сообщениями, энергично заявляя, что вы не должны проверять типы. хорошо, GvR однажды сказал что-то о том, что в чистой теории это может быть правильно, но на практике, isinstance часто служит полезной цели (это давным-давно, у вас нет ссылки; вы можете прочитать, что GvR говорит о связанных проблемах в подобных сообщениях).
Что смешно, так это то, что многие люди предполагают, что целью ОП было проверить, является ли тип данного x является числовым целочисленным типом - то, что я понял, это то, что я обычно имею в виду, используя слова ОП: x представляет целое число. и это может быть очень важно: например, спросить кого-нибудь, сколько предметов они хотели бы выбрать, вы можете проверить, получили ли вы неотрицательное целое число обратно. таких случаев достаточно.
Также, на мой взгляд, важно видеть, что (1) проверка типов является ОДНОЙ - и часто довольно грубой - мерой правильности программы, потому что (2) часто имеют смысл ограниченные значения и значения, выходящие за пределы которые делают глупости. иногда имеют смысл только некоторые прерывистые значения - например, учитывая все числа, в данном случае возможны только действительные (не сложные) целые числа.
забавный не один, кажется, упоминает проверку x == math.floor( x ), если это приведет к ошибке с каким-то большим десятичным классом, ну, может быть, пришло время переосмыслить парадигмы ООП. есть также PEP 357, который рассматривает, как использовать не так очевидно,int-но-конечно-целочисленные значения, которые будут использоваться в качестве индексов списка. не уверен, нравится ли мне решение.
Если вы хотите проверить, что строка состоит только из цифр, но преобразование в 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.
Это очень просто проверить в 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")
Почему бы просто не проверить, равно ли значение, которое вы хотите проверить, самому себе в виде целого числа, как показано ниже?
def isInt(val):
return val == int(val)
Если вы читаете из файла и у вас есть массив или словарь со значениями нескольких типов данных, будет полезно следующее. Просто проверьте, может ли переменная быть приведена к типу int(или к любому другому типу данных, который вы хотите применить) или нет.
try :
int(a);
#Variable a is int
except ValueError :
# Variable a is not an int
При наличии NumPy проверить, как..
isinstance(var, numbers.Integral)
.. (медленно) или..
isinstance(var, (int, long, np.integer))
.. чтобы соответствовать всем вариантам типа как np.int8, np.uint16...
(падение long в PY3)
Распознать ЛЮБОЙ целочисленный объект из любого места - сложная игра в догадки. проверка
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) # True
is_int(7.5) # False
is_int(-1) # True
Простой способ сделать это - напрямую проверить, равен ли остаток от деления на 1 0 или нет.
if this_variable % 1 == 0:
list.append(this_variable)
else:
print 'Not an Integer!'
Если переменная вводится как строка (например, '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)), но это был более длинный код. Интересно, есть ли разница в использовании ресурсов или скорости.
Если вам просто нужно значение, operator.index (__index__ специальный метод) это путь, по моему мнению. Так как он должен работать для всех типов, которые можно безопасно привести к целому числу. Т.е. с плавающей точкой не работают, целые числа, даже причудливые целочисленные классы, которые не реализуют абстрактный класс Integral, работают с помощью утиной типизации.
operator.index это то, что используется для индексации списков и т. д. И, на мой взгляд, его следует использовать для гораздо большего / продвижения.
На самом деле, я бы сказал, что это единственный правильный способ получить целочисленные значения, если вы хотите быть уверены, что числа с плавающей запятой из-за проблем с усечением и т. Д. Отклоняются и работают со всеми целочисленными типами (т. Е. С числами и т. Д.), Даже если они могут (пока) не поддерживать абстрактный класс.
Это то, что __index__ был введен для!
Если вы хотите проверить, не обращая внимания на версию Python (2.x против 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)
Используйте функцию 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')
#!/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)
Более общий подход, который попытается проверить как целые числа, так и целые числа, заданные в виде строк, будет
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
#######################################
# 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"
Если вы хотите написать 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):
...
Я писал программу, чтобы проверить, было ли число квадратным, и столкнулся с этой проблемой, код, который я использовал:
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!")
Чтобы определить, было ли число целым числом, я преобразовал число с плавающей точкой, полученное из квадратного корня пользовательского ввода, в округленное целое число (сохраненное как значение), если эти два числа были равны, то первое число должно быть целым числом, что позволяет Программа для ответа. Это может быть не самый короткий способ сделать это, но это сработало для меня.
Если у вас нет int, вы можете сделать это:
var = 15.4
if(var - int(var) != 0):
print "Value is not integer"
Проверка, является ли объект строкой (работает с Python 2.* и Python 3.*)
text = get_text()
try:
text = text+""
except:
return "Not a string"
do_something(text)