Бесконечность 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 часто используется для представления отсутствующих, недоступных или неопределённых числовых результатов.