Python предоставляет несколько способов определить, является ли значение целым числом. Наиболее прямой из них – использование функции isinstance(). Она позволяет проверить, принадлежит ли объект к типу int: isinstance(x, int). Этот метод корректно работает с целыми числами, включая отрицательные значения и ноль.
Если переменная может быть представлена в виде числа, но передаётся в виде строки, потребуется предварительно привести её к числовому типу с помощью int() или float(), а затем провести проверку. Например: x = float(s); x.is_integer(). Метод is_integer() у объектов типа float возвращает True, если число не имеет дробной части.
При работе с пользовательским вводом часто возникает необходимость обрабатывать ошибки преобразования. В таких случаях целесообразно использовать конструкцию try…except, чтобы перехватить исключение ValueError, если строка не может быть преобразована в число: try: int(s) except ValueError: ....
Для более строгой проверки без преобразования типов можно использовать регулярные выражения. Например, re.fullmatch(r"-?\d+", s) проверяет, состоит ли строка только из цифр и, возможно, минуса в начале. Это исключает числа с плавающей точкой и научную нотацию.
Проверка типа с помощью isinstance()
Если переменная x содержит целое число, результат будет True. Например: isinstance(7, int) возвращает True, а isinstance(7.0, int) – False, поскольку 7.0 относится к типу float.
Проверка с isinstance() надёжнее, чем сравнение типов через type(), поскольку учитывает наследование. Например, bool является подклассом int, поэтому isinstance(True, int) тоже возвращает True. Если требуется исключить логические значения, дополнительно проверяют not isinstance(x, bool).
Пример проверки, исключающей bool:
def is_integer(value):
return isinstance(value, int) and not isinstance(value, bool)
Такой подход надёжен при валидации данных, особенно если тип данных может быть неочевидным.
Как отличить целое число от числа с плавающей запятой
В Python тип данных целого числа – int, а числа с плавающей точкой – float. Для определения типа можно использовать встроенную функцию type(). Пример:
type(10) # вернёт <class 'int'>
type(10.0) # вернёт <class 'float'>
Если переменная уже задана, то различие удобно проверять через isinstance():
isinstance(x, int) # True, если x – целое число
isinstance(x, float) # True, если x – число с плавающей точкой
Числа с плавающей точкой иногда выглядят как целые, но остаются float. Например, 10.0 – это float, несмотря на отсутствие дробной части. Для проверки, представимо ли float как целое, используют метод is_integer():
(10.0).is_integer() # True
(10.5).is_integer() # False
Также полезна функция math.modf(), которая возвращает дробную и целую части числа:
import math
math.modf(7.0) # (0.0, 7.0)
math.modf(7.2) # (0.1999999999999993, 7.0)
Если первая часть результата – ноль, число можно трактовать как целое по значению, но тип всё равно останется float. Для приведения float к int используют int(), но это отбрасывает дробную часть без округления.
int(9.8) # 9
Проверка, является ли строка представлением целого числа
Для проверки, может ли строка быть преобразована в целое число, чаще всего используют метод str.isdigit(). Однако он подходит только для положительных чисел без знака. Для более универсального подхода используют блок try-except с попыткой преобразовать строку через int().
'42'.isdigit()вернётTrue'-42'.isdigit()вернётFalse'0032'тожеTrue, так как ведущие нули допустимы
Надёжный способ с использованием int():
def is_integer_string(s):
try:
int(s)
return True
except ValueError:
return False
is_integer_string('123')→Trueis_integer_string('-123')→Trueis_integer_string('12.3')→Falseis_integer_string('abc')→False
Проверка с регулярными выражениями:
import re
def is_integer_string_regex(s):
return bool(re.fullmatch(r'[+-]?\d+', s))
- Поддерживаются знаки
+и- - Строка должна состоять только из цифр (после знака)
Метод с int() предпочтительнее: он обрабатывает пробелы и исключает ошибочные случаи вроде '1_000', которые регулярное выражение может не уловить без доработки.
Использование метода float.is_integer() для проверки
Метод float.is_integer() применяется к значениям типа float и возвращает True, если число не имеет дробной части. Это не означает, что значение принадлежит типу int, но позволяет проверить, представлено ли вещественное число как целое.
Пример:
x = 10.0
if isinstance(x, float) and x.is_integer():
print("Целое число")
else:
print("Не целое")
Метод следует использовать только при работе с числами типа float. Если переменная имеет тип int, вызов is_integer() вызовет ошибку. Для универсальности рекомендуется сначала проверить тип с помощью isinstance(x, float).
Следует учитывать, что из-за особенностей представления чисел с плавающей точкой, проверка может дать неожиданный результат при работе с числами, полученными в результате вычислений:
x = 0.1 + 0.2 # x = 0.30000000000000004
print(x.is_integer()) # False
Для таких случаев перед проверкой допустимо округление:
rounded = round(x, 10)
if rounded.is_integer():
print("Целое после округления")
float.is_integer() подходит для случаев, когда необходимо отличить целое представление от дробного внутри чисел типа float, без преобразования типов.
Как обрабатывать исключения при попытке преобразования
При попытке преобразовать значение в целое число с помощью int() может возникнуть исключение ValueError, если строка не содержит корректное представление числа, или TypeError, если передан неподходящий тип данных.
Чтобы избежать аварийного завершения программы, используйте конструкцию try-except:
def is_integer(value):
try:
int(value)
return True
except (ValueError, TypeError):
return False
Рекомендуется обрабатывать оба типа исключений, так как:
ValueErrorвозникает при попытке преобразовать, например,"abc"или"12.3";TypeErrorможет быть вызван передачейNone, списка или словаря.
Если нужно не просто проверить, а получить результат преобразования, используйте следующий подход:
def try_parse_int(value, default=None):
try:
return int(value)
except (ValueError, TypeError):
return default
Такой способ позволяет задать возвращаемое значение при неудачном преобразовании, что удобно при обработке пользовательского ввода или данных из внешних источников.
Избегайте перехвата всех исключений без указания типа (except:) – это мешает отладке и может скрыть другие ошибки.
Проверка целочисленности результата арифметических операций
Первый способ – использование оператора % (остаток от деления). Если остаток от деления результата операции на 1 равен нулю, то результат является целым числом. Например, при делении нацело, можно проверить остаток следующим образом:
result = 10 / 2
if result % 1 == 0:
print("Результат целый")Второй способ – применение функции is_integer() объекта типа float. Эта функция возвращает True, если значение является целым числом (в формате с плавающей точкой), и False в противном случае. Пример:
result = 10 / 2
if result.is_integer():
print("Результат целый")Третий способ – использование функции int() для явного преобразования результата. При этом можно проверить, совпадает ли преобразованное значение с исходным:
result = 10 / 2
if result == int(result):
print("Результат целый")Важно отметить, что при делении целых чисел, результат может быть в формате float. Поэтому, чтобы избежать ошибок, необходимо всегда проверять, является ли результат целым числом после операции деления.
В случаях, когда операция может привести к потере точности (например, при делении чисел с плавающей точкой), можно использовать проверку с погрешностью, если значения могут быть близки к целому числу, но с небольшими погрешностями.
Загрузка...
