Как узнать, что число целое в языке Python
При работе с числами в Python часто возникает необходимость определить, является ли значение целым числом. Эта задача может относиться как к типу данных (int), так и к значению числа с плавающей точкой, не имеющему дробной части. Рассмотрим несколько подходов с примерами кода.
Эффективный способ проверки целого числа
Наиболее универсальное решение объединяет проверку типа int и проверку значения для чисел с плавающей точкой:
def is_integer_number(x):
return isinstance(x, int) or (isinstance(x, float) and x.is_integer())
число ли python (проверка, является ли значение числом в python)
Функция isinstance(x, int) возвращает True, если x имеет тип int или его подкласс (например, bool). Метод float.is_integer() проверяет, что число с плавающей точкой не имеет дробной части (например, 5.0, -3.0).
Типичная ошибка
Использование type(x) == int не учитывает подклассы. Для bool это даст False, хотя логические значения считаются целыми. Функция isinstance более корректна.
Цель использования
Подходит для большинства сценариев, когда нужно узнать, представляет ли переменная целое число в математическом смысле, независимо от того, хранится ли оно как int или float.
Как проверить, что переменная имеет именно тип int, а не подкласс?
Если требуется строгое соответствие типу int, используется type(x) is int или type(x) == int.
def is_strict_int(x):
return type(x) is int
определить целое число python (определить, является ли число целым в python)
Этот способ отвергает bool, что может быть полезно, если требуется различать целые числа и логические значения.
Типичная ошибка
Забыть, что bool является подклассом int, и ожидать True для True. Для большинства приложений такое поведение нежелательно.
Цель использования
Когда необходимо идентифицировать именно целые числа без смешивания с логическими, например, в строгих проверках типов для сериализации.
Как определить, что число с плавающей точкой не имеет дробной части?
Для чисел типа float можно сравнить значение с его целой частью: x == int(x). Приведение к int отбрасывает дробную часть, и если число не изменилось, значит оно целое.
def is_integer_float(x):
if isinstance(x, float):
return x == int(x)
return False
проверить int python (проверка на целое число в python)
Недостаток: при очень больших числах float может потерять точность, и сравнение станет ненадёжным. Альтернатива - использование math.isclose.
Типичная ошибка
Применение к строкам или другим типам вызовет исключение. Необходима предварительная проверка типа.
Цель использования
Когда нужно проверить именно значение float, а не тип int, и точность не критична.
Как использовать математические функции для проверки целостности?
Функции math.floor и math.ceil возвращают ближайшее целое вниз или вверх. Если число целое, оба результата совпадают с исходным.
import math
def is_integer_math(x):
return math.floor(x) == x or math.ceil(x) == x
Однако более прямой способ - x.is_integer() для float, но он не работает для int. Функция math.modf разделяет число на дробную и целую части; если дробная часть равна 0, число целое.
def is_integer_modf(x):
fractional, _ = math.modf(x)
return fractional == 0.0
Типичная ошибка
Для int эти функции тоже работают, но результат может быть неочевиден. Например, math.floor(5) вернет 5, но сравнение с плавающей точкой может дать True. Однако лучше использовать специализированные методы.
Цель использования
Когда по каким-то причинам не хочется использовать isinstance или is_integer, или когда число может быть других типов, поддерживающих арифметику.
Как проверить, что строка представляет целое число?
Метод str.isdigit() проверяет, что все символы строки являются цифрами. Но он не учитывает знак минус и десятичную точку. Для целых чисел с возможным знаком используется регулярное выражение или попытка преобразования.
def is_integer_string(s):
try:
int(s)
return True
except ValueError:
return False
Этот способ обрабатывает отрицательные числа и пробелы (при int(' 5') тоже сработает). Использовать isdigit можно только для неотрицательных целых.
Типичная ошибка
Применение isdigit к отрицательным числам или числам с плавающей точкой даст False. Кроме того, int('') вызовет ValueError, поэтому требуется обработка исключений.
Цель использования
Когда исходные данные получены в виде строки (пользовательский ввод, чтение из файла) и требуется проверить, можно ли интерпретировать их как целое число.
Как определить, можно ли преобразовать значение в целое число без ошибки?
Использовать конструкцию try...except с int(x). Она преобразует float, строку, bool, даже комплексные числа? int(5+0j) выдаст ошибку. Но для большинства типов это сработает.
def can_be_int(x):
try:
int(x)
return True
except (ValueError, TypeError):
return False
Обратите внимание, что int(5.0) вернёт 5, а int(5.5) вызовет ValueError? Нет, int(5.5) вернёт 5, отбросив дробную часть. Поэтому этот метод не проверяет целостность значения, а только возможность преобразования. Для проверки целостности float нужно дополнительно убедиться, что x == int(x).
Типичная ошибка
Путаница между 'может быть преобразован в int' и 'является целым числом'. Например, int(5.5) успешно выполняется, но 5.5 не является целым числом.
Цель использования
Когда необходимо проверить, что значение может быть безопасно передано в функцию, ожидающую int, или когда нужно привести к int без потери информации (для float требуется дополнительная проверка).
Расширенные примеры проверки целых чисел
Пример 1: Универсальная функция для различных типов
def is_integer_number(x):
return isinstance(x, int) or (isinstance(x, float) and x.is_integer())
test_values = [5, 5.0, 5.5, True, False, '5', 5+0j, 3.14, -7, -7.0, float('inf'), float('nan')]
for v in test_values:
result = is_integer_number(v)
print(f'{v!r:15} -> {result}')
5 -> True 5.0 -> True 5.5 -> False True -> True False -> True '5' -> False (5+0j) -> False 3.14 -> False -7 -> True -7.0 -> True inf -> False nan -> False
Пример 2: Использование math.modf
import math
def is_integer_modf(x):
if not isinstance(x, (int, float)):
return False
fractional, _ = math.modf(x)
return fractional == 0.0
print(is_integer_modf(5))
print(is_integer_modf(5.0))
print(is_integer_modf(5.5))
print(is_integer_modf(-3.0))
print(is_integer_modf(0.0))
True True False True True
Пример 3: Проверка строк с помощью регулярного выражения
import re
pattern = re.compile(r'^[-+]?\\d+$')
def is_integer_regex(s):
return bool(pattern.match(s.strip()))
test_strings = ['123', '-456', '+789', '12.3', 'abc', ' -5 ', '']
for s in test_strings:
print(f'{s!r:10} -> {is_integer_regex(s)}')
'123' -> True '-456' -> True '+789' -> True '12.3' -> False 'abc' -> False ' -5 ' -> True '' -> False
Пример 4: Проверка с плавающей точкой с учётом погрешности (math.isclose)
import math
def is_integer_close(x, eps=1e-9):
if not isinstance(x, float):
return False
return math.isclose(x, round(x), rel_tol=eps, abs_tol=eps)
# Пример с потенциальной ошибкой округления
y = 2.0 ** 0.5
y_sq = y ** 2
print(y_sq)
print(y_sq == int(y_sq))
print(is_integer_close(y_sq))
2.0000000000000004 False True
Пример 5: Проверка с использованием Decimal для точности
from decimal import Decimal
def is_integer_decimal(x):
try:
d = Decimal(x)
return d == d.to_integral_value()
except:
return False
print(is_integer_decimal('5.0'))
print(is_integer_decimal('5.5'))
print(is_integer_decimal(5.0))
print(is_integer_decimal(5.5))
print(is_integer_decimal(0.1+0.2))
True False True False False