原文鏈接： https://www.numpy.org.cn/
本節內容：
- 數組的創建
- 數組操作（獲取數組屬性，數組運算，數組復制，數組展開等等）
- 獲取數組特定元素
1、創建數組
（1）常用的創建一維數組的方式
# 可以將任意類型的序列（列表、元組、字典、集合、字符串）傳遞給np.array()
a1 = np.array([1, 2, 3, 4]) # 傳遞列表
a2 = np.array((1, 2, 3, 4)) # 傳遞元組
a3 = np.array([1, 2, 3, 4], dtype=float) # 在創建時，指定數組元素的類型
a4 = a3.astype(str) # 也可以改變數組元素的類型
a5 = np.array([1, 2.0, 'a'], dtype=object) # 可以將類型設置成object，就能讓數組接收多種類型的值
a6 = a5.tolist() # 可以將數組轉化回list
print(a1, '\n') # [1 2 3 4]
print(a2, '\n') # [1 2 3 4]
print(a3) # [1. 2. 3. 4.]
print(a4) # ['1.0' '2.0' '3.0' '4.0']
print(a5) # [1 2.0 'a']
print(a6) # [1, 2.0, 'a']
（2）快速創建特定一維數組的幾個方法
# 情況1
# 快速創建一個所有元素為0的數組,用np.zeros()
# 與此類似還有np.ones(),創建一個所有元素為1的數組
# 只有一個參數時可以寫成：np.zeros(5)
# 打印結果：[0. 0. 0. 0. 0.]
my_new_array = np.zeros((5))
print(my_new_array)
# 情況2
# 創建一個隨機數值的數組
# 默認是為每個元素分配0-1之間的隨機值
# 同上述相同，只有一個參數時，可以寫成np.random.random(5)
my_random_array = np.random.random((5))
print(my_random_array)
# 情況3
# 創建一個值范圍為0到4的數組
c = np.arange(5)
print(c) # [0 1 2 3 4]
# np.arange()可以創建一個在定義的起始值和結束值之間具有特定序列的數組；3表示步長
c2 = np.arange(10, 35, 3)
print(c2) # [10 13 16 19 22 25 28 31 34]
# 情況4
# 在0到4之間創建4個元素的數組，這4個元素平均分布在0-4之間
d = np.linspace(0, 4, 4)
print(d) #[0. 1.33333333 2.66666667 4. ]
（3）創建多維數組
# 方式1
# 如下，為了創建一個二維數組，我們傳遞了一個列表的列表；
# 同理也可以傳遞一個元組的元組來創建一個二維數組；既有行又有列則為二維
a = np.array([[1.0, 2.0], [3.0, 4.0]])
print(a)
# 方式2
# 也可以通過reshape()方法將一維數組改造形狀變成多維數組
# 這里是將一維數組變成4*5的二維數組
array = np.arange(20).reshape(4,5)
print(array)
2、數組的操作
（1）通過索引訪問數組元素
# 對一維數組，a[i]形式訪問數組
array1 = np.array([1, 2, 3, 4])
print(array1[0], array1[1], array1[2], array1[3]) # 1 2 3 4
# 對二維數組通過a[i][j]形式訪問數組元素
array2 = array1.reshape(2, 2)
print(array2[0][0], array2[0][1], array2[1][0], array2[1][1]) # 1 2 3 4
# 如下形式也可以獲取二維數組單個元素
print(array2[0, 0])
（2）獲取數組的一些屬性
array1 = np.array([1, 2, 3, 4])
array2 = array1.reshape(2, 2)
array3 = np.array(['a', 'b', 'c'])
# 1、打印array1對象的類型，
print(type(array1))
#2、 打印數組元素的數據類型
print(array1.dtype) # int32
print(array3.dtype) #
<表示字節順序，小端（最小有效字節存儲在最小地址中）
# U表示Unicode，數據類型
# 1表示元素位長，數據大小
# 3、打印數組元素個數
print(array1.size) # 4
print(array2.size) # 4
# 4、打印數組形狀
print(array1.shape) # (4,)
# 也可以按方法的形式獲取該屬性
print(np.shape(array1)) # (4,)
print(array2.shape) # (2, 2)
# 可以獲取shape返回的元組中的值;如下獲取的就是array2數組有幾行
print(array2.shape[0]) # 2
# 5、打印數組中的一個元素占幾個字節;
# 因為在array1.shape數組元素是int32的，即32位整型；
# 而一個字節是8位，所以一個元素占32/8=4個字節
print(array1.itemsize) # 4
# 6、打印數組的維數;這個維數和shape元組中的元素個數一致
print(array1.ndim) # 1
#7、 打印數組要消耗多少內存（字節）；一般數組消耗的內存>=數組實際所占的內存
print(array1.nbytes) # 16
（3）數組的運算
array1 = np.array([[1, 2],
[3, 4]])
array2 = np.array([[5, 6],
[7, 8]])
# （1）可以發現數組的 + - * / 都是逐元素運算的
print(array1 + array2)
# [[ 6 8]
# [10 12]]
print(array1 - array2)
# [[-4 -4]
# [-4 -4]]
print(array1 * array2)
# [[ 5 12]
# [21 32]]
print(array1 / array2)
# [[0.2 0.33333333]
# [0.42857143 0.5 ]]
# （2）平方運算也是逐元素運算的
print(array1 ** 2)
# [[ 1 4]
# [ 9 16]]
# （3）>,<邏輯運算也是逐元素運算的；返回的是一個布爾型數組
print(array1 > array2)
# [[False False]
# [False False]]
# （4）array1.dot(array2)點積運算不是逐元素元素的，與矩陣乘法運算規則相同
print(array1.dot(array2))
# [[19 22]
# [43 50]]
# 對dot點積運算進一步探索；一維情況
x = np.array([1, 2, 3, 4])
y = np.array([5, 6])
# print(x.dot(y)) # 此時會報錯,如下
# ValueError: shapes (4,) and (2,) not aligned: 4 (dim 0) != 2 (dim 0)
# 當兩個一維數組的元素個數相同時，才能進行dot運算；1*5 + 2*6 + 3*7 + 4*8 = 70
z = np.array([5, 6, 7, 8])
print(x.dot(z)) # 70
# 對dot點積運算進一步探索；二維情況
p = np.array([[1, 2], [3, 4], [5, 6]])
q = np.array([2])
# print(p.dot(q)) # 報錯如下;表明p的列數要和q的行數相等，點積才能運算
# ValueError: shapes (3,2) and (1,) not aligned: 2 (dim 1) != 1 (dim 0)
r = np.array([[1], [2]])
print(p.dot(r))
# [[ 5]
# [11]
# [17]]
# （5）特殊運算符
a = np.arange(10)
print(a.mean()) # 4.5
print(a.sum()) # 45
print(a.min()) # 0
print(a.max()) # 9
print(a.cumsum()) # [ 0 1 3 6 10 15 21 28 36 45]
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
# 逐列計算最小值
print(np.amin(a, axis=0)) # [1 2 3 4]
# 逐列計算最大值
print(np.amax(a, axis=0)) # [ 9 10 11 12]
# 逐行計算最小值
print(np.amin(a, axis=1)) # [1 5 9]
（4）數組的復制
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
# 淺復制；改變a2的同時，也改變了a
a2 = a
a2[0, 0] = 100
print(a)
# [[100 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
# 深復制；改變a3并沒有改變a
a3 = a.copy()
a3[0, 1] = 101
print(a3)
# [[100 101 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
print(a)
# [[100 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
（5）flatten和ravel展開數組的區別
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
b1 = a.flatten()
b2 = a.ravel()
print(b1) # [ 1 2 3 4 5 6 7 8 9 10 11 12]
print(b2) # [ 1 2 3 4 5 6 7 8 9 10 11 12]
# 可以發現b1是淺復制(flatten())
b1[0] = 100
print(a)
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
# b2是深復制(a.ravel())
b2[0] = 999
print(a)
# [[999 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
（6）tile和repeat創建重復數組
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
# 重復a的整體,2次
b = np.tile(a, 2)
print(b)
# [[ 1 2 3 4 1 2 3 4]
# [ 5 6 7 8 5 6 7 8]
# [ 9 10 11 12 9 10 11 12]]
# 逐元素重復a,每個元素重復3次，行優先；可以發現repeat方法返回的結果是一維數組
c = np.repeat(a, 3)
print(c)
# [ 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8
# 9 9 9 10 10 10 11 11 11 12 12 12]
（7）隨機數組的生成詳述
# （1）生成2*2的隨機數組；取值范圍[0,1)
print(np.random.rand(2, 2))
# [[0.05351956 0.52744627]
# [0.65351703 0.45760785]]
# （2）打印均值為0方差為1的正態分布形成的2*2隨機數組；
print(np.random.randn(2, 2))
# [[ 1.72616696e-01 -3.75028315e-01]
# [ 5.73511471e-01 -5.68613463e-04]]
# （3）打印2*2的隨機數組，隨機數取值范圍在[0, 10),左閉右開
print(np.random.randint(0, 10, size=[2, 2]))
# [[8 3]
# [9 1]]
#（4） 打印隨機數，取值范圍[0,1)
print(np.random.random())
# 0.6703799424762051
# 打印隨機數組，3個元素
print(np.random.random(3))
# [0.06488424 0.23714481 0.10028496]
# 打印2*1的隨機數組
print(np.random.random(size=[2, 1]))
# [[0.64914024]
# [0.89535928]]
# （5）在給定的列表中選擇隨機元素組成數組
print(np.random.choice(['aaa', 'b', 'c', 'ddd'], size=3))
# ['b' 'b' 'aaa']
# 從給定的列表中選擇10個項目，具有預定義的概率“p”;注意p中的概率加起來要等于1
print(np.random.choice(['a', 'e', 'i', 'o', 'u'], size=10, p=[0.3, 0.1, 0.1, 0.4, 0.1]))
# ['u' 'o' 'o' 'i' 'i' 'a' 'e' 'o' 'a' 'a']
# （6）如果要每次都重復同一組隨機數，則需要設置種子或隨機狀態
# 方式1，創建隨機狀態;會發現運行兩次打印出來的隨機數組相同的
r1 = np.random.RandomState(100)
print(r1.rand(2, 2))
# [[0.54340494 0.27836939]
# [0.42451759 0.84477613]]
# 方式2，設置隨機種子
np.random.seed(100)
print(np.random.rand(2, 1))
# [[0.54340494]
# [0.27836939]]
（8）unique方法
# np.unique()會返回無重復的數組元素；
# 將return_counts設置為True可以返回每個元素的計數;默認是False
a = np.array([1, 1, 2, 2, 2, 3, 4, 5, 6, 1])
u, c = np.unique(a, return_counts=True)
print(u, c) # [1 2 3 4 5 6] [3 3 1 1 1 1]
b = a.reshape(2, 5)
u, c = np.unique(b, return_counts=True)
print(u, c) # [1 2 3 4 5 6] [3 3 1 1 1 1]
3、獲取數組元素的幾種方法
（1）數組的切片操作—獲取數組某塊元素
a = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
# 獲取單個數組元素可以直接通過索引方式得到；注意索引是從0開始
print(a[2, 4]) # 25
# 切片操作，就是獲取數組某些部分的元素
# 打印數組第一行所有元素; 分號代表所有
print(a[0, :]) # [11 12 13 14 15]
# 打印數組第一列所有元素；
print(a[:, 0]) # [11 16 21 26 31]
# 打印第1,2,3列
print(a[:, 0:3])
# [[11 12 13]
# [16 17 18]
# [21 22 23]
# [26 27 28]
# [31 32 33]]
# 打印第1,2,4列
print(a[:, [0, 1, 3]])
# print(a[:, (0, 1, 3)]) # 元組也可以
# [[11 12 14]
# [16 17 19]
# [21 22 24]
# [26 27 29]
# [31 32 34]]
# 打印1,2,3行和1,2,4列
print(a[0:3, [0, 1, 3]])
# [[11 12 14]
# [16 17 19]
# [21 22 24]]
# 打印1,3,5行和1,3,5列; 即下標是0,2,4
print(a[::2, ::2])
# [[11 13 15]
# [21 23 25]
# [31 33 35]]
# 翻轉行和翻轉整個數組元素
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
print(a[::-1, ])
# [[ 9 10 11 12]
# [ 5 6 7 8]
# [ 1 2 3 4]]
print(a[::-1, ::-1])
# [[12 11 10 9]
# [ 8 7 6 5]
# [ 4 3 2 1]]
（2）花式索引—獲取數組中的特定元素
# 一維數組下使用
a = np.arange(0, 100, 9)
print(a) # [ 0 9 18 27 36 45 54 63 72 81 90 99]
indices = [1, 5, -2]
print(a[indices]) # [ 9 45 90]
# 對二維數組同樣適用；此時將嵌套的一維數組作為一個元素
a2 = a.reshape(3, 4)
print(a2)
# [[ 0 9 18 27]
# [36 45 54 63]
# [72 81 90 99]]
indices = [1, 2, -2]
print(a2[indices])
# [[36 45 54 63]
# [72 81 90 99]
# [36 45 54 63]]
indices = [1, -2]
print(a2[indices])
# [[36 45 54 63]
# [36 45 54 63]]
indices = [-1]
print(a2[indices])
# [[72 81 90 99]]
（3）布爾屏蔽—根據指定的條件獲取數組中的元素
a = np.arange(0, 10)
print(a) # [0 1 2 3 4 5 6 7 8 9]
mask = a > 6
print(a[mask]) # [7 8 9]
（4）where() 函數是另外一個根據條件返回數組中的值的有效方法
a = np.arange(0, 100, 10)
print(a) # [ 0 10 20 30 40 50 60 70 80 90]
# 注意，np.where返回的是滿足條件的元素下標
b = np.where(a < 50)
print(b) # (array([0, 1, 2, 3, 4], dtype=int64),)
# 可以通過數組的take方法獲取滿足條件的元素
print(a.take(b)) # [[ 0 10 20 30 40]]
# 獲取返回的元組中的下標數組
c = np.where(a >= 50)[0]
print(c) # [5 6 7 8 9]
# np.where還有x,y兩個參數
d = np.where(a >= 50, 'true', 'false')
print(d)
# ['false' 'false' 'false' 'false' 'false' 'true' 'true' 'true' 'true' 'true']
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
