Comment puis-je créer un tableau dont les éléments sont tous égaux à une valeur spécifiée?

Comment puis-je créer un tableau où chaque entrée est la même valeur? Je sais numpy.ones() et numpy.zeros() le faire pour les 1 et les 0, mais qu'en est -1?

Par exemple:

>>import numpy as np
>>np.zeros((3,3))
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

>>np.ones((2,5))
array([[ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.]])

>>np.negative_ones((2,5))
???

OriginalL'auteur maxm | 2013-01-01

  1. 16

    Je ne sais pas si il y a un joli one-liner sans une opération arithmétique, mais probablement le plus rapide approche consiste à créer un tableau non initialisé à l'aide de empty et ensuite utiliser .fill() pour définir les valeurs. Pour comparaison:

    >>> timeit m = np.zeros((3,3)); m += -1
100000 loops, best of 3: 6.9 us per loop
>>> timeit m = np.ones((3,3)); m *= -1
100000 loops, best of 3: 9.49 us per loop
>>> timeit m = np.zeros((3,3)); m.fill(-1)
100000 loops, best of 3: 2.31 us per loop
>>> timeit m = np.empty((3,3)); m[:] = -1
100000 loops, best of 3: 3.18 us per loop

>>> timeit m = np.empty((3,3)); m.fill(-1)
100000 loops, best of 3: 2.09 us per loop

    mais pour être honnête, j'ai tendance à ajouter à zéro de la matrice ou de multiplier ceux de la matrice au lieu de cela, comme l'initialisation est rarement un goulot d'étranglement.

    100000 loops, best of 3: 9.49 us per loop Pourquoi est-ce si long ?
    1. ces timeings sont malheureusement pas que représentant, parce que les tableaux est tout simplement trop petit, les frais généraux pour les appels de fonction joue un rôle (probablement la raison pour laquelle il est quelque peu plus lent). 2. En fait, ces timings légèrement changer au fil des versions, mais je pense que l'utilisation de découpage (j'aime aussi [...]) ou .fill sont à la fois grands (et aussi gagner ici). plus: lisibilité compte...
    Eh bien, ones est fondamentalement empty + fill avec une erreur de capture, de sorte que le seul endroit que toute différence de performances est en petite taille des matrices, parce que asymptotiquement ils font exactement la même chose.
    Il y a maintenant un one-liner np.full(), comme par ma réponse ci-dessous.

    OriginalL'auteur DSM

  2. 8

    Utilisation np.plein() comme suit:

    np.full((2, 5), -1.)

    Retourne:

    array([[-1., -1., -1., -1., -1.],
       [-1., -1., -1., -1., -1.]])
    Yep. Nouveau dans numpy 1.8.0 en octobre 2013, ce qui est après la accepté de répondre ici, sinon ce serait la seule réponse.

    OriginalL'auteur DontDivideByZero

  3. 7

    -1 * np.((2,5))

    Multplying par le nombre dont vous avez besoin dans la matrice fera l'affaire.

    In [5]: -1 * np.ones((2,5))
Out[5]: 
array([[-1., -1., -1., -1., -1.],
       [-1., -1., -1., -1., -1.]])

In [6]: 5 * np.ones((2,5))                                                                                                                                                                                                                  
Out[6]:                                                                                                                                                                                                                                      
array([[ 5.,  5.,  5.,  5.,  5.],                                                                                                                                                                                                            
       [ 5.,  5.,  5.,  5.,  5.]])

    OriginalL'auteur Manish Mulani

  4. 3

    Pour un tableau de 1s

    -1 * np.ones((2,5))

    Il suffit de multiplier avec la constante.

    OriginalL'auteur asheeshr

  5. 2
    foo = np.repeat(10, 50).reshape((5,10))

    Permettra de créer un 5x10 matrice de 10s.

    OriginalL'auteur Ramon J Romero y Vigil

  6. 0

    Comment sur:

    [[-1]*n]*m

    où n est le nombre de colonnes et m est le nombre de lignes?

    OriginalL'auteur learning