Pythonic and efficient way of finding adjacent cells in grid

It wasn't clear to me if there was other information in the cells than just the x and y coordinates. In any case, I think that a change of data structures is needed to make this faster.

I assumed that there is extra information in the cells and made grid.cells as a dictionary with the keys being tuples of the coordinates. A similar thing could be done withgrid.cells as a set if there is only the coordinate information in the cells.

def get_adjacent_cells( self, x_coord, y_coord ):
    result = {}
    for x,y in [(x_coord+i,y_coord+j) for i in (-1,0,1) for j in (-1,0,1) if i != 0 or j != 0]:
        if (x,y) in grid.cells:
            result[(x,y)] = grid.cells[(x,y)]

Depending on what you want to do with the data, you might not want to make result a dict, but hopefully you get the idea. This should be much faster than your code because your code is making 8 checks on every cell in grid.cells.

Your code is going to be as slow as large is your grid, because you're iterating over the cells just to get 8 of them (of which you already know their coordinates).

If you can do random access by their indices, I suggest something like the following:

adjacency = [(i,j) for i in (-1,0,1) for j in (-1,0,1) if not (i == j == 0)] #the adjacency matrix

def get_adjacent_cells( self, cell ):
     x_coord = cell.x_coord
     y_coord = cell.y_coord
     for dx, dy in adjacency:
          if 0 <= (x_coord + dx) < max_x and 0 <= y_coord + dy < max_y: #boundaries check
#yielding is usually faster than constructing a list and returning it if you're just using it once
              yield grid[x_coord + dx, y_coord + dy]

max_x and max_y are supposed to be the size of the grid, and the grid.__getitem__ is supposed to accept a tuple with the coordinates and return the cell in that position.

Well, this won't help performance any, but you can avoid code duplication by saying

if abs(c.x_coord - x_coord) == 1 or abs(c.y_coord - y_coord) == 1:
    result.append(c)

To affect performance, your grid cells should know who their neighbors are, either through an attribute like c.neighbors, or through an implicit structure, like a list of lists, so you can access by coordinate.

grid = [[a,b,c],
        [d,e,f],
        [g,h,i]]

Then you can check for neighborliness using the list indices.

This is probably the most efficient way to look for neighbours if grid.cells is implemented as a set (though there's a mistake in the first if-statement - you need to test for equality to x_coord + 1 rather than to x_coord).

However, implementing grid.cells as a list of lists would allow you to refer to individual cells by row and column number. It would also allow you to measure the total number of rows and columns. get_adjacent_cells could then work by first checking which edges border the current cell, and then looking up the neighbours in all other directions and appending them to the result list.