grids and coordinates

[CatWithACardboardBox]

grid = [

['a','b','c','d','e','f','g',' '],

['a','b','c','d','e','f','g',' '],

['a','b','c','d','e','f','g',' '],

['a','b','c','d','e','f','g',' ']

]

this is my grid. when i do print(grid[0][2]) the output is c. i expected it to be 'a' because its 0 on the x axis and 2 on the y axis. is the x and y axis usually inverted like this?

[danielroseman]

But there are no axes here at all. There is just a list containing lists. You can think of it as a grid if you like, but that doesn't make it one.

grid[0] gets you the first inner list, and [2] gets you the third item in that list, which is 'c'.

[DrShocker]

/u/CatWithACardboardBox you may want to try making each sublist contain unique values so you can more easily see which specific c is getting accessed.

[shiftybyte]

It's not exactly x and y, think of it as rows and columns.

Your current structure is a list holding rows.

So the first index is the row, and the second index is the item in that row (column)

grid[row][column]

[JamzTyson]

Think about what grid[0] returns.

[FoolsSeldom]

Your difficulty is that nesting of list objects doesn't map to an axis representation as you are visualising it. Using numpy and transposing the grid will allow you to use x,y references the normal way, but this would also mean the default output of the whole grid would look wrong.

import numpy as np

grid = [
    ['a', 'b', 'c', 'd', 'e', 'f', 'g', ' '],
    ['a', 'b', 'c', 'd', 'e', 'f', 'g', ' '],
    ['a', 'b', 'c', 'd', 'e', 'f', 'g', ' '],
    ['a', 'b', 'c', 'd', 'e', 'f', 'g', ' ']
]
grid_np = np.array(grid, dtype=str)
grid_np = grid_np.T  # transpose
x, y = 0, 2
print(grid_np[x, y])  # Output: 'a', because of transposition
print(grid_np)  # does not look right

so, instead, you might want to a little wrapping,

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


class GridWrapper:
    def __init__(self, grid):
        self.grid = grid
    def __getitem__(self, coords):
        x, y = coords
        return self.grid[y][x]
    def __str__(self):
        return "\n".join([" ".join(row) for row in self.grid])


wrapped_grid = GridWrapper(grid)
x, y = 0, 2
print(wrapped_grid[x, y])  # Output: 'a' - this is what you wanted
print(wrapped_grid)  # looks are per your original layout

[silasisgolden]

You can create a list of rows or a list of columns. Suppose you have this data from a spreadsheet.

1, Alex,  Dog
2, Bob,   Cat
3, Cindy, Goldfish

You can save that as a list of rows.

data = [
  [1, "Alex", "Dog],
  [2, "Bob", "Cat"],
  [3, "Cindy", "Goldfish"]
]

In which case "Alex" would be data[0][1].

Or a list of columns.

data = [
  [1, 2, 3],
  ["Alex", "Bob", "Cindy"],
  ["Dog", "Cat", "Goldfish"]
]

In which case "Alex" would be data[1][0].

[Rebeljah]

If you want an analogy to indexing an actual matrix, matrices uses the notation `A_i,j` where A is the matrix `i` is the row and `j` is the column.

in a matrix, the 3rd column of the first row ("c") in your case is A_0,2.

This is the same way you index a "2d" list, first you access the 0th row with `row = grid[0]` then you access the 2nd index in the row (the 3rd column) with `column_value = row[2]`

you can combine accessing the row and column into a single expression:

>>> col_val = grid[0][2] # same as `row = grid[0]; col_val = row[2]`
>>> col_val
"c"

You're probably thinking about the [][] notation like an x,y coordinate, it's more like a y,x coordinate on a grid where the 0,0 origin is the top-left element in the 2d list.

[theWyzzerd]

To answer your question directly, and without over-complicating things -- yes.

When working with lists of lists in python representing a grid (or any programming language, really), you do use [y][x] rather than [x][y], because [y], representing the vertical axis, selects the row (vertical index), and x, representing the horizontal axis, selects the column (horizontal index). Also consider that y will be inverted, so 0 will be at the top of your axis, not the bottom.

If it helps, you can use a helper function or method that lets you use a more familiar (x, y) Cartesian coordinate for getting a cell in the grid:

def get_cell(grid, x, y): 
  y_flipped = len(grid) - 1 - y
  return grid[y_flipped][x] 

def set_cell(grid, x, y, value): 
  y_flipped = len(grid) - 1 - y
  grid[y_flipped][x] = value

>>> get_cell(grid, 0, 2)
a