12、Numpy數組常見操作

1、番外說明

大家好，我是小P，本系列是本人對Python模塊Numpy的一些學習記錄，總結於此一方面方便其它初學者學習，另一方面害怕自己遺忘，希望大家喜歡。此外，對“目標檢測/模型壓縮/語義分割”感興趣的小夥伴，歡迎加入QQ羣 813221712 討論交流，進羣請看羣公告！（可以點擊如下連接直接加入！）
點擊鏈接加入羣聊【Object Detection】：https://jq.qq.com/?_wv=1027&k=5kXCXF8

2、正題

參考鏈接：

https://www.runoob.com/numpy/numpy-array-manipulation.html

Numpy 中包含了一些函數用於處理數組，大概可分爲以下幾類：

● 修改數組形狀
● 翻轉數組
● 修改數組維度
● 連接數組
● 分割數組
● 數組元素的添加與刪除

2.1 修改數組形狀

2.1.1 numpy.reshape

numpy.reshape 函數可以在不改變數據的條件下修改形狀，格式如下：

numpy.reshape(arr, newshape, order='C')

● arr：要修改形狀的數組
● newshape：整數或者整數數組，新的形狀應當兼容原有形狀
● order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原順序，‘k’ – 元素在內存中的出現順序。

實例：使用reshape改變數組形狀

import numpy as np
 
a = np.arange(8)
print ('原始數組：')
print (a)
 
b = a.reshape(4,2)
print ('修改後的數組：')
print (b)

輸出結果如下：

原始數組：
[0 1 2 3 4 5 6 7]

修改後的數組：
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

2.1.2 numpy.ndarray.flat

numpy.ndarray.flat 是一個數組元素迭代器，返回一維的數組複製，實例如下:
實例：numpy.ndarray.flat

import numpy as np
 
a = np.arange(9).reshape(3,3) 
print ('原始數組：')
for items in a:
    print (items)

#對數組中每個元素都進行處理，可以使用flat屬性，該屬性是一個數組元素迭代器：
print ('迭代後的數組：')
for element in a.flat:
    print (element)

輸出結果如下：

原始數組：
[0 1 2]
[3 4 5]
[6 7 8]

迭代後的數組：
0
1
2
3
4
5
6
7
8

2.1.3 numpy.ndarray.flatten

numpy.ndarray.flatten 返回一份數組拷貝，對拷貝所做的修改不會影響原始數組，格式如下：

ndarray.flatten(order='C')

參數說明：

● order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原順序，‘K’ – 元素在內存中的出現順序。

實例：numpy.ndarray.flatten的使用

import numpy as np
 
a = np.arange(8).reshape(2,4)
print ('原數組：')
print (a)

print ('展開的數組：')
print (a.flatten())
 
print ('以 F 風格順序展開的數組：')
print (a.flatten(order = 'F'))

輸出結果如下：

原數組：
[[0 1 2 3]
 [4 5 6 7]]

展開的數組：
[0 1 2 3 4 5 6 7]

以 F 風格順序展開的數組：
[0 4 1 5 2 6 3 7]

2.1.4 numpy.ravel

numpy.ravel() 展平的數組元素，順序通常是"C風格"，返回的是數組視圖（view，有點類似 C/C++引用reference的意味），修改會影響原始數組。該函數接收兩個參數：

numpy.ravel(a, order='C')

參數說明：

● order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原順序，‘K’ – 元素在內存中的出現順序。

實例：numpy.ravel的使用

import numpy as np
 
a = np.arange(8).reshape(2,4)
print ('原數組：')
print (a)
 
print ('調用 ravel 函數之後：')
print (a.ravel())
 
print ('以 F 風格順序調用 ravel 函數之後：')
print (a.ravel(order = 'F'))

輸出結果如下：

原數組：
[[0 1 2 3]
 [4 5 6 7]]

調用 ravel 函數之後：
[0 1 2 3 4 5 6 7]

以 F 風格順序調用 ravel 函數之後：
[0 4 1 5 2 6 3 7]

2.2 翻轉數組

2.2.1 numpy.transpose

numpy.transpose 函數用於對換數組的維度，格式如下：

numpy.transpose(arr, axes)

參數說明:

● arr：要操作的數組
● axes：整數列表，對應維度，通常所有維度都會對換。

實例：numpy.transpose兌換數組維度

import numpy as np
 
a = np.arange(12).reshape(3,4)   
print ('原數組：')
print (a )
 
print ('對換數組：')
print (np.transpose(a))

輸出結果如下：

原數組：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

對換數組：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

2.2.2 numpy.ndarray.T 類似 numpy.transpose：

實例：numpy.ndarray.T使用

import numpy as np
 
a = np.arange(12).reshape(3,4)
print ('原數組：')
print (a)
 
print ('轉置數組：')
print (a.T)
輸出結果如下：

原數組：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

轉置數組：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

2.2.3 numpy.rollaxis

numpy.rollaxis 函數向後滾動特定的軸到一個特定位置，格式如下：

numpy.rollaxis(arr, axis, start)

參數說明：

● arr：數組
● axis：要向後滾動的軸，其它軸的相對位置不會改變
● start：默認爲零，表示完整的滾動。會滾動到特定位置。

實例：numpy.rollaxis的使用

import numpy as np  
# 創建了三維的 ndarray
a = np.arange(8).reshape(2,2,2)
 
print ('原數組：')
print (a)

# 將軸 2 滾動到軸 0（寬度到深度）
print ('調用 rollaxis 函數：')
print (np.rollaxis(a,2))

# 將軸 0 滾動到軸 1：（寬度到高度）
print ('調用 rollaxis 函數：')
print (np.rollaxis(a,2,1))

輸出結果如下：

原數組：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]

調用 rollaxis 函數：
[[[0 2]
  [4 6]]

 [[1 3]
  [5 7]]]

調用 rollaxis 函數：
[[[0 2]
  [1 3]]

 [[4 6]
  [5 7]]]

2.2.4 numpy.swapaxes

numpy.swapaxes 函數用於交換數組的兩個軸，格式如下：

numpy.swapaxes(arr, axis1, axis2)

參數說明：

● arr：輸入的數組
● axis1：對應第一個軸的整數
● axis2：對應第二個軸的整數

實例：numpy.swapaxes的使用

import numpy as np
 
# 創建了三維的 ndarray
a = np.arange(8).reshape(2,2,2)
print ('原數組：')
print (a)

# 現在交換軸 0（深度方向）到軸 2（寬度方向） 
print ('調用 swapaxes 函數後的數組：')
print (np.swapaxes(a, 2, 0))

輸出結果如下：

原數組：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]

調用 swapaxes 函數後的數組：
[[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]

2.3 修改數組維度

2.3.1 numpy.broadcast

numpy.broadcast 用於模仿廣播的對象，它返回一個對象，該對象封裝了將一個數組廣播到另一個數組的結果。

該函數使用兩個數組作爲輸入參數，如下實例：

實例：使用廣播進行

import numpy as np  
x = np.array([[1], [2], [3]])
y = np.array([4, 5, 6])  
 
# 對 y 廣播 x
b = np.broadcast(x,y)  
# 它擁有 iterator 屬性，基於自身組件的迭代器元組
print ('對 y 廣播 x：')
r,c = b.iters
 
# Python3.x 爲 next(context) ，Python2.x 爲 context.next()
print (next(r), next(c))
print (next(r), next(c))

# shape 屬性返回廣播對象的形狀
print ('廣播對象的形狀：')
print (b.shape)

# 手動使用 broadcast 將 x 與 y 相加
b = np.broadcast(x,y)
c = np.empty(b.shape)
 
print ('手動使用 broadcast 將 x 與 y 相加：')
print (c.shape)
c.flat = [u + v for (u,v) in b]
 
print ('調用 flat 函數：')
print (c)

# 獲得了和 NumPy 內建的廣播支持相同的結果
print ('x 與 y 的和：')
print (x + y)

輸出結果爲：

對 y 廣播 x：
1 4
1 5

廣播對象的形狀：
(3, 3)

手動使用 broadcast 將 x 與 y 相加：
(3, 3)

調用 flat 函數：
[[5. 6. 7.]
 [6. 7. 8.]
 [7. 8. 9.]]

x 與 y 的和：
[[5 6 7]
 [6 7 8]
 [7 8 9]]

2.3.2 numpy.broadcast_to

numpy.broadcast_to 函數將數組廣播到新形狀。它在原始數組上返回只讀視圖。 它通常不連續。 如果新形狀不符合 NumPy 的廣播規則，該函數可能會拋出ValueError。

numpy.broadcast_to(array, shape, subok)

實例：numpy.broadcast_to(array,shape,subok)

import numpy as np
 
a = np.arange(4).reshape(1,4)
print ('原數組：')
print (a)
 
print ('調用 broadcast_to 函數之後：')
print (np.broadcast_to(a,(4,4)))

輸出結果爲：

原數組：

[[0 1 2 3]]

調用 broadcast_to 函數之後：
[[0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]]

2.3.3 numpy.expand_dims

numpy.expand_dims 函數通過在指定位置插入新的軸來擴展數組形狀，函數格式如下

numpy.expand_dims(arr, axis)

參數說明：

● arr：輸入數組
● axis：新軸插入的位置

實例：numpy.expand_dims

import numpy as np
 
x = np.array(([1,2],[3,4]))
print ('數組 x：')
print (x)

y = np.expand_dims(x, axis = 0)
print ('數組 y：')
print (y)
 
print ('數組 x 和 y 的形狀：')
print (x.shape, y.shape)

# 在位置 1 插入軸
y = np.expand_dims(x, axis = 1)
print ('在位置 1 插入軸之後的數組 y：')
print (y)
 
print ('x.ndim 和 y.ndim：')
print (x.ndim,y.ndim)
 
print ('x.shape 和 y.shape：')
print (x.shape, y.shape)

輸出結果爲：

數組 x：
[[1 2]
 [3 4]]

數組 y：
[[[1 2]
  [3 4]]]

數組 x 和 y 的形狀：
(2, 2) (1, 2, 2)

在位置 1 插入軸之後的數組 y：
[[[1 2]]

 [[3 4]]]

x.ndim 和 y.ndim：
2 3

x.shape 和 y.shape：
(2, 2) (2, 1, 2)

2.3.4 numpy.squeeze

numpy.squeeze 函數從給定數組的形狀中刪除一維的條目，函數格式如下：

numpy.squeeze(arr, axis)

參數說明：

● arr：輸入數組
● axis：整數或整數元組，用於選擇形狀中一維條目的子集

實例：numpy.squeeze使用

import numpy as np
 
x = np.arange(9).reshape(1,3,3) 
print ('數組 x：')
print (x)

y = np.squeeze(x) 
print ('數組 y：')
print (y)
 
print ('數組 x 和 y 的形狀：')
print (x.shape, y.shape)

輸出結果爲：

數組 x：
[[[0 1 2]
  [3 4 5]
  [6 7 8]]]

數組 y：
[[0 1 2]
 [3 4 5]
 [6 7 8]]

數組 x 和 y 的形狀：
(1, 3, 3) (3, 3)

2.4 連接數組

2.4.1 numpy.concatenate

numpy.concatenate 函數用於沿指定軸連接相同形狀的兩個或多個數組，格式如下：

numpy.concatenate((a1, a2, ...), axis)

參數說明：

● a1, a2, …：相同類型的數組
● axis：沿着它連接數組的軸，默認爲 0

實例：使用numpy.concatenate連接數組

import numpy as np

a = np.array([[1,2],[3,4]])
print ('第一個數組：')
print (a)

b = np.array([[5,6],[7,8]])
print ('第二個數組：')
print (b)

# 兩個數組的維度相同
print ('沿軸 0 連接兩個數組：')
print (np.concatenate((a,b)))
 
print ('沿軸 1 連接兩個數組：')
print (np.concatenate((a,b),axis = 1))

輸出結果爲：

第一個數組：
[[1 2]
 [3 4]]

第二個數組：
[[5 6]
 [7 8]]

沿軸 0 連接兩個數組：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

沿軸 1 連接兩個數組：
[[1 2 5 6]
 [3 4 7 8]]

2.4.2 numpy.stack

numpy.stack 函數用於沿新軸連接數組序列，格式如下：

numpy.stack(arrays, axis)

參數說明：

● arrays相同形狀的數組序列
● axis：返回數組中的軸，輸入數組沿着它來堆疊

實例：numpy.stack的使用

import numpy as np
 
a = np.array([[1,2],[3,4]])
print ('第一個數組：')
print (a)

b = np.array([[5,6],[7,8]])
print ('第二個數組：')
print (b)
 
print ('沿軸 0 堆疊兩個數組：')
print (np.stack((a,b),0))
 
print ('沿軸 1 堆疊兩個數組：')
print (np.stack((a,b),1))

輸出結果如下：

第一個數組：
[[1 2]
 [3 4]]

第二個數組：
[[5 6]
 [7 8]]

沿軸 0 堆疊兩個數組：
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

沿軸 1 堆疊兩個數組：
[[[1 2]
  [5 6]]

 [[3 4]
  [7 8]]]

2.4.3 numpy.hstack

numpy.hstack 是 numpy.stack 函數的變體，它通過水平堆疊來生成數組。

實例：numpy.hstack使用

import numpy as np
 
a = np.array([[1,2],[3,4]]) 
print ('第一個數組：')
print (a)

b = np.array([[5,6],[7,8]])
print ('第二個數組：')
print (b)
 
print ('水平堆疊：')
c = np.hstack((a,b))
print (c)

輸出結果如下：

第一個數組：
[[1 2]
 [3 4]]

第二個數組：
[[5 6]
 [7 8]]

水平堆疊：
[[1 2 5 6]
 [3 4 7 8]]

2.4.4 numpy.vstack

numpy.vstack 是 numpy.stack 函數的變體，它通過垂直堆疊來生成數組。

實例：numpy.vstack使用

import numpy as np
 
a = np.array([[1,2],[3,4]])
print ('第一個數組：')
print (a)

b = np.array([[5,6],[7,8]])
print ('第二個數組：')
print (b)
 
print ('豎直堆疊：')
c = np.vstack((a,b))
print (c)

輸出結果爲：

第一個數組：
[[1 2]
 [3 4]]

第二個數組：
[[5 6]
 [7 8]]

豎直堆疊：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

2.5 分割數組

2.5.1 numpy.split

numpy.split 函數沿特定的軸將數組分割爲子數組，格式如下：

numpy.split(ary, indices_or_sections, axis)

參數說明：

● ary：被分割的數組
● indices_or_sections：果是一個整數，就用該數平均切分，如果是一個數組，爲沿軸切分的位置（左開右閉）
● axis：沿着哪個維度進行切向，默認爲0，橫向切分。爲1時，縱向切分

實例：numpy.split使用

import numpy as np
 
a = np.arange(9)
print ('第一個數組：')
print (a)
 
print ('將數組分爲三個大小相等的子數組：')
b = np.split(a,3)
print (b)
 
print ('將數組在一維數組中表明的位置分割：')
b = np.split(a,[4,7])
print (b)

輸出結果爲：

第一個數組：
[0 1 2 3 4 5 6 7 8]
  
將數組分爲三個大小相等的子數組：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]

將數組在一維數組中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

2.5.2 numpy.hsplit

numpy.hsplit 函數用於水平分割數組，通過指定要返回的相同形狀的數組數量來拆分原數組。

實例：numpy.hsplit使用

import numpy as np
 
harr = np.floor(10 * np.random.random((2, 6)))
print ('原array：')
print(harr)
 
print ('拆分後：')
print(np.hsplit(harr, 3))

輸出結果爲：

原array：
[[4. 7. 6. 3. 2. 6.]
 [6. 3. 6. 7. 9. 7.]]
 
拆分後：
[array([[4., 7.],
       [6., 3.]]), array([[6., 3.],
       [6., 7.]]), array([[2., 6.],
       [9., 7.]])]

2.5.3 numpy.vsplit

numpy.vsplit 沿着垂直軸分割，其分割方式與hsplit用法相同。

實例：numpy.vsplit使用

import numpy as np
 
a = np.arange(16).reshape(4,4)
print ('第一個數組：')
print (a)
 
print ('豎直分割：')
b = np.vsplit(a,2)
print (b)

輸出結果爲：

第一個數組：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

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

2.6 數組元素的添加與刪除

2.6.1 numpy.resize

numpy.resize 函數返回指定大小的新數組。

如果新數組大小大於原始大小，則包含原始數組中的元素的副本。

numpy.resize(arr, shape)

參數說明：

● arr：要修改大小的數組
● shape：返回數組的新形狀

實例：numpy.resize使用

import numpy as np
 
a = np.array([[1,2,3],[4,5,6]])
print ('第一個數組：')
print (a)
 
print ('第一個數組的形狀：')
print (a.shape)

b = np.resize(a, (3,2)) 
print ('第二個數組：')
print (b)
 
print ('第二個數組的形狀：')
print (b.shape)

# 要注意 a 的第一行在 b 中重複出現，因爲尺寸變大了
print ('修改第二個數組的大小：')
b = np.resize(a,(3,3))
print (b)

輸出結果爲：

第一個數組：
[[1 2 3]
 [4 5 6]]

第一個數組的形狀：
(2, 3)

第二個數組：
[[1 2]
 [3 4]
 [5 6]]

第二個數組的形狀：
(3, 2)

修改第二個數組的大小：
[[1 2 3]
 [4 5 6]
 [1 2 3]]

2.6.2 numpy.append

numpy.append 函數在數組的末尾添加值。 追加操作會分配整個數組，並把原來的數組複製到新數組中。 此外，輸入數組的維度必須匹配否則將生成ValueError。

append 函數返回的始終是一個一維數組。

numpy.append(arr, values, axis=None)

參數說明：

● arr：輸入數組
● values：要向arr添加的值，需要和arr形狀相同（除了要添加的軸）
● axis：默認爲 None。當axis無定義時，是橫向加成，返回總是爲一維數組！當axis有定義的時候，分別爲0的時候（列數要相同）。當axis爲1時，數組是加在右邊（行數要相同）。

實例：numpy.append使用

import numpy as np
 
a = np.array([[1,2,3],[4,5,6]])
print ('第一個數組：')
print (a)
 
print ('向數組添加元素：')
print (np.append(a, [7,8,9]))
 
print ('沿軸 0 添加元素：')
print (np.append(a, [[7,8,9]],axis = 0))
 
print ('沿軸 1 添加元素：')
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))

輸出結果爲：

第一個數組：
[[1 2 3]
 [4 5 6]]

向數組添加元素：
[1 2 3 4 5 6 7 8 9]

沿軸 0 添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]

沿軸 1 添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

2.6.3 numpy.insert

numpy.insert 函數在給定索引之前，沿給定軸在輸入數組中插入值。

如果值的類型轉換爲要插入，則它與輸入數組不同。 插入沒有原地的，函數會返回一個新數組。 此外，如果未提供軸，則輸入數組會被展開。

numpy.insert(arr, obj, values, axis)

參數說明：

● arr：輸入數組
● obj：在其之前插入值的索引
● values：要插入的值
● axis：沿着它插入的軸，如果未提供，則輸入數組會被展開

實例：numpy.insert使用

import numpy as np
 
a = np.array([[1,2],[3,4],[5,6]])
print ('第一個數組：')
print (a)
 
print ('未傳遞 Axis 參數。 在插入之前輸入數組會被展開。')
print (np.insert(a,3,[11,12]))

print ('傳遞了 Axis 參數。 會廣播值數組來配輸入數組。')
print ('沿軸 0 廣播：')
print (np.insert(a,1,[11],axis = 0))
 
print ('沿軸 1 廣播：')
print (np.insert(a,1,11,axis = 1))

輸出結果如下：

第一個數組：
[[1 2]
 [3 4]
 [5 6]]

未傳遞 Axis 參數。 在插入之前輸入數組會被展開。
[ 1  2  3 11 12  4  5  6]

傳遞了 Axis 參數。 會廣播值數組來配輸入數組。
沿軸 0 廣播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]

沿軸 1 廣播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

2.6.4 numpy.delete

numpy.delete 函數返回從輸入數組中刪除指定子數組的新數組。 與 insert() 函數的情況一樣，如果未提供軸參數，則輸入數組將展開。

Numpy.delete(arr, obj, axis)

參數說明：

● arr：輸入數組
● obj：可以被切片，整數或者整數數組，表明要從輸入數組刪除的子數組
● axis：沿着它刪除給定子數組的軸，如果未提供，則輸入數組會被展開

實例：numpy.delete使用

import numpy as np
 
a = np.arange(12).reshape(3,4)
print ('第一個數組：')
print (a)
 
print ('未傳遞 Axis 參數。 在插入之前輸入數組會被展開。')
print (np.delete(a,5))
 
print ('刪除第二列：')
print (np.delete(a,1,axis = 1))
 
print ('包含從數組中刪除的替代值的切片：')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))

輸出結果爲：

第一個數組：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

未傳遞 Axis 參數。 在插入之前輸入數組會被展開。
[ 0  1  2  3  4  6  7  8  9 10 11]

刪除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]

包含從數組中刪除的替代值的切片：
[ 2  4  6  8 10]

2.6.5 numpy.unique

numpy.unique 函數用於去除數組中的重複元素。

numpy.unique(arr, return_index, return_inverse, return_counts)

參數說明：

● arr：輸入數組，如果不是一維數組則會展開
● return_index：如果爲true，返回新列表元素在舊列表中的位置（下標），並以列表形式儲
● return_inverse：如果爲true，返回舊列表元素在新列表中的位置（下標），並以列表形式儲
● return_counts：如果爲true，返回去重數組中的元素在原數組中的出現次數

實例：numpy.unique使用

import numpy as np
 
a = np.array([5,2,6,2,7,5,6,8,2,9]) 
print ('第一個數組：')
print (a)
 
print ('第一個數組的去重值：')
u = np.unique(a)
print (u)
 
print ('去重數組的索引數組：')
u,indices = np.unique(a, return_index = True)
print (indices)
 
print ('我們可以看到每個和原數組下標對應的數值：')
print (a)
 
print ('去重數組的下標：')
u,indices = np.unique(a,return_inverse = True)
print (u)
 
print ('下標爲：')
print (indices)
 
print ('使用下標重構原數組：')
print (u[indices])
 
print ('返回去重元素的重複數量：')
u,indices = np.unique(a,return_counts = True)
print (u)
print (indices)

輸出結果爲：

第一個數組：
[5 2 6 2 7 5 6 8 2 9]

第一個數組的去重值：
[2 5 6 7 8 9]

去重數組的索引數組：
[1 0 2 4 7 9]

我們可以看到每個和原數組下標對應的數值：
[5 2 6 2 7 5 6 8 2 9]

去重數組的下標：
[2 5 6 7 8 9]

下標爲：
[1 0 2 0 3 1 2 4 0 5]

使用下標重構原數組：
[5 2 6 2 7 5 6 8 2 9]

返回去重元素的重複數量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]