Бесконечность inf и значение nan в Python
Обновлено:
В Python у класса:
float
есть специальные значения:
inf
-inf
nan
Они относятся к вещественным числам, но обладают особым поведением.
Положительная бесконечность
1. float('inf')
Положительную бесконечность можно создать так:
positive_infinity = float('inf')
print(positive_infinity)
Результат:
inf
Строка может быть записана в разном регистре:
float('inf')
float('Inf')
float('INF')
Все варианты создают положительную бесконечность.
2. Можно написать infinity
Работает и полное слово:
float('infinity')
Например:
number = float('infinity')
print(number)
Результат:
inf
Также регистр букв не имеет значения:
float('Infinity')
float('INFINITY')
Обычно используется более короткий вариант:
float('inf')
Отрицательная бесконечность
3. Минус внутри строки
negative_infinity = float('-inf')
print(negative_infinity)
Результат:
-inf
4. Унарный минус
Можно сначала создать положительную бесконечность, а затем применить унарный минус:
negative_infinity = -float('inf')
Результат будет тем же:
-inf
То есть:
float('-inf') == -float('inf')
возвращает:
True
Обычно запись:
float('-inf')
удобно воспринимать сразу как создание отрицательной бесконечности.
math.inf
5. Бесконечность из модуля math
Положительная бесконечность есть и в модуле:
math
Например:
import math
print(math.inf)
Результат:
inf
Отрицательная:
import math
print(-math.inf)
Результат:
-inf
float('inf') и math.inf
6. Значения равны
import math
first = float('inf')
second = math.inf
print(first == second)
Результат:
True
Оба объекта представляют положительную бесконечность.
7. is здесь использовать не нужно
Например:
import math
first = float('inf')
second = math.inf
print(first is second)
В обычной реализации Python мы получим:
False
Почему?
Вызов:
float('inf')
создаёт объект float.
А:
math.inf
— это уже существующий объект, сохранённый внутри модуля math.
Поэтому два объекта могут представлять совершенно одинаковое числовое значение:
first == second
но быть разными объектами:
first is second
Напоминаем:
== → сравнивает значения
is → проверяет идентичность объектов
Для чисел используем сравнение значений:
==
а не is.
inf является float
8. Проверяем тип
number = float('inf')
print(type(number))
Результат:
<class 'float'>
То есть:
inf
— специальное значение класса:
float
То же самое относится к:
-inf
nan
Получение inf при вычислениях
9. Переполнение float
У вещественного числа существует максимальное конечное значение.
При некоторых операциях результат может оказаться слишком большим для представления обычным float.
Например:
number = 1e308
result = number * 10
print(result)
Результат:
inf
То есть математический результат оказался за пределами максимального конечного значения float, и результатом стала положительная бесконечность.
Для отрицательного значения:
number = -1e308
result = number * 10
print(result)
получим:
-inf
При этом разные операции могут вести себя по-разному: некоторые операции при слишком большом результате способны вызвать OverflowError, поэтому не следует воспринимать inf как универсальный результат любого переполнения.
Сравнение с обычными числами
10. Положительная бесконечность
infinity = float('inf')
huge_number = 9 ** 999
print(
infinity > huge_number
)
Результат:
True
Python-класс int способен хранить целые числа произвольной величины в пределах доступной памяти.
Но положительная бесконечность при числовом сравнении считается больше любого конечного числа:
... < 100 < 1_000_000 < огромное число < inf
11. Отрицательная бесконечность
negative_infinity = float('-inf')
huge_negative_number = -(9 ** 999)
print(
negative_infinity
< huge_negative_number
)
Результат:
True
То есть:
-inf < любое конечное число < inf
Операции с бесконечностью
Следующие примеры достаточно один раз посмотреть. Запоминать их все не нужно.
12. Сложение
inf = float('inf')
print(inf + 100)
Результат:
inf
13. Вычитание конечного числа
inf = float('inf')
print(inf - 1_000_000)
Результат:
inf
14. Умножение
inf = float('inf')
print(inf * 10)
Результат:
inf
А:
print(inf * -10)
Результат:
-inf
15. Бесконечность плюс бесконечность
inf = float('inf')
print(inf + inf)
Результат:
inf
16. Умножение бесконечностей
inf = float('inf')
print(inf * inf)
Результат:
inf
А:
print(
inf * float('-inf')
)
получим:
-inf
Неопределённые операции
Некоторые операции не имеют однозначного числового результата.
Например:
inf - inf
Нельзя определить, какое конечное число должно получиться.
Для таких случаев существует ещё одно специальное значение.
nan
17. Not a Number
Создать его можно:
nan = float('nan')
print(nan)
Результат:
nan
Название означает:
NaN → Not a Number
то есть:
не число.
При этом с точки зрения Python:
print(
type(float('nan'))
)
результат:
<class 'float'>
То есть nan технически является специальным значением класса float.
Особенные сравнения nan
18. Больше нуля?
nan = float('nan')
print(nan > 0)
Результат:
False
19. Меньше нуля?
print(nan < 0)
Результат:
False
20. Равно нулю?
print(nan == 0)
Результат:
False
21. nan не равен даже самому себе
nan = float('nan')
print(nan == nan)
Результат:
False
Это одно из самых необычных свойств nan.
И наоборот:
print(nan != nan)
получим:
True
Откуда появляется nan
22. Бесконечность минус бесконечность
inf = float('inf')
result = inf - inf
print(result)
Результат:
nan
23. Бесконечность делим на бесконечность
inf = float('inf')
result = inf / inf
print(result)
Результат:
nan
24. Бесконечность умножаем на ноль
inf = float('inf')
result = inf * 0
print(result)
Результат:
nan
Это неопределённые математические случаи.
Несколько операций для справки
| Выражение | Результат |
|---|---|
inf + 10 |
inf |
inf - 10 |
inf |
-inf + 10 |
-inf |
inf * 10 |
inf |
inf * -10 |
-inf |
inf + inf |
inf |
inf * inf |
inf |
100 / inf |
0.0 |
-100 / inf |
-0.0 |
inf - inf |
nan |
inf / inf |
nan |
inf * 0 |
nan |
Важно:
1 / 0
не создаёт inf.
В Python обычное деление на ноль вызывает:
ZeroDivisionError
nan и сортировка
25. С nan нужно быть осторожным
Возьмём:
nan = float('nan')
numbers = [
10,
nan,
5,
20,
]
Проблема заключается в том, что обычные сравнения с nan возвращают False:
nan < 10
nan > 10
nan == 10
все дают:
False
Поэтому алгоритмы, основанные на обычном сравнении чисел, могут давать неожиданные результаты.
Например:
sorted(numbers)
не является надёжным способом получить нормальный числовой порядок, если среди данных находится nan.
Список при этом не обязан вызвать ошибку — результат просто может не соответствовать привычному представлению о сортировке чисел.
min() и max()
26. Результат может зависеть от положения nan
Например:
nan = float('nan')
numbers = [
nan,
10,
20,
]
print(
max(numbers)
)
результат может оказаться:
nan
Проблема снова связана с необычным поведением сравнений.
Поэтому при обработке настоящих числовых данных nan обычно сначала специально обнаруживают и обрабатывают.
Для чего вообще нужен nan
nan может показаться бесполезным, но в реальных программах он встречается достаточно часто.
27. Отсутствующее числовое измерение
Представим, что датчик должен передавать температуру:
21.5
22.1
?
23.0
Одно измерение получить не удалось.
Можно представить его как:
temperatures = [
21.5,
22.1,
float('nan'),
23.0,
]
nan показывает:
Здесь должно было находиться числовое значение, но корректного результата нет.
Такое особенно часто встречается при обработке таблиц, измерений и научных данных.
28. Неопределённый результат вычисления
Например:
inf = float('inf')
result = inf / inf
У операции нет нормального конечного результата, поэтому:
result
становится:
nan
То есть nan может распространяться дальше по вычислениям и показывать, что на предыдущем этапе появился неопределённый результат.
Практическое применение inf
Бесконечность особенно удобна как стартовое значение в некоторых алгоритмах.
29. Поиск минимального числа
Предположим, нужно самостоятельно найти минимум списка.
Можно написать:
def get_min(numbers):
minimum = float('inf')
for number in numbers:
if number < minimum:
minimum = number
return minimum
Используем:
numbers = [
50,
20,
70,
-10,
35,
]
print(
get_min(numbers)
)
Результат:
-10
30. Почему inf здесь удобно
Изначально:
minimum = float('inf')
Любое обычное конечное число будет меньше:
50 < inf
поэтому уже первый элемент станет новым минимумом.
Дальше функция продолжает искать более маленькие значения.
Нам не нужно заранее придумывать что-нибудь вроде:
minimum = 999999999
Потому что однажды в списке может оказаться число ещё больше.
Отрицательная бесконечность для максимума
31. Поиск максимального числа
Тот же принцип работает наоборот:
def get_max(numbers):
maximum = float('-inf')
for number in numbers:
if number > maximum:
maximum = number
return maximum
Пример:
numbers = [
-500,
-20,
-700,
-10,
]
print(
get_max(numbers)
)
Результат:
-10
Изначально:
maximum = float('-inf')
и любое конечное число больше отрицательной бесконечности.
Проверка на nan
32. Необычное свойство можно использовать
Мы знаем:
nan != nan
Поэтому простейшая проверка может выглядеть так:
def is_nan(number):
return number != number
Например:
print(
is_nan(
float('nan')
)
)
print(
is_nan(100)
)
Результат:
True
False
В реальном Python-коде для явной проверки обычно существует специальная функция:
math.isnan()
но сам пример хорошо демонстрирует необычное свойство nan.
Удаляем nan из результатов
33. Простой алгоритм
def remove_nan(numbers):
result = []
for number in numbers:
if number == number:
result.append(number)
return result
Используем:
numbers = [
10,
float('nan'),
20,
float('nan'),
30,
]
result = remove_nan(
numbers
)
print(result)
Получим:
[10, 20, 30]
Для обычных чисел:
number == number
возвращает:
True
Для nan:
nan == nan
возвращает:
False
Поэтому nan не попадает в новый список.
Главное по теме
Положительная бесконечность:
float('inf')
Отрицательная:
float('-inf')
Также:
import math
math.inf
-math.inf
inf является специальным значением:
float
и выполняет роль математической бесконечности:
-inf < любое конечное число < inf
Некоторые неопределённые операции:
inf - inf
inf / inf
inf * 0
возвращают:
nan
nan означает:
Not a Number
и обладает необычным свойством:
nan == nan
возвращает:
False
Поэтому при наличии nan обычные:
sorted()
min()
max()
могут давать неожиданные результаты.
Практически:
float('inf')
удобно использовать как начальное значение при поиске минимума:
minimum = float('inf')
а:
float('-inf')
при поиске максимума:
maximum = float('-inf')
nan часто используется для представления отсутствующих, недоступных или неопределённых числовых результатов.