Numpy常用用法总结
文章目录
- 1、array基本信息以及生成各种常见array基本操作，生成array，得到对应的基本信息
- 1.1 查看
- 1.2 dtype
- 1.3 常见array格式生成
- 2、计算
- 2.1 加减乘除
- 2.2 平方，三角函数，比较元素大小,矩阵
- 3、随机数和max,min,sum
- 4、矩阵转置和排序，以及元素比较大小重置元素方法
- 5、平均值 中值 diff cumsum
- 6、索引
- 6.1 最大最小、非零索引
- 6.2 取行、取列、取值
- 6.3 迭代元素和降维
- 7、合并分割
1、array基本信息以及生成各种常见array基本操作，生成array，得到对应的基本信息
1.1 查看
import numpy as np
array = np.array([[1,2,3],[2,3,4]])
print(array)
#查看每个元素的类型
print(array.dtype)
#查看array的维度
print(array.ndim)
#查看形状
print(array.shape)
#所有元素的个数
print(array.size)
Out:
[[1 2 3]
[2 3 4]]
int32
2
(2, 3)
6
array的生成就是np.array(list)，本质上是把定义的list转换成array，因为array可以更加方便地计算和操作，比如矩阵的转置和相乘。
1.2 dtype
不设置type，则默认为int64,如果设置为int类型而没有设置字节大小则还是默认为int64,如果元素本身为小数，则默认为float64。
所以如果用int64，则如果元素都为整数则不需要设置默认即可，设置其他类型需要设置，float类似。
a = np.array([2, 23, 4], dtype=np.float32)
print(a)
[ 2. 23. 4.]
1.3 常见array格式生成
#生成shape为（2,3）全为0的array
b= np.zeros((2, 3), dtype=np.int)
print(b)
##生成shape为（2,3）全为1的array
c = np.ones((2,3),dtype=np.str)
print(c)
# 生成shape=(3, 4)的全为接近空的array
d = np.empty((3, 4))
print(d)
# 生成array 10到21 每隔3的一增加，for循环中主要使用
e = np.arange(10,21,3)
print(e)
# reshape能够重新定义矩阵的形状
f = np.arange(12).reshape((3,4))
print(f)
#等间隔产生6个数
g = np.linspace(1.0, 10.0, 6).reshape((3, 2))
Out
[[0 0 0]
[0 0 0]]
[['1' '1' '1']
['1' '1' '1']]
[[1.26043630e-311 1.26043661e-311 7.54894003e+252 2.95479883e+137]
[1.42800637e+248 2.64686750e+180 1.09936856e+248 6.99481925e+228]
[7.54894003e+252 7.67109635e+170 2.64686750e+180 5.63234836e-322]]
[10 13 16 19]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 1. 2.8]
[ 4.6 6.4]
[ 8.2 10. ]]
2、计算
2.1 加减乘除
import numpy as np
a = np.array([10, 20, 30, 40])
b = np.arange(4)
c = a + b
print(c)
d = np.array([[1, 2],[3, 4]])
e = np.arange(1, 8, 2).reshape((2, 2))
print(d*e)
print(d/e)
#维度不同下的计算
a = np.array([[1,2,3,4],[6,7,8,9]])
b = np.arange(1,5)
print(a+b)
print(a*b)
print(a/b)
Out:
[10 21 32 43]
[[ 1 6]
[15 28]]
[[1. 0.66666667]
[0.6 0.57142857]]
[[ 2 4 6 8]
[ 7 9 11 13]]
[[ 1 4 9 16]
[ 6 14 24 36]]
[[1. 1. 1. 1. ]
[6. 3.5 2.66666667 2.25 ]]
2.2 平方，三角函数，比较元素大小,矩阵
import numpy as np
a = np.array([10, 20, 30, 40])
b = np.arange(4)
#平方
print(a**2)
#三角函数
print(np.sin(a))
#元素比较
print(b<3)
print(b == 3)
#矩阵计算
d = np.array([[1, 2],[3, 4]])
e = np.arange(1, 8, 2).reshape((2, 2))
print(d.dot(e))
print(np.dot(d,e))
np.dot(d, e) 与d.dot(e)一样，都为d和e进行矩阵相乘
Out
[ 100 400 900 1600]
[-0.54402111 0.91294525 -0.98803162 0.74511316]
[ True True True False]
[False False False True]
[[11 17]
[23 37]]
[[11 17]
[23 37]]
3、随机数和max,min,sum
# 随机产生shape为（２，４）的一个array，每个元素都为0-1之间随机生成
f = np.random.random((2, 4))
print(f)
[[0.2651074 0.06022938 0.03103761 0.29572785]
[0.73063531 0.45682806 0.30643989 0.61639371]]
sum为总，min为最小，max为最大，如果不设置axis维度参数的话，则都为整个array的元素来说，但一般我们运用都只是算某个维度的sum,max,min，在二维数据中，axis=0代表行，第一个维度，axis=1，代表列为第二个维度，其实这么记并不是很好很有可能记错，我一般都是这么记得：axis=0为行，那意思就是每一行都要算呗？算完那不就是一列的每一行算个数被，axis=1类推，多维数据类推即可
4、矩阵转置和排序，以及元素比较大小重置元素方法
每一行进行重新大小排序当然也有axis参数配置，根据axis参数说明来操作
numpy.clip(a, a_min, a_max, out=None)
a : 输入的数组
a_min: 限定的最小值 也可以是数组,如果为数组时 shape必须和a一样
a_max:限定的最大值 也可以是数组,shape和a一样
out：剪裁后的数组存入的数组
import numpy as np
# 随机产生shape为（２，４）的一个array，每个元素都为0-1之间随机生成
c = np.arange(14, 2, -1).reshape((3, 4))
print(c)
[[14 13 12 11]
[10 9 8 7]
[ 6 5 4 3]]
#排序
print(np.sort(c))
"""
[[11 12 13 14]
[ 7 8 9 10]
[ 3 4 5 6]]
"""
#转置
print(np.transpose(c))
print(c.T)
"""
[[14 10 6]
[13 9 5]
[12 8 4]
[11 7 3]]
"""
#c矩阵中的元素小于５的等于５，大于９的等于９
print(np.clip(c, 5, 9))
"""
[[9 9 9 9]
[9 9 8 7]
[6 5 5 5]]
"""
5、平均值 中值 diff cumsum
cumsum：每个元素变成当前元素＋前面所有元素的和
c = np.arange(14, 2, -1).reshape((3, 4))
print(np.cumsum(c))
[ 14 27 39 50 60 69 77 84 90 95 99 102]
np.diff(a) #当前元素减去前面元素的差
[[-1 -1 -1]
[-1 -1 -1]
[-1 -1 -1]]
6、索引
6.1 最大最小、非零索引
a = np.array([[2, 6, 0, 4],[4, 8, 9, 1],[10, 2, 3, 11]])
print(np.argmax(a))
print(np.argmax(a,axis=1))
print(np.argmax(a,axis=0))
11#值
[1 2 3] #索引
[2 1 1 2]
6.2 取行、取列、取值
a[:, 1:2]：:代表行所有也就是一列要的话，这一列的每一行都要，1:2对应的从索引为１的列来算移植相当于取到索引为（2-1）的列，2为取的最高索引大一个。所以总体来讲就是首先取每一行，之后在行里取索引１->１的列元素，所以为最终的结果列向量。
a[:, 1:3]：按照上面的分析则每一行都要，列要索引为1和(3-1)的元素，那就是索引为1和2的所有元素，也就是第二列和第三列的元素。
a[1, 1:3]：为a[:, 1:3]的索引为１的所有元素。
这里需要注意的是
a[:, 1] #索引为１的列,生成为行向量，
a[:, 1:2] #索引为１的列，生成为列向量
因为两种取值的思想不一样，最终造成的结果也不一样，一个是直接取，所以维度减少了一个，另一个是在原本维度上截取，最终还是原来的维度。
import numpy as np
a = np.arange(3, 15).reshape((3, 4))
print(a)
print(a[1]) #索引为1的行，同下
print(a[:][1])
#取值 第三行第二列，如下两种表示
print(a[2,1])
print(a[2][1])
print(a[:, 1]) #索引为１的列,生成为行向量
print(a[:, 1:2]) #索引为１的列,生成为列向量
print(a[:, 1:3])
Out:
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
[ 7 8 9 10]
[ 7 8 9 10]
12
12
[ 4 8 12]
[[ 4]
[ 8]
[12]]
[[ 4 5]
[ 8 9]
[12 13]]
6.3 迭代元素和降维
降维：
a.flatten() # 所有元素变成一维
import numpy as np
a = np.arange(3, 15).reshape((3, 4))# 数据都是下取上差一个取到
#迭代取所有行
for row in a:
print(row)
for column in a.T:
print(column)
print(a.flatten()) # 所有元素变成一维
print()
b = np.array([[1, 2, 3]])
#每个元素打印
for item in a.flat:
print(item)
7、合并分割
np.vstack:按垂直方向（行顺序）堆叠数组构成一个新的数组
np.hstack:按水平方向（列顺序）堆叠数组构成一个新的数组
stack()函数
函数原型为：stack(arrays, axis=0)，arrays可以传数组和列表。
import numpy as np
a = np.array([1, 1, 2])
b = np.array([2, 3, 4])
c = np.vstack((a, b))
print(c)
print(np.hstack((a,b)))
a = np.array([[1],[2],[3]])
b = np.array([[4],[5],[6]])
print(np.hstack((a,b)))
a=[[1,2,3],
[4,5,6]]
print("列表a如下：")
print(a)
print("增加一维，新维度的下标为0")
c=np.stack(a,axis=0)
print(c)
print("增加一维，新维度的下标为1")
c=np.stack(a,axis=1)
print(c)
Out:
[[1 1 2]
[2 3 4]]
[1 1 2 2 3 4]
[[1 4]
[2 5]
[3 6]]
列表a如下：
[[1, 2, 3], [4, 5, 6]]
增加一维，新维度的下标为0
[[1 2 3]
[4 5 6]]
增加一维，新维度的下标为1
[[1 4]
[2 5]
[3 6]]