【NumPy】

NumPy是一个功能强大的Python库，主要用于对多维数组执行计算。NumPy这个词来源于两个单词-- Numerical和Python。NumPy提供了大量的库函数和操作，可以帮助程序员轻松地进行数值计算。

NumPy提供的最重要的数据结构是一个称为NumPy数组的强大对象。NumPy数组是通常的Python数组的扩展。NumPy数组配备了大量的函数和运算符，可以帮助我们快速编写各种类型计算的高性能代码。首先是让我们看看如何快速定义一维NumPy数组：

import numpy as np#导入numpy包
my_array = np.array([1, 2, 3, 4, 5]) 
print(my_array)

对于创建和访问数组，我们可以：

• 通过numpy array函数，从python list中创建数组
  通过numpy zeros函数，创建全0数组
  通过numpy eye函数，创建单位数组
  通过numpy arange函数，创建等间隔的数字数组
  通过numpy random函数，创建随机数组

#python list
list_array={1,2,3,4}
print([np.array(list_array)])
#numpy zeros 全0数组
print([np.zeros(shape=(3,4))])
#numpy eye单位矩阵
print([np.eye(3)])
#numpy arange 创建等间隔的数字数组
print([np.arange(1,10)])
#numpy random 随机数组
#np.random.rand(10)  返回10个0-1之间的数据（0,1）
#np.random.randn(10) 返回10个服从标准正态分布的数据
#np.random.randint(10) 返回0-9之间任意整数
print([np.random.rand(10)])

[array({1, 2, 3, 4}, dtype=object)]
[array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])]
[array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])]
[array([1, 2, 3, 4, 5, 6, 7, 8, 9])]
[array([0.67683333, 0.30753763, 0.14685895, 0.95830765, 0.02249831,
0.94844599, 0.85210617, 0.53572195, 0.89290498, 0.16993403])]

• 通过 ndim,查看数组维度（一维、二维···）
  通过shape, 查看数组大小
  通过size,查看数组元素的总数
  通过dtype,查看数据类型

import numpy as np
#ndim,查看数组维度（一维、二维···）
#shape, 查看数组大小
#size,查看数组元素的总数
#dtype,查看数据类型
list_array=[1,2,3,4]
array_test=np.array([list_array,list_array])
print(array_test)
print(array_test.ndim)
print(array_test.shape)
print(array_test.size)
print(array_test.dtype)

[[1 2 3 4]
[1 2 3 4]]
2
(2, 4)
8
int32

访问数组

b=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(b)
print(b[0,0])#b[0][0]相当于b[0,0]
print(b[1:,1:])
print(b[:2,:2])

[[1 2 3]
[4 5 6]
[7 8 9]]
1
[[5 6]
[8 9]]
[[1 2]
[4 5]]

reshape

#reshape
a=np.arange(1,10)
print(a.reshape(3,3))

[[1 2 3]
[4 5 6]
[7 8 9]]

1.数组之间相加减（对应位相加相减）同型

import numpy as np
a=np.arange(1,10).reshape(3,3)
b=np.arange(1,10).reshape(3,3)
print(a)
print(b)
print(a+b)
print(a-b)

[[1 2 3]
[4 5 6]
[7 8 9]]
[[1 2 3]
[4 5 6]
[7 8 9]]
[[ 2 4 6]
[ 8 10 12]
[14 16 18]]
[[0 0 0]
[0 0 0]
[0 0 0]]

2.数组相乘除（对应位相乘相除）

print(a*b)
print(a/b)

一般为相加减以及相乘操作，一般不会相除，因为分母可能为0

矩阵 只能是二维
数组 可以是多个维度
矩阵是数组的子集

matrix可以直接将数组传入变为矩阵
1.矩阵相加减

import numpy as np
a=np.arange(1,10).reshape(3,3)
b=np.arange(1,10).reshape(3,3)
matrix_a=np.matrix(a)
matrix_b=np.matrix(b)
print(matrix_a+matrix_b)
print(matrix_a-matrix_b)

[[ 2 4 6]
[ 8 10 12]
[14 16 18]]
[[0 0 0]
[0 0 0]
[0 0 0]]

2.矩阵的乘法 d.dot(e)
其中d的列数，必须与e的行数一致

import numpy as np
d=np.matrix(np.arange(12).reshape(3,4))
e=np.matrix(np.arange(12).reshape(4,3))
print(d.dot(e))

[[ 42 48 54]
[114 136 158]
[186 224 262]]

• np.concatenate 连接数组
  axis=0 垂直方向堆叠数组,要有相同的列数
  axis=1 水平方向堆叠数组,要有相同的行数

import numpy as np
a=np.arange(6).reshape(2,3)
b=np.arange(3).reshape(1,3)
c=np.arange(10).reshape(2,5)
x=np.concatenate([a,b],axis=0)#垂直方向堆叠数组
print(x)

[[0 1 2]
[3 4 5]
[0 1 2]]

• np.vstack()
  vertical 垂直方向堆叠数组
  注意：两个数组，需要有相同的列数
  np.vstack([a,b])
• np.hstack()
  Horizontal
  水平方向堆叠数组
  注意：两个数组，需要有相同的行数
  np.hstack([a,c])

• np.split()
  indices_or_section
  1.如果“索引或区段”是整数N，则数组将沿着“轴”被分成N个相等的数组，如果N无法整除，则会引发一个错误
  2.[2,5] ary[:2] ary[2:5] ary[5:]
  axis 分割的轴，axis默认为0

import numpy as np
ary=np.arange(9)
x=np.split(ary,3)
y=np.split(ary,[2,5])
print(x)
print(y)

[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
[array([0, 1]), array([2, 3, 4]), array([5, 6, 7, 8])]

import numpy as np
x=np.arange(16).reshape(4,4)
print(x)
y=np.split(x,2,axis=0) #axis=0水平分割； axis=1垂直分割
print(y)
z=np.split(x,2,axis=1)
print(z)

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]),
array([[ 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]])]

np.sum(a) 或a.sum()
np.min(a)或 a.min()
np.max(a)或 a.max()

axis=0 沿着横轴方向压缩，—>看纵轴
axis=1 沿着纵轴方向压缩，—>看横轴

import numpy as np
x=np.arange(16).reshape(4,4)
print(x)
a=np.sum(x,axis=1)
b=np.sum(x,axis=0)
c=np.min(x,axis=0)
d=np.min(x,axis=1)
print(a)
print(b)
print(c)
print(d)

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[ 6 22 38 54]
[24 28 32 36]
[0 1 2 3]
[ 0 4 8 12]

• mean 均值
  axis=0 沿着横轴方向压缩，—>看纵轴
  axis=1 沿着纵轴方向压缩，—>看横轴

import numpy as np
x=np.arange(16).reshape(4,4)
print(x)
a=np.mean(x,axis=0)
b=np.mean(x,axis=1)
print(a)
print(b)

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[6. 7. 8. 9.]
[ 1.5 5.5 9.5 13.5]

• percentile 分位数

按住shift+tab 查看函数参数

import numpy as np
a=np.random.rand(10000) #返回10000个0-1之间的数据（0,1）
print(a)
print(np.percentile(a,q=25))#25%的数小于打印出来的数值
print(np.percentile(a,q=100))
q_list=[0,25,50,75,100]
for q in q_list:
    print(q,'的分位数为：',np.percentile(a,q=q))

[0.54896705 0.9165718 0.5329977 … 0.48900617 0.71593818 0.23784945]
0.24597003810093268
0.9997373198066611
0 的分位数为： 0.00018737445289696009
25 的分位数为： 0.24597003810093268
50 的分位数为： 0.5066633495212403
75 的分位数为： 0.7510081561220974
100 的分位数为： 0.9997373198066611

• argmin 返回数值中，最小值对应的index(索引)
• argmax 返回数值中，最大值对应的index(索引)

import numpy as np
a=np.random.random(16)
print(a)
#argmin 返回数值中，最小值对应的index(索引)
print(np.argmin(a))
#argmax 返回数值中，最大值对应的index(索引)
print(np.argmax(a))

[0.21514063 0.40441362 0.52441668 0.94327202 0.32505289 0.60981457
0.58001178 0.25916644 0.8219534 0.31389722 0.40016282 0.01845851
0.04136518 0.01556752 0.7254186 0.40169261]
13
3

• shuffle 打乱数组排序
• sort

import numpy as np
x=np.arange(16).reshape(4,4)
print(x)
np.random.shuffle(x)
print(x)
a=np.sort(x,axis=0)
b=np.sort(x,axis=1)
print(a)
print(b)

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[[ 4 5 6 7]
[12 13 14 15]
[ 0 1 2 3]
[ 8 9 10 11]]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[[ 4 5 6 7]
[12 13 14 15]
[ 0 1 2 3]
[ 8 9 10 11]]

• index
  x[0,[True,False,False,True]]可以通过布尔来索引两个间隔的值

import numpy as np
x=np.arange(16).reshape(4,4)
print(x)
ind=[True,False,False,True]
y=x[0,ind]
print(y)

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[0 3]

• 筛选 数组中[3,10)的数值
• 筛选数组中可以整除2的数

import numpy as np
x=np.arange(16).reshape(4,4)
print(x)
print(x[(x>=3)&(x<10)])
print(x[x%2==0])

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[3 4 5 6 7 8 9]
[ 0 2 4 6 8 10 12 14]