You can use boolean indexing.

In [413]: x[x[:, -1] != 0]
Out[413]: 
array([[0, 2, 1],
       [0, 1, 1],
       [1, 0, 2],
       [2, 1, 2]])

1. x[:, -1] will retrieve the last column

2. x[:, -1] != 0 returns a boolean mask

3. Use the mask to index into the original array

If you want to keep using numpy, the solution isn't hard.

data = data[np.logical_not(np.logical_and(data[:,0] > 20, data[:,0] < 25))]
data = data[np.logical_not(np.logical_and(data[:,0] > 30, data[:,0] < 35))]

Or if you want to combine it all into one statement,

data = data[
    np.logical_not(np.logical_or(
        np.logical_and(data[:,0] > 20, data[:,0] < 25),
        np.logical_and(data[:,0] > 30, data[:,0] < 35)
    ))
]

To explain, conditional statements like data[:,0] < 25 create boolean arrays that track, element-by-element, where the condition in an array is true or false. In this case, it tells you where the first column of data is less than 25.

You can also index numpy arrays with these boolean arrays. A statement like data[data[:,0] > 30] extracts all the rows where data[:,0] > 30 is true, or all the rows where the first element is greater than 30. This kind of conditional indexing is how you extract the rows (or columns, or elements) that you want.

Finally, we need logical tools to combine boolean arrays element-by-element. Regular and, or, and not statements don't work because they try to combine the boolean arrays together as a whole. Fortunately, numpy provides a set of these tools for use in the form of np.logical_and, np.logical_or, and np.logical_not. With these, we can combine our boolean arrays element-wise to find rows that satisfy more complicated conditions.

The simplest way to delete rows and columns from arrays is the numpy.delete method.

Suppose I have the following array x:

x = array([[1,2,3],
        [4,5,6],
        [7,8,9]])

To delete the first row, do this:

x = numpy.delete(x, (0), axis=0)

To delete the third column, do this:

x = numpy.delete(x,(2), axis=1)

So you could find the indices of the rows which have a 0 in them, put them in a list or a tuple and pass this as the second argument of the function.

Numpy provides the where function:

import numpy as np
>>> x = np.array([1,2,3,4])
>>> x
array([1, 2, 3, 4])
>>> np.where(x <= 2)
(array([0, 1], dtype=int64),)

or

>>> x = np.arange(6).reshape(2, 3)
>>> x
array([[0, 1, 2],
       [3, 4, 5]])

>>> x[np.where( x < 5 )]
array([0, 1, 2, 3, 4])

using where and delete in combination, you can for example delete the first row in the above matrix using this:

>>> np.delete(x, np.where(np.all(x < 3,axis=1)), axis=0)
array([[3, 4, 5]])

you can change the indices_or_sections value to length of the first axis, this will prevent any empty arrays from being produced

import numpy as np

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

arr_split = np.array_split(arr1,
                           indices_or_sections = arr1.shape[0],
                           axis = 0)

arr_split

>>> [
    array([[1., 2., 3.]]),
    array([[4., 5., 6.]]),
    array([[7., 8., 9.]])
]

Note, numpy supports vectorized comparisons:

>>> test
array([[1, 2, 'a'],
       [4, 5, 6],
       [7, 'a', 9],
       [10, 11, 12]], dtype=object)
>>> test == 'a'
array([[False, False,  True],
       [False, False, False],
       [False,  True, False],
       [False, False, False]], dtype=bool)

Now, you want the rows where all are not equalt to 'a':

>>> (test != 'a').all(axis=1)
array([False,  True, False,  True], dtype=bool)

So, simply select the rows with the mask:

>>> row_mask = (test != 'a').all(axis=1)
>>> test[row_mask,:]
array([[4, 5, 6],
       [10, 11, 12]], dtype=object)

You can easily do it with this piece of code:

new_data = data[(data == -1).sum(axis=1) < 2]

Result:

>>> new_data
array([[ 1.1,  1.2,  1.3,  1.4],
       [ 2.1,  2.2,  2.3, -1. ]])

You can use something like this: first create dictionary of occurrences of each value in the sub arrays using np.unique and only keep arrays where no positive number appears more than once.

A = np.array([[-1, -1, -1, -1], [-1, -1, 1, 2], [-1, -1, 1, 1], [2, 1, -1, 2]])

new_array = []

# loop through each array
for array in A:
    # Get a dictionary of the counts of each value
    unique, counts = np.unique(array, return_counts=True)
    counts = dict(zip(unique, counts))
    # Find the number of occurences of postive numbers
    positive_occurences = [value for key, value in counts.items() if key > 0]
    # Append to new_array if no positive number appears more than once
    if any(y > 1 for y in positive_occurences):
        continue
    else:
        new_array.append(array)

new_array = np.array(new_array)

this returns:

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

From your example, you want to remove row with index 1 from the first array,
and row with index 3 from the second array.
So use those indices when executing np.delete:

a1 = np.delete(i, z[0][0], axis=0)