Numpy基础知识
一、Numpy简介
NumPy（Numeric Python）是一个用python实现的科学计算的扩展程序库，提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。NumPy是一个功能强大的Python库，主要用于对多维数组执行计算。NumPy这个词来源于两个单词– Numerical和Python。NumPy提供了许多高级的数值计算工具，如：矩阵数据类型、矢量处理，以及精密的运算库，可以轻松地进行数值计算。
二、Numpy数组计算基础
1、array函数的用法
| 参数 | 说明 |
| object | 创建的数组对象 |
| dtype | dtype指定数组元素的数据类型 |
| ndmin | ndmin指定生成几维数组 |
1.1.1 利用Numpy提供的array函数创建数组对象(object)
import numpy as np # 导入模块包
arr = np.array([]) # 创建空数组
arr1 = np.array([1, 2, 3, 4, 5]) # 利用array函数创建一维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]]) # 创建二维数组1.1.2 指定数组元素的数据类型(dtype)
arr1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=float)
arr2 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], dtype=bool)
arr3 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=complex)print("dtype指定数组元素的数据类型为浮点类型", arr1) # [1. 2. 3. 4. 5. 6. 7. 8. 9.]
print("dtype指定数组元素的数据类型为bool类型", arr2) # [ True True True True True True True True True False]
print("dtype指定数组元素的数据类型为复数类型", arr3) # [1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j 6.+0.j 7.+0.j 8.+0.j 9.+0.j]
1.1.3 指定数组元素的维数(ndmin)
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], ndmin=3)
print("ndmin值为1，指定生成一维数组", arr) # [1 2 3 4 5 6 7 8 9]
print("ndmin值为2，指定生成二维数组", arr) # [[1 2 3 4 5 6 7 8 9]]
print("ndmin值为3，指定生成三维数组", arr) # [[[1 2 3 4 5 6 7 8 9]]]
| 属性 | 说明 |
| ndim | 返回int，表示数组的维度 |
| shape | 返回元组，表示数组形状 |
| size | 返回int，表示数组中的元素总数 |
| dtype | 返回data-type，表示数组中元素的数据类型 |
| itemsize | 返回int，表示数组中每个元素的储存空间(单位bite) |
1.2.1 shape用于查看数组形状,结果用元组的形式表示
空的显示(0, ) 一维表示 (元素个数，) 二维表示(行, 列)
print(arr.shape) # (0,)
print(arr1.shape) # (5,)
print(arr2.shape) # (2, 3)1.2.2 shape 重新设置数组的shape属性
arr2.shape = 3, 2 # 把arr2 改成 3行2列数组
[[1, 2],[3, 4],[5, 6]]1.2.3 dtypt 查看数组元素类型
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("dtype查看数组元素的类型", arr.dtype) # int1.2.4 size 查看数组中的元素个数
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("查看数组个数", arr.size) # 61.2.5 itemsize查看数组元素的储存空间
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("查看数组元素的储存空间", arr.itemsize) # 42、arange函数的用法
说明: 通过指定开始值、终值和步长来创建一维数组，创建的数组不包含终值
| 参数 | 说明 |
|---|---|
| start | 开始值，默认为0 |
| stop | 终值，生成的数组不包括该值 |
| step | 步长 |
| dtype | 指定输出的数据类型，默认为None |
2.1、arange函数创建数组
# arange函数的参数(start, stop, step, dtype)
arr = np.arange(0, 10, 2, dtype=int) # 包首不包尾
print(arr)
[0 2 4 6 8]3、linspace函数创建等差数列数组
| start | 开始值，无默认值 |
| stop | 终值，生成的数组，包括该值，无默认值 |
| num | 生成样本数，默认50个 |
| dtype | 指定输出的数据类型，默认为None |
# linspace函数的参数(start, stop, num, dtype)
arr1 = np.linspace(0, 10, 6, dtype=int) # 包头包尾 等差数列
print(arr1) # [ 0 2 4 6 8 10]4、logspace函数创建等比数列数组
| 参数 | 说明 |
|---|---|
| start | base ** start 指数 起始值 |
| end | base ** end 指数 终值 |
| num | 指定指数起始值到终值分成多少份， 默认 50 |
| endpoint | 布尔值，包不包括终值 |
| base | 默认 10.0，指定底数 |
| dtype | 指定输出类型 |
| axis | 用于储存样本的轴，默认为0 |
arrr = np.logspace(1, 5, num=5, endpoint=True, base=10.0, dtype=int, axis=0)
print(arrr)
底数为 10 , 生成五个 指数为1-5的等比数列, 类型为int
[ 10 100 1000 10000 100000]arrr = np.logspace(0, 4, num=5, endpoint=True, base=2, dtype=int, axis=0)
print(arrr)
[ 1 2 4 8 16]5、zeros函数创建元素都为0的数组
print("使用zeros创建 几行几列 元素全为0数组:\n", np.zeros((3, 4)))
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]6、eye函数创建单位矩阵
print("使用eye创建 (单位矩阵) 数组 :\n", np.eye((3)))
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]7、diag函数创建对角矩阵
print("使用diag创建 对角矩阵 数组 :\n", np.diag([1, 2, 3, 4]))
[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]8、ones函数创建数组
print("使用ones创建 五行五列全为1 的数组 :\n", np.ones((5, 3)))
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]9、生成随机数
对于Numpy 来说 与随机数相关的函数都在random模块中, 其中可以生成服从多种概率分布的随机数函数
9.1、使用random函数生成随机数
参数为整数，返回随机浮点数个数
import numpy as np
print('生成0-1、10个随机数', np.random.random(10))
# [0.10987808 ,0.46744674, 0.17708785, 0.30340278, 0.69318883 ,0.38080395 ,0.97276299 ,0.44607394 ,0.20992605 ,0.1303952 ]9.2、使用rand函数生成服从均匀分布的随机数
np.random.randn(d0,d1,d2……dn)
1) 当函数括号内没有参数时，则返回一个浮点数；
2）当函数括号内有一个参数时，则返回秩为1的数组，不能表示向量和矩阵；
3）当函数括号内有两个及以上参数时，则返回对应维度的数组，能表示向量或矩阵；
# rand函数可以随机生成服从均匀分布的随机数
print('生成2行2列服从均匀分布的随机数', np.random.rand(2, 2))
# [[0.39393012 0.52005315]
# [0.96116509 0.41460862]]9.3、使用randn 函数生成服从正态分布的随机数(参数和rand类似)
# 使用randn 函数生成服从正态分布的随机数
print('生成2行2列服从正态分布的随机数', np.random.randn(2, 2))
# [[0.51936168 - 0.85725725]
# [0.02650592 - 0.12556538]]9.4、使用randint 函数生成给定范围的随机数
randint(最小值, 最大值, 几行几列的数组)
print('生成2行2列给定范围的随机数', np.random.randint(2, 10, size=[2, 5]))
# [[5 6 8 2 2]
# [7 2 8 9 6]]10、变换数组的形状
10.1、使用reshape函数改变数组形状
arr = np.arange(0, 10)
print("将一维数组改成2行2列", arr.reshape(2, 5))
# [[0 1 2 3 4]
# [5 6 7 8 9]]10.2、使用ravel, flatten函数展平数组
arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
newArr = np.array(arr)
# ravel 展平数组
print(newArr.ravel())
# [1 2 3 4 5 6 7 8 9]
# flatten 展平数组
# 它可以横向展品和纵向展品
print('数组横向展平', newArr.flatten())
print('数组纵向展平', newArr.flatten('F'))10.3、使用hstack、vstack、concatenate 组合数组
concatenate(数组1, 数组2，axis=0或者1)
参数axis=1 时 可以对数组进行横向组合
参数axis=0 时 可以对数组进行纵向组合
# 使用hstack 函数实现数组横向组合
arr2 = np.arange(12).reshape(3, 4)
arr3 = np.arange(12, 24).reshape(3, 4)
print(arr2, arr3)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]
print('使用hstack 函数实现数组横向组合', np.hstack((arr3, arr2)))
# [[12 13 14 15 0 1 2 3]
# [16 17 18 19 4 5 6 7]
# [20 21 22 23 8 9 10 11]]
print('使用vstack 函数实现数组纵向组合', np.vstack((arr3, arr2)))
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]
# [ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 使用 concatenate 函数组合数组
print('使用concatenate 函数实现数组横向组合', np.concatenate((arr3, arr2), axis=1))
# [[12 13 14 15 0 1 2 3]
# [16 17 18 19 4 5 6 7]
# [20 21 22 23 8 9 10 11]]
print('使用concatenate 函数实现数组纵向组合', np.concatenate((arr3, arr2), axis=0))
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]
# [ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]10.3、使用hsplit、vsplit、split函数分割数组
split(数组1, 分割的份数，axis=0或者1)
参数axis=1 时 可以对数组进行横向分割
参数axis=0 时 可以对数组进行纵向分割
# 使用hsplit vsplit split 函数进行数组分割
print(arr2)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
print('使用 hsplit 函数实现数组横向分割', np.hsplit(arr2, 4 ))
# [array([[0],[4],[8]]), array([[1],[5],[9]]), array([[ 2],[ 6],[10]]), array([[ 3],[ 7],[11]])]
print('使用 vsplit 函数实现数组纵向分割', np.vsplit(arr2, 3 ))
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
print('使用 split 函数实现数组 纵向 分割', np.split(arr2, 3 , axis=0))
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
print('使用 split 函数实现数组 横向 分割', np.split(arr2, 2, axis=1))
# [array([[0, 1],[4, 5],[8, 9]]), array([[2, 3],[6, 7],[10, 11]])]三、创建Numpy 矩阵
在NumPy中，矩阵（Matrix）是二维的特殊数组对象，它具有特定的数学和线性代数属性。NumPy中的矩阵可以通过
numpy.matrix 、mat、bmat类来创建，也可以使用二维NumPy数组来表示。以下是一些关于NumPy矩阵的特点和功能：
二维结构：NumPy矩阵是二维的，具有行和列的结构。可以通过行号和列号来访问和操作矩阵中的元素。
矩阵运算：NumPy提供了许多用于矩阵运算的函数和方法，如矩阵乘法、逆矩阵、转置、行列式等。这些操作可以方便地应用于NumPy矩阵对象。
线性代数功能：NumPy的矩阵对象具有丰富的线性代数功能，包括求解线性方程组、特征值和特征向量计算、奇异值分解等。
简化的语法：NumPy矩阵对象提供了一些简化的语法，使得矩阵运算更加直观和易读。例如，可以使用
*运算符进行矩阵乘法，使用**运算符进行矩阵的幂运算。切片和索引：与NumPy数组一样，可以使用切片和索引操作来访问和修改矩阵中的元素。可以通过行号和列号进行切片操作，或者使用布尔索引进行条件筛选。
数值计算：与NumPy数组一样，NumPy矩阵对象可以应用各种数值计算和统计函数，如求和、平均值、标准差等。
创建矩阵
# 使用mat 创建矩阵
Mat = np.mat('1 2 3; 4 5 6; 7 8 9') # 使用分号隔开数据
print(Mat)
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# 使用 matrix 创建矩阵 直接传入二维数组
Matrix = np.matrix([[1,2,3], [4,5,6], [7,8,9]]) #
print(Matrix)
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# 使用 bmat 函数创建分块矩阵
arr1 = np.eye(3)
print(arr1)
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
arr2 = np.diag([1,2,3])
print(arr2)
# [[1 0 0]
# [0 2 0]
# [0 0 3]]
print("创建的矩阵为\n", np.bmat('arr1 arr2'))
# [[1. 0. 0. 1. 0. 0.]
# [0. 1. 0. 0. 2. 0.]
# [0. 0. 1. 0. 0. 3.]]
print("创建的矩阵为\n", np.bmat('arr1 arr2; arr1 arr2'))
# [[1. 0. 0. 1. 0. 0.]
# [0. 1. 0. 0. 2. 0.]
# [0. 0. 1. 0. 0. 3.]
# [1. 0. 0. 1. 0. 0.]
# [0. 1. 0. 0. 2. 0.]
# [0. 0. 1. 0. 0. 3.]]矩阵的运算
# 矩阵运算
# 矩阵相乘
mat1 = np.mat('1 2 3; 4 5 6; 7 8 9') # 使用分号隔开数据
mat2 = np.matrix([[1,2,3], [4,5,6], [7,8,9]])
mutiply= mat1 * mat2
print(mutiply)
# [[ 30 36 42]
# [ 66 81 96]
# [102 126 150]]
# 矩阵相加
add = mat1 + mat2
print(add)
# [[ 2 4 6]
# [ 8 10 12]
# [14 16 18]]
# 矩阵相减
subtraction = mat1 - mat2
print(subtraction)
# 转置矩阵
print(mat1)
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
print(mat1.T)
# [[1 4 7]
# [2 5 8]
# [3 6 9]]
# 共轭矩阵
print(mat1)
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
print(mat1.H)
# [[1 4 7]
# [2 5 8]
# [3 6 9]]四、ufunc 函数
ufunc（Universal Function）是NumPy中的一种函数，用于对数组进行逐元素操作的通用函数。ufunc函数可以对数组的每个元素进行相同的操作，支持各种数学运算、逻辑运算和其他操作。
逐元素操作：ufunc函数对数组的每个元素进行操作，而不需要显式使用循环。这使得对大规模数组进行高效的向量化操作成为可能。
数学运算：ufunc函数支持各种数学运算，如加法、减法、乘法、除法、取余、指数、对数等。例如，
numpy.add是一个ufunc函数，用于执行两个数组的逐元素加法操作。逻辑运算：ufunc函数支持逻辑运算，如与（
numpy.logical_and）、或（numpy.logical_or）、非（numpy.logical_not）等。这些函数可以应用于布尔类型的数组。位运算：ufunc函数支持位运算，如与（
numpy.bitwise_and）、或（numpy.bitwise_or）、异或（numpy.bitwise_xor）等。这些函数可以应用于整数类型的数组。比较操作：ufunc函数支持比较操作，如大于（
numpy.greater）、小于（numpy.less）、等于（numpy.equal）、不等于（numpy.not_equal）等。这些函数可以应用于各种数据类型的数组。形状广播：ufunc函数支持形状广播（broadcasting），即在进行逐元素操作时自动调整数组的形状，使得操作能够在不同形状的数组上进行。
自定义ufunc函数：除了NumPy提供的内置ufunc函数，还可以自定义ufunc函数来执行特定的操作。通过使用
numpy.vectorize装饰器或numpy.frompyfunc函数，可以将自定义函数转换为ufunc函数。
# 数组的运算
arr1 = np.array([1,2,3,4])
arr2 = np.array([5,6,7,8])
print('数组相加', arr1 + arr2)
# 数组相加 [ 6 8 10 12]
print('数组相乘', arr1 * arr2)
# 数组相乘 [ 5 12 21 32]
print('数组相除', arr1 / arr2)
# 数组相除 [0.2 0.33333333 0.42857143 0.5 ]
print('数组相减', arr1 - arr2)
# 数组相减 [-4 -4 -4 -4]
# 数组的比较运算
print(arr1>arr2)
# [False False False False]
print(arr1=arr2)
# False False False False]
print(arr1!=arr2)
# [ True True True True]
# 数组的逻辑运算
print(np.all(arr1 == arr2))
# False
print(np.any(arr1 == arr2))
# False ufunc函数支持形状广播（broadcasting），即在进行逐元素操作时自动调整数组的形状，使得操作能够在不同形状的数组上进行
arr1 = np.array([1 , 2, 3])
arr2 = np.array([1])
print(arr1 + arr2)
# [2 3 4]
arr1 = np.arange(0, 9).reshape(3, 3)
print(arr1)
# [[0 1 2]
# [3 4 5]
# [6 7 8]]
arr2 = np.arange(1,4)
print(arr2)
# [1 2 3]
print(arr1 + arr2)
# [[ 1 3 5]
# [ 4 6 8]
# [ 7 9 11]]