Because all of the errors have the same relative weight. Supplying a weight parameter does not change the actual values you are averaging, it just indicates the weight with which each value value contributes to the average. In other words, after multiplying each value passed by its corresponding weight, np.average divides by the sum of the weights provided.

>>> import numpy as np
>>> np.average([1, 2, 3], weights=[0.2, 0.2, 0.2])
2.0
>>> np.average([1, 2, 3])
2.0

Effectively, the average formula for an n-dimensional array-like container is

where each weight is assumed to be equal to 1 when not provided to numpy.average.

As an addenda to the comments and answers, let's test the speed for a simple case - axis=0 on a 2d array:

In [48]: A = np.arange(10000).reshape(100,100)

In [49]: timeit np.average(A, axis=0)
53.5 µs ± 170 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [50]: timeit np.mean(A, axis=0)
52.4 µs ± 179 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [51]: timeit A.mean(axis=0)
48.2 µs ± 79.6 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

average and mean time almost the same. The method version a bit faster. The difference lies in the complexity of the outer calling structure, not in the actual calculation.

np.average is written in Python (follow the [source] line in the docs). For the no-weights case, it ends up using a.mean, the mean method of the array. np.mean also uses the method (though the outer python code layer is a bit more obscure).

You can create a 3D array containing your 2D arrays to be averaged, then average along axis=0 using np.mean or np.average (the latter allows for weighted averages):

np.mean( np.array([ old_set, new_set ]), axis=0 )

This averaging scheme can be applied to any (n)-dimensional array, because the created (n+1)-dimensional array will always contain the original arrays to be averaged along its axis=0.