numpy安装
pycharm中生成的项目文件包含numpy不需要安装，直接导入即可
import numpy as np
numpy的基本使用
array =np.array([[1,2,3],[2,3,4]]) #创建numpy数组
print(array)
print('number of dim:',array.ndim) #输出数组的纬度
print('shape:',array.shape)#输出数组的形状
print('size',array.size)#输出数组的元素个数
输出结果
[[1 2 3]
[2 3 4]]
number of dim: 2
shape: (2, 3)
size 6
numpy创建array
a = np.array([2,3,4],dtype=np.int32) #新建numpy数组，dtype是设置数组元素的属性
print(a.dtype)
b = np.array([[2,3,4],[5,6,7]]) #定义二位的numpy数组，也就是矩阵，和列表的定义方法类似
print(b)
c = np.zeros( (3,4) ) #定义一个三行四列的零矩阵
print(c)
d = np.ones((3,4),dtype=np.int32) #定义一个三行四列元素全部为1的矩阵
print(d)
e = np.arange(10,20,2) #定义一个数列，和range()函数类似，左闭右开，2是步长，默认为1
print(e)
f = np.arange(12).reshape((3,4))#定义一个从0到11形状为三行四列的数组
print(f)
g = np.linspace(1,10,5) #生成1到10的线段，第三个参数的意思是取线段的五个点使其四等分，当然起点是1，终点是10
print(g)
#同样也可以用reshape()去修改g的形状
#g = np.linspace(1,10,5).reshape(2,3)
#print(g)
输出结果
a: int32
b: [[2 3 4]
[5 6 7]]
c: [[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
d: [[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
e: [10 12 14 16 18]
f: [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
g: [ 1. 3.25 5.5 7.75 10. ]
numpy的基础运算
a = np.array([10,20,30,40])
b = np.arange(4) #生成0到3的一维数组，也可以说是一行四列的矩阵
#加减法就是元素逐个相加或者相减
print('加减法就是元素逐个相加或者相减')
c = a+b
d = a-b
print(a,b)
print(c)
print(d)
#各个元素的平方
print('各个元素的平方')
e = b**2
print(c)
#三角函数
print('三角函数')
f = np.sin(3.14)
g = np.cos(0)
print(f,g)
#大于小于等的比较
print('大于小于等的比较')
print(b)
print(b<3)
print(b==3)
#两种乘法
print('两种乘法')
m = np.array([[1,1],[0,1]])
n = np.arange(4).reshape((2,2))
result = m*n #各个元素相乘
result_dot = np.dot(m,n) #矩阵乘法
result_dot_2 = m.dot(n) #矩阵乘法的第二种表达形式，也是m右乘n
print(result)
print(result_dot)
print(result_dot_2)
#求和最大值最小值
print('求和最大值最小值')
k = np.random.random((2,3))
print(k)
print(np.sum(k)) #求和
print(np.min(k)) #最小值
print(np.max(k)) #最大值
#sum()函数可以设置axis参数，当axis=1的时候在横向进行运算，当axis=0的时候在纵向进行运算
print(np.sum(k,axis=1)) #横向的元素求和
print(np.min(k,axis=0)) #依次比较纵向元素，返回最小值
print(np.max(k,axis=1)) #依次比较横向元素，返回最大值
输出结果
加减法就是元素逐个相加或者相减
[10 20 30 40] [0 1 2 3]
[10 21 32 43]
[10 19 28 37]
各个元素的平方
[10 21 32 43]
三角函数
0.0015926529164868282 1.0
大于小于等的比较
[0 1 2 3]
[ True True True False]
[False False False True]
两种乘法
[[0 1]
[0 3]]
[[2 4]
[2 3]]
[[2 4]
[2 3]]
求和最大值最小值
[[0.60469268 0.60164501 0.40323566]
[0.01248801 0.72253772 0.30805768]]
2.6526567555759173
0.012488011443382963
0.7225377172452148
[1.60957335 1.04308341]
[0.01248801 0.60164501 0.30805768]
[0.60469268 0.72253772]
numpy基础运算拓展
a = np.arange(2,14).reshape((3,4))
print('a：',a)
print('数组中最大元素与最小元素的索引')
print(np.argmin(a)) #a数组中最小元素的索引
print(np.argmax(a)) #a数组中最大元素的索引
print('数组的平均值、中位数')
print(a.mean()) #a数组所有元素的平均值
print(np.median(a)) #a数组的中位数
print('数组元素的累加与差')
print(np.cumsum(a)) #这个函数的输出结果a数组元素从头到第n个位置的元素的累加，也就是此函数的第二个输出结果就是a数组中第一个元素加上第二个元素
print(np.diff(a)) #a数组左右两个元素的差
print('找出数组中非0的数')
print(np.nonzero(a)) #这个函数的输出结果是两个数组，第一个数组表示非零元素的行位置，第二数组表示非零元素的列位置
print('对数组进行排序')
b = np.arange(14,2,-1).reshape((3,4))
print(b)
print(np.sort(b)) #排序的规则是逐行排序，从小到大
print('矩阵的转置')
print(np.transpose(a))
print(a.T) #转置
print('让数组中大于最大值的数等于最大值，小于最小值的数等于最小值')
print(a)
print(np.clip(a,5,9)) #让a数组中大于9的数全部变成9，小于5的数全部变成5
输出结果
a： [[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
数组中最大元素与最小元素的索引
0
11
数组的平均值、中位数
7.5
7.5
数组元素的累加与差
[ 2 5 9 14 20 27 35 44 54 65 77 90]
[[1 1 1]
[1 1 1]
[1 1 1]]
找出数组中非0的数
(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
对数组进行排序
[[14 13 12 11]
[10 9 8 7]
[ 6 5 4 3]]
[[11 12 13 14]
[ 7 8 9 10]
[ 3 4 5 6]]
矩阵的转置
[[ 2 6 10]
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]]
[[ 2 6 10]
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]]
让数组中大于最大值的数等于最大值，小于最小值的数等于最小值
[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
[[5 5 5 5]
[6 7 8 9]
[9 9 9 9]]
numpy的索引
a = np.arange(3,15)
print(a)
print(a[3]) #输出第四个元素
b = np.arange(3,15).reshape(3,4)
print(b)
print(b[2][1]) #和下面的都是输出第三行第二列的元素
print(b[2,1])
print(b[2,:]) #和列表相同，可以用冒号代替这一行所有的元素
#输出矩阵b的每一行
for row in b:
print(row)
#输出矩阵b的每一列，实际上不存在这种功能，但可以通过转置来实现
print(b)
for col in b.T:
print(col)
#输出矩阵b的每一个元素，不可以直接循环遍历b，这样输出的是每一行，要先把矩阵平整化，让它变成一个一维数组
for item in b.flat:
print(item)
numpy的array合并
a = np.array([1,1,1])
b = np.array([2,2,2])
print(np.vstack((a,b))) #vertical stack 垂直地上下合并
print(np.hstack((a,b))) #horizontal stack 水平地左右合并
#本来a是一个数组，我们没有办法使其转置
print(a.T)
#但是我们只需要给其增加一个纬度，就能让其变成一行三列的矩阵
print(a[np.newaxis,:].T) #在左边加是让其在横向有维度
print(a[:,np.newaxis]) #在右边加就是让其在纵向有纬度，直接变成一行三列了
#多个array进行合并
a=a[np.newaxis,:]
b=b[np.newaxis,:]
c = np.concatenate((a,b),axis=0) #axis=0的时候就是水平方向地上下合并
print(c)
c = np.concatenate((a,b),axis=1) #axis=1的时候就是垂直方向地左右合并
print(c)
numpy的array分割
a = np.arange(12).reshape((3,4))
print(a)
print(np.split(a,2,axis=1)) #对array纵向分割，分成两块
print(np.split(a,3,axis=0)) #对array横向分割，分成三块
#split()只可以对array进行等分，有三行的话，横向只能分三块，有四列，纵向不能分成三块
#实现不等地分割
print(np.array_split(a,3,axis=1))
'''
最后的分割结果如下
[array([[0, 1],
[4, 5],
[8, 9]]),
array([[ 2],
[ 6],
[10]]),
array([[ 3],
[ 7],
[11]])]
'''
#更加简单的分割函数
print(np.vsplit(a,3)) #沿着array的纵方向水平切割
print(np.hsplit(a,2)) #沿着array的水平方向垂直切割
#这两个函数真的反人类，vertical明明是垂直，horizontal是水平，记忆地时候就记他们的作用和函数名是相反地
#然后axis取值速记，axis=1s的时候，可以把1看成垂直的，所以axis=1代表着纵向，反之axis=0代表水平方向
numpy的copy和deep copy
copy实质上只做了一件事情，就是单纯地把指针指了过去
而deep copy所做的事情：1.在内存中开辟新的地址；2.复制原来的值；3.指针指向新的地址
a = np.arange(4)
#传递性质
b = a
c = a
d = b
print(a)
a[0] = 2
print(a)
print(b)
print(d)
print(b is a)
print(d is a)
#所以说，如果当我修改d里面元素值的时候，a的元素值也会跟着发生变化
d[1:3] = [22,33]
print(d)
print(a)
print(b)
print(b is a)
print(d is a)
#本质上他们之间传递的是内存上的地址，如果我们不想在复制array的时候让其关联起来
b = a.copy() #deep copy 这就单纯的把值给他,而地址没有传递
a[2] = 100
print(a)
print(b)
print(a is b)
|