Estou usando numpy e desejo indexar uma linha sem perder as informações de dimensão.
import numpy as np
X = np.zeros((100,10))
X.shape # >> (100, 10)
xslice = X[10,:]
xslice.shape # >> (10,) Neste exemplo, xslice agora tem 1 dimensão, mas eu quero que seja (1,10). Em R, eu usaria X [10,:, drop = F]. Existe algo semelhante em entorpecido. Não consegui encontrar na documentação e não vi uma pergunta semelhante feita.
Obrigado!
Respostas:
Provavelmente é mais fácil de fazer x[None, 10, :]ou de forma equivalente (mas mais legível)x[np.newaxis, 10, :] .
Quanto ao motivo pelo qual não é o padrão, pessoalmente, acho que ter matrizes constantemente com dimensões singleton se torna irritante muito rapidamente. Eu acho que os devs entorpecidos se sentiram da mesma maneira.
Além disso, arrays de transmissão de controle entorpecido muito bem, então geralmente há poucos motivos para reter a dimensão do array de onde veio o slice. Se você fez isso, coisas como:
a = np.zeros((100,100,10))
b = np.zeros(100,10)
a[0,:,:] = bou não funcionaria ou seria muito mais difícil de implementar.
(Ou pelo menos esse é o meu palpite sobre o raciocínio do devedor entorpecido por trás de descartar informações de dimensão ao fatiar)
Nones ao lado das sombras que você está cortando.
b; deveria ser b = np.zeros((100,10)).
X[10,None](usando seu código como exemplo).
np.matmul()ou@ ). Acabei de me queimar com isso.
Outra solução é fazer
X[[10],:]ou
I = array([10])
X[I,:]A dimensionalidade de uma matriz é preservada quando a indexação é realizada por uma lista (ou matriz) de índices. Isso é bom porque deixa você com a escolha entre manter a dimensão e comprimir.
x = np.array([[1,2,3,4]]) se você cortá- x[[0],[1,2]] lo, obterá o unidimensional. array([2, 3]) Minha opinião é que ao selecionar vetores de coluna ou linha, é melhor tornar o corte simples e, em seguida np.reshape, usar . Então, no meu exemplo serianp.reshape(x[0,[1,2]],[1,2])
X[[10]]seria interpretado como X[10]e a forma seria menor; da mesma forma, X[[10, 20]] == X[10, 20]e a forma é ainda menor
aforma (10, 20, 30), então a[0, :, [0]]terá forma (1, 20), não (20, 1), porque neste último os índices são transmitidos para o a[[0], :, [0]]que muitas vezes não é bem o que você espera! Visto a[0, :, :1]que lhe dará (20, 1)como esperado. Além disso, veja o comentário acima para casos extremos esquisitos com índice único. No geral, parece que esse método tem muitos casos extremos.
Encontrei algumas soluções razoáveis.
1) usar numpy.take(X,[10],0)
2) use esta indexação estranha X[10:11:, :]
Idealmente, este deve ser o padrão. Nunca entendi por que as dimensões são abandonadas. Mas isso é uma discussão para numpy ...
alist[0]e mantidas ao dividi-las.
slice(n, n+1)para extração de índice n) deve ser a resposta aceita, pois é a única que se estende naturalmente ao caso n-dimensional.
X[10:11, :]no Python 3.7.5 (ou seja, sem os dois pontos extras após o 11)
Aqui está uma alternativa que eu gosto mais. Em vez de indexar com um único número, indexe com um intervalo. Ou seja, use X[10:11,:]. (Observe que 10:11não inclui 11).
import numpy as np
X = np.zeros((100,10))
X.shape # >> (100, 10)
xslice = X[10:11,:]
xslice.shape # >> (1,10)Isso torna mais fácil entender com mais dimensões também, sem Nonefazer malabarismos e descobrir qual eixo usar qual índice. Também não há necessidade de fazer contabilidade extra em relação ao tamanho do array, apenas i:i+1para qualquer um ique você usaria na indexação regular.
b = np.ones((2, 3, 4))
b.shape # >> (2, 3, 4)
b[1:2,:,:].shape # >> (1, 3, 4)
b[:, 2:3, :].shape . # >> (2, 1, 4)Para adicionar à solução que envolve indexação por listas ou matrizes por gnebehay, também é possível usar tuplas:
X[(10,),:]
x[None, 10]fará o que você quiser.