In addition to my comment, math.isclose uses abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol) which is commutative, but at the cost of an additional operation (which could be costly for numpy arrays which need to be stacked in order to find the maximum). It isn't hard to implement your own if you really require this property:

def isclose_comm(a, b, rtol=1e-5, atol=1e-8):
   ab = np.stack((a, b))
   return np.abs(a - b) <= (atol + rtol * ab.max(axis=0))

x = np.random.random(5)

x
Out[94]: array([0.36007049, 0.86934972, 0.05827216, 0.60794612, 0.24539454])

y = x + np.random.random(5)/1e6

y
Out[96]: array([0.36007072, 0.86934976, 0.05827312, 0.6079464 , 0.24539492])

np.isclose(x, y)
Out[97]: array([ True,  True,  False,  True,  True])

isclose_comm(x, y)
Out[98]: array([ True,  True,  True,  True,  True])

z = np.zeros(5)

isclose_comm(x, z)
Out[100]: array([False, False, False, False, False])

allclose equivelent:

def allclose_comm(a, b, rtol=1e-5, atol=1e-8):
    return isclose_comm(a, b, rtol, atol).all()

What's happening is that allclose broadcasts its input. This allows comparisons with similarly shaped arrays (e.g. 3 and [3, 3, 3]) following the broadcasting rules.

For your purposes, have a look at the numpy.testing functions, specifically np.testing.assert_allclose or assert_array_almost_equal, which will check for shape as well as values. (I don't remember the difference between those two offhand, but it relates to the way they calculate floating point differences.)

These are particularly handy if you're using assert-based unit testing.

Most (all?) of the numpy.testing.assert_* functions check for array shape as well as value equality.

For example:

In [1]: import numpy as np

In [2]: np.testing.assert_allclose([1], [[1]])

Which yields:

AssertionError:
Not equal to tolerance rtol=1e-07, atol=0

(shapes (1,), (1, 1) mismatch)
 x: array([1])
 y: array([[1]])

Another useful (and currently not as well documented as it could be) thing to know about these functions is that they compare NaN's as equal.

For example, this will succeed:

In [3]: np.testing.assert_allclose([np.nan], [np.nan])

While numpy.allclose will return False for the same case:

In [4]: np.allclose([np.nan], [np.nan])
Out[4]: False

On a side note, numpy.isclose (but not allclose) has an equal_nan kwarg to control this.

Rather than using np.isclose, use np.allclose. This will return a single boolean value for that comparison.