NumPy
Numpy ：提供了一个在Python中做科学计算的基础库，重在数值计算，主要用于多维数组(矩阵)处理的库。用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多。本身是由C语言开发，是个很基础的扩展，Python其余的科学计算扩展大部分都是以此为基础。
高性能科学计算和数据分析的基础包
ndarray，多维数组(矩阵)，具有矢量运算能力，快速、节省空间
矩阵运算，无需循环，可完成类似Matlab中的矢量运算
线性代数、随机数生成
使用以下语句导入 Numpy 库：
import numpy as np
NumPy 数组
创建数组
>>> a = np.array([1,2,3])>>> b = np.array([(1.5,2,3), (4,5,6)], dtype =float)>>> c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]], dtype = float)
初始化占位符
>>> np.zeros((3,4))#创建值为0数组
>>> np.ones((2,3,4),dtype=np.int16)#创建值为1数组
>>> d = np.arange(10,25,5)#创建均匀间隔的数组(步进值)
>>> np.linspace(0,2,9)#创建均匀间隔的数组(样本数)
>>> e = np.full((2,2),7)#创建常数数组
>>> f = np.eye(2)#创建2x2单位矩阵
>>> np.random.random((2,2))#创建随机值的数组
>>> np.empty((3,2))#创建空数组
输入/输出
保存与载入磁盘上的文件
>>> np.save('my_array', a)>>> np.savez('array.npz', a, b)>>> np.load('my_array.npy')
保存与载入文本文件
>>> np.loadtxt("myfile.txt")>>> np.genfromtxt("my_file.csv", delimiter=',')>>> np.savetxt("myarray.txt", a, delimiter=" ")
数据类型
>>> np.int64#带符号的64位整数
>>> np.float32#标准双精度浮点数
>>> np.complex#显示为128位浮点数的复数
>>> np.bool#布尔值：True值和False值
>>> np.object#Python对象
>>> np.string_#固定长度字符串
>>> np.unicode_#固定长度Unicode
数组信息
>>> a.shape#数组形状 几行几列
>>> len(a) #数组长度
>>> b.ndim #几维数组
>>> e.size#数组有多少元素
>>> b.dtype#数据类型
>>> b.dtype.name#数据类型的名字
>>> b.astype(int) #数据类型转换
调用帮助
>>> np.info(np.ndarray.dtype)
数组计算
算数运算
减法 减法 加法 加法 除法 除法 乘法 乘法 幂 平方根 正弦 余弦 自然对数 点积
>>> g = a - b array([[-0.5, 0. , 0. ], [-3. , -3. , -3. ]])>>>np.subtract(a,b)>>> b + a array([[ 2.5, 4. , 6. ], [ 5. , 7. , 9. ]])>>>np.add(b,a)>>> a / b array([[ 0.66666667, 1. , 1. ], [ 0.25 , 0.4 , 0.5]])>>>np.divide(a,b)>>> a * b array([[ 1.5, 4. , 9. ], [ 4. , 10. , 18. ]])>>>np.multiply(a,b)>>>np.exp(b)>>>np.sqrt(b)>>>np.sin(a)>>>np.cos(b)>>>np.log(a)>>>e.dot(f)
array([[7., 7.], [ 7., 7.]])
比较
>>> a == b array([[False, True, True], [False, False, False]], dtype=bool)#对比值
>>> a < 2 array([True, False, False], dtype=bool)#对比值
>>> np.array_equal(a, b) #对比数组
聚合函数
>>> a.sum()#数组汇总
>>> a.min()#数组最小值
>>> b.max(axis=0)#数组最大值
>>> b.cumsum(axis=1)#按行 数组元素的累加值
>>> a.mean()#平均数
>>> b.median()#中位数
>>> a.corrcoef()#相关系数
>>> np.std(b)#标准差
数组复制
>>> h = a.view()#使用同一数据创建数组视图
>>> np.copy(a)#创建数组的副本
>>> h = a.copy() #创建数组的深度拷贝
数组排序
>>> a.sort()#数组排序
>>> c.sort(axis=0) #以轴为依据对数组排序
子集、切片、 索引
a:
b：
子集
>>> a[2]# 选择索引2对应的值
3
>>>b[1,2]#选择行1列2对应的值(等同于b[1][2]
6.0
切片
>>> a[0:2] #选择索引为0与1对应的值
array([1, 2])>>> b[0:2,1]#选择第1列中第0行、第1行的值
array([2., 5.])>>> b[:1]#选择第0行的所有值(等同于b[0:1,:1]
array([[1.5, 2., 3.]])>>> c[1,...]#等同于 [1,:,:]
array([[[3., 2., 1.], [ 4., 5., 6.]]])>>> a[ : :-1]#反转数组a
array([3, 2, 1])
条件索引
>>> a[a<2]#选择数组a中所有小于2的值
array([1])
花式索引
>>> b[[1, 0, 1, 0],[0, 1, 2, 0]]#选择(1,0),(0,1),(1,2) 和(0,0)所对应的值
array([4. , 2. , 6. , 1.5])>>> b[[1, 0, 1, 0]][:,[0,1,2,0]]#选择矩阵的行列子集
array([[4. ,5. , 6. , 4. ], [ 1.5, 2. , 3. , 1.5], [ 4. , 5. , 6. , 4. ], [ 1.5, 2. , 3. , 1.5]])
数组操作
转置数组
>>> i = np.transpose(b)#转置数组
>>> i.T#转置数组
改变数组形状
>>> b.ravel()#拉平数组
>>> g.reshape(3,-2)#改变数组形状，但不改变数据
添加或删除值
>>> h.resize((2,6))#返回形状为(2,6)的新数组
>>> np.append(h,g)#追加数据
>>> np.insert(a, 1, 5)#插入数据
>>> np.delete(a,[1])#删除数据
合并数组
>>> np.concatenate((a,d),axis=0)#拼接数组
array([1, 2, 3, 10, 15, 20])>>> np.vstack((a,b))#纵向以行的维度堆叠数组
array([[1. , 2. , 3. ], [ 1.5, 2. , 3. ], [ 4. , 5. , 6. ]])>>> np.r_[e,f]#纵向以行的维度堆叠数组
>>> np.hstack((e,f))#横向以列的维度堆叠数组
array([[7., 7., 1., 0.], [ 7., 7., 0., 1.]])>>> np.column_stack((a,d))#以列的维度创建堆叠数组
array([[1, 10], [ 2, 15], [ 3, 20]])>>> np.c_[a,d] #以列的维度创建堆叠数组
分割数组
>>> np.hsplit(a,3)#纵向分割数组为3等份
[array([1]),array([2]),array([3])]>>> np.vsplit(c,2) #横向分割数组为2等份
[array([[[1.5, 2. , 1. ], [ 4. , 5. , 6. ]]]), array([[[ 3., 2., 3.], [ 4., 5., 6.]]])]
ndarray的随机创建
通过随机抽样 (numpy.random) 生成随机数据。
示例代码：
#导入numpy，别名np
importnumpy as np#生成指定维度大小(3行4列)的随机多维浮点型数据(二维)，rand固定区间0.0 ~ 1.0
arr = np.random.rand(3, 4)print(arr)print(type(arr))#生成指定维度大小(3行4列)的随机多维整型数据(二维)，randint()可以指定区间(-1, 5)
arr = np.random.randint(-1, 5, size = (3, 4)) #'size='可省略
print(arr)print(type(arr))#生成指定维度大小(3行4列)的随机多维浮点型数据(二维)，uniform()可以指定区间(-1, 5)
arr = np.random.uniform(-1, 5, size = (3, 4)) #'size='可省略
print(arr)print(type(arr))print('维度个数:', arr.ndim)print('维度大小:', arr.shape)print('数据类型:', arr.dtype)
运行结果：
[[ 0.09371338 0.06273976 0.22748452 0.49557778]
[ 0.30840042 0.35659161 0.54995724 0.018144 ]
[ 0.94551493 0.70916088 0.58877255 0.90435672]]
[[ 1 3 0 1]
[ 1 4 4 3]
[ 2 0 -1 -1]]
[[ 2.25275308 1.67484038 -0.03161878 -0.44635706]
[ 1.35459097 1.66294159 2.47419548 -0.51144655]
[ 1.43987571 4.71505054 4.33634358 2.48202309]]
维度个数: 2
维度大小: (3, 4)
数据类型: float64
ndarray的序列创建
np.array(collection)
collection 为 序列型对象(list)、嵌套序列对象(list of list)。
示例代码：
#list序列转换为 ndarray
lis = range(10)
arr=np.array(lis)print(arr) #ndarray数据
print(arr.ndim) #维度个数
print(arr.shape) #维度大小
#list of list嵌套序列转换为ndarray
lis_lis = [range(10), range(10)]
arr=np.array(lis_lis)print(arr) #ndarray数据
print(arr.ndim) #维度个数
print(arr.shape) #维度大小
运行结果：
# list序列转换为 ndarray
[0 1 2 3 4 5 6 7 8 9]
1
(10,)
# list of list嵌套序列转换为 ndarray
[[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]]
2
(2, 10)
np.zeros()
指定大小的全0数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。
np.ones()
指定大小的全1数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。
np.empty()
初始化数组，不是总是返回全0，有时返回的是未初始的随机值(内存里的随机值)。
示例代码：
#np.zeros
zeros_arr = np.zeros((3, 4))#np.ones
ones_arr = np.ones((2, 3))#np.empty
empty_arr = np.empty((3, 3))#np.empty 指定数据类型
empty_int_arr = np.empty((3, 3), int)print('------zeros_arr-------')print(zeros_arr)print('\n------ones_arr-------')print(ones_arr)print('\n------empty_arr-------')print(empty_arr)print('\n------empty_int_arr-------')print(empty_int_arr)
运行结果：
------zeros_arr-------
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
------ones_arr-------
[[ 1. 1. 1.]
[ 1. 1. 1.]]
------empty_arr-------
[[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]]
------empty_int_arr-------
[[0 0 0]
[0 0 0]
[0 0 0]]
5. np.arange() 和 reshape()
arange() 类似 python 的 range() ，创建一个一维 ndarray 数组。
reshape() 将 重新调整数组的维数。
示例代码：
#np.arange()
arr = np.arange(15) #15个元素的 一维数组
print(arr)print(arr.reshape(3, 5)) #3x5个元素的 二维数组
print(arr.reshape(1, 3, 5)) #1x3x5个元素的 三维数组
运行结果：
[ 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]]
[[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]]
6. np.arange() 和 random.shuffle()
random.shuffle() 将打乱数组序列(类似于洗牌)。
示例代码：
arr = np.arange(15)print(arr)
np.random.shuffle(arr)print(arr)print(arr.reshape(3,5))
运行结果：
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
[ 5 8 1 7 4 0 12 9 11 2 13 14 10 3 6]
[[ 5 8 1 7 4]
[ 0 12 9 11 2]
[13 14 10 3 6]]
ndarray的数据类型
1. dtype参数
指定数组的数据类型，类型名+位数，如float64, int32
2. astype方法
转换数组的数据类型
示例代码(1、2)：
#初始化3行4列数组，数据类型为float64
zeros_float_arr = np.zeros((3, 4), dtype=np.float64)print(zeros_float_arr)print(zeros_float_arr.dtype)#astype转换数据类型，将已有的数组的数据类型转换为int32
zeros_int_arr =zeros_float_arr.astype(np.int32)print(zeros_int_arr)print(zeros_int_arr.dtype)
运行结果：
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
float64
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
int32
ndarray的矩阵运算
数组是编程中的概念，矩阵、矢量是数学概念。
在计算机编程中，矩阵可以用数组形式定义，矢量可以用结构定义!
1. 矢量运算：相同大小的数组间运算应用在元素上
#矢量与矢量运算
arr = np.array([[1, 2, 3],
[4, 5, 6]])print("元素相乘：")print(arr *arr)print("矩阵相加：")print(arr + arr)
运行结果：
元素相乘：
[[ 1 4 9]
[16 25 36]]
矩阵相加：
[[ 2 4 6]
[ 8 10 12]]
2. 矢量和标量运算："广播" - 将标量"广播"到各个元素
#矢量与标量运算
print(1. /arr)print(2. * arr)
运行结果：
[[ 1. 0.5 0.33333333]
[ 0.25 0.2 0.16666667]]
[[ 2. 4. 6.]
[ 8. 10. 12.]]
ndarray的索引与切片
1. 一维数组的索引与切片
与Python的列表索引功能相似
#一维数组
arr1 = np.arange(10)print(arr1)print(arr1[2:5])
运行结果：
[0 1 2 3 4 5 6 7 8 9]
[2 3 4]
2. 多维数组的索引与切片：
arr[r1:r2, c1:c2]
arr[1,1] 等价 arr[1][1]
[:] 代表某个维度的数据
#多维数组
arr2 = np.arange(12).reshape(3,4)print(arr2)print(arr2[1])print(arr2[0:2, 2:])print(arr2[:, 1:3])
运行结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[4 5 6 7]
[[2 3]
[6 7]]
[[ 1 2]
[ 5 6]
[ 9 10]]
3. 条件索引
布尔值多维数组：arr[condition]，condition也可以是多个条件组合。
注意，多个条件组合要使用 & | 连接，而不是Python的 and or。
#条件索引
#找出 data_arr 中 2005年后的数据
data_arr = np.random.rand(3,3)print(data_arr)
year_arr= np.array([[2000, 2001, 2000],
[2005, 2002, 2009],
[2001, 2003, 2010]])
is_year_after_2005= year_arr >= 2005
print(is_year_after_2005, is_year_after_2005.dtype)
filtered_arr=data_arr[is_year_after_2005]print(filtered_arr)#filtered_arr = data_arr[year_arr >= 2005]#print(filtered_arr)
#多个条件
filtered_arr = data_arr[(year_arr <= 2005) & (year_arr % 2 ==0)]print(filtered_arr)
运行结果：
[[ 0.53514038 0.93893429 0.1087513 ]
[ 0.32076215 0.39820313 0.89765765]
[ 0.6572177 0.71284822 0.15108756]]
[[False False False]
[ True False True]
[False False True]] bool
[ 0.32076215 0.89765765 0.15108756]
[ 0.32076215 0.89765765 0.15108756]
[ 0.53514038 0.1087513 0.39820313]
ndarray的维数转换
二维数组直接使用转换函数：transpose()
高维数组转换要指定维度编号参数 (0, 1, 2, …)，注意参数是元组
arr = np.random.rand(2,3) #2x3 数组
print(arr)print(arr.transpose()) #转换为 3x2 数组
arr3d= np.random.rand(2,3,4) #2x3x4 数组，2对应0，3对应1，4对应3
print(arr3d)print(arr3d.transpose((1,0,2))) #根据维度编号，转为为 3x2x4 数组
运行结果：
# 二维数组转换
# 转换前：
[[ 0.50020075 0.88897914 0.18656499]
[ 0.32765696 0.94564495 0.16549632]]
# 转换后：
[[ 0.50020075 0.32765696]
[ 0.88897914 0.94564495]
[ 0.18656499 0.16549632]]
# 高维数组转换
# 转换前：
[[[ 0.91281153 0.61213743 0.16214062 0.73380458]
[ 0.45539155 0.04232412 0.82857746 0.35097793]
[ 0.70418988 0.78075814 0.70963972 0.63774692]]
[[ 0.17772347 0.64875514 0.48422954 0.86919646]
[ 0.92771033 0.51518773 0.82679073 0.18469917]
[ 0.37260457 0.49041953 0.96221477 0.16300198]]]
# 转换后：
[[[ 0.91281153 0.61213743 0.16214062 0.73380458]
[ 0.17772347 0.64875514 0.48422954 0.86919646]]
[[ 0.45539155 0.04232412 0.82857746 0.35097793]
[ 0.92771033 0.51518773 0.82679073 0.18469917]]
[[ 0.70418988 0.78075814 0.70963972 0.63774692]
[ 0.37260457 0.49041953 0.96221477 0.16300198]]]
元素计算函数
ceil(): 向上最接近的整数，参数是 number 或 array
floor(): 向下最接近的整数，参数是 number 或 array
rint(): 四舍五入，参数是 number 或 array
isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
multiply(): 元素相乘，参数是 number 或 array
divide(): 元素相除，参数是 number 或 array
abs()：元素的绝对值，参数是 number 或 array
where(condition, x, y): 三元运算符，x if condition else y
#randn() 返回具有标准正态分布的序列。
arr = np.random.randn(2,3)print(arr)print(np.ceil(arr))print(np.floor(arr))print(np.rint(arr))print(np.isnan(arr))print(np.multiply(arr, arr))print(np.divide(arr, arr))print(np.where(arr > 0, 1, -1))
运行结果：
# print(arr)
[[-0.75803752 0.0314314 1.15323032]
[ 1.17567832 0.43641395 0.26288021]]
# print(np.ceil(arr))
[[-0. 1. 2.]
[ 2. 1. 1.]]
# print(np.floor(arr))
[[-1. 0. 1.]
[ 1. 0. 0.]]
# print(np.rint(arr))
[[-1. 0. 1.]
[ 1. 0. 0.]]
# print(np.isnan(arr))
[[False False False]
[False False False]]
# print(np.multiply(arr, arr))
[[ 5.16284053e+00 1.77170104e+00 3.04027254e-02]
[ 5.11465231e-03 3.46109263e+00 1.37512421e-02]]
# print(np.divide(arr, arr))
[[ 1. 1. 1.]
[ 1. 1. 1.]]
# print(np.where(arr > 0, 1, -1))
[[ 1 1 -1]
[-1 1 1]]
元素统计函数
np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array
np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array
np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array
多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。
arr = np.arange(12).reshape(3,4)print(arr)print(np.cumsum(arr)) #返回一个一维数组，每个元素都是之前所有元素的 累加和
print(np.sum(arr)) #所有元素的和
print(np.sum(arr, axis=0)) #数组的按列统计和
print(np.sum(arr, axis=1)) #数组的按行统计和
运行结果：
# print(arr)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
# print(np.cumsum(arr))
[ 0 1 3 6 10 15 21 28 36 45 55 66]
# print(np.sum(arr)) # 所有元素的和
66
# print(np.sum(arr, axis=0)) # 0表示对数组的每一列的统计和
[12 15 18 21]
# print(np.sum(arr, axis=1)) # 1表示数组的每一行的统计和
[ 6 22 38]
元素判断函数
np.any(): 至少有一个元素满足指定条件，返回True
np.all(): 所有的元素满足指定条件，返回True
arr = np.random.randn(2,3)print(arr)print(np.any(arr >0))print(np.all(arr > 0))
运行结果：
[[ 0.05075769 -1.31919688 -1.80636984]
[-1.29317016 -1.3336612 -0.19316432]]
True
False
元素去重排序函数
np.unique():找到唯一值并返回排序结果，类似于Python的set集合
arr = np.array([[1, 2, 1], [2, 3, 4]])print(arr)print(np.unique(arr))
运行结果：
[[1 2 1]
[2 3 4]]
[1 2 3 4]
最后补充一个库Scipy
Scipy ：基于Numpy提供了一个在Python中做科学计算的工具集，专为科学和工程设计的Python工具包。主要应用于统计、优化、整合、线性代数模块、傅里叶变换、信号和图像处理、常微分方程求解、稀疏矩阵等，在数学系或者工程系相对用的多一些，和数据处理的关系不大， 我们知道即可，这里不做讲解。
在NumPy库的基础上增加了众多的数学、科学及工程常用的库函数
线性代数、常微分方程求解、信号处理、图像处理
一般的数据处理numpy已经够用
import scipy as sp
3289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
