Numpy是Python科学计算的基础库，提供了强大的N维数组对象Ndarray、广播功能、线性代数操作等。文章介绍了如何创建和操作数组，包括普通创建、其他创建方式，如arange、linspace、logspace等，以及切片和索引。还详细讲解了广播机制和线性代数函数，如dot、vdot、matmul等，并展示了如何进行矩阵运算和求解线性方程。此外，文章还涵盖了数组迭代和修改元素的方法。
Numpy —— 科学计算库
NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。
NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：
- 一个强大的N维数组对象 ndarray
- 广播功能函数
- 整合 C/C++/Fortran 代码的工具
- 线性代数、傅里叶变换、随机数生成等功能
引入
import numpy as np # 通常都采用np作为简写名
# 可用内置函数version()检测其版本
np.__version__
列表类型与数组类型
**# 列表 —— 数据类型可以不同，不过处理效率不高，速度慢**
li = list(range(10)) # li = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
li[5] = 'Hello Python' # 将li的第六个元素该为字符型的'Hello Python', 此时li = [0, 1, 2, 3, 4, 'Hello Python', 6, 7, 8, 9]
**# 数组 —— array 数据类型一定要是相同的，处理效率要比list高。但是矩阵操作不太方便了**
构建方式: array.array('字符(数据指明类型)', 列表生成式)
import array
arr = array.array('i', list(range(10))) # arr : array('i', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr = array.array('f', list(range(10))) # arr : array('f', [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0])
arr = array.array('t', list(range(10)))
/*
ValueError Traceback (most recent call last)
<ipython-input-19-837f57a40226> in <module>
----> 1 arr = array.array('t', list(range(10)))
ValueError: bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)
*/
Ndarray(多维数组/矩阵)
- ndarray 对象是用于存放同类型元素的多维数组。
- ndarray 中的每个元素在内存中都有相同存储大小的区域。
- ndarray 内部由以下内容组成：
- 一个指向数据（内存或内存映射文件中的一块数据）的指针。
- 数据类型或 dtype，描述在数组中的固定大小值的格子。
- 一个表示数组形状（shape）的元组，表示各维度大小的元组。
- 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数
跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。
~ 普通创建 ~
只需调用 NumPy 的 array 函数即可：
PS:
[2 3 4]显然是数组
但是初始化不能： b = [2 3 4]
因为这样会：SyntaxError: invalid syntax
必须用函数初始化！
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
【ndarray 对象由计算机内存的连续一维部分组成，并结合索引模式，将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格，即前述的F样式)来保存元素。】
PS：
向量、矩阵均由array函数创建，区别在于
向量 v = array( [逗号分隔的元素] )
矩阵 M = array( [ [ ], [ ],…,[ ] ) ====> "（[ ]）“里面有多少个”[ ]"取决于矩阵的行数
注意：
本质上，还是数组！所以，元素类型必须是一致的！
不过，仍然有可兼容类型的自动转换！
import numpy as np
构建一个一维矩阵（一维数组）
a = np.array([1,2,3])
print(a) # [1 2 3]
print(type(a)) # 对象类型: numpy.ndarray
print(a.dtype) # 数据类型: dtype('int32')
print(a.shape) # 数组各个维度的长度: (3,) —— shape是一个元组
print(a.ndim) # 数组维度: 1
# 利用列表生成式来创建数组
nparr = np.array(list(range(10)))
print(nparr) # array([0 1 2 3 4 5 6 7 8 9])
# 数组元素的类型必须是相同的！
nparr[5] = 'Hello Python'
/*
---------------------------------------------------------------------------
ValueError
Traceback (most recent call last)
<ipython-input-28-c4124591e6eb> in <module>
----> 1 nparr[5] = 'Hello Python'
ValueError: invalid literal for int() with base 10: 'Hello Python'
*/
# 类型的自动转换（创建时自动转换成最高的类型，更改时自动转换成数据数组原来的数据类型）
nparr[5] = 55.23 # 原本是整型数据，现把其中一个改成浮点型，会自动向下取整
print(nparr) # array([ 0 1 2 3 4 55 6 7 8 9])
t = np.array([1.0, 2.3, 6.4, 8.9]) # 数组原本的数据类型是浮点型，现要把其中一个改成整型，所以会自动转换。
t[3] = 8
print(t) # array([1. , 2.3, 6.4, 8. ])
nparr2 = np.array([1, 2, 3.0]) # 以兼容的数据创建矩阵，数据类型便是最高的那级
print(nparr2.dtype) # dtype('float64')
nparr3 = np.array([1, 2, 3], dtype=float) # 可以指定元素类型
print(nparr3) # array([1., 2., 3.])
# 构建一个二维矩阵
a = np.array([[1, 2], [3, 4]]) # "([])"里有两个“[]”
print (a)
''' [[1, 2]
[3, 4]]
'''
# 设置最小维度 —— 设置ndim
import numpy as np
a = np.array([1,2,3,4,5], ndmin = 2)
print (a) # [[1, 2, 3, 4, 5]]
# 使用zero（浮点零）/ones（浮点1）/empty（未初始化，系统随机给数据）创建数组:根据shape来创建
# numpy.empty(shape, dtype = float, order = 'C')
x = np.zeros(6) # [0. 0. 0. 0. 0. 0.]
x = np.zeros((2,3))
''' [[0. 0. 0.]
[0. 0. 0.]]
'''
x = np.ones(3) # [1. 1. 1.]
x = np.empty((3,3))
'''
[[0.00000000e+000 0.00000000e+000 0.00000000e+000]
[0.00000000e+000 0.00000000e+000 3.04344438e-321]
[7.56593016e-307 1.11261027e-306 4.84184333e-322]]
''
y = np.empty(3) # [1. 1. 1.]
其他创建方式
numpy.asarray
numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。
numpy.asarray(a, dtype = None, order = None)
import numpy as np
# 将列表转换成（多维）数组
x = [1,2,3]
a = np.asarray(x)
print (a) # [1 2 3]
# 将元组转换为 ndarray:
x = (1,2,3)
a = np.asarray(x)
print (a) # [1 2 3]
# 将元组列表转换为 ndarray:
x = [(1,2,3),(4,5)]
a = np.asarray(x)
print (a) # [(1, 2, 3) (4, 5)]
# 设置了 dtype 参数：
x = [1,2,3]
a = np.asarray(x, dtype = float)
print (a) # [ 1. 2. 3.]
从数值范围创建数组
numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：
numpy.arange(start, stop, step, dtype)
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
import numpy as np
# 生成 0 到 5 的数组:
x = np.arange(5)
print (x) # [0 1 2 3 4]
# 设置返回类型位 float:
x = np.arange(5, dtype = float)
print (x) # [0. 1. 2. 3. 4.]
# 设置了起始值、终止值及步长：
x = np.arange(10,20,2)
print (x) # [10 12 14 16 18]
numpy.linspace
用于创建一个一维数组，数组是一个等差数列构成的，格式如下：
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
import numpy as np # 导包
# 设置起始点为 1 ，终止点为 10，数列个数为 10
a = np.linspace(1,10,10)
print(a) # [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
# 设置元素全部是1的等差数列：
a = np.linspace(1,1,10)
print(a) # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
# 将 endpoint 设为 false，不包含终止值：
（如果将 endpoint 设为 true，则会包含 20。）
a = np.linspace(10, 20, 5, endpoint = False)
print(a) # [10. 12. 14. 16. 18.]
# 将retstep设为true,会显示间距
a = np.linspace(1,10,10,retstep= True)
print(a) # (array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
# 可以设置输出的ndarray转换形状
b =np.linspace(1,10,10).reshape([10,1])
print(b)
'''
[[ 1.]
[ 2.]
[ 3.]
[ 4.]
[ 5.]
[ 6.]
[ 7.]
[ 8.]
[ 9.]
[10.]]
'''
numpy.logspace
numpy.logspace 函数用于创建一个于等比数列。格式如下：
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
base 参数意思是取对数的时候 log 的下标。
import numpy as np
# 默认底数是 10
a = np.logspace(1.0, 2.0, num = 10)
print (a)
'''
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]
'''
# 将对数的底数设置为 2 :
a = np.logspace(0,9,10,base=2)
print (a) # [ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
~ 基本切片和索引~
ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。
- 一维数组的索引：与Python的列表索引功能相似
- 多维数组的索引：
- arr[r1:r2, c1:c2]
- [:] 代表某个维度的所有数据
- arr[1,1] 等价 arr[1][1]
- 多维数组arr[1:]表示从下标为1的行一直提取到最后
ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。
冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。
切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。
实例
1.内置slice函数
a = np.arange(10) # 首先通过 arange() 函数创建 ndarray 对象
s = slice(2,7,2) # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s]) # [2 4 6]
2.通过冒号分隔切片参数 start:stop:step 来进行切片操作：
a = np.arange(10)
b = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2
print(b) # [2 4 6]
3.单独提取，有关冒号的多种切片
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
b = a[5]
print(b) # 5
print(a[2:]) # [2 3 4 5 6 7 8 9]
print(a[2:5]) # [2 3 4]
4.多维数组的行切、列切
行切
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
'''
[[1 2 3]
[3 4 5]
[4 5 6]]
'''
print(a[1:])
'''
[[3 4 5]
[4 5 6]]
'''
列切
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print (a[...,1]) # 第2列元素 —— [2 4 5]
print (a[1,...]) # 第2行元素 —— [3 4 5]
print (a[...,1:]) # 第2列及剩下的所有元素
'''
[[2 3]
[4 5]
[5 6]]
'''
5.深复制浅复制
用copy()：生成一个形状相同的东西，并把原数组的数组依次赋值进去。之后再怎么改原来的，都不会影响现在这个。因为已经是两个不同的、没有任何联系的东西了。
直接用=赋值：副本，原来的、副本这两个其中任何一个被改，另外那个也会改。时时刻刻保持同步、一致。
x = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
y = x[0].copy()
# 生成一个副本
'''
[[1 2]
[3 4]]
'''
z = x[0] # 未生成一个副本
'''
[[1 2]
[3 4]]
'''
y[0,0] = 0
print(y)
'''
[[0 2]
[3 4]]
'''
z[0,0] = -1
'''
[[-1 2]
[ 3 4]]
'''
print(x[0])
'''
[[-1 2]
[ 3 4]]
'''
6.切片赋值
```python
x = np.array([[1,2],[3,4],[5,6]])
print(x[:][:1]) # [[1 2]]
# 标量赋值
x[:2,:1] = 0 # 把前两行，前一列的两个元素赋值为0
print(x)
'''
[[0 2]
[0 4]
[5 6]]
'''
# 数组赋值 —— 修改的形状和赋值用的数组的形状必须相同
```python
x = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
x[:2, :1] = [[8],[6]]
print(x)
'''
[[8 2 3]
[6 5 6]
[7 8 9]]
'''
x = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
x[:3,:2] = [[1, 2], [3,4], [0, 0]]
print(x)
'''
[[1 2 3]
[3 4 6]
[0 0 9]]
'''
布尔索引和花式索引
布尔索引：使用布尔数组作为索引。arr[condition]，condition为一个条件/多个条件组成的布尔数组。
布尔型数组的长度必须跟被索引的轴长度一致!一一对应，True就输出，False就不输出！
x = numpy.array([3,2,3,1,3,0])
y = numpy.array([True,False,True,False,True,False])
print(x[y]) # [3 3 3]
print(x[y==False]) # [2,1,0]
print(x >= 3) # [ True False True False True False]
print(x[~(x>=3)]) # [2,1,0]
print((x==2)|(x==1)) # [False True False True False False]
x[(x==2)|(x==1)] = 0
print(x) # [3 0 3 0 3 0]
花式索引：使用整型数组作为索引。
x = numpy.array([1,2,3,4,5,6])
print(x[[0,1,2]]) # [1 2 3]
print(x[[-1,-2,-3]]) # [6,5,4]
# 最外的[]是表示取索引，第一个[]对行切片，第二个[]是对列切片
x = numpy.array([[1,2],[3,4],[5,6]])
print x[[0,1]] # [[1,2],[3,4]]
print x[[0,1],[0,1]] # [1,4] 打印x[0][0]和x[1][1]
print x[[0,1]][:,[0,1]] # 打印01行的01列 [[1,2],[3,4]]
# 使用numpy.ix_()函数增强可读性
print x[numpy.ix_([0,1],[0,1])] #同上 打印01行的01列 [[1,2],[3,4]]
x[[0,1],[0,1]] = [0,0]
print(x) # [[0,2],[3,0],[5,6]]
PS:
x = np.arange(32).reshape((8,4))
print(x[[4,2,1,7]])
'''
[[16 17 18 19]
[ 8 9 10 11]
[ 4 5 6 7]
[28 29 30 31]]
'''
print(x[[-4,-2,-1,-7]])
'''
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
'''
print(x[np.ix_([1,5,7,2],[0,3,1,2])])
'''
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
'''
广播（broadcast）
广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。
import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c = a * b
print (c) # [ 10 40 90 160]
当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。如：
import numpy as np
a = np.array([[ 0, 0, 0],
[10,10,10],
[20,20,20],
[30,30,30]])
b = np.array([1,2,3])
print(a + b)
'''
[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
'''
广播的规则:
让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
输出数组的形状是输入数组形状的各个维度上的最大值。
如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
简单理解：
对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：
- 数组拥有相同形状。
- 当前维度的值相等。
- 当前维度的值有一个是 1。
若条件不满足，抛出 “ValueError: frames are not aligned” 异常。
线性代数
数组的转置/轴对换只会返回源数据的一个视图，不会对源数据进行修改。
代码示例：
numpy.dot()
类似于np.matmul()
numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；
对于二维数组，计算的是两个数组的矩阵乘积；
对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。
numpy.dot(a, b, out=None)
a : ndarray 数组
b : ndarray 数组
out : ndarray, 可选，用来保存dot()的计算结果
k = numpy.arange(9)
m = k.reshape((3,3)) # 改变数组的shape复制生成2维的，每个维度长度为3的数组
print(k) # [0 1 2 3 4 5 6 7 8]
print(m) # [[0 1 2] [3 4 5] [6 7 8]]
# 转置(矩阵)数组：T属性 : mT[x][y] = m[y][x]
print(m.T) # [[0 3 6] [1 4 7] [2 5 8]]
# 计算矩阵的内积 xTx
print(numpy.dot(m,m.T)) # numpy.dot点乘
a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(np.dot(a,b))
'''
[[37 40]
[85 92]]
'''
numpy.vdot()
numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。
import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
# vdot 将数组展开计算内积
print (np.vdot(a,b)) # 130
计算式：
1*11 + 2*12 + 3*13 + 4*14 = 130
numpy.inner()
numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。
import numpy as np
print (np.inner(np.array([1,2,3]),np.array([0,1,0]))) # 等价于 1*0+2*1+3*0=2
a = np.array([[1,2], [3,4]])
b = np.array([[11, 12], [13, 14]])
print (np.inner(a,b))
'''
[[35 41]
[81 95]]
'''
（多维点积）内积计算式：
1*11+2*12, 1*13+2*14
3*11+4*12, 3*13+4*14
numpy.matmul
类似于np.dot()
numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。
另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。
import numpy as np
对于二维数组，它就是矩阵乘法：
a = [[1,0],[0,1]]
b = [[4,1],[2,2]]
print (np.matmul(a,b))
'''
[[4 1]
[2 2]]
'''
二维和一维运算：
a = [[1,0],[0,1]]
b = [1,2]
print (np.matmul(a,b))
print (np.matmul(b,a))
'''
[1 2]
[1 2]
'''
a = np.array([[1, 2], [3, 4]])
b = np.array([5, 6]) # 一维向量默认都是纵向量
print(np.matmul(a, b)) # [17 39] 可正常算出
print(np.matmul(b, a)) # [23 34] 不能正常算出，用广播：
'''
原来的纵向量变成第一维度的向量，第二维度的用[1, 1]充当。
结果再把第二维度的向量抹去。
b * a = [[5 6], * [[1 2],
[1 1]] [3 4]]
= [[23 34],
[4 6]]
'''
维度大于二的数组 ：
a = np.arange(8).reshape(2,2,2)
b = np.arange(4).reshape(2,2)
print (np.matmul(a,b))
'''
[[[ 2 3]
[ 6 11]]
[[10 19]
[14 27]]]
'''
numpy.linalg.det()
numpy.linalg.det() 函数计算输入矩阵的行列式。对于矩阵[[a，b]，[c，d]]，行列式计算为 ad-bc。
import numpy as np
a = np.array([[1,2], [3,4]])
print (np.linalg.det(a)) # -2.0
b = np.array([[6,1,1], [4, -2, 5], [2,8,7]])
print (b)
print (np.linalg.det(b))
print (6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2))
'''
[[ 6 1 1]
[ 4 -2 5]
[ 2 8 7]]
-306.0
-306
...
numpy.linalg.inv()
numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。
逆矩阵（inverse matrix）：设A是数域上的一个n阶矩阵，若在相同数域上存在另一个n阶矩阵B，使得： AB=BA=E ，则我们称B是A的逆矩阵，而A则被称为可逆矩阵。注：E为单位矩阵。
A = [[1,1,1],[0, 2, 5],[2, 5, -1]]
B = [6, -4 ,27]
C = np.linalg.inv(A)
'''
[[ 1.28571429 -0.28571429 -0.14285714]
[-0.47619048 0.14285714 0.23809524]
[ 0.19047619 0.14285714 -0.0952381 ]]
'''
print(np.dot(C,B)) # [ 5. 3. -2.]
numpy.linalg.solve()
numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解。
print(np.linalg.solve(A,B)) # [ 5. 3. -2.]
numpy.transpose()
矩阵转置：
可以使用 numpy.transpose 函数来对换数组的维度，还可以使用 T 属性。。
a = np.arange(12).reshape(3, 4)
print(a)
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
'''
print(a.T)
'''
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
'''
print(np.transpose(a))
'''
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
'''
NumPy 矩阵库(Matrix)
NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。
矩阵总是二维的，而 ndarray 是一个 n 维数组。 两个对象都是可互换的。
numpy.matlib.zeros()
numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。
import numpy.matlib # 记得矩阵库
import numpy as np
print (np.matlib.zeros((2,2)))
'''
[[0. 0.]
[0. 0.]]
numpy.matlib.ones()
numpy.matlib.ones()函数创建一个以 1 填充的矩阵。
import numpy.matlib
import numpy as np
print (np.matlib.ones((2,2)))
'''
[[1. 1.]
[1. 1.]]
'''
numpy.matlib.eye()
numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。
numpy.matlib.eye(n, M,k, dtype)
- n: 返回矩阵的行数
- M: 返回矩阵的列数，默认为 n
- k: 对角线的索引
- dtype: 数据类型
import numpy.matlib
import numpy as np
print (np.matlib.eye(n = 3, M = 4, k = 0, dtype = float))
'''
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]]
'''
numpy.matlib.identity()
numpy.matlib.identity() 函数返回给定大小的单位矩阵。
单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。
import numpy.matlib
import numpy as np
# 大小为 5，类型位浮点型
print (np.matlib.identity(5, dtype = float))
'''
[[ 1. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 1.]]
'''
numpy.matlib.rand()
numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。
import numpy.matlib
import numpy as np
print (np.matlib.rand(3,3))
'''
[[0.23966718 0.16147628 0.14162 ]
[0.28379085 0.59934741 0.62985825]
[0.99527238 0.11137883 0.41105367]]
'''
数组操作
迭代数组：
NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。
（迭代器最基本的任务的可以完成对数组元素的访问。 ）
接下来我们使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代。
import numpy as np
a = np.arange(6).reshape(2,3)
print ('原始数组是：')
print (a)
print ('\n')
print ('迭代输出元素：')
for x in np.nditer(a):
print (x, end=", " )
print ('\n')
'''
原始数组是：
[[0 1 2]
[3 4 5]]
迭代输出元素：
0, 1, 2, 3, 4, 5,
'''
以上实例不是使用标准 C 或者 Fortran 顺序，选择的顺序是和数组内存布局一致的，这样做是为了提升访问的效率，默认是行序优先（row-major order，或者说是 C-order）。
可以通过显式设置，来强制 nditer 对象使用某种顺序：
for x in np.nditer(a, order='F'):Fortran order，即是列序优先；
for x in np.nditer(a.T, order='C'):C order，即是行序优先；
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print ('原始数组是：')
print (a)
print ('\n')
print ('原始数组的转置是：')
b = a.T
print (b)
print ('\n')
print ('以 C 风格顺序排序：')
c = b.copy(order='C')
print (c)
for x in np.nditer(c):
print (x, end=", " )
print ('\n')
print ('以 F 风格顺序排序：')
c = b.copy(order='F')
print (c)
for x in np.nditer(c):
print (x, end=", " )
'''
原始数组是：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
原始数组的转置是：
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
以 C 风格顺序排序：
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55,
以 F 风格顺序排序：
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,
'''
修改数组中元素的值
nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 write-only 的模式。
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print ('原始数组是：')
print (a)
print ('\n')
for x in np.nditer(a, op_flags=['readwrite']):
x[...]=2*x # 必须要有'...'
print ('修改后的数组是：')
print (a)
'''
原始数组是：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
修改后的数组是：
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
'''
扫一扫
2340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
