from pprint import pprint
pprint(the_list)

Python 2, 74 73 72 bytes

-1 thanks to loopy walt

-1 thanks to dingledooper

f=lambda l,s=',\n  ':l<[f]and`l`or'[ %s ]'%s.join(f(r,s+'  ')for r in l)

Try it online!

Ok, I'm a molecular biologist and not a professional programmer, so bear with me.
In my very naïf opinion, which you shouldn't take into much consideration, one of the options is to make your own version of pprint, aware of numpy's ndarray objects, and printing them the way you want them.

What I did, and it worked with me, is to open the pprint module (under the Lib directory) and create a modified copy, like this:

(I pasted the working, modified code on pastebin, you can find it here )

First, in the import section, have it try to import numpy's ndarray, by adding:

try:
    from numpy import ndarray
    np_arrays = True
except ImportError:
    np_arrays = False

Then, in the definition of the _format function, right after this:

# This is already there
if self._depth and level > self._depth:
    write(rep)
    return

(so at line 154 in my copy, after the imports) you should add:

# Format numpy.ndarray object representations
if np_arrays and issubclass(typ, ndarray):
    write('array(dtype:' + str(object.dtype))
    write('; shape: ' + str(object.shape) + ')')
    return

(then the function continues with, r = getattr(typ, "__repr__", None)...)

Now save this script in the same Lib directory where pprint is, with a new name like i.e. mypprint.py and then try:

from mypprint import pprint
pprint.pprint(object_with_np.arrays)  

If A.ndim is not in 1, 2, 3, your code tries to return a non-existing string s. It would be better to be explicit about what your code supports atm:

def ndtotext(A, w=None, h=None):
    ...
    else:
        raise NotImplementedError("Currently only 1 - 3 dimensions are supported")
    return s

While we are at the point of having your code be clear about what is happening, you should add a docstring explaining what your code does:

def ndtotext(A, w=None, h=None):
    """Returns a string to pretty print the numpy.ndarray `A`.

    Currently supports 1 - 3 dimensions only.
    Raises a NotImplementedError if an array with more dimensions is passed.

    Describe `w` and `h`.
    """
    ...

Next, Python has an official style-guide, PEP8, which programmers are encouraged to follow. One of the things it recommends is surrounding operators with spaces (which I fixed in the rest of the code) and using lower_case for variables and functions (which I left as is for now).

Now, let's come to your actual code:

• You calculate some values multiple times (like str(A[0])), save those to a variable.
• If you want to compare to None, use is (since it is a singleton).
• No else needed after an if...return (this is a matter of personal style, I prefer not having the additional level of indentation).
• Use str.rjust to add enough whitespace in front of your strings. You could also use str.format for this, but it looks less nice.
• Your w has a weird structure, with the width of the first column being the last entry and the rest starting at zero.
• Give the unicode values names. And then add functions to draw a line of specified length.

• String addition is costly and slow. Try to consistently use building a list and str.joining it.

  UPPER_LEFT = u'\u250c'
  UPPER_RIGHT = u'\u2510'
  LOWER_LEFT = u'\u2514'
  LOWER_RIGHT = u'\u2518'
  HORIZONTAL = u'\u2500'
  VERTICAL = u'\u2502'
  
  def upper_line(width):
      return UPPER_LEFT + HORIZONTAL * width + UPPER_RIGHT
  
  def lower_line(width):
      return LOWER_LEFT + HORIZONTAL * width + LOWER_RIGHT
  
  def left_line(height):
      return "\n".join([UPPER_LEFT] + [VERTICAL] * height + [LOWER_LEFT])
  
  def right_line(height):
      return "\n".join([UPPER_RIGHT] + [VERTICAL] * height + [LOWER_RIGHT])
  
  def ndtotext(A, w=None, h=None):
      """Returns a string to pretty print the numpy.ndarray `A`.
  
      Currently supports 1 - 3 dimensions only.
      Raises a NotImplementedError if an array with more dimensions is passed.
  
      Describe `w` and `h`.
      """
      if A.ndim == 1:
          if w is None:
              return str(A)
          s = " ".join([str(value).rjust(width) for value, width in zip(A, w)])
          return '[{}]'.format(s)
      elif A.ndim == 2:
          widths = [max([len(str(s)) for s in A[:, i]]) for i in range(A.shape[1])]
          s = "".join([' ' + ndtotext(AA, w=widths) + ' \n' for AA in A])
          w0 = sum(widths) + len(widths) - 1 + 2 # spaces between elements and corners
          return upper_line(w0) + '\n'  + s + lower_line(w0)
      elif A.ndim == 3:
          h = A.shape[1]
          strings = [left_line(h)]
          strings.extend(ndtotext(a) + '\n' for a in A)
          strings.append(right_line(h))
          return '\n'.join(''.join(pair) for pair in zip(*map(str.splitlines, strings)))
      raise NotImplementedError("Currently only 1 - 3 dimensions are supported")
  

This can probably be even more compactified, but I think it is a good start.

Example usage:

x = np.arange(12)

print(ndtotext(x))
[ 0  1  2  3  4  5  6  7  8  9 10 11]

print(ndtotext(x.reshape(3, 4)))
┌───────────┐
 [0 1  2  3] 
 [4 5  6  7] 
 [8 9 10 11] 
└───────────┘

print(ndtotext(x.reshape(3, 2, 2)))
┌┌─────┐┌─────┐┌───────┐┐
│ [0 1]  [4 5]  [ 8  9] │
│ [2 3]  [6 7]  [10 11] │
└└─────┘└─────┘└───────┘┘

Use numpy.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. ]

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]

instead of

[ 0.078  0.48   0.413  0.83   0.776  0.102  0.513  0.462  0.335  0.712]