数学计算工具库-Numpy

Numpy（Numerical Python）

Numpy：提供了一个在Python中做科学计算的基础库，重在数值计算，主要用于多维数组（矩阵）处理的库。用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多。本身是由C语言开发，是个很基础的扩展，Python其余的科学计算扩展大部分都是以此为基础。

• 高性能科学计算和数据分析的基础包

• ndarray，多维数组（矩阵），具有矢量运算能力，快速、节省空间

• 矩阵运算，无需循环，可完成类似Matlab中的矢量运算

• 线性代数、随机数生成

• import numpy as np

Scipy

Scipy ：基于Numpy提供了一个在Python中做科学计算的工具集，专为科学和工程设计的Python工具包。主要应用于统计、优化、整合、线性代数模块、傅里叶变换、信号和图像处理、常微分方程求解、稀疏矩阵等，在数学系或者工程系相对用的多一些，和数据处理的关系不大， 我们知道即可，这里不做讲解。

• 在NumPy库的基础上增加了众多的数学、科学及工程常用的库函数

• 线性代数、常微分方程求解、信号处理、图像处理

• 一般的数据处理numpy已经够用

• import scipy as sp

---

 

ndarray 多维数组(N Dimension Array)

NumPy数组是一个多维的数组对象（矩阵），称为ndarray，具有矢量算术运算能力和复杂的广播能力，并具有执行速度快和节省空间的特点。

注意：ndarray的下标从0开始，且数组里的所有元素必须是相同类型

ndarray拥有的属性

1. ndim属性：维度个数
2. shape属性：维度大小
3. dtype属性：数据类型

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))

print('维度个数: ', arr.ndim)
print('维度大小: ', arr.shape)
print('数据类型: ', arr.dtype)

效果：

[[0.79504779 0.16123613 0.70996342 0.78046926]
 [0.65905115 0.95009793 0.35331166 0.75117232]
 [0.1457965  0.47664155 0.08532238 0.55371099]]
<class 'numpy.ndarray'>
[[ 1  0  0  4]
 [ 3  2  3  2]
 [ 0  1 -1  4]]
<class 'numpy.ndarray'>
[[ 3.3520979   4.36571846  2.13926496 -0.82483995]
 [ 0.36302781  4.02376606  1.9752519  -0.16793017]
 [ 0.04568178  3.31841901 -0.78181444  4.90897601]]
<class 'numpy.ndarray'>
维度个数:  2
维度大小:  (3, 4)
数据类型:  float64

ndarray的序列创建

1. np.array(collection)

collection 为 序列型对象(list)、嵌套序列对象(list of list)。

# list序列转换为 ndarray
import numpy as np

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)    # 维度大小

效果：

[0 1 2 3 4 5 6 7 8 9]
1
(10,)
[[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，有时返回的是未初始的随机值（内存里的随机值）。

# list序列转换为 ndarray
import numpy as np

# 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('
------ones_arr-------')
print(ones_arr)

print('
------empty_arr-------')
print(empty_arr)

print('
------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-------
[[-2.68156159e+154  1.29073764e-231  2.19484874e-314]
 [ 2.20090106e-314  2.20090631e-314  2.20090109e-314]
 [ 0.00000000e+000  0.00000000e+000  0.00000000e+000]]

------empty_int_arr-------
[[-2305843009213693952  4611694785890592072 -2305843009213693947]
 [ 8070459299711120806           4575920132           4575962608]
 [          4575975536           4575966032           4576021120]]

5. np.arange() 和 reshape()

arange() 类似 python 的 range() ，创建一个一维 ndarray 数组。

reshape() 将 重新调整数组的维数。

# list序列转换为 ndarray
import numpy as np

# np.arange()
arr = np.arange(15) # 15个元素的 一维数组
print('------arr-------')
print(arr)
print('------arr.reshape(3, 5)-------')
print(arr.reshape(3, 5)) # 3x5个元素的 二维数组
print('------arr.reshape(1, 3, 5)-------')
print(arr.reshape(1, 3, 5)) # 1x3x5个元素的 三维数组

效果：

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

6. np.arange() 和 random.shuffle()

random.shuffle() 将打乱数组序列（类似于洗牌）。

# list序列转换为 ndarray
import numpy as np

arr = np.arange(15)
print(arr)

np.random.shuffle(arr)
print(arr)
print("------")
print(arr.reshape(3,5))

效果：

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
[ 0 13  4  6  9  5  3  8 12  1 11  7 14 10  2]
------
[[ 0 13  4  6  9]
 [ 5  3  8 12  1]
 [11  7 14 10  2]]

ndarray的数据类型

1. dtype参数

指定数组的数据类型，类型名+位数，如float64, int32

2. astype方法

转换数组的数据类型

# list序列转换为 ndarray
import numpy as np

# 初始化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. 矢量运算：相同大小的数组间运算应用在元素上

import numpy as np

# 矢量与矢量运算
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. 矢量和标量运算："广播" - 将标量"广播"到各个元素

import numpy as np

# 矢量与矢量运算
arr = np.array([[1, 2, 3],
                [4, 5, 6]])


# 矢量与标量运算
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的列表索引功能相似

import numpy as np

# 一维数组
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]

[:] 代表某个维度的数据

import numpy as np

# 多维数组
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。

import numpy as np

# 条件索引

# 找出 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.98334856 0.63551066 0.29149196]
 [0.72503413 0.93842167 0.37301235]
 [0.9551573  0.14087825 0.25574944]]
[[False False False]
 [ True False  True]
 [False False  True]] bool
[0.72503413 0.37301235 0.25574944]
[0.98334856 0.29149196 0.93842167]

ndarray的维数转换

二维数组直接使用转换函数：transpose()

高维数组转换要指定维度编号参数 (0, 1, 2, …)，注意参数是元组

import numpy as np

arr = np.random.rand(2,3)    # 2x3 数组
print("转换前")
print(arr)
print("转换后")
print(arr.transpose()) # 转换为 3x2 数组


arr3d = np.random.rand(2,3,4) # 2x3x4 数组，2对应0，3对应1，4对应3
print("转换前")
print(arr3d)
print("转换后")
print(arr3d.transpose((1,0,2))) # 根据维度编号，转为为 3x2x4 数组

 

效果：

转换前
[[0.89524524 0.08353467 0.39123507]
 [0.88177968 0.97609575 0.3881562 ]]
转换后
[[0.89524524 0.88177968]
 [0.08353467 0.97609575]
 [0.39123507 0.3881562 ]]
转换前
[[[0.62153196 0.78681829 0.34988096 0.15066897]
  [0.08783996 0.76118557 0.36000474 0.12955172]
  [0.59389965 0.98384567 0.50790895 0.50955181]]

 [[0.36728472 0.02177603 0.74034979 0.52395055]
  [0.15123696 0.52766901 0.16023566 0.38975676]
  [0.86663207 0.12199002 0.91367068 0.07474323]]]
转换后
[[[0.62153196 0.78681829 0.34988096 0.15066897]
  [0.36728472 0.02177603 0.74034979 0.52395055]]

 [[0.08783996 0.76118557 0.36000474 0.12955172]
  [0.15123696 0.52766901 0.16023566 0.38975676]]

 [[0.59389965 0.98384567 0.50790895 0.50955181]
  [0.86663207 0.12199002 0.91367068 0.07474323]]]

ndarray的元素处理

元素计算函数

1. ceil(): 向上最接近的整数，参数是 number 或 array

2. floor(): 向下最接近的整数，参数是 number 或 array

3. rint(): 四舍五入，参数是 number 或 array
4. isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
5. multiply(): 元素相乘，参数是 number 或 array
6. divide(): 元素相除，参数是 number 或 array
7. abs()：元素的绝对值，参数是 number 或 array
8. where(condition, x, y): 三元运算符，x if condition else y

import numpy as np

# randn() 返回具有标准正态分布的序列。
arr = np.random.randn(2,3)
print("arr")
print(arr)
print("np.ceil")
print(np.ceil(arr))
print("np.floor")
print(np.floor(arr))
print("np.rint")
print(np.rint(arr))
print("np.isnan")
print(np.isnan(arr))
print("np.multiply")
print(np.multiply(arr, arr))
print("np.divide")
print(np.divide(arr, arr))
print("np.where")
print(np.where(arr > 0, 1, -1))

效果：

arr
[[-0.28099283  0.07128696 -1.2619215 ]
 [ 1.04315532 -0.68456104  1.04562554]]
np.ceil
[[-0.  1. -1.]
 [ 2. -0.  2.]]
np.floor
[[-1.  0. -2.]
 [ 1. -1.  1.]]
np.rint
[[-0.  0. -1.]
 [ 1. -1.  1.]]
np.isnan
[[False False False]
 [False False False]]
np.multiply
[[0.07895697 0.00508183 1.59244588]
 [1.08817303 0.46862382 1.09333277]]
np.divide
[[1. 1. 1.]
 [1. 1. 1.]]
np.where
[[-1  1 -1]
 [ 1 -1  1]]

元素统计函数

1. np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array

2. np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array

3. np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
4. np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
5. np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array
6. 多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。

import numpy as np

arr = np.arange(12).reshape(3, 4)
print("arr")
print(arr)
print("cumsum")
print(np.cumsum(arr))  # 返回一个一维数组，每个元素都是之前所有元素的 累加和
print("np.sum(arr)")
print(np.sum(arr))  # 所有元素的和
print("np.sum(arr, axis=0)")
print(np.sum(arr, axis=0))  # 数组的按列统计和
print("np.sum(arr, axis=1)")
print(np.sum(arr, axis=1))  # 数组的按行统计和

效果：

arr
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
cumsum
[ 0  1  3  6 10 15 21 28 36 45 55 66]
np.sum(arr)
66
np.sum(arr, axis=0)
[12 15 18 21]
np.sum(arr, axis=1)
[ 6 22 38]

元素判断函数

1. np.any(): 至少有一个元素满足指定条件，返回True
2. np.all(): 所有的元素满足指定条件，返回True

import numpy as np

arr = np.random.randn(2,3)
print(arr)

print(np.any(arr > 0))
print(np.all(arr > 0))

效果：

[[-1.08208833  0.46202246  0.04891938]
 [-0.73026743  0.78151862  0.51218528]]
True
False

元素去重排序函数

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

import numpy as np

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]