Existe uma diferença entre `board[x, y]` e `board[x][y]` no Python?




arrays list (4)

A sintaxe do board[x, y] provavelmente está sendo aplicada a uma matriz numpy, que aceita essa sintaxe para implementar operações de fatia indexada em linha / coluna. Veja estes exemplos:

>>> x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  # creates 2D array
>>> x
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

>>> x[1]  # get second row (remember, index starts at 0)
array([4, 5, 6])

>>> x[:, 2]  # get third column
array([3, 6, 9])

>>> x[1, 2]  # get element on second row, third column
6

>>> x[1][2]  # same as before but with non-broadcasting syntax (i.e. works for lists as you are used to)
6

>>> x[1, 0:2]  # get first two elements of second row  
array([4, 5])

>>> x[0:2, 0:2]  # subsets the original array, "extracting" values from the first two columns/rows only
array([[1, 2],
       [4, 5]])

Obviamente, escrever my_list[x, y] gera um erro porque x, y é realmente uma tupla (x, y) , e as listas regulares não podem funcionar com tuplas como um valor de indexação.

Estou trabalhando em um tutorial no site GeekforGeeks e notei que eles estão verificando um ponto em uma matriz usando a board[x,y] , que eu nunca vi antes. Eu não acho que isso funcionaria, mas quando executo o programa, tudo sai como o esperado.

Tentei executar um exemplo de código menor usando o método descrito acima versus o método com o qual estou mais familiarizado ( board[x][y] ), mas quando executo meu código, obtenho TypeError: list indices must be integers or slices, not tuple

Meu código:

board = [[1,1,1], [1,2,2], [1,2,2]]
win = 'True'

if board[1][1] == 2:
    win = 'True by normal standards'
    print(win)
if board[1, 1] == 2:
    win = 'True by weird standards'
    print(win)

print(win)

O código deles:

def row_win(board, player): 
    for x in range(len(board)): 
        win = True

        for y in range(len(board)): 
            if board[x, y] != player: 
                win = False
                continue

        if win == True: 
            return(win) 
    return(win) 

Alguém pode me explicar por que o board[x,y] funciona e o que exatamente está acontecendo? Eu nunca vi isso antes, exceto para criar listas, e não estou entendendo isso conceitualmente.


Eles são capazes de fazer isso, pois estão usando o NumPy, o que não gera nenhum erro.

>>> a = np.array([[1,1,1], [1,2,2], [1,2,2]])
>>> a[1,1]
2
>>> # equivalent to
>>> a = [[1,1,1], [1,2,2], [1,2,2]]
>>> a[1][1]
2
>>> 

Isso funciona porque o objeto que eles estão usando (nesse caso, matriz numpy) sobrecarrega o método __getitem__ . Veja este exemplo de brinquedo:

class MyArray:
  def __init__(self, arr):
    self.arr = arr
  def __getitem__(self, t):
    return self.arr[t[0]][t[1]]

myarr = MyArray([[1,1,1], [1,2,2], [1,2,2]])
print(myarr[0,1])

Na verdade, ele não funciona no Python base (como no seu exemplo). Se você executar seu código, o Python lançará uma exceção: 'TypeError: os índices da lista devem ser números inteiros ou fatias, não tuplas'.

O 1, 1 passado para o board é interpretado como uma tupla e, como o quadro deve ser indexado com números inteiros ou fatias, isso não funcionará.

No entanto, se o board fosse algum tipo de estrutura de dados do tipo array e o desenvolvedor implementasse o suporte à indexação com tuplas, isso funcionaria. Um exemplo disso é matrizes numpy .







indexing