2-1 Numpy-数组

（1） 数组的创建

 # !usr/bin/env python
 # Author:@vilicute
 import numpy as np
 # 1、用array创建数组并查看数组的属性
 arr1 = np.array([1, 2, 3, 4])  # 一维数组
 print("一维数组创建：arr1 = ", arr1)
 arr2 = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])  # 二维数组
 print("\n二维数组创建：arr2 = \n", arr2)
 # 数组属性
 print("数组维数：", arr2.ndim)
 print("数组维度：", arr2.shape)
 print("数组类型：", arr2.dtype)
 print("元素个数：", arr2.size)
 print("元素大小：", arr2.itemsize)
 arr2.shape = 4, 3  # 重新设置维度属性
 print("\n重置维度后的数组为：arr2_reshape = \n", arr2)
 '''
 一维数组创建：arr1 =  [1 2 3 4]
 二维数组创建：arr2 =
  [[ 1  2  3  4]
  [ 5  6  7  8]
  [ 9 10 11 12]]
 数组维数： 2
 数组维度： (3, 4)
 数组类型： int32
 元素个数： 12
 元素大小： 4
 重置维度后的数组为：arr2_reshape =
  [[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]
  [10 11 12]]
  '''

 # 2、用arange创建数组
 arr3 = np.arange(0, 1, 0.1)  # (初值，终值，间隔)  左闭右开
 print("\n等差数组：arr3 = ", arr3)
 '''
 等差数组：arr3 =  [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
 '''
 # 3、用linspace创建数组
 arr4 = np.linspace(0, 1, 4)  # (初值，终值，个数)  等差数列
 print("\n特殊等差数组：arr4 = ", arr4)
 '''
 特殊等差数组：arr4 =  [0.         0.33333333 0.66666667 1.        ]
 '''
 # 4、用logspace创建数组
 arr5 = np.logspace(0, 2, 4)  # (10^0，10^2，个数)  等比数列
 print("\n10^等比数组：arr5 = ", arr5)
 '''
 10^等比数组：arr5 =  [  1.           4.64158883  21.5443469  100.        ]
 '''
 # 5、用zeros创建数组
 arr6 = np.zeros((3, 3))  # (a,b) 维数
 print("\n全0数组：arr6 = \n", arr6)
 '''
 全0数组：arr6 =
  [[0. 0. 0.]
   [0. 0. 0.]
   [0. 0. 0.]]
 '''
 # 6、用eye创建数组
 arr7 = np.eye(3)  # 类似于单位矩阵
 print("\n单位对角数组：arr7 = \n", arr7)
 '''
 单位对角数组：arr7 =
  [[1. 0. 0.]
   [0. 1. 0.]
   [0. 0. 1.]]
 '''
 # 7、用diag创建数组
 arr8 = np.diag([1, 2, 3, 4])  # [a,b,c,d] 对角元素
 print("\n对角数组：arr8 = \n", arr8)
 '''
 对角数组：arr8 =
  [[1 0 0 0]
   [0 2 0 0]
   [0 0 3 0]
   [0 0 0 4]]
 '''
 # 8、用ones创建数组
 arr9 = np.ones((4, 3))  # (a,b) 维数
 print("\n单位数组：arr9 = \n", arr9)
 '''
 单位数组：arr9 =
  [[1. 1. 1.]
   [1. 1. 1.]
   [1. 1. 1.]
   [1. 1. 1.]]
 '''
 # 9、自定义数据数组创建
 arr10 = np.array([("vilicute", 52, 5.02), ("shame", 55, 55.02)])
 print("\n自定义数据类型数组：arr10 = \n", arr10)
 '''
 自定义数据类型数组：arr10 =
  [['vilicute' '52' '5.02']
   ['shame' '55' '55.02']]
 '''
 # 10、生成随机数组
 arr11 = np.random.random(10)  # 个数
 print("\n随机数组：arr11 = \n", arr11)
 '''
 随机数组：arr11 =
  [0.10325528 0.58512919 0.44988683 0.49719158 0.6361162  0.08344581 0.00998028 0.85750635 0.37264001 0.94651211]
 '''
 # 11、生成服从均匀分布随机数
 arr12 = np.random.rand(4, 3)
 print("\n服从均匀分布随机数组：arr12 = \n", arr12)
 '''
 服从均匀分布随机数组：arr12 =
  [[0.85982146 0.31343986 0.89078588]
   [0.15717079 0.04499381 0.32277901]
   [0.70737793 0.75456669 0.43207658]
   [0.73633332 0.05820537 0.73123502]]
 '''
 # 12、生成服从正态分布随机数
 arr13 = np.random.randn(4, 3)
 print("\n服从正态分布随机数组：arr13 = \n", arr13)
 '''
 服从正态分布随机数组：arr13 =
  [[ 0.36057176 -0.71389648 -0.26165942]
   [ 1.38415272  0.90255961 -1.42104002]
   [ 0.48616978  1.22208226  0.65215556]
   [ 0.2997037   1.31383623 -0.10306966]]
 '''
 # 13、生成给定上下限的随机数组
 arr14 = np.random.randint(2, 10, size=[2, 5])   # size 维数
 print("\n给定上下限的随机数组:arr14 = \n", arr14)
 '''
 给定上下限的随机数组:arr14 =
  [[2 8 4 4 7]
   [3 7 5 6 5]]
 '''

（2）数组的访问

 # !usr/bin/env python
 # Author:@vilicute
 import numpy as np
 ar = np.random.randint(0,10,size = [4,5])
 print(ar)
 print(ar[1,3])    # 第二行第四列
 print(ar[0,2:4])  # 0行的3，4列元素
 print(ar[1:,2:])  # 1行2列之后的元素
 print(ar[:,2])    # 第3列元素
 print(ar[2,:])    # 第3行元素
 '''
 [[6 0 3 8 9]
  [8 7 4 8 2]
  [0 0 1 7 2]
  [8 2 0 8 7]]

 8
 [3 8]
 [[4 8 2]
  [1 7 2]
  [0 8 7]]

 [3 4 1 0]
 [0 0 1 7 2]
 '''

（3）数组形态的变换

 # !usr/bin/env python
 # Author:@vilicute
 import numpy as np
 arr1 = np.arange(12)
 print(arr1)
 array1 = arr1.reshape(3, 4)
 print("\n新的数组形态为：\n", array1)
 ndim = arr1.reshape(3, 4).ndim
 print("\n数组维度：", ndim)
 '''
 [ 0  1  2  3  4  5  6  7  8  9 10 11]
 新的数组形态为：
  [[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]
 数组维度： 2
 '''
 arr2 = np.random.randint(5, 15, size=[4, 5])
 print(arr2)
 arr2_ravel = arr2.ravel()          #数组（横向）展平
 arr2_flatten = arr2.flatten()      #数组（横向）展平
 arr2_flatten_F = arr2.flatten('F') #数组（纵向）展平
 print("\n数组（横向）展平ravel(): ", arr2_ravel)
 print("\n数组（横向）展平flatten(): ", arr2_flatten)
 print("\n数组（纵向）展平flatten(): ", arr2_flatten_F)
 '''
 [[12  5  6  8 10]
  [11 11  8 11  7]
  [13  7  5  5 11]
  [ 8  6 11 13  6]]
 数组（横向）展平ravel(): [12  5  6  8 10 11 11  8 11  7 13  7  5  5 11  8  6 11 13  6]
 数组（横向）展平flatten(): [12  5  6  8 10 11 11  8 11  7 13  7  5  5 11  8  6 11 13  6]
 数组（纵向）展平flatten(): [12 11 13  8  5 11  7  6  6  8  5 11  8 11  5 13 10  7 11  6]
 '''
 arr3 = arr2*2
 print("\n乘法计算：\n", arr3)
 '''
 乘法计算：
  [[24 10 12 16 20]
   [22 22 16 22 14]
   [26 14 10 10 22]
   [16 12 22 26 12]]
 '''
 arr_hstack = np.hstack((arr2, arr3)) #横向组合
 arr_vstack = np.vstack((arr2, arr3)) #纵向组合
 print("\narr2与arr3横向组合：\n", arr_hstack)
 print("\narr2与arr3纵向组合：\n", arr_vstack)
 ''' 功能同上
 arr_hstack = np.concatenate((arr2, arr3), axis=1) #横向组合
 arr_vstack = np.concatenate((arr2, arr3), axis=0) #纵向组合
 print("\narr2与arr3横向组合：\n", arr_hstack)
 print("\narr2与arr3纵向组合：\n", arr_vstack)
 '''
 '''
 arr2与arr3横向组合：
  [[12  5  6  8 10 24 10 12 16 20]
   [11 11  8 11  7 22 22 16 22 14]
   [13  7  5  5 11 26 14 10 10 22]
   [ 8  6 11 13  6 16 12 22 26 12]]
 arr2与arr3纵向组合：
  [[12  5  6  8 10]
   [11 11  8 11  7]
   [13  7  5  5 11]
   [ 8  6 11 13  6]
   [24 10 12 16 20]
   [22 22 16 22 14]
   [26 14 10 10 22]
   [16 12 22 26 12]]
 '''
 arr4 = np.arange(16).reshape(4, 4)
 print("\narr4=\n", arr4)
 arr_hsplit = np.hsplit(arr4, 2) #横向分割, <=>np.split(arr4,2,axis = 1)
 arr_vsplit = np.vsplit(arr4, 2) #纵向分割, <=>np.split(arr4,2,axis = 0)
 print("\n横向分割：\n", arr_hsplit)
 print("\n纵向分割：\n", arr_vsplit)
 '''
 arr4=
  [[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]
  [12 13 14 15]]
 横向分割：
  [array([[ 0,  1],
          [ 4,  5],
          [ 8,  9],
          [12, 13]]),
   array([[ 2,  3],
          [ 6,  7],
          [10, 11],
          [14, 15]])]
 纵向分割：
  [array([[0, 1, 2, 3],
          [4, 5, 6, 7]]),
   array([[ 8,  9, 10, 11],
          [12, 13, 14, 15]])]
 '''

（4）数组排序

 # !usr/bin/env python
 # Author:@vilicute
 import numpy as np
 arr1 = np.random.randint(10, 100, size=[4, 5])
 arr2 = np.random.randint(10, 100, size=[4, 4])
 arr3 = np.random.randint(10, 100, size=[4, 3])
 arr4 = np.array(['小明', '小小', '小红', '小明', '小米', '小迭'])
 print("\narr1=\n", arr1, "\narr2=\n", arr2, "\narr3=\n", arr3)
 arr1.sort(axis=1)
 print("\n横向排序 arr1 =\n", arr1)
 print("\narr2=\n", arr2)
 arr2.sort(axis=0)
 print("\n纵向排序 arr2 =\n", arr2)
 print("\narr3=\n", arr3)
 print("\n排序下标(按行给出)：\n", arr3.argsort())
 print("\narr4=", arr4)
 print("\n去重：", np.unique(arr4))
 print("\n重复：", np.tile(arr4, 2))
 print("\n按行重复：\n", arr1.repeat(2, axis=1))
 print("\n按列重复：\n", arr1.repeat(2, axis=0))
 '''
 arr1=
  [[24 11 78 47 65]
  [81 54 56 90 45]
  [75 61 50 22 23]
  [77 64 63 84 69]]
 arr2=
  [[12 23 37 32]
  [41 20 58 77]
  [43 76 42 97]
  [77 53 28 90]]
 arr3=
  [[53 33 81]
  [77 22 63]
  [90 20 66]
  [28 61 38]]
 横向排序 arr1 =
  [[11 24 47 65 78]
  [45 54 56 81 90]
  [22 23 50 61 75]
  [63 64 69 77 84]]
 arr2=
  [[12 23 37 32]
  [41 20 58 77]
  [43 76 42 97]
  [77 53 28 90]]
 纵向排序 arr2 =
  [[12 20 28 32]
  [41 23 37 77]
  [43 53 42 90]
  [77 76 58 97]]
 arr3=
  [[53 33 81]
  [77 22 63]
  [90 20 66]
  [28 61 38]]
 排序下标(按行给出)：
  [[1 0 2]
  [1 2 0]
  [1 2 0]
  [0 2 1]]
 arr4= ['小明' '小小' '小红' '小明' '小米' '小迭']
 去重： ['小小' '小明' '小米' '小红' '小迭']
 重复： ['小明' '小小' '小红' '小明' '小米' '小迭' '小明' '小小' '小红' '小明' '小米' '小迭']
 按行重复：
  [[11 11 24 24 47 47 65 65 78 78]
  [45 45 54 54 56 56 81 81 90 90]
  [22 22 23 23 50 50 61 61 75 75]
  [63 63 64 64 69 69 77 77 84 84]]
 按列重复：
  [[11 24 47 65 78]
  [11 24 47 65 78]
  [45 54 56 81 90]
  [45 54 56 81 90]
  [22 23 50 61 75]
  [22 23 50 61 75]
  [63 64 69 77 84]
  [63 64 69 77 84]]
 '''

（5）数组统计

 # !usr/bin/env python
 # Author:@vilicute
 import numpy as np
 arr1 = np.random.randint(10, 100, size=[4, 5])
 print("\narr1=\n", arr1)
 arr_sum = np.sum(arr1) #求和
 arr_sum0 = arr1.sum(axis=0) #纵向求和
 arr_sum1 = arr1.sum(axis=1) #横向求和
 arr_mean = np.mean(arr1) #均值
 arr_mean0 = arr1.mean(axis=0) #纵向均值
 arr_mean1 = arr1.mean(axis=1) #横向均值
 arr_std = np.std(arr1) #标准差
 arr_var = np.var(arr1) #方差
 arr_min = np.min(arr1) #最小值
 arr_max = np.max(arr1) #最大值
 arr_argmin = np.argmin(arr1) #最小值索引
 arr_argmax = np.argmax(arr1) #最大值索引
 print("\n求和：", arr_sum)
 print("\n纵向求和：", arr_sum0)
 print("\n横向求和：", arr_sum1)
 print("\n均值：",arr_mean)
 print("\n纵向均值：", arr_mean0)
 print("\n横向均值：", arr_mean1)
 print("\n标准差：", arr_std)
 print("\n方差：", arr_var)
 print("\n最小值：", arr_min)
 print("\n最大值：", arr_max)
 print("\n最小值索引：", arr_argmin)
 print("\n最大值索引：", arr_argmax)
 '''
 arr1=
  [[28 54 50 40 75]
   [93 26 95 81 41]
   [12 43 73 49 82]
   [27 26 26 13 37]]
 求和： 971
 纵向求和： [160 149 244 183 235]
 横向求和： [247 336 259 129]
 均值： 48.55
 纵向均值： [40.00 37.25 61.00 45.75 58.75]
 横向均值： [49.4 67.2 51.8 25.8]
 标准差： 25.437128375663793
 方差： 647.0475000000001
 最小值： 12
 最大值： 95
 最小值索引： 10
 最大值索引： 7
 '''

（6）数组运算

 # !usr/bin/env python
 # Author:@vilicute

 # ufunc函数，针对数组所有元素进行操作，效率高

 import numpy as np

 arr1 = np.array([9,6,3])
 arr2 = np.array([2,5,6])
 arr3 = np.array([[1,1,1,],[2,2,2],[3,3,3],[4,4,4]])
 arr4 = np.array([[4],[5],[6],[7]])

 print("相加：",arr1+arr2)
 print("相减：",arr1-arr2)
 print("相乘：",arr1*arr2)
 print("相除：",arr1/arr2)
 print("幂运算：",arr1**arr2)

 print("比较运算：",arr1<arr2)   # >  <=  >=  ==  !=
 print("逻辑and 和 or：",np.all(arr1 == arr2),np.any(arr1 == arr2))
 print("\n一维广播机制相加：\n",arr1+arr3)
 print("\n二维广播机制相加：\n",arr4+arr3)

 '''
 相加： [11 11  9]
 相减： [ 7  1 -3]
 相乘： [18 30 18]
 相除： [4.5 1.2 0.5]
 幂运算： [  81 7776  729]
 比较运算： [False False  True]
 逻辑and 和 or： False False
 一维广播机制相加：
  [[10  7  4]
  [11  8  5]
  [12  9  6]
  [13 10  7]]
 二维广播机制相加：
  [[ 5  5  5]
  [ 7  7  7]
  [ 9  9  9]
  [11 11 11]]
 '''