Here's a simple function which returns the coordinates as a tuple (or None if no index is found). Note that this is for 2D matrices, and returns the first instance of the element in the matrix.

(Edit: see hiro protagonist's answer for an alternative Pythonic version)

def find(element, matrix):
    for i in range(len(matrix)):
        for j in range(len(matrix[i])):
            if matrix[i][j] == element:
                return (i, j)

Or, if you want to find all indexes rather than just the first:

def findall(element, matrix):
    result = []
    for i in range(len(matrix)):
        for j in range(len(matrix[i])):
            if matrix[i][j] == element:
                result.append((i, j))
    return result

You can use it like so:

A = [[5, 10],
     [15, 20],
     [25, 5]]


find(25, A) # Will return (2, 0)
find(50, A) # Will return None

findall(5, A) # Will return [(0, 0), (2, 1)]
findall(4, A) # Will return []

If you convert mymatrix to a numpy array you can jsut use numpy.where to return the indices:

>>> import numpy as np
>>> mymatrix=[[1,2,3],[4,5,6],[7,8,9]]
>>> a = np.array(mymatrix)
>>> a
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> b = np.where(a==9)
>>> b
(array([2]), array([2]))
>>> mymatrix=[[1,2,3],[9,5,6],[7,8,9]]
>>> a = np.array(mymatrix)
>>> a
array([[1, 2, 3],
       [9, 5, 6],
       [7, 8, 9]])
>>> b = np.where(a==9)
>>> b
(array([1, 2]), array([0, 2]))

First, .append() with 2 arguments isn't going to work. You probably meant to append a tuple or list consisting of ri and ei.

Also, please don't use built–in names like list for variables – that's confusing for everyone, including the interpreter.

And as for solving your problem in an efficient manner, it would be best to iterate over list (here values_sought) not in the outer–, but in the innermost loop, so as to avoid pointless checking of the same matrix coordinates multiple times, like this:

values_sought = [1, 2, 3]
matrix = [[0,1,2], [3,2,0], [1,2,3]]
coordinates = []

for row_index, row in enumerate(matrix):
    if not values_sought: break
    for column_index, value_present in enumerate(row):
        if not values_sought: break
        for value_sought_index, value_sought in enumerate(values_sought):
            if value_present == value_sought:
                coordinates.append((row_index, column_index))
                values_sought.pop(value_sought_index)
                break

Values are removed from values_sought after being found, so you may want to have a temporary list for that purpose if you need to still have these values afterwards.

Try appending this logic. Much simpler logic as we are only checking for neighbours. The main logic is to capture and x and y index when neighbours are calculated and append that to a List(List) where internal list has three elements first element second x index and third y index. And then a simple print statement can satisfy the expectation.

x = 1 # x coordinate of 1 in the matrix
y = 2 # y coordinate of 1 in the matrix

neighborsArr = []
for x_elem in (x-1, x, x+1):
    for y_elem in (y-1, y, y+1):
        element = m[y_elem][x_elem] # getting the element in m
        if m[y_elem][x_elem] != m[y][x]: # if the element is the same as itself (aka 1), remove it from neighbors
            neighborsArr.append([element,x_elem, y_elem])

print(neighborsArr)

# [[0, 0, 1], [0, 0, 2], [0, 0, 3], [2, 1, 1], [0, 1, 3], [0, 2, 1], [0, 2, 2], [0, 2, 3]]

c = random.choice(neighborsArr) # take a random element of the neighbors
print(c)
# [0, 2, 2]

print(c[0])
# 0
print("neighbour element : ", c[0], "\tx_index: ",c[1], "\ty_index :", c[2])
# neighbour element :  0    x_index:  2     y_index : 2

You may use the function np.argwhere to get the indices of a value within an array or a matrix and later use these values for a filename. See the following example:

element = 4
mat = np.array([
    [0, 1, 2],
    [3, 4, 5], 
    [6, 7, 8],
])

idxs = np.argwhere(mat == element)

print(idxs[0])  # --> [1, 1]

# Unpack the row and column index
row, col = idxs[0]

# You can then use the pair in a filename like
fname = f"file_{row}-{col}.txt"

# or similarly
fname = "file_{}-{}.txt".format(row, col)

Note however that np.argwhere always returns an array of indices.

This is indeed a NumPy-style operation, it's not particularly mathematical or Matrix-like. To use NumPy methods, first convert Q to a NumPy array first, and then search through the array, applying lambda expr: Zc in expr.free_symbols. Putting everything together,

idx = np.nonzero(np.vectorize(lambda expr: Zc in expr.free_symbols)(np.array(Q)))

returns (array([0, 1]), array([1, 0]))

Caution: this is not a tuple of row-column coordinates, this is a tuple [row coordinates], [column coordinates]. For example, if there was also Zc in bottom right cornet, then idx is

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

A more readable form, and the one you probably want, is obtained with np.array(idx).T:

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

Or, without NumPy, just loop over the elements and report what you found.

found = []
for i in range(2):
  for j in range(2):
    if Zc in Q[i, j].free_symbols:
      found.append([i, j])
print(found)

Here is a modification of this loop where we search for an expression, such as the product of two symbols. The test is whether the expression is modified if that product is replaced by 0. Also, apparently you don't want other symbols present? Check for that is added too.

found = []
for i in range(3):
  for j in range(3):
    if Q[i, j].subs(Zc*L, 0) != Q[i, j] and Q[i, j].free_symbols == set([L, Zc]):
      found.append([i, j])
print(found)