¿Cómo imprimir la matriz NumPy completa, sin truncamiento?

Cuando imprimo una matriz numpy, obtengo una representación truncada, pero quiero la matriz completa.

¿Hay alguna forma de hacer esto?

Ejemplos:

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

Uso numpy.set_printoptions:

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

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

Sugiero usar en np.influgar de lo np.nanque otros sugieren. Ambos funcionan para su propósito, pero al establecer el umbral en "infinito", es obvio que todos leen su código a lo que se refiere. Tener un umbral de "no un número" me parece un poco vago.

Las respuestas anteriores son las correctas, pero como una alternativa más débil puede transformarse en una lista:

>>> 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 o más reciente

Si usa NumPy 1.15 (lanzado el 23-07-2018) o más reciente, puede usar el printoptionsadministrador de contexto:

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

(por supuesto, reemplace numpypor npsi así fue como importó numpy)

El uso de un administrador de contexto (el withbloque) asegura que después de que el administrador de contexto haya finalizado, las opciones de impresión volverán a ser lo que eran antes de que comenzara el bloque. Asegura que la configuración es temporal y solo se aplica al código dentro del bloque.

Consulte la numpy.printoptionsdocumentación para obtener detalles sobre el administrador de contexto y qué otros argumentos admite.

Esto suena como si estuvieras usando numpy.

Si ese es el caso, puede agregar:

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

Eso desactivará la impresión de la esquina. Para obtener más información, consulte este Tutorial de NumPy .

Aquí hay una manera única de hacer esto, que es útil si no desea cambiar su configuración predeterminada:

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)

Usando un administrador de contexto como Paul Price sugirió

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

o si necesitas una cadena:

import StringIO
sio = StringIO.StringIO()
numpy.savetxt(sio, numpy.arange(10000))
s = sio.getvalue()
print s

El formato de salida predeterminado es:

0.000000000000000000e+00
1.000000000000000000e+00
2.000000000000000000e+00
3.000000000000000000e+00
...

y se puede configurar con más argumentos.

Observe en particular cómo esto tampoco muestra los corchetes y permite una gran cantidad de personalización, como se menciona en: ¿Cómo imprimir una matriz Numpy sin corchetes?

Probado en Python 2.7.12, numpy 1.11.1.

Esta es una ligera modificación (eliminó la opción de pasar argumentos adicionales a la respuesta set_printoptions)de Neok .

Muestra cómo puede usar contextlib.contextmanagerpara crear fácilmente un administrador de contexto con menos líneas de código:

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)

En su código se puede usar así:

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)

Complementario a esta respuesta del número máximo de columnas (fijado con numpy.set_printoptions(threshold=numpy.nan)), también hay un límite de caracteres que se mostrarán. En algunos entornos, como cuando se llama a python desde bash (en lugar de la sesión interactiva), esto se puede solucionar configurando el parámetro de la linewidthsiguiente manera.

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)

En este caso, su ventana debería limitar el número de caracteres para ajustar la línea.

Para aquellos que usan texto sublime y desean ver resultados dentro de la ventana de salida, deben agregar la opción "word_wrap": falsede compilación al archivo de compilación sublime [ fuente ].

Desde la versión 1.16 de NumPy, para más detalles ver el boleto 12251 de GitHub .

from sys import maxsize
from numpy import set_printoptions

set_printoptions(threshold=maxsize)

Para apagarlo y volver al modo normal

np.set_printoptions(threshold=False)

Supongamos que tienes una matriz numpy

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

Si desea imprimir la matriz completa de una sola vez (sin alternar np.set_printoptions), pero quiere algo más simple (menos código) que el administrador de contexto, simplemente haga

for row in arr:
     print row 

Una ligera modificación: (ya que va a imprimir una gran lista)

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

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

Esto aumentará el número de caracteres por línea (ancho de línea predeterminado de 75). Use cualquier valor que desee para el ancho de línea que se adapte a su entorno de codificación. Esto le ahorrará tener que pasar por una gran cantidad de líneas de salida al agregar más caracteres por línea.

Puedes usar la array2stringfunción - docs .

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

No siempre querrá que se impriman todos los elementos, especialmente para matrices grandes.

Una forma sencilla de mostrar más elementos:

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

Funciona bien cuando la matriz en rodajas <1000 por defecto.

Si tienes pandas disponibles,

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

evita el efecto secundario de requerir un reinicio de numpy.set_printoptions(threshold=sys.maxsize)y no obtienes numpy.array y corchetes. Me parece conveniente para volcar una amplia gama en un archivo de registro

Si una matriz es demasiado grande para imprimirse, NumPy omite automáticamente la parte central de la matriz y solo imprime las esquinas: para deshabilitar este comportamiento y obligar a NumPy a imprimir la matriz completa, puede cambiar las opciones de impresión usando set_printoptions.

>>> np.set_printoptions(threshold='nan')

o

>>> np.set_printoptions(edgeitems=3,infstr='inf',
... linewidth=75, nanstr='nan', precision=8,
... suppress=False, threshold=1000, formatter=None)

También puede consultar la documentación de numpy documentación de numpy para "o parte" para obtener más ayuda.