Come stampare l'intero array NumPy, senza troncamento?

Quando stampo un array intorpidito, ottengo una rappresentazione troncata, ma voglio l'array completo.

C'è un modo per fare questo?

Esempi:

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

Utilizzare numpy.set_printoptions:

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

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

Suggerisco di utilizzare al np.infposto del np.nanquale è suggerito da altri. Entrambi funzionano per il tuo scopo, ma impostando la soglia su "infinito" è ovvio per chiunque legga il tuo codice cosa intendi. Avere una soglia di "non un numero" mi sembra un po 'vago.

Le risposte precedenti sono quelle corrette, ma come alternativa più debole puoi trasformarti in un elenco:

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

Se usi NumPy 1.15 (rilasciato il 23-07-2018) o più recente, puoi utilizzare il printoptionsgestore di contesto:

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

(ovviamente, sostituisci numpycon npse è così che hai importato numpy)

L'uso di un gestore di contesto (il withblocco) assicura che, una volta terminato il gestore di contesto, le opzioni di stampa torneranno a quello che erano prima dell'inizio del blocco. Assicura che l'impostazione sia temporanea e applicata solo al codice all'interno del blocco.

Consultare la numpy.printoptionsdocumentazione per i dettagli sul gestore del contesto e su quali altri argomenti supporta.

Sembra che tu stia usando intorpidito.

In tal caso, puoi aggiungere:

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

Ciò disabiliterà la stampa d'angolo. Per ulteriori informazioni, vedere questo tutorial di NumPy .

Ecco un modo unico per farlo, che è utile se non vuoi cambiare le tue impostazioni predefinite:

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)

Utilizzo di un gestore di contesto come suggerito da 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 se hai bisogno di una stringa:

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

Il formato di output predefinito è:

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

e può essere configurato con ulteriori argomenti.

Nota in particolare come anche questo non mostri le parentesi quadre e consenta molta personalizzazione, come indicato in: Come stampare un array Numpy senza parentesi?

Testato su Python 2.7.12, numpy 1.11.1.

Questa è una leggera modifica (rimossa l'opzione per passare ulteriori argomenti alla risposta set_printoptions)di Neok .

Mostra come è possibile utilizzare contextlib.contextmanagerper creare facilmente un simile gestore di contesto con meno righe di codice:

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)

Nel tuo codice può essere usato in questo modo:

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)

In aggiunta a questa risposta dal numero massimo di colonne (risolto con numpy.set_printoptions(threshold=numpy.nan)), esiste anche un limite di caratteri da visualizzare. In alcuni ambienti come quando si chiama python da bash (piuttosto che dalla sessione interattiva), questo può essere risolto impostando il parametro linewidthcome segue.

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)

In questo caso, la finestra dovrebbe limitare il numero di caratteri per avvolgere la linea.

Per quelli che usano il testo sublime e vogliono vedere i risultati nella finestra di output, dovresti aggiungere l'opzione build "word_wrap": falseal file sublime-build [ source ].

Dalla versione 1.16 di NumPy, per maggiori dettagli vedere il ticket 12251 di GitHub .

from sys import maxsize
from numpy import set_printoptions

set_printoptions(threshold=maxsize)

Per spegnerlo e tornare alla modalità normale

np.set_printoptions(threshold=False)

Supponiamo di avere un array intorpidito

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

Se vuoi stampare l'intero array in un modo unico (senza attivare np.set_printoptions), ma vuoi qualcosa di più semplice (meno codice) del gestore del contesto, fai semplicemente

for row in arr:
     print row 

Una leggera modifica: (poiché hai intenzione di stampare un enorme elenco)

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

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

Ciò consentirà di aumentare il numero di caratteri per riga (larghezza di riga predefinita di 75). Usa qualsiasi valore che ti piace per la larghezza di riga adatta al tuo ambiente di codifica. Questo ti eviterà di dover attraversare un numero enorme di righe di output aggiungendo più caratteri per riga.

Puoi usare la array2stringfunzione - documenti .

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

Non vorrai sempre stampare tutti gli articoli, specialmente per array di grandi dimensioni.

Un modo semplice per mostrare più elementi:

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

Funziona bene quando viene suddivisa una matrice <1000 di default.

Se hai i panda disponibili,

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

evita l'effetto collaterale di richiedere un reset di numpy.set_printoptions(threshold=sys.maxsize)e non ottieni numpy.array e parentesi. Lo trovo conveniente per scaricare una vasta gamma in un file di registro

Se un array è troppo grande per essere stampato, NumPy salta automaticamente la parte centrale dell'array e stampa solo gli angoli: per disabilitare questo comportamento e forzare NumPy a stampare l'intero array, è possibile modificare le opzioni di stampa 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)

È inoltre possibile fare riferimento alla documentazione numpy documentazione numpy per "o parte" per ulteriori informazioni.