Como imprimir a matriz NumPy completa, sem truncamento?

Quando imprimo uma matriz numpy, obtenho uma representação truncada, mas quero a matriz completa.

Há alguma maneira de fazer isso?

Exemplos:

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

Use numpy.set_printoptions:

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

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

Eu sugiro usar em np.infvez do np.nanque é sugerido por outros. Ambos funcionam para o seu propósito, mas, ao definir o limite como "infinito", é óbvio para todos que leem o seu código o que você quer dizer. Ter um limiar de "não um número" parece um pouco vago para mim.

As respostas anteriores são as corretas, mas como uma alternativa mais fraca, você pode se transformar em uma 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 ou mais recente

Se você usa o NumPy 1.15 (lançado em 23-07-2018) ou mais recente, pode usar o printoptionsgerenciador de contexto:

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

(é claro, substitua numpypor npse é assim que você importou numpy)

O uso de um gerenciador de contexto (o with-block) garante que, após a conclusão do gerenciador de contexto, as opções de impressão retornem ao que estavam antes do início do bloco. Ele garante que a configuração seja temporária e aplicada apenas ao código dentro do bloco.

Consulte a numpy.printoptionsdocumentação para obter detalhes sobre o gerenciador de contexto e quais outros argumentos ele suporta.

Parece que você está usando numpy.

Se for esse o caso, você pode adicionar:

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

Isso desativará a impressão de canto. Para mais informações, consulte este tutorial do NumPy .

Aqui está uma maneira única de fazer isso, que é útil se você não quiser alterar suas configurações padrão:

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 um gerenciador de contexto como Paul Price sugeriu

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 se você precisar de uma string:

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

O formato de saída padrão é:

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

e pode ser configurado com outros argumentos.

Observe em particular como isso também não mostra os colchetes, e permite muita personalização, como mencionado em: Como imprimir um array Numpy sem colchetes?

Testado em Python 2.7.12, numpy 1.11.1.

Essa é uma pequena modificação (removida a opção de passar argumentos adicionais para a resposta set_printoptions)de neok .

Ele mostra como você pode usar contextlib.contextmanagerpara criar facilmente um gerenciador de contexto com menos linhas 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)

No seu código, ele pode ser usado assim:

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)

Complementar a esta resposta do número máximo de colunas (fixo com numpy.set_printoptions(threshold=numpy.nan)), também há um limite de caracteres a serem exibidos. Em alguns ambientes, como ao chamar python do bash (em vez da sessão interativa), isso pode ser corrigido definindo o parâmetro da linewidthseguinte maneira.

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)

Nesse caso, sua janela deve limitar o número de caracteres para quebrar a linha.

Para aqueles que usam o texto sublime e desejam ver os resultados na janela de saída, adicione a opção "word_wrap": falsede compilação ao arquivo de compilação sublime [ origem ].

Desde a versão 1.16 do NumPy, para obter mais detalhes, consulte o ticket 12251 do GitHub .

from sys import maxsize
from numpy import set_printoptions

set_printoptions(threshold=maxsize)

Para desligá-lo e retornar ao modo normal

np.set_printoptions(threshold=False)

Suponha que você tenha uma matriz numpy

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

Se você deseja imprimir a matriz completa de uma maneira única (sem alternar np.set_printoptions), mas deseja algo mais simples (menos código) do que o gerenciador de contexto, basta

for row in arr:
     print row 

Uma pequena modificação: (já que você vai imprimir uma lista enorme)

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

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

Isso aumentará o número de caracteres por linha (largura de linha padrão de 75). Use qualquer valor que você desejar para a largura de linha adequada ao seu ambiente de codificação. Isso evitará que você precise passar por um grande número de linhas de saída adicionando mais caracteres por linha.

Você pode usar a array2stringfunção - docs .

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

Você nem sempre deseja que todos os itens sejam impressos, especialmente para matrizes grandes.

Uma maneira simples de mostrar mais itens:

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 bem quando a matriz fatiada <1000 por padrão.

Se você tem pandas disponíveis,

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

evita o efeito colateral de exigir uma redefinição de numpy.set_printoptions(threshold=sys.maxsize)e você não obtém o numpy.array e colchetes. Acho isso conveniente para despejar uma grande variedade em um arquivo de log

Se uma matriz for muito grande para ser impressa, o NumPy ignorará automaticamente a parte central da matriz e imprimirá apenas os cantos: Para desativar esse comportamento e forçar o NumPy a imprimir a matriz inteira, você pode alterar as opções de impressão usando 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)

Você também pode consultar a documentação numpy documentação numpy para "ou parte" para obter mais ajuda.