numpy使用总结
numpy是Python中常用的数据处理库的基础库,一般通过import numpy as np的方式导进
科学计算库numpy
在numpy中,主要的数据结构是ndarray,在numpy中称为数组,其中二维数组对应于数学上的矩阵,是数据处理中的常见结构
numpy的创建
-
可以通过读取本地文件来创建:genfromtxt()
world_alcohol = numpy.genfromtxt("world_alcohol.txt", delimiter=",",dtype=str,skip_header=1)其中
"world_alcohol.txt"为数据文件的路径,delimiter=","为区分元素的字符,以数据文件的具体情况来指定,有时候是空格,dtype=str指定生成ndarray的元素类型,有int/float/str三种类型可选,并且在一个ndarray中全部元素只能为同一种类型,如果指定的类型不对,转换后会有数据丢失,skip_header=1表示不读取第一行 -
可以通过将Python中的列表转换而成:array()
vector = numpy.array([5, 10, 15, 20],dtype=int)第一个参数为Python中的列表数据结构,列表可以是一维/二维等列表,一维列表表示矩阵中的标量,二维列表表示普通矩阵,指定类型为可选参数
****
打印数组的维度(行数和列数):shape
vector = numpy.array([1, 2, 3, 4])
print(vector.shape)
matrix = numpy.array([[5, 10, 15], [20, 25, 30]])
print(matrix.shape)输出
(4,)
(2, 3)查看列表中元素的数据类型dtype
numbers = numpy.array([1, 2, 3, 4])
numbers.dtype输出
dtype('int32')索引与切片
跟Python中的列表类似,,为不同维度的分隔符,:可以取同一个维度的一个范围,二维矩阵则是将行的选取范围和列的选取单位进行并集操作
一维矩阵的范围选取
vector = numpy.array([5, 10, 15, 20])
print(vector[0:3]) 输出
[ 5 10 15]二维矩阵的范围选取
matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
print(matrix[:,1])
#输出
[10 25 40]matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
print(matrix[:,0:2])
#输出
[[ 5 10]
[20 25]
[35 40]]matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
print(matrix[1:3,0:2])
#输出
[[20 25]
[35 40]]numpy的条件判断
使用numpy的条件判断时,矩阵会将每一个元素都与该条件进行比较,返回每个元素的比较结果,结果为True或False
#输入
vector = numpy.array([5, 10, 15, 20])
vector >= 10
#输出
array([False, True, True, True])
#输入
matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
matrix <= 25
#输出
array([[ True, True, True],
[ True, True, False],
[False, False, False]])通过判断得到的结果,可以用来当做索引取值
在上一步对矩阵进行条件判断后,得到一个与矩阵维度相同的元素只有True和False的矩阵(暂且取名b),在实际应用中,我们通常不仅仅需要得到这个矩阵b,更多的是需要得到满足该条件的元素值,在numpy中可以通过矩阵b作为索引,取出位置处为true的元素值
vector = numpy.array([5, 10, 15, 20])
equal_to_ten = (vector == 10)
print equal_to_ten
print(vector[equal_to_ten])
#输出
[False True False False]
[10]
matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
second_column_25 = (matrix[:,1] == 25)
print second_column_25
#条件结果一维矩阵,可以用来作为获取某些行或者列的索引
print(matrix[second_column_25, :])
#输出
[False True False]
[[20 25 30]]条件判断结果可以使用$ |这两个逻辑操作符进行运算,跟普通的条件运算一样
vector = numpy.array([5, 10, 15, 20])
equal_to_ten_and_five = (vector == 10) & (vector == 5)
print equal_to_ten_and_five
#输出
[False False False False]
vector = numpy.array([5, 10, 15, 20])
equal_to_ten_or_five = (vector == 10) | (vector == 5)
print equal_to_ten_or_five
#输出
[ True True False False]
vector = numpy.array([5, 10, 15, 20])
equal_to_ten_or_five = (vector == 10) | (vector == 5)
vector[equal_to_ten_or_five] = 50
print(vector)
#输出
[50 50 15 20]转换矩阵元素的数据类型astype
vector = numpy.array(["1", "2", "3"])
print vector.dtype
print vector
vector = vector.astype(float)
print vector.dtype
print vector
#输出
|S1
['1' '2' '3']
float64
[ 1. 2. 3.]矩阵元素的累加求和sum()
vector = numpy.array([5, 10, 15, 20])
vector.sum()
#输出
50
#axis指的是计算行还是列方向,axis=0:从列方向进行计算,axis=1:从行方向进计算,如果没有传入axis参数,求的是整个矩阵的元素和
matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
print (matrix.sum())
print (matrix.sum(axis=1))
#输出
225
array([ 30, 75, 120])
matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
print (matrix.sum(axis=0))
#输出
array([60, 75, 90])一个小例子,求出world_alcohol.txt数据中第5列的和及平均数
#replace nan value with 0
world_alcohol = numpy.genfromtxt("world_alcohol.txt", delimiter=",")
#isnan对矩阵元素进行是否为nan进行判断
is_value_empty = numpy.isnan(world_alcohol[:,4])
#将为nan的元素值替换为'0'
world_alcohol[is_value_empty, 4] = '0'
alcohol_consumption = world_alcohol[:,4]
#将str类型转换为float类型,进行下一步的计算
alcohol_consumption = alcohol_consumption.astype(float)
total_alcohol = alcohol_consumption.sum()
average_alcohol = alcohol_consumption.mean()
print (total_alcohol)
print (average_alcohol)
#输出
1137.78
1.140060120240481常用函数
arange
np.arange([start,]stop[,step,],dtype=None),确定一个数值范围,从范围中取出符合step要求的数,组成一个一维矩阵
reshape
np.reshape(),修改矩阵维度,参数中需要传入矩阵新维度,如果其中一个维度参数为-1,则以另外一个维度参数进行计算
import numpy as np
a = np.arange(15).reshape(3, -1)
print(a)
b=a.reshape(5,-1)
print(b)
#输出
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]
[12 13 14]]查看矩阵的维度shape
shape是每个矩阵的属性,调用可以获取到维度(即行与高)
a.shape
#输出
(3,5)查看矩阵的维数ndim
ndim是矩阵的属性,比如二维矩阵的维数是2
a.ndim
#输出
2数据类型名称的字符串dtype.name
dtype返回的是类型,而dtype.name返回的是类型的字符串
a.dtype.name
#输出
'int64'查看矩阵中元素的总数量size
a.size
#输出
15创建全0矩阵,zeros(),参数传值类型为tuple
np.zeros ((3,4))
#输出
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]])创建全1矩阵,ones(),参数传值类型为tuple
np.ones( (2,3,4), dtype=np.int32 )
#输出
array([[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],
[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]]])生成随机数矩阵np.random.random(),参数传值为tuple,由此发现,如果函数参数需要传递的参数为矩阵的维度,参数都是用tuple包装起来,这个是必须的,因为很多函数除了需要传递维度的参数,还需要传递其他参数,比如指定类型等,需要将维度参数封装起来,才符合逻辑
np.random.random(),获取范围为[0:1)的随机数,可以传入tuple来确定矩阵的维度
np.random.random((4,3))
#输出
array([[0.74742051, 0.70915301, 0.2530189 ],
[0.4440015 , 0.94236515, 0.49901836],
[0.55138142, 0.92399121, 0.36560045],
[0.86989627, 0.91722679, 0.20743568]])输出指定范围指定数量的数据linspace()
a=np.linspace( 0, 2*numpy.pi, (100) )
print(a.size)
np.sin(a)
#输出
10
array([ 0.00000000e+00, 6.42787610e-01, 9.84807753e-01, 8.66025404e-01,
3.42020143e-01, -3.42020143e-01, -8.66025404e-01, -9.84807753e-01,
-6.42787610e-01, -2.44929360e-16])矩阵与常量的加减乘除
矩阵里的每一个元素有常量进行加减乘除的运算,得到一个新矩阵
矩阵与矩阵的加减乘
矩阵与矩阵的加减就是两个矩阵对应位置的元素进行加减
矩阵与矩阵的乘法分两种情况,一种是a*b这种的,是两个矩阵对应位置中的元素进行相乘;第二种是a.dot(b)点乘,是矩阵的乘积,需要a矩阵的列数与b矩阵的行数相等
A = np.array( [[1,1],
[0,1]] )
B = np.array( [[2,0],
[3,4]] )
print (A*B)
print (A.dot(B))
#输出
[[2 0]
[0 4]]
[[5 4]
[3 4]] 求每个元素的开方np.sqrt(a),将每个元素作为指数,求e的次方
B = np.arange(3)
print (np.exp(B))
print (np.sqrt(B))
#输出
[1. 2.71828183 7.3890561 ]
[0. 1. 1.41421356]将矩阵进行地板除np.floor(a),将矩阵展开成一维矩阵a.ravel(),矩阵倒置a.T, 修改矩阵的维度a.shape=(x,y),a.reshape(x,y),a.resize(x,y)
a = np.floor(10*np.random.random((3,4)))
print (a)
print (a.ravel())
a.shape = (6, 2)
a.shape=(2,6)
print (a)
print (a.T)
print (a.resize((2,6)))
print (a)
#输出
[[8. 1. 2. 8.]
[5. 6. 3. 8.]
[3. 5. 8. 0.]]
[8. 1. 2. 8. 5. 6. 3. 8. 3. 5. 8. 0.]
[[8. 1. 2. 8. 5. 6.]
[3. 8. 3. 5. 8. 0.]]
[[8. 3.]
[1. 8.]
[2. 3.]
[8. 5.]
[5. 8.]
[6. 0.]]
None
[[8. 1. 2. 8. 5. 6.]
[3. 8. 3. 5. 8. 0.]]矩阵的拼接,水平方向进行拼接np.hstack(a,b),垂直方向拼接np.vstack(a,b)
a = np.floor(10*np.random.random((2,2)))
b = np.floor(10*np.random.random((2,2)))
print (a)
print ('---')
print (b)
print ('---')
print (np.hstack((a,b)))
print ('---')
print (np.vstack((a,b)))
#输出
[[1. 8.]
[7. 1.]]
---
[[1. 2.]
[3. 4.]]
---
[[1. 8. 1. 2.]
[7. 1. 3. 4.]]
---
[[1. 8.]
[7. 1.]
[1. 2.]
[3. 4.]]矩阵的切割,在行方向进行切割np.hsplit(a,x),在列方向进行切割np.vsplit(a,x),其中a是需要切割的矩阵,x是将矩阵切割成多少份
a = np.floor(10*np.random.random((2,12)))
print (a)
print (np.hsplit(a,2))
#以第4列为分割线,分别切割成3份,其中第4列为单独的一份
print (np.hsplit(a,(3,4)))
a = np.floor(10*np.random.random((12,2)))
print (a)
np.vsplit(a,3)
#输出
[[6. 2. 1. 6. 2. 3. 6. 5. 3. 3. 3. 7.]
[1. 4. 9. 0. 1. 6. 9. 2. 7. 9. 8. 9.]]
[array([[6., 2., 1., 6., 2., 3.],
[1., 4., 9., 0., 1., 6.]]), array([[6., 5., 3., 3., 3., 7.],
[9., 2., 7., 9., 8., 9.]])]
[array([[6., 2., 1.],
[1., 4., 9.]]), array([[6.],
[0.]]), array([[2., 3., 6., 5., 3., 3., 3., 7.],
[1., 6., 9., 2., 7., 9., 8., 9.]])]
[[4. 7.]
[9. 5.]
[4. 1.]
[0. 9.]
[9. 9.]
[3. 1.]
[2. 8.]
[1. 6.]
[8. 1.]
[0. 3.]
[3. 4.]
[4. 4.]]
[array([[4., 7.],
[9., 5.],
[4., 1.],
[0., 9.]]), array([[9., 9.],
[3., 1.],
[2.,