目录

前言

创建矩阵(使用 ndarray 对象)

获取矩阵的行数和列数(二维)

截取矩阵

按行列截取

条件拦截

矩阵组合

通过函数创建矩阵

排列

linspace

日志空间

个,零,眼,空

来自字符串

fromfunction

矩阵运算

常用矩阵运算符

常用矩阵函数

矩阵乘法(点乘法)

矩阵的转置

矩阵的逆 a_1

矩阵信息获取(如均值)

最大值和最小值

平均值

方差

标准差

中位数

求和

累计和

前言

NumPy(Numerical Python)是Python语言的扩展,支持大量维数组和矩阵运算,以及大量用于数组运算的数学函数库。

创建矩阵(使用ndarray对象)

对于python中的numpy模块,通常使用它们提供的ndarray对象。通过将列表作为参数来创建 ndarray 对象很容易。例如:

import numpy as np #Introducing numpy 库

#创建一维数组对象

a u003d np.array([1,2,3,4,5])

#创建二维数组对象

a2 u003d np.array([[1,2,3,4,5],[6,7,8,9,10]])

#用它们的类比创建多维对象

获取矩阵的行数和列数(二维)

定制为用matlab编程,在遍历矩阵时,一般会先得到矩阵的行数和列数。要获取 narray 对象的每个维度的长度,可以使用 narray 对象的 shape 属性

将 numpy 导入为 np

a u003d np.array([[1,2,3,4,5],[6,7,8,9,10]])

print(a.shape) #结果返回一个元组 tuple (2L, 5L)

print(a.shape[0]) #获取行数,返回2

print(a.shape[1]) #获取列数,返回5

截取矩阵

按行列截取

矩阵截取和list一样,可以用[](方括号)截取

将 numpy 导入为 np

a u003d np.array([[1,2,3,4,5],[6,7,8,9,10]])

print(a[0:1]) #截取第一行并返回[[1 2 3 4 5]]

print(a[1,2:5]) #截取第二行第三第四列,返回到[8 9]

print(a[1,:]) #截取第二行返回[67 8 9 10]

条件拦截

条件拦截实际上是一个布尔语句,它本身在 [] (方括号)中传递

将 numpy 导入为 np

a u003d np.array([[1,2,3,4,5],[6,7,8,9,10]])

b u003d a[a>6] # 截取矩阵a中大于6的元素,范围为一维数组

print(b) # 返回 [7 8 9 10]

实际上,布尔语句首先生成一个布尔矩阵,通过在[](方括号)中传递它进行截断

打印(a>6)

"""

返回

[[假假假假]

[假真真真真假]]

"""

条件截取常用于将矩阵中满足一定条件的元素转换为特定值。例如,矩阵中大于 6 的元素被转换为 0

将 numpy 导入为 np

a u003d np.array([[1,2,3,4,5],[6,7,8,9,10]])

打印(一)

"""

起始矩阵是

[[ 1 2 3 4 5]

[ 6 7 8 9 10]]

"""

a[a % 2 u003du003d 0] u003d 0

打印(一)

"""

偶数归零后的矩阵为

[[1 0 3 0 5]

[0 7 0 9 0]]

"""

矩阵组合

矩阵的组合可以通过numpy中的hstack和vstack方法来实现

将 numpy 导入为 np

a1 u003d np.array([[1,2],[3,4]])

a2 u003d np.array([[5,6],[7,8]])

#!注意参数是作为列表或元组传入的

打印(np.hstack([a1,a2]))

"""

横向合并,返回如下结果

[[1 2 5 6]

[3 4 7 8]]

"""

打印(np.vstack((a1,a2)))

"""

垂直合并,返回如下结果

[[1 2]

[3 4]

[5 6]

[7 8]]

"""

矩阵的合并也可以使用 concatenatef 方法完成

np.concatenate( (a1,a2), axisu003d0 ) 等价于 np.vstack( (a1,a2) )

np.concatenate( (a1,a2), axisu003d1 ) 等价于 np.hstack( (a1,a2) )

按函数创建矩阵

numpy 模块带有创建 ndarray 对象的函数,这使得创建普通或常规矩阵变得容易。

范围

将 numpy 导入为 np

a u003d np.arange(10) # 默认从0到10(不包括10),步长为1

print(a) # 返回 [0 1 2 3 4 5 6 7 8 9]

a1 u003d np.arange(5,10) # 从 5 到 10(不包括 10),步长为 1

print(a1) # 返回到[5 6 7 8 9]

a2 u003d np.arange(5,20,2) # 从5到20(不包括20),步长为2

print(a2) # 返回 [5 7 9 11 13 15 17 19]

林空间

linspace() 与 matlab 的 linspace 类似,它创建指定数量的等间隔序列,并实际生成一个等差列。

将 numpy 导入为 np

linspace(start, stop, numu003d50, endpointu003dTrue, retstepu003dFalse, dtypeu003dNone, axisu003d0)

"""

开始:数组_like

序列的起始值。

停止:数组_like

序列的结束值,除非 `endpoint`设置为 False。

在这种情况下,序列由 ``num + 1``的最后一个组成

均匀分布的样本,因此 `stop`被排除在外。注意步骤

当 `endpoint`为 False 时,大小会发生变化。

num : int,可选

要生成的样本数。默认值为 50。必须为非负数。

端点:布尔值,可选

如果为真,`stop`是最后一个样本。否则,不包括在内。

默认为真。

retstep : bool,可选

如果为 True,则返回 (`samples`, `step`),其中 `step`是间距

样本之间。

dtype:dtype,可选

输出数组的类型。如果没有给出`dtype`,则推断数据

从其他输入参数中键入。

"""

a u003d np.linspace(0,10,5) # 生成从 0 到 10 的 7 个数字的等差列

打印(一)

结果 [0.2.5 5 5.7.5 10.]

a u003d np.linspace(0, 10, 5, restepu003dTrue)

结果(数组 ([0., 2.5, 5., 7.5, 10.]), 2.5)

• 开始:起始值

• 停止:结束值

• num:要生成的数量,不写默认为50

• 端点:默认为True,表示停止,False表示不停止

• restep:默认为False,如果设置为True,返回等差列和步长的元组

• dtype:指定数据类型,默认从输入参数推断

日志空间

linspace用于生成等差列,logspace用于生成对数等比列

将 numpy 导入为 np

logspace(start, stop, numu003d50, endpointu003dTrue, baseu003d10.0, dtypeu003dNone, axisu003d0):

"""

返回在对数刻度上均匀分布的数字。

在线性空间中,序列从``base ** start``开始

(`base`的 `start`次方) 并以 ``base ** stop``结尾

(见下文 `endpoint`)。

.. 版本更改:: 1.16.0

现在支持非标量 `start`和 `stop`。

参数

---

开始:数组_like

``base ** start``是序列的起始值。

停止:数组_like

``base ** stop``是序列的最终值,除非`endpoint`

为假。在这种情况下,``num + 1``值在

日志空间中的间隔,除了最后一个(一系列

长度 `num`) 被返回。

num : 整数,可选

要生成的样本数。默认值为 50。

端点:布尔值,可选

如果为真,`stop`是最后一个样本。否则,不包括在内。

默认为真。

基础:浮动,可选

日志空间的基础。元素之间的步长

``ln(samples) / ln(base)``(或 ``log_base(samples)``)是一致的。

默认值为 10.0。

数据类型:数据类型

输出数组的类型。如果没有给出`dtype`,则推断数据

从其他输入参数中键入。

轴:int,可选

结果中用于存储样本的轴。仅在开始时相关

或 stop 类似于数组。默认情况下 (0),样本将沿着

在开头插入新轴。最后使用 -1 得到一个轴。

"""

a u003d np.logspace(0,2,5)

打印(一)

结果[1.3.16227766 10.31.6227766 100.]

• 开始:起始值

• 停止:结束值

• num:元素个数,默认为50

• 端点:默认为True,表示停止,False表示不停止

• Base:指定对数的底,默认为10

• dtype:指定数据类型,默认从输入参数推断

• 轴:结果中的轴用于存储样本。仅当 start 或 stop 类似于数组时才相关。默认情况下 (0),样本将跟随在开头插入的新轴。使用 -1 获取轴的末端

将 numpy 导入为 np

a u003d np.logspace([0, 0], [2, 2], 5, 轴u003d-1)

b u003d np.logspace([0, 0], [2, 2], 5)

打印(一)

"""

[[ 1. 3.16227766 10. 31.6227766 100. ]

[ 1. 3.16227766 10. 31.6227766 100. ]]

"""

打印(b)

"""

[[ 1. 1. ]

[ 3.16227766 3.16227766]

[ 10. 10. ]

[ 31.6227766 31.6227766 ]

[100. 100.]]

"""

个,零,眼,空

one 创建全 1 矩阵 zeros 创建全 0 矩阵 eye 创建单位矩阵 empty 创建空矩阵(实际值)

将 numpy 导入为 np

a_ones u003d np.ones((3,4)) # 创建一个 3*4 Full 1 矩阵

打印(一个_ones)

"""

结果

[[ 1. 1. 1. 1.]

[ 1. 1. 1. 1.]

[ 1. 1. 1. 1.]]

"""

a_zeros u003d np.zeros((3,4)) # 创建一个3*4的全0矩阵

打印(a_zeros)

"""

结果

[[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]]

"""

a_eye u003d np.eye(3) # 创建一个三阶单位矩阵

打印(a_eye)

"""

结果

[ 1. 0. 0.]

[ 0. 1. 0.]

[ 0. 0. 1.]]

"""

a_empty u003d np.empty((3,4)) # 创建一个3*4的空矩阵

打印(一个_empty)

"""

结果

[[ 1.78006111e-306 -3.13259416e-294 4.71524461e-309 1.94927842e+289]

[ 2.10230387e-309 5.42870216e+294 6.73606381e-310 3.82265219e-297]

[ i.24242356e-309 1.07034394e-296 2.1268797j+183 i.88703165j-315]]

"""

来自字符串

fromstring() 方法将字符串转换为 ndarray 对象,这在对字符串进行数字化以获得字符串的 ascii 序列时很有用

将 numpy 导入为 np

a u003d "abcdef"

b u003d np.fromstring(a,dtypeu003dnp.int8) # 因为一个字符是8,所以指定dtype为np.int8

print(b) # 返回 [97 98 99 100 101 102]

来自函数

fromfunction() 方法根据矩阵的行号和列号生成矩阵的元素。例如,创建一个矩阵,其中每个元素都是行号和列号的总和

将 numpy 导入为 np

定义函数(i,j):

返回 i+j

a u003d np.fromfunction(func,(5,6))

第一个参数为指定函数,第二个参数为列表或元组,表示矩阵的大小

打印(一)

"""

结果

[[ 0.1.2.3.4.5.]

[ 1. 2. 3. 4. 5. 6.]

[ 2. 3. 4. 5. 6. 7.]

[ 3. 4. 5. 6. 7. 8.]

[ 4. 5. 6. 7. 8. 9.]]

"""

矩阵运算

常用矩阵运算符

numpy 中的 ndarray 对象重载了许多运算符,这些运算符可用于对矩阵之间的对应元素执行操作。

操作员

解释

添加矩阵对应元素

-

矩阵对应元素的减法

*

矩阵对应元素的乘法

/

将矩阵的对应元素相除,如果都是整数则取商

%

矩阵对应元素相除后的余数

**

矩阵的每个元素都是 n 次方,例如**2:每个元素都是平方的

将 numpy 导入为 np

a1 u003d np.array([[4,5,6],[1,2,3]])

a2 u003d np.array([[6,5,4],[3,2,1]])

print(a1+a2) # 加法

"""

结果

[[10 10 10]

[ 4 4 4]]

"""

print(a1/a2) # 整数除法商

"""

结果

[[0 1 1]

[0 1 3]]

"""

print(a1%a2) # 除余数

"""

结果

[[4 0 2]

[1 0 0]]

"""

常用矩阵函数

同样,在 numpy 中定义了许多函数,可用于作用于矩阵中的每个元素。 numpy模块,import numpy as np,a默认是一个ndarray对象,导入到表中。

矩阵函数

解释

np.sin(a)

对矩阵 a 中的每个元素取正弦,sin(x)

np.cos(a)

矩阵 a 中每个元素的余弦,cos(x)

np.tan(a)

与矩阵 a 中的每个元素相切,tan(x)

np.face

取矩阵 a 中每个元素的反正弦,arcsin(x)

np.arccos(a)

取矩阵 a 中每个元素的反余弦,arccos(x)

np.arctan(a)

弧形 n(x)

np.exp(a)

对矩阵 a 中的每个元素取一个指数函数,例如

np.sqrt(a)

对矩阵 a x 中的每个元素求根

将 numpy 导入为 np

a u003d np.array([[1,2,3],[4,5,6]])

打印(np.sin(a))

"""

结果

[[ 0.84147098 0.90929743 0.14112001]

[-0.7568025 -0.95892427 -0.2794155 ]]

"""

打印(np.face(a))

"""

结果

C:\Users\Administrator\Desktop\learn.py:6: RuntimeWarning: 在 arcsin 中遇到无效值

打印(np.face(a))

[[ 1.57079633 在]

[在中]]

"""

当矩阵中的元素不在定义的域内时,RuntimeWarning 会导致 nan(不是数字)

矩阵乘法(点乘法)

矩阵乘法必须满足矩阵乘法的条件,即第一个矩阵的列数等于第二个矩阵的行数。

矩阵乘法的功能是点

将 numpy 导入为 np

a1 u003d np.array([[1,2,3],[4,5,6]]) # a1是一个2*3矩阵

a2 u003d np.array([[1,2],[3,4],[5,6]]) # a2是一个3*2矩阵

print(a1.shape[1]u003du003da2.shape[0]) # 真,满足矩阵乘法条件

打印(a1.dot(a2))

a1.dot(a2) 等价于 matlab 中的 a1*a2

而python中的a1*a2等价于matlab中的a1.*a2

"""

结果

[[22 28]

[49 64]]

"""

矩阵的转置

将 numpy 导入为 np

a u003d np.array([[1,2,3],[4,5,6]])

打印(a.转置())

"""

结果

[[1 4]

[2 5]

[3 6]]

"""

转置矩阵的更简单方法是 a.T.

将 numpy 导入为 np

a u003d np.array([[1,2,3],[4,5,6]])

打印(a.T)

"""

结果

[[1 4]

[2 5]

[3 6]]

"""

矩阵的逆a_1

要反转一个矩阵,需要先导入 numpy.linalg,然后使用 linalg 的 inv 函数进行反转。矩阵求逆要求矩阵的行数和列数相同

将 numpy 导入为 np

导入 numpy.linalg 作为 lg

a u003d np.array([[1,2,3],[4,5,6],[7,8,9]])

打印(lg.inv(a))

"""

结果

[[ -4.50359963j+15 p.00719925j+15 -4.50359963j+15]

[ p.00719925j+15 -1.80143985j+16p.00719925j+15]

[ -4.50359963j+15p.00719925j+15 -4.50359963j+15]]

"""

a u003d np.eye(3) # 三阶单位矩阵

print(lg.inv(a)) # 单位矩阵的逆是自己

"""

结果

[[ 1. 0. 0.]

[ 0. 1. 0.]

[ 0. 0. 1.]]

"""

矩阵信息获取(如均值)

最大值和最小值

获取矩阵中元素的最大值和最小值的函数分别是max和min,用于获取整个矩阵、行或列的最大值和最小值。

将 numpy 导入为 np

a u003d np.array([[1,2,3],[4,5,6]])

print(a.max()) #获取整个矩阵的最大值 结果:6

print(a.min()) #结果:1

可以指定关键字参数axis来获取一行的最大(小)值或者一列的最大(小)值

#axisu003d0 行方向最大(小)值,即每一列的最大(小)值

#axisu003d1 列方向最大(小)值,即每一行的最大(小)值

例如

打印(a.max(轴 u003d 0))

结果是[45 6]

打印(a.max(轴 u003d 1))

结果是[3 6]

获取最大最小元素的位置,可以通过argmax函数获取

打印(a.argmax(轴 u003d 1))

结果是[2]

平均值

类似地,可以获得整个矩阵、行或列的平均值。

将 numpy 导入为 np

a u003d np.array([[1,2,3],[4,5,6]])

print(a.mean()) #结果为:3.5

同理,关键字axis参数可以让你指定取平均值的方向

print(a.mean(axisu003d0)) # 结果 [2.5 3.5 4.5]

print(a.mean(axisu003d1)) # 结果[2.5.]

方差

方差函数是var(),方差函数var()等价于函数mean(abs(x-x.mean())**2),其中x是一个矩阵

将 numpy 导入为 np

a u003d np.array([[1,2,3],[4,5,6]])

print(a.var()) # 结果 2.916666667

print(a.var(axisu003d0)) # 结果 [2.25 2.25 2.25]

print(a.var(axisu003d1)) # 结果[0.66666667 0.66666667]

标准差

标准差的函数是std()。 std() 等价于 sqrt (mean (abs (x-x.mean()**2)) 或 sqrt(x.var())

将 numpy 导入为 np

a u003d np.array([[1,2,3],[4,5,6]])

print(a.std()) # 结果 1.70782512766

print(a.std(axisu003d0)) # 结果 [1.5 1.5 1.5]

print(a.std(axisu003d1)) # 结果[0.81649658 0.81649658]

中位数

中位数是指序列按大小排序后的中间值,如果有偶数,则取中间两者的平均值。

比如序列[5,2,6,4,2],按大小顺序[2,2,4,5,6],中间是4,所以这个序列的中值为4.

或者序列[5,2,6,4,3,2],按大小顺序[2,2,3,4,5,6],因为有偶数,中间两个数是3,4,这个序列的中值为3.5。

中位数函数是median(),调用方法是numpy.median(x,[axis]),axis可以指定轴方向,默认axis u003d None,中位数为所有数字

将 numpy 导入为 np

x u003d np.array([[1,2,3],[4,5,6]])

print(np.median(x)) # 所有数字的中位数

结果 3.5

print(np.median(x,axisu003d0)) # 沿第一维的中位数

结果[2.5 3.5 4.5]

print(np.median(x,axisu003d1)) # 沿第二维的中位数

结果[2.5.]

求和

矩阵求和的函数是sum(),可以对行、列或者整个矩阵求和

将 numpy 导入为 np

a u003d np.array([[1,2,3],[4,5,6]])

print(a.sum()) # 对整个矩阵求和

结果 21

print(a.sum(axisu003d0)) # 求和行方向

结果[57 9]

print(a.sum(axisu003d1)) # 求和列方向

结果[6 15]

累计金额

一个位置的累积和是指该位置之前(包括)所有元素的总和。

例如一个序列[1,2,3,4,5],其累积和为[1,3,6,10,15],即第一个元素为1,第二个元素为1+2u003d3,...,第五个元素是1+2+3+4+5u003d15。

矩阵的累积求和函数是cumsum(),可以对行、列或整个矩阵求和

将 numpy 导入为 np

a u003d np.array([[1,2,3],[4,5,6]])

print(a.cumsum()) # 对整个矩阵求和

结果[1 3 6 10 15 21]

print(a.cumsum(axisu003d0)) # 行方向的累积和

"""

结果

[[1 2 3]

[5 7 9]]

"""

print(a.cumsum(axisu003d1)) # 列方向的累积和

"""

结果

[[ 1 3 6]

[ 4 9 15]]

"""