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为(2,4)的一个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为(2,4)的一个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矩阵中的元素小于5的等于5,大于9的等于9
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对应的从索引为1的列来算移植相当于取到索引为(2-1)的列,2为取的最高索引大一个。所以总体来讲就是首先取每一行,之后在行里取索引1->1的列元素,所以为最终的结果列向量。

a[:, 1:3]:按照上面的分析则每一行都要,列要索引为1和(3-1)的元素,那就是索引为1和2的所有元素,也就是第二列和第三列的元素。

a[1, 1:3]:为a[:, 1:3]的索引为1的所有元素。
这里需要注意的是

a[:, 1]  #索引为1的列,生成为行向量,

a[:, 1:2] #索引为1的列,生成为列向量

因为两种取值的思想不一样,最终造成的结果也不一样,一个是直接取,所以维度减少了一个,另一个是在原本维度上截取,最终还是原来的维度。

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])  #索引为1的列,生成为行向量
print(a[:, 1:2]) #索引为1的列,生成为列向量

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

你可能感兴趣的:(Numpy)