# How to print the full NumPy array, without truncation?

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

94

Use `numpy.set_printoptions`:

``````import sys
import numpy
numpy.set_printoptions(threshold=sys.maxsize)
``````
Tuesday, June 1, 2021

79

You can use `set_printoptions` to set the precision of the output:

``````import numpy as np
x=np.random.random(10)
print(x)
# [ 0.07837821  0.48002108  0.41274116  0.82993414  0.77610352  0.1023732
#   0.51303098  0.4617183   0.33487207  0.71162095]

np.set_printoptions(precision=3)
print(x)
# [ 0.078  0.48   0.413  0.83   0.776  0.102  0.513  0.462  0.335  0.712]
``````

And `suppress` suppresses the use of scientific notation for small numbers:

``````y=np.array([1.5e-10,1.5,1500])
print(y)
# [  1.500e-10   1.500e+00   1.500e+03]
np.set_printoptions(suppress=True)
print(y)
# [    0.      1.5  1500. ]
``````

See the docs for set_printoptions for other options.

To apply print options locally, using NumPy 1.15.0 or later, you could use the numpy.printoptions context manager. For example, inside the `with-suite` `precision=3` and `suppress=True` are set:

``````x = np.random.random(10)
with np.printoptions(precision=3, suppress=True):
print(x)
# [ 0.073  0.461  0.689  0.754  0.624  0.901  0.049  0.582  0.557  0.348]
``````

But outside the `with-suite` the print options are back to default settings:

``````print(x)
# [ 0.07334334  0.46132615  0.68935231  0.75379645  0.62424021  0.90115836
#   0.04879837  0.58207504  0.55694118  0.34768638]
``````

If you are using an earlier version of NumPy, you can create the context manager yourself. For example,

``````import numpy as np
import contextlib

@contextlib.contextmanager
def printoptions(*args, **kwargs):
original = np.get_printoptions()
np.set_printoptions(*args, **kwargs)
try:
yield
finally:
np.set_printoptions(**original)

x = np.random.random(10)
with printoptions(precision=3, suppress=True):
print(x)
# [ 0.073  0.461  0.689  0.754  0.624  0.901  0.049  0.582  0.557  0.348]
``````

To prevent zeros from being stripped from the end of floats:

`np.set_printoptions` now has a `formatter` parameter which allows you to specify a format function for each type.

``````np.set_printoptions(formatter={'float': '{: 0.3f}'.format})
print(x)
``````

which prints

``````[ 0.078  0.480  0.413  0.830  0.776  0.102  0.513  0.462  0.335  0.712]
``````

``````[ 0.078  0.48   0.413  0.83   0.776  0.102  0.513  0.462  0.335  0.712]
``````
Tuesday, June 1, 2021

73

In Python `(1)` means just `1`. `()` can be freely added to group numbers and expressions for human readability (e.g. `(1+3)*3` v `(1+3,)*3`). Thus to denote a 1 element tuple it uses `(1,)` (and requires you to use it as well).

Thus

``````(array([4, 5, 6, 7, 8]),)
``````

is a one element tuple, that element being an array.

If you applied `where` to a 2d array, the result would be a 2 element tuple.

The result of `where` is such that it can be plugged directly into an indexing slot, e.g.

``````a[where(a>0)]
a[a>0]
``````

should return the same things

as would

``````I,J = where(a>0)   # a is 2d
a[I,J]
a[(I,J)]
``````

``````In [278]: a=np.array([1,2,3,4,5,6,7,8,9])
In [279]: np.where(a>4)
Out[279]: (array([4, 5, 6, 7, 8], dtype=int32),)  # tuple

In [280]: a[np.where(a>4)]
Out[280]: array([5, 6, 7, 8, 9])

In [281]: I=np.where(a>4)
In [282]: I
Out[282]: (array([4, 5, 6, 7, 8], dtype=int32),)
In [283]: a[I]
Out[283]: array([5, 6, 7, 8, 9])

In [286]: i, = np.where(a>4)   # note the , on LHS
In [287]: i
Out[287]: array([4, 5, 6, 7, 8], dtype=int32)  # not tuple
In [288]: a[i]
Out[288]: array([5, 6, 7, 8, 9])
In [289]: a[(i,)]
Out[289]: array([5, 6, 7, 8, 9])
``````

======================

`np.flatnonzero` shows the correct way of returning just one array, regardless of the dimensions of the input array.

``````In [299]: np.flatnonzero(a>4)
Out[299]: array([4, 5, 6, 7, 8], dtype=int32)
In [300]: np.flatnonzero(a>4)+10
Out[300]: array([14, 15, 16, 17, 18], dtype=int32)
``````

It's doc says:

This is equivalent to a.ravel().nonzero()[0]

In fact that is literally what the function does.

By flattening `a` removes the question of what to do with multiple dimensions. And then it takes the response out of the tuple, giving you a plain array. With flattening it doesn't have make a special case for 1d arrays.

===========================

@Divakar suggests `np.argwhere`:

``````In [303]: np.argwhere(a>4)
Out[303]:
array([[4],
[5],
[6],
[7],
[8]], dtype=int32)
``````

which does `np.transpose(np.where(a>4))`

Or if you don't like the column vector, you could transpose it again

``````In [307]: np.argwhere(a>4).T
Out[307]: array([[4, 5, 6, 7, 8]], dtype=int32)
``````

except now it is a 1xn array.

We could just as well have wrapped `where` in `array`:

``````In [311]: np.array(np.where(a>4))
Out[311]: array([[4, 5, 6, 7, 8]], dtype=int32)
``````

Lots of ways of taking an array out the `where` tuple (`[0]`, `i,=`, `transpose`, `array`, etc).

Sunday, August 1, 2021

56

2 ways to solve this:

You can solve this by replacing

``````A *= B
``````

with

``````A = (A * B)
``````

or with

``````numpy.multiply(A, B, out=A, casting='unsafe')
``````
Wednesday, August 11, 2021

21

This has nothing to do with the null terminator. a string must be null-terminated.

You're facing issues with the trailing newline (`n`) here. you have to strip off that newline before passing the string to `printf()`.

Easiest way [requires modification of `str`]: You can do this with `strcspn()`. Pseudo code:

``````str[strcspn(str,"n")] = 0;
``````

if possible, to achieve this output without modifying the strings.

Yes, possible, too. In that case, you need to use the length modifier with `printf()` to limit the length of the array to be printed, something like,

``````printf("%15s", str);  //counting the ending `.` in str as shown
``````

but IMHO, this is not the best way, as, the length of the string has to be known and fixed, otherwise, it won't work.

A little flexible case,

``````printf("%.*s", n, str);
``````

where, `n` has to be supplied and it needs to hold the length of the string to be printed, (without the newline)

Wednesday, October 6, 2021