Numpy常用用法总结

最新推荐文章于 2024-07-24 23:27:06 发布

凯旋的皇阿玛

最新推荐文章于 2024-07-24 23:27:06 发布

阅读量983

点赞数 1

分类专栏： Numpy

Numpy 专栏收录该内容

10 篇文章 6 订阅

订阅专栏

文章目录

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]]