Python：循环矩阵以检查向量中的所有值

Question

I have this vector: possibleGrades=np.array([-3,0,2,4,7,10,12])

And I want the computer to tell me where in this matrix there are values which are not from the vector:

    [[ 7.   7.   4. ]
 [12.  10.  10. ]
 [-3.   7.   2. ]
 [10.   8.  12. ]
 [ nan  7.   nan]
 [ 7.   7.  10. ]
 [ 4.5  nan  2. ]
 [ 2.  12.   4. ]]

My idea:

for i in range(matrixGr):
    if (-3) in matrixGr:
        pass
    elif 0 in matrixGr:
        pass
    elif 2 in matrixGr:
        pass
    elif 4 in matrixGr:
        pass
    elif 7 in matrixGr:
        pass
    elif 10 in matrixGr:
        pass
    elif 12 in matrixGr:
        pass
    else:
        print("The data set contains incorrect grades at {location?}!")

But this is not possible and how to do it is beyond what my mental capacity can conduct.

What is a smart and possible way?

It would be very nice if it was possible to say like "row X contains invalid grade 8 (eg)", so something with string " row {:s} has the invalid grade {:s}" and.format("something smart")

Can anyone help with this?

Answer 1

You could try this:

import numpy as np

possibleGrades = np.array([-3, 0, 2, 4, 7, 10, 12])

matrixGr = np.array([[7, 7, 4],
                   [12, 10, 10],
                   [-3, 7, 2],
                   [10, 8, 12],
                   [np.nan, 7, np.nan],
                   [7, 7, 10],
                   [4.5, np.nan, 2],
                   [2, 12, 4]])

locations = [(i, j) for i in range(matrixGr.shape[0]) for j in range(matrixGr.shape[1]) if matrixGr[i, j] not in possibleGrades]

locations:
[(3, 1), (4, 0), (4, 2), (6, 0), (6, 1)]

Good luck !

Answer 2

Maybe you can try this:

possibleGrades = np.array([-3,0,2,4,7,10,12])
matrix = np.array([
    [ 7. ,  7.,   4. ],
    [12.,  10.  ,10. ],
    [-3.,   7.  , 2. ],
    [10.,   8.  ,12. ],
    [ np.nan,  7.  , np.nan],
    [ 7. ,  7.  ,10. ],
    [ 4.5,  np.nan , 2. ],
    [ 2. , 12.,   4. ]
])
line, col = np.where(np.isin(matrix, possibleGrades, invert=True))
print('locations:')
[print(f'Invalid value {matrix[line[i],col[i]]} at location ({line[i]},{col[i]})') for i in range(line.size)]

You should get the result:

locations:
Invalid value 8.0 at location (3,1)
Invalid value nan at location (4,0)
Invalid value nan at location (4,2)
Invalid value 4.5 at location (6,0)
Invalid value nan at location (6,1)

• np.isin : find elements in the vector but the option invert=True enable to invert the result.
• np.where : finds the lines and columns corresponding to True elements.

Answer 3

Here's a simple oneliner that returns the indices that are not in your list of "goodgrades" using list comprehension and the enumerate() function:

goodgrades = [-3,0,2,4,7,10,12]
testgrades = [10,-3,11]
badgrades = [ind for ind, i in enumerate(testgrades) if i not in goodgrades]

testgrades = [7,10,7] returns nothing, while [7,-1,7] returns [1].

To expand this to a list of grade lists, you can use this as a function:

def checkgrades(grades):
    return [ind for ind, i in enumerate(grades) if i not in goodgrades]

now, you can use it in a loop and print test results row by row:

for row in range(len(grades)):
    badgrades = checkgrades(grades[row])
    if badgrades != []:
        print('Bad grades found in row {} at indices {}'.format(row, badgrades))

Answer 4

Here is a one-liner that returns a boolean matrix the same size as matrixGr , with True if the grade is in possibleGrades and False otherwise:

>>> np.any(np.stack([grade==matrixGr for grade in possibleGrades]),axis=0)
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True, False,  True],
       [False,  True, False],
       [ True,  True,  True],
       [False, False,  True],
       [ True,  True,  True]])

If you want the opposite, just add np.logical_not() around it:

>>> np.logical_not(np.any(np.stack([e==mat for e in possibleGrades]),axis=0))
array([[False, False, False],
       [False, False, False],
       [False, False, False],
       [False,  True, False],
       [ True, False,  True],
       [False, False, False],
       [ True,  True, False],
       [False, False, False]])

In brief, what it does is that it builds a boolean matrix for each grade in possibleGrades , then aggregates all the result.