One approach with boolean-indexing would be -

mask = np.in1d(np.arange(A.size),B)
out = np.r_[A[mask], A[~mask]]

Sample run -

In [26]: A = np.array([ 1, 2, 5, 9.8, 55, 3])

In [27]: B = np.array([ 3, 4])

In [28]: mask = np.in1d(np.arange(A.size),B)

In [29]: np.r_[A[mask], A[~mask]]
Out[29]: array([  9.8,  55. ,   1. ,   2. ,   5. ,   3. ])

Another with integer-indexing -

idx = np.setdiff1d(np.arange(A.size),B)
out = np.r_[A[B], A[idx]]

Sample run -

In [36]: idx = np.setdiff1d(np.arange(A.size),B)

In [37]: np.r_[A[B], A[idx]]
Out[37]: array([  9.8,  55. ,   1. ,   2. ,   5. ,   3. ])

Here's an approach using advanced-indexing -

# arr: Input array, rm_idx : 2-row list/array of indices to be removed
m,n,p = arr.shape
mask = np.asarray(rm_idx[1])[:,None] != np.arange(n)
out = arr[np.arange(m)[:,None],np.where(mask)[1].reshape(m,-1)]

Alternatively, with boolean-indexing -

out = arr.reshape(-1,p)[mask.ravel()].reshape(m,-1,p)

A bit less memory-intensive approach as we try to avoid creating 2D mask -

vmask = ~np.in1d(np.arange(m*n),rm_idx[1] + n*np.arange(m))
out = arr.reshape(-1,p)[vmask].reshape(m,-1,p)

A possible solution using mode:

>>> from scipy.stats import mode
>>> eps = 5
>>> most_freq = mode(circles[:, 0])[0][0]
>>> mask = np.abs(circles[:, 0] - most_freq) <= eps
>>> circles[mask]
array([[288, 300,  25],
   [288, 362,  25],
   [288, 238,  24]])

Edit: if your circles array is limited to to non-negative integers, you can use the following expression for most_freq:

most_freq = np.bincount(circles[:, 0]).argmax()

You can play around with the name of field.

r=[(x['SHAPE@XY'][i][0],x['SHAPE@XY'][i][1],x['PrimeKey'][i]) for i in range(x.shape[0])]
x=np.rec.fromrecords(r, formats = 'f8,f8,i4', names = 'SHAPE@X,SHAPE@Y,PrimeKey')
rec.array([(506173.7478, 5455684.263900001, 1),
       (506175.22869999986, 5455648.723099999, 2),
       (506229.03359999973, 5455661.5572999995, 3),
       (506250.25939999986, 5455614.169500001, 4),
       (506305.54509999976, 5455579.122300001, 5),
       (506331.70710000023, 5455688.2129, 6)], 
      dtype=[('SHAPE@X', '<f8'), ('SHAPE@Y', '<f8'), ('PrimeKey', '<i4')])

Use numpy.delete(), which returns a new array with sub-arrays along an axis deleted.

numpy.delete(a, index)

For your specific question:

import numpy as np

a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
index = [2, 3, 6]

new_a = np.delete(a, index)

print(new_a)
# Output: [1, 2, 5, 6, 8, 9]

Note that numpy.delete() returns a new array since array scalars are immutable, similar to strings in Python, so each time a change is made to it, a new object is created. I.e., to quote the delete() docs:

"A copy of arr with the elements specified by obj removed. Note that delete does not occur in-place..."

If the code I post has output, it is the result of running the code.

Creating example data for testing:

>>> import numpy as np
>>> data = np.array([
... [1,2,3,4],
... [5,7,8,9],
... [7,5,1,0]
... ])

You can slice the array to get the first column:

>>> data[:, 0]
array([1, 5, 7])

Figure out which of these first-column values is in range by broadcasting the comparison operators across them (being careful that we can't chain these operators, and must combine them using a bitwise rather than logical AND, because of syntax limitations):

>>> first = data[:, 0]
>>> (4 <= first) & (first <= 6)
array([False,  True, False])

Finally, we can use that to mask the original array:

>>> data[(4 <= first) & (first <= 6)]
array([[5, 7, 8, 9]])

You needn't do that in two lines. Numpy allows you to splice within a single statement, like this:

room_matrix[1:3, 1:3]
#will slice rows starting from 1 to 2 (row numbers start at 0), likewise for columns