numpy常用用法总结

目录

 

使用

基本操作

数组与标量、数组之间的运算

数组的 矩阵积

布尔索引

---

科学计算库，新的数据结构ndarry，多维数组对象，处理后交给pandas进一步处理

使用

import numpy as np;

arr=np.array([[1,2],[2,3],[4,5]])

array([[1, 2],

       [2, 3],

       [4, 5]])

#维度数量：二维数组，前边有两个方括号

#建立NDarray多维数组，可以直接使用嵌套列表

arr.dim                                       #维度数量,定义时前边有几个方括号就是几个维度的数组

arr.dtype                                    #数据类型

arr.array(['1','2','3','4'],dtype=int)           #zhuanhaun转换数据类型

arr.size                                                          #数据多少

np.zeros((m,n))                                           #m行n列纯0二维数组

np.ones((m,n))                                           #m行n列纯1二维数组

np.empty((m,n))                                         #m行n列空二维数组

 

arr3=arr2.astype('|U2')                            #改变数据类型

arr4=arr2.astype('|S2')

arr5=np.arange(20)

arr6=np.arange(1,20,2)                            #从[0,20,1)

arr7=arr5.reshape(4,5)                #reshape不会改变原来的数据类型，得到的新的ndarray是原数组的视图；元素的形状可变，总个数不可变；

 

改变ndarray形状：

a=np.arange(0,20,2)

a.reshape(2,5)

a.reshape(-1,5)

a.reshape(2,-1)

a.shape

a.shape=5,-1

a.shape=-1,2

 

视图：改变arr7中的元素，arr5中的元素会相应进行修改；

副本:拷贝数据放到了新的内存空间,副本元素的改变不会引起原始数据的改变

对于ndarray的操作，一定要清楚改变的对象是副本还是视图，是否会对原始数据造成改变

 

arr8=arr5.copy()            

 

基本操作

数组与标量、数组之间的运算

1. 数组不用循环即可对每个元素执行批量计算，这通常叫做矢量化，用数组表达式代替循环的做法（通常使用循环进行计算）

arr+arr2

arr*arr2

arr/arr2

arr3=np.random.random((2,3))

arr3+arr4.reshape(2,3)

arr3.dot(arr4)

arr4.dot(arr3)

行轴 axis[0] 垂直的轴

列轴 axis[1] 水平的轴

arr4.dot(arr3)

arr.transpose()

np.transpose()

 

arr2

array([[ 0,  1,  2,  3,  4],

       [ 5,  6,  7,  8,  9],

       [10, 11, 12, 13, 14],

       [15, 16, 17, 18, 19],

       [20, 21, 22, 23, 24]])

arr2.sum(axis=0)               #沿axis=0的方向求和，也就是列方向

array([50, 55, 60, 65, 70])

 

1. 矢量化数组运算性能比纯python方式快1~2个数量级
2. 大小相等的数组之间的任何算术运算都会将运算应用到元素级
3. 大小相等的两个数组之间的任何算术运算都会将其运算应用到元素级上的操作
4. 元素级操作：在NumPy中，大小相等的数组之间的运算，为元素级运算，即只用于位置相同的元素之间，所得的运算结果组成一个新的数组，运算结果的位置跟操作数位置相同。

数组的 矩阵积

数组的索引

布尔索引

arr5>0.1

array([[ True,  True,  True],

       [ True,  True,  True],

       [ True,  True,  True]], dtype=bool)

array([[ True,  True,  True,  True],

       [ True,  True,  True,  True],

       [ True,  True,  True,  True],

       [ True,  True,  True, False],

       [False, False, False, False],

       [False, False, False, False],

       [False, False, False, False],

       [False, False, False, False]], dtype=bool)

arr6[arr6<15]        #将布尔值为真的数值取出组成一个新的数组(是副本，不是视图)

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

 

花式索引:

花式索引(Fancy indexing)指的是利用整数数组进行索引的方式。

arr[][]                                                  #嵌套索引

arr[, , ]                                                 #花式索引

arr[][   ,  ,  ]                                 #花式索引与嵌套索引联合使用

arr[[ , , ], :]

arr6[[0,3,5],:]

array([[ 0,  1,  2,  3],

       [12, 13, 14, 15],

       [20, 21, 22, 23]])

arr6[[0,3,5],[0,3,2]]                           #按位取，前边取出行，后边按位取出对应的列

array([ 0, 15, 22])

 

array([   1.,    2.,  nan,    3.,  nan])

cc[np.isnan(cc)]=111

array([   1.,    2.,  111.,    3.,  111.])

 

 

np.ix_([0,3,5],[0,2,3])                      #生成一个所引器

(array([[0],

        [3],

        [5]]), array([[0, 2, 3]]))

ran

array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],

       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],

       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],

       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],

       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],

       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],

       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],

       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79]])

ran[np.ix_([0,1,2],[0,1,2])]   花式索引得出的值是两个轴共同确定的矩阵

array([[ 0,  1,  2],

       [10, 11, 12],

       [20, 21, 22]])

可以使用嵌套来实现：

ran [[0,1,2],:][:,[0,1,2]]    或ran[[0,1,2]][:,[0,1,2]] 

ran[[0,1,2],[0,1,2]]

array([ 0, 11, 22])

 

数组的转置与轴对换：注意：创建的是视图

transpose()函数用于数组的转置，对于2维数组来说是行列互换；     #arr.transpose()

数组的T属性，也是转置             #arr.T

 

通用函数：

• ufunc：numpy模块中对ndarray中数据进行快速元素级运算的函数，也可以看做是简单的函数(接受一个或多个标量值，并产生一个或多个标量值)的矢量化包装器。

•  主要包括一元函数和二元函数

 

一元ufunc	描述	调用方式
modf	将数组中元素的小数位和整数位以两部分独立数组的形式返回	np.modf(arr)
isnan	返回一个表示“那些值是NaN(不是一个数字)”的布尔类型数组	np.isnan(arr)
isfinite、isinf	分别一个表示”那些元素是有穷的(非inf、非NaN)”或者“那些元素是无穷的”的布尔型数组	np.isfinite(arr) np.isinf(arr)
cos、cosh、sin、sinh、tan、tanh	普通以及双曲型三角函数	np.cos(arr) np.sin(arr) np.tan(arr)
arccos、arccosh、arcsin、arcsinh、arctan、arctanh	反三角函数	np.arccos(arr) np.arrsin(arr) np.arrtan(arr)

二元ufunc	描述	调用方式
mod	元素级的取模	np.mod(arr1,arr2)
dot	求两个数组的点积	np.dot(arr1,arr2)
greater、greater_equal、less、less_equal、equal、not_equal	执行元素级别的比较运算，最终返回一个布尔型数组	np.greater(arr1, arr2) np.less(arr1, arr2) np.equal(arr1, arr2)
logical_and、logical_or、logical_xor	执行元素级别的布尔逻辑运算，相当于中缀运算符&、|、^	np.logical_and(arr1,arr2) np.logical_or(arr1,arr2) np.logical_xor(arr1,arr2)
power	求解对数组中的每个元素进行给定次数的指数值，类似于: arr ** 3	np.power(arr, 3) np.power(arr, arr2)#按位次方运算

 

聚合函数：

聚合函数是对一组值(eg一个数组)进行操作，返回一个单一值作为结果的函数。当然聚合函数也可以指定对某个具体的轴进行数据聚合操作；常将的聚合操作有：平均值、最大值、最小值、方差等等

max

min

mean

std

sum

 

arr6.sum(axis=0)              #按照列去取值      #

arr6.sum(axis=1)         # 按照行去取值    #

 

 

np.where(): 函数是三元表达式：x if condition else y的矢量化版本

三元表达式：1 if 2>3  else 0

conditon=np.array([ture,false,ture,false])

x=np.array([1,1.1,1.2,1.3,1.4,1.5])

y=np.array([2,2.1,2.2,2.3,2.4,2.5])

 

np.where[condition,xarr,yarr]

等同于

zip_arr=zip(x,y,condition)

result=[x if bl else y for x,y,bl in zip_arr]

 

np.where(np.isnan(arr),0,arr);

 

 

np.unique()函数:    主要作用是将数组中的元素进行去重操作(也就是只保存不重复的数据)

 

数据文件读写

以二进制方式保存到磁盘

array_name=np.array([ … ])

np.save(‘datafile_name’,array_name)    #不需用添加后缀，将多维数组存储到文件，自动添加后缀 .npy （二进制文件）

np.load(‘data.npy’)         #注意，此处需要后缀进行读操作

 

文本文件

存取文本文件，读取数据：

np.loadtxt(‘example.csv’,delimiter=’,’);

 1366