numpy基础知识学习笔记

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)