e记法 python 底数_[Python]—NumPy 入门教程

短命女 2023-01-01 05:00 137阅读 0赞

这里是一则小广告：

关注作者请点击这里哦：zdr0

我的专栏里面不仅有学习笔记，也有一些科普文章，相信我的专栏不会让您失望哦～大家可以关注一下：数学及自然科学

记得点赞加收藏哦～

创作不易，请赞赏一下支持一下作者吧\[期待\]～

\-尽力写最好的讲义，尽力写最好的科普。

\-由于本人是自学Python，所以文中如果有错误或表述不当的地方还望给位大佬不吝指出，感谢！

![Image 1][] 是

![Image 1][] 中的用于数值计算的一个包，在这篇文章中我将来介绍一些

![Image 1][] 包的一些基本操作，首先我们要在

![Image 1][] 中导入这个包：

import numpy as np总注：若无特殊说明，那么下文中的数组均指的是

![Image 1][] 数组。

![Image 1][]

![Image 1][] 数组

首先我们来学习一下

![Image 1][] 维的

![Image 1][] 数组。一个一维

![Image 1][] 的

![Image 1][] 数组是一个矢量；

一个二维

![Image 1][] 的

![Image 1][] 数组是一个矩阵。

比如：

>>> A = np.array(\[\[1,2,3,4\],

\[5,6,7,8\],

\[9,10,11,12\],

\[13,14,15,16\]\])

>>>

>>> print(A)

\[\[ 1 2 3 4\]

\[ 5 6 7 8\]

\[ 9 10 11 12\]

\[13 14 15 16\]\]

上面的例子创建的矩阵相当于矩阵：

![Image 1][]

而：

>>> x = np.array(\[1,2,3,4\])

>>> y = np.array(\[\[10\],

\[20\],

\[30\]\])

>>>

>>> print(x)

\[1 2 3 4\]

>>>

>>> print(y)

\[\[10\]

\[20\]

\[30\]\]

创建的是两个矢量，它们相当于矢量：

![Image 1][]

而一维的矢量通常被看是属于

![Image 1][] 的一个矩阵。如果想要创建一个

![Image 1][] 下的矩阵，那么我们只要像这里一样，创建一个二维的数组即可。在

![Image 1][] 中，矢量没有行矢量和列矢量之分。根据需求转化为对应的形式。我们可以对数组中的某个元素进行赋值，只要我们给出这个元素的位置即可，即给出想要进行赋值的元素的行索引和列索引即可。注意：行和列的初始索引均为

![Image 1][] 。

假如我们要对第一个例子中的矩阵

![Image 1][] 的索引为

![Image 1][] 的元素赋值为

![Image 1][] 的话那我们只需要：

>>> A\[3,2\] = 0

>>>

>>> print(A)

\[\[ 1 2 3 4\]

\[ 5 6 7 8\]

\[ 9 10 11 12\]

\[13 14 0 16\]\]

![Image 1][] 代表的是数学形式中的矩阵

![Image 1][] 的第

![Image 1][] 行第

![Image 1][] 列的数字。而在

![Image 1][] 数组中，

![Image 1][] 代表的是矩阵

![Image 1][] 中的第

![Image 1][] 行第

![Image 1][] 列的数字。这是因为这数学形式中，矩阵的行、列均是从

![Image 1][] 开始索引的，而在

![Image 1][] 数组中，矩阵的行、列均是从

![Image 1][] 开始索引。所以，

![Image 1][] 数组中的矩阵的第

![Image 1][] 行相当于数学形式中的

![Image 1][] 行；第

![Image 1][] 列相当于数学形式中的第

![Image 1][] 列。现在对应的

![Image 1][] 是：

![Image 1][]

对于元素均为

![Image 1][] 或元素均为

![Image 1][] 的矩阵我们有更简便的方式创建：

>>> B = np.zeros((4,3))

>>> C = np.ones((2,5))

>>>

>>> print(B)

\[\[0. 0. 0.\]

\[0. 0. 0.\]

\[0. 0. 0.\]\]

>>>

>>> print(C)

\[\[1. 1. 1. 1. 1.\]

\[1. 1. 1. 1. 1.\]\]

![Image 1][] 对应了矩阵：

![Image 1][]![Image 1][] 创建一个

![Image 1][] 行

![Image 1][] 列的元素全部为

![Image 1][] 的矩阵；

![Image 1][] 创建一个

![Image 1][] 行

![Image 1][] 列的元素全部为

![Image 1][] 的矩阵。注意：这里的

![Image 1][] 不是索引！而是这个矩阵的行数和列数！

对于单位矩阵，我们也有简便的创建方式：

>>> n = 3

>>> I = np.eye(n,n)

>>> I1 = np.eye(3,3)

>>>

>>> print(I)

\[\[1. 0. 0.\]

\[0. 1. 0.\]

\[0. 0. 1.\]\]

>>>

>>> print(I1)

\[\[1. 0. 0.\]

\[0. 1. 0.\]

\[0. 0. 1.\]\]

![Image 1][] 均为三维的单位矩阵，它们相当于：

![Image 1][]![Image 1][] 创建一个

![Image 1][] 的单位矩阵。注意：

![Image 1][] 可以被提前赋值，也可以在创建单位矩阵的同时进行赋值(见上例)。而且与

![Image 1][] 和

![Image 1][] 相比，

![Image 1][] 后面只有一个括号！

还有一些命令可以生成一些特殊的数组，比如：

>>> x =np.arange(0,2.2,0.2)

>>>

>>> print(x)

\[0. 0.2 0.4 0.6 0.8 1. 1.2 1.4 1.6 1.8 2. \]

![Image 1][] 是一个一维的数组，它们相当于：

![Image 1][]![Image 1][] 创建一个范围为

![Image 1][] ，间隔为

![Image 1][] 的一维数组。

![Image 1][]

![Image 1][] 数组的一部分

我们在

![Image 1][] 节的一开始定义了定义了一个数组

![Image 1][] 之后，下面我们就思考了，如何取出这个

![Image 1][] 中的一部分呢？这一部分可以是某一行，某一列，或是一个子数组，我们来看以下代码：

>>> A = np.array(\[\[1,2,3,4\],

\[5,6,7,8\],

\[9,10,11,12\],

\[13,14,15,16\]\])

>>>

>>> print(A)

\[\[ 1 2 3 4\]

\[ 5 6 7 8\]

\[ 9 10 11 12\]

\[13 14 15 16\]\]

>>>

>>> u = A\[1,:\] \#a vector from A

>>> v = A\[:,2\] \#a vector from A

>>> B = A\[0:3,0:2\] \#a matrix from A

>>> C = A\[2:4,2:4\] \#a matrix from A

>>>

>>> print(u)

\[5 6 7 8\]

>>>

>>> print(v)

\[ 3 7 11 15\]

>>>

>>> print(B)

\[\[ 1 2\]

\[ 5 6\]

\[ 9 10\]\]

>>>

>>> print(C)

\[\[11 12\]

\[15 16\]\]

其中，

![Image 1][] 是二维数组

![Image 1][] 中索引为

![Image 1][] 的行(即第二行)，它相当于：

![Image 1][]

![Image 1][] 是二维数组

![Image 1][] 中索引为

![Image 1][] 的列(即第三列)，它相当于：

![Image 1][]

![Image 1][] 是二维数组

![Image 1][] 中索引为

![Image 1][] 到索引为

![Image 1][] 行、索引为

![Image 1][] 到索引为

![Image 1][] 列的子数组，它相当于：

![Image 1][]

![Image 1][] 是二维数组

![Image 1][] 中索引为

![Image 1][] 到索引为

![Image 1][] 行、索引为

![Image 1][] 到索引为

![Image 1][] 列的子数组，它相当于：

![Image 1][]![Image 1][] 取出数组中行索引为

![Image 1][] ，列索引为

![Image 1][] 的元素。且

![Image 1][] 的值必须小于二维数组

![Image 1][] 的最大行数，而

![Image 1][] 的值必须小于二维数组

![Image 1][] 的最大列数；

![Image 1][] 取出二维数组

![Image 1][] 中的索引为

![Image 1][] 的一整行，且

![Image 1][] 小于

![Image 1][] 的最大行数。所取出的一整行为一个矢量，且这个矢量的维度是二维数组

![Image 1][] 的列数；

![Image 1][] 取出二维数组

![Image 1][] 中的索引为

![Image 1][] 的一整列，且

![Image 1][] 小于

![Image 1][] 的最大列数。所取出的一整列为一个矢量，且这个矢量的维度是二维数组

![Image 1][] 的行数；

![Image 1][] 取出二维数组

![Image 1][] 中的索引

![Image 1][] 到索引

![Image 1][] 行、索引

![Image 1][] 到索引

![Image 1][] 列的一个子数组。其中，

![Image 1][] 的值可以等于二维数组

![Image 1][] 的最大行数；

![Image 1][] 的值可以等于二维数组

![Image 1][] 的最大列数，但是

![Image 1][] 的值不能等于二维数组

![Image 1][] 的最大行数；

![Image 1][] 的值不能等于二维数组

![Image 1][] 的最大列数。所取出的子数组是一个矩阵；

![Image 1][] 取出二维数组

![Image 1][] 中的索引

![Image 1][] 到索引

![Image 1][] 行的一个子数组。其中，

![Image 1][] 的值可以等于二维数组

![Image 1][] 的最大行数，但是

![Image 1][] 的值不能等于二维数组

![Image 1][] 的最大行数，所取出的子数组是一个行矩阵；

![Image 1][] 取出二维数组

![Image 1][] 中的索引

![Image 1][] 到索引

![Image 1][] 列的一个子数组。其中，

![Image 1][] 的值可以等于二维数组

![Image 1][] 的最大列数，但是

![Image 1][] 的值不能等于二维数组

![Image 1][] 的最大列数，所取出的子数组是一个列矩阵。

下面举几个错误例子：

>>> A\[4,4\]

Traceback (most recent call last):

File "", line 1, in

A\[4,4\]

IndexError: index 4 is out of bounds for axis 0 with size 4

>>>

>>> F = A\[4:4,:\]

>>> print(F)

\[\]

>>> G = A\[:,4:4\]

>>> print(G)

\[\]

>>> H = A\[4:3,:\]

>>> print(H)

\[\]

>>> I = A\[:,4:3\]

>>> print(I)

\[\]

再来体会一下

![Image 1][] 和

![Image 1][] 之间的区别：

>>> A\[3,3\]

16 \#scalar

>>>

>>> H = A\[3:4,3:4\]

>>> print(H)

\[\[16\]\] \#matrix

一个数组也可以通过它的子数组定义，比如：

>>> I = np.eye(2,2)

>>> Z = np.zeros((2,2))

>>> E = np.array(\[\[2,-1\],

\[-1,2\]\])

>>> D = np.hstack((np.vstack((E,Z,I),np.vstack((Z,E,Z)),np.vstack((I,Z,E))))

>>>

>>>print(D)

\[\[ 2. -1. 0. 0. 1. 0.\]

\[-1. 2. 0. 0. 0. 1.\]

\[ 0. 0. 2. -1. 0. 0.\]

\[ 0. 0. -1. 2. 0. 0.\]

\[ 1. 0. 0. 0. 2. -1.\]

\[ 0. 1. 0. 0. -1. 2.\]\]

![Image 1][] 最终是由

![Image 1][] ：

![Image 1][]

![Image 1][] ：

![Image 1][]

![Image 1][] ：

![Image 1][]

所组成，最后：

![Image 1][]

这里将矩阵

![Image 1][] 组合起来用到了两个函数：![Image 1][] 参数

![Image 1][] 可以是元组，列表，或者

![Image 1][] 数组，返回结果为

![Image 1][] 数组。

![Image 1][] ，动词，具有“堆、叠”之意，

![Image 1][] ，形容词，“水平的”，所以

![Image 1][] 的意思就是“水平堆叠”，即就是水平(按列顺序)把数组给堆叠起来；

![Image 1][] 参数

![Image 1][] 可以是元组，列表，或者

![Image 1][] 数组，返回结果为

![Image 1][] 数组。

![Image 1][] ，动词，具有“堆、叠”之意，

![Image 1][] ，形容词，“垂直的”，所以

![Image 1][] 的意思就是“垂直堆叠”，即就是垂直(按列顺序)把数组给堆叠起来；

所以：![Image 1][] 是将矩阵

![Image 1][] 按照顺序垂直堆叠起来，作为矩阵

![Image 1][] 的第一、二列：

![Image 1][]![Image 1][] 是将矩阵

![Image 1][] 按照顺序垂直堆叠起来，作为矩阵

![Image 1][] 的第三、四列：

![Image 1][]![Image 1][] 是将矩阵

![Image 1][] 按照顺序垂直堆叠起来，作为矩阵

![Image 1][] 的第五、六列：

![Image 1][]![Image 1][] 是将矩阵

![Image 1][] 按照顺序水平堆叠起来

![Image 1][] ，即得到

![Image 1][] 。

我们还可以将二维数组

![Image 1][] 中的某行或某列删除，比如：

>>> B = np.delete(A,(1),axis = 0)

>>> C = np.delete(A,(1),axis = 1)

>>>

>>> print(B)

\[\[ 1 2 3 4\]

\[ 9 10 11 12\]

\[13 14 15 16\]\]

>>>

>>> print(C)

\[\[ 1 3 4\]

\[ 5 7 8\]

\[ 9 11 12\]

\[13 15 16\]\]

其中，矩阵

![Image 1][] 是删除了矩阵

![Image 1][] 中的索引为

![Image 1][] 的行(即第二行

![Image 1][] )后的数组，其相当于：

![Image 1][]

矩阵

![Image 1][] 是删除了矩阵

![Image 1][] 中的索引为

![Image 1][] 的列(即第二列

![Image 1][] )后的数组，其相当于：

![Image 1][]![Image 1][] 其中，

![Image 1][] 为被操作的数组，

![Image 1][] 指的是要删除的项的索引，

![Image 1][] 的取值可以是：

![Image 1][]

![Image 1][] ：

![Image 1][] 按行删除；

![Image 1][]

![Image 1][] ：

![Image 1][] 按列删除；

![Image 1][]

![Image 1][] ：

![Image 1][] 会先按行展开，然后按照

![Image 1][] ，删除第

![Image 1][] (从

![Image 1][] 开始)位置的数，返回一个行矩阵。注意：

![Image 1][] 的值只能小于矩阵

![Image 1][] 的最大行数或者最大列数！

我们也可以按照以下方式定义一个矩阵：

>>> D = np.vstack((A\[0:2,:\],np.array(\[21,22,23,24\]),A\[3,:\]))

将矩阵

![Image 1][] 的索引为

![Image 1][] 的行(即第一行)到索引为

![Image 1][] 的行(即第二行)，矢量

![Image 1][] 和举证

![Image 1][] 索引为

![Image 1][] 的行(即第四行)垂直堆叠起来得到矩阵

![Image 1][] ，最终矩阵

![Image 1][] 相当于：

![Image 1][]

![Image 1][] 数组的运算

对于两个

![Image 1][] 维的二维数组(矩阵)

![Image 1][] ，由于两者维数相同，所以可以直接进行相加减：

>>> A = np.array(\[\[1,2\],

\[3,4\]\])

>>> B = np.array(\[\[5,6\],

\[7,8\]\])

>>>

>>> C = A+B

>>> print(C)

\[\[ 6 8\]

\[10 12\]\]

>>>

>>> D = A-B

>>>

>>>print(D)

\[\[-4 -4\]

\[-4 -4\]\]

两个相同维数的矩阵相加减就是它们对应位置上的元素相加减，即若：

![Image 1][]

则：

![Image 1][]

对于矩阵的乘法，

![Image 1][] 除了定义了数学中两个矩阵的乘法之外，还定义了一种特殊的矩阵乘法——对应元素相乘。下面我们就通过一个例子来看看两者有何不同：

>>> A = np.array(\[\[1,2\],

\[3,4\]\])

>>> B = np.array(\[\[5,6\],

\[7,8\]\])

>>>

>>> print(A\*B)

\[\[ 5 12\]

\[21 32\]\]

>>>

>>> print(np.dot(A,B))

\[\[19 22\]

\[43 50\]\]

>>>

>>> print(np.dot(B,A))

\[\[23 34\]

\[31 46\]\]![Image 1][] 只对维数相同的矩阵

![Image 1][] 有效！否则会报错。将对应位置上的元素相乘放在对应位置上即可；

![Image 1][] 数学上的矩阵乘法即

![Image 1][] 。且一般有

![Image 1][] 。而且可以调换顺序(这里可以调换顺序是指矩阵

![Image 1][] 调换之后仍可以计算出结果)的矩阵

![Image 1][] 为

![Image 1][] ，则

![Image 1][] ，

![Image 1][] 。比如：

>>> C = np.array(\[\[1,2\],

\[3,4\],

\[5,6\]\])

>>> D = np.array(\[\[1,2,3\],

\[4,5,6\]\])

>>> print(np.dot(C,D))

\[\[ 9 12 15\]

\[19 26 33\]

\[29 40 51\]\]

>>> print(np.dot(D,C))

\[\[22 28\]

\[49 64\]\]

>>> print(C\*D)

Traceback (most recent call last):

File "", line 1, in

print(C\*D)

ValueError: operands could not be broadcast together with shapes (3,2) (2,3)

由于矩阵的

![Image 1][] 乘只能在同维数的两个矩阵下进行，那么随之而来的一种计算方式就是对矩阵求幂，我们来看一个例子：

>>> A = np.array(\[\[1,2\],

\[3,4\]\])

>>>

>>> E = np.linalg.matrix\_power(A,3) \#C = A∗A∗A

>>> F = A\*\*3

>>>

>>> print(E)

\[\[ 37 54\]

\[ 81 118\]\]

>>>

>>> print(F)

\[\[ 1 8\]

\[27 64\]\]![Image 1][] 矩阵

![Image 1][] 的

![Image 1][] 次方，即

![Image 1][] 个 矩阵

![Image 1][] 相乘，矩阵

![Image 1][] 必须为方阵；

![Image 1][] 矩阵

![Image 1][] 中的各个元素的

![Image 1][] 次方，在这种情况下，矩阵

![Image 1][] 不必为方阵。

最后的是矩阵的除法，例如：

>>> A = np.array(\[\[1,2\],

\[3,4\]\],)

>>> B = np.array(\[\[5,6\],

\[7,8\]\],)

>>>

>>> print(A/B)

\[\[0.2 0.33333333\]

\[0.42857143 0.5 \]\]

>>>

>>> C = np.array(\[\[1,2\],

\[3,4\],

\[5,6\]\])

>>> E = np.array(\[\[2,1\],

\[4,3\],

\[6,5\]\])

>>> print(C/E)

\[\[0.5 2. \]

\[0.75 1.33333333\]

\[0.83333333 1.2 \]\]![Image 1][] 矩阵

![Image 1][] 和矩阵

![Image 1][] 的对应位置上的元素相除。这里矩阵

![Image 1][] 虽不必具有相同的维数，但是矩阵

![Image 1][] 的行数和列数必须一致，即若

![Image 1][] ，那么

![Image 1][] 。

![Image 1][] 数组函数

我们还是以在

![Image 1][] 节最开始创建的二维数组

![Image 1][] 为例进行说明进行说明。

我们想要确定矩阵

![Image 1][] 的维数，那我们需要使用以下函数：

>>> A = np.array(\[\[1,2,3,4\],

\[5,6,7,8\],

\[9,10,11,12\],

\[13,14,15,16\]\])

>>>

>>> np.shape(A)

(4,4)![Image 1][] 确定矩阵矩阵

![Image 1][] 的维数，并将结果存在一个元组中。第一个数字是行的维数，第二个数字是列的维数。

确定一个一维数组的长度：

>>> x = (\[1,2,3,4,5,6\])

>>> len(x)

6![Image 1][] 确定一维数组

![Image 1][] 的长度。

取出矩阵

![Image 1][] 的主对角线上的元素：

>>> print(np.diag(A))

\[ 1 6 11 16\]

>>>

>>> C = np.array(\[\[1,2\],

\[3,4\],

\[5,6\]\])

>>>

>>> print(np.diag(C))

\[1 4\]

>>>

>>> D = np.array(\[\[1,2,3\],

\[4,5,6\]\])

>>>

>>> print(np.diag(D))

\[1 5\]![Image 1][] 取出矩阵

![Image 1][] 的主对角线上的元素，并返回一个一维数组。这里的矩阵

![Image 1][] 不必为方阵，即便不是方阵也可以(见上例)。

反过来，给定一个长度为的

![Image 1][] 一维数组

![Image 1][] ，则下面的命令：

>>> v = np.array(\[1,2,3,4,5,6\]) \#n = 6

>>> B = np.diag(v)

>>> print(B)

\[\[1 0 0 0 0 0\]

\[0 2 0 0 0 0\]

\[0 0 3 0 0 0\]

\[0 0 0 4 0 0\]

\[0 0 0 0 5 0\]

\[0 0 0 0 0 6\]\]![Image 1][] 生成一个以一维数组

![Image 1][] 中的元素为对角线元素的、维度为

![Image 1][] 的矩阵，而且这个矩阵除了主对角线上的元素以外其余全部元素均为

![Image 1][] 。

>>> v = np.array(\[1,2,3,4,5,6\])

>>> C = np.diag(v,1)

>>>

>>> print(C)

\[\[0 1 0 0 0 0 0\]

\[0 0 2 0 0 0 0\]

\[0 0 0 3 0 0 0\]

\[0 0 0 0 4 0 0\]

\[0 0 0 0 0 5 0\]

\[0 0 0 0 0 0 6\]

\[0 0 0 0 0 0 0\]\]![Image 1][] 生成一个以一维数组

![Image 1][] 中的元素为主对角线上面的第

![Image 1][] 条副对角线上的元素的、维度为

![Image 1][] 的矩阵，而且这个矩阵除了主对角线上面的第条

![Image 1][] 副对角线上的元素以外其余全部元素均为

![Image 1][] 。

我么也可以通过以下命令来求矩阵

![Image 1][] 中的所有行和所有列上的元素的和：

>>> print(np.sum(A,axis = 0))

\[28 32 36 40\]

>>>

>>> print(np.sum(A,axis = 1))

\[10 26 42 58\]![Image 1][] 对矩阵

![Image 1][] 的每一列上的元素求和，最终得到一个一维的数组；

![Image 1][] 对矩阵

![Image 1][] 的每一行上的元素求和，最终得到一个一维的数组。

>>> B = A.T

>>> print(B)

\[\[ 1 5 9 13\]

\[ 2 6 10 14\]

\[ 3 7 11 15\]

\[ 4 8 12 16\]\]![Image 1][] 计算矩阵

![Image 1][] 的转置。

还有一些别的例子：

>>> u = np.sum(np.diag(A))

>>> z = np.sum(A\[:,3\])

>>> v = np.sum(A)

>>>

>>> print(np.sum(np.diag(A)))

>>> print(np.sum(A\[:,3\]))

>>> print(np.sum(A))

136![Image 1][] 求矩阵

![Image 1][] 的对角线上的元素的和；

![Image 1][] 求矩阵

![Image 1][] 的第四列上的元素的和；

![Image 1][] 求矩阵

![Image 1][] 的所有元素的和；

下面的函数是有关一维数组

![Image 1][] 的函数：

>>> np.max(x)

>>> np.min(x)

>>> np.linalg.norm(x,ord=1)

21.0

>>> np.linalg.norm(x,ord=2)

9.539392014169456

>>> np.linalg.norm(x,ord=np.inf)

6.0![Image 1][] 求一维数组

![Image 1][] 的最大值；

![Image 1][] 求一维数组

![Image 1][] 的最小值；

![Image 1][] 求一维数组

![Image 1][] 的

![Image 1][] 范数；

![Image 1][] 求一维数组

![Image 1][] 的

![Image 1][] 范数；

![Image 1][] 求一维数组

![Image 1][] 的

![Image 1][] 范数。

还有一些常见的常数：

>>> np.pi

3.141592653589793

>>> np.e

2.718281828459045

最后一些是一些我们在数学上学习的过的重要函数：

>>> np.exp(a)

>>> np.log(a) \#自然底数的对数函数

>>> np.log10(a)

>>> np.log2(a)

>>> np.sqrt(a)

>>> a∗∗(1/n) \#n次根号a

>>> np.sin(a)

>>> np.cos(a)

>>> np.tan(a)

>>> np.ceil(a) \#>=a的下一个整数

>>> np.floor(a) \#<=a的下一个整数

>>> np.round(a) \#对a四舍五入

[Image 1]:

e记法 python 底数_[Python]—NumPy 入门教程

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Python入门教程 | Python3 字符串

相关 Python入门教程 | Python 数字(Number)

相关科学记数法中的e

相关 e记法 python 底数_[Python]—NumPy 入门教程

相关【C语言程序设计】求自然底数e，求自然对数的底e！

相关 Python基础教程学习目录 - Python入门教程

相关数学里的 e 为什么叫做自然底数？

相关 Pro/E二次开发入门详细教程

相关 Python ActiveMQ入门教程

相关科学计数法e