Python开源科学计算工具包——NumPy
- NumPy(Numerical Python)
- 一、NumPy概述
- NumPy安装
- Numpy导入
- 二、ndarray(N Dimension Array)多维数组
- 2.1 ndarray的随机创建
- 2.2 ndarray的序列创建
- 1. np.array(collection)
- 2. np.zeros()
- 3. np.ones()
- 4. np.empty()
- 5. np.arange() 和 reshape()
- 6. random.shuffle()
- 2.3 ndarray的数据类型
- 1 dtype参数
- 2 astype方法
- 2.4 ndarray的矩阵运算
- 1. 矢量运算
- 2. 矢量和标量运算：
- 2.5 ndarray的索引与切片
- 1. 一维数组的索引与切片
- 2. 多维数组的索引与切片
- 3. 条件索引
- 2.6 ndarray数组的堆叠和拆分
- 1. np.hstack()
- 2. np.vstack()
- 3. np.concatenate()
- 4. np.vsplit(arr, num)
- 5. np.vhsplit(arr, num)
- 2.7 ndarray的维数转换
- 1. 转换函数transpose()
- 三、NumPy元素处理函数
- 3.1 元素计算函数
- 3.2 元素统计函数
- 3.3 元素判断函数
- 3.4 元素去重排序函数
- 四、NumPy的输入输出
NumPy(Numerical Python)
一、NumPy概述
Numpy：提供了一个在Python中做科学计算的基础库，重在数值计算，主要用于多维数组（矩阵）处理的库。用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多。本身是由C语言开发，是个很基础的扩展，Python其余的科学计算扩展大部分都是以此为基础，并且具有如下的特点：
- 高性能科学计算和数据分析的基础包
- ndarray，多维数组（矩阵），具有矢量运算能力，快速、节省空间
- 矩阵运算，无需循环，可完成类似Matlab中的矢量运算
- 线性代数、随机数生成
NumPy安装
pip install numpy建议使用镜像源安装
pip install numpy -i http://pypi.douban.com/simpleNumpy导入
import numpy as np二、ndarray(N Dimension Array)多维数组
NumPy数组是一个多维的数组对象（矩阵），称为ndarray，具有矢量算术运算能力和复杂的广播能力，并具有执行速度快和节省空间的特点。
注意：ndarray的下标从0开始，且数组里的所有元素必须是相同类型
ndarray拥有的属性:
- ndim属性：维度个数
- shape属性：维度大小
- dtype属性：数据类型
2.1 ndarray的随机创建
通过随机抽样 (numpy.random) 生成随机数据。
示例代码：
# 导入numpy，常用别名np
import numpy 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))
# 查看ndarray数组的三个属性
print('维度个数: ', arr.ndim)
print('维度大小: ', arr.shape)
print('数据类型: ', arr.dtype)运行结果：
[[0.20776543 0.05644036 0.82344846 0.12190856]
[0.17839012 0.11031226 0.21898422 0.86373933]
[0.71846769 0.75067335 0.02772548 0.12501256]]
<class 'numpy.ndarray'>
[[ 2 -1 -1 -1]
[ 3 3 3 4]
[ 2 4 2 1]]
<class 'numpy.ndarray'>
[[ 2.82766538 0.49051349 1.53284559 3.71549299]
[ 4.13903504 0.80369036 2.39538575 1.83586258]
[-0.61540369 3.77059577 3.40745296 2.66228213]]
<class 'numpy.ndarray'>
维度个数: 2
维度大小: (3, 4)
数据类型: float642.2 ndarray的序列创建
1. 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)2. np.zeros()
指定大小的全0数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。
3. np.ones()
指定大小的全1数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。
4. np.empty()
初始化数组，不是总是返回全0，有时返回的是未初始的随机值（内存里的随机值）。
示例代码（2、3、4）：
# 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() 将 重新调整数组的维数。
示例代码（5）：
# 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. random.shuffle()
random.shuffle() 将打乱数组序列（类似于洗牌）。
示例代码（6）：
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]]2.3 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]]
int322.4 ndarray的矩阵运算
数组是编程中的概念，矩阵、矢量是数学概念。
在计算机编程中，矩阵可以用数组形式定义，矢量可以用结构定义!
1. 矢量运算
相同大小的数组间运算应用在元素上
示例代码（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. 矢量和标量运算：
运用"广播"特性 - 将标量"广播"到各个元素
示例代码（2）：
# 矢量与标量运算
print(1. / arr)
print(2. * arr)运行结果：
[[ 1. 0.5 0.33333333]
[ 0.25 0.2 0.16666667]]
[[ 2. 4. 6.]
[ 8. 10. 12.]]2.5 ndarray的索引与切片
1. 一维数组的索引与切片
与Python的列表索引功能相似
示例代码（1）：
# 一维数组
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]
[:] 代表某个维度的数据
示例代码（2）：
# 多维数组
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。
示例代码（3）：
# 条件索引
# 找出 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.23675142 0.76965556 0.70049116]
[0.96381477 0.73135583 0.92682762]
[0.67538759 0.20978428 0.98193949]]
[[False False False]
[ True False True]
[False False True]] bool
[0.96381477 0.92682762 0.98193949]
[0.23675142 0.70049116 0.73135583]2.6 ndarray数组的堆叠和拆分
1. np.hstack()
沿着水平方向将矩阵堆叠起来
2. np.vstack()
沿着竖直方向将矩阵堆叠起来
3. np.concatenate()
这个函数相当于np.hstack()和np.vstack()的扩展，指定axis实现维度的堆叠（默认axis=0）。
示例代码（1、2、3）
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a)
print(b)
print(np.vstack((a, b))) # 垂直方向堆叠
print(np.hstack((a, b))) # 水平方向堆叠
print(np.concatenate((a, b), axis=0)) # axis=0为垂直方向堆叠
print(np.concatenate((a, b), axis=1)) # axis=1为水平方向堆叠运行结果：
# print(a)
[[1 2 3]]
# print(b)
[[4 5 6]]
# print(np.vstack((a, b)))
[[1 2 3]
[4 5 6]]
# print(np.hstack((a, b)))
[[1 2 3 4 5 6]]
# print(np.concatenate((a, b), axis=0))
[[1 2 3]
[4 5 6]]
# print(np.concatenate((a, b), axis=01))
[[1 2 3 4 5 6]]4. np.vsplit(arr, num)
将数组arr沿垂直方向等分成num个数组
5. np.vhsplit(arr, num)
将数组arr沿水平方向等分成num个数组
示例代码（4、5）
arr = np.arange(16).reshape(4, 4)
print(arr)
print(np.vsplit(arr, 2)) # 垂直方向拆分
print(np.hsplit(arr, 2)) # 水平方向拆分运行结果：
# print(arr)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
# print(np.vsplit(arr, 2))
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
# print(np.hsplit(arr, 2))
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]2.7 ndarray的维数转换
1. 转换函数transpose()
二维数组直接使用转换函数：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]]]三、NumPy元素处理函数
3.1 元素计算函数
-
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
示例代码（1、2、3、4、5、6、7）：
# 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]]3.2 元素统计函数
-
np.mean(): 所有元素的平均值，参数是 number 或 array -
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]3.3 元素判断函数
-
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.39298953 -1.43424555 1.1257751 ]
[-0.54957431 1.59704483 -1.2902345 ]]
True
False3.4 元素去重排序函数
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]四、NumPy的输入输出
- np.save()
np.save(file, arr, allow_pickle=True, fix_imports=True)
解释：
以“.npy”格式将数组保存到二进制文件中。
参数：
file 要保存的文件名称，需指定文件保存路径，如果未设置，保存到默认路径。其文件拓展名为.npy
arr为需要保存的数组，也即把数组arr保存至名称为file的文件中。
- np.load()
np.load(file, mmap_mode=None, allow_pickle=False, fix_imports=True,encoding=‘ASCII’)
解释：
读取“.npy”和“.npyz”格式的数组
示例代码：
import os
# 导入numpy，别名np
import numpy as np
# 设置工作目录
os.chdir("D:/")
arr = np.random.rand(5, 5)
print(arr)
# 保存
np.save("test.npy", arr)
# 读取
arr_load = np.load("test.npy")
print(arr_load)运行结果：
# print(arr)
[[0.26227782 0.12979435 0.19547043 0.95373697 0.52018522]
[0.53634665 0.09585291 0.65016007 0.32308343 0.37570973]
[0.24178071 0.74988316 0.56192327 0.80809143 0.11936357]
[0.92303961 0.49556896 0.27234759 0.26546911 0.7319916 ]
[0.57394935 0.68830502 0.88637439 0.36367103 0.46749134]]
# print(arr_load)
[[0.26227782 0.12979435 0.19547043 0.95373697 0.52018522]
[0.53634665 0.09585291 0.65016007 0.32308343 0.37570973]
[0.24178071 0.74988316 0.56192327 0.80809143 0.11936357]
[0.92303961 0.49556896 0.27234759 0.26546911 0.7319916 ]
[0.57394935 0.68830502 0.88637439 0.36367103 0.46749134]]- np.savetxt() 和 np.loadtxt()
np.loadtxt和np.savetxt可以读写1维和2维数组的文本文件：
同时可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等。 —— 注意：只能处理 1维和2维数组。可以用于CSV格式文本文件 ——
np.savetxt(fname, X, fmt=’%.18e’, delimiter=’ ‘, newline=’\n’,
header=’’, footer=’’, comments=’# ‘, encoding=None) Docstring: Save an
array to a text file. ———— np.loadtxt(fname, dtype=<class ‘float’>,
comments=’#’, delimiter=None, converters=None, skiprows=0,
usecols=None, unpack=False, ndmin=0, encoding=‘bytes’, max_rows=None)
示例代码（3、4）：
# 设置工作目录
os.chdir("D:/")
arr = np.random.rand(5, 5)
print(arr)
# 保存
np.savetxt("save_test.txt", arr, delimiter=",")
# 读取
arr_load = np.loadtxt("save_test.txt")
print(arr_load)运行结果：
# print(arr)
[[0.16179526 0.13046954 0.49780349 0.23940531 0.09144103]
[0.44650955 0.40605901 0.64078346 0.37099027 0.85711949]
[0.21287174 0.99561607 0.73555747 0.39515148 0.58858826]
[0.91759668 0.63505903 0.17556816 0.02113077 0.38563622]
[0.89076388 0.0411067 0.2713734 0.94187858 0.13492434]]
# print(arr_load)
[[0.16 0.13 0.5 0.24 0.09]
[0.45 0.41 0.64 0.37 0.86]
[0.21 1. 0.74 0.4 0.59]
[0.92 0.64 0.18 0.02 0.39]
[0.89 0.04 0.27 0.94 0.13]]
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
