numpy的操作

 import numpy as np

 ########################
 # 索引
 n1 = np.random.randint(0, 100, 10)
 # print(n1)
 '''
 [68 27 40 11 18  6 61 62 67 31]
 '''
 # print(n1[5])
 '''
 6
 '''
 n2 = np.random.randint(0, 100, (3, 4))  # 创建一个由0到100中随机产生的3行4列的随机数组
 # print(n2)
 '''
 [[46  5 20 78]
  [20  2 71 76]
  [27 71 19 39]]
 '''
 # print(n2[0, 1])  # 打印出来第0行的第2个元素
 '''
 5
 '''
 #############################
 # 切片操作
 n3 = np.random.randint(150, size=10)  # 创建一个由0到150的随机整数组成的元素个数为10的一维数组
 # print(n3)
 '''
 [ 41  72  15 121  55  76  65  10 101  77]
 '''
 # print(n3[1:3])  # 取出索引从1到2的值
 '''
 [72 15]
 '''
 n4 = np.random.randint(0, 100, (3, 4, 5))  # 创建一个3维数组
 # print(n4)
 '''
 [[[27 80 43 98 87]
   [96 99  2 41 86]
   [73 83 96 54 26]
   [10 76 87 53 47]]

  [[33 63 98 70 41]
   [82 29 80 92 72]
   [98 44 51 97 85]
   [23 33  2 10 49]]

  [[86 79 98 76 65]
   [42  4 29 38 90]
   [ 6 57 92 66 38]
   [36 58 25 43 53]]]
 '''
 # print(n4[1:3])
 '''
 [[[33 63 98 70 41]
   [82 29 80 92 72]
   [98 44 51 97 85]
   [23 33  2 10 49]]

  [[86 79 98 76 65]
   [42  4 29 38 90]
   [ 6 57 92 66 38]
   [36 58 25 43 53]]]
 '''
 # print(n4[1:3, 1:4])
 '''
 [[[82 29 80 92 72]
   [98 44 51 97 85]
   [23 33  2 10 49]]

  [[42  4 29 38 90]
   [ 6 57 92 66 38]
   [36 58 25 43 53]]]
 '''
 # print(n4[1:3, 1:4, 1:4])
 '''
 [[[29 80 92]
   [44 51 97]
   [33  2 10]]

  [[ 4 29 38]
   [57 92 66]
   [58 25 43]]]
 '''
 ###############################
 # 变形
 n5 = np.random.randint(0, 100, (3, 4))
 # print(n5)
 '''
 [[78 85 94 85]
  [16 67 88 71]
  [80 12 13 10]]
 '''
 n6 = n5.reshape(4, 3)
 # print(n6)
 '''
 [[78 85 94]
  [85 16 67]
  [88 71 80]
  [12 13 10]]
 '''
 ## reshape和resize的区别
 a = np.array([(1, 2, 3), (4, 5, 6)])
 b = a.reshape(3, 2)
 # print(b)
 '''
 [[1 2]
  [3 4]
  [5 6]]
  将a数组的数据由2行3列变成3行2列得到b数组，但是a数组没有发生改变
  '''
 a.resize(3, 2)
 # print(a)
 '''
 [[1 2]
  [3 4]
  [5 6]]
  a数组由2行3列变成3行2列，此时，a数组的形状发生了改变
  '''
 # 多维数组降成一维
 # print(n6.shape)
 '''
 (4, 3)
 '''
 n7 = n6.reshape(4 * 3)
 # print(n7)
 '''
 [23 65 78 78 85 11 44 69 85 10 11 43]
 '''
 n8 = n6.reshape(-1)
 # print(n8)
 '''
 [23 65 78 78 85 11 44 69 85 10 11 43]
 '''
 ###############################
 # 级联(将两个数组连在一起）
 '''
 注意：1、级联的参数必须是列表：一定要加中括号或小括号
       2、维度必须相同
       3、形状相符
       4、【重点】级联的方向默认是shape这个元组的第一个值所代表的维度方向
       5、可以通过axis参数改变级联的方向
 '''
 n9 = np.random.randint(0, 10, size=(5, 5))  # 创建一个由0到10的正整数的随机数生成的5行5列的随机数组
 # print(n9)
 '''
 [[7 1 9 3 0]
  [7 0 9 3 0]
  [2 1 4 0 6]
  [0 8 2 8 3]
  [6 8 8 4 4]]
 '''
 n10 = np.concatenate((n9, n9))  # 横着级联
 # print(n10)
 '''
 [[7 1 9 3 0]
  [7 0 9 3 0]
  [2 1 4 0 6]
  [0 8 2 8 3]
  [6 8 8 4 4]
  [7 1 9 3 0]
  [7 0 9 3 0]
  [2 1 4 0 6]
  [0 8 2 8 3]
  [6 8 8 4 4]]
 '''
 n11 = np.concatenate((n9, n9), axis=0)  # 竖着级联
 # print(n11)
 '''
 [[7 1 9 3 0]
  [7 0 9 3 0]
  [2 1 4 0 6]
  [0 8 2 8 3]
  [6 8 8 4 4]
  [7 1 9 3 0]
  [7 0 9 3 0]
  [2 1 4 0 6]
  [0 8 2 8 3]
  [6 8 8 4 4]]
 '''
 n12 = np.concatenate((n9, n9), axis=1)  # 横着级联
 # print(n12)
 '''
 [[7 1 9 3 0 7 1 9 3 0]
  [7 0 9 3 0 7 0 9 3 0]
  [2 1 4 0 6 2 1 4 0 6]
  [0 8 2 8 3 0 8 2 8 3]
  [6 8 8 4 4 6 8 8 4 4]]
 '''
 n13 = np.array([
     (1, 2, 3),
     (7, 8, 9)
 ], dtype=int)
 # print(n13)
 '''
 [[1 2 3]
  [7 8 9]]
 '''
 n14 = np.hstack(n13)  # 将多维数组进行水平级联，处理自己进行维度变更
 # print(n14)
 '''
 [1 2 3 7 8 9]
 '''
 n15 = np.vstack(n14)  # 将一维数组进行垂直级联，处理自己进行维度变更
 # print(n15)
 '''
 [[1]
  [2]
  [3]
  [7]
  [8]
  [9]]
 '''
 n16 = np.array([[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]])
 # print(n16)
 #################################
 # 切分
 '''
 与级联类似，三个函数完成切分工作：
 1、np.split
 2、np.vsplit
 3、np.hsplit
 '''
 n17 = np.random.randint(0, 150, size=(5, 7))
 # print(n17)
 n18 = np.split(n17, (1, 3))  # 按行切割数组，此处是分别在行号为1和3前切割
 n19 = np.split(n17, (1, 3), axis=0)  # 和n18的操作一样
 # print(n18)
 #####################################
 # 副本
 '''
 所有赋值运算不会为ndarray的任何元素创建副本。赋值后的对象的操作也对原来的对象生效。
 '''
 n20 = np.random.randint(0, 100, (3, 4))
 # print(n20)
 '''
 [[ 8 83 57 15]
  [81 61  0  0]
  [56 88 73 91]]
 '''
 n21 = n20  # 此时，n21和n20是完全相同，并且两者是有联系的。对n21操作的同时也对n22操作了。实际上是两者的指针指向了同一块内存地址
 n21[2, 3] = 500
 # print(n21)
 '''
 [[  8  83  57  15]
  [ 81  61   0   0]
  [ 56  88  73 500]]
 '''
 # print(n20)
 '''
 [[  8  83  57  15]
  [ 81  61   0   0]
  [ 56  88  73 500]]
 '''
 n22 = np.array([[8, 83, 57, 15],
                 [81, 61, 0, 0],
                 [56, 88, 73, 91]])
 n23 = n22.copy()  # 此时n23为n22的副本，与n22完全分隔开了，对n23操作不会影响到n22。实际上是，在内存中新建了一个地方，把n22的值存放在里面，同时n23的指针也指向了新的地址，而n22任然指向原先的。
 n23[1, 2] = 500
 # print(n23)
 '''
 [[  8  83  57  15]
  [ 81  61 500   0]
  [ 56  88  73  91]]
 '''
 # print(n22)
 '''
 [[ 8 83 57 15]
  [81 61  0  0]
  [56 88 73 91]]
 '''
 ##数组的计算
 a = np.array([1, 2, 3])
 b = np.array([4, 5, 6])
 # 加法
 c = a + b
 print(c)
 '''
 [5 7 9]
 '''
 # 减法
 d = a - b
 print(d)
 '''
 [-3 -3 -3]
 '''
 # 乘法
 e = a * b
 print(e)
 '''
 [ 4 10 18]
 '''
 # 求和
 f = np.array([(1, 2, 3), (4, 5, 6)])
 print(f.sum())
 '''
 21
 '''
 # 按列求和
 print(f.sum(axis=0))
 '''
 [5 7 9]
 '''
 # 按行求和
 print(f.sum(axis=1))
 '''
 [ 6 15]
 '''
 # 最小值的值
 print(f.min())
 '''
 1
 '''
 # 最小值的索引
 print(f.argmin())
 '''
 0
 '''
 # 最大值的值
 print(f.max())
 '''
 6
 '''
 print(f.argmax())
 '''
 5
 '''
 # 平均值
 print(f.mean())
 '''
 3.5
 '''
 # 方差
 print(f.var())
 '''
 2.9166666666666665
 '''
 # 标准差
 print(f.std())
 '''
 1.707825127659933
 '''
 #############
 # 线性代数的运算
 # 矩阵内积
 np.dot()
 # 行列式
 np.linalg.det()
 # 逆矩阵
 np.linalg.inv()
 # 多元一次方程组求根
 np.linalg.solve()
 # 求特征值和特征向量
 np.linalg.eig()