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