#頭條創作挑戰賽#

NumPy 字符串函數

以下函數用于對 dtype 為 numpy.string_ 或 numpy.unicode_ 的數組執行向量化字符串操作。 它們基于 Python 內置庫中的標準字符串函數。

numpy.char.add()

numpy.char.add() 函數依次對兩個數組的元素進行字符串連接。

import numpy as np
print("連接兩個字符串：")
print(np.char.add(['hello'],[' rainNight']))

連接兩個字符串：
['hello rainNight']

numpy.char.multiply()

numpy.char.multiply() 函數執行多重連接。

import numpy as np
print(np.char.multiply('RainNight ',4))

RainNight RainNight RainNight RainNight 

numpy.char.center()

numpy.char.center() 函數用于將字符串居中，并使用指定字符在左側和右側進行填充。

import numpy as np
# str: 字符串，width: 長度，fillchar: 填充字符
print (np.char.center('RainNight', 25,fillchar = '+'))

++++++++RainNight++++++++

numpy.char.capitalize()

numpy.char.capitalize() 函數將字符串的第一個字母轉換為大寫：

import numpy as np
print (np.char.capitalize('rainNight'))

Rainnight

numpy.char.title()

numpy.char.title() 函數將字符串的每個單詞的第一個字母轉換為大寫：

import numpy as np
print (np.char.title('i like geek'))

I Like Geek

numpy.char.lower()

numpy.char.lower() 函數對數組的每個元素轉換為小寫。它對每個元素調用 str.lower。

import numpy as np
#操作數組
print (np.char.lower(['RAINNIGHT','GEEK']))
# 操作字符串
print (np.char.lower('RAINNIGHT'))

['rainnight' 'geek']
rainnight

numpy.char.upper()

numpy.char.upper() 函數對數組的每個元素轉換為大寫。它對每個元素調用 str.upper。

import numpy as np
#操作數組
print (np.char.upper(['rainnight','geek']))
# 操作字符串
print (np.char.upper('rainnight'))

['RAINNIGHT' 'GEEK']
RAINNIGHT

numpy.char.split()

numpy.char.split() 通過指定分隔符對字符串進行分割，并返回數組。默認情況下，分隔符為空格。

import numpy as np 
# 分隔符默認為空格
print (np.char.split ('i like geek?'))
# 分隔符為 .
print (np.char.split ('www.nerearn.top', sep = '.'))

['i', 'like', 'geek?']
['www', 'nerearn', 'top']

numpy.char.splitlines()

numpy.char.splitlines() 函數以換行符作為分隔符來分割字符串，并返回數組。

import numpy as np 
# 換行符 \n
print (np.char.splitlines('i\nlike geek?')) 
print (np.char.splitlines('i\rlike geek?'))

['i', 'like geek?']
['i', 'like geek?']

numpy.char.strip()

numpy.char.strip() 函數用于移除開頭或結尾處的特定字符。

import numpy as np 
# 移除字符串頭尾的 a 字符
print (np.char.strip('rain night char','a'))
# 移除數組元素頭尾的 a 字符
print (np.char.strip(['rain','run','char'],'r'))

rain night char
['ain' 'un' 'cha']

numpy.char.join()

numpy.char.join() 函數通過指定分隔符來連接數組中的元素或字符串

import numpy as np 
# 操作字符串
print (np.char.join(':','rainNight'))
# 指定多個分隔符操作數組元素
print (np.char.join([':','-'],['rainNight','geek']))

r:a:i:n:N:i:g:h:t
['r:a:i:n:N:i:g:h:t' 'g-e-e-k']

numpy.char.replace()

numpy.char.replace() 函數使用新字符串替換字符串中的所有子字符串。

import numpy as np 
print (np.char.replace ('i like geek', 'ee', 'oo'))

i like gook

numpy.char.encode()

numpy.char.encode() 函數對數組中的每個元素調用 str.encode 函數。 默認編碼是 utf-8，可以使用標準 Python 庫中的編解碼器。

import numpy as np 
a = np.char.encode('geek', 'cp500') 
print (a)

b'\x87\x85\x85\x92'

numpy.char.decode()

numpy.char.decode() 函數對編碼的元素進行 str.decode() 解碼。

import numpy as np 
a = np.char.encode('geek', 'cp500') 
print (a)
print (np.char.decode(a,'cp500'))

b'\x87\x85\x85\x92'
geek

NumPy 數學函數

NumPy 包含大量的各種數學運算的函數，包括三角函數，算術運算的函數，復數處理函數等。

三角函數

NumPy 提供了標準的三角函數：sin()、cos()、tan()。

import numpy as np
a = np.array([0,30,45,60,90])
print ('不同角度的正弦值：')
# 通過乘 pi/180 轉化為弧度  
print (np.sin(a*np.pi/360))
print ('\n')
print ('數組中角度的余弦值：')
print (np.cos(a*np.pi/360))
print ('\n')
print ('數組中角度的正切值：')
print (np.tan(a*np.pi/360))

不同角度的正弦值：
[0.         0.25881905 0.38268343 0.5        0.70710678]


數組中角度的余弦值：
[1.         0.96592583 0.92387953 0.8660254  0.70710678]


數組中角度的正切值：
[0.         0.26794919 0.41421356 0.57735027 1.        ]

arcsin，arccos，和 arctan 函數返回給定角度的 sin，cos 和 tan 的反三角函數。

這些函數的結果可以通過 numpy.degrees() 函數將弧度轉換為角度。

import numpy as np
a = np.array([0,30,45,60,90])  
print ('含有正弦值的數組：')
sin = np.sin(a*np.pi/180)  
print (sin)brprint ('\n')
print ('計算角度的反正弦，返回值以弧度為單位：')
inv = np.arcsin(sin)  
print (inv)
print ('\n')
print ('通過轉化為角度制來檢查結果：')
print (np.degrees(inv))
print ('\n')
print ('arccos 和 arctan 函數行為類似：')
cos = np.cos(a*np.pi/180)  
print (cos)
print ('\n')
print ('反余弦：')
inv = np.arccos(cos)  
print (inv)
print ('\n')
print ('角度制單位：')
print (np.degrees(inv))
print ('\n')
print ('tan 函數：')
tan = np.tan(a*np.pi/180)  
print (tan)brprint ('\n')
print ('反正切：')
inv = np.arctan(tan)  
print (inv)
print ('\n')
print ('角度制單位：')
print (np.degrees(inv))

含有正弦值的數組：
[0.         0.5        0.70710678 0.8660254  1.        ]


計算角度的反正弦，返回值以弧度為單位：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]


通過轉化為角度制來檢查結果：
[ 0. 30. 45. 60. 90.]


arccos 和 arctan 函數行為類似：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
 6.12323400e-17]


反余弦：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]


角度制單位：
[ 0. 30. 45. 60. 90.]


tan 函數：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
 1.63312394e+16]


反正切：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]


角度制單位：
[ 0. 30. 45. 60. 90.]

雨夜的博客–數學工具：向量運算、冪指運算、N次方計算器、三角函數運算、在線分解質因數計算器

舍入函數

numpy.around() 函數返回指定數字的四舍五入值。

numpy.around(a,decimals)

import numpy as np
a = np.array([1.0,5.55,  123,  0.567,  25.532])  
print  ('原數組：')
print (a)
print ('\n')
print ('舍入后：')
print (np.around(a))
print (np.around(a, decimals =  1))
print (np.around(a, decimals =  -1))

原數組：
[  1.      5.55  123.      0.567  25.532]


舍入后：
[  1.   6. 123.   1.  26.]
[  1.    5.6 123.    0.6  25.5]
[  0.  10. 120.   0.  30.]

numpy.floor()

numpy.floor() 返回小于或者等于指定表達式的最大整數，即向下取整。

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print ('提供的數組：')
print (a)
print ('\n')
print ('修改后的數組：')
print (np.floor(a))

提供的數組：
[-1.7  1.5 -0.2  0.6 10. ]


修改后的數組：
[-2.  1. -1.  0. 10.]

numpy.ceil()

numpy.ceil() 返回大于或者等于指定表達式的最小整數，即向上取整。

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print  ('提供的數組：')
print (a)
print ('\n')
print ('修改后的數組：')
print (np.ceil(a))

提供的數組：
[-1.7  1.5 -0.2  0.6 10. ]


修改后的數組：
[-1.  2. -0.  1. 10.]

NumPy 算術函數

NumPy 算術函數包含簡單的加減乘除: add()，subtract()，multiply() 和 divide()。

需要注意的是數組必須具有相同的形狀或符合數組廣播規則。

import numpy as np 
a = np.arange(9, dtype = np.float_).reshape(3,3)  
print ('第一個數組：')
print (a)
print ('\n')
print ('第二個數組：')
b = np.array([10,10,10])  
print (b)
print ('\n')
print ('兩個數組相加：')
print (np.add(a,b))
print ('\n')
print ('兩個數組相減：')
print (np.subtract(a,b))
print ('\n')
print ('兩個數組相乘：')
print (np.multiply(a,b))
print ('\n')
print ('兩個數組相除：')
print (np.divide(a,b))

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


第二個數組：
[10 10 10]


兩個數組相加：
[[10. 11. 12.]
 [13. 14. 15.]
 [16. 17. 18.]]


兩個數組相減：
[[-10.  -9.  -8.]
 [ -7.  -6.  -5.]
 [ -4.  -3.  -2.]]


兩個數組相乘：
[[ 0. 10. 20.]
 [30. 40. 50.]
 [60. 70. 80.]]


兩個數組相除：
[[0.  0.1 0.2]
 [0.3 0.4 0.5]
 [0.6 0.7 0.8]]

此外 Numpy 也包含了其他重要的算術函數。

向量運算

numpy.reciprocal()

numpy.reciprocal() 函數返回參數逐元素的倒數。如 1/4 倒數為 4/1。

import numpy as np 
a = np.array([0.25,  1.33,  1,  100])  
print ('我們的數組是：')
print (a)
print ('\n')
print ('調用 reciprocal 函數：')
print (np.reciprocal(a))

我們的數組是：
[  0.25   1.33   1.   100.  ]


調用 reciprocal 函數：
[4.        0.7518797 1.        0.01     ]

numpy.power()

numpy.power() 函數將第一個輸入數組中的元素作為底數，計算它與第二個輸入數組中相應元素的冪。

import numpy as np 
a = np.array([10,100,1000])  
print ('我們的數組是；')
print (a)
print ('\n') 
print ('調用 power 函數：')
print (np.power(a,2))
print ('\n')
print ('第二個數組：')
b = np.array([1,2,3])  
print (b)
print ('\n')
print ('再次調用 power 函數：')
print (np.power(a,b))

我們的數組是；
[  10  100 1000]


調用 power 函數：
[    100   10000 1000000]


第二個數組：
[1 2 3]


再次調用 power 函數：
[        10      10000 1000000000]

numpy.mod()

numpy.mod() 計算輸入數組中相應元素的相除后的余數。 函數 numpy.remainder() 也產生相同的結果。

import numpy as np
a = np.array([10,20,30]) 
b = np.array([3,5,7])  
print ('第一個數組：')
print (a)
print ('\n')
print ('第二個數組：')
print (b)
print ('\n')
print ('調用 mod() 函數：')
print (np.mod(a,b))
print ('\n')
print ('調用 remainder() 函數：')
print (np.remainder(a,b))

第一個數組：
[10 20 30]


第二個數組：
[3 5 7]


調用 mod() 函數：
[1 0 2]


調用 remainder() 函數：
[1 0 2]

雨夜的博客–數學工具：向量運算、冪指運算、N次方計算器、三角函數運算、在線分解質因數計算器

NumPy 統計函數

NumPy 提供了很多統計函數，用于從數組中查找最小元素，最大元素，百分位標準差和方差等。 函數說明如下：

numpy.amin() 和 numpy.amax()

numpy.amin() 用于計算數組中的元素沿指定軸的最小值。

numpy.amax() 用于計算數組中的元素沿指定軸的最大值。

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print ('我們的數組是：')
print (a)brprint ('\n')
print ('調用 amin() 函數：')
print (np.amin(a,1))
print ('\n')
print ('再次調用 amin() 函數：')
print (np.amin(a,0))
print ('\n')
print ('調用 amax() 函數：')
print (np.amax(a))
print ('\n')
print ('再次調用 amax() 函數：')
print (np.amax(a, axis =  0))

我們的數組是：
[[3 7 5]
 [8 4 3]
 [2 4 9]]


調用 amin() 函數：
[3 3 2]


再次調用 amin() 函數：
[2 4 3]


調用 amax() 函數：
9


再次調用 amax() 函數：
[8 7 9]

numpy.ptp()

numpy.ptp()函數計算數組中元素最大值與最小值的差（最大值 – 最小值）。

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print ('我們的數組是：')
print (a)
print ('\n')
print ('調用 ptp() 函數：')
print (np.ptp(a))
print ('\n')
print ('沿軸 1 調用 ptp() 函數：')
print (np.ptp(a, axis =  1))
print ('\n')
print ('沿軸 0 調用 ptp() 函數：')
print (np.ptp(a, axis =  0))

我們的數組是：
[[3 7 5]
 [8 4 3]
 [2 4 9]]


調用 ptp() 函數：
7


沿軸 1 調用 ptp() 函數：
[4 5 7]


沿軸 0 調用 ptp() 函數：
[6 3 6]

numpy.percentile()

百分位數是統計中使用的度量，表示小于這個值的觀察值的百分比。 函數numpy.percentile()接受以下參數。

numpy.percentile(a, q, axis)

import numpy as np
a = np.array([[10, 7, 4], [3, 2, 1]])
print ('我們的數組是：')
print (a)
print ('調用 percentile() 函數：')
# 50% 的分位數，就是 a 里排序之后的中位數
print (np.percentile(a, 50)) 
# axis 為 0，在縱列上求
print (np.percentile(a, 50, axis=0)) 
# axis 為 1，在橫行上求
print (np.percentile(a, 50, axis=1)) 
# 保持維度不變
print (np.percentile(a, 50, axis=1, keepdims=True))

我們的數組是：
[[10  7  4]
 [ 3  2  1]]
調用 percentile() 函數：
3.5
[6.5 4.5 2.5]
[7. 2.]
[[7.]
 [2.]]

numpy.median()

numpy.median() 函數用于計算數組 a 中元素的中位數（中值）

import numpy as np
a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
print ('我們的數組是：')
print (a)
print ('\n')
print ('調用 median() 函數：')
print (np.median(a))
print ('\n')
print ('沿軸 0 調用 median() 函數：')
print (np.median(a, axis =  0))
print ('\n')
print ('沿軸 1 調用 median() 函數：')
print (np.median(a, axis =  1))

我們的數組是：
[[30 65 70]
 [80 95 10]
 [50 90 60]]


調用 median() 函數：
65.0


沿軸 0 調用 median() 函數：
[50. 90. 60.]


沿軸 1 調用 median() 函數：
[65. 80. 60.]

numpy.mean()

numpy.mean() 函數返回數組中元素的算術平均值。 如果提供了軸，則沿其計算。

算術平均值是沿軸的元素的總和除以元素的數量。

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print ('我們的數組是：')
print (a)
print ('\n')
print ('調用 mean() 函數：')
print (np.mean(a))
print ('\n')
print ('沿軸 0 調用 mean() 函數：')
print (np.mean(a, axis =  0))
print ('\n')
print ('沿軸 1 調用 mean() 函數：')
print (np.mean(a, axis =  1))

我們的數組是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]


調用 mean() 函數：
3.6666666666666665


沿軸 0 調用 mean() 函數：
[2.66666667 3.66666667 4.66666667]


沿軸 1 調用 mean() 函數：
[2. 4. 5.]

numpy.average()

numpy.average() 函數根據在另一個數組中給出的各自的權重計算數組中元素的加權平均值。

該函數可以接受一個軸參數。 如果沒有指定軸，則數組會被展開。

加權平均值即將各數值乘以相應的權數，然后加總求和得到總體值，再除以總的單位數。

考慮數組[1,2,3,4]和相應的權重[4,3,2,1]，通過將相應元素的乘積相加，并將和除以權重的和，來計算加權平均值。

import numpy as np 
a = np.array([1,2,3,4])  
print ('我們的數組是：')
print (a)
print ('\n')
print ('調用 average() 函數：')
print (np.average(a))
print ('\n')
# 不指定權重時相當于 mean 函數
wts = np.array([4,3,2,1])  
print ('再次調用 average() 函數：')
print (np.average(a,weights = wts))
print ('\n')
# 如果 returned 參數設為 true，則返回權重的和  
print ('權重的和：')
print (np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))

我們的數組是：
[1 2 3 4]


調用 average() 函數：
2.5


再次調用 average() 函數：
2.0


權重的和：
(2.0, 10.0)

在多維數組中，可以指定用于計算的軸。

import numpy as np 
a = np.arange(6).reshape(3,2)  
print ('我們的數組是：')
print (a)
print ('\n')
print ('修改后的數組：')
wt = np.array([3,5])  
print (np.average(a, axis =  1, weights = wt))
print ('\n')
print ('修改后的數組：')
print (np.average(a, axis =  1, weights = wt, returned =  True))br

我們的數組是：
[[0 1]
 [2 3]
 [4 5]]


修改后的數組：
[0.625 2.625 4.625]


修改后的數組：
(array([0.625, 2.625, 4.625]), array([8., 8., 8.]))

標準差

標準差是一組數據平均值分散程度的一種度量。

標準差是方差的算術平方根。

標準差公式如下：

std = sqrt(mean((x – x.mean())**2))

import numpy as np 
print (np.std([1,2,3,4]))

1.118033988749895

方差

統計中的方差（樣本方差）是每個樣本值與全體樣本值的平均數之差的平方值的平均數，即 mean((x – x.mean())** 2)。

換句話說，標準差是方差的平方根。

import numpy as np
print (np.var([1,2,3,4]))

1.25

NumPy 排序、條件刷選函數

NumPy 提供了多種排序的方法。 這些排序函數實現不同的排序算法，每個排序算法的特征在于執行速度，最壞情況性能，所需的工作空間和算法的穩定性。 下表顯示了三種排序算法的比較。

numpy.sort()

numpy.sort() 函數返回輸入數組的排序副本。

numpy.sort(a, axis, kind, order)

import numpy as np  
a = np.array([[3,7],[9,1]])  
print ('我們的數組是：')
print (a)
print ('\n')
print ('調用 sort() 函數：')
print (np.sort(a))
print ('\n')
print ('按列排序：')
print (np.sort(a, axis =  0))
print ('\n')
# 在 sort 函數中排序字段 
dt = np.dtype([('name',  'S10'),('age',  int)]) 
a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
print ('我們的數組是：')
print (a)
print ('\n')
print ('按 name 排序：')
print (np.sort(a, order =  'name'))

我們的數組是：
[[3 7]
 [9 1]]


調用 sort() 函數：
[[3 7]
 [1 9]]


按列排序：
[[3 1]
 [9 7]]


我們的數組是：
[(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]


按 name 排序：
[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]

numpy.argsort()

numpy.argsort() 函數返回的是數組值從小到大的索引值。

import numpy as np
x = np.array([3,  1,  2])  
print ('我們的數組是：')
print (x)
print ('\n')
print ('對 x 調用 argsort() 函數：')
y = np.argsort(x)  
print (y)
print ('\n')
print ('以排序后的順序重構原數組：')
print (x[y])
print ('\n')
print ('使用循環重構原數組：')
for i in y:  
   print (x[i], end=" ")

我們的數組是：
[3 1 2]


對 x 調用 argsort() 函數：
[1 2 0]


以排序后的順序重構原數組：
[1 2 3]


使用循環重構原數組：
1 2 3 

numpy.lexsort()

numpy.lexsort() 用于對多個序列進行排序。把它想象成對電子表格進行排序，每一列代表一個序列，排序時優先照顧靠后的列。

import numpy as np 
nm =  ('raju','anil','ravi','amar') 
dv =  ('f.y.',  's.y.',  's.y.',  'f.y.') 
ind = np.lexsort((dv,nm))  
print ('調用 lexsort() 函數：') 
print (ind) 
print ('\n') 
print ('使用這個索引來獲取排序后的數據：') 
print ([nm[i]  +  ", "  + dv[i]  for i in ind])

調用 lexsort() 函數：
[3 1 0 2]


使用這個索引來獲取排序后的數據：
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

numpy.argmax() 和 numpy.argmin()

numpy.argmax() 和 numpy.argmin()函數分別沿給定軸返回最大和最小元素的索引。

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print  ('我們的數組是：') 
print (a) 
print ('\n') 
print ('調用 argmax() 函數：') 
print (np.argmax(a)) 
print ('\n') 
print ('展開數組：') 
print (a.flatten()) 
print ('\n') 
print ('沿軸 0 的最大值索引：') 
maxindex = np.argmax(a, axis =  0)  
print (maxindex) 
print ('\n') 
print ('沿軸 1 的最大值索引：') 
maxindex = np.argmax(a, axis =  1)  
print (maxindex) 
print ('\n') 
print ('調用 argmin() 函數：') 
minindex = np.argmin(a)  
print (minindex) 
print ('\n') 
print ('展開數組中的最小值：') 
print (a.flatten()[minindex]) 
print ('\n') 
print ('沿軸 0 的最小值索引：') 
minindex = np.argmin(a, axis =  0)  
print (minindex) 
print ('\n') 
print ('沿軸 1 的最小值索引：') 
minindex = np.argmin(a, axis =  1)  
print (minindex)

我們的數組是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]


調用 argmax() 函數：
7


展開數組：
[30 40 70 80 20 10 50 90 60]


沿軸 0 的最大值索引：
[1 2 0]


沿軸 1 的最大值索引：
[2 0 1]


調用 argmin() 函數：
5


展開數組中的最小值：
10


沿軸 0 的最小值索引：
[0 1 1]


沿軸 1 的最小值索引：
[0 2 0]

numpy.nonzero()

numpy.nonzero() 函數返回輸入數組中非零元素的索引。

import numpy as np
a = np.array([[30,40,0],[0,20,10],[50,0,60]])
print ('我們的數組是：')
print (a)
print ('\n')
print ('調用 nonzero() 函數：')
print (np.nonzero (a))

我們的數組是：
[[30 40  0]
 [ 0 20 10]
 [50  0 60]]


調用 nonzero() 函數：
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

numpy.where()

numpy.where() 函數返回輸入數組中滿足給定條件的元素的索引。

import numpy as np 
x = np.arange(9.).reshape(3,  3) 
print ('我們的數組是：')
print (x)
print ( '大于 3 的元素的索引：')
y = np.where(x >  3)  
print (y)
print ('使用這些索引來獲取滿足條件的元素：')
print (x[y])

我們的數組是：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
大于 3 的元素的索引：
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
使用這些索引來獲取滿足條件的元素：
[4. 5. 6. 7. 8.]

numpy.extract()

numpy.extract() 函數根據某個條件從數組中抽取元素，返回滿條件的元素。

import numpy as np 
x = np.arange(9.).reshape(3,  3) 
print ('我們的數組是：')
print (x)
# 定義條件, 選擇偶數元素
condition = np.mod(x,2)  ==  0  
print ('按元素的條件值：')
print (condition)
print ('使用條件提取元素：')
print (np.extract(condition, x))

我們的數組是：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
按元素的條件值：
[[ True False  True]
 [False  True False]
 [ True False  True]]
使用條件提取元素：
[0. 2. 4. 6. 8.]