How to print the full NumPy array, without truncation?

Question

When I print a numpy array, I get a truncated representation, but I want the full array.

Is there any way to do this?

Examples:

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

Is there a way to do it on a "one off" basis? That is, to print out the full output once, but not at other times in the script? — tumultous_rooster, May 18 '14 at 03:07
Could you change the accepted answer to the one recommending `np.inf`? `np.nan` and `'nan'` only work by total fluke, and [`'nan'` doesn't even work in Python 3](http://ideone.com/tjyGhX) because they changed the mixed-type comparison implementation that `threshold='nan'` depended on. — user2357112 supports Monica, Jun 01 '17 at 20:03
(`threshold=np.nan` rather than `'nan'` depends on a different fluke, which is that the array printing logic compares the array size to the threshold with [`a.size > _summaryThreshold`](https://github.com/numpy/numpy/blob/v1.12.0/numpy/core/arrayprint.py#L318). This always returns `False` for `_summaryThreshold=np.nan`. If the comparison had been `a.size <= _summaryThreshold`, testing whether the array should be fully printed instead of testing whether it should be summarized, this threshold would trigger summarization for all arrays.) — user2357112 supports Monica, Jun 01 '17 at 20:14
A "one-off" way of doing it: If you have a numpy.array `tmp` just `list(tmp)`. Other options with different formatting are `tmp.tolist()` or for more control `print("\n".join(str(x) for x in tmp))`. — travc, Dec 30 '17 at 02:17
A simple trick is to convert the array to a pandas dataframe, and take advantage of it's more friendly formatting: `import pandas; pandas.DataFrame(my_numpy_array)` — John Mark, Apr 20 '20 at 19:18
@tumultous_rooster For a temporary change, see the answer below using the new numpy context manager. — nealmcb, Nov 02 '20 at 02:17

score 745 · Accepted Answer · edited Mar 21 '19 at 21:15

745

Use numpy.set_printoptions:

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

edited Mar 21 '19 at 21:15

paulmelnikow

16,036
6
56
110

answered Jan 01 '10 at 06:26

Raja Selvaraj

7,126
3
18
13

3

if you only want to print a `numpy` array only once, unfortunately this solution has the downside of requiring you to reset this configuration change after doing the print. – Trevor Boyd Smith Jun 05 '19 at 13:56
2

@TrevorBoydSmith, Do you know how to reset this parameter after the print? – ColinMac Jul 01 '19 at 22:56
2

@ColinMac see https://stackoverflow.com/a/24542498/52074 where he saves the settings. does an operation. then restores the settings. – Trevor Boyd Smith Jul 02 '19 at 12:56
2

And how to reset it back to normal? – Gulzar Mar 15 '20 at 15:46
1

@Gulzar numpy.set_printoptions(threshold=1000) – Friendly Fella Jun 20 '20 at 11:52
3

@Gulzar use: numpy.set_printoptions(threshold = False) – Rahul Vishwakarma Jun 30 '20 at 06:41
Ok, but the relevant option is `edgeitems` (as @MustafaCandan shows) not `threshold`. So this isn't the answer. – smci Mar 19 '21 at 21:10

score 253 · Answer 2 · answered Sep 24 '14 at 14:01

253

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

I suggest using np.inf instead of np.nan which is suggested by others. They both work for your purpose, but by setting the threshold to "infinity" it is obvious to everybody reading your code what you mean. Having a threshold of "not a number" seems a little vague to me.

answered Sep 24 '14 at 14:01

PaulMag

3,288
2
13
27

20

What's the inverse operation of this? How to go back to the previous setting (with the dots)? – Karlo Mar 03 '17 at 10:55
14

@Karlo The default number is 1000, so `np.set_printoptions(threshold=1000)` will revert it to default behaviour. But you can set this threshold as low or high as you like. `np.set_printoptions(threshold=np.inf)` simply changes the maximum size a printed array can be before it is truncated to infinite, so that it is never truncated no matter how big. If you set the threshold to any real number then that will be the maximum size. – PaulMag Mar 04 '17 at 03:36
9

Not only is this clearer, it's much less fragile. There is **no special handling** for `np.inf`, `np.nan`, or `'nan'`. Whatever you put there, NumPy will still use a plain `>` to compare the size of the array to your threshold. `np.nan` only happens to work because it's `a.size > _summaryThreshold` instead of `a.size <= _summaryThreshold`, and `np.nan` returns `False` for all `>`/`=`/`<=` comparisons. `'nan'` only happens to work due to fragile implementation details of Python 2's mixed-type comparison logic; it breaks completely on Python 3. – user2357112 supports Monica Jun 01 '17 at 20:12
2

Use sys.maxsize since the value is documented to be an int – mattip Nov 08 '18 at 19:09
5

To properly answer @Karlo's question, note that the initial value for the print options threshold is found in `np.get_printoptions()['threshold']`. You can store this value before setting the threshold and then restore it afterwards (or use a `with` block as suggested in other answers). – Ninjakannon Mar 14 '20 at 15:14

score 125 · Answer 3 · edited Apr 02 '18 at 23:46

125

The previous answers are the correct ones, but as a weaker alternative you can transform into a 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]]

edited Apr 02 '18 at 23:46

Eric

87,154
48
211
332

answered Apr 23 '15 at 13:40

Anoyz

6,603
2
26
35

18

This seems to be the best one-off way to see your full array in a print statement. – Aaron Bramson Aug 01 '18 at 02:27
@AaronBramson i agree... this is less-error prone when you need just one print statement (one line of code as opposed to 3 lines for: change config, print, reset config). – Trevor Boyd Smith Jun 05 '19 at 13:58
I like that this prints the comma separators – ObviousChild Feb 15 '20 at 17:10

gerrit · Answer 4 · 2020-10-15T16:08:41.353

Temporary setting

If you use NumPy 1.15 (released 2018-07-23) or newer, you can use the printoptions context manager:

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

(of course, replace numpy by np if that's how you imported numpy)

The use of a context manager (the with-block) ensures that after the context manager is finished, the print options will revert to whatever they were before the block started. It ensures the setting is temporary, and only applied to code within the block.

See numpy.printoptions documentation for details on the context manager and what other arguments it supports.

score 44 · Answer 5 · edited Mar 01 '20 at 10:38

44

Here is a one-off way to do this, which is useful if you don't want to change your default settings:

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)

edited Mar 01 '20 at 10:38

Paul Rougieux

7,937
1
49
82

answered Jul 02 '14 at 23:08

ZSG

1,179
10
17

14

Looks like this would be a good place to use a context manager, so you can say "with fullprint". – Paul Price Sep 17 '14 at 15:38

score 41 · Answer 6 · edited Nov 09 '18 at 03:53

41

This sounds like you're using numpy.

If that's the case, you can add:

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

That will disable the corner printing. For more information, see this NumPy Tutorial.

edited Nov 09 '18 at 03:53

Eric

87,154
48
211
332

answered Jan 01 '10 at 02:02

Reed Copsey

522,342
70
1,092
1,340

6

`ValueError: threshold must be numeric and non-NAN, try sys.maxsize for untruncated representation` – Eric Mar 07 '19 at 06:49
Yes, That part of the official Numpy tutorial is wrong – aderchox Apr 16 '20 at 09:25

neok · Answer 7 · 2020-02-17T13:42:18.080

34

Using a context manager as Paul Price sugggested

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)

edited Feb 17 '20 at 13:42

answered Sep 09 '16 at 06:33

neok

802
8
14

7

This context manager is built into numpy 1.15, thanks to https://github.com/numpy/numpy/pull/10406, under the name `np.printoptions` – Eric Apr 02 '18 at 23:48

Ciro Santilli新疆棉花TRUMP BAN BAD · Answer 8 · 2019-05-02T07:01:42.923

15

numpy.savetxt

numpy.savetxt(sys.stdout, numpy.arange(10000))

or if you need a string:

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

The default output format is:

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

and it can be configured with further arguments.

Note in particular how this also not shows the square brackets, and allows for a lot of customization, as mentioned at: How to print a Numpy array without brackets?

Tested on Python 2.7.12, numpy 1.11.1.

edited May 02 '19 at 07:01

answered Feb 04 '17 at 23:22

Ciro Santilli新疆棉花TRUMP BAN BAD

256,395
72
959
767

1

minor drawback to this method is that in only works with 1d and 2d arrays – Fnord Aug 08 '19 at 15:43
@Fnord thanks for this info, let me know if you find a workaround! – Ciro Santilli新疆棉花TRUMP BAN BAD Aug 08 '19 at 15:56

MSeifert · Answer 9 · 2018-04-03T06:16:04.940

13

This is a slight modification (removed the option to pass additional arguments to set_printoptions)of neoks answer.

It shows how you can use contextlib.contextmanager to easily create such a contextmanager with fewer lines of code:

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)

In your code it can be used like this:

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)

edited Apr 03 '18 at 06:16

answered Aug 23 '17 at 05:43

MSeifert

118,681
27
271
293

1

You should always put a `try` / `finally` around the `yield` in a context manager, so that the cleanup happens no matter what. – Eric Apr 02 '18 at 23:48
1

@Eric indeed. Thank you for your helpful comment and I have updated the answer. – MSeifert Apr 03 '18 at 06:17
In 1.15, this can be spelt `with np.printoptions(threshold=np.inf):` – Eric Apr 04 '18 at 17:41

score 7 · Answer 10 · answered Sep 28 '18 at 06:34

Complementary to this answer from the maximum number of columns (fixed with numpy.set_printoptions(threshold=numpy.nan)), there is also a limit of characters to be displayed. In some environments like when calling python from bash (rather than the interactive session), this can be fixed by setting the parameter linewidth as following.

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 this case, your window should limit the number of characters to wrap the line.

For those out there using sublime text and wanting to see results within the output window, you should add the build option "word_wrap": false to the sublime-build file [source] .

score 6 · Answer 11 · edited Jan 22 '19 at 14:48

6

Since NumPy version 1.16, for more details see GitHub ticket 12251.

from sys import maxsize
from numpy import set_printoptions

set_printoptions(threshold=maxsize)

edited Jan 22 '19 at 14:48

Georgy

6,348
7
46
58

answered Jan 21 '19 at 20:12

Velizar VESSELINOV

685
9
12

score 6 · Answer 12 · answered Apr 23 '20 at 08:13

A slight modification: (since you are going to print a huge list)

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

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

This will increase the number of characters per line (default linewidth of 75). Use any value you like for the linewidth which suits your coding environment. This will save you from having to go through huge number of output lines by adding more characters per line.

score 5 · Answer 13 · answered May 24 '19 at 06:12

5

To turn it off and return to the normal mode

np.set_printoptions(threshold=False)

answered May 24 '19 at 06:12

ewalel

1,255
13
20

It works for me (Jupyter python version 3). You may try the code below.As per the official documnetation the code below should put back to the default options. Which it did for me too. >np.set_printoptions(edgeitems=3,infstr='inf', linewidth=75, nanstr='nan', precision=8, suppress=False, threshold=1000, formatter=None) – ewalel Jul 17 '19 at 07:54
Okay, it must be because I'm not using Jupyter. The accepted answer does work for me in a pure python environment though. – Mathyou Jul 17 '19 at 19:14
This means `threshold=0`, which means "truncate as soon as possible" - not what you want at all. – Eric Oct 29 '19 at 19:12

score 5 · Answer 14 · answered Jan 20 '21 at 17:36

5

with np.printoptions(edgeitems=50):
    print(x)

Change 50 to how many lines you wanna see

Source: here

answered Jan 20 '21 at 17:36

mustafa candan

311
2
8

score 3 · Answer 15 · answered May 02 '18 at 18:33

Suppose you have a numpy array

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

If you want to print the full array in a one-off way (without toggling np.set_printoptions), but want something simpler (less code) than the context manager, just do

for row in arr:
     print row

score 3 · Answer 16 · answered Jan 12 '21 at 22:47

If you're using a jupyter notebook, I found this to be the simplest solution for one off cases. Basically convert the numpy array to a list and then to a string and then print. This has the benefit of keeping the comma separators in the array, whereas using numpyp.printoptions(threshold=np.inf) does not:

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

score 2 · Answer 17 · answered Mar 06 '19 at 05:35

You won't always want all items printed, especially for large arrays.

A simple way to show more items:

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

It works fine when sliced array < 1000 by default.

score 2 · Answer 18 · answered Dec 23 '20 at 22:39

2

If you are using Jupyter, try the variable inspector extension. You can click each variable to see the entire array.

answered Dec 23 '20 at 22:39

Jason

166
1
12

score 1 · Answer 19 · answered Aug 03 '18 at 13:01

1

You can use the array2string function - docs.

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

answered Aug 03 '18 at 13:01

Szymon Zmilczak

313
3
9

`ValueError: threshold must be numeric and non-NAN, try sys.maxsize for untruncated representation` – Eric Oct 29 '19 at 19:12

score 0 · Answer 20 · answered May 19 '20 at 03:45

If you have pandas available,

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

avoids the side effect of requiring a reset of numpy.set_printoptions(threshold=sys.maxsize) and you don't get the numpy.array and brackets. I find this convenient for dumping a wide array into a log file

score -1 · Answer 21 · edited Mar 19 '18 at 20:57

-1

If an array is too large to be printed, NumPy automatically skips the central part of the array and only prints the corners: To disable this behaviour and force NumPy to print the entire array, you can change the printing options using set_printoptions.

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

or

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

You can also refer to the numpy documentation numpy documentation for "or part" for more help.

edited Mar 19 '18 at 20:57

MSeifert

118,681
27
271
293

answered Jul 01 '17 at 13:27

Arshdeep Singh

479
6
7

3

Do not use `'nan'`, `np.nan`, or any of the above. It's unsupported, and this bad advice is causing pain for people transitioning to python 3 – Eric Nov 09 '18 at 03:55
`ValueError: threshold must be numeric and non-NAN, try sys.maxsize for untruncated representation` – Eric Oct 29 '19 at 19:13

How to print the full NumPy array, without truncation?

21 Answers21

Temporary setting

Linked

Related