Chuyển một mảng NumPy

Tôi sử dụng Python và NumPy và có một số vấn đề với "transpose":

import numpy as np
a = np.array([5,4])
print(a)
print(a.T)

Gọi a.Tlà không hoán chuyển mảng. Nếu alà ví dụ [[],[]]thì nó chuyển đổi chính xác, nhưng tôi cần chuyển vị [...,...,...].

Nó hoạt động chính xác như nó được yêu cầu. Chuyển vị của mảng 1D vẫn là mảng 1D ! (Nếu bạn đã quen với MATLAB, về cơ bản, nó không có khái niệm về mảng 1D. Mảng "1D" của Matlab là 2D.)

Nếu bạn muốn biến vectơ 1D của mình thành một mảng 2D và sau đó hoán chuyển nó, chỉ cần cắt nó với np.newaxis(hoặc None, chúng giống nhau, newaxischỉ dễ đọc hơn).

import numpy as np
a = np.array([5,4])[np.newaxis]
print(a)
print(a.T)

Nói chung, mặc dù, bạn không cần phải lo lắng về điều này. Thêm kích thước phụ thường không phải là những gì bạn muốn, nếu bạn chỉ làm theo thói quen. Numpy sẽ tự động phát một mảng 1D khi thực hiện các phép tính khác nhau. Thường không cần phân biệt vectơ hàng và vectơ cột (cả hai đều không phải là vectơ . Cả hai đều là 2D!) Khi bạn chỉ muốn một vectơ.

Sử dụng hai cặp khung thay vì một. Điều này tạo ra một mảng 2D, có thể được hoán vị, không giống như mảng 1D bạn tạo nếu bạn sử dụng một cặp khung.

import numpy as np    
a = np.array([[5, 4]])
a.T

Ví dụ kỹ lưỡng hơn:

>>> a = [3,6,9]
>>> b = np.array(a)
>>> b.T
array([3, 6, 9])         #Here it didn't transpose because 'a' is 1 dimensional
>>> b = np.array([a])
>>> b.T
array([[3],              #Here it did transpose because a is 2 dimensional
       [6],
       [9]])

Sử dụng shapephương pháp của Numpy để xem những gì đang xảy ra ở đây:

>>> b = np.array([10,20,30])
>>> b.shape
(3,)
>>> b = np.array([[10,20,30]])
>>> b.shape
(1, 3)

Đối với mảng 1D :

a = np.array([1, 2, 3, 4])
a = a.reshape((-1, 1)) # <--- THIS IS IT

print a
array([[1],
       [2],
       [3],
       [4]])

Khi bạn hiểu rằng -1 ở đây có nghĩa là "càng nhiều hàng càng cần thiết", tôi thấy đây là cách dễ nhất để "hoán đổi" một mảng. Nếu mảng của bạn có chiều cao hơn chỉ cần sử dụng a.T.

Bạn có thể chuyển đổi một vectơ hiện có thành một ma trận bằng cách gói nó trong một bộ dấu ngoặc vuông bổ sung ...

from numpy import *
v=array([5,4]) ## create a numpy vector
array([v]).T ## transpose a vector into a matrix

numpy cũng có một matrixlớp (xem mảng so với ma trận ) ...

matrix(v).T ## transpose a vector into a matrix

mảng 1D numpy -> ma trận cột / hàng:

>>> a=np.array([1,2,4])
>>> a[:, None]    # col
array([[1],
       [2],
       [4]])
>>> a[None, :]    # row, or faster `a[None]`
array([[1, 2, 4]])

Và như @ joe-Kington nói, bạn có thể thay thế Nonebằng np.newaxischo dễ đọc.

Để 'hoán đổi' một mảng 1d sang cột 2d, bạn có thể sử dụng numpy.vstack:

>>> numpy.vstack(numpy.array([1,2,3]))
array([[1],
       [2],
       [3]])

Nó cũng hoạt động cho danh sách vanilla:

>>> numpy.vstack([1,2,3])
array([[1],
       [2],
       [3]])

Bạn chỉ có thể hoán chuyển một mảng 2D. Bạn có thể sử dụng numpy.matrixđể tạo một mảng 2D. Đây là ba năm muộn, nhưng tôi chỉ thêm vào các giải pháp có thể:

import numpy as np
m = np.matrix([2, 3])
m.T

thay vì sử dụng arr[:,None]để tạo vector cột

Chuyển vị của

x = [[0 1],
     [2 3]]

Là

xT = [[0 2],
      [1 3]]

mã này là:

x = array([[0, 1],[2, 3]]);
np.transpose(x)        

đây là một liên kết để biết thêm thông tin:

http://docs.scipy.org/doc/numpy/reference/generated/numpy.transpose.html

Giải pháp khác.... :-)

import numpy as np

a = [1,2,4]

[1, 2, 4]

b = np.array([a]).T

mảng ([[1], [2], [4]])

Tôi chỉ củng cố bài viết trên, hy vọng nó sẽ giúp người khác tiết kiệm thời gian:

Mảng dưới đây có (2, )kích thước, đó là mảng 1 chiều,

b_new = np.array([2j, 3j])  

Có hai cách để hoán chuyển mảng 1-D:

cắt nó với "np.newaxis" hoặc không.!

print(b_new[np.newaxis].T.shape)
print(b_new[None].T.shape)

cách viết khác, ở trên mà không cần Thoạt động.!

print(b_new[:, np.newaxis].shape)
print(b_new[:, None].shape)

Gói [] hoặc sử dụng np.matrix, có nghĩa là thêm một chiều mới.!

print(np.array([b_new]).T.shape)
print(np.matrix(b_new).T.shape)

Như một số ý kiến ​​ở trên đã đề cập, chuyển vị của mảng 1D là mảng 1D, vì vậy một cách để hoán chuyển mảng 1D sẽ là chuyển đổi mảng thành ma trận như sau:

np.transpose(a.reshape(len(a), 1))

Tên của hàm trong numpylà cột_stack .

>>>a=np.array([5,4])
>>>np.column_stack(a)
array([[5, 4]])

Có một phương pháp không được mô tả trong các câu trả lời nhưng được mô tả trong tài liệu cho numpy.ndarray.transposephương pháp:

Đối với mảng 1-D, điều này không có tác dụng, vì một vectơ chuyển đổi chỉ đơn giản là cùng một vectơ. Để chuyển đổi mảng 1-D thành vectơ cột 2D, phải thêm kích thước bổ sung. np.atleast2d (a) .T đạt được điều này, cũng như một [:, np.newaxis].

Người ta có thể làm:

import numpy as np
a = np.array([5,4])
print(a)
print(np.atleast_2d(a).T)

Mà (imo) là đẹp hơn so với sử dụng newaxis.

Về cơ bản những gì hàm chuyển đổi làm là hoán đổi hình dạng và bước tiến của mảng:

>>> a = np.ones((1,2,3))

>>> a.shape
(1, 2, 3)

>>> a.T.shape
(3, 2, 1)

>>> a.strides
(48, 24, 8)

>>> a.T.strides
(8, 24, 48)

Trong trường hợp mảng numpy 1D (mảng hạng 1), hình dạng và sải chân là các bộ dữ liệu 1 phần tử và không thể hoán đổi, và chuyển vị của mảng 1D như vậy trả về nó không thay đổi. Thay vào đó, bạn có thể hoán chuyển một "vectơ hàng" (mảng hình numpy (1, n)) thành một "vectơ cột" (mảng hình numpy (n, 1)). Để đạt được điều này, trước tiên bạn phải chuyển mảng numpy 1D của mình thành vector hàng và sau đó hoán đổi hình dạng và sải chân (hoán vị nó). Dưới đây là một chức năng thực hiện nó:

from numpy.lib.stride_tricks import as_strided

def transpose(a):
    a = np.atleast_2d(a)
    return as_strided(a, shape=a.shape[::-1], strides=a.strides[::-1])

Thí dụ:

>>> a = np.arange(3)
>>> a
array([0, 1, 2])

>>> transpose(a)
array([[0],
       [1],
       [2]])

>>> a = np.arange(1, 7).reshape(2,3)
>>> a     
array([[1, 2, 3],
       [4, 5, 6]])

>>> transpose(a)
array([[1, 4],
       [2, 5],
       [3, 6]])

Tất nhiên bạn không phải làm theo cách này vì bạn có mảng 1D và bạn có thể định hình lại trực tiếp thành (n, 1)mảng bằng a.reshape((-1, 1))hoặc a[:, None]. Tôi chỉ muốn chứng minh làm thế nào hoán vị một mảng hoạt động.

Cách tôi đã học để thực hiện điều này một cách nhỏ gọn và dễ đọc cho các mảng 1-D, cho đến nay:

h = np.array([1,2,3,4,5])

v1 = np.vstack(h)
v2 = np.c_[h]

h1 = np.hstack(v1)
h2 = np.r_[v2[:,0]]

numpy.r_ và numpy.c_ dịch các đối tượng lát thành nối tương ứng dọc theo trục thứ nhất và thứ hai, tương ứng. Do đó, việc cắt v2 [:, 0] khi hoán đổi mảng dọc v2 thành mảng ngang h2

numpy.vstack tương đương với việc ghép dọc trục thứ nhất sau khi các mảng hình 1-D (N,) đã được định hình lại thành (1, N). Tái tạo mảng chia cho vsplit .