Как проверить, является ли переменная целым числом?
Если вам необходимо это сделать, сделайте
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:
...
Этот менталитет постепенно преодолевается использованием абстрактных базовых классов, которые позволяют вам регистрировать точные свойства, которыми должен обладать ваш объект (сложение? умножение? удвоение?), заставляя его наследоваться от специально созданного класса. Это было бы лучшим решением, поскольку оно позволяет точно создавать объекты с необходимыми и достаточными атрибутами, но вам придется прочитать документацию о том, как его использовать.
Все предложенные ответы до сих пор, кажется, ускользнул тот факт, что двойной (плавает в Python фактически удваивается) и может быть целым (если она не имеет ничего после запятой). Я использую встроенную в is_integer()` метод двойников, чтобы проверить это.
Пример (делать что-то каждый х раз за цикл):
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
В противном случае, вы могли бы проверить, если он имеет тип 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
, а длинный
, но также позволяет другие пользовательские типы, которые ведут себя как целые числа для работы.
Здесь'ы резюме различных упомянутых здесь методов:
инт(х) == х
попробуйте X = оператора.индекс(Х)
isinstance(х, инт)
isinstance(х, цифры.Интеграл)
и здесь's, как они применяются в различных числовых типов, которые имеют целочисленные значения:
в <!-- Понятие типа int(х)==х .индекс() имеет тип int Интеграл Целых 5 Истина Истина Истина Истина НП.int8|16|32|64(5) Верно верно неверно верно sympy.Целое Число(5) Неверно Неверно НП.массив(5) неверно неверно Поплавки 5.0 Ошибку TypeError Истинное Ложное Ложное НП.массив(5.0) ошибку TypeError истинное ложное ложное НП.float16|32|64(5) ошибку TypeError истинное ложное ложное mpmath.МПФ(5) ошибку TypeError истинное ложное ложное sympy.Поплавок(5) Ошибку TypeError Истинное Ложное Ложное Комплекс 5+0j ошибку TypeError исключение TypeError ложное ложное НП.complex64|128(5) актуально (предупреждает) ошибку TypeError ложное ложное mpmath.ПДК(5) ошибку TypeError исключение TypeError ложное ложное Рациональных дробей.Часть(5) Ошибку TypeError Истинное Ложное Ложное sympy.Рациональное(5) Неверно Неверно Десятичной запятой.Десятичное(5) Ошибку TypeError Истинное Ложное Ложное
-->
Вы можете видеть, что они не'Т 100% соответствует. Дроби и рациональные концептуально одинаковы, но одна подает `.метод index () и другие не'т. Сложные типы Дон'т, как конвертировать в int, даже если реальная часть является неотъемлемой частью и мнимой частью равен 0.
(НП.int8|16|32|64(5)
это значит, что НП.int8(5),
НП.типа int32(5) и т. д. все ведут себя одинаково)
>>> isinstance(3, int)
True
Подробнее смотрите здесь.
Обратите внимание, что это не поможет, если вы ищете int
-подобные атрибуты. В этом случае вы также можете захотеть проверить наличие long
:
>>> isinstance(3L, (long, int))
True
Я'видел подобные проверки на тип массива/индекса в исходниках Python, но не думаю, что это можно увидеть за пределами C.
Ответ SO: Вы уверены, что должны проверять его тип? Либо не передавайте тип, который вы не можете обработать, либо не пытайтесь перехитрить ваших потенциальных пользователей кода, у них может быть веская причина не передавать 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.")
это's действительно ошеломляет-видеть такое бурное обсуждение идет, когда такой простой, действующий и, я считаю, мирской вопрос задают.
некоторые люди отмечают, что проверки типа против типа int
(и долго
) может потерять тех случаях, когда большие десятичные числа,. совсем правильно.
некоторые люди отмечают, что вы должны 'делаю х + 1` и убедиться в том, что не получается. ну, с одной стороны, это работает на поплавках тоже, и, с другой стороны, это'ы легко для того чтобы построить класс, который наверняка не очень числовые, но определяет оператор " + " в некотором роде.
я в ладах со многими постами решительно заявив, что вы не должны проверить видах. ну, Гвр однажды сказал что-то о том, что в чистой теории, которые могут быть правы, но на практике, `isinstance часто служит полезной цели (что'ов некоторое время назад, Дон'т иметь ссылку; вы можете прочитать, что Гвр говорит о вопросам, связанным с посты подобные этому).
что забавно, как многие люди, кажется, предположить, что ОП'с целью было проверить, является ли типа в данной X
- это числовой целочисленный тип—то, что я понял это то, что я обычно имею в виду при использовании ОП's в словах: ли х
представляет собой целое число. и это может быть очень важно: как задать кому-то, сколько элементов они'd не хочу, чтобы выбрать, вы можете хотеть проверить вас неотрицательное целое число обратно. использование таких случаев предостаточно.
это's также, на мой взгляд, важно видеть, что (1) проверка типа является лишь одной—и часто довольно грубых—мера правильности программы, потому что (2) она часто ограничена значения, которые имеют смысл, и из-за границы значений, которые делают глупости. иногда просто некоторые кратковременные значения имеет смысла—как учитывая все цифры, только те реальные (не сложные), целые числа могут быть использованы в данном случае.
смешно не кажется, что одно упоминание проверка на х == математика.пол( X )
. если это должно дать ошибку с какой-то большой класс десятичные, ну, тогда, может быть, это's время, чтобы переосмыслить ООП парадигмы. существует также ОПТОСОЗ 357, что рассматривается как использование не так очевидно-инт
-но-конечно-целое, как ценности будут использоваться в качестве индексов списка. не уверен, нравится ли мне решение.
Нашел связанный вопрос здесь, на самом SO.
Разработчики Python предпочитают не проверять типы, а делать операцию, специфичную для типа, и ловить исключение TypeError
. Но если вы не знаете тип, тогда у вас есть следующее.
>>> i = 12345
>>> type(i)
<type 'int'>
>>> type(i) is int
True
почему бы просто не проверить, если значение, которое вы хотите проверить, равен сам бросил как целое число, как показано ниже?
def isInt(val):
return val == int(val)
Если вы хотите проверить, что строка состоит только из цифр, но преобразование в инт выиграл'т помочь, вы всегда можете просто использовать регулярное выражение.
import re
x = "01234"
match = re.search("^\d+$", x)
try: x = match.group(0)
except AttributeError: print("not a valid number")
Result: x == "01234"
В этом случае, если Х "Привет", преобразования ее в числовой тип хотел кинуть ValueError, но данные могут быть потеряны в процессе. С помощью regex и ловили AttributeError позволит вам получить подтверждения числовых символов в строке, например, с ведущим 0'ов.
Если вы не'т хотите, чтобы бросить AttributeError, но вместо этого просто хотел выглядеть более конкретные проблемы, вы можете варьировать regex и просто проверить матча:
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'ов.
Вы также можете использовать НТР.isdigit
. Попробуйте найти помощи(ул. isdigit)`
def is_digit(str):
return str.isdigit()
Если переменная вводится как строка (напр.'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/за исключением
и проверяем на `(Инт(переменной)), но это было больше кода. Интересно, если там'ы никакой разницы в использовании ресурсов или скорость.
Вот простой пример, как можно определить целое число
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
Если вам просто нужно значение**, оператора.индекс(
специальный методиндекс`) является путь, на мой взгляд. Поскольку он должен работать для всех типов, которые могут быть безопасно приведены к число. Т. е. плавает плохо, целые числа, даже причудливое целое число классов, которые не реализуют целостный абстрактный класс работы с утиной типизацией.
оператора.индекс используется для индексации списка и т. д. И на мой взгляд она должна быть использована для гораздо больше, повышен.
На самом деле я утверждаю, что это единственно правильный путь, чтобы получить целые значения, если вы хотите быть уверены, что числа с плавающей запятой, из-за проблем усек, и т. д. отклоняются и он работает со всеми целыми типами (т. е. библиотеки numpy и т. д.) даже если они не могут (пока) поддерживает абстрактный класс.
Это то, что __индекс__
был представлен на!
В присутствии включает проверьте, как ..
isinstance(var, numbers.Integral)
.. (медленно) или ..
isinstance(var, (int, long, np.integer))
.. для того, чтобы соответствовать всем вариантам типа как НП.int8,
НП.типа uint16`, ...
(Падение давно
в PY3)
Признавая ни целое число-подобный объект из любой точки мира-это хитрая игра в угадайку. Проверка
var & 0 == 0
за правду и не исключение может быть хорошим выбором. Аналогично, проверка на знаковый целочисленный тип исключительно:
var ^ -1 == -var - 1
Если вы хотите проверить, не обращая внимания на Python версии (2.х против 3.х) используйте шесть
(PyPI) и это'атрибут s integer_types
:
import six
if isinstance(obj, six.integer_types):
print('obj is an integer!')
В шесть
(очень легкие-вес одного файла модуля), она's просто сделать это:
import sys
PY3 = sys.version_info[0] == 3
if PY3:
integer_types = int,
else:
integer_types = (int, long)
Если Вы читаете из файла и у вас есть массив или словарь со значениями нескольких типов, следующие будут полезны. Просто проверить, является ли переменная может быть преобразован в тип int(или любой другой тип данных, которые вы хотите реализовать) или нет.
try :
int(a);
#Variable a is int
except ValueError :
# Variable a is not an int