Numpy常见的使用方法操作(2019.7.20更新)

最新推荐文章于 2023-02-06 19:54:52 发布

tigerlib

最新推荐文章于 2023-02-06 19:54:52 发布

阅读量396

点赞数 2

分类专栏： Python 文章标签： Numpy Python 数据分析多维数组矩阵

本文链接：https://blog.csdn.net/weixin_44695969/article/details/92066359

版权

Python 专栏收录该内容

50 篇文章 2 订阅

订阅专栏

Numpy（Numerical Python）：Python中一个用作高性能科学计算和数据分析的基础包，本身是由C语言开发，是个很基础的扩展，Python其余的科学计算扩展大部分都是以此为基础。

主要用于用来存储和处理多维数组（大型矩阵），比Python自身的嵌套列表结构要高效的多。
具有矢量运算能力，快速、节省空间；矩阵运算，无需循环，可完成类似Matlab中的矢量运算
ndarray的下标从0开始，且数组里的所有元素必须是相同类型
导包：import numpy as np

1. 创建多维数组（ndarray N维数组）

1. 创建多维数组（ndarray N维数组）

操作	代码实现	返回值	说明
随机创建	*np.random.rand(d0, d1, ..., dn)* np.random.rand(3, 4)	新数组	生成指定维度大小（3行4列）均匀分布的随机多维浮点型数据（二维），rand固定区间0.0 ~ 1.0 np.random.randn() 返回具有标准正态分布的序列
	np.random.randint(-1, 5, size = (3, 4))	新数组	生成指定维度大小（3行4列）的随机多维整型数据（二维），randint()可以指定区间（-1, 5）
	*np.random.uniform(low=0.0, high=1.0, size=None)* np.random.uniform(-1, 5, size = (3, 4))	新数组	功能：从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high. 参数介绍: low: 采样下界，float类型，默认值为0； high: 采样上界，float类型，默认值为1； size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出mnk个样本，缺省时输出1个值。生成指定维度大小（3行4列）的随机多维浮点型数据（二维），uniform()可以指定区间（-1, 5）
	*np.random.randn(d0, d1, …, dn)*	新数组	功能：从标准正态分布中返回一个或多个样本值
	*np.random.normal(loc=0.0, scale=1.0, size=None)*	新数组	loc：float 此概率分布的均值 scale：float 此概率分布的标准差 size: int or tuple of ints
	*np.random.standard_normal(size=None)*	新数组	返回指定形状的标准正态分布的数组
序列创建	np.array(range(10))	新数组	生成一维数组（10, ）
	np.array([range(10),range(10)])	新数组	生成二维数组（2, 10）
	np.arange(0, 15, 3) <=> np.array(range(0, 15, 3))	新数组（等差）	arange() 类似python的 range()，创建一个一维ndarray数组指定步长
	np.linspace (start, stop, num, endpoint) np.linspace(0, 100, 11) array([ 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100.])	新数组（等差）	start:序列的起始值 stop:序列的终止值 num:要生成的等间隔样例数量，默认为50 指定数量 endpoint:序列中是否包含stop值，默认为ture
	np.logspace(start,stop, num)	新数组（等比）	num:要生成的等比数列数量，默认为50
	对比： np.array(array, dtype) np.asarray(array, dtype)	新数组	唯一不同： np.array -- 深拷贝 np.asarray -- 浅拷贝
	np.zeros((3, 4))	新数组	指定大小的全0数组。注意：第一个参数是元组，用来指定大小，如（3,4）
	np.ones((2, 3))	新数组	指定大小的全1数组。注意：第一个参数是元组，用来指定大小，如（3,4）
	np.empty((3, 3))	新数组	初始化数组，不是总是返回全0，有时返回的是未初始的随机值(内存里的随机值)
	np.empty((3, 3), int)	新数组	指定数据类型
参数	np.zeros((3, 4), dtype=np.float64)	新数组	初始化数组（3行4列），使用dtype参数，指定数据类型

2. 多维数组的属性和方法

功能		代码实现	返回值	说明
属性	ndim	array.ndim	维度个数（整数）	维度个数
	shape	array.shape	维度大小（元组）	维度大小
	size	array.size	数组中的元素总数量
	itemsize	array.itemsize	数组元素的长度（单位字节）
	dtype	array.dtype	数据类型（例：float64，int64）	数据类型
方法	astype()	array.astype(np.int32)	新数组	将已有数组的数据类型转换为int32
	reshape()	array.reshape(3, 5)	新数组	reshape() 将重新调整数组的维数(3, 5)
	reshape()	array.reshape(1, 3, 5)	新数组	维数(1, 3, 5)
	resize([ ])	array.resize([1, 3, 5])	None	注意和reshape的区别
	astype()	array.astype(np.int32)	新数组	修改数组的类型
	array.tostring([order]) 或者 array.tobytes([order])		新数组	构造包含数组中原始数据字节的Python字节
np.random.shuffle(array)			None	将打乱数组序列（类似于洗牌）。

3. 数组的运算

数组是编程中的概念，矩阵、矢量是数学概念。

在计算机编程中，矩阵可以用数组形式定义，矢量可以用结构定义!

a. 数组的加减乘除

运算		代码实现	返回值	说明
数组与数组：两个数组的维度大小相等（或者符合广播机制）	加法	array1 + array2	新数组	相对应的位置的元素相加
	减法	array1 - array2	新数组	相对应的位置的元素相减
	乘法	*array1 array2**	新数组	相对应的位置的元素相乘
	除法	array1 / array2	新数组	相对应的位置的元素相除，数组array2中的所有元素必须非零
矩阵乘法		np.matmul(a, b)	新数组	a，b只能是矩阵，不能是标量
矩阵乘法		np.dot(a, b)	新数组	a，b可以都是矩阵，也可以是标量（类似于*点乘）
数组与数字：将运算广播到数组的每一个元素	加法	array + k	新数组	数字k与数组array的每个元素相加，得到一个新数组
	减法	k - array	新数组	数字k作为被减数，与数组array的每个元素相减，得到一个新数组
	减法	array - k	新数组	数字k作为减数，与数组array的每个元素相减，得到一个新数组
	乘法	*array k**	新数组	数字k与数组array的每个元素相乘，得到一个新数组
	除法	k / array	新数组	数字k作为被除数，与数组array的每个元素相除，数组array中的所有元素必须非零
	除法	array / k	新数组	数字k作为除数，与数组array的每个元素相除，数字k必须非零

b. 数组的计算函数

函数名	代码实现	返回值	说明
ceil()	np.ceil(array)	新数组	向上最接近的整数，参数是 number 或 array
floor()	np.floor(array)	新数组	向下最接近的整数，参数是 number 或 array
rint()	np.rint(array)	新数组	四舍五入，参数是 number 或 array
isnan()	np.isnan(array)	新数组(类型bool)	判断元素是否为 NaN(Not a Number)，参数是 number 或 array
multiply()	np.multiply(array, array)	新数组	元素相乘，参数是 number 或 array
divide()	np.divide(array, array)	新数组	元素相除，参数是 number 或 array
abs()	np.abs(array)	新数组	元素的绝对值，参数是 number 或 array
where()	np.where(array > 0, 1, -1)	新数组	where(condition, x, y)三元运算符，x if condition else y 数组array中，满足大于0条件的元素，将它的值设为1；不满足条件的元素设为-1

c. 数组的统计函数

多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。

函数名	代码实现	返回值	说明
mean()	np.mean(array)	相应数据	所有元素的平均值，参数是 number 或 array
sum()	np.sum(array)	相应数据	所有元素的和，参数是 number 或 array
max()	np.max(array)	相应数据	所有元素的最大值，参数是 number 或 array
min()	np.min(array)	相应数据	所有元素的最小值，参数是 number 或 array
std()	np.std(array)	相应数据	所有元素的标准差，参数是 number 或 array
var()	np.var(array)	相应数据	所有元素的方差，参数是 number 或 array
median()	np.median(array)	相应数据	所有元素的中位数，参数是 number 或 array
argmax()	np.argmax(array)	相应数据	最大值的下标索引值，参数是 number 或 array
argmin()	np.argmin(array)	相应数据	最小值的下标索引值，参数是 number 或 array
cumsum()	np.cumsum(array)	相应数据	返回一个一维数组，每个元素都是之前所有元素的累加和，参数是 number 或 array
cumprod()	np.cumprod(array)	相应数据	返回一个一维数组，每个元素都是之前所有元素的累乘积，参数是 number 或 array

d. 数组的判断函数

函数名	代码实现	返回值	说明
any()	np.any(array > 0)	True/False	至少有一个元素满足指定条件，返回True
all()	np.all(array > 0)	True/False	所有的元素满足指定条件，返回True

e. 数组的去重排序函数

np.unique(array): 找到唯一值并返回排序结果，返回一个一维数组。类似于Python的set集合

4. 数组的索引与切片

操作		代码实现	返回值	说明
一维数组	索引	array[2]	指定数字	得到第三个数字（索引为2）
一维数组	切片	array[2 : 5]	新数组
二维数组	索引	array[1]	新数组	得到第二行数据（一维数组，索引为1）
	索引	array[1, 3] <=> array[1][3]	指定数字	得到第二行，第四列的数字
	切片	array[1 : 3, 2 : ]	新数组	得到第二三行与第三列之后所有列组合成的新数组
	切片	array[ : , 2 : 4]	新数组	[:] 代表某个维度的数据
多维数组与二维数组类似

5. 数组的条件索引

注意：多个条件组合要使用（& 、|）连接，而不是Python的（and、or）

In [1]: array1 = np.random.randint(-5,5,size=(3,4))                                               

In [2]: array1                                                                                    
Out[2]: 
array([[-2,  2, -2,  3],
       [-3, -4, -1, -3],
       [-2, -3, -5,  0]])

In [3]: array2 = np.arange(12).reshape(3,4)                                                      

In [4]: array2                                                                                   
Out[4]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [5]: condition1 = array1 >= -2                    # 布尔值多维数组                                             

In [6]: condition2 = array1 <= 0                                                                  

In [7]: condition1.dtype                                                                         
Out[7]: dtype('bool')

In [8]: condition1                                                                               
Out[8]: 
array([[ True,  True,  True,  True],
       [False, False,  True, False],
       [ True, False, False,  True]])

In [9]: condition2                                                                               
Out[9]: 
array([[ True, False,  True, False],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True]])

In [10]: condition1 & condition2                    # 多个条件组合要使用 & | 连接，而不是Python的 and or                                                  
Out[10]: 
array([[ True, False,  True, False],
       [False, False,  True, False],
       [ True, False, False,  True]])

In [11]: array2[condition1]                                                                       
Out[11]: array([ 0,  1,  2,  3,  6,  8, 11])

In [12]: array2[condition1 & condition2]                                                          
Out[12]: array([ 0,  2,  6,  8, 11])

6. 数组的维度转换

a. 二维数组（类似矩阵转置）

In [40]: array1 = np.random.randint(-5,5,size=(3,4))      # 维度大小(3,4)                                        
In [41]: array1                                                                                   
Out[41]: 
array([[-3,  4, -4, -4],
       [-5, -4, -5, -5],
       [-3, -5, -2,  3]])

In [42]: array1.transpose()                               # 维度大小(4,3)，类似矩阵的转置                                        
Out[42]: 
array([[-3, -5, -3],
       [ 4, -4, -5],
       [-4, -5, -2],
       [-4, -5,  3]])

b. 高维数组

In [43]: array2 = np.random.randint(-5,5,size=(2,3,4))    # 维度大小(2,3,4)                                         
In [44]: array2                                                                                   
Out[44]: 
array([[[-5, -3,  2,  4],
        [-3,  0, -5,  1],
        [-2, -5, -2,  2]],

       [[-1, -4,  1, -1],
        [-2,  0, -4, -1],
        [ 4, -2,  0, -2]]])

In [45]: array2.transpose()                               # 维度大小(4,3,2)
Out[45]: 
array([[[-5, -1],
        [-3, -2],
        [-2,  4]],

       [[-3, -4],
        [ 0,  0],
        [-5, -2]],

       [[ 2,  1],
        [-5, -4],
        [-2,  0]],

       [[ 4, -1],
        [ 1, -1],
        [ 2, -2]]])

In [46]: array2.transpose(1,0,2)                         # 维度大小(3,2,4), 3对应1，2对应0，4对应2                                            
Out[46]: 
array([[[-5, -3,  2,  4],
        [-1, -4,  1, -1]],

       [[-3,  0, -5,  1],
        [-2,  0, -4, -1]],

       [[-2, -5, -2,  2],
        [ 4, -2,  0, -2]]])

tigerlib

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Numpy常见的使用方法操作(2019.7.20更新)

Numpy（Numerical Python）：Python中一个用作高性能科学计算和数据分析的基础包，本身是由C语言开发，是个很基础的扩展，Python其余的科学计算扩展大部分都是以此为基础。主要用于用来存储和处理多维数组（大型矩阵），比Python自身的嵌套列表结构要高效的多。具有矢量运算能力，快速、节省空间；矩阵运算，无需循环，可完成类似Matlab中的矢量运算 ndarray的下...
复制链接

扫一扫