Why not simply use masking here:

z[z % 3 == 0]

For your sample matrix, this will generate:

>>> z[z % 3 == 0]
array([0, 3, 6])

If you pass a matrix with the same dimensions with booleans as indices, you get an array with the elements of that matrix where the boolean matrix is True.

This will furthermore work more efficient, since you do the filtering at the numpy level (whereas list comprehension works at the Python interpreter level).

In [31]: a= np.array([1,2,3,4,10,12,13])                                        
In [32]: a                                                                      
Out[32]: array([ 1,  2,  3,  4, 10, 12, 13])

The 2 conditions individually:

In [33]: a<4                                                                    
Out[33]: array([ True,  True,  True, False, False, False, False])
In [34]: a>10                                                                   
Out[34]: array([False, False, False, False, False,  True,  True])

Join them with logical or:

In [35]: (a<4) | (a>10)                                                         
Out[35]: array([ True,  True,  True, False, False,  True,  True])

where is a tuple (size 1 because there's 1 dimension):

In [36]: np.where((a<4) | (a>10))                                               
Out[36]: (array([0, 1, 2, 5, 6]),)

That tuple can be used directly to index a:

In [37]: a[_]                                                                   
Out[37]: array([ 1,  2,  3, 12, 13])

argwhere gives the same indices but in a 'vertical' format:

In [38]: np.argwhere((a<4) | (a>10))                                            
Out[38]: 
array([[0],
       [1],
       [2],
       [5],
       [6]])

It may be easier to visualize, but isn't so useful for indexing (unless you do it iteratively).

With the logical and, the result is an empty index - no value meets both conditions:

In [39]: np.where((a<4) & (a>10))                                               
Out[39]: (array([], dtype=int64),)