numpy使用总结

numpy是Python中常用的数据处理库的基础库,一般通过import numpy as np的方式导进

科学计算库numpy

在numpy中,主要的数据结构是ndarray,在numpy中称为数组,其中二维数组对应于数学上的矩阵,是数据处理中的常见结构

numpy的创建

1. 可以通过读取本地文件来创建: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表示不读取第一行

2. 可以通过将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., 8.],
        [1., 6.]]), array([[8., 1.],
        [0., 3.],
        [3., 4.],
        [4., 4.]])]

矩阵的复制,浅复制a=b,深复制b=a.copy()

浅复制只是将a所指向的对象的引用传递给b,也就是a与b所持有的对象引用是一样的,在修改任何一个矩阵,其他一个都会变

深复制,是重新生成一个矩阵对象,再将新生成的矩阵对象地址赋值给b变量,修改a或者b其中一个矩阵,不影响其他矩阵

返回矩阵每一列或者每一行中的最大值的索引值a.argmax([aixs]),返回每一行或者每一列的最大/最小值a.max([aixs]),求索引值这个函数往往可以用在先求出特征中符合某个条件的值的行数,接着再通过行数得到该样本的数据

import numpy as np
data = np.sin(np.arange(20)).reshape(5,4)
print (data)
ind = data.argmax(axis=0)
print (ind)
print (data.max(axis=0)

#输出
[[ 0.          0.84147098  0.90929743  0.14112001]
 [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
 [ 0.98935825  0.41211849 -0.54402111 -0.99999021]
 [-0.53657292  0.42016704  0.99060736  0.65028784]
 [-0.28790332 -0.96139749 -0.75098725  0.14987721]]
[2 0 3 1]
[0.98935825 0.84147098 0.99060736 0.6569866 ]

矩阵的重复拓展tile

np.tile(a,(x,y))将a矩阵在行方向拓展x次,在列方向拓展y次

a = np.arange(0, 40, 10)
b = np.tile(a, (3, 5))
print (b)

#输出
[[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
 [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
 [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]]

矩阵升序排序np.sort(a,axis)

轴参数:axis=0,表示列,axis=1,表示行

a = np.array([[4, 3, 5], [1, 2, 1]])
print (a)
b = np.sort(a, axis=1)
print (b)

#输出
[[4 3 5]
 [1 2 1]]
[[3 4 5]
 [1 1 2]]

输出矩阵,元素值从小到大的索引位置

a = np.array([4, 6, 1, 2])
j = np.argsort(a)

/#输出
[2 3 0 1]
[1 2 4 6]