矩阵是一个由m*n个数排成的m行n列的表称为m行n列的矩阵，简称为m*n矩阵。下面的矩阵是一个3*2(3乘2)矩阵，因为它有三行四列。

在数学的概念中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合，最早来自于方程组的系数及常数所构成的方阵。这一概念由19世纪英国数学家凯利首先提出。

矩阵是高等代数学中的常见工具，也常见于统计分析等应用数学学科中。 矩阵的运算是数值分析领域的重要问题。将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。对一些应用广泛而形式特殊的矩阵，例如稀疏矩阵和准对角矩阵，有特定的快速运算算法。

python列表生成矩阵

在Python中也有矩阵的概念，但是Python中没有矩阵这种的内置类型。但是我们可以将Python中的列表看做一个矩阵。例如：

A = [[2,8],
	[-5,32],
	[0,8]]

我们可以把这个列表看做为是一个3行2列的矩阵。

接下来我们看一下如何使用嵌套列表。

A = [[1, 4, 5, 12], 
    [-5, 8, 9, 0],
    [-6, 7, 11, 19]]
print("A =", A) 
print("A[1] =", A[1])      # 第二行
print("A[1][2] =", A[1][2])   # 第二行的第三个元素
print("A[0][-1] =", A[0][-1])   # 第一行的最后一个元素
column = [];        # 一个空的列表
for row in A:
  column.append(row[2])   
print("第三列 =", column)

当我们运行上面的代码的时候，我们得到的输出将会是：

A = [[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]]
A[1] = [-5, 8, 9, 0]
A[1][2] = 9
A[0][-1] = 12
第三列 = [5, 9, 11]

使用嵌套的列表作为矩阵来说比较适合用于简单的计算任务，但是在Python中呢我们可以使用Numpy库，它在处理矩阵上有更好的方法。

numpy Array（数组）

Python中的Numpy库是一个用于科学计算的包，它是一个针对n维数组对象的强大的库，在想要使用Numpy之前，我们需要安装它才可以，那么我们怎么样才可以安装它呢？答案很简单，我们只需要在我们的电脑上下载安装Anaconda就可以了，Anaconda它本身就自带Numpy和其他的几个跟数据科学还有机器学习相关的库。

一旦我们安装完成了之后，我们就可以导入并使用它的功能了。Numpy提供针对数字的多维数组（实际上只是一个对象）举个例子来说：

import numpy as np
a = np.array([1, 2, 3])
print(a)        #打印变量a      
print(type(a))  #输出变量a的数据类型

最终的输出为

[1 2 3]
<class 'numpy.ndarray'>

就像你看到的输出一样，Numpy中的数组类名为ndarray。

那么我们如何创建一个Numpy数组呢？创建Numpy数组有很多方法，以下我们介绍一下创建数组的几种方法。

1.创建整数、浮点数、和复数的数组

import numpy as np
A = np.array([[1, 2, 3], 
              [3, 4, 5]]) #创建一个整数数组
print(A)

A = np.array([[1.1, 2, 3], 
              [3, 4, 5]]) #创建一个小数数组
print(A)

A = np.array([[1, 2, 3], 
              [3, 4, 5]], dtype = complex) # 创建一个复数数组
print(A)

当运行上方的代码时，我们得到的代码输出将会是：

[[1 2 3]
 [3 4 5]]

[[1.1 2.  3. ]
 [3.  4.  5. ]]

[[1.+0.j 2.+0.j 3.+0.j]
 [3.+0.j 4.+0.j 5.+0.j]]

2.创建0和1的数组

创建一个充满0的数组，我们需要使用np.zeros函数，np.zeros函数的参数如下：

np.zeros（shape，dtype=float，order=“C”)：返回一个给定形状和类型的用0填充的数组，一般我们只需要设置第一个参数就可以了；

Shape：数组的形状

dtype：数据类型，可选参数，默认为Numpy.float64(浮点数)

order：可选参数，C代表行优先；F代表列优先

dtype包括的数据类型：

参数代表意义t位数t4代表4位数b布尔值（bool）true或者falsei整数（int）i8（64位）u无符号整数u8（64位）f浮点数f8（64位）c浮点负数o对象s字符串s24u编码u24

下面我们就创建一个3行2列内容为0的数组

import numpy as np
zeors_array = np.zeros( (3, 2) )
print(zeors_array)

运行上方的代码我们得到的输出为：

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

创建一个充满1的数组，我们需要使用np.ones函数，np.ones函数的参数如下：

np.ones（shape，dtype=float，order=“C”)：返回一个给定形状和类型的用1填充的数组，函数内的参数与np.zeros相同，一般只需要设置第一个参数就好了。

下面我们生成一个5行5列类型为整数的数组。

import numpy as np
ones_array = np.ones((5,5),dtype=np.int32)
print(ones_array)

运行上方的代码，在代码中我们将dtype设置为int32位，占4个字节。因此这个数组可以取 -2147483648 ~ 2147483647之间的值，我们得到的输出为：

[[1 1 1 1 1]
 [1 1 1 1 1]
 [1 1 1 1 1]
 [1 1 1 1 1]
 [1 1 1 1 1]]

3.使用arange（）和reshape（）生成矩阵

np.arange（起点，终点，步长）函数返回一个有起点终点的固定步长的列表。np.arange函数分为三种情况：

1、一个参数：参数值为终点，起点取值默认为0，步长默认为12、 两个参数：第一个参数为起点，第二个参数为终点，步长默认为3、 三个参数：第一个参数为起点，第二个参数为终点，第三个参数为步长（支持小数）

np.reshape（shape）：shape参数为要设置矩阵的形状

下面我们生成一个长度为12的一维矩阵，然后将其设置为一个3行4列的矩阵

import numpy as np
a = np.arange(12)
print('a =',a)

b = np.arange(12).reshape(3,4)
print('b =',b)

通过运行上方的代码我们得到的输出为：

a = [ 0  1  2  3  4  5  6  7  8  9 10 11]
b = [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

矩阵运算

下面，我们将通过两个矩阵的加法，两个矩阵的乘法和一个矩阵的转置。我们之前可以使用嵌套的列表来编写这些。那么接下来我们看一下如何通过Numpy数组完成这些任务。

矩阵之间的加法

我们可以使用+这个运算符来计算两个numpy矩阵的对应元素

import numpy as np
A = np.array([[3, 7], 
              [5, -8]])
B = np.array([[2, -4], 
              [2, 0]])
C = A + B      
print(C)

运行上方的代码我们得到的输出为

[[ 5  3]
 [ 7 -8]]

矩阵之间的乘法

要将两个矩阵相乘，我们需要使用dot()方法，需要注意的是*只能用于数组乘法（两个数组对应元素的乘法），不用于矩阵乘法。

import numpy as np
A = np.array([[4,5,6],
              [-5, 0, 2]])
B = np.array([[3, 2], 
              [4, -1], 
              [4, -3]])
C = A.dot(B)
print(C)

运行代码我们得到的输出为：

[[ 56 -15]
 [ -7 -16]]

矩阵的转置

我们可以使用numpy.transpose来计算矩阵的转置。

import numpy as np
A = np.array([[1,3,5],
              [2,2,1], 
              [3,0,-3]])
print(A.transpose())

运行代码我们可以得到矩阵的转置，将列转为行，将行转为列。

[[ 1  2  3]
 [ 3  2  0]
 [ 5  1 -3]]

正如代码运行出的结果那样，使用Numpy我们可以更加简单的完成我们的任务。

查看矩阵中的元素、行与列

查看矩阵中的元素

查看矩阵中的元素跟列表比较相似，我们可以通过索引来查看矩阵中的元素，让我们先从简单的一维数据开始。

import numpy as np
A = np.array([2, 4, 6, 8, 10, 12, 14])
print("A[0] =", A[0])     # 查看数组中的第一个元素    
print("A[2] =", A[2])     # 查看数组中的第三个元素
print("A[-1] =", A[-1])   # 查看数组中的最后一个元素

运行代码我们得到的输出为：

A[0] = 2
A[2] = 6
A[-1] = 14

接下来我们查看如何查看一个二维数组（就是一个矩阵）的元素

import numpy as np
A = np.array([[11, 24, 3, 0],
              [-3, 7, 10, 8],
              [0, -7, 25, 32]])
#查看第一行的第一个元素
print("A[0][0] =", A[0][0])  
#查看第二行的第三个元素
print("A[1][2] =", A[1][2])
#查看最后一行的最后一个元素
print("A[-1][-1] =", A[-1][-1])     

运行上方的代码我们得到的输出为：

A[0][0] = 11
A[1][2] = 10
A[-1][-1] = 32

查看矩阵中的行

import numpy as np
A = np.array([[11, 24, 3, 0],
              [-3, 7, 10, 8],
              [0, -7, 25, 32]])
print("A[0] =", A[0]) # 查看第一行
print("A[2] =", A[1]) # 查看第二行
print("A[-1] =", A[-1]) # 查看最后一行 (在这个矩阵中为第三行)

运行代码我们得到的输出为：

A[0] = [11 24  3  0]
A[2] = [-3  7 10  8]
A[-1] = [ 0 -7 25 32]

查看矩阵中的列

import numpy as np
A = np.array([[11, 24, 3, 0],
              [-3, 7, 10, 8],
              [0, -7, 25, 32]])
print("A[:,0] =",A[:,0]) # 查看第一列
print("A[:,3] =", A[:,2]) # 查看第三列
print("A[:,-1] =", A[:,-1]) #查看最后一列(在这个矩阵中为第四列)

运行代码我们得到的输出为：

A[:,0] = [11 -3  0]
A[:,3] = [ 3 10 25]
A[:,-1] = [ 0  8 32]

矩阵的切片

一维数组中的切片其实类似于列表，举个例子，让我们看一下矩阵的切片

import numpy as np
matrix = np.array([1, 3, 5, 7, 9, 2, 4, 6, 8, 10])
# 查看第三个到第五个元素
print(matrix[2:5])        
# 查看第一个到第四个元素
print(matrix[:-5])          
# 查看第六个到最后一个元素
print(matrix[5:])        
# 查看第一个元素到最后一个元素
print(matrix[:])         
#将列表进行扭转进行查看
print(matrix[::-1])        

运行上面的代码我们可以得到的结果是：

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

现在我们看一下如何分割一个矩阵。

import numpy as np
A = np.array([[11, 24, 3, 0],
              [-3, 7, 10, 8],
              [0, -7, 25, 32]])
print(A[:2, :4])  # 查看前两行和前撕裂
print(A[:1,])  # 查看第一行和所有列
print(A[:,2])  # 查看所有的行和第二列
print(A[:, 2:5])  #查看所有的行和第三到第五列

现在运行代码，查看一下最终的结果。

[[11 24  3  0]
 [-3  7 10  8]]
 
[[11 24  3  0]]

[ 3 10 25]

[[ 3  0]
 [10  8]
 [25 32]]

以上就是在Python中Numpy库中矩阵的相关操作，希望可以帮到你理解，有什么问题欢迎进行留言，我们进行讨论哦~。