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

¿Hay alguna manera 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]])
respuesta

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 np.infen lugar de np.nanlo que otros sugieren. Ambos funcionan para su propósito, pero al establecer el umbral en "infinito", es obvio para todos los que leen su código lo que quiere decir. Tener un umbral de "no es un número" me parece un poco vago.

Las respuestas anteriores son las correctas, pero como alternativa más débil puedes transformarlas 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]]

Ajuste temporal

Si usa NumPy 1.15 (lanzado el 23 de julio de 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í es como importó numpy)

El uso de un administrador de contexto (el withbloque -) asegura que una vez que finalice el administrador de contexto, las opciones de impresión volverán a ser las que eran antes de que comenzara el bloque. Garantiza que la configuración sea temporal y solo se aplique al código dentro del bloque.

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

Aquí hay una forma única de hacer esto, que es útil si no desea cambiar la 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)

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 deshabilitará la impresión de esquinas. Para obtener más información, consulte este tutorial de NumPy .

Usar un administrador de contexto como sugirió 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))

o si necesita 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.

Tenga en cuenta 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 (se 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 de este tipo 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 tu 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)
with np.printoptions(edgeitems=50):
    print(x)

Cambia 50 a cuántas líneas quieres ver

Fuente: aquí

Una ligera modificación: (ya que vas a imprimir una lista enorme)

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

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 para mostrar. 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 linewidthde la siguiente 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 debe limitar la cantidad de caracteres para envolver la línea.

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

Para apagarlo y volver al modo normal

np.set_printoptions(threshold=False)

Desde la versión 1.16 de NumPy, para obtener más detalles, consulte el ticket 12251 de GitHub .

from sys import maxsize
from numpy import set_printoptions

set_printoptions(threshold=maxsize)

Supongamos que tiene 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 desea algo más simple (menos código) que el administrador de contexto, simplemente hágalo

for row in arr:
     print row 

Si está utilizando un cuaderno jupyter, encontré que esta es la solución más simple para casos únicos. Básicamente, convierta la matriz numpy en una lista y luego en una cadena y luego imprima. Esto tiene la ventaja de mantener los separadores de coma en la matriz, mientras que el uso numpyp.printoptions(threshold=np.inf)no:

import numpy as np
print(str(np.arange(10000).reshape(250,40).tolist()))

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 cortada <1000 por defecto.

Si está utilizando Jupyter, pruebe la extensión del inspector de variables . Puede hacer clic en cada variable para ver la matriz completa.

Puede utilizar 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]

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 numpy.set_printoptions(threshold=sys.maxsize)y no obtiene el numpy.array y los corchetes. Encuentro esto conveniente para volcar una amplia matriz 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 toda la matriz, 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 numpy documentación numpy para "o parte" para obtener más ayuda.