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

NumPy數組操作

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

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

修改數組形狀

函數	描述
reshape	不改變數據的條件下修改形狀
flat	數組元素迭代器
flatten	返回一份數組拷貝，對拷貝所做的修改不會影響原始數組
ravel	返回展開數組

numpy.reshape

numpy.reshape 函數可以在不改變數據的條件下修改形狀，格式如下： numpy.reshape(arr, newshape, order=‘C’)

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

實例：

import numpy as np

a = np.arange(8)
print('原始數組:')
print(a)
print('\n')

b = a.reshape(4,2)
print('修改後的數組：')
print(b)

輸出結果如下：

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

numpy.ndarray.flat

numpy.ndarray.flat是一個數組元素迭代器，實例如下：
實例：

import numpy as np

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

# 對數組中每個元素都進行處理，可以使用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

numpy.ndarray.flatten

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

ndarray.flatten(order='C')

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

import numpy as np

a = np.arange(8).reshape(2, 4)

print('原數組：')
print(a)
print('\n')
# 默認按行

print('展開的數組：')
print(a.flatten())
print('\n')

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]

numpy.ravel

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

該函數接收兩個參數：

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

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

實例：

import numpy as np

a = np.arange(8).reshape(2, 4)

print('原數組：')
print(a)
print('\n')

print('調用 ravel 函數之後：')
print(a.ravel())
print('\n')

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]

翻轉數組：

函數	描述
transpose	對換數組的維度
ndarray.T	和self.transpose()相同
rollaxis	向後滾動指定的軸
swapaxes	對換數組的兩個軸

numpy.transpose

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

numpy.transpose(arr, axes)

參數說明：

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

import numpy as np

a = np.arange(12).reshape(3,4)

print('原數組：')
print(a)
print('\n')

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]]

numpy.ndarray.T 類似 numpy.transpose：
實例：

import numpy as np

a = np.arange(12).reshape(3,4)

print('原數組：')
print(a)
print('\n')

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]]

numpy.rollaxis

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

numpy.rollaxis(arr, axis, start)

參數說明：

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

實例：

import numpy as np

# 創建了三維的 ndarray
a = np.arange(8).reshape(2, 2, 2)

print('原數組：')
print(a)
print('\n')
# 將軸 2 滾動到軸 0（寬度到深度）

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

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]]]

numpy.swapaxes

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

numpy.swapaxes(arr, axis1, axis2)

• arr：輸入的數組
• axis1:對應第一個軸的整數
• axis2:對應第二個軸的整數
  實例：

import numpy as np

#創建了三維的ndarray
a = np.arange(8).reshape(2,2,2)

print('原數組:')
print(a)
print('\n')
#現在交換軸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]]]

修改數組維度

維度	描述
broadcast	產生模仿廣播的對象
broadcast_to	將數組廣播到新形狀
expand_dims	擴展數組的形狀
squeeze	從數組的形狀中刪除一維條目

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))
print ('\n')
# shape 屬性返回廣播對象的形狀
 
print ('廣播對象的形狀：')
print (b.shape)
print ('\n')
# 手動使用 broadcast 將 x 與 y 相加
b = np.broadcast(x,y)
c = np.empty(b.shape)
 
print ('手動使用 broadcast 將 x 與 y 相加：')
print (c.shape)
print ('\n')
c.flat = [u + v for (u,v) in b]
 
print ('調用 flat 函數：')
print (c)
print ('\n')
# 獲得了和 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]]

numpy.broadcast_to

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

numpy.broadcast_to(array, shape, subok)

實例：

import numpy as np

a = np.arange(4).reshape(1,4)
print('原數組:')
print(a)
print('\n')

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]]

numpy.expand_dims

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

numpy.expand_dims(arr, axis)

參數說明：

• arr:輸入數組
• axis:新軸插入的位置

import numpy as np

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

print('數組 x：')
print(x)
print('\n')
y = np.expand_dims(x, axis=0)

print('數組 y：')
print(y)
print('\n')

print('數組 x 和 y 的形狀：')
print(x.shape, y.shape)
print('\n')
# 在位置 1 插入軸
y = np.expand_dims(x, axis=1)

print('在位置 1 插入軸之後的數組 y：')
print(y)
print('\n')

print('x.ndim 和 y.ndim：')
print(x.ndim, y.ndim)
print('\n')

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)

numpy.squeeze

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

numpy.squeeze(arr, axis)

參數說明：

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

import numpy as np

x = np.arange(9).reshape(1, 3, 3)

print('數組 x：')
print(x)
print('\n')
y = np.squeeze(x)

print('數組 y：')
print(y)
print('\n')

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)

連接數組

函數	描述
concatenate	連接沿現有軸的數組序列
stack	沿着新的軸加入一系列數組。
hstack	水平堆疊序列中的數組（列方向）
vstack	豎直堆疊序列中的數組 （行方向）

numpy.concatenate

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

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

參數說明：

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

實例：

import numpy as np

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

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

print('第二個數組：')
print(b)
print('\n')
# 兩個數組的維度相同

print('沿軸 0 連接兩個數組：')
print(np.concatenate((a, b)))
print('\n')

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]]

numpy.stack

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

numpy.stack(arrays, axis)

參數說明：

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

實例：

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一個數組：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二個數組：')
print (b)
print ('\n')
 
print ('沿軸 0 堆疊兩個數組：')
print (np.stack((a,b),0))
print ('\n')
 
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]]]

numpy.hstack

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

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一個數組：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二個數組：')
print (b)
print ('\n')
 
print ('水平堆疊：')
c = np.hstack((a,b))
print (c)
print ('\n')

輸出結果如下：

第一個數組：
[[1 2]
 [3 4]]
第二個數組：
[[5 6]
 [7 8]]
水平堆疊：
[[1 2 5 6]
 [3 4 7 8]]

numpy.vstack

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

import numpy as np

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

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

print('第二個數組：')
print(b)
print('\n')

print('豎直堆疊：')
c = np.vstack((a, b))
print(c)

輸出結果爲：

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


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


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

分割數組

函數	數組及操作
split	將一個數組分割爲多個子數組
hsplit	將一個數組水平分割爲多個子數組（按列）
vsplit	將一個數組垂直分割爲多個子數組（按行）

numpy.split

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

numpy.split(ary, indices_or_sections, axis)

參數說明：

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

實例：

import numpy as np
 
a = np.arange(9)
 
print ('第一個數組：')
print (a)
print ('\n')
 
print ('將數組分爲三個大小相等的子數組：')
b = np.split(a,3)
print (b)
print ('\n')
 
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])]

numpy.hsplit

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

import numpy as np

# 生成一個2行，6列的數組
harr = np.floor(10 * np.random.random((2,6)))
print('原array:')
print(harr)

print('拆分後：')
print(np.hsplit(harr,3))

輸出結果爲：

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

numpy.vsplit

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

import numpy as np

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

print('第一個數組：')
print(a)
print('\n')

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]])]

數組元素的添加與刪除

函數	元素及描述
resize	返回指定形狀的新數組
append	將值添加到數組末尾
insert	沿指定軸將值插入到指定下標之前
delete	刪掉某個軸的子數組，並返回刪除後的新數組
unique	查找數組內的唯一元素

numpy.resize

numpy.resize 函數返回指定大小的新數組。
如果新數組大小大於原始大小，則包含原始數組中的元素的副本。

numpy.resize(arr, shape)

參數說明：

• arr:要修改大小的數組
• shape:返回數組的新形狀

import numpy as np
 
a = np.array([[1,2,3],[4,5,6]])
 
print ('第一個數組：')
print (a)
print ('\n')
 
print ('第一個數組的形狀：')
print (a.shape)
print ('\n')
b = np.resize(a, (3,2))
 
print ('第二個數組：')
print (b)
print ('\n')
 
print ('第二個數組的形狀：')
print (b.shape)
print ('\n')
# 要注意 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]]

numpy.append

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

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

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

參數說明：

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

實例：

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

numpy.insert

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

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

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

參數說明：

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

import numpy as np

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

print('第一個數組：')
print(a)
print('\n')

print('未傳遞 Axis 參數。 在插入之前輸入數組會被展開。')
print(np.insert(a, 3, [11, 12]))
print('\n')
print('傳遞了 Axis 參數。 會廣播值數組來配輸入數組。')

print('沿軸 0 廣播：')
print(np.insert(a, 1, [11], axis=0))
print('\n')

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]]

numpy.delete

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

Numpy.delete(arr,obj,axis)

參數說明：

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

import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('第一個數組：')
print (a)
print ('\n')
 
print ('未傳遞 Axis 參數。 在插入之前輸入數組會被展開。')
print (np.delete(a,5))
print ('\n')
 
print ('刪除第二列：')
print (np.delete(a,1,axis = 1))
print ('\n')
 
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]

numpy.unique

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

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

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

實例：

import numpy as np

a = np.array([5,2,6,2,7,5,6,8,2,9])

print('第一個數組：')
print(a)
print('\n')

print('第一個數組的去重值：')
u = np.unique(a)
print(u)
print('\n')

print('去重數組的索引數組：')
u,indices = np.unique(a,return_index=True)
print(u)
#即：留下來的元素在原來數組中的值
print(indices)
print('\n')

print('我們可以看到每個和原數組下標對應的數值：')
print(a)
print('\n')

print('去重數組的下標：')
u,indices = np.unique(a,return_inverse=True)
print(u)
print('\n')

print('下標爲(表示：[5 2 6 2 7 5 6 8 2 9]，在u中的位置)：')
print(indices)
print('\n')

print('使用下標重構原數組（通過u和在u中的座標重新構造原來的數組）：')
print(u[indices])

print('返回去重元素的重複數量：')
u,indices = np.unique(a,return_counts=True)
print(u)
# 表示u中出現了重複了元素的次數
print(indices)

輸出結果爲：

第一個數組：
[5 2 6 2 7 5 6 8 2 9]
第一個數組的去重值：
[2 5 6 7 8 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]
下標爲(表示：[5 2 6 2 7 5 6 8 2 9]，在u中的位置)：
[1 0 2 0 3 1 2 4 0 5]
使用下標重構原數組（通過u和在u中的座標重新構造原來的數組）：
[5 2 6 2 7 5 6 8 2 9]
返回去重元素的重複數量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]