différence entre np.inf et float ('Inf')

Est-il une différence entre NumPy np.inf et float('Inf')?
float('Inf') == np.inf retourne Truede sorte qu'il semble qu'ils sont interchangeables, donc je me demandais pourquoi NumPy a défini ses propres "inf" constante, et quand dois-je utiliser une constante à la place de l'autre (en tenant compte du style des préoccupations trop)?

source d'informationauteur AreTor

  1. 15

    TL,DR: Il n'y a pas de différence, et ils peuvent être utilisés de façon interchangeable.

    En plus d'avoir la même valeur que math.inf et float('inf'):

    >>> import math
>>> import numpy as np

>>> np.inf == float('inf')
True
>>> np.inf == math.inf
True

    Il a également le même type:

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

    C'est intéressant parce que NumPy a également son propre point flottant types:

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

    De sorte qu'il a la même valeur et le même type que math.inf et float('inf') qui signifie qu'il est de façon interchangeable.

    Raisons pour l'utilisation de np.inf

    1. C'est moins le type:

      • np.inf (6 caractères)
      • math.inf (8 caractères; nouveau en python 3.5)
      • float('inf') (12 caractères)

      Cela signifie que si vous avez déjà NumPy importés, vous pouvez vous enregistrer 6 (ou 2) caractères par événement par rapport à float('inf') (ou math.inf).

    2. Parce que c'est plus facile à retenir.

      Au moins pour moi, c'est beaucoup plus facile de se rappeler np.inf que j'ai besoin d'appeler float avec une chaîne.

      Aussi NumPy définit également certaines des alias supplémentaires pour l'infini:

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

      Il définit également un alias pour l'infini négatif:

      np.NINF

      De même pour nan:

      np.nan
np.NaN
np.NAN

    3. Constantes sont des constantes

      Ce point est basée sur Disponible et peut être complètement différente dans un autre Python de mise en œuvre.

      Un float Disponible instance nécessite 24 Octets:

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

      Si vous pouvez ré-utiliser le même exemple, vous pourriez économiser beaucoup de mémoire par rapport à la création d'un bon nombre de nouveaux cas. Bien sûr, ce point est muet si vous créez votre propre inf constante, mais si vous ne vous sentez pas à l'époque:

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

      b serait d'utiliser 24 * 1000000 Octets (environ 23 MO) plus de mémoire que a.

    4. L'accès à une constante est plus rapide que la création de 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)

      Bien sûr, vous pouvez créer votre propre constant pour contrer ce point. Mais pourquoi s'embêter si NumPy déjà fait pour vous.