Comment imprimer le tableau NumPy complet, sans troncature?

Lorsque j'imprime un tableau numpy, j'obtiens une représentation tronquée, mais je veux le tableau complet.

Y a-t-il un moyen de faire ça?

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]])

Utilisation numpy.set_printoptions:

import sys
import numpy
numpy.set_printoptions(threshold=sys.maxsize)

import numpy as np
np.set_printoptions(threshold=np.inf)

Je suggère d'utiliser np.infau lieu de np.nance qui est suggéré par d'autres. Ils fonctionnent tous les deux pour votre objectif, mais en définissant le seuil sur "infini", il est évident pour tout le monde qui lit 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 alternative plus faible, vous pouvez vous transformer en 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]]

NumPy 1.15 ou plus récent

Si vous utilisez NumPy 1.15 (publié le 2018-07-23) ou une version plus récente, vous pouvez utiliser le printoptionsgestionnaire de contexte:

with numpy.printoptions(threshold=numpy.inf):
    print(arr)

(bien sûr, remplacez numpypar npsi c'est comme ça que vous avez importé numpy)

L'utilisation d'un gestionnaire de contexte (le with-bloc) garantit qu'après la fin du gestionnaire de contexte, les options d'impression reviendront à ce qu'elles étaient avant le démarrage du bloc. Il garantit que le paramètre est temporaire et appliqué uniquement au code dans le bloc.

Consultez la numpy.printoptionsdocumentation pour plus de détails sur le gestionnaire de contexte et les autres arguments qu'il prend en charge.

On dirait que vous utilisez numpy.

Si tel est le cas, vous pouvez ajouter:

import numpy as np
np.set_printoptions(threshold=np.nan)

Cela désactivera l'impression des coins. Pour plus d'informations, consultez ce didacticiel NumPy .

Voici une façon unique de le faire, ce qui est utile si vous ne souhaitez pas modifier vos paramètres par défaut:

def fullprint(*args, **kwargs):
  from pprint import pprint
  import numpy
  opt = numpy.get_printoptions()
  numpy.set_printoptions(threshold=numpy.inf)
  pprint(*args, **kwargs)
  numpy.set_printoptions(**opt)

Utiliser un gestionnaire de contexte comme l'a suggéré Paul Price

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)


if __name__ == '__main__': 
    a = np.arange(1001)

    with fullprint():
        print(a)

    print(a)

    with fullprint(threshold=None, edgeitems=10):
        print(a)

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 ne montre pas non plus 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.

Il s'agit d'une légère modification (suppression de l'option permettant de passer des arguments supplémentaires à la réponse set_printoptions)de neok .

Il montre comment vous pouvez utiliser contextlib.contextmanagerpour créer facilement un tel gestionnaire de contexte 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 de cette réponse du nombre maximum de colonnes (fixé avec numpy.set_printoptions(threshold=numpy.nan)), il y a aussi une limite de caractères à afficher. Dans certains environnements, comme lors de l'appel de python à partir de bash (plutôt que dans la session interactive), cela peut être corrigé en définissant le paramètre linewidthcomme 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, votre fenêtre doit limiter le nombre de caractères pour boucler la ligne.

Pour ceux qui utilisent du texte sublime et souhaitent voir les résultats dans la fenêtre de sortie, vous devez ajouter l'option "word_wrap": falsede génération au fichier de construction sublime [ source ].

Depuis la version 1.16 de NumPy, pour plus de détails, voir le ticket GitHub 12251 .

from sys import maxsize
from numpy import set_printoptions

set_printoptions(threshold=maxsize)

Pour l'éteindre et revenir au mode normal

np.set_printoptions(threshold=False)

Supposons que vous ayez un tableau numpy

 arr = numpy.arange(10000).reshape(250,40)

Si vous souhaitez imprimer le tableau complet de manière unique (sans basculer np.set_printoptions), mais que vous voulez quelque chose de plus simple (moins de code) que le gestionnaire de contexte, faites simplement

for row in arr:
     print row 

Une légère modification: (puisque vous allez imprimer une énorme liste)

import numpy as np
np.set_printoptions(threshold=np.inf, linewidth=200)

x = np.arange(1000)
print(x)

Cela augmentera le nombre de caractères par ligne (largeur de ligne par défaut de 75). Utilisez n'importe quelle valeur que vous aimez pour la largeur de ligne qui convient à votre environnement de codage. Cela vous évitera d'avoir à parcourir un grand nombre de lignes de sortie en ajoutant plus de caractères par ligne.

Vous pouvez utiliser la array2stringfonction - docs .

a = numpy.arange(10000).reshape(250,40)
print(numpy.array2string(a, threshold=numpy.nan, max_line_width=numpy.nan))
# [Big output]

Vous ne voudrez pas toujours que tous les éléments soient imprimés, en particulier pour les grands tableaux.

Un moyen simple de montrer plus d'articles:

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 lorsque la tranche est <1000 par défaut.

Si vous avez des pandas disponibles,

    numpy.arange(10000).reshape(250,40)
    print(pandas.DataFrame(a).to_string(header=False, index=False))

évite l'effet secondaire d'exiger une réinitialisation de numpy.set_printoptions(threshold=sys.maxsize)et vous n'obtenez pas le numpy.array et les crochets. Je trouve cela pratique pour vider un large éventail dans un fichier journal

Si une matrice est trop grande pour être imprimée, NumPy ignore automatiquement la partie centrale de la matrice et imprime uniquement les coins: pour désactiver ce comportement et forcer NumPy à imprimer la totalité de la matrice, vous pouvez modifier les options d'impression à l'aide de 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 vous référer à la documentation numpy pour "ou une partie" pour plus d'aide.