TL, DR: No hay diferencia y se pueden usar indistintamente.

Además de tener el mismo valor que math.inf y float('inf') :

 >>> import math >>> import numpy as np >>> np.inf == float('inf') True >>> np.inf == math.inf True

También tiene el mismo tipo:

 >>> import numpy as np >>> type(np.inf) float >>> type(np.inf) is type(float('inf')) float

Eso es interesante porque NumPy también tiene sus propios tipos de punto flotante:

 >>> np.float32(np.inf) inf >>> type(np.float32(np.inf)) numpy.float32 >>> np.float32('inf') == np.inf # nevertheless equal True

Por lo tanto, tiene el mismo valor y el mismo tipo que math.inf y float('inf') , lo que significa que es intercambiable.

Razones para usar np.inf

1. Es menos escribir:

• np.inf (6 caracteres)
• math.inf (8 caracteres; nuevo en python 3.5)
• float('inf') (12 caracteres)

Eso significa que si ya ha importado NumPy, puede ahorrarse 6 (o 2) caracteres por aparición en comparación con float('inf') (o math.inf ).

2. Porque es más fácil de recordar.

Al menos para mí, es mucho más fácil recordar np.inf que eso, necesito llamar a float con una cadena.

Además, NumPy define algunos alias adicionales para el infinito:

 np.Inf np.inf np.infty np.Infinity np.PINF

También define un alias para el infinito negativo:

 np.NINF

Del mismo modo para nan :

 np.nan np.NaN np.NAN

3. Las constantes son constantes

Este punto está basado en CPython y podría ser completamente diferente en otra implementación de Python.

Una instancia float de CPython requiere 24 bytes:

 >>> import sys >>> sys.getsizeof(np.inf) 24

Si puede reutilizar la misma instancia, puede ahorrar mucha memoria en comparación con la creación de muchas instancias nuevas. Por supuesto, este punto es mudo si crea su propia constante inf , pero si no lo hace, entonces:

 a = [np.inf for _ in range(1000000)] b = [float('inf') for _ in range(1000000)]

b usaría 24 * 1000000 Bytes (~23 MB) más de memoria que a .

4. Acceder a una constante es más rápido que crear la variable.

    %timeit np.inf 37.9 ns ± 0.692 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) %timeit float('inf') 232 ns ± 13.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) %timeit [np.inf for _ in range(10000)] 552 µs ± 15.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) %timeit [float('inf') for _ in range(10000)] 2.59 ms ± 78.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Por supuesto, puede crear su propia constante para contrarrestar ese punto. Pero, ¿por qué molestarse si NumPy ya lo hizo por ti?