Comment imprimer la pleine gamme NumPy, sans troncature?
-
22-09-2019 - |
Question
Lorsque j'imprime un tableau numpy, je reçois une représentation tronquée, mais je veux le tableau complet.
Est-il possible de le faire?
Exemples:
>>> numpy.arange(10000)
array([ 0, 1, 2, ..., 9997, 9998, 9999])
>>> numpy.arange(10000).reshape(250,40)
array([[ 0, 1, 2, ..., 37, 38, 39],
[ 40, 41, 42, ..., 77, 78, 79],
[ 80, 81, 82, ..., 117, 118, 119],
...,
[9880, 9881, 9882, ..., 9917, 9918, 9919],
[9920, 9921, 9922, ..., 9957, 9958, 9959],
[9960, 9961, 9962, ..., 9997, 9998, 9999]])
La solution
Utilisez numpy.set_printoptions
:
import sys
import numpy
numpy.set_printoptions(threshold=sys.maxsize)
Autres conseils
import numpy as np
np.set_printoptions(threshold=np.inf)
Je suggère d'utiliser np.inf
au lieu de np.nan
qui est suggéré par d'autres. Ils travaillent tous les deux pour votre but, mais en fixant le seuil à « l'infini » il est évident à tout le monde à lire votre code ce que vous voulez dire. Avoir un seuil de « pas un nombre » me semble un peu vague.
Les réponses précédentes sont les bonnes, mais comme une alternative plus faible que vous pouvez transformer en une liste:
>>> numpy.arange(100).reshape(25,4).tolist()
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15], [16, 17, 18, 19], [20, 21,
22, 23], [24, 25, 26, 27], [28, 29, 30, 31], [32, 33, 34, 35], [36, 37, 38, 39], [40, 41,
42, 43], [44, 45, 46, 47], [48, 49, 50, 51], [52, 53, 54, 55], [56, 57, 58, 59], [60, 61,
62, 63], [64, 65, 66, 67], [68, 69, 70, 71], [72, 73, 74, 75], [76, 77, 78, 79], [80, 81,
82, 83], [84, 85, 86, 87], [88, 89, 90, 91], [92, 93, 94, 95], [96, 97, 98, 99]]
Cela sonne comme vous utilisez numpy.
Si tel est le cas, vous pouvez ajouter:
import numpy as np
np.set_printoptions(threshold=np.nan)
Ceci désactivera l'impression de coin. Pour plus d'informations, consultez cette NumPy Tutorial .
Voici un moyen unique pour ce faire, ce qui est utile si vous ne voulez pas changer vos paramètres par défaut:
def fullprint(*args, **kwargs):
from pprint import pprint
import numpy
opt = numpy.get_printoptions()
numpy.set_printoptions(threshold='nan')
pprint(*args, **kwargs)
numpy.set_printoptions(**opt)
L'utilisation d'un gestionnaire de contexte comme Paul Prix sugggested
import numpy as np
class fullprint:
'context manager for printing full numpy arrays'
def __init__(self, **kwargs):
kwargs.setdefault('threshold', np.inf)
self.opt = kwargs
def __enter__(self):
self._opt = np.get_printoptions()
np.set_printoptions(**self.opt)
def __exit__(self, type, value, traceback):
np.set_printoptions(**self._opt)
a = np.arange(1001)
with fullprint():
print(a)
print(a)
with fullprint(threshold=None, edgeitems=10):
print(a)
numpy 1.15 ou plus récent
Si vous utilisez NumPy 1,15 (publié 23/07/2018) ou plus récent, vous pouvez utiliser le gestionnaire de contexte printoptions
:
with numpy.printoptions(threshold=numpy.inf):
print(arr)
(bien sûr, remplacer numpy
par np
si c'est comment vous avez importé numpy
)
L'utilisation d'un gestionnaire de contexte (le with
bloc) assure que, après le gestionnaire de contexte est terminé, les options d'impression seront revenir à ce qu'ils étaient avant que le bloc a commencé. Il assure le réglage est temporaire et appliquée uniquement au code dans le bloc.
Voir documentation numpy.printoptions
détails sur le gestionnaire de contexte et quels autres arguments qu'il soutient.
numpy.savetxt
numpy.savetxt(sys.stdout, numpy.arange(10000))
ou si vous avez besoin d'une chaîne:
import StringIO
sio = StringIO.StringIO()
numpy.savetxt(sio, numpy.arange(10000))
s = sio.getvalue()
print s
Le format de sortie par défaut est:
0.000000000000000000e+00
1.000000000000000000e+00
2.000000000000000000e+00
3.000000000000000000e+00
...
et il peut être configuré avec d'autres arguments.
Notez en particulier comment cela également ne montre pas les crochets, et permet beaucoup de personnalisation, comme mentionné à: Comment imprimer un tableau numpy sans crochets?
Testé sur Python 2.7.12, numpy 1.11.1.
Ceci est une légère modification (supprimé la possibilité de transmettre des arguments supplémentaires pour set_printoptions)
of neok la réponse .
Il montre comment vous pouvez utiliser contextlib.contextmanager
pour créer facilement une telle ContextManager avec moins de lignes de code:
import numpy as np
from contextlib import contextmanager
@contextmanager
def show_complete_array():
oldoptions = np.get_printoptions()
np.set_printoptions(threshold=np.inf)
try:
yield
finally:
np.set_printoptions(**oldoptions)
Dans votre code, il peut être utilisé comme ceci:
a = np.arange(1001)
print(a) # shows the truncated array
with show_complete_array():
print(a) # shows the complete array
print(a) # shows the truncated array (again)
En complément à cette répondre à partir du nombre maximum de colonnes fixes (avec numpy.set_printoptions(threshold=numpy.nan)
), il y a aussi une limite de caractères à afficher. Dans certains environnements comme lorsque vous appelez python bash (plutôt que la session interactive), cela peut être résolu en définissant le paramètre linewidth
comme suit.
import numpy as np
np.set_printoptions(linewidth=2000) # default = 75
Mat = np.arange(20000,20150).reshape(2,75) # 150 elements (75 columns)
print(Mat)
Dans ce cas, la fenêtre devrait limiter le nombre de caractères pour envelopper la ligne.
Pour ceux là en utilisant du texte sublime et vouloir voir les résultats dans la fenêtre de sortie, vous devez ajouter l'option de compilation "word_wrap": false
au fichier-build sublime [ Source ].
Pour la désactiver et revenir au mode normal
np.set_printoptions(threshold=False)
Supposons que vous avez un tableau numpy
arr = numpy.arange(10000).reshape(250,40)
Si vous voulez imprimer le tableau complet d'une manière unique (sans np.set_printoptions basculer), mais que vous voulez quelque chose de plus simple (moins de code) que le gestionnaire de contexte, il suffit de faire
for row in arr:
print row
Vous pouvez utiliser la fonction array2string
- docs .
a = numpy.arange(10000).reshape(250,40)
print(numpy.array2string(a, threshold=numpy.nan, max_line_width=numpy.nan))
# [Big output]
Depuis la version NumPy 1,16, pour plus de détails, voir billet 12251 GitHub.
from sys import maxsize
from numpy import set_printoptions
set_printoptions(threshold=maxsize)
Vous ne voudrez pas toujours tous les articles imprimés, en particulier pour les grands tableaux.
Une façon simple de montrer plus d'éléments:
In [349]: ar
Out[349]: array([1, 1, 1, ..., 0, 0, 0])
In [350]: ar[:100]
Out[350]:
array([1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1,
1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1])
Il fonctionne très bien quand tableau en tranches <1000 par défaut.
Si un tableau est trop grand pour être imprimé, NumPy saute automatiquement la partie centrale du tableau et n'imprime les coins:
Pour désactiver ce comportement et forcer NumPy à imprimer le tableau entier, vous pouvez modifier les options d'impression en utilisant set_printoptions
.
>>> np.set_printoptions(threshold='nan')
ou
>>> np.set_printoptions(edgeitems=3,infstr='inf',
... linewidth=75, nanstr='nan', precision=8,
... suppress=False, threshold=1000, formatter=None)
Vous pouvez également consulter le numpy documentation numpy documentation "ou partie" pour plus d'aide.