Введение
В этом практическом занятии (лабораторной работе) вы научитесь проверять, имеет ли число с плавающей запятой (float) дробную часть в Python, решив проблемы, связанные с представлением чисел с плавающей запятой. В начале занятия мы рассмотрим неисправность, присущую числам с плавающей запятой, и ее влияние на прямые сравнения. Вы создадите скрипт на Python, чтобы увидеть, как простые вычисления, такие как 0.1 + 0.2, могут давать значения, немного отличающиеся от ожидаемых, что приводит к неожиданным результатам сравнения.
Затем в рамках занятия вы изучите два метода определения, представляет ли число с плавающей запятой целое число: использование метода is_integer() и сравнение числа с плавающей запятой с его целочисленным преобразованием. Эти методы предоставляют практические решения для точного определения чисел с плавающей запятой без дробной части, несмотря на ограничения базового представления.
Исследуйте представление чисел с плавающей запятой
На этом этапе вы узнаете, как числа с плавающей запятой представлены в 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), для точной оценки равенства чисел с плавающей запятой.
