Hướng dẫn split 2d array python - tách mảng 2d python

Trong bài đăng này, chúng ta sẽ thấy cách chia một mảng 2D Numpy bằng cách sử dụng Split, Array_Split, HSplit, VSplit và DSplit.

Các chức năng phân chia này cho phép bạn phân vùng mảng theo hình dạng và kích thước khác nhau và danh sách trả về Subarrays

• Split (): Chia một mảng thành nhiều mảng phụ có kích thước bằng nhau: Split an array into multiple sub-arrays of equal size: Split an array into multiple sub-arrays of equal size
• Array_Split (): Nó chia một mảng thành nhiều mảng phụ có kích thước bằng hoặc gần bằng nhau. Không nêu ra một ngoại lệ nếu một bộ phận bình đẳng không thể được thực hiện.: It Split an array into multiple sub-arrays of equal or near-equal size. Does not raise an exception if an equal division cannot be made.: It Split an array into multiple sub-arrays of equal or near-equal size. Does not raise an exception if an equal division cannot be made.
• hsplit (): chia một mảng thành nhiều phần phụ theo chiều ngang (khôn ngoan cột).: Splits an array into multiple sub-arrays horizontally (column-wise).: Splits an array into multiple sub-arrays horizontally (column-wise).
• vsplit (): Nó chia mảng thành nhiều mảng phụ theo chiều dọc (hàng khôn ngoan).: It Split array into multiple sub-arrays vertically (row wise).: It Split array into multiple sub-arrays vertically (row wise).
• dsplit (): chia một mảng thành nhiều mảng phụ dọc theo trục thứ 3 (độ sâu).: Splits an array into multiple sub-arrays along the 3rd axis (depth).: Splits an array into multiple sub-arrays along the 3rd axis (depth).

Tách ra

Phương pháp này thực hiện sau ba đối số và danh sách trả về các mảng phụ. Mảng sẽ được chia thành n mảng bằng nhau dọc theo trục. Nếu không thể phân chia như vậy, một lỗi được nêu ra

Mảng: một đối tượng ndarray cho phân vùng Ictices_or_sections: Int hoặc 1D Axis: Trục: An ndarray object for partition indices_or_sections: int or 1D array axis: the axis along which to split: An ndarray object for partition indices_or_sections: int or 1D array axis: the axis along which to split

Tách mảng 1D

Hãy để tạo ra một mảng 1D trước tiên

import numpy as np
x = np.arange(10)
x

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Hãy để phân chia mảng 1-D trên thành 5 phần bằng cách sử dụng phương thức numpy split ()

[array([0, 1]), array([2, 3]), array([4, 5]), array([6, 7]), array([8, 9])]

Tiếp theo, chúng tôi sẽ vượt qua một mảng 1-D cho phân vùng của x, tức là danh sách các chỉ số dọc theo mảng nào được chia thành các mảng con

np.split(x, [4, 6, 7, 9])

[array([0, 1, 2, 3]), array([4, 5]), array([6]), array([7, 8]), array([9])]

Chúng tôi đã vượt qua danh sách chỉ số 1D [4, 6, 7, 9] để phân vùng để X được chia thành Subarrays sau:

Phân vùng đầu tiên: Chỉ mục 0 đến 3 vì phần tử 1 trong danh sách chỉ số 1D là 4 mảng ([0, 1, 2, 3])

Phân vùng thứ 2: Chỉ mục 4 đến 5 trong phần tử 1 và 2 của mảng danh sách chỉ số 1D ([4,5])

Phân vùng thứ 3: Chỉ mục 6 đến 6 giữa phần tử thứ 2 và thứ 3 của mảng danh sách chỉ số 1D ([6])

Phân vùng thứ 4: Chỉ mục 7 đến 8 giữa phần tử thứ 3 và thứ 4 của mảng danh sách chỉ số 1D ([7,8])

Phân vùng thứ 5: Chỉ mục 9 đến cuối cùng giữa phần tử thứ 4 và chỉ mục cuối cùng của mảng danh sách chỉ số ([9])

Tách mảng 2D

Hãy để tạo ra một mảng 2D trước tiên

x = np.arange(16).reshape(4,4)
x

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

Chúng tôi sẽ chia mảng 2D trên thành mảng phụ bằng danh sách chỉ số của [1,3]

[array([[0, 1, 2, 3]]), array([[ 4,  5,  6,  7],
        [ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]

Phân vùng đầu tiên: INDEX 0 dọc theo trục = 0 vì phần tử 1 trong danh sách chỉ số là 1 mảng ([0,1,2,3]))

Phân vùng thứ 2: INDEX 1 đến 2 dọc theo trục = 0 trong phần tử thứ 1 và thứ 3 trong mảng danh sách chỉ số ([0,1,2,3])

Phân vùng thứ 3: Chỉ mục 3 đến 3 dọc theo trục = 0 giữa phần tử thứ 3 của danh sách chỉ số và chỉ mục cuối cùng của mảng 2D, tức là 3 mảng ([0,1,2,3])

Array_Split

Phương pháp này giống như phân chia ở trên và chỉ có sự khác biệt là nó cũng cho phép phân vùng không đồng đều

Đây là một mảng 2D mà chúng tôi sẽ chia thành Subarrays không đồng đều

x = np.arange(16).reshape(4,4)
x

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

Hãy để chia thành 3 để không thể phân vùng bằng nhau, vì vậy hãy để xem cách thức hoạt động của nó

[[7 6 2 4 4 2 5 2 3]
 [2 3 7 6 8 8 2 6 2]
 [4 1 3 1 3 8 1 3 7]
 [6 1 1 5 7 2 1 5 8]
 [8 8 7 6 6 1 8 8 4]
 [6 1 8 2 1 4 5 1 8]
 [7 3 4 2 5 6 1 2 7]
 [4 6 7 5 8 2 8 2 8]
 [6 6 5 5 6 1 2 6 4]]
[[array([[7, 6, 2],
       [2, 3, 7],
       [4, 1, 3]]), array([[4, 4, 2],
       [6, 8, 8],
       [1, 3, 8]]), array([[5, 2, 3],
       [2, 6, 2],
       [1, 3, 7]])], [array([[6, 1, 1],
       [8, 8, 7],
       [6, 1, 8]]), array([[5, 7, 2],
       [6, 6, 1],
       [2, 1, 4]]), array([[1, 5, 8],
       [8, 8, 4],
       [5, 1, 8]])], [array([[7, 3, 4],
       [4, 6, 7],
       [6, 6, 5]]), array([[2, 5, 6],
       [5, 8, 2],
       [5, 6, 1]]), array([[1, 2, 7],
       [8, 2, 8],
       [2, 6, 4]])]]

Nếu L là chiều dài của mảng và N là không mong đợi. của parition of the mảng sau đó

Nó trả về l % n ròng phụ có kích thước l // n + 1, là 1 subarray có kích thước 2 và con con đầu tiên ở trên là mảng ([[0, 1, 2, 3], [4, 5, 6, 7, 7, ]])

Hai subarrays khác sẽ có kích thước l // n tức là 1 và điều đó cho hai mảng mảng phụ này ([[8, 9, 10, 11]]), mảng ([[12, 13, 14, 15]])

Chia mảng theo cột bằng cách sử dụng hsplit

Chia một mảng thành nhiều phần phụ theo chiều ngang (cột khôn ngoan). HSPLIT tương đương với phân tách với trục = 1

Mảng luôn được chia theo trục thứ hai bất kể kích thước mảng

[[7 6 2 4 4 2 5 2 3]
 [2 3 7 6 8 8 2 6 2]
 [4 1 3 1 3 8 1 3 7]
 [6 1 1 5 7 2 1 5 8]
 [8 8 7 6 6 1 8 8 4]
 [6 1 8 2 1 4 5 1 8]
 [7 3 4 2 5 6 1 2 7]
 [4 6 7 5 8 2 8 2 8]
 [6 6 5 5 6 1 2 6 4]]
[[array([[7, 6, 2],
       [2, 3, 7],
       [4, 1, 3]]), array([[4, 4, 2],
       [6, 8, 8],
       [1, 3, 8]]), array([[5, 2, 3],
       [2, 6, 2],
       [1, 3, 7]])], [array([[6, 1, 1],
       [8, 8, 7],
       [6, 1, 8]]), array([[5, 7, 2],
       [6, 6, 1],
       [2, 1, 4]]), array([[1, 5, 8],
       [8, 8, 4],
       [5, 1, 8]])], [array([[7, 3, 4],
       [4, 6, 7],
       [6, 6, 5]]), array([[2, 5, 6],
       [5, 8, 2],
       [5, 6, 1]]), array([[1, 2, 7],
       [8, 2, 8],
       [2, 6, 4]])]]

[[7 6 2 4 4 2 5 2 3]
 [2 3 7 6 8 8 2 6 2]
 [4 1 3 1 3 8 1 3 7]
 [6 1 1 5 7 2 1 5 8]
 [8 8 7 6 6 1 8 8 4]
 [6 1 8 2 1 4 5 1 8]
 [7 3 4 2 5 6 1 2 7]
 [4 6 7 5 8 2 8 2 8]
 [6 6 5 5 6 1 2 6 4]]
[[array([[7, 6, 2],
       [2, 3, 7],
       [4, 1, 3]]), array([[4, 4, 2],
       [6, 8, 8],
       [1, 3, 8]]), array([[5, 2, 3],
       [2, 6, 2],
       [1, 3, 7]])], [array([[6, 1, 1],
       [8, 8, 7],
       [6, 1, 8]]), array([[5, 7, 2],
       [6, 6, 1],
       [2, 1, 4]]), array([[1, 5, 8],
       [8, 8, 4],
       [5, 1, 8]])], [array([[7, 3, 4],
       [4, 6, 7],
       [6, 6, 5]]), array([[2, 5, 6],
       [5, 8, 2],
       [5, 6, 1]]), array([[1, 2, 7],
       [8, 2, 8],
       [2, 6, 4]])]]

Tiếp theo, chúng tôi sẽ phân chia mảng trên tại INDEX 2

[[7 6 2 4 4 2 5 2 3]
 [2 3 7 6 8 8 2 6 2]
 [4 1 3 1 3 8 1 3 7]
 [6 1 1 5 7 2 1 5 8]
 [8 8 7 6 6 1 8 8 4]
 [6 1 8 2 1 4 5 1 8]
 [7 3 4 2 5 6 1 2 7]
 [4 6 7 5 8 2 8 2 8]
 [6 6 5 5 6 1 2 6 4]]
[[array([[7, 6, 2],
       [2, 3, 7],
       [4, 1, 3]]), array([[4, 4, 2],
       [6, 8, 8],
       [1, 3, 8]]), array([[5, 2, 3],
       [2, 6, 2],
       [1, 3, 7]])], [array([[6, 1, 1],
       [8, 8, 7],
       [6, 1, 8]]), array([[5, 7, 2],
       [6, 6, 1],
       [2, 1, 4]]), array([[1, 5, 8],
       [8, 8, 4],
       [5, 1, 8]])], [array([[7, 3, 4],
       [4, 6, 7],
       [6, 6, 5]]), array([[2, 5, 6],
       [5, 8, 2],
       [5, 6, 1]]), array([[1, 2, 7],
       [8, 2, 8],
       [2, 6, 4]])]]

Điều này chia một mảng 5 × 4 thành hai mảng 5x2

Hãy cùng đưa ra một danh sách các chỉ số để chia

[[7 6 2 4 4 2 5 2 3]
 [2 3 7 6 8 8 2 6 2]
 [4 1 3 1 3 8 1 3 7]
 [6 1 1 5 7 2 1 5 8]
 [8 8 7 6 6 1 8 8 4]
 [6 1 8 2 1 4 5 1 8]
 [7 3 4 2 5 6 1 2 7]
 [4 6 7 5 8 2 8 2 8]
 [6 6 5 5 6 1 2 6 4]]
[[array([[7, 6, 2],
       [2, 3, 7],
       [4, 1, 3]]), array([[4, 4, 2],
       [6, 8, 8],
       [1, 3, 8]]), array([[5, 2, 3],
       [2, 6, 2],
       [1, 3, 7]])], [array([[6, 1, 1],
       [8, 8, 7],
       [6, 1, 8]]), array([[5, 7, 2],
       [6, 6, 1],
       [2, 1, 4]]), array([[1, 5, 8],
       [8, 8, 4],
       [5, 1, 8]])], [array([[7, 3, 4],
       [4, 6, 7],
       [6, 6, 5]]), array([[2, 5, 6],
       [5, 8, 2],
       [5, 6, 1]]), array([[1, 2, 7],
       [8, 2, 8],
       [2, 6, 4]])]]

Nó chia thành 3 Subarrays. Cái đầu tiên có kích thước 5x3 và thứ hai của kích thước 5x1 và thứ ba là một mảng trống

Chúng tôi đã thảo luận điều này rằng đầu tiên nó chia tách từ 0 đến 2 vì chỉ mục đầu tiên cho phân chia là 3 và thứ hai giữa các chỉ số 3 và 4 vì phần tử thứ hai là 5 và cuối cùng bất cứ điều gì ngoài Chỉ số 5

Tách mảng theo hàng bằng VSPLIT

Chia một mảng thành nhiều mảng phụ theo chiều dọc (hàng khôn)

________ 25 & nbsp; tương đương với & nbsp; ________ 26 & nbsp; với & nbsp; trục = 0 & nbsp;

Điều này hoạt động giống hệt như chức năng phân chia đã thảo luận ở trên

Tách các mảng dọc theo trục thứ ba, tức là trục = 2 bằng cách sử dụng DSplit

Chia mảng thành nhiều mảng phụ dọc theo trục thứ 3 (độ sâu)

DSplit tương đương với phân chia với trục = 2. Mảng luôn được phân chia dọc theo trục thứ ba với kích thước mảng lớn hơn hoặc bằng 3

[[7 6 2 4 4 2 5 2 3]
 [2 3 7 6 8 8 2 6 2]
 [4 1 3 1 3 8 1 3 7]
 [6 1 1 5 7 2 1 5 8]
 [8 8 7 6 6 1 8 8 4]
 [6 1 8 2 1 4 5 1 8]
 [7 3 4 2 5 6 1 2 7]
 [4 6 7 5 8 2 8 2 8]
 [6 6 5 5 6 1 2 6 4]]
[[array([[7, 6, 2],
       [2, 3, 7],
       [4, 1, 3]]), array([[4, 4, 2],
       [6, 8, 8],
       [1, 3, 8]]), array([[5, 2, 3],
       [2, 6, 2],
       [1, 3, 7]])], [array([[6, 1, 1],
       [8, 8, 7],
       [6, 1, 8]]), array([[5, 7, 2],
       [6, 6, 1],
       [2, 1, 4]]), array([[1, 5, 8],
       [8, 8, 4],
       [5, 1, 8]])], [array([[7, 3, 4],
       [4, 6, 7],
       [6, 6, 5]]), array([[2, 5, 6],
       [5, 8, 2],
       [5, 6, 1]]), array([[1, 2, 7],
       [8, 2, 8],
       [2, 6, 4]])]]

[[7 6 2 4 4 2 5 2 3]
 [2 3 7 6 8 8 2 6 2]
 [4 1 3 1 3 8 1 3 7]
 [6 1 1 5 7 2 1 5 8]
 [8 8 7 6 6 1 8 8 4]
 [6 1 8 2 1 4 5 1 8]
 [7 3 4 2 5 6 1 2 7]
 [4 6 7 5 8 2 8 2 8]
 [6 6 5 5 6 1 2 6 4]]
[[array([[7, 6, 2],
       [2, 3, 7],
       [4, 1, 3]]), array([[4, 4, 2],
       [6, 8, 8],
       [1, 3, 8]]), array([[5, 2, 3],
       [2, 6, 2],
       [1, 3, 7]])], [array([[6, 1, 1],
       [8, 8, 7],
       [6, 1, 8]]), array([[5, 7, 2],
       [6, 6, 1],
       [2, 1, 4]]), array([[1, 5, 8],
       [8, 8, 4],
       [5, 1, 8]])], [array([[7, 3, 4],
       [4, 6, 7],
       [6, 6, 5]]), array([[2, 5, 6],
       [5, 8, 2],
       [5, 6, 1]]), array([[1, 2, 7],
       [8, 2, 8],
       [2, 6, 4]])]]

Hãy để phân chia mảng này dọc theo danh sách các chỉ số sau [2,3]

[[7 6 2 4 4 2 5 2 3]
 [2 3 7 6 8 8 2 6 2]
 [4 1 3 1 3 8 1 3 7]
 [6 1 1 5 7 2 1 5 8]
 [8 8 7 6 6 1 8 8 4]
 [6 1 8 2 1 4 5 1 8]
 [7 3 4 2 5 6 1 2 7]
 [4 6 7 5 8 2 8 2 8]
 [6 6 5 5 6 1 2 6 4]]
[[array([[7, 6, 2],
       [2, 3, 7],
       [4, 1, 3]]), array([[4, 4, 2],
       [6, 8, 8],
       [1, 3, 8]]), array([[5, 2, 3],
       [2, 6, 2],
       [1, 3, 7]])], [array([[6, 1, 1],
       [8, 8, 7],
       [6, 1, 8]]), array([[5, 7, 2],
       [6, 6, 1],
       [2, 1, 4]]), array([[1, 5, 8],
       [8, 8, 4],
       [5, 1, 8]])], [array([[7, 3, 4],
       [4, 6, 7],
       [6, 6, 5]]), array([[2, 5, 6],
       [5, 8, 2],
       [5, 6, 1]]), array([[1, 2, 7],
       [8, 2, 8],
       [2, 6, 4]])]]

import numpy as np
x = np.arange(10)
x

Vì vậy, nó chia một ma trận 2x2x6 thành ba kích thước subarrays: 2x2x2, 2x2x1 và 2x2x3

Tách các mảng ở các giá trị

Nếu chúng ta muốn chia một mảng ở một giá trị cụ thể thì chỉ cần sử dụng np. Where để tìm chỉ mục của giá trị đó và truyền đó làm tham số để chia tách

import numpy as np
x = np.arange(10)
x

import numpy as np
x = np.arange(10)
x

Hãy để phân chia mảng này ở giá trị 6. Vì vậy, trước tiên chúng tôi sẽ xác định chỉ số của phần tử này trong mảng bằng phương thức np.where ()

import numpy as np
x = np.arange(10)
x

import numpy as np
x = np.arange(10)
x

Vì vậy, nó chia một ma trận 8 × 2 thành 3 mảng phụ không đồng đều có kích thước sau: 3 × 2, 3 × 2 và 2 × 2

Sự kết luận

Dưới đây là những điểm để tóm tắt việc học của chúng tôi về việc tách mảng bằng cách sử dụng Numpy

• Chức năng chia tách () chia một mảng thành nhiều mảng phụ
• Có thể được truyền một interger hoặc danh sách các chỉ số để chia tách
• Chức năng chia () hoạt động dọc theo trục 0 hoặc 1
• hàm mảng_split () chia mảng thành kích thước không đồng đều không giống như hàm split ()
• Chức năng hsplit () có thể được sử dụng để phân chia một mảng theo cột. nó giống như hàm split () với trục = 1
• hàm vSplit () giống như hàm split () với trục = 0 i.e. mặc định
• DSplit () chia mảng thành nhiều mảng phụ dọc theo trục thứ 3, tức là trục = 2
• Sử dụng hàm numpy.where () để phân chia mảng ở một giá trị cụ thể