Как проверить, имеет ли число с плавающей запятой в Python дробную часть

Введение

В этом практическом занятии (лабораторной работе) вы научитесь проверять, имеет ли число с плавающей запятой (float) дробную часть в Python, решив проблемы, связанные с представлением чисел с плавающей запятой. В начале занятия мы рассмотрим неисправность, присущую числам с плавающей запятой, и ее влияние на прямые сравнения. Вы создадите скрипт на Python, чтобы увидеть, как простые вычисления, такие как 0.1 + 0.2, могут давать значения, немного отличающиеся от ожидаемых, что приводит к неожиданным результатам сравнения.

Затем в рамках занятия вы изучите два метода определения, представляет ли число с плавающей запятой целое число: использование метода is_integer() и сравнение числа с плавающей запятой с его целочисленным преобразованием. Эти методы предоставляют практические решения для точного определения чисел с плавающей запятой без дробной части, несмотря на ограничения базового представления.

Skills Graph

Исследование представления чисел с плавающей запятой

На этом этапе вы узнаете, как числа с плавающей запятой представлены в Python и как это представление может повлиять на числовые сравнения. Числа с плавающей запятой используются для представления вещественных чисел (чисел с десятичной точкой) в компьютерах. Однако из-за способа их хранения в памяти они часто являются приближениями реальных чисел. Это может привести к неожиданным результатам при выполнении сравнений.

Начнем с создания файла Python с именем float_representation.py в каталоге ~/project с помощью редактора VS Code.

## Create a floating-point number
x = 0.1 + 0.2

## Print the value of x
print(x)

Сохраните файл и запустите его с помощью следующей команды в терминале:

python float_representation.py

Вы, возможно, ожидаете, что вывод будет 0.3, но, скорее всего, увидите что-то вроде этого:

0.30000000000000004

Это происходит потому, что 0.1 и 0.2 не могут быть представлены точно как числа с плавающей запятой. Результат сложения - это число, очень близкое к 0.3, но не точно равное ему.

Теперь давайте посмотрим, как эта неточность может повлиять на сравнения. Добавьте следующий код в файл float_representation.py:

## Create a floating-point number
x = 0.1 + 0.2

## Check if x is equal to 0.3
if x == 0.3:
    print("x is equal to 0.3")
else:
    print("x is not equal to 0.3")

Сохраните файл и запустите его снова:

python float_representation.py

Скорее всего, вы увидите следующий вывод:

x is not equal to 0.3

Это происходит потому, что x не точно равно 0.3 из-за проблемы с представлением чисел с плавающей запятой.

Для точного сравнения чисел с плавающей запятой вы должны использовать значение допуска (tolerance). Вместо проверки на точное равенство проверяйте, является ли абсолютная разность между двумя числами меньше небольшого значения допуска.

Измените файл float_representation.py, чтобы включить значение допуска:

## Create a floating-point number
x = 0.1 + 0.2

## Define a tolerance value
tolerance = 1e-9  ## A small value like 0.000000001

## Check if x is approximately equal to 0.3
if abs(x - 0.3) < tolerance:
    print("x is approximately equal to 0.3")
else:
    print("x is not approximately equal to 0.3")

Сохраните файл и запустите его еще раз:

python float_representation.py

Теперь вы должны увидеть следующий вывод:

x is approximately equal to 0.3

Используя значение допуска, вы можете точно сравнивать числа с плавающей запятой, несмотря на неисправность, присущую их представлению. Это важное понятие, которое необходимо понять при работе с числами с плавающей запятой в Python и других языках программирования.

Использование метода is_integer()

На этом этапе вы узнаете, как использовать метод is_integer() для проверки, представляет ли число с плавающей запятой целое число. Метод is_integer() - это встроенный метод для объектов типа float в Python, который возвращает True, если число с плавающей запятой имеет целочисленное значение (то есть дробная часть равна нулю), и False в противном случае.

Создадим новый файл Python с именем is_integer_example.py в каталоге ~/project с помощью редактора VS Code.

## Example 1: Integer value
x = 5.0
print(x.is_integer())

## Example 2: Non-integer value
y = 3.14
print(y.is_integer())

## Example 3: Another integer value
z = -2.0
print(z.is_integer())

Сохраните файл и запустите его с помощью следующей команды в терминале:

python is_integer_example.py

Вы должны увидеть следующий вывод:

True
False
True

Как вы можете видеть, is_integer() возвращает True для 5.0 и -2.0, потому что они представляют целые числа, и False для 3.14, потому что оно имеет дробную часть.

Теперь рассмотрим проблему представления чисел с плавающей запятой, о которой мы говорили на предыдущем этапе. Иногда число, которое должно быть целым, может не быть представлено точно из-за неточности представления чисел с плавающей запятой.

Измените файл is_integer_example.py, добавив следующий код:

## Example 4: Floating-point imprecision
a = 0.1 + 0.2
print(a)
print(a.is_integer())

Сохраните файл и запустите его снова:

python is_integer_example.py

Скорее всего, вы увидите следующий вывод:

0.30000000000000004
False

Хотя математически 0.1 + 0.2 равно 0.3, представление числа с плавающей запятой делает его немного другим, поэтому is_integer() возвращает False.

Для обработки таких случаев вы можете сочетать is_integer() с проверкой на допустимую погрешность (tolerance), как мы узнали на предыдущем этапе. Однако в данном случае мы проверяем, представляет ли число целое значение, а не равно ли оно определенному значению.

В целом, метод is_integer() - полезный инструмент для определения, представляет ли число с плавающей запятой целое значение. Однако будьте осторожны с потенциальным влиянием неточности представления чисел с плавающей запятой и учитывайте эти аспекты при использовании этого метода.

Сравнение с преобразованием в int

На этом этапе вы рассмотрите другой способ проверить, представляет ли число с плавающей запятой целое значение: сравнив его с результатом преобразования в целое число с помощью функции int(). Функция int() отбрасывает дробную часть числа с плавающей запятой, фактически преобразуя его в ближайшее целое число к нулю.

Создайте новый файл Python с именем int_conversion.py в каталоге ~/project с помощью редактора VS Code.

## Example 1: Integer value
x = 5.0
if x == int(x):
    print("x is an integer")
else:
    print("x is not an integer")

## Example 2: Non-integer value
y = 3.14
if y == int(y):
    print("y is an integer")
else:
    print("y is not an integer")

## Example 3: Another integer value
z = -2.0
if z == int(z):
    print("z is an integer")
else:
    print("z is not an integer")

Сохраните файл и запустите его с помощью следующей команды в терминале:

python int_conversion.py

Вы должны увидеть следующий вывод:

x is an integer
y is not an integer
z is an integer

Этот подход работает потому, что если число с плавающей запятой уже представляет целое число, то преобразование его в целое с помощью int() не изменит его значение. Если у числа с плавающей запятой есть дробная часть, функция int() отбросит ее, в результате чего получится другое значение.

Теперь рассмотрим снова проблему представления чисел с плавающей запятой. Измените файл int_conversion.py, добавив следующий код:

## Example 4: Floating-point imprecision
a = 0.1 + 0.2
print(a)
if a == int(a):
    print("a is an integer")
else:
    print("a is not an integer")

Сохраните файл и запустите его снова:

python int_conversion.py

Скорее всего, вы увидите следующий вывод:

0.30000000000000004
a is not an integer

Как и на предыдущем этапе, неточность представления чисел с плавающей запятой делает a немного отличным от 0.3, и поэтому оно не равно результату его преобразования в целое число (которым будет 0).

Важно отметить, что использование преобразования в int() для проверки представления целого числа может быть менее точным, чем использование is_integer(). Метод is_integer() проверяет, представляет ли число с плавающей запятой целое значение, в то время как сравнение с int() проверяет, равно ли число с плавающей запятой его целой части после отбрасывания дробной части.

В целом, сравнение числа с плавающей запятой с его преобразованием в целое с помощью int() - это еще один способ проверить, представляет ли оно целое значение. Однако будьте осторожны с потенциальным влиянием неточности представления чисел с плавающей запятой и рассмотрите возможность использования is_integer() для более точных результатов.

Резюме

В этом практическом занятии (lab) вы изучили сложности представления чисел с плавающей запятой в Python и их влияние на числовые сравнения. Вы узнали, что числа с плавающей запятой часто являются приближениями действительных чисел из-за их хранения в памяти, что может привести к потенциальным неточностям при выполнении прямых проверок на равенство.

Вы заметили, что сложение 0.1 и 0.2 может не дать точно 0.3, и что прямое сравнение с использованием == может дать неожиданные результаты. В практическом занятии подчеркнута важность понимания этих ограничений и необходимость использования альтернативных методов сравнения, таких как использование значений допустимой погрешности (tolerance), для точной оценки равенства чисел с плавающей запятой.