Python数学建模之核心工具库_python建模用什么库

1.NumPy

1.功能简介

        NumPy 是 Python 用于科学计算的基础工具库。它主要包含四大功能：

        (1）强大的多维数组对象；

        (2）复杂的函数功能；

        (3）集成 C / C +＋和 FORTRAN 代码的工具；

        (4）有用的线性代数、傅里叶变换和随机数功能等。

        NumPy 提供了两种基本的对象：ndarray 和 ufunc。ndarray 存储单一数据类型的多维数组，ufunc 是能够对数组进行处理的函数。

2.函数的导入

        导入 NumPy 工具库时，一般改变其名称为 np :

import numpy as np

3.数组的创建

1.使用array()

        使用 array() 将列表或元组转换为 ndarray 数组，调用格式为：

array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

        object：表示要转换为 ndarray 数组的列表或元组。

        dtype：表示指定转换后的数组的数据类型。默认为 None。

        copy：表示是否复制输入的对象。默认为 True，即进行复制。

        order：表示创建数组时的存储顺序。默认为 'K'，表示数组在内存中以尽可能紧凑的方式存储，即按照最佳存储顺序存储数组。

        subok：表示是否允许子类继承 ndarray 类。默认为 False，即不允许。

        ndmin：表示要创建的数组的最小维度。默认为 0，即根据输入的对象自动确定数组的维度。

示例代码：

import numpy as np
 
# 将列表转换为ndarray数组
list1 = [1, 2, 3, 4, 5]
array1 = np.array(list1)
 
# 将元组转换为ndarray数组
tuple1 = (6, 7, 8, 9, 10)
array2 = np.array(tuple1)
 
# 按指定数据类型生成新的数组
array3 = array1.astype(float)
 
# 生成指定数据类型的数组
list2 = [1.1, 2.2, 3.3, 4.4, 5.5]
array4 = np.array(list2, dtype=int)
 
# 指定存储顺序（列优先）和最小维度
list3 = [[1, 2], [3, 4], [5, 6]]
array5 = np.array(list3, order='F', ndmin=2)
 
print(array1); print(array2); print(array3); print(array4); print(array5)

运行结果：

[1 2 3 4 5]
[ 6  7  8  9 10]
[1. 2. 3. 4. 5.]
[1 2 3 4 5]
[[1 2]
 [3 4]
 [5 6]]

2.使用arrange()

        使用 arrange() 在给定区间内创建等差数组，调用格式为：

arange(start=0, stop=None, step=1, dtype=None)

        start：表示等差数组的起始值。如果未指定，则默认为0。 

        stop：表示等差数组的终止值（不包含在数组中）。

        step：表示等差数组的步长。如果未指定，则默认为1。

        dtype：表示指定数组的数据类型。默认为 None，即根据输入的值自动推导。

 示例代码：

import numpy as np
 
# 创建从0到4的等差数组，默认步长为1
array1 = np.arange(5)
 
# 创建从2到10的等差数组，步长为2
array2 = np.arange(2, 11, 2)
 
# 创建从1到10的等差数组，步长为1.5，指定数据类型为float
array3 = np.arange(1, 10, 1.5, dtype=float)
 
print(array1); print(array2); print(array3)

运行结果：

[0 1 2 3 4]
[ 2  4  6  8 10]
[1.  2.5 4.  5.5 7.  8.5]

3.使用linspace()

        使用 linspace() 在给定区间内创建 num 个数据的等差数组，调用格式为：

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

        start：表示等差数组的起始值。

        stop：表示等差数组的终止值。

        num：表示要生成的等差数组中的数据个数，默认为 50。

        endpoint：表示是否将 stop 值包含在数组中，默认为 True，即包含。

        retstep：表示是否返回等差步长，默认为 False，即不返回。

        dtype：表示指定数组的数据类型，默认为 None，即根据输入的值自动推导。

示例代码：

import numpy as np
 
# 创建从0到10的等差数组，包含5个数据
array1 = np.linspace(0, 10, num=5)
 
# 创建从2到10的等差数组，包含10个数据，且不包含终止值
array2 = np.linspace(2, 10, num=10, endpoint=False)
 
# 创建从1到10的等差数组，包含7个数据，返回步长
array3, step = np.linspace(1, 10, num=7, retstep=True)
 
print(array1); print(array2); print(array3, step)

运行结果：

[ 0.   2.5  5.   7.5 10. ]
[2.  2.8 3.6 4.4 5.2 6.  6.8 7.6 8.4 9.2]
[ 1.   2.5  4.   5.5  7.   8.5 10. ] 1.5

4.使用logspace()

        使用 logspace() 在给定区间上生成等比数组，调用格式为：

logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

        start：表示等比数组的起始值。

        stop：表示等比数组的终止值。

        num：表示要生成的等比数组中的数据个数，默认为 50。

        endpoint：表示是否将 stop 值包含在数组中，默认为 True，即包含。

        base：表示等比数列的底数，默认为 10.0，即以 10 为底数。

        dtype：表示指定数组的数据类型，默认为 None，即根据输入的值自动推导。

示例代码：

import numpy as np
 
# 在10的0次方到10的2次方之间生成包含5个数据的等比数组
array1 = np.logspace(0, 2, num=5)
 
# 在2的0次方到2的4次方之间生成包含6个数据的等比数组，且不包含终止值
array2 = np.logspace(0, 4, num=6, endpoint=False, base=2)
 
# 在1的-2次方到1的2次方之间生成包含7个数据的等比数组，以e为底数
array3 = np.logspace(-2, 2, num=7, base=np.e)
 
print(array1); print(array2); print(array3)

 运行结果：

[  1.           3.16227766  10.          31.6227766  100.        ]
[ 1.          1.58740105  2.5198421   4.          6.34960421 10.0793684 ]
[0.13533528 0.26359714 0.51341712 1.         1.94773404 3.79366789
 7.3890561 ]

5.使用ones()、zeros()、empty()、ones_like()等函数

1.ones()、zeros()、empty()

        使用 ones() 生成指定维数，元素值全为 1 的数组，调用格式为：

ones(shape, dtype=None, order='C')

         shape：表示生成数组的形状，可以是一个整数，表示生成一个一维数组，或者是一个整数元组，表示生成一个多维数组。

        dtype：表示指定数组的数据类型,默认为 None，即使用默认的数据类型。

        order：表示数组在内存中的存储顺序,默认为 'C'，表示按行存储。

示例代码：

import numpy as np
 
# 生成一个一维数组，包含5个元素，元素值全部为1
array1 = np.ones(5)
 
# 生成一个二维数组，形状为(3, 4)，元素值全部为1
array2 = np.ones((3, 4))
 
# 生成一个三维数组，形状为(2, 3, 2)，元素值全部为1
array3 = np.ones((2, 3, 2))
 
print('array1:\n',array1); print('array2:\n',array2); print('array3:\n',array3)

运行结果：

array1:
 [1. 1. 1. 1. 1.]
array2:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
array3:
 [[[1. 1.]
  [1. 1.]
  [1. 1.]]
 
 [[1. 1.]
  [1. 1.]
  [1. 1.]]]

        zeros() 和 empty() 的用法与 ones() 相同，只不过 zeros() 生成数组的元素值全为 0 ,empty()生成数组元素的值是随机数。

2.eyes()

        使用 eyes() 生成指定维数，指定对角线元素值全为 1 的数组，调用格式为：

eye(N, M=None, k=0, dtype=float, order='C')

        N：表示生成数组的行数（或列数，如果 M 未指定）。

        M：可选参数，表示生成数组的列数，默认为 None，即默认与行数 N 相等。

        k：可选参数，表示从主对角线偏移的次数，默认为 0，表示主对角线。k为正值表示主对角线向上偏移，k为负值表示主对角线向下偏移。

        dtype：表示指定数组的数据类型，默认为 float。

        order：表示数组在内存中的存储顺序，默认为 'C'，表示按行存储。

示例代码：

import numpy as np
 
# 生成一个形状为(3, 3)的二维数组，主对角线上的元素值为1，其余元素值为0
array1 = np.eye(3)
 
# 生成一个形状为(4, 5)的二维数组，主对角线上的元素值为1，其余元素值为0
array2 = np.eye(4, 5)
 
# 生成一个形状为(5, 5)的二维数组，主对角线上的元素值为1，上方和下方各偏移一次的对角线上元素值为1
array3 = np.eye(5, k=1)
 
# 生成一个形状为(3, 3)的二维数组，数据类型为整数，主对角线上的元素值为1，其余元素值为0
array4 = np.eye(3, dtype=int)
 
# 生成一个形状为(3, 3)的二维数组，以列优先方式存储，主对角线上的元素值为1，其余元素值为0
array5 = np.eye(3, order='F')
 
print('array1:\n',array1); print('array2:\n',array2); print('array3:\n',array3); print('array4:\n',array4); print('array5:\n',array5)

运行结果：

array1:
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
array2:
 [[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]]
array3:
 [[0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]
 [0. 0. 0. 0. 0.]]
array4:
 [[1 0 0]
 [0 1 0]
 [0 0 1]]
array5:
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

 3.ones_like()和zeros_like()

        使用 ones_like() 函数生成一个与给定数组具有相同形状和数据类型的数组，调用格式为：

ones_like(a, dtype=None, order='K', subok=True, shape=None)

        a：表示输入的数组，用于确定生成数组的形状和数据类型。

        dtype：可选参数，表示指定生成数组的数据类型，默认为 None，即与输入数组的数据类型相同。

        order：表示数组在内存中的存储顺序，默认为 'K'，即使用输入数组的存储顺序。

        subok：表示生成的数组是否允许子类化，默认为 True，允许子类化。

        shape：可选参数，表示生成数组的形状，默认为 None，即与输入数组的形状相同。 

示例代码：

import numpy as np
 
# 生成一个与输入数组 a 形状相同的数组，元素值都为1
a = np.array([[2, 3, 4], [5, 6, 7]])
array1 = np.ones_like(a)
 
# 生成一个与输入数组 a 形状相同的数组，元素值都为1，数据类型为整数
array2 = np.ones_like(a, dtype=int)
 
# 生成一个与输入数组 a 形状相同的数组，元素值都为1，存储顺序为列优先
array3 = np.ones_like(a, order='F')
 
# 生成一个与输入数组 a 形状相同的数组，元素值都为1，不允许子类化
array4 = np.ones_like(a, subok=False)
 
# 生成一个形状为 (3, 2) 的数组，元素值都为1
array5 = np.ones_like(a, shape=(3, 2))
 
print('array1:\n',array1); print('array2:\n',array2); print('array3:\n',array3); print('array4:\n',array4); print('array5:\n',array5)

运行结果：

array1:
 [[1 1 1]
 [1 1 1]]
array2:
 [[1 1 1]
 [1 1 1]]
array3:
 [[1 1 1]
 [1 1 1]]
array4:
 [[1 1 1]
 [1 1 1]]
array5:
 [[1 1]
 [1 1]
 [1 1]]

        zeros_like() 函数用法与ones_like() 函数相同，只不过元素值为0。

4.数组元素的索引

        二维数组元素的引用方式为a[i][j]或a[i,j]，下面四种索引均以以下的二维数组为例：