You can use a bool index array that you can produce using np.in1d.

You can index a np.ndarray along any axis you want using for example an array of bools indicating whether an element should be included. Since you want to index along axis=0, meaning you want to choose from the outest index, you need to have 1D np.array whose length is the number of rows. Each of its elements will indicate whether the row should be included.

A fast way to get this is to use np.in1d on the second column of a. You get all elements of that column by a[:, 1]. Now you have a 1D np.array whose elements should be checked against your filter. Thats what np.in1d is for.

So the complete code would look like:

import numpy as np

a = np.asarray([[2,'a'],[3,'b'],[4,'c'],[5,'d']])
filter = np.asarray(['a','c'])
a[np.in1d(a[:, 1], filter)]

or in a longer form:

import numpy as np

a = np.asarray([[2,'a'],[3,'b'],[4,'c'],[5,'d']])
filter = np.asarray(['a','c'])
mask = np.in1d(a[:, 1], filter)
a[mask]

You should perform the condition only over the first column:

x_displayed = xy_dat[((xy_dat[:,0] > min) & (xy_dat[:,0] < max))]

What we do here is constructing a view where we only take into account the first column with xy_dat[:,0]. By now checking if this 1d is between bounds, we construct a 1D boolean array of the rows we should retain, and now we make a selection of these rows by using it as item in the xy_dat[..] parameter.

>>> a[ (-6<a[:,1]) & (a[:,1]<3) ]

array([[ 1,  2],
       [ 3, -5]])

You need to chain all conditions with bitwise operators and the perform boolean indexing:

array[(array[:,0] > 0) & (array[:,0] < 100) & (array[:,3] > 90) & (array[:,3] < 100)]

array([[ 4.  , 78.01, 65.  , 98.  ],
       [ 6.  , 45.98, 56.54, 98.76]])

you can use multiple filters in a slice, something like this:

x = np.arange(90.).reshape(30, 3)
#set the first 10 rows of cols 1,2 to be zero
x[0:10, 0:2] = 0.0
x[(x[:,0] == 0.) & (x[:,1] == 0.) & (x[:,2] > 10)]
#should give only a few rows
array([[  0.,   0.,  11.],
       [  0.,   0.,  14.],
       [  0.,   0.,  17.],
       [  0.,   0.,  20.],
       [  0.,   0.,  23.],
       [  0.,   0.,  26.],
       [  0.,   0.,  29.]])

You can use np.in1d to get a boolean mask and use it to filter columns in the sorted array, something like this -

output = sortedNonFiltered[:,np.in1d(sortedNonFiltered[0],listOfValues)]

Sample run -

In [76]: nonSortedNonFiltered
Out[76]: 
array([[9, 8, 5, 4, 6, 7, 1, 2, 3],
       [1, 3, 2, 6, 4, 5, 7, 9, 8]])

In [77]: sortedNonFiltered
Out[77]: 
array([[9, 5, 8, 6, 7, 4, 1, 3, 2],
       [1, 2, 3, 4, 5, 6, 7, 8, 9]])
In [78]: listOfValues
Out[78]: array([8, 6, 5, 2, 1])

In [79]: sortedNonFiltered[:,np.in1d(sortedNonFiltered[0],listOfValues)]
Out[79]: 
array([[5, 8, 6, 1, 2],
       [2, 3, 4, 7, 9]])

Using np.array instead of np.matrix allows you to do a simple mask indexing like:

a = a[a[:, 2] != 0]

to convert from np.matrix to np.array you can do:

a = np.asarray(a)    

You can use the NumPy-based library, Pandas, which has a more generally useful implementation of ndarrays:

>>> # import the library
>>> import pandas as PD

Create some sample data as python dictionary, whose keys are the column names and whose values are the column values as a python list; one key/value pair per column

>>> data = {'category_code': ['D', 'A', 'B', 'C', 'D', 'A', 'C', 'A'], 
            'value':[4, 2, 6, 3, 8, 4, 3, 9]}

>>> # convert to a Pandas 'DataFrame'
>>> D = PD.DataFrame(data)

To return just the rows in which the category_code is either B or C, two steps conceptually, but can easily be done in a single line:

>>> # step 1: create the index 
>>> idx = (D.category_code== 'B') | (D.category_code == 'C')

>>> # then filter the data against that index:
>>> D.ix[idx]

        category_code  value
   2             B      6
   3             C      3
   6             C      3

Note the difference between indexing in Pandas versus NumPy, the library upon which Pandas is built. In NumPy, you would just place the index inside the brackets, indicating which dimension you are indexing with a ",", and using ":" to indicate that you want all of the values (columns) in the other dimension:

>>>  D[idx,:]

In Pandas, you call the the data frame's ix method, and place only the index inside the brackets:

>>> D.loc[idx]

Once you actually use numpy.arrays, it all works:

import numpy as np

selections = np.array([True, False, True])
data = np.array([[ 1, 2, 3 ],
        [ 4, 5, 6 ]])

>>> data[:, selections]
array([[1, 3],
       [4, 6]])