Comment imprimer un tableau numpy.array sans notation scientifique et avec une précision donnée ?

Question

Je suis curieux de savoir s'il existe un moyen d'imprimer des documents formatés. numpy.arrays par exemple, d'une manière similaire à celle-ci :

x = 1.23456
print '%.3f' % x

Si je veux imprimer le numpy.array de flottants, il imprime plusieurs décimales, souvent au format "scientifique", qui est plutôt difficile à lire, même pour les tableaux de faible dimension. Cependant, numpy.array doit apparemment être imprimé comme une chaîne de caractères, c'est-à-dire, avec %s . Existe-t-il une solution à ce problème ?

Answer 1

Vous pouvez utiliser set_printoptions pour définir la précision de la sortie :

import numpy as np
x=np.random.random(10)
print(x)
# [ 0.07837821  0.48002108  0.41274116  0.82993414  0.77610352  0.1023732
#   0.51303098  0.4617183   0.33487207  0.71162095]

np.set_printoptions(precision=3)
print(x)
# [ 0.078  0.48   0.413  0.83   0.776  0.102  0.513  0.462  0.335  0.712]

Et suppress supprime l'utilisation de la notation scientifique pour les petits nombres :

y=np.array([1.5e-10,1.5,1500])
print(y)
# [  1.500e-10   1.500e+00   1.500e+03]
np.set_printoptions(suppress=True)
print(y)
# [    0.      1.5  1500. ]

Voir le Documentation pour set_printoptions pour d'autres options.

---

Pour appliquer les options d'impression localement Si vous utilisez NumPy 1.15.0 ou une version ultérieure, vous pouvez utiliser la fonction numpy.printoptions gestionnaire de contexte. Par exemple, à l'intérieur du with-suite precision=3 y suppress=True sont fixés :

x = np.random.random(10)
with np.printoptions(precision=3, suppress=True):
    print(x)
    # [ 0.073  0.461  0.689  0.754  0.624  0.901  0.049  0.582  0.557  0.348]

Mais en dehors de la with-suite les options d'impression reviennent aux paramètres par défaut :

print(x)    
# [ 0.07334334  0.46132615  0.68935231  0.75379645  0.62424021  0.90115836
#   0.04879837  0.58207504  0.55694118  0.34768638]

Si vous utilisez une version antérieure de NumPy, vous pouvez créer le gestionnaire de contexte vous-même. Par exemple,

import numpy as np
import contextlib

@contextlib.contextmanager
def printoptions(*args, **kwargs):
    original = np.get_printoptions()
    np.set_printoptions(*args, **kwargs)
    try:
        yield
    finally: 
        np.set_printoptions(**original)

x = np.random.random(10)
with printoptions(precision=3, suppress=True):
    print(x)
    # [ 0.073  0.461  0.689  0.754  0.624  0.901  0.049  0.582  0.557  0.348]

---

Pour éviter que les zéros ne soient supprimés à la fin des flottants :

np.set_printoptions a maintenant un formatter qui vous permet de spécifier une fonction de format pour chaque type.

np.set_printoptions(formatter={'float': '{: 0.3f}'.format})
print(x)

qui imprime

[ 0.078  0.480  0.413  0.830  0.776  0.102  0.513  0.462  0.335  0.712]

au lieu de

[ 0.078  0.48   0.413  0.83   0.776  0.102  0.513  0.462  0.335  0.712]

Answer 2

Vous pouvez obtenir un sous-ensemble de la np.set_printoptions de la fonctionnalité de l np.array_str qui ne s'applique qu'à une seule instruction d'impression.

http://docs.scipy.org/doc/numpy/reference/generated/numpy.array_str.html

Par exemple :

In [27]: x = np.array([[1.1, 0.9, 1e-6]]*3)

In [28]: print x
[[  1.10000000e+00   9.00000000e-01   1.00000000e-06]
 [  1.10000000e+00   9.00000000e-01   1.00000000e-06]
 [  1.10000000e+00   9.00000000e-01   1.00000000e-06]]

In [29]: print np.array_str(x, precision=2)
[[  1.10e+00   9.00e-01   1.00e-06]
 [  1.10e+00   9.00e-01   1.00e-06]
 [  1.10e+00   9.00e-01   1.00e-06]]

In [30]: print np.array_str(x, precision=2, suppress_small=True)
[[ 1.1  0.9  0. ]
 [ 1.1  0.9  0. ]
 [ 1.1  0.9  0. ]]

Answer 3

Unutbu a donné une réponse très complète (ils ont obtenu un +1 de ma part aussi), mais voici une alternative lo-tech :

>>> x=np.random.randn(5)
>>> x
array([ 0.25276524,  2.28334499, -1.88221637,  0.69949927,  1.0285625 ])
>>> ['{:.2f}'.format(i) for i in x]
['0.25', '2.28', '-1.88', '0.70', '1.03']

En tant que fonction (en utilisant le format() syntaxe pour le formatage) :

def ndprint(a, format_string ='{0:.2f}'):
    print [format_string.format(v,i) for i,v in enumerate(a)]

Utilisation :

>>> ndprint(x)
['0.25', '2.28', '-1.88', '0.70', '1.03']

>>> ndprint(x, '{:10.4e}')
['2.5277e-01', '2.2833e+00', '-1.8822e+00', '6.9950e-01', '1.0286e+00']

>>> ndprint(x, '{:.8g}')
['0.25276524', '2.283345', '-1.8822164', '0.69949927', '1.0285625']

L'index du tableau est accessible dans la chaîne de format :

>>> ndprint(x, 'Element[{1:d}]={0:.2f}')
['Element[0]=0.25', 'Element[1]=2.28', 'Element[2]=-1.88', 'Element[3]=0.70', 'Element[4]=1.03']

Answer 4

Pour info, Numpy 1.15 (date de sortie en attente) va inclure un gestionnaire de contexte pour définir localement les options d'impression . Cela signifie que l'exemple suivant fonctionnera de la même manière que l'exemple correspondant dans le document la réponse acceptée (par unutbu et Neil G) sans avoir à écrire votre propre gestionnaire de contexte. Par exemple, en utilisant leur exemple :

x = np.random.random(10)
with np.printoptions(precision=3, suppress=True):
    print(x)
    # [ 0.073  0.461  0.689  0.754  0.624  0.901  0.049  0.582  0.557  0.348]

Answer 5

La gemme qui permet d'obtenir trop facilement le résultat sous forme de chaîne (dans les versions actuelles de numpy) est cachée dans la réponse de Denis : np.array2string

>>> import numpy as np
>>> x=np.random.random(10)
>>> np.array2string(x, formatter={'float_kind':'{0:.3f}'.format})
'[0.599 0.847 0.513 0.155 0.844 0.753 0.920 0.797 0.427 0.420]'