Créer numpy matrice remplie avec NaNs

Vous aurez rarement besoin de boucles pour les opérations de numpy.
Vous pouvez créer un tableau non initialisé et de céder à toutes les entrées à la fois:

>>> a = numpy.empty((3,3,))
>>> a[:] = numpy.nan
>>> a
array([[ NaN,  NaN,  NaN],
       [ NaN,  NaN,  NaN],
       [ NaN,  NaN,  NaN]])

J'ai chronométré les alternatives a[:] = numpy.nan ici et a.fill(numpy.nan) posté par Blaenk:

$ python -mtimeit "import numpy as np; a = np.empty((100,100));" "a.fill(np.nan)"
10000 loops, best of 3: 54.3 usec per loop
$ python -mtimeit "import numpy as np; a = np.empty((100,100));" "a[:] = np.nan" 
10000 loops, best of 3: 88.8 usec per loop

Les horaires indiquent une préférence pour les ndarray.fill(..) comme l'alternative plus rapide. Otoh, que, j'aime numpy la commodité de mise en œuvre de l'endroit où vous pouvez affecter des valeurs à l'ensemble de tranches à la fois, le code de l'intention est très claire.

J'ai comparé les solutions de rechange proposées pour la vitesse et a constaté que, pour assez grand vecteurs/matrices à remplir, toutes les solutions de rechange à l'exception val * ones et array(n * [val]) sont tout aussi rapides.

Code de reproduire la parcelle:

import numpy
import perfplot

val = 42.0


def fill(n):
    a = numpy.empty(n)
    a.fill(val)
    return a


def colon(n):
    a = numpy.empty(n)
    a[:] = val
    return a


def full(n):
    return numpy.full(n, val)


def ones_times(n):
    return val * numpy.ones(n)


def list(n):
    return numpy.array(n * [val])


perfplot.show(
    setup=lambda n: n,
    kernels=[fill, colon, full, ones_times, list],
    n_range=[2**k for k in range(20)],
    logx=True,
    logy=True,
    xlabel='len(a)'
    )

Vous pouvez toujours utiliser la multiplication si vous n'avez pas immédiatement rappeler le .empty ou .full méthodes:

>>> np.nan * np.ones(shape=(3,2))
array([[ nan,  nan],
       [ nan,  nan],
       [ nan,  nan]])

Bien sûr, il fonctionne avec n'importe quelle autre valeur numérique ainsi:

>>> 42 * np.ones(shape=(3,2))
array([[ 42,  42],
       [ 42,  42],
       [ 42, 42]])

Mais l' @u0b34a0f6ae de accepté de répondre à est 3x plus rapide (nombre de cycles CPU, pas de cerveau cycles de rappeler numpy syntaxe ;):

$ python -mtimeit "import numpy as np; X = np.empty((100,100));" "X[:] = np.nan;"
100000 loops, best of 3: 8.9 usec per loop
(predict)laneh@predict:~/src/predict/predict/webapp$ master
$ python -mtimeit "import numpy as np; X = np.ones((100,100));" "X *= np.nan;"
10000 loops, best of 3: 24.9 usec per loop

Une autre alternative est numpy.broadcast_to(val,n) qui renvoie en temps constant quelle que soit la taille et est aussi le plus efficace en terme de mémoire (elle renvoie une vue de la répétition de l'élément). Le problème, c'est que la valeur retournée est en lecture seule.

Ci-dessous une comparaison des performances de toutes les autres méthodes qui ont été proposées à l'aide de la même référence que dans Nico Schlömer réponse.