Jak wydrukować pełną tablicę NumPy bez obcięcia?

Kiedy drukuję tablicę numpy, otrzymuję obciętą reprezentację, ale chcę pełną tablicę.

Czy jest na to sposób?

Przykłady:

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

Użyj numpy.set_printoptions:

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

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

Sugeruję używanie np.infzamiast tego, np.nanco sugerują inni. Oba działają dla twojego celu, ale ustawiając próg na „nieskończoność”, każdy odczytuje twój kod, co masz na myśli. Próg „nie liczby” wydaje mi się trochę niejasny.

Poprzednie odpowiedzi są prawidłowe, ale jako słabszą alternatywę możesz przekształcić się w listę:

>>> 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 lub nowszy

Jeśli używasz NumPy 1.15 (wydany 2018-07-23) lub nowszego, możesz użyć printoptionsmenedżera kontekstu:

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

(oczywiście zastąpić numpyprzez npjeśli to jak importowane numpy)

Zastosowanie menedżera kontekstu ( with-block) zapewnia, że ​​po zakończeniu menedżera kontekstu opcje drukowania powrócą do tego, co były przed rozpoczęciem bloku. Zapewnia to, że ustawienie jest tymczasowe i dotyczy tylko kodu w bloku.

Zobacz numpy.printoptionsdokumentację, aby uzyskać szczegółowe informacje na temat menedżera kontekstu i innych obsługiwanych przez niego argumentów.

To brzmi jak używasz numpy.

W takim przypadku możesz dodać:

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

To wyłączy drukowanie w rogu. Aby uzyskać więcej informacji, zobacz ten samouczek NumPy .

Oto jednorazowy sposób na zrobienie tego, co jest przydatne, jeśli nie chcesz zmieniać ustawień domyślnych:

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)

Używanie menedżera kontekstu, gdy Paul Price podstępnie

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

lub jeśli potrzebujesz łańcucha:

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

Domyślny format wyjściowy to:

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

i może być skonfigurowany z dalszymi argumentami.

Zwróć uwagę w szczególności, że nie pokazuje to również nawiasów kwadratowych i pozwala na wiele dostosowań, jak wspomniano w: Jak wydrukować tablicę Numpy bez nawiasów?

Testowane na Pythonie 2.7.12, numpy 1.11.1.

Jest to niewielka modyfikacja (usunięto opcję przekazywania dodatkowych argumentów do set_printoptions)odpowiedzi neoka .

Pokazuje, jak można contextlib.contextmanagerłatwo utworzyć takiego menedżera kontekstu z mniejszą liczbą wierszy kodu:

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)

W twoim kodzie można go użyć w następujący sposób:

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)

W uzupełnieniu do tej odpowiedzi z maksymalnej liczby kolumn (ustalonych za pomocą numpy.set_printoptions(threshold=numpy.nan)) istnieje również limit znaków do wyświetlenia. W niektórych środowiskach, takich jak wywoływanie Pythona z bash (zamiast sesji interaktywnej), można to naprawić, ustawiając parametr linewidthw następujący sposób.

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)

W takim przypadku twoje okno powinno ograniczyć liczbę znaków do zawinięcia linii.

Dla tych, którzy używają wzniosłego tekstu i chcą zobaczyć wyniki w oknie wyjściowym, należy dodać opcję kompilacji "word_wrap": falsedo pliku wzniosłej kompilacji [ źródło ].

Od wersji NumPy 1.16 więcej informacji można znaleźć na bilecie GitHub 12251 .

from sys import maxsize
from numpy import set_printoptions

set_printoptions(threshold=maxsize)

Aby go wyłączyć i powrócić do normalnego trybu

np.set_printoptions(threshold=False)

Załóżmy, że masz tablicę numpy

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

Jeśli chcesz wydrukować pełną tablicę w sposób jednorazowy (bez przełączania np.set_printoptions), ale chcesz czegoś prostszego (mniej kodu) niż menedżer kontekstu, po prostu zrób

for row in arr:
     print row 

Drobna modyfikacja: (ponieważ zamierzasz wydrukować ogromną listę)

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

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

Zwiększy to liczbę znaków w wierszu (domyślna szerokość linii 75). Użyj dowolnej wartości szerokości linii, która odpowiada Twojemu środowisku kodowania. Dzięki temu nie będziesz musiał przechodzić przez ogromną liczbę linii wyjściowych, dodając więcej znaków w linii.

Możesz użyć array2stringfunkcji - docs .

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

Nie zawsze chcesz wydrukować wszystkie elementy, szczególnie w przypadku dużych tablic.

Prosty sposób, aby pokazać więcej przedmiotów:

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

Domyślnie działa dobrze, gdy tablica podzielona na <1000.

Jeśli masz dostępne pandy,

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

unika efektu ubocznego wymagającego resetu numpy.set_printoptions(threshold=sys.maxsize)i nie dostajesz numpy.array i nawiasów. Uważam to za wygodne do zrzucania szerokiej tablicy do pliku dziennika

Jeśli tablica jest zbyt duża, aby ją wydrukować, NumPy automatycznie pomija środkową część tablicy i drukuje tylko rogi: Aby wyłączyć to zachowanie i zmusić NumPy do wydrukowania całej tablicy, możesz zmienić opcje drukowania za pomocą set_printoptions.

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

lub

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

Możesz także skorzystać z dokumentacji numpy w dokumentacji numpy dla „lub części”, aby uzyskać dodatkową pomoc.