浅谈numpy库的常用基本操作方法

224 阅读 0 评论 148 点赞

我是靠谱客的博主含蓄冬日，最近开发中收集的这篇文章主要介绍浅谈numpy库的常用基本操作方法，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

NumPy数组的维数称为秩（rank），一维数组的秩为1，二维数组的秩为2，以此类推。在NumPy中，每一个线性的数组称为是一个轴（axes），秩其实是描述轴的数量。比如说，二维数组相当于是一个一维数组，而这个一维数组中每个元素又是一个一维数组。所以这个一维数组就是NumPy中的轴（axes），而轴的数量——秩，就是数组的维数。

1、创建矩阵

Numpy库中的矩阵模块为ndarray对象，有很多属性：T，data, dtype,flags,flat,imag,real,size,

itemsize,nbytes,ndim,shape,strides,ctypes,base等等。

1.1采用ndarray对象

import numpy as np #引入numpy库
#创建一维的narray对象
a = np.array([1,2,3,4,5])
#创建二维的narray对象
a2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
#创建多维对象以其类推

1.2通过函数创建矩阵

1.2.1 arange

import numpy as np
a = np.arange(10) # 默认从0开始到10（不包括10），步长为1
print(a) # 返回 [0 1 2 3 4 5 6 7 8 9]
a1 = np.arange(5,10) # 从5开始到10（不包括10），步长为1
print(a1) # 返回 [5 6 7 8 9]
a2 = np.arange(5,20,2) # 从5开始到20（不包括20），步长为2
print(a2) # 返回 [ 5 7 9 11 13 15 17 19]

1.2.2 linspace

linspace()和matlab的linspace很类似，用于创建指定数量等间隔的序列，实际生成一个等差数列。

import numpy as np
a = np.linspace(0,10,5) # 生成首位是0，末位是10，含5个数的等差数列
print(a)

1.2.3 logspace

linspace用于生成等差数列，而logspace用于生成等比数列。

下面的例子用于生成首位是100，末位是102，含5个数的等比数列

import numpy as np
a = np.logspace(0,2,5)
print(a)

1.2.4 ones,zeros,eye,empty

ones创建全1矩阵
zeros创建全0矩阵
eye创建单位矩阵
empty创建空矩阵（实际有值）

import numpy as np
a_ones = np.ones((3,4)) # 创建3*4的全1矩阵
print(a_ones)
# 结果
[[ 1. 1. 1. 1.]
 [ 1. 1. 1. 1.]
 [ 1. 1. 1. 1.]]
a_zeros = np.zeros((3,4)) # 创建3*4的全0矩阵
print(a_zeros)
# 结果
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
a_eye = np.eye(3) # 创建3阶单位矩阵
print(a_eye)
# 结果
[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
a_empty = np.empty((3,4)) # 创建3*4的空矩阵 
print(a_empty)
# 结果
[[ 1.78006111e-306 -3.13259416e-294 4.71524461e-309 1.94927842e+289]
[ 2.10230387e-309 5.42870216e+294 6.73606381e-310 3.82265219e-297]
[ 6.24242356e-309 1.07034394e-296 2.12687797e+183 6.88703165e-315]]

1.2.5 fromstring

fromstring()方法可以将字符串转化成ndarray对象，需要将字符串数字化时这个方法比较有用，可以获得字符串的ascii码序列。

a = "abcdef"
b = np.fromstring(a,dtype=np.int8) # 因为一个字符为8位，所以指定dtype为np.int8
print(b) # 返回 [ 97 98 99 100 101 102]

1.2.6 fromfunction

fromfunction()方法可以根据矩阵的行号列号生成矩阵的元素。

例如创建一个矩阵，矩阵中的每个元素都为行号和列号的和。

import numpy as np
def func(i,j): 
 return i+j
a = np.fromfunction(func,(5,6)) 
# 第一个参数为指定函数，第二个参数为列表list或元组tuple,说明矩阵的大小
print(a)
# 返回
[[ 0. 1. 2. 3. 4. 5.]
[ 1. 2. 3. 4. 5. 6.]
[ 2. 3. 4. 5. 6. 7.]
[ 3. 4. 5. 6. 7. 8.]
[ 4. 5. 6. 7. 8. 9.]]
#注意这里行号的列号都是从0开始的

2.矩阵的操作

numpy中的ndarray对象重载了许多运算符，使用这些运算符可以完成矩阵间对应元素的运算。

如 +，-，*，/，%，**

2.1矩阵函数操作

2.1.1 常用数学运算（导入numpy模块：import numpy as np）

矩阵函数	说明
np.sin(a)	对矩阵a中每个元素取正弦,sin(x)
np.cos(a)	对矩阵a中每个元素取余弦,cos(x)
np.tan(a)	对矩阵a中每个元素取正切,tan(x)
np.arcsin(a)	对矩阵a中每个元素取反正弦,arcsin(x)
np.arccos(a)	对矩阵a中每个元素取反余弦,arccos(x)
np.arctan(a)	对矩阵a中每个元素取反正切,arctan(x)
np.exp(a)	对矩阵a中每个元素取指数函数,ex
np.sqrt(a)	对矩阵a中每个元素开根号√x

如：求矩阵每个元素的sin值

import numpy as np
array=np.array([[1,2,3],
        [4,5,6]])
print(np.sin(array))
#结果
# [[ 0.84147098 0.90929743 0.14112001]
# [-0.7568025 -0.95892427 -0.2794155 ]]

2.1.2矩阵乘法（点乘）

矩阵乘法必须满足矩阵乘法的条件，即第一个矩阵的列数等于第二个矩阵的行数。

矩阵乘法的函数为 dot

 import numpy as np
a1 = np.array([[1,2,3],[4,5,6]]) # a1为2*3矩阵
a2 = np.array([[1,2],[3,4],[5,6]]) # a2为3*2矩阵
print(a1.shape[1]==a2.shape[0]) # True, 满足矩阵乘法条件
print(a1.dot(a2)) 
# a1.dot(a2)相当于matlab中的a1*a2
# 而python中的a1*a2相当于matlab中的a1.*a2
# 结果
[[22 28]
[49 64]]

2.1.3矩阵的转置(transpose或T)

import numpy as np
array=np.array([[1,2,3],
        [4,5,6]])
print(array.transpose())#或np.transpose(array)
print(array.T)
# 结果
# [[1 4]
# [2 5]
# [3 6]]
#      transpose与T效果一样
# [[1 4]
# [2 5]
# [3 6]]

2.1.4矩阵的逆

求矩阵的逆需要先导入numpy.linalg，用linalg的inv函数来求逆。

矩阵求逆的条件是矩阵的行数和列数相同。

import numpy as np
import numpy.linalg as lg
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(lg.inv(a))
# 结果
[[ -4.50359963e+15  9.00719925e+15 -4.50359963e+15]
 [ 9.00719925e+15 -1.80143985e+16  9.00719925e+15]
[ -4.50359963e+15  9.00719925e+15 -4.50359963e+15]]
a = np.eye(3) # 3阶单位矩阵
print(lg.inv(a)) # 单位矩阵的逆为他本身
# 结果
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]

2.1.5最大值最小值

获得矩阵中元素最大最小值的函数分别是max和min，可以获得整个矩阵、行或列的最大最小值。

import numpy as np
array=np.array([[1,2,3],
        [4,5,6]])
print(array.max())#结果为6
print(array.min())#结果为1
#同时还可以指定axis关键字，获取行或列的最大、最小值
print(array.max(axis=0)) #x轴最大值，0,1分别代表行列

2.1.6平均值

获得矩阵中元素的平均值可以通过函数mean()或average()。同样地，可以获得整个矩阵、行或列的平均值

import numpy as np
array=np.array([[1,2,3],
        [4,5,6]])
print(array.mean())#结果为3.5
print(np.average(array))#结果为3.5
print(array.mean(axis=0))#行方向的平均值，同样，0,1代表维度

2.1.7方差

方差的函数为var(),方差函数var()相当于函数mean(abs(x - x.mean())**2),其中x为矩阵。

import numpy as np
array=np.array([[1,2,3],
        [4,5,6]])
print(array.var())#结果为2.91666666667
#同样可通过axis指定维度0,1分别代表行列，
print(array.var(axis=0))
# 结果
# [ 2.25 2.25 2.25]

2.1.8标准差

标准差的函数为std()。

std()相当于sqrt(mean(abs(x - x.mean())**2))，或相当于sqrt(x.var())。

import numpy as np
array=np.array([[1,2,3],
        [4,5,6]])
print(array.std())#结果为1.70782512766
#同样可通过axis指定维度0,1分别代表行列，
print(array.std(axis=0))
# 结果
# [ 1.5 1.5 1.5]

2.1.9中位数or中值

中值指的是将序列按大小顺序排列后，排在中间的那个值，如果有偶数个数，则是排在中间两个数的平均值。

例如序列[5,2,6,4,2]，按大小顺序排成 [2,2,4,5,6]，排在中间的数是4，所以这个序列的中值是4。

又如序列[5,2,6,4,3,2]，按大小顺序排成 [2,2,3,4,5,6]，因为有偶数个数，排在中间两个数是3、4，所以这个序列中值是3.5。

中值的函数是median()，调用方法为numpy.median(x,[axis])，axis可指定轴方向，默认axis=None，对所有数去中值

import numpy as np
array=np.array([[1,2,3],
        [4,5,6]])
print(np.median(array))#结果：3.5
#指定维度
print(np.median(array,axis=0))
#结果
# [ 2.5 3.5 4.5]

2.1.10　求和

矩阵求和的函数是sum()，可以对行，列，或整个矩阵求和

import numpy as np
array=np.array([[1,2,3],
        [4,5,6]])
print(array.sum())#结果：21
#指定维度
print(array.sum(axis=0))
#结果
# [5 7 9]

2.1.11 累计和或累加

某位置累积和指的是该位置之前(包括该位置)所有元素的和。

例如序列[1,2,3,4,5]，其累计和为[1,3,6,10,15]，即第一个元素为1，第二个元素为1+2=3，……，第五个元素为1+2+3+4+5=15。

矩阵求累积和的函数是cumsum()，可以对行，列，或整个矩阵求累积和。

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.cumsum())      # 对整个矩阵求累积和
# 结果 [ 1 3 6 10 15 21]
print(a.cumsum(axis=0)) # 对行方向求累积和
# 结果
[[1 2 3]
[5 7 9]]
print(a.cumsum(axis=1)) # 对列方向求累积和
# 结果
[[ 1 3 6]
[ 4 9 15]]

2.2矩阵的截取

2.2.1 按行列截取

矩阵的截取和list相同，可以通过[]（方括号）来截取

import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a[0:1]) #截取第一行,返回 [[1 2 3 4 5]]
print(a[1,2:5]) #截取第二行，第三、四、五列，返回 [8 9 10]
print(a[1,:]) #截取第二行,返回 [ 6 7 8 9 10]

2.2.2按条件截取

import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
b = a[a>6] # 截取矩阵a中大于6的元素，范围的是一维数组
print(b) # 返回 [ 7 8 9 10]
# 其实布尔语句首先生成一个布尔矩阵，将布尔矩阵传入[]（方括号）实现截取
print(a>6) 
# 返回
[[False False False False False]
[False True True True True]]

按条件截取应用较多的是对矩阵中满足一定条件的元素变成特定的值。

例如将矩阵中大于6的元素变成0。

import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a)
#开始矩阵为
[[ 1 2 3 4 5]
 [ 6 7 8 9 10]]
a[a>6] = 0
print(a)
#大于6清零后矩阵为
[[1 2 3 4 5]
[6 0 0 0 0]]

2.2.3 clip截取

clip（矩阵，min，max）#返回值：所有小于min的值都等于min，所有大于max的值都等于max

import numpy as np
array=np.array([[1,2,3],
        [4,5,6]])
print(array.clip(2,4))
#结果
# [[2 2 3]
# [4 4 4]]

2.3 矩阵的合并

矩阵的合并可以通过numpy中的hstack方法和vstack方法实现

import numpy as np
a1 = np.array([[1,2],[3,4]])
a2 = np.array([[5,6],[7,8]])
#!注意 参数传入时要以列表list或元组tuple的形式传入
print(np.hstack([a1,a2])) 
#横向合并，返回结果如下 
[[1 2 5 6]
[3 4 7 8]]
print(np.vstack((a1,a2)))
#纵向合并，返回结果如下
[[1 2]
[3 4]
[5 6]
[7 8]]

矩阵的合并也可以通过concatenatef方法。

np.concatenate( (a1,a2), axis=0 ) 等价于 np.vstack( (a1,a2) )

np.concatenate( (a1,a2), axis=1 ) 等价于 np.hstack( (a1,a2) )

以上这篇浅谈numpy库的常用基本操作方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。