I have an array that might look like this:

```
ANOVAInputMatrixValuesArray = [[ 0.96488889, 0.73641667, 0.67521429, 0.592875,
0.53172222], [ 0.78008333, 0.5938125, 0.481, 0.39883333, 0.]]
```

Notice that one of the rows has a zero value at the end. I want to delete any row that contains a zero, while keeping any row that contains non-zero values in all cells.

But the array will have different numbers of rows every time it is populated, and the zeros will be located in different rows each time.

I get the number of non-zero elements in each row with the following line of code:

```
NumNonzeroElementsInRows = (ANOVAInputMatrixValuesArray != 0).sum(1)
```

For the array above, `NumNonzeroElementsInRows`

contains: [5 4]

The five indicates that all possible values in row 0 are nonzero, while the four indicates that one of the possible values in row 1 is a zero.

Therefore, I am trying to use the following lines of code to find and delete rows that contain zero values.

```
for q in range(len(NumNonzeroElementsInRows)):
if NumNonzeroElementsInRows[q] < NumNonzeroElementsInRows.max():
p.delete(ANOVAInputMatrixValuesArray, q, axis=0)
```

But for some reason, this code does not seem to do anything, even though doing a lot of print commands indicates that all of the variables seem to be populating correctly leading up to the code.

There must be some easy way to simply "delete any row that contains a zero value."

Can anyone show me what code to write to accomplish this?

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.

Licensed under: CC-BY-SA with attribution

Not affiliated with: Stack Overflow