前言

在学习PyTorch的时候，我们首先需要将其与NumPy相联系，还是之前NumPy中提到过的，PyTorch中很多概念直接由NumPy中迁移对比理解就行

• np=>torch
• 数组array=>张量tensor
• n维数组/数组的维度=>n阶张量/张量的阶数

然后我们需要了解GPU存储张量/数据，如下，我们按照之前的方式创建一个阶张量并且打印

import torch  
ts1 = torch.randn(3,4)  
print(ts1)

输出
tensor([[ 1.3641, -0.3565, -1.1902,  0.4284],
        [ 0.6414,  0.0928,  0.7420,  0.0064],
        [ 1.3765, -0.8911, -0.5673, -1.7459]])

一切运行都没问题，但是默认上所有的输出都是在CPU上进行的，我们的深度学习要利用GPU，所以我们必须让GPU存储张量，这个时候我们需要用到data.to("cuda:0")，使用这个就可以让data存储到对应的0号GPU上(GPU有几号取决于你的设备，通过nvidia-smi查看有几个，有多个的可以cuda:1)

import torch  
ts1 = torch.randn(3,4).to("cuda")  
print(ts1)

同样的，我们在后续的学习中也需要把神经网络的模型也要搬到GPU上才可以正常运行，所以需要使用如下代码

class DNN(torch.nn.Module):
    ...略...

model = DNN().to("cuda:0")

所以这个to("cuda:0")很常用，大家需要记住和学会使用

DNN原理篇

DNN就是深度神经网络，其核心就是：通过学习大量样本的输入和输出特征之间的关系，以拟合出输入和输出之间的方程，学习完毕后，能达到你给输出特征，他给出输出特征。神经网络可以分为如下几个步骤：划分数据集，训练网络，测试网络，使用网络

划分数据集

首先，数据集是一个包含多个样本的集合，每个样本都必须要有输入和输出，将数据集按照一定比例划分为训练集和测试集，分别用于训练网络和测试网络（简单理解：数据集=训练集+测试集）
如下数据集，1000个样本，三个输入，三个输出，按照8:2的比例划分

神经节点是根据数据集来的，因为输入和输出都是三个，那么肯定输入和输出都会需要三个神经元，即输入神经元必须和每个样本的输入特征数量一致，输出层必须和每个样本的输出特征数量一致。至于中间的隐藏层可以自行设计
如下图，是可以适用于上面数据集的神经网络结构，因为在编程语言中索引都是从0开始的，所以我们神经网络结构图也从输入层开始称之为第0层，依次往后就是第1层，第2层...

训练网络

神经网络的训练过程就是经过很多次前向传播和反向传播的轮回，最终不断调整其内部参数（权重w和偏置b）以拟合任意复杂函数的过程，内部参数一开始是随机的（例如Xavier初始值，He初始值），但是最终会被不断优化到最佳，神经网络的最终目的就是为了优化内部参数，仅此一个目标而已

当然，还有一些训练网络在开始之前需要设置好一些外部参数，例如网络的层数，每个隐藏层的节点数，每个节点的激活函数类型，学习率，轮回次数，每次轮回的样本数等等，业界习惯把内部参数称之为参数，外部参数称之为超参数

前向传播

所谓前向传播就是：将输入特征送入到神经网络输出层后，神经网络逐层计算最终到输出层，简单理解就是从输入到输出的一个过程就称之为前向传播

计算过程中所使用的参数就是内部参数，所有的隐藏层与输出层的神经元都有内部参数,输入层是没有参数的
假设现在我们要将输入进入到第一层的第一个神经元上进行计算，该神经元节点的计算过程为y=w1*x1+w2*x2+w3*x3+b。你可以理解为，每一根线就是一个权重 ω，每一个神经元节点也都有它自己的偏置 b。

因为按照上面的过程得到每个神经元节点的函数都是线性的方程，所以必须在计算完成后套一个非线性的函数，也称之为激活函数

为什么需要一个非线性的激活函数呢？这个很好理解，训练网络就是来回训练，你全部都是线性计算那么其实根本不需要来回训练，训练一次其实就拟合出来了。如下，一个比较简单的四层神经网络，反向来看，y=w5 z5+w6 z6 +d，然后依次把z5和z6逐层拆分，那么在最后肯定是得到一个关于X的线性方程即ax+b这样的形式，如果有多个输入，也无非就是多加了几个元，即y=a1x1+a2x2+b，所以激活函数是必备的

反向传播

经过前向传播，网络会根据当前的内部参数计算出一个输出特征的预测值，但是这个预测值和真实值之间肯定会存在很大的差距。首先我们会需要一个损失函数来计算这个差距（例如求预测值和真实值之间的差的绝对值，这个就是一个典型的损失函数）

损失函数计算完之后，逐层退回求梯度(这个过程涉及到了比较复杂的数学理论,目前先可以不需要掌握。这个过程的逻辑大概就是看看每个内部参数变大还是变小，能减少损失函数值，也就是调整内部参数以减少损失函数值)，从而达到优化内部参数的目的

在这个过程中，有一个外部参数称之为学习率，学习率越大，内部参数优化越快，但是不能过大，过大的学习率会导致损失函数越过最低点在谷底反复横跳，因此在训练开始前选择一个合适的学习率很重要（可以这么理解，想象一个先下降后上升的函数，在这个过程中我们的损失函数是越来越低的，但是会存在一个最低点，学习率越大，下降的越快，但是可能下降的过多导致超过了这个最低点，最低点后又会变大了，变大后就得逆向调整，但是因为每次变化都比较大，就是达到不到那个最低点，从而导致反复横跳）

batch_size

前向传播和反向传播一次时，有如下三种情况

• 批量梯度下降（BGD），把所有的样本一次性输入进网络，这种方式计算开销很大，速度很慢
• 随机梯度下降（SGD），每次只把一个样本输入进网络，每计算一个样本就更新一次参数，这种方式速度很快但是收敛性很差，可能会在最优点附近震荡，两次参数的更新也有可能抵消
• 小批量梯度下降(MBGD)，为了中和上面两种方式而诞生的，把样本规划为若干批，按照批次来更新参数
  所谓的batch_size也就是一批次中的样本数，也就是一次性喂进网络的样本数，此外由于 Batch Normalization 层（Batch正规化层，用于将每次产生的小批量样本进行标准化）的存在，batch_size 一般设置为 2 的幂次方，并且不能为 1。

  注意，PyTorch实现时只支持批量和小批量梯度下降，即第一个和第三个情况，不支持单个样本的输入方式。PyTorch中的torch.optim.SGD只表示梯度下降

epochs

一个epochs就是指全部数据完成了一次前向传播和后向传播
为了帮助理解，可以看一下如下的说明
假设样本一共有10240个，batch_size=1024，epochs=5，这个情况说明

1. 1个epochs需要10次（10240/1024）前向传播和后向传播
2. 全部样本都将进行5次前向传播和后向传播
3. 整个过程经过了（10* 5）次前向传播和后向传播

测试网络

测试网络的目的主要是为了防止训练过拟合，所谓的过拟合就是，训练过头，网络优化后的内部参数只针对于训练样本有效，对于别的样本无效。（可以理解为原本要训练成一个普遍适用的函数，结果训练过头成为了训练样本的特例函数）所以网络训练好后，需要拿测试集作为输入，进行一次前向传播后，将结果与测试集的真实输出进行对比查看准确率

使用网络

真正使用网络进行预测时，样本只知输入，不知输出。直接将样本的输入进行 1 次前向传播，即可得到预测的输出。

DNN的实现

在Python的第三方库中，torch.nn提供了搭建网络所需要的所有组件，所以我们可以映入库且为了方便别名nn

import torch.nn as nn

按照之前原理篇内容，我们知道DNN的四个步骤，其中第一个步骤就是划分数据集

那么我们首先来准备数据集，在这里我们生成10000个样本，每个样本设定三个输入特征(X1,X2,X3)和三个输出特征(Y1,Y2,Y3)，我们规定

• 每个输入特征相互独立，均服从均匀分布
• 当（X1+X2+X3）<1的时候，Y1为1，否则Y1=0
• 当1<（X1+X2+X3）<2的时候，Y2为1，否则Y2=0
• 当（X1+X2+X3）>2的时候，Y3为1，否则Y3=0
  那么对应的Python代码如下

import torch.nn as nn  
import torch  

# 生成三个输入特征，rand生成1000行1列的范围在[0,1]的张量  
X1 = torch.rand(1000,1)  
X2 = torch.rand(1000,1)  
X3 = torch.rand(1000,1)  

# 生成输出特征, .float()将布尔张量转化为浮点型张量  
Y1 = ( (X1+X2+X3)<1 ).float() # 输出特征 1
Y2 = ( (1<(X1+X2+X3)) & ((X1+X2+X3)<2) ).float() # 输出特征 2
Y3 = ( (X1+X2+X3)>2 ).float() # 输出特征 3  
data = torch.cat([X1,X2,X3,Y1,Y2,Y3],axis=1) # 整合数据集  
data = data.to('cuda:0')  # 迁入到GPU
print(data.shape) # torch.Size([1000, 6])

数据集准备完毕后，我们需要划分数据集为测试集和样本集

# 划分数据集大小 我们采用7:3  
train_size = int(len(data)*0.7)  
test_size = len(data)-train_size  
# 打乱数据  data.size(0)获取第0维度即第一列的长度 
# arr.randperm(n)打乱arr上0~n-1索引内的范围
data = data[torch.randperm(data.size(0)),:]  
train_data = data[0:train_size,:] # 训练集  
test_data = data[train_size:len(data)] # 测试集  
print(train_data.shape, test_data.shape,sep="##")  # 打印查看是否正确划分

这部分基本属于通用代码，以后如果需要都可以直接拿着用

数据都准备好了，接下就是需要构建网络,一般在搭建自己的神经网络的时候，可以以nn.Module为父类，该对象中包含了网络各个层的定义

在定义的网络子类中，通常包含__init__构造方法和forward方法，其中init方法用于构造自己的神经网络结构，forward方法用于将输入数据进行前向传播。由于张量可以自动计算梯度，所以不需要出现反向传播方法。

class MyDNN(nn.Module):  
    def __init__(self):  
        ''' 搭建神经网络各个层 '''        
        super(MyDNN,self).__init__() 
        #Sequential() 可以理解为顺序队列，在里面按顺序定义各个隐藏层，不要把输入层定义在里面 
        self.net = nn.Sequential( 
        # 隐藏层也称之为线形层所以我们这方法也就是.Linear(preNodeNumber,selfNodeNumber)  
        # 两个参数是 上一层节点数和本层节点数  
        # 因为这是第一层隐藏层，所以上一层就是输入层，我们是三个输入特征，所以第一个参数为3  
            nn.Linear(3,5),  
            # 激活函数 激活函数一般有ReLU tanh sigmoid,一般选ReLU  
            nn.ReLU(),  
            # 再来一个隐藏层 只不过这个隐藏层的输入是上一层的输出，所以第一个参数为5  
            nn.Linear(5,5),  
            nn.ReLU(),  
            nn.Linear(5,5),  
            nn.ReLU(),  
            nn.Linear(5,3)  
        )  

    def forward(self,x):  
        '''  前向传播 '''        # net就是上面定义的顺序队列，上面叫啥这里就调用啥  
        y = self.net(x)  
        return y # y即输出数据

# 创建MyDNN实例对象且放入GPU，打印查看一下
dnn = MyDNN().to('cuda:0')
print(dnn)

输出
MyDNN(
  (net): Sequential(
    (0): Linear(in_features=3, out_features=5, bias=True)
    (1): ReLU()
    (2): Linear(in_features=5, out_features=5, bias=True)
    (3): ReLU()
    (4): Linear(in_features=5, out_features=5, bias=True)
    (5): ReLU()
    (6): Linear(in_features=5, out_features=3, bias=True)
  )
)

我们构建了网络，但是有没有发现好像并没有设计到内部参数即权重和偏置，其内部参数其实在神经网络训练前会被赋予随机数，且随着训练会逐渐迭代至最佳值
我们可以通过DNN对象.named_parameters()+for循环进行查看

for name,param in dnn.named_paramaeters():
    print(f"参数:{name}\n 形状:{param.shape}\n 数值:{param}\n")

可以看到遍历了所有的神经元节点，展示了每个节点的权重w和偏置b，可以看到w是[5,3]那么也就是一共15根线，每一根线是不同的权重，这个和我们上面的那个图是一致的；b是[5]，而我们的第一层隐藏层也是五个节点，也就是每个节点都有自己的偏置b，初始值都是随机的
而且可以看到，有权重和偏置的是0，2，4，6这几个节点，这是因为1，3，5都是激活函数；所有的节点后面都是device="cuda:0"说明都在GPU上 ； 所有的requires_grad=True是说明是否需要计算梯度，这里都是True说明需要进行反向传播的内部参数都打开了张量自带的梯度计算功能

我们再来看一下外部参数，外部参数是调参师/炼丹师！关注的重点，包括但不限于网络层数;各隐藏层节点数;各节点激活函数;内部参数的初始值，和训练网络有关的超参数有损失函数,学习率,优化算法,batch_size,epochs

对于激活函数，我们可以访问访问对应版本的文档torch.nn — PyTorch 2.1 documentation查看PyTorch内置的激活函数，有很多而且点对应的函数可以看到其数学公式和函数图像，我们这里使用的就是ReLu()

对于损失函数，可以访问对应版本的torch.nn — PyTorch 2.1 documentation，也有很多

loss_fn = nn.MSELoss()

对于学习率和优化算法可以访问torch.optim — PyTorch 2.10 documentation，这里面比较出名的就是SGD,Adam，可以按照他的实例进行使用,lr参数就是学习率，需要注意的是，PyTorch实现时只支持BGD和MBGD，不支持单个样本的输入方式，我们下面案例代码中torch.optim.SGD只代表梯度下降

learning_rate = 0.01 #学习率
optimizer = torch.optim.SGD(dnn.parameters(),lr=learing_rate)# 优化算法

都准备好了，接下来就可以训练网络了。
训练网络就是一个来回进行前向传播和反向传播的过程，所以最外层我们就是一个循环
然后使用dnn(输入特征)可以得到预期值Pred
然后有了预期值就需要和真实值计算误差函数loss = loss_fn(预期值Pred,真实输出特征Y) 这里的loss_fn是前面定义的损失函数名
每一轮梯度都会不一样，为了不受前面的影响，需要记得清除上一轮滞留的梯度optimizer.zero_grad()，其中optimizer是优化算法对象
之后进行反向传播loss.backward()，loss是上面误差函数调用后的返回值
最后利用优化算法对象进行一次内部参数优化optimizer.step()

# 训练网络  
epochs = 1000 # 所有样本都会轮回1000次  
losses = [] # 用于记录损失函数变化的列表  

# 给训练集划分输入和输出(在我们当前案例中前三列为输入，后三列为输出)  
X = train_data[:,:3]  
Y = train_data[:,-3:]  
# 开始循环进行训练  
for epoch in range(epochs):  
    Pred = dnn(X) # 一次前向传播BGD  
    loss = loss_fn(Pred, Y) # 计算损失函数  
    # 保存记录损失值  
    # loss.item()方法可以将损失函数降级为一个元素  
    # 因为loss是一个张量，张量不能直接存储在list中，所以这里要先降级  
    losses.append(loss.item())  
    optimizer.zero_grad() # 每一轮梯度都不一样 消除上一轮滞留的梯度  
    loss.backward() # 一次反向传播  
    optimizer.step() # 优化内部参数  

Fig = plt.figure()  
plt.plot(range(epochs),losses)  
plt.xlabel('epochs')  
plt.ylabel('loss')  
plt.show()

可以看到训练后损失函数越来越少

最后是测试网络
测试时只需要让测试集进行一次向前传播即可，不需要计算梯度，所以可以局部关闭梯度，该操作使用with torch.no_grad()命令实现
考虑到输出特征时独热编码，而预测的数据一般都接近0/1的小数，为了让预测数据和真实数据之间进行比较，需要对预测数据进行规整。除此之外还要计算预测值正确总数从而计算占比

# 测试网络  
# 将测试集的输入特征和输出特征分开  
X = train_data[:,:3]  
Y = train_data[:,-3:]  
# 进行一次前向传播  
# 局部关闭梯度计算功能 这个部分的代码块不会进行梯度计算  
with torch.no_grad():  
    Pred = dnn(X) # 前向传播一次  
    # 输出特征是独热编码，预测数据一般都是0~1内的小数，需要进行格式规整  
    # 预测结果Pred中，每行样本都是三个输出，最大的那个也就是最有可能的，将其设置为1，其余的设置为0  
    # 这样子Pred就和真实结果集格式一致  
    Pred[:,torch.argmax(Pred,axis=1)]=1  
    Pred[Pred!=1]=0  
    # 计算测试集的准确度  
    # Pred==Y 让预测结果和真实结果比较 得到3000行3列布尔类型的张量  
    # .all()方法会扫描只有全部为True的时候才会返回True (1)代表按行扫描 得到一个3000行1列的张量  
    # torch.sum就是将3000行相加，True为1False为0，所以最终结果就是预测值==真实值的正确样本总数  
    correct = torch.sum((Pred==Y).all(1)) # 预测结果正确的样本  

    # 正常数组shape(行,列,...) 类比到张量就是 第0维就是对应行，第1维对应列  
    # 可以理解为shape(0维,1维,2维)  
    # size(维度)是张量特有的，numpy中没有  
    total = Y.size(0) # 第一个维度上的值也就是3000  
    print(f'测试集精准度:{100*correct/total}%')

归纳：到目前为止，我们已经初步完成了一个DNN的入门代码案例，整个代码内容和运行结果如下

import torch.nn as nn  
import torch  
from matplotlib import pyplot as plt  

class MyDNN(nn.Module):  
    def __init__(self):  
        ''' 搭建神经网络各个层 '''  
        #Sequential() 可以理解为顺序队列，在里面按顺序定义各个隐藏层，不要把输入层定义在里面 
        super(MyDNN,self).__init__()  
        self.net = nn.Sequential( 
        # 隐藏层也称之为线形层 所以我们这方法也就是.Linear(preNodeNumber,selfNodeNumber) 
        # 两个参数是 上一层节点数和本层节点数  
        # 因为这是第一层隐藏层，所以上一层就是输入层，我们是三个输入特征，所以第一个参数为3  
            nn.Linear(3,5),  
        # 激活函数 激活函数一般有ReLU tanh sigmoid,一般选ReLU  
            nn.ReLU(),  
        # 再来一个隐藏层 只不过这个隐藏层的输入是上一层的输出，所以第一个参数为5  
            nn.Linear(5,5),  
            nn.ReLU(),  
            nn.Linear(5,5),  
            nn.ReLU(),  
            nn.Linear(5,3)  
        )  

    def forward(self,x):  
        '''  前向传播 '''        
        # net就是上面定义的顺序队列，上面叫啥这里就调用啥  
        y = self.net(x)  
        return y # y即输出数据  

dnn = MyDNN().to('cuda:0') # 放入GPU  
loss_fn = nn.MSELoss() # 损失函数  
learing_rate = 0.01 # 学习率  
optimizer = torch.optim.SGD(dnn.parameters(),lr=learing_rate) # 优化算法  

# 生成三个输入特征，rand生成1000行1列的范围在[0,1]的张量  
X1 = torch.rand(1000,1)  
X2 = torch.rand(1000,1)  
X3 = torch.rand(1000,1)  

# 生成输出特征, .float()将布尔张量转化为浮点型张量  
Y1 = ( (X1+X2+X3)<1 ).float() # 输出特征 1
Y2 = ( (1<(X1+X2+X3)) & ((X1+X2+X3)<2) ).float() # 输出特征 2
Y3 = ( (X1+X2+X3)>2 ).float() # 输出特征 3  
data = torch.cat([X1,X2,X3,Y1,Y2,Y3],axis=1) # 整合数据集  
data = data.to('cuda:0')  
print(data.shape) # torch.Size([1000, 6])  

# 划分数据集大小 我们采用7:3  
train_size = int(len(data)*0.7)  
test_size = len(data)-train_size  
# 打乱数据  
data = data[torch.randperm(data.size(0)),:]  
train_data = data[0:train_size,:] # 训练集  
test_data = data[train_size:len(data)] # 测试集  
print(train_data.shape, test_data.shape,sep="##")  # 打印查看是否正确划分  

# 训练网络  
epochs = 1000 # 所有样本都会轮回1000次  
losses = [] # 用于记录损失函数变化的列表  

# 给训练集划分输入和输出(在我们当前案例中前三列为输入，后三列为输出)  
X = train_data[:,:3]  
Y = train_data[:,-3:]  
# 开始循环进行训练  
for epoch in range(epochs):  
    Pred = dnn(X) # 一次前向传播BGD  
    loss = loss_fn(Pred, Y) # 计算损失函数  
    # 保存记录损失值  
    # loss.item()方法可以将损失函数降级为一个元素  
    # 因为loss是一个张量，张量不能直接存储在list中，所以这里要先降级  
    losses.append(loss.item())  
    optimizer.zero_grad() # 每一轮梯度都不一样 消除上一轮滞留的梯度  
    loss.backward() # 一次反向传播  
    optimizer.step() # 优化内部参数  

Fig = plt.figure()  
plt.plot(range(epochs),losses)  
plt.xlabel('epochs')  
plt.ylabel('loss')  
plt.show()  

# 测试网络  
# 将测试集的输入特征和输出特征分开  
X = train_data[:,:3]  
Y = train_data[:,-3:]  
# 进行一次前向传播  
# 局部关闭梯度计算功能 这个部分的代码块不会进行梯度计算  
with torch.no_grad():  
    Pred = dnn(X) # 前向传播一次  
# 输出特征是独热编码，预测数据一般都是0~1内的小数，需要进行格式规整  
# 预测结果Pred中，每行样本都是三个输出，最大的那个也就是最有可能的，将其设置为1，其余的设置为0  
# 这样子Pred就和真实结果集格式一致  
    Pred[:,torch.argmax(Pred,axis=1)]=1  
    Pred[Pred!=1]=0  
# 计算测试集的准确度  
# Pred==Y 让预测结果和真实结果比较 得到3000行3列布尔类型的张量  
# .all()方法会扫描只有全部为True的时候才会返回True (1)代表按行扫描 得到一个3000行1列的张量  
# torch.sum就是将3000行相加，True为1False为0，所以最终结果就是预测值==真实值的正确样本总数  
    correct = torch.sum((Pred==Y).all(1)) # 预测结果正确的样本  

# 正常数组shape(行,列,...) 类比到张量就是 第0维就是对应行，第1维对应列  
# 可以理解为shape(0维,1维,2维)  
# size(维度)是张量特有的，numpy中没有  
    total = Y.size(0) # 第一个维度上的值也就是3000  
    print(f'测试集精准度:{100*correct/total}%')

网络保存与导入

有时候训练一个大网络需要几天，那么必须要把整个网络连同里面的优化好的内部参数给保存下来下次使用或者别的设备使用，这里就需要用到网络的保存与导入
网络的保存使用torch.save(dnn,文件名.pth)；网络的导入使用torch.load(文件名)（load方法有个weights_only 参数决定安全策略，低版本中默认为False直接使用没问题，但是高版本中默认值从 False 改为 True，所以高版本中要使用需要指定一下torch.load(文件名,weights_only=False)）
我们继续拿上面的案例尝试一下保存和导入，然后进行测试，测试准确率一致

torch.save(dnn,'MyFirstDNN.pth')
newDnn = torch.load('MyFirstDNN.pth',weights_only=False)  
# 用导入的newDnn进行测试  
with torch.no_grad():  
    Pred = newDnn(X)  
    Pred[:,torch.argmax(Pred,axis=1)]=1  
    Pred[Pred!=1]=0  
    correct = torch.sum((Pred==Y).all(1))  
    total = Y.size(0)  
    print(f'newDnn测试集精准度:{100*correct/total}%')

批量梯度下降

上面的DNN的相关实现的案例其实就是一种批量梯度下降，我们暂且先不用管批量梯度下降的具体含义和定义。接下来，我们使用一个已有的数据进行实战
我们这里有一份Data.xlsx的关于糖尿病相关的数据文件

对此我们进行依次批量梯度下降的深度神经网络学习的代码编写

import numpy as np  
import pandas as pd  
import torch.nn as nn  
import torch  
from matplotlib import pyplot as plt  

class MyDnn(nn.Module):  
    def __init__(self):  
        ''' 搭建自己的网络 '''        super(MyDnn, self).__init__()  
        self.net = nn.Sequential(  
            nn.Linear(8,32),  
            nn.Sigmoid(),  
            nn.Linear(32,8),  
            nn.Sigmoid(),  
            nn.Linear(8,4),  
            nn.Sigmoid(),  
            nn.Linear(4,1),  
            nn.Sigmoid()  
        )  

    # 核心修正：forword → forward  
    def forward(self,x):  
        ''' 前向传播 '''        y = self.net(x)  
        return y  

sourceData = pd.read_csv(r"D:\ZhuoMian\Data.csv", index_col=0)  
# 验证读取结果（打印前5行 + 数据基本信息）  
print(sourceData.head())  # 打印前5行  
# 转化为NumPy数据类型并且转化为float类型  
arr = sourceData.values.astype(np.float32)  
# 转化为张量且放入GPU上  
ts = torch.tensor(arr)  
ts = ts.to('cuda:0')  
print(ts)  
print("======================")  

# 依旧按照3：7划分训练集和测试集  
train_size = int(len(ts)*0.7)  
test_size = len(ts)-train_size  
# 打乱数据  
random_ts = ts[torch.randperm(ts.size(0)),:]  
train_data = random_ts[:train_size]  
test_data = random_ts[train_size:]  
print(train_data)  
print(test_data)  

model = MyDnn().to('cuda:0')  
print(model)  

# 创建损失函数 和 优化算法  
loss_fun = nn.BCELoss(reduction='mean')  
learing_rate = 0.005  # 注：learning 拼写错误，建议改为 learning_rateoptimizer = torch.optim.Adam(model.parameters(), lr=learing_rate)  

# 开始训练  
epochs = 5000  
losses = []  

X = train_data[:,:-1]  
Y = train_data[:,-1].reshape(-1,1) # reshape将一阶张量变为二阶  
for epoch in range(epochs):  
    pred = model(X)  # 对应变量名修正  
    loss = loss_fun(pred,Y)  
    losses.append(loss.item())  
    optimizer.zero_grad()  
    loss.backward()  
    optimizer.step()  

# 画图展示  
fig = plt.figure()  
plt.plot(range(epochs),losses)  
plt.xlabel("epoch")  
plt.ylabel("loss")  
plt.show()  

# 测试  
X = test_data[:,:-1]  
Y = test_data[:,-1].reshape(-1,1)  
with torch.no_grad():  
    pred = model(X)   
    pred[pred >=0.5] = 1  
    pred[pred <0.5] = 0  
    currentSize = torch.sum((pred==Y).all(1))  
    # 精度打印修正：转浮点型，避免张量显示问题  
    accuracy = 100 * currentSize / Y.size(0)  
    print(f"测试准确度 {accuracy.item():.2f}%")

小批量梯度下降

我们依旧使用上面的数据和神经网络结构，但是本次采用的方式为小批量梯度下降，使用小批量梯度下降的时候需要使用Pytorch的三个内置的实用工具

• DataSize用于封装数据集
• DataLoader用于加载数据不同的批次
• random_split用于划分训练集与测试集

from torch.utils.data import Dataset, DataLoader,random_split

整体步骤是差不多的，首先依旧是制作数据集
在小批量梯度下降制作数据集的时候，我们需要用制作一个类继承上面说的DataSet且重写其__init__方法;__getitem__;__len__三个方法，三个方法的作用分别是加载数据集，获取数据索引，获取数据总量
小批量梯度下降和批量梯度下降在代码上，主要是数据集的封装划分;训练网络；测试网络上有一些不同，其余的定义神经网络模型，损失函数定义和使用，优化算法的定义和使用都是一样的

这里不详细逐步介绍了，自行看代码查看不同和理解小批量梯度下降的处理逻辑

import numpy as np  
import pandas as pd  
import torch.nn as nn  
import torch  
from torch.utils.data import Dataset, DataLoader,random_split  
from matplotlib import pyplot as plt  

# 小批量梯度下降  
# 封装数据集  
class MyData(Dataset):  
    def __init__(self, filePath):  
        ''' 加载数据集 '''        # 我们的数据集还是之前那些数据，所以把之前通过Pandas获取数据的逻辑写到这里来即可  
        sourceData = pd.read_csv(filePath, index_col=0)  
        # 验证读取结果（打印前5行 + 数据基本信息）  
        print(sourceData.head())  # 打印前5行  
        # 转化为NumPy数据类型并且转化为float类型  
        arr = sourceData.values.astype(np.float32)  
        # 转化为张量且放入GPU上  
        ts = torch.tensor(arr)  
        ts = ts.to('cuda:0')  
        self.X = ts[:, :-1]  # 前八列为输入特征  
        self.Y = ts[:, -1].reshape(-1, 1)  # 最后一列为输出特征  
        self.len = ts.size(0)  

    # 获取数据索引  
    def __getitem__(self, index):  
        return self.X[index], self.Y[index]  

    # 获取数据集的长度  
    def __len__(self):  
        return self.len  

Data = MyData("D:/ZhuoMian/Data.csv")  
train_size = int(len(Data) * 0.7)  # 训练集大小  
test_size = len(Data) - train_size  # 测试集大小  
train_data, test_data = random_split(Data, [train_size, test_size])  # 直接利用工具函数 让其帮助我们进行测试集和训练集的划分  
# 批次加载器 第一个为数据集 第二个数据为批次数据 第三个参数为是否每一个epoch之内都要进行小批次划分 true为是的 false为否  
# 我们可以从批次加载器中获取训练数据  
# 一般我的训练集需要shuffler为True 保证每次不同从而训练效果好 测试集因为只要一次 所以没必要每次都划分  
train_loader = DataLoader(train_data, batch_size=128, shuffle=True)  
test_loader = DataLoader(test_data, batch_size=64, shuffle=False)  

# 搭建神经网络  
class DNN(nn.Module):  
    def __init__(self):  
        super(DNN, self).__init__()  
        self.net = nn.Sequential(  
            nn.Linear(8, 32), nn.Sigmoid(),  
            nn.Linear(32, 8), nn.Sigmoid(),  
            nn.Linear(8, 4), nn.Sigmoid(),  
            nn.Linear(4, 1), nn.Sigmoid(),  
        )  

    def forward(self, x):  
        y = self.net(x)  
        return y  

# 构建网络对象且放入GPU  
module = DNN().to('cuda:0')  
# 设置学习率，损失函数，优化算法  
loss_fun = nn.BCELoss(reduction='mean')  
learing_rate = 0.005  
optimizer = torch.optim.Adam(module.parameters(), lr=learing_rate)  
# 训练网络  
epochs = 500  
losses = []  
for epoch in range(epochs):  
    for (x, y) in train_loader:  
        Pred = module(x)  
        loss = loss_fun(Pred, y)  
        losses.append(loss.item())  
        optimizer.zero_grad()  
        loss.backward()  
        optimizer.step()  

Fig = plt.figure()  
plt.plot(range(len(losses)), losses)  
plt.xlabel("epoch")  
plt.ylabel("loss")  
plt.show()  

# 测试网络  
correct = 0  
total = 0  
for (x, y) in test_loader:  
    Pred = module(x)  
    Pred[Pred>0.5] = 1  
    Pred[Pred<0.5] = 0  
    correct += torch.sum((Pred==y).all(1))  
    total += y.size(0)  
    print(f"测试集准确率为{100*correct/total:.2f}%") // 这里我们是每批次都相加展示了一次

// 实际上应该在这里统一打印一次最后的
// print(f"测试集准确率为{100*correct/total:.2f}%")
// 不过问题不大，这里的打印结果肯定和上面for里面最后一次循环的打印是一致的

运行后可以看到，图片展示的loss损失值的变化和批量梯度下降完全不一样，并且测试网络给出的数据也是多个（因为分批次了，每个批次都有一个准确率的计算）
可以看到最终结果其实准确率要比批量梯度下降要好一些，虽然从图上来看损失函数不是递减的

手写数字识别

手写数字数据集(MNIST)是机器学习领域的标准数据集，被称之为机器学习领域的HelloWorld
,因为任何的AI算法都可以用词标准数据集进行校验，MNIST内的每个样本都是一副二维的灰度图像

在MNIST中，模型的输入就是一副图像，模型的输出就是与图像中对应的数字（0-9，非独热编码）

我们不用手动将输出转化为独热编码，因为PyTorch会在整个过程中自动将数据集的输出转化为独热编码，我们只需要在测试网络的时候，将预测输出和真正结果对比的时候进行转化对比即可

每一图/样本，其实都是一个28X28的二维数组（二维就是灰度图；三维对应的就是彩图）

和之前不同的是，在这种多分类问题中，神经网络的输出层需要一个softmax激活函数(之前的只要在隐藏层后面跟上激活函数即我们的.ReLU()，在这里最后的输出层那里也需要添加一个激活函数)，它可以把输出层的数据归一化到0-1上且相加为1，从而模拟出概率的意思

如何理解这句话呢，就是我们这个数字识别，其输出层肯定是10个即0-9，每一组输入一张图都会有十个输出，这是个输出的值都会被压缩到0~1内且相加为1，就相当于0~9九个可能，每个可能的数值就是其概率，最大的那个也就是概率最大的

那我们现在开始制作数据集，这次的数据集需要在torchvision库中分别下载训练集和测试集，因此需要从torchvision库中导入datasets，下载前还需要借助torchvision中的ransforms进行图像转换,将数据集变为张量且调整数据集的统计分布
首先导入需要的包

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import matplotlib.pyplot as plt

制作数据集

在下载数据集之前，我们需要设定转换参数transform，利用函数transforms.Compose([..])，该参数解决如下两个问题

• ToTensor将图像数据转化为张量，且调整三个维度的顺序为C W H，C为通道数，二维灰度图的通道数为1，三维RGB彩图的通道数为3
• Normalize正规化，将神经网络的输入数据转化为标准正态分布，有助于训练效果，根据统计计算，MNIST的训练集所有的像素的均值为0.1307，标准差为0.3081（将一个普通的正态分部转化为一个标准正态分部的方式：所有值减去均值然后除以标准差）

# 设定下载集参数 这段代码基本固定 可以重复使用  
transform = transforms.Compose([  
    transforms.ToTensor(),  
    transforms.Normalize((0.1307,), (0.3081,))  
])

设置好下载参数之后，就可以下载训练集和测试集，下载数据集需要利用datasets.MNIST(root=...;train=...;transform=...;download=...)
下载会比较耗时间，需要等待

# 下载数据集  
# 四个参数含义:  
# 下载后保存的位置;是否为训练集(false则代表为测试集);  
# download代表检测第一个参数root下是否有,如果root存在则不需要下载  
train_Data = datasets.MNIST(  
    root='D:/ZhuoMian/bigThree/PythonLearn/BasePy/data/mnist',  
    train=True,  
    transform=transform,  
    download=True  
)  

test_Data = datasets.MNIST(  
    root='D:/ZhuoMian/bigThree/PythonLearn/BasePy/data/mnist',  
    train=False,  
    transform=transform,  
    download=True  
)

批次加载器

在这里我们也会需要用到批次加载器，和上面小批量梯度下降一致的使用

# 批次加载器  
train_Loader = DataLoader(train_Data,batch_size=64,shuffle=True)  
test_Loader = DataLoader(test_Data,batch_size=64,shuffle=False)

构建网络

整体还是一样的，继承nn.Module然后重写__init__和forward函数,不一样的是，因为输入是图片，我们需要将图片铺成一维的，所以在输入层之前需要借助nn.Flatten()实现

# 搭建神经网络  
class MnistDNN(nn.Module):  
    def __init__(self):  
        # 每个输入都是28*28的二维数组 所以输入得为28*28  
        # 输出为0-9所以需要10个节点  
        super(MnistDNN,self).__init__()  
        self.net = nn.Sequential(  
            nn.Flatten(),   # 把图片铺成一维  
            nn.Linear(28*28,512),  
            nn.ReLU(),  
            nn.Linear(512,256),  
            nn.ReLU(),  
            nn.Linear(256,128),  
            nn.ReLU(),  
            nn.Linear(128,64),  
            nn.ReLU(),  
            nn.Linear(64,10)  
        )  

    def forward(self, x):  
        return self.net(x)

# 创建模型对象且放入GPU  
model = MnistDNN().to("cuda:0")

损失函数和优化算法

损失函数和优化算法也还是一样的，这次我们使用的是CrossEntropyLoss这个损失函数，优化算法依旧选择SGD
可以看到，我们上面说了，这种多分类问题需要在输出层后面再加一个softMax激活函数，可以明显地看到我们在构建网络的链路最后并没有加，这是因为CrossEntropyLoss自带softMax激活函数，而损失函数刚好是计算输出层的数值的，所以这里就可以直接作用上

# 损失函数和优化算法  
loss_fn = nn.CrossEntropyLoss() # 自带softMax激活函数  
learning_rate = 0.01  
# 这里比平常多了一个参数momentum动量的设置,它使得梯度下降算法有了力和惯性  
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate,momentum=0.5)

训练网络

因为使用了批次加载器，那么我们依旧是从批次中获取数据
需要注意的是，因为我们的数据集是下载在文件下的，但是数据集内部我们无法进入，所以我们不能直接将整个数据集放入到cuda上，所以在遍历获取的时候，需要先将x,y放入到cuda上

epochs = 5  
losses = []  
for epoch in range(epochs):  
    for(x,y) in train_Loader:  
        # 因为无法将整个数据集放入到cuda上 所以这里在计算的时候再放入到cuda上  
        x,y = x.to("cuda:0"),y.to("cuda:0")  
        Pred = model(x)  
        loss = loss_fn(Pred, y)  
        losses.append(loss.item())  
        optimizer.zero_grad()  
        loss.backward()  
        optimizer.step()  

Fig = plt.figure()  
plt.plot(range(len(losses)),losses)  
plt.xlabel("Epochs")  
plt.ylabel("Loss")  
plt.show()

测试网络

同小批次梯度下降的测试网络过程，需要从测试集的批量加载器中获取数据，然后求出预估值之后，利用a,b = torch,max(Pred.data,dim=1)获取每一行的最大值和最大值的位置，最大位置其实就是我们的预测值(假设你一行输入，最后得到了10个数值索引为0-9，分别代表了0-9每个数字的占比/权重/概率，最大的那个就是我们的预测结果，所以这里获取最大值的位置其实就是对应的数字了)
因为predicted和y都是一阶张量（类比于一维数组），所以不能使用.all()方法

correct = 0  
total = 0  
with torch.no_grad():  
    for (x,y) in test_Loader:  
        x,y = x.to("cuda:0"),y.to("cuda:0")  
        Pred = model(x)  
        _,predicted = torch.max(Pred.data,dim=1)  
        correct += torch.sum((predicted==y))  
        total += y.size(0)  
print(f"测试集精准度:{100*correct/total}%")

该案例的最终代码如下

import torch  
import torch.nn as nn  
from torch.utils.data import DataLoader  
from torchvision import transforms  
from torchvision import datasets  
import matplotlib.pyplot as plt  

# 设定下载集参数 这段代码基本固定 可以重复使用  
transform = transforms.Compose([  
    transforms.ToTensor(),  
    transforms.Normalize((0.1307,), (0.3081,))  
])  

# 下载数据集  
# 四个参数含义:  
# 下载后保存的位置;是否为训练集(false则代表为测试集);  
# download代表检测第一个参数root下是否有,如果root存在则不需要下载  
train_Data = datasets.MNIST(  
    root='D:/ZhuoMian/bigThree/PythonLearn/BasePy/data/mnist',  
    train=True,  
    transform=transform,  
    download=True  
)  

test_Data = datasets.MNIST(  
    root='D:/ZhuoMian/bigThree/PythonLearn/BasePy/data/mnist',  
    train=False,  
    transform=transform,  
    download=True  
)  

# 批次加载器  
train_Loader = DataLoader(train_Data,batch_size=64,shuffle=True)  
test_Loader = DataLoader(test_Data,batch_size=64,shuffle=False)  

# 搭建神经网络  
class MnistDNN(nn.Module):  
    def __init__(self):  
        # 每个输入都是28*28的二维数组 所以输入得为28*28  
        # 输出为0-9所以需要10个节点  
        super(MnistDNN,self).__init__()  
        self.net = nn.Sequential(  
            nn.Flatten(),   # 把图片铺成一维  
            nn.Linear(28*28,512),  
            nn.ReLU(),  
            nn.Linear(512,256),  
            nn.ReLU(),  
            nn.Linear(256,128),  
            nn.ReLU(),  
            nn.Linear(128,64),  
            nn.ReLU(),  
            nn.Linear(64,10)  
        )  

    def forward(self, x):  
        return self.net(x)  

# 创建模型对象且放入GPU  
model = MnistDNN().to("cuda:0")  

# 损失函数和优化算法  
loss_fn = nn.CrossEntropyLoss() # 自带softMax激活函数  
learning_rate = 0.01  
# 这里比平常多了一个参数momentum动量的设置,它使得梯度下降算法有了力和惯性  
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate,momentum=0.5)  

# 训练网络  
epochs = 5  
losses = []  
for epoch in range(epochs):  
    for(x,y) in train_Loader:  
        # 因为无法将整个数据集放入到cuda上 所以这里在计算的时候再放入到cuda上  
        x,y = x.to("cuda:0"),y.to("cuda:0")  
        Pred = model(x)  
        loss = loss_fn(Pred, y)  
        losses.append(loss.item())  
        optimizer.zero_grad()  
        loss.backward()  
        optimizer.step()  

Fig = plt.figure()  
plt.plot(range(len(losses)),losses)  
plt.xlabel("Epochs")  
plt.ylabel("Loss")  
plt.show()  

# 测试网络  
correct = 0  
total = 0  
with torch.no_grad():  
    for (x,y) in test_Loader:  
        x,y = x.to("cuda:0"),y.to("cuda:0")  
        Pred = model(x)  
        _,predicted = torch.max(Pred.data,dim=1)  
        correct += torch.sum((predicted==y))  
        total += y.size(0)  
print(f"测试集精准度:{100*correct/total}%")

最后的运行结果为

学习此章之前请有一定的Python基础，如果无，可以查看深度学习入门-Base篇
这一篇主要是学习Numpy，Pandas和Matplotlib

Numpy

NumPy是为了克服Python原生的列表List的一些缺点而被创建的
要能在Python程序中使用NumPy，首先就需要记住要导包

import numpy as np

数据类型

NumPy的每一个列表中只能包含一种数据类型以节约内存
NumPy.array一般由np.array(list)创建，即传入Python原生列表对象得到NumPy的array对象
用NumPy创建常见的数据类型的数组,同时通过输出语句可以观察到，NumPy.array对象的打印结果之间使用空格分隔而不会出现逗号(,)而Python原生List打印时会使用逗号进行分隔

import numpy as np  
intNumber_arr = np.array([1,2,3,4,5])  #整数型数组
floatNumber_arr = np.array([1.0,2.2,3.3,4.4,5.5]) #浮点型数组  
str_arr = np.array(["A","AB","哈哈"]) #字符型数组
print(intNumber_arr)  # [1 2 3 4 5]
print(floatNumber_arr)  
print(str_arr) #[A AB 哈哈]

因为类型是确定的，所以如果往一个已经确定类型的array中插入别的类型的元素，就会自动的转换/强转

import numpy as np  
intNumber_arr = np.array([1,2,3,4,5])  
floatNumber_arr = np.array([1.9,2.2,3.3,4.4,5.5])  
intNumber_arr[0]=11.99  #往整型中插入浮点型
floatNumber_arr[0]=100  #往浮点型中插入整型
print(intNumber_arr[0]) # 11 小数部分被截断，精度缺失
print(floatNumber_arr[0]) # 100.0

如果需要整体转化，即将一个本来为整型类型的array转化为浮点数类型的array，可以使用.astype()方法

import numpy as np  
intNumber_arr = np.array([1,2,3,4,5])  
int2Float_arr = intNumber_arr.astype(float)  
print(int2Float_arr) # [1. 2. 3. 4. 5.]

数组的创建

NumPy中常见的array创建方式有如下几种

• np.array(list)和np.array(list,dtype)，都是根据元组/列表进行创建，后者的dtype可以指定类型，假如你的list都是整型，但是你想得到一个浮点型的array，就可以让dtype=float

• np.zero()创建一个空array

• np.ones(shape)创建一个shape形状的整型array，元素全部默认为1,拓展，如果我们需要一个全x的数组，可以 x*np.ones(shape) 实现

• np.full(shape,x)创建一个shape形状的，内容全部为x的array

• np.eye(n,k=0)创建一个n * n 的矩阵，对角线为k，k可指定，默认为0

• np.arange(start=0,stop,step=1)和np.arange(start=0,stop,step=1,dtype)，注意区间左开右闭

• # 语法：np.arange(start, stop, step, dtype) 
  arr_arange1 = np.arange(10) # 从0开始，步长1，到10终止（不包含10） 
  arr_arange2 = np.arange(2, 10, 2) # 从2开始，步长2，到10终止 
  arr_arange3 = np.arange(0, 1, 0.2) # 支持浮点数步长 
  print("默认序列：", arr_arange1) 
  print("步长2序列：", arr_arange2) 
  print("浮点步长序列：", arr_arange3)
  
  

• np.linspcae(start,stop,num=50,endpoint=True)在start-stop的范围内生成number个数据，会尽力保证等差，endpoint参数决定是否包含stop，也就是说该函数默认是包含终止值，但是如果不需要，可以通过参数控制

• import numpy as np  
  # 语法：np.linspace(start, stop, num=50, endpoint=True)  
  arr_lin1 = np.linspace(0, 10, 5)  # 0到10之间，生成5个均匀分布的数  
  arr_lin2 = np.linspace(0, np.pi, 10, endpoint=False)  # 不包含终止值π  
  print("5个元素的等差序列：", arr_lin1)  
  print("10个元素（不含π）的序列：", arr_lin2)
  

• np.logspcae(start,stop,num=50)生成从10^start 到 10^stop 范围内的 number个数，可以理解为生成一个等比序列

• np.random.rand(...)创建一个元素内容在[0,1]内的arr，可变入参，每个参数作为一个维度

• import numpy as np  
  # 1. 不传参数：生成单个随机数（标量）  
  d1 = np.random.rand()  
  print("不传参数：", d1, type(d1))  
  # 2. 传单个整数：生成一维数组  
  d2 = np.random.rand(5)  
  print("\n传单个整数（一维数组）：", d2)  
  # 3. 传多个整数：生成多维数组（2行3列）  
  d3 = np.random.rand(2, 3)  
  print("\n传多个整数（二维数组）：\n", d3)  
  # 4. 不推荐：传元组（不会报错，但生成的是 1行2列数组，不符合预期）  
  d4 = np.random.rand((2, 3))  # 不报错，但结果非预期  
  print("\n传元组（非预期结果）：\n", d4, d4.shape)
  

• np.random.random(shape),功能和rand一样，主要区别在于传参，这里需要传入shap，而不能传入多个参数

• import numpy as np  
  # 1. 不传参数：生成单个随机数（不是数组，是标量）  
  r1 = np.random.random()  
  print("不传参数：", r1, type(r1))  
  # 2. 传单个整数：生成一维数组  
  r2 = np.random.random(5)  
  print("\n传单个整数（一维数组）：", r2) 
  # 3. 传元组：生成多维数组（2行3列）  
  r3 = np.random.random((2, 3))  
  print("\n传元组（二维数组）：\n", r3)  
  # 4. 错误用法：直接传多个整数（会抛出 TypeError）  
  # r4 = np.random.random(2, 3)  # 报错！
  

• np.random.randn生成均值为0，方差为1的标准正态分布(高斯分布)随机数，语法同rand()

• import numpy as np  
  randn1 = np.random.randn(5) #一行五列  
  randn2 = np.random.randn(2, 3) # 两行三列  
  print("一维标准正态分布随机数：", randn1)  
  print("\n二维标准正态分布随机数：\n", randn2)
  

• np.random.randint(start,stop,shape)生成一个元素范围在start-stop之间，shape形状的array，其实也可以通过random函数变化得到,例如10-100: 90*np.random.random(shape)+10

• np.random.normal(均值,标准差,样本数量/shape)生成符合指定均值、指定标准差的正态分布随机数，返回 NumPy 数组（ndarray）或单个标量。randn()方法其实就是normal(0,1)的一种特里

多维数组

多维数组本身还是很好理解的,Numpy中稍微有点稀奇的一个是shape形状这个概念，有些函数例如np.ones(shape)需要传入这个来创建数组

arr1 = [1,2,3]  # 形状为 3 or (3,) 表示三列，一维数组
arr2 = [[1,2,3]] # 形状为 (1,3) 表示是一个二维数组，目前是一行三列
arr3 = [[[1,2,3]]] # 形状为 (1,1,3) 表示三维数组

来看一下np.ones(shape)创建多维数组，同时，我们可以利用array.shape来获取一个数组的形状

import numpy as np  
arr1 = np.ones(4)  
arr2 = np.ones((2,4)) 
# 三维数组 最外层2个元素 每个元素中1个二维元素 每个二维元素中一个长度为4的一维数组 
arr3 = np.ones((2,1,4))  
print(arr1,arr1.shape)
print("========================")  
print(arr2)  
print("========================")  
print(arr3)

输入如下
[1. 1. 1. 1.] (4,)
========================
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]]
========================
[[[1. 1. 1. 1.]]

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

在很多时候，我们会需要进行数字的运算，运算的时候我们可能会需要将一维数组转化为二维或者将二维数组转化为一维数组，这个时候就需要借助reshape(shape),这个方法在传递参数的时候，可以只传入一个维度，剩下的维度传入-1可以函数底层进行计算

import numpy as np  
arr1 = np.ones(4) # 一行四列  
arr2 = np.ones((2,4)) # 两行四列  
arr3 = arr1.reshape((4,1))  
print(arr3)  
print("========================")  
arr4 = arr2.reshape((1,-1)) # 重新塑形 但是我只指塑性为一行,列的参数-1让函数底层自行计算  
print(arr4)

输出
[[1.]
 [1.]
 [1.]
 [1.]]
========================
[[1. 1. 1. 1. 1. 1. 1. 1.]]

元素的访问和修改

访问array的元素和访问List元素一样，可以采用下标索引访问，同样支持负数；如果是矩阵/多维，则使用[index1,index2]的方式

import numpy as np  
arr = np.array([[1,2,3],[4,5,6]])  
print(arr)  
print(arr[1,1]) # 5  
arr[1,1] = 99  
print(arr[1,1]) # 99 其实也可以和别的语言一样使用 arr[index1][index2]的形式

还有一种花式索引，其形式为[ [ index1,index2,index3.... ] ]，适合让我们批量挑取元素进行访问

import numpy as np  
# 假设这里是一个100长度的一维数组，我们可以利用花式索引批量拿出0,10,15,10位置的元素  
arr1 = np.arange(100)  
temp = arr1[[0,10,15,10]]  
print(temp)  
print("=============================")  
# 这里有个多维数组  
arr2 = np.random.randint(0,10,(5,5))  
print(arr2)  
print("=============================")  
# 批量将(0,0),(1,1),(2,2),(3,3)位置的元素赋值为100  
arr2[ [0,1,2,3],[0,1,2,3] ] = 100  
print(arr2)

数组的切片

array中也可以和List一样具有切片的特性

import numpy as np  
# 假设这里是一个100长度的一维数组，我们可以利用花式索引批量拿出0,10,15,10位置的元素  
arr1 = np.random.randint(0,100,10)  
# [29 13 15 98 49 54 83 80 56 95]  
print(arr1)  
print("===========================")  
# [13 15 98 49 54 83]  
print(arr1[1:-3]) # 拿出1到倒数第三个元素  
print("===========================")  
# [29 15 49 83 56]  
print(arr1[::2]) # 拿出所有元素，步长为2  
print("===========================")  

arr2 = np.random.randint(0,100,(5,5))  
'''  
[[93 80  8 97 58]  
 [25  0 73 54 23] [56 66 34 70 33] [ 4 80  8  6 77] [62 44 33 12 49]]'''  
print(arr2)  
print("===========================") 
print(arr2[2,:]) #提取第二行 其实也可以arr2[2] 只是这么写没那么规范 
'''  
[[ 0 73 54]  
 [66 34 70]]'''  
print(arr2[1:3,1:-1]) # 切除1到3行;每行为1到倒数第二个元素

利用切片来提取矩阵的列

import numpy as np  
arr = np.arange(1,21).reshape((4,5))  
# 提取整个第二列 但是需要注意,提取出单个列的话返回的是向量而不是矩阵
print(arr[:,2]) #  [ 3  8 13 18]  
print(arr[:,2:4]) # 多个列就是矩阵

# 如果想把 arr[:,2]得到的向量转化为矩阵  
# 方法一  
print("==================")  
print(arr[:,2:3])  
# 方法二  
print("==================")  
temp = arr[:,2].reshape((-1,1))  
print(temp)  
# 方法三  
print("==================")  
temp2 = arr[:,2].reshape((1,-1))  
print(temp2.T) # T可以得到矩阵的倒置,只对矩阵有效

然后对于切片，之前也提到过，在NumPy中切片是数组的视图，而不是一份新数据，所以修改也会影响原来的数组，这个和List的特点不一样，并且赋值也不会创建新的变量(例如 arr2 = arr1，修改arr2也会导致arr1被修改)。如果真的需要拷贝一份新的，则使用copy()方法

数组的变形

数组的变形主要是针对于矩阵，向量是不存在什么变形的说法的，如果一定要说，向量应该也就一个reshape()操作了

• arr.T矩阵的倒置

• np.flipud(arr)和np.fliplr(arr)前者为上下翻转(flip-up-down)，后者为左右翻转(flip-left-right)，向量只能使用flipud(arr)(这里可能会感觉，向量不是一行么，为何只能上下反倒不能左右，其实这个是和数学上一致的，数学上向量默认为列向量)

• np.reshape() 不多介绍了，很熟悉，矩阵的重塑

• np.concatenate(arrays,axis=0)，默认按照行进行拼接(行数会增加)，axis=1则按照列进行拼接(列数会增加),第一个参数arrays是要参与拼接的所有arr组成的arr

• import numpy as np  
  arr1 = np.arange(1,7).reshape((2,3))  
  arr2 = np.arange(10,16).reshape((2,3))  
  print(np.concatenate((arr1,arr2)))  
  print(np.concatenate((arr1,arr2),1))
  

• np.split(arr,[index1,index2...])在arr的index1，index2...的索引位置前进行切分

• import numpy as np  
  arr = np.arange(10,90,10)  
  print(arr)  
  tempA,tempB = np.split(arr,[5])  
  print(tempA)  # [10 20 30 40 50]
  print(tempB)  # [60 70 80]
  
  temp1,temp2,temp3 = np.split(arr,[3,6])  
  print(temp1)  # [10 20 30]
  print(temp2)  # [40 50 60]
  print(temp3)  # [70 80]
  

  如果是对矩阵进行切分

• import numpy as np  
  arr = np.arange(10,90,10).reshape(4,2)  
  '''  
  [[10 20]  
   [30 40] 
   [50 60] 
   [70 80]]'''  
  print(arr)  
  temp1,temp2 = np.split(arr,[2]) # 默认按行，那就从第二行开始切分  
  '''  
  [[10 20]  
   [30 40]]'''  
  print(temp1)  
  
  '''  
  [[50 60]  
   [70 80]]'''  
  print(temp2)  
  
  temp1,temp2 = np.split(arr,[1],axis=1) # 按列切分,从第一列开始竖着切分  
  '''  
  [[10]  
   [30] 
   [50] 
   [70]]'''  
  print(temp1)  
  
  '''  
  [[20]  
   [40] 
   [60] 
   [80]]'''  
  print(temp2)
  

数组的运算

直接看代码案例,首先是单个矩阵的基本运算，记住一个点所有的元素都会被操作和计算

import numpy as np  
baseArr = np.arange(1,13).reshape(3,4)  
print(baseArr)  
# 加法-作用到每个元素上，每个元素都加  
print(baseArr + 10)  
# 减法-作用到每个元素上，每个元素都减  
print(baseArr - 10)  
# 乘法-作用到每个元素上，每个元素都乘  
print(baseArr * 10)  
# 除法-作用到每个元素上，每个元素都除  
print(baseArr / 10)  
# 取模-作用到每个元素上，每个元素都取模  
print(baseArr % 10)
# 相反数-每个元素都取反
print(-baseArr)

然后是两个矩阵之间的计算

import numpy as np  
arr1 = np.arange(10,20).reshape(2,5)  
arr2 = np.arange(1,11).reshape(2,5)  
# 矩阵间的减法-对应位置的元素相减  
print(arr1-arr2)  
# 矩阵间的加法-对应位置的元素相加  
print(arr1+arr2)  
# 矩阵间的乘法-对应位置的元素相乘,也就是逐元素乘积,线性代数中的那种乘法形式之后会有别的函数负责 
print(arr1*arr2)  
# 矩阵间的除法-对应位置的元素相除  
print(arr1/arr2)  
# 矩阵间的取模-对应位置的元素相取模  
print(arr1%arr2)

上面的都是必须要满足两个矩阵维度相匹配的前提,对于和不同形状的之间的计算，涉及到了广播。有如下两个规则
如果向量和矩阵之间计算，那么向量会被广播成满足矩阵计算要求的行矩阵
如果某个矩阵是行矩阵/列矩阵，则其会被广播从而适配另外一个矩阵
如下案例代码，展示向量和矩阵之间的计算，当一个(x,y)的矩阵和一个向量进行计算的时候，向量必须满足格式即一行y列，该向量会被升级为(1,y)的行距阵，然后再广播为(x,y)的矩阵以适配另外一个矩阵

import numpy as np  
arr2 = np.arange(1,7).reshape(2,3)  
arr1 = np.array([-100,0,100])  
# arr1是向量 需要去主动适配arr2  
# 所以arr1在计算的时候就会变为  
'''  
[  
[-100,0,100],  
[-100,0,100],  
[-100,0,100]  
]  
'''  
# 然后每一个元素和arr2进行运算  
print(arr1*arr2)

当一个(x,y)的矩阵和一个列矩阵进行计算的时候，列矩阵必须满足(x,1)即X行1列，该列矩阵会被广播为(x,y)的矩阵从而适配

import numpy as np  
arr2 = np.arange(1,7).reshape(3,2)  
arr1 = np.array([-100,0,100]).reshape(3,1)  
# arr1是向量 需要去主动适配arr2  
# 所以arr1在计算的时候就会变为  
'''  
[  
[-100  -100]  
 [ 0 0] [ 100 100]]  
'''  
# 然后每一个元素和arr2进行运算  
print(arr1*arr2)

输出
[[-100 -200]
 [   0    0]
 [ 500  600]]

如果是一个行矩阵(1,y)和一个列矩阵(x,1)，双方都会广播为(x,y)的矩阵后进行操作

import numpy as np  
arr2 = np.arange(1,4).reshape(1,3)  
arr1 = np.array([-100,0,100]).reshape(3,1)  

print(arr1)  
print(arr2)  

print(arr1*arr2)

输出
[[-100]
 [   0]
 [ 100]]

[[1 2 3]]

[[-100 -200 -300]
 [   0    0    0]
 [ 100  200  300]]

数组的函数

矩阵乘积-np.dot

我们在之前讲的数组的一些运算，可以发现都是一些逐元计算。那么线性代数上的矩阵的乘积怎么实现呢？这里就需要借助np.dot(arr1,arr2)函数了
向量和向量的乘积，就和线代上的向量乘法一致，利用(x,y) * (y,x)然后相加即可

import numpy as np  
arr1 = np.arange(1,4)  
arr2 = np.arange(11,14)  
print(arr1)  # [1 2 3 ]
print(arr2)  # [11 12 13]
# 1*11+2*12+3*13=74  
print(np.dot(arr1,arr2))

同理，如果是向量和矩阵相乘，向量依次和矩阵的每一列每个元素相乘且求和

import numpy as np  
arr1 = np.arange(5)  
arr2 = np.arange(15).reshape(5,3)  
print(arr1)  
print(arr2)  
'''  
按照(1,5)*(5,3)=(1,3)  

             [[ 0  1  2]  
             [ 3  4  5]     [[0*0+1*3+2*6+3*9+4*12=90]                            [0 1 2 3 4]* [ 6  7  8]   =  [0*1+1*4+2*7+3*10+4*13=100]]  
             [ 9 10 11]     [0*2+1*5+2*8+3*11+4*14=110]]                                        [12 13 14]]  
'''  
print(np.dot(arr1,arr2))

需要知道啊，线代中ab和ba是不一定相等的，所以同理，我们矩阵和向量相乘结果不一定和向量和矩阵相乘是一致的

import numpy as np  
arr1 = np.arange(5)  
arr2 = np.arange(15).reshape(3,5)  
print(arr1)  
print(arr2)  
print(np.dot(arr2,arr1)) # [30 80 130]

矩阵和矩阵相乘

import numpy as np  
arr1 = np.arange(10).reshape((5,2))  
arr2 = np.arange(16).reshape(2,8)  
print(arr1)  
print(arr2)  
print(np.dot(arr1,arr2))

数学函数

NumPy中提供了不少数学相关的函数，这里主要来介绍几个

• np.abs()求绝对值
• np.sin();np.cos();np.tan()三角函数相关
• np.exp(x)求e^x
• np.log(x)求ln(x)；利用换底公式可以得到log2(x) = np.log(x)/np.log(2);log10(x) = np.log(x)/np.log(10)

聚合函数

矩阵和向量的聚合函数使用方式基本一致，只是向量使用的时候没有axis这个参数，常用的聚合函数有六个

• np.max(arr,axis)求最大值，如果axis=0,则结果和行数相等，那么也是取出每列中最大值然后组成新的arr；同理，如果axis=1则结果和列数相等，也就是取出每一行的最大值然后组合；如果不写axis，则返回整个arr中最大的值
• np.sum(arr,axis)求和，如果axis=0，则对每列求和；axis=1则对每行求和；不写axis则整体求和
• np.mean()均值函数，axis的规则是一样的，求得是平均值
• np.std()求标准差，axis规则一样
• np.nan..()考虑到矩阵/向量中会存在缺失值，如果使用以上聚合函数遇到缺失会报错，那么我们可以在函数名前面加nan使用其安全的版本，计算的时候会自动忽略缺失值

布尔数组

布尔数组在NumPy中主要是通过整型数组/浮点数数组通过比较得方式之后得到得，和常数进行比较或者两个数组之间比较都会产生布尔数组

import numpy as np  
arr1 = np.arange(5)  
bool_arr = arr1 > 3  
print(bool_arr) #[False False False False  True]

复杂一点的就是多条件比较，需要注意，在Python中是使用and or not,在NumPy中是使用& | ~

import numpy as np  
arr1 = np.arange(1,11)  
bool_arr = (arr1 > 3)&(arr1 < 7)  
print(bool_arr) # [False False False  True  True  True False False False False]

对于布尔数组而言，主要的应用在于聚合函数
np.sum()中传入的是布尔数组的时候，返回True的个数；np.any()只有布尔数组中有一个或者多于一个元素为True则返回True(例如判断两个arr中是否含有相同的元素)；np.all()只有当布尔数组中所有的元素都为True的时候才会返回True

布尔数组也可以作为数字数字的掩码，即利用布尔数组的结果来从原本的数组中进行快速的筛选。这个怎么理解呢，看案例代码

import numpy as np  
arr1 = np.arange(1,11).reshape(5,2)  
print(arr1[(arr1>7)|(arr1<2)]) # [ 1  8  9 10]

# 在两个arr比较筛选出arr2>arr3的部分 和 arr3大于arr2的部分 这种需求下也可以使用
arr2 = np.random.randint(1,100, (3,4))  
arr3 = np.random.randint(1,100, (3,4))  
print(arr2[ arr2>arr3 ])  
print(arr3[ arr3>arr2 ])

arr4 = np.random.randint(300,900,(10,10))
print(np.where( arr4>600 )) # 得到所有大于600的索引位置
print(np.where( arr4>600 )[0]) # 得到大于600的第一索引位置 类似findFirst的效果
print(np.where( arr4==np.max(arr4) )) # 找到最大元素所在索引位置

数组与张量

这部分内容是对于PyTorch的，因为NumPy很流行，PyTorch很大程度上吸收了NumPy的语法，我们可以将np=>torch;数组array=>张量tensor;n维数组/数组的维度=>n阶张量/张量的阶数这三个概念直接进行替换，从而能帮助我们很方便的上手PyTorch
并且张量和数组之间可以直接转换
ts = torch.tensor(arr) ; array = np.array(ts)
当然，也没有说完全100%一样，但是不一样的地方是极少数，下图这几个方法是两者的不同之处，其余的方法是一致的

Pandas

Pands是一个标签库，其主要的作用就是在NumPy数组基础上基于其行列标签。Pandas中数组所有的特性依旧存在
一样的，我们在使用Pands得时候需要先导入库

import pandas as pd

对象的创建

一维对象

方法一：借助字典创建
Numpy中我们可以通过np.array(list)将列表转化为数组，在Pandas中我们可以利用pd.Series(dict)将Python的dict字典对象转化为Series对象
可以看到，Series的输出格式和dict的是不一样，而且在最后会告诉你其value的是什么对象类型，当然只是value的类型和Key无关

import pandas as pd  
dict_v = {"A":1, "B":2, "C":3}  
print(dict_v)  
series = pd.Series(dict_v)  
print(series)

输出
{'A': 1, 'B': 2, 'C': 3}
A    1
B    2
C    3
dtype: int64

方法二：借助数组创建
考虑到字典的创建本来就比较麻烦，我们可以利用两个数组创建，即pd.Series(values,keys),传入两个参数，第一个为value序列，第二个为Key序列(序列可以是列表，元组，数组，张量都可以)
keys可以省略，省略后key序列将会从0开始递增

import pandas as pd  
values = (1,2,3)  
keys = ("a","b","c")  
series = pd.Series(values,keys)  
print(series)

Series对象可以通过.values和.index两个属性分别得到value序列和key序列，需要注意的是，无论构建的时候你传入的是张量还是元组还是列表还是其他的，最后用values得到的都是数组的数据类型
所以可以知道，Pandas其实是基于NumPy创建的库

二维对象

把一维Series对象当作一列，二维对象就是多个一列合在一起，那么就是多列，所以二维对象一定是基于多个Series对象的，每一个Series就是一列数据
创建Series的时候，字典的Key是index，竖直方向延展；当需要创建二维DataFrame对象的时候，肯定还需要水平方向向的键，也就是colums

(1)我们可以利用多个Series创建DataFrame对象pd.DataFrame({key1:series1,key2:series2})

import pandas as pd  
value = [1,2,3,4,5,6]  
key_age = [27,45,33,36,27,43]  
key_name = ["张三","李四","王五","赵六","孙七","周八"]  
#s1理解为病人序号和年龄的字典表  
s1 = pd.Series(key_age,value)  
#s2理解为病人序号和姓名的字典表  
s2 = pd.Series(key_name,value)  
# 如果要合并成二维，那么就是序号-年龄-姓名  
df = pd.DataFrame( {"年龄":s1,"姓名":s2} )  
print(s1)  
print(s2)  
print(df)

输出
1    27
2    45
3    33
4    36
5    27
6    43
dtype: int64
1    张三
2    李四
3    王五
4    赵六
5    孙七
6    周八
dtype: object
   年龄  姓名
1  27  张三
2  45  李四
3  33  王五
4  36  赵六
5  27  孙七
6  43  周八

从结果看到，行标签就是每个Series的Key序列，那如果两者的Keys序列不一样会怎么样？那么最终的DataFrame会去两个Key序列的并集，那么必然出现数据缺失，确实的地方会使用NaN

(2）直接利用三个数组创建二维DataFrame
pd.DataFrame(values,indexs,columns)第一个为value序列(序列中的每个元素就是对应结果表中的每一行的内容)，第二个行标签序列，第三个为列标签序列，后两个参数可以不写，会默认从0开始递增作为序列

import pandas as pd  
values = [["女",18,"发烧"],["男",19,"咽喉炎"],["未知",29,"腱鞘炎"],["男",35,"急性肠胃炎"],["女",33,"鼻炎"] ]  
index = [1,2,3,4,5]  
colums = ["性别","年龄","病因"]  
df = pd.DataFrame(values, index=index, columns=colums)  
print(df)

对于二维DataFrame，因为多了一个columns属性，所以可以通过df.columns获取列标签序列

对象索引

Pandas中的索引分为了显式索引和隐式索引。显式索引是Pandas对象提供的索引，隐式索引是数组本身自带的从0开始的索引。那么如果说，我们此时显式索引也是整型的话，就会导致sr[0]你不知道是按照显式访问还是隐式访问的
所以Pandas作者提供了索引器，可以通过loc访问显式;iloc访问隐式

import pandas as pd  
sr = pd.Series(["x", "a", "b", "c"],[2,4,3,1])  
print(sr)  
# 分别通过显式索引和隐式索引访问元素b  
print(sr.loc[3]) # 显式索引 b的key为3 所以用3访问  
print(sr.iloc[2])# 隐式索引 b的key2 所以用2访问

当然，如上是基于隐式和显式会冲突的前提下，如果不会冲突，则可以不要使用loc,再者，因为之前也提到了Pandas基于NumPy的，所以花式索引也能使用来着；同样，也具备切片的特点，且切片也只是视图，共享内存地址

在二维对象DataFrame中，即使显式索引和隐式索引从理论上来讲不会冲突，但是你不使用索引器就会报错，所以在使用Pandas的时候我们得习惯使用索引器访问

import pandas as pd  
# 字典创建法  
i=["1号","2号","3号","4号"]  
v1 =[53,64,72,82 ]  
v2=["女",'男','男','女']  
sr1 =pd.Series(v1,index=i)  
sr2 = pd.Series(v2,index=i)  
df=pd.DataFrame({"年龄":sr1,"性别":sr2})  
# 访问指定元素  
print(df.loc["1号","年龄"]) #索引  
print(df.loc[["1号","3号"],["年龄","性别"]])#花式索引  
print(df.loc["1号":"4号","性别"])#切片  
print(df.loc[:,"年龄"])#切片 获取第一列

提取某一行或者某一列的时候，可以简写df.loc["3号"];df["年龄"]

对象变形

有时候的数据是畸形的，比如说行是特性，列是个体，那么我们必须要进行转置，此时使用df.T

import pandas as pd  
# 先构建畸形数据
arr1 = ["1号", "2号", "3号", "4号"]  
arr2 = ["年龄", "性别"]  
arr3 = [[19,20,21,22],["男","女","男","女"]]  
'''  
    1号  2号  3号  4号  
年龄  19  20  21  22
性别   男   女   男   女  
'''  
df = pd.DataFrame(arr3, index=arr2, columns=arr1)  
print(df)  
print("===================")  
'''  
    年龄 性别  
1号  19  男  
2号  20  女  
3号  21  男  
4号  22  女  
'''  
print(df.T)

除此之外，我们还可能会需要交换两行/两列的顺序，即上下翻转或者左右翻转，这个需要借助切片中step=-1即倒着采样的特性

import pandas as pd  
arr1 = ["1号", "2号", "3号", "4号"]  
arr2 = ["年龄", "性别"]  
arr3 = [[19,20,21,22],["男","女","男","女"]]  
df = pd.DataFrame(arr3, index=arr2, columns=arr1)  
print(df)   
'''  
    年龄 性别  
1号  19  男  
2号  20  女  
3号  21  男  
4号  22  女  
'''  
print(df.T)  
df = df.T  
print("========接着上面的案例===========") 
print(df.iloc[:,::-1])#左右翻转 即性别和年龄列翻过来  
print(df.iloc[::-1,:])#上下翻转 1234变为4321

对象的重塑

因为对象比数组多了行列标签，所以原本的reshape()方法其实已经不适用。Pandas对象的重塑没那么灵活，但是在实际场景中用的也少。
我们可以直接通过df[newKey]=newSr的方式，给当前df对象直接新增一列，列的标签为newKey，列下面的values即newSr；通过df.loc["一号"]=[...]的方式新增一行

我们还可以进行Serise对象的相加，使用pd.concat([sr1,sr2])
结果的key为两个key的并集，并且由于Pandas舍弃了字典和集合的不可重复性，所以concat后的结果是会有重复的

可以看到，这个方法是默认在行的基础上进行合并的(增加行数)，如果需要在列的基础上进行合并(增加列数)，则使用pd.concat([sr1,sr2],axis=1)

如果需要不重复性，可以利用.index.is_unique或.colomns.is_unique返回是否为True来判断，如果为True则说明没有重复，如果为False则说明有重复需要去重

对象的计算

如果我们现在需要对某一列的数据全部加10，那么可以直接df[列名]=df[列名]+10，其余计算操作一样的

如果我们需要进行对象和对象之间的计算，例如df1+df2
那么需要保证双方都是数字对象，两者可以维度不同，没有的数据NaN（相加的双方只要有一方没有那行，计算结果就会为NaN），有的数据相互加

并且，NumPy中的数学函数例如np.cos()等都可以直接作用于Pandas的对象中

import numpy as np  
import pandas as pd  
v1 = [ [10, '女'], [20, '男'], [30, '男'], [40, '女'] ]  
v2 = [ 1, 2 ,3, 6 ]  
i1 = [ '1 号', '2 号', '3 号', '4 号' ]; c1 = [ '年龄', '性别' ]  
i2 = [ '1 号', '2 号', '3 号', '6 号' ]; c2 = [ '牌照' ]  
df1 = pd.DataFrame( v1, index=i1, columns=c1 )  
df2 = pd.DataFrame( v2, index=i2, columns=c2 )  
df1['年龄'] = np.log(df1['年龄'])  
print(df1)

缺失值

Serise和DataFrame对象都能使用.isnull()方法检查是否为缺失值，如果要检测是否不为缺失值，可以使用.notnull() 或者 ~(.isnull())取反操作

对于Serise对象，我们可以直接使用.dropna()方法去除缺失值，对于DataFrame对象，要么去除含有NaN的那一行或者那一列，使用df.dropna()默认是剔除那一行，如果需要去除那一列，需要指定axis参数df.dropna(axis="columns")，一般我们都是去一行，因为一行才是个体，列是特征

当然，如果因为一个就删除一行可能过于激进，我们可以使用df.dropna(how='all')这种方式，只有当这一行/列全部为NaN的时候才会被去除

如果需要填充缺失值，可以使用sr.fillna(x)和df.fillna(x)，会使用X将NaN进行填充；
搭配np的一些聚合函数，例如.fillna(np.mean(sr/df))则可以实现均值填充；
.fillna(method='ffill')则可以实现用上一值/前值进行填充
.fillna(method='bfill')则可以实现用下一值/后值进行填充

操作Excel/CSV和数据分析

我们一般还是使用CSV,需要注意的是，如果你的文档数据里面没有行列标签，那么你需要手动补上行标签和列标签
当我们需要导入CSV的时候，可以使用pd.read_csv(path,index_col=0),第二个参数啥意思暂且不需要在意，需要注意的是，Pandas可能会要求CSV文件为utf-8的格式才能解析

当我们读取到的CSV比较大，得到df对象也比较大，我们可以使用df.head()只打印前五行的内容，然后就能用NumPy的方法，因为Pandas将其变为了对象的方法，所以也可以直接用df对象直接调用一些聚合函数,从而不需要导入Numpy包，且这些函数都属于安全版本，即都会忽略NaN

可以看到，如果每次数据分析我们都需要来回调用df.max;df.min;df.mean这些聚合函数，显得十分繁琐和冗余，所以有一个.describe()方法能直接查看所有相关的聚合信息，可以看到这个函数会忽略字符串列（因为字符串没有计算意义）

数据透视

数据透视对于数据分析极其的重要
如下 我们这里有一个泰坦尼克号的人员信息和生还信息名单，我现在需要考察前面的其他特征 和 考察核心即是否生还 之间的关系（这个可以类比神经网络，是否生还即为输出，前面的为输入）

对上述进行数据透视，需要借助.pivot_table方法，如下，传入两个参数第一个为考察核心，第二个为参考特征，整个方法就是考察性别如何影响生还率的，看到输出知道，女性生还率70%+

除此之外，还可以指定一个columns参数作为第二个参考特征

在这个函数的入参中，有一个aggfunc参数，默认为mean，除此之外，所有的聚合函数都可以作为其入参，会影响其计算，例如我们可以df.pivot_table('是否生还',index='性别',aggfunc='max')，当然，在我们目前的案例中，mean平均值是最佳选择

多特征的数据透视

上述的操作我们只引用了性别和船舱两个参考特征，如果我们还需要引入更多的特征，例如表格中的年龄和费用。
可以观察到，这两个列的数据都十分的分散，如果需要加入分类，会导致dt对象横向和纵向索引都会很大，那么这个时候就不能再按类别分了，此时需要借助pd.cut()和pd.qcut()
例如年龄，我们可以不一岁一岁的进行分类，而是按照范围进行分

age = pd.cut(df['年龄'],[0,18,120])

上述代码利用cut方法就将年龄分为了0-18;18-120两个区间，此时我们再将其加入到pivot_table函数中进行计算

我们还可以加入费用，可以看到，pd.cut可以让我们自己决定如何分隔数据，pd.qcut()只需要给出希望分成多少份，函数能自己帮我们分

Matplotlib

简单使用

Matplotlib本身库比较大，我们一般也只需要用到核心模块matplotlib.pyplot,

import matplotlib.pyplot as plt

我们先来尝试一下最简单的画图,这里使用.plot(x,y)函数

import matplotlib.pyplot as plt  
fig1 = plt.figure()  #创建新图窗
x = [1,2,3,4,5]  #数据的X值
y = [1,4,9,16,25]  #数据的Y值
plt.plot(x,y)  #.plot(x,y)函数，先描点再画线
plt.show()

可以看到这个图虽然出来了，但是不是很高清，我们可以通过添加另外一个库让图片更加清晰

import matplotlib.pyplot as plt  
from matplotlib_inline import backend_inline  
backend_inline.set_matplotlib_formats('svg')  
fig1 = plt.figure()  
x = [1,2,3,4,5]  
y = [1,4,9,16,25]  
plt.plot(x,y)  
plt.show()

保存图片

保存图片需要使用.savefig()，入参里面填入要保存的绝对路径和图形名以及后缀，需要注意这里要有个r字符串,即r'绝对路径\图形名.后缀 ，这个后缀，为了保存清晰的图片，我们基本都推荐保存svg矢量格式的图片

import matplotlib.pyplot as plt  
# 移除 matplotlib_inline 相关代码，因为它们仅适用于 Jupyter 环境  
fig1 = plt.figure()  
x = [1,2,3,4,5]  
y = [1,4,9,16,25]  
plt.plot(x,y)  
plt.show()  
fig1.savefig('fig1.png')

两种画图方式

Matplotlib中有两种画图方式：Matlab方式和面向对象的方式，我们上面展示的是前者
两种方式都可以完成需求并且大部分时候两者能互相转换，一般建议自己使用Matlab，但是面向对象的方式也要知道，遇到别人的工程这么写的时候能知道
如下对比知道，面向对象的方式先调用了一次axes()方法，fig是整个窗口，axes是窗口内画图的部分，也就是坐标轴

图窗与坐标轴

图形窗口（figure）在 Matlab 中会单独弹出，该窗口中可容纳元素，也可以是空的窗口。画图之前记得手动创建一下Fig对象，虽然例如使用Jupyter中不一定看得到，但是如果有保存图片的需求，这个Fig对象是必不可少的
坐标轴（axes）是一个矩形，其下方是 x 轴的数值与刻度，左侧是 y 轴的数值与刻度。

多图形的绘制

如上图，我们只是划了一条线，我们想要在一个窗口内画多个该如何做？很简单，就是利用plt对象多调用几次plot函数即可

import matplotlib.pyplot as plt  
fig1 = plt.figure()  
x = [ 1, 2, 3, 4, 5 ] # 数据的 x 值  
y1 = [ 1, 2, 3, 4, 5 ] # 数据的 y1 值  
y2 = [ 0, 0, 0, 0, 0 ] # 数据的 y2 值  
y3 = [ -1, -2, -3, -4, -5 ] # 数据的 y3 值  

# 使用Matlab的方式绘制  
plt.plot(x,y1)  
plt.plot(x,y2)  
plt.plot(x,y3)  
plt.show()  

# 使用面向对象的方式绘制  
ax1 = plt.axes()  
ax1.plot(x,y1)  
ax1.plot(x,y2)  
ax1.plot(x,y3)

绘制多个子图

在绘制多个子图上，两种方式可能区别会大一点
首先，两种方式都是借助plt.subplot()方法
可以看到，使用Matlab的方式绘制，就是依次交替使用subplot()方法和plot()方法,且需要传入三个参数 ；
而使用面向对象的方式，需要向plt.subplot(x) 传入一个参数x代表需要几个子图，然后会返回Fig对象和ax数组对象，需要注意，这里会返回Fig对象，就不需要再次使用plt.figure()了，然后因为ax反参是一个数组，数组的长度就是子图的个数，代表每个坐标系，所以我们只需要遍历并且都调用plot方法即可,我们之后都可以利用plt.subplot()代替plt.figure()和plt.axes()

import matplotlib.pyplot as plt  
fig1 = plt.figure()  
x = [ 1, 2, 3, 4, 5 ] # 数据的 x 值  
y1 = [ 1, 2, 3, 4, 5 ] # 数据的 y1 值  
y2 = [ 0, 0, 0, 0, 0 ] # 数据的 y2 值  
y3 = [ -1, -2, -3, -4, -5 ] # 数据的 y3 值  

# 使用Matlab的方式绘制
# 传入三个参数 分别代表 需要 3行1列个子图，当前是子图的第一个
plt.subplot(3,1,1)  
plt.plot(x,y1)  
plt.subplot(3,1,2)  
plt.plot(x,y2)  
plt.subplot(3,1,3)  
plt.plot(x,y3)  

# 使用面向对象的方式绘制  
fig2,ax2 = plt.subplot(3)  
ax2[0].plot(x,y1)  
ax2[1].plot(x,y2)  
ax2[2].plot(x,y3)

图表类型

plt提供了五类基本的图表类型二维图;网络图;统计图;轮廓图;三维图
我们这里只看深度学习可能会要用到的，如果遇到了不会的，可以直接去官方现场学
Plot types — Matplotlib 3.10.8 documentation
作者也还准备了许多提前画好的图，我们可以借鉴和学习Examples — Matplotlib 3.10.8 documentation

二维图

二维图，只需要给定两个向量即可画图，其中线型图其实可以代替其余大部分的二维图，画对应图就使用名字旁对应的函数，我们这里只会介绍线型图Plot

我们这里只学习plot()
首先对于plot()的基本使用我们已经了解，最基本的需要两个入参plot(x,y)代表横坐标和纵坐标
如果需要使用颜色，可以添加入参color,例如plt.plot(x,y,color="#7CB5EC")，需要注意，这个color是十六进制的方式进行获取和输入，可以通过其余网站或者QQ截图的方式获取

#绘制不同颜色的二维图
import matplotlib.pyplot as plt  
fig1 = plt.figure()  
x = [ 1, 2, 3, 4, 5 ] # 数据的 x 值  
y1 = [ 0, 1, 2, 3, 4 ] # 数据的 y1 值  
y2 = [ 1, 2, 3, 4, 5 ] # 数据的 y2 值  
y3 = [ 2, 3, 4, 5, 6 ] # 数据的 y3 值  
y4 = [ 3, 4, 5, 6, 7 ] # 数据的 y4 值  
y5 = [ 4, 5, 6, 7, 8 ] # 数据的 y5 值  

plt.plot(x, y1, color='#7CB5EC')  
plt.plot(x, y2, color='#F7A35C')  
plt.plot(x, y3, color='#A2A2D0')  
plt.plot(x, y4, color='#F6675D')  
plt.plot(x, y5, color='#47ADC7')  
plt.show()

# 使用面向对象的方式
Fig2, ax2 = plt.subplots()
ax2.plot(x, y1, color='#7CB5EC')
ax2.plot(x, y2, color='#F7A35C')
ax2.plot(x, y3, color='#A2A2D0')
ax2.plot(x, y4, color='#F6675D')
ax2.plot(x, y5, color='#47ADC7')

如果需要设置线条样式，可以使用linestyle入参,例如plt.plot(x, y1, linestyle='-')，这个参数默认就是-表示实线，除此之外我们一般还可以设置:表示点线, -.表示虚线,--表示虚线, 表示隐藏该线条等等

import matplotlib.pyplot as plt  
fig1 = plt.figure()  
x = [ 1, 2, 3, 4, 5 ] # 数据的 x 值  
y1 = [ 0, 1, 2, 3, 4 ] # 数据的 y1 值  
y2 = [ 1, 2, 3, 4, 5 ] # 数据的 y2 值  
y3 = [ 2, 3, 4, 5, 6 ] # 数据的 y3 值  
y4 = [ 3, 4, 5, 6, 7 ] # 数据的 y4 值  
y5 = [ 4, 5, 6, 7, 8 ] # 数据的 y5 值  

plt.plot(x, y1, linestyle='-')  
plt.plot(x, y2, linestyle='--')  
plt.plot(x, y3, linestyle='-.')  
plt.plot(x, y4, linestyle=':')  
plt.plot(x, y5, linestyle=' ')  
plt.show()

# 面向对象方式
Fig2, ax2 = plt.subplots()
ax2.plot(x, y1, linestyle='-')
ax2.plot(x, y2, linestyle='--')
ax2.plot(x, y3, linestyle='-.')
ax2.plot(x, y4, linestyle=':')
ax2.plot(x, y5, linestyle=' ')

如果需要设置粗细，可以使用linewidth,例如plt.plot(x, y1, linewidth=0.5)，一般我们设置0.5-3的范围就差不多了

如果需要标记节点，可以使用marker,例如plt.plot(x, y1, marker='.')，如果还需要修改标记的大小，可以使用markersize,我们一般设置为3-9的大小差不多

那么综上，我们可以一起用起来，如下图所示
此时可以关注一下线条五，可以看到线条五linestyle=''并且marker='o' ，这个就是隐藏线条的最大作用，可以模拟出二维图中的散点图即plt.scatter()并且效率更高，scatter是一个一个点单独渲染，plot是整体渲染且格式整齐

还可以将上述属性综合起来写在第三个参数上，例如

# 如下第三个参数bs-  b表示颜色为blue s表示使用正方形标记节点  -表示线条样式
plt.plot(train_process['epoch'], train_process.val_acc_all, "bs-", label="Val acc")

网格图

网格图我们只介绍imshow()函数，其余两个在深度学习中用处不大

imshow()的功能是绘制图像，可以接受二维数组（灰度图）或者三维数组（彩色图）等将其作为图像数据渲染成可视化图像，在绘制图片、热力图、卷积神经网络的特征图等基于像素 / 数组的可视化中都有应用，执行之后不会有任何窗口弹出，如下案例代码弹窗是show()函数的功能

import matplotlib.pyplot as plt  
import numpy as np  
x = np.linspace(0,10,1000)  
# 1000 行 ×1 列的彩色竖条热力图，数据基于 `sin(x)*cos(x)` 的周期性波动
l = np.sin(x)*np.cos(x).reshape(-1,1)  
fig1 = plt.figure()  
plt.imshow(l)  # imshow函数负责将l这个二维数组绘画出来
plt.show() # 图片展示功能是show()的作用 如果没有这一行 不会弹窗的

# 面向对象的方式
plt.subplots()

除此之外，所有的网格图都可以配置加一个颜色条，但是这种功能在面向对象的方式中是缺失的，所以我们只能通过Matlab的方式中进行操作

import matplotlib.pyplot as plt  
import numpy as np  
x = np.linspace(0,10,1000)  
l = np.sin(x)*np.cos(x).reshape(-1,1)  
fig1 = plt.figure()  
plt.imshow(l)  
plt.colorbar()  
plt.show()

统计图

在深度学习领域，我们一般只要用到直方图，其余的都是数据分析领域的，我们这里也只学习hist()函数

需要注意的是，条形图bar和直方图hist不要弄混，条型图bar可以被plot替代，hist则是统计学中的函数，为了看清楚分布的均值与标准差
先来看看其简单的使用，传入样本数组，即可进行绘制，如下图，利用NumPy生成符合正态分布的100个样本data，然后将其传入到hist(data)中

import matplotlib.pyplot as plt  
import numpy as np  
arr = np.random.randn(100)  
print(arr)  
fig1 = plt.figure()  
plt.hist(arr)  
plt.show()

可以通过bins参数设置区间划分的数量，默认是10，也就是10条柱，可以修改为20试试
plt.hist(data,bins=20)或者ax.hist(data,bins=20)

可以通过alpha参数设置透明度，alpha参数的默认为1，我们可以修改为0.5试试
plt.hist(data,alpha=0.5)/ax.hist(data,alpha=0.5)

可以通过histtype设置图表类型，默认为bar，可以从["bar", "barstacked", "step", "stepfilled"]中进行选择，例如plt.hist(data,histtype="step")/ax.hist(data,histtype="step")就是设置为无填充的样式

可以通过color设置直方图颜色，和plot()的颜色设置一样，采用十六进制颜色设置plt.hist(arr,bins=20,alpha=0.5,histtype="step",color="#14C468")设置为绿色

通过edgecolor设置直方图边缘颜色，即两两直方柱之间的边缘部分的颜色。例如plt.hist(data,edgecolor="#191A1C")

图床属性

坐标轴上下限设置

尽管 Matplotlib 会自动调整图窗为最佳的坐标轴上下限，但叛逆的我们知道，很多时候仍需手动设置，才能适应当时的情况。
这里有两种方式lim和axis

lim法

lim法分为了xlim(start，end)和ylim(start,end),分别用于设置X轴和Y轴的上下限，我们可以看到，如下是没有指定的时候，自动给我们配置的XY轴情况

我们自己指定后展示如下，需要注意的是，plt和ax对于这个方法相对调用稍微不太一样plt.xlim()/ax.set_xlim()

import matplotlib.pyplot as plt  
fig = plt.figure()  
x = [1,2,3,4,5,6]  
y = [1,16,81,100,125,180]  
plt.plot(x,y)  
plt.xlim(1,7)  
plt.ylim(1,180)  
plt.show()

# 面向对象方式（lim 法）
Fig2, ax2 = plt.subplots()
ax2.plot(x,y)
ax2.set_xlim(1,5)
ax2.set_ylim(1,125)

axis法

axis主要是入参上和lim法不一样，传入一个lenth=4的列表，分别为[x.start , x.end , y.start , y.end ]，除此之外，还可以使用axis('equal')让x轴和y轴比例达到1:1

import matplotlib.pyplot as plt  
fig = plt.figure()  
x = [1,2,3,4,5,6]  
y = [1,16,81,100,125,180]  
plt.plot(x,y)  
plt.axis([1,7,1,180])  
plt.show()

标题与轴名称

这里也是Matlab方式和面向对象的方式最后的一个区别
我们会需要给X轴还有Y轴还有整个图像命名，这个时候就需要借助plt.title设置标题;plt.xlabel设置X轴名字;plt.ylabel设置Y轴名字
这里顺便汇总一些Matlab和面向对象的一些方法区别汇总

import matplotlib.pyplot as plt  
fig = plt.figure()  
x = [1,2,3,4,5,6]  
y = [1,16,81,100,125,180]  
plt.plot(x,y)  
plt.title('Plot Title')  
plt.xlabel('X Axis')  
plt.ylabel('Y Axis')  
plt.show()

额外提一下，面向对象方式统一了五个函数，所以我们可以写成
ax.set(xlim=(),ylim(),title="",xlabel="",ylabel="")

图例

图例一般只会出现在二维图和统计图中，网格图一般使用颜色条
图例主要就是使用label参数，如果你想要这个线条有图例就加入label参数，反之如果不想要就不加即可,默认展示在左上角

还有一种就是使用plt.legend()函数，给其传入一个数组，数组一一对应前面你的线条，同时legend函数还有三个常用的关键字参数
第一个 loc设置图例位置，可选upper;center;lower和left;center,right两组中分别选一个，那么就可使用legend(data,loc='upper right')，也可以直接使用legend(data,loc='best')程序自行调整为最佳
第二个 frameon图例边框，默认True，为显示；如果不想要边框则设置为False
第三个 ncol用于设置图例的列数，默认为1即所有图例都一列展示，可以根据需求设置为多列，例如设置为两列ncol=2

网格

可以给图形背景上网格，主要利用plt.grid()函数
该函数有两个参数color设置颜色以及linestyle设置线条格式

import matplotlib.pyplot as plt  
fig = plt.figure()  
x = [1,2,3,4,5,6]  
y = [1,16,81,100,125,180]  
plt.plot(x,y)  
plt.title('Plot Title')  
plt.xlabel('X Axis')  
plt.ylabel('Y Axis')  
plt.grid(linestyle='--')  
plt.show()

主要的参考资料来源 《深度学习入门：基于Python的理论与实现 (斋藤康毅) 》（鱼书） B站Up主爆肝杰哥的相关视频 主要考虑到是入门以及快速能上手工程，没有基础，不能在数学等其余问题上过多的纠结，本身掌握程度不够，所以不会以李沐老师的课成为第一课程，后续才会去看 此外，因为是为了深度学习才接触的Python，并非专攻Python方向，所以对于Python的很多其他的特性也不会涉及，一切以深度学习的需要进行学习

前言

在深度学习领域，我们主要是利用Python以及几个库进行，分别是

• NumPy-为Python加上了关键的数组变量类型

• Pandas-在NumPy的基础上添加了类似Excel的行列标签

• Matplotlib-借鉴Matlab，为Python提供了绘图能力

• Scikit-learn-机器学习库，包含了分类，回归，聚类，将为等多种算法

• Tensorflow-Goole研发的深度学习框架

• PyTorch-FaceBook研发的深度学习框架

深度学习的相关概念

大家可能听说过人工智能；机器学习；神经网络；深度学习等多个专有名词，实际上这几个都是有联系的

• 人工智能是最大的一个概念，最顶层的，其中一个重要的分支就是机器学习

• 机器学习的算法多种多样，其中核心就是神经网络

• 神经网络的隐藏层如果够深，就可以被称之为深层神经网络，这也属于我们所说的深度学习

• 深度学习包括了深度神经网络；卷积神经网络；循环神经网络

变量类型与输出语句

总览

学习Python首先需要注意如下几点

1. Python的注释是采用#而不是 //，多行注释要采用三个双引号"""..."""

2. Python是动态语言类型不是静态，在声明变量的时候不需要指定变量类型，如果需要指定数据类型，可以使用类型注解（但是即使使用，也只是作为提示作用，不会受到编译器强制校验）

3. Python没有末尾分号，但是有比较烦人的缩进，所以不要在Python中随便使用空格

首先我们来看看如何定义一个变量

# 直接声明和初始化即可
a = 2  
# 如果需要指定类型 可以使用类型注解，即name:type的形式
b:int = 2  
# 但是类型注解只是起到提示的作用，编译器并不会校验，所以如下代码也不会报错
c:int = "abc"

Python原生的数据类型分为两大类：基本变量类型和高级变量类型，一共七种数据类型 基本数据类型包括：字符串，数字，布尔类型 ； 高级变量类型包括：集合，元组，列表，字典 七种类型展示如下，需要注意一下几点

• Python不能够声明但是不赋值，这是因为在Python中变量只有被赋值的时候才是真正被创建，在其他语言中，例如Java中允许int a;这是因为在Java中声明即创建了对应的内存空间，a已经存在只是没有数值

• Python中的布尔类型严格遵循大小写，只能是True和False，而不能是true或false

• Python四大高级变量类型，set集合是使用大括号{} ； list列表使用中括号[] ； tuple元组使用的小括号() ； dict字典是大括号但为Key-Value的形式

• list集合：有序，支持下标访问，地址不可变但是内容可变，支持增删改，允许重复，空列表使用[]或者list()

• tuple元组：有序，同列表可下标访问；不可变，一旦确认不能修改，不能增删改；允许重复；空元组使用()或者tuple()；如果是只有一个元素的元组创建，必须加一个逗号(1,)

• set集合：无序,不能下标查找；可变，支持增删，但不能修改已有元素；不可重复，自动去重；空集合使用set()；支持集合运算符交集(&),并集( | ),差集(-)等

• dict字典：3.7版本及其以上默认按照插入顺序排序；3.7之前无序 ； 可变 Key唯一，重复会覆盖原本的 ； Value可重复 ；Key必须是不可变类型(例如int,str,tuple；列表/集合/字典就不能作为Key) ； 空字典使用dict()或者{}，只能通过键值对访问而不能通过索引访问

# 声明但不赋值 这个在python中是不允许的
s:int
​
# 基本变量类型  
s = "zeal" # 字符串  
# 数字类型  
age = 22  
height = 1.75  
weight = 120.0  
# 布尔类型  
bool_t = True  
bool_f = False  
  
# 高级变量类型  
#集合set 利用大括号包裹{}  
set_v = {1,2,3}  
print(set_v)  
  
  
# 元组tuple 利用 小括号包裹()  
tuple_v = (1,2,3)  
print(tuple_v)  
  
# 列表  
list_v = [1,2,3,4,5]  
print(list_v)  
  
# 字典dict  
dict_v = {"name":"zeal","age":22}  
print(dict_v)

基本变量类型

字符串类型

Python中字符串类型，也就是我们别的编程语言中说的String类型，可以使用双引号，也可以使用单引号,支持两种方式的原因是为了保证当字符串本身有单引号或者双引号的时候可以灵活处理，如果字符串本身同时具备单引号和双引号，那么和别的编程语言一样，就需要使用转义了。

# 当变量中本身具备单引号  
s1 = "I'm a student."  # 使用双引号包裹字符串 防止字符串本身的单引号截断  
# 当变量中本身具备双引号  
s2 = 'He said, "I am a student."'  # 使用单引号包裹字符串 防止字符串本身的双引号截断  
# 当变量中同时具备单引号和双引号  
s3 = "He said, \"I'm a student.\""  # 使用转义字符 \ 来表示字符串中的双引号,当然，也可以转义单引号

当我们要想组合字符串类型的变量的时候，可以利用 f字符串，将需要引入的字符串变量在f后的字符串中通过大括号{...}包裹起来从而实现引用，在输出中我们常这么使用

name = "zeal"  
love = "play game"  
# 组合字符串为一个新字符串
result = f"My name is {name} and I love {love}"  
print(result)
# 直接在打印语句中组合字符串  
print(f"My name is {name} and I love {love}")

当然，print还有另外一个用法，直接利用逗号,进行拼接，但是因为默认,会用一个空格隔开，我们可以在最后用sep=设置间隔符从而实现无间隔拼接

print("my name is",name,"and age is",age,sep=" ")

数字类型

数字类型分为整型和浮点型，具体的区别我们在NumPy中再去介绍。 Python中常见运算规则如下

# 1. 算术运算符
print("-" * 40)  
a = 10  
b = 3  
print(f"a = {a}, b = {b}")  
  
print(f"加法: a + b = {a} + {b} = {a + b}")  
print(f"减法: a - b = {a} - {b} = {a - b}")  
print(f"乘法: a * b = {a} * {b} = {a * b}")  
#需要注意python中的单个/是完整的除法 也就是会计算完
#别的语言中 / 是整除，python中 // 才是整除
print(f"除法: a / b = {a} / {b} = {a / b}")  
print(f"整除: a // b = {a} // {b} = {a // b}")  
print(f"取余: a % b = {a} % {b} = {a % b}")  
print(f"幂运算: a ** b = {a} ** {b} = {a ** b}")  # a的b次方,即a^b
  
# 2. 比较运算符
# 等于为== 不等于为!= 可以直接使用>= 和 <=
print("-" * 40)  
x = 15  
y = 20  
print(f"x = {x}, y = {y}")  
  
print(f"等于: x == y -> {x} == {y} = {x == y}")  
print(f"不等于: x != y -> {x} != {y} = {x != y}")  
print(f"大于: x > y -> {x} > {y} = {x > y}")  
print(f"小于: x < y -> {x} < {y} = {x < y}")  
print(f"大于等于: x >= y -> {x} >= {y} = {x >= y}")  
print(f"小于等于: x <= y -> {x} <= {y} = {x <= y}")  
  
# 3. 赋值运算符 (Assignment Operators)print("\n【3】赋值运算符 (Assignment Operators)")  
print("-" * 40)  
c = 5  
print(f"初始值: c = {c}")  
  
c += 3      # c = c + 3  
print(f"加法赋值: c += 3 -> c = {c}")  
  
c -= 2      # c = c - 2  
print(f"减法赋值: c -= 2 -> c = {c}")  
  
c *= 4      # c = c * 4  
print(f"乘法赋值: c *= 4 -> c = {c}")  
  
c /= 2      # c = c / 2  
print(f"除法赋值: c /= 2 -> c = {c}")  
  
c //= 3     # c = c // 3  
print(f"整除赋值: c //= 3 -> c = {c}")  
  
c %= 4      # c = c % 4  
print(f"取余赋值: c %= 4 -> c = {c}")  
  
c **= 3     # c = c ** 3  
print(f"幂运算赋值: c **= 3 -> c = {c}")  
  
# 4. 位运算符 
print("-" * 40)  
m = 12      # 二进制: 1100  
n = 10      # 二进制: 1010  
# 利用bin(number) 可以得到number的二进制
print(f"m = {m} (二进制: {bin(m)}), n = {n} (二进制: {bin(n)})")  
  
print(f"按位与: m & n = {m} & {n} = {m & n} (二进制: {bin(m & n)})")  
print(f"按位或: m | n = {m} | {n} = {m | n} (二进制: {bin(m | n)})")  
print(f"按位异或: m ^ n = {m} ^ {n} = {m ^ n} (二进制: {bin(m ^ n)})")  
print(f"按位取反: ~m = ~{m} = {~m} (二进制: {bin(~m & 0b1111)})")  
print(f"左移: m << 2 = {m} << 2 = {m << 2} (二进制: {bin(m << 2)})")  
print(f"右移: m >> 2 = {m} >> 2 = {m >> 2} (二进制: {bin(m >> 2)})")  
  
# 5. 逻辑运算符 这里需要注意和别的语言的区别,python的与或非使用的为 and or not 而不是& | !
print("-" * 40)  
p = True  
q = False  
print(f"p = {p}, q = {q}")  
  
print(f"逻辑与: p and q = {p} and {q} = {p and q}")  
print(f"逻辑或: p or q = {p} or {q} = {p or q}")  
print(f"逻辑非: not p = not {p} = {not p}")  
  
# 6. 成员运算符和身份运算符 
# 主要用于高级变量类型，检查是否在集合内，in 和 not in
# 元组，列表，集合，字典都可以使用，对于字典而言，检查的是key不是value
print("-" * 40)  
num_list = [1, 2, 3, 4, 5]  
num1 = 10  
num2 = 10  
print(f"列表: {num_list}, num1 = {num1}, num2 = {num2}")  
  
print(f"成员运算符 in: 3 in num_list = {3 in num_list}")  
print(f"成员运算符 not in: 6 not in num_list = {6 not in num_list}")  
print(f"身份运算符 is: num1 is num2 = {num1 is num2}")  
print(f"身份运算符 is not: num1 is not num_list = {num1 is not num_list}")  
  
# 7. 运算符优先级示例  
print("\n【7】运算符优先级示例")  
print("-" * 40)  
result1 = 10 + 5 * 3  
result2 = (10 + 5) * 3  
result3 = 2 ** 3 * 4  
result4 = 2 ** (3 * 4)  
  
print(f"乘法优先于加法: 10 + 5 * 3 = {result1}")  
print(f"括号改变优先级: (10 + 5) * 3 = {result2}")  
print(f"幂运算优先于乘法: 2 ** 3 * 4 = {result3}")  
print(f"括号改变优先级: 2 ** (3 * 4) = {result4}")  
  
# 8. 不同数字类型之间的运算  
print("\n【8】不同数字类型之间的运算")  
print("-" * 40)  
int_num = 10  
float_num = 3.5  
complex_num = 2 + 3j  
  
print(f"整数: {int_num}, 浮点数: {float_num}, 复数: {complex_num}")  
print(f"整数 + 浮点数: {int_num} + {float_num} = {int_num + float_num} (类型: {type(int_num + float_num)})")  
print(f"整数 + 复数: {int_num} + {complex_num} = {int_num + complex_num} (类型: {type(int_num + complex_num)})")  
print(f"浮点数 * 复数: {float_num} * {complex_num} = {float_num * complex_num} (类型: {type(float_num * complex_num)})")

类型转换

Python中，字符串，浮点数，整数，布尔类型之间都可以转换

• 需要转化为字符串，使用str()

• 需要转化为整数，使用int()

• 需要转化为浮点数，使用float()

• 需要转化为布尔类型，使用bool() 需要注意，上述的这些属于内置工具函数，而不是别的语言中的强转，但也要注意 浮点数字符串不能int(); 非0数字和非空字符串(包括空格组成的字符串) 使用bool()返回True; 0和串("")使用bool()返回False

str_v = "123.123"  
print(float(str_v))  
print(bool(str_v))  
  
number1 = 99  
number2 = 0  
print(str(number1))  
print(str(number2))  
print(bool(number2))  
  
bool_v1 = True  
bool_v2 = False  
print(str(bool_v1))  
print(str(bool_v2))  
print(int(bool_v1))  
print(int(bool_v2))
​

高级变量类型

Set集合

Set集合的特点：无序 ； 不可重复 ；可以使用-；|；&进行集合的运算；不能修改，只能删除和新增

set_1 = {"湖","南","科","专",1,2,3}  
print(set_1) # 输出 {1, 2, 3, '南', '专', '湖', '科'}  体现无序
set_2 = set(["湖","南","科","科",4,5,6])  # 类似上面的类型转换，可有元组得到
print(set_2) # 输出 {4, 5, 6, '南', '湖', '科'} 体现自动去重
​
print(set_1-set_2) # set1中有但是set2中没有的  
print(set_1|set_2) # set1或set2中的所有元素  
print(set_1&set_2) # set1和set2中的交集元素

我们可以使用 in 和 not in判断元素是否存在于集合中

可以通过list(set)或者tuple(set)的方式将集合转换为列表或者元组，从而实现遍历和查找元素 如果要修改元素，因为不支持修改，我们只能先删除再添加，删除我们常用的语法是remove()和discard()（前者删除不存在的元素的时候会报错，后者不会更加安全），新增则用add()

集合在深度学习的过程中遇到的概率比较低，会被Pands替代，所以不过多讲述

List列表

Python中的列表就可以比作Java中的ArrayList，边长的数组，可重复，有序，下标访问，只是基于Python动态语言的特性，一个List中可以包含任何数据类型，不存在类型限制，也可以List套List

list_v = [1,2,3,"ZhangSan",True,[4,5,6]]  
print(list_v)
print(list_v[0])

虽然List没有限制，但是实际上底层List还是会需要存储每个类型的数据类型，导致数组其实占用空间增大了。在NumPy中我们会用NumPy数组（仅仅接纳一种数据类型的列表）代替List，提升运行速度，降低内存压力

List支持负数下标索引，我们知道0索引位置对应的List的第一个元素，那么-1其实就是倒数第一个元素，以此类推，-2就是倒数第二个元素

list_v = [1,2,3,"ZhangSan",True,[4,5,6]]  
print(list_v[-1],list_v[-2],list_v[-3])  
list_v[-2]=100  
print(list_v[-1],list_v[-2],list_v[-3])

Python的List有着和Golang的数组一样的切片的特性，切片就是列表一部分，可以利用[start:end]的形式截取列表中的 start~end 之间的部分，注意左闭右开

list_v = [1,2,3,"ZhangSan",True,[4,5,6]]  
print(list_v[1:]) # 第二个元素到最后  
print(list_v[:]) # 全部元素  
print(list_v[1:2]) # 只有第二个元素  
print(list_v[:5]) # 前四个元素 等同于 print(list_v[:-1])

除此之外，Python的切片还能支持间隔切片。当我们明确隔n个元素采样一次的时候，可以使用[star:end:n]

list_v = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]  
print(list_v[1:-1:2]) # [2, 4, 6, 8, 10, 12, 14]

特别注意，Python的切片和原列表对象是完全独立的，也就是两个列表了实际上，所以对于几百万数据的大列表进行切片操作，对于主机而言是一个很大的考验，这点要和Go的切片区分开来，Go中的切片和原来的是共享的

list_v = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]  
list_v2 = list_v[1:-1:2]  
print(list_v2)   # [2, 4, 6, 8, 10, 12, 14]
list_v2[0] = 99  
print(list_v2)  # [99, 4, 6, 8, 10, 12, 14]
print(list_v) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

在NumPy的数组中这个就被舍弃了，NumPy中的切片和原数组是共享的，修改切片也会修改原数组，如果真的需要完全拷贝一份新的，就是借助copy()函数

List可以通过append()函数添加元素，也可以通过加法和乘法扩充和复制

list_v = [1,2,3,4]  
list_v.append(5)  
print(list_v)  #12345
print(list_v+[6])   #123456
print(list_v+[6,7,8])  #12345678
print(list_v*2) #1234512345

列表还有一个列表推导式，可以了解和学习一下 正常的我们创建由已知列表开平方得到新列表，我们需要借助for循环，代码如下

result = []
for i in [1,2,3,4]:
    result = result+[i**2]
print(result)

使用列表推导式之后可以这么写

result = [i**2 for i in [1,2,3,4]]

也还是加一点的if判断

result = []
for i in [1,2,3,4]:
    if i<3:
        result = result+[i**2]
print(result)
​
# 列表推导式写法
result = [i**2 for i in [1,2,3,4] if i<3]

tuple元组

元组的特点：有序；可重复；单个元素不可修改但是可重新赋值替换；下标访问

tuple_age = (1,2,3)  
# 这种创建方式极其简单方便
# 同时也可以看到，python中对于类型的要求没那么强
tuple_name = "张三","李四",99  tuple_null = ()  # 创建空元组
print(tuple_age)  
# tuple_age[0]=10 在运行的时候会报错
tuple_age = 3,3,3  
print(tuple_age[0]) # 下标访问单个元素
print(tuple_name)  
print(tuple_null)

除此之外，可以利用元组进行批量赋值，或者说就是Python的批量赋值的特性

a,b,c = 1,2,3  
e,f,g = (11,12.2,13.33)  
print(a,b,c)  
print(e,f,g)

当有多个数值的列表，然后你只需要部分数值的时候，你可以利用元组的快捷构造的特性进行截取

result1,result2,*other,result3 =1,2,3,4,5  
print(result1)  #1
print(result2)  #2
print(other)  #[3,4]
print(result3) #5

dict字典

一个Key-Value结构，不可重复，重复会覆盖；无序 ；Key唯一 ； Value可以为任何数据类型，Key只能是不可变的元素（数字，字符串，布尔，元组，不可变集合）

dict_v = {  
    "name":"zhangsan",  
    "age":18,  
    1:(1,2,3),  
    2:[1,2,3],  
    3:{1,2,3},  
    "4":True  
}  
# {'name': 'zhangsan', 'age': 18, 1: (1, 2, 3), 2: [1, 2, 3], 3: {1, 2, 3}, '4': True}
print(dict_v)

字典添加元素，可以直接通过dict[newKey]=newValue的方式进行新增

dict_v = {  
    "name":"zhangsan",  
    "age":18,  
}  
dict_v["newKey"] = "newValue"  
print(dict_v)

类型转换

集合，列表，元组，字典之间也可以进行转换，用到如下四个函数

• 转化为集合使用set()

• 转化为元组使用tuple()

• 转化为列表使用list()

• 转化为字典使用dist() 这里就展示图片，不附带代码了，可自行尝试，需要注意的是，其余的转化为字典的时候，因为字典是双列的，所以肯定还会需要一个单列集合，这个时候就需要借助zip(A,B)函数，该函数会将入参A和B进行一一对应，然后让A[0]作为Key，B[0]作为Value从而组成dict[0]，这里需要注意，传入的A和B如果是集合这种无序的，那么会造成匹配不一样按照预期一样

流程控制

if语句

在Python中，if语句的使用格式为如下，需要注意：

• Python中的函数，循环，if条件判断等都不会使用end来表示代码块的结束

• Python中使用缩进来表示代码块的范围

• 每一个判断条件的最后都有一个冒号，不要遗漏

if 判断条件:
    逻辑处理一
elif 判断条件:
    逻辑处理二
else:
    逻辑处理三

简单的分数区间判断案例

source = 85  
if source == 100:  
    print("满昏")  
elif source >= 90:  
    print("优秀")  
elif source >= 60:  
    print("及格")  
else:  
    print("不及格")

循环语句

Python中for循环的基本使用如下

for 变量名 in 可迭代对象:
    循环体逻辑
    
    
# 遍历列表，依次取出每个元素 
fruits = ["苹果", "香蕉", "橙子"] 
for fruit in fruits: 
    print(f"我喜欢吃：{fruit}") 
# 输出结果： # 我喜欢吃：苹果 # 我喜欢吃：香蕉 # 我喜欢吃：橙子

如果需要计数式循环，即例如Java中for(int i=0;i<10;i++),可以借助range(n)，该函数会创建一个0~n-1的整数序列供for循环使用,需要注意，range()函数也是左闭右开的区间范围

# 用法1：range(n) → 生成 0 ~ n-1 的整数序列  
for i in range(5):  
    print(i)  # 输出：0 1 2 3 4  
  
# 用法2：range(start, end) → 生成 start ~ end-1 的整数序列（左闭右开）  
for i in range(2, 7):  
    print(i)  # 输出：2 3 4 5 6  
  
# 用法3：range(start, end, step) → 步长为step，生成等差序列  
for i in range(0, 10, 2):  
    print(i)  # 输出：0 2 4 6 8（偶数）  
  
# 示例：通过索引遍历列表  
fruits = ["苹果", "香蕉", "橙子"]  
for i in range(len(fruits)):  
    print(f"索引{i}：{fruits[i]}")

for循环也常用于高级变量类型的遍历

# 1. 遍历列表 (List)print("\n【1】遍历列表 (List)")  
print("-" * 40)  
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]  
print(f"列表内容: {fruits}")  
  
print("方法1: 直接遍历元素")  
for fruit in fruits:  
    print(f"  - {fruit}")  
  
print("\n方法2: 使用enumerate()获取索引和值")  
for index, fruit in enumerate(fruits):  
    print(f"  索引: {index}, 值: {fruit}")  
  
print("\n方法3: 使用range(len())遍历索引")  
for i in range(len(fruits)):  
    print(f"  索引: {i}, 值: {fruits[i]}")  
  
# 2. 遍历元组 (Tuple)print("\n【2】遍历元组 (Tuple)")  
print("-" * 40)  
colors = ("红色", "绿色", "蓝色", "黄色")  
print(f"元组内容: {colors}")  
  
print("方法1: 直接遍历元素")  
for color in colors:  
    print(f"  - {color}")  
  
print("\n方法2: 使用enumerate()获取索引和值")  
for index, color in enumerate(colors):  
    print(f"  索引: {index}, 值: {color}")  
  
# 3. 遍历集合 (Set)print("\n【3】遍历集合 (Set)")  
print("-" * 40)  
numbers = {1, 2, 3, 4, 5, 3, 2}  # 注意：集合会自动去除重复元素  
print(f"集合内容: {numbers}")  
  
print("方法1: 直接遍历元素")  
for num in numbers:  
    print(f"  - {num}")  
  
print("\n方法2: 对集合排序后遍历")  
for num in sorted(numbers):  
    print(f"  - {num} (排序后)")  
  
# 4. 遍历字典 (Dictionary)print("\n【4】遍历字典 (Dictionary)")  
print("-" * 40)  
student_scores = {  
    "张三": 95,  
    "李四": 87,  
    "王五": 92,  
    "赵六": 78  
}  
print(f"字典内容: {student_scores}")  
  
print("方法1: 遍历键(keys)")  
for name in student_scores:  
    print(f"  学生: {name}, 分数: {student_scores[name]}")  
  
print("\n方法2: 明确遍历键(keys)")  
for name in student_scores.keys():  
    print(f"  学生: {name}, 分数: {student_scores[name]}")  
  
print("\n方法3: 遍历值(values)")  
for score in student_scores.values():  
    print(f"  分数: {score}")  
  
print("\n方法4: 同时遍历键和值(items)")  
for name, score in student_scores.items():  
    print(f"  学生: {name}, 分数: {score}")  
  
# 5. 嵌套数据结构的遍历  
print("\n【5】嵌套数据结构的遍历")  
print("-" * 40)  
nested_data = {  
    "班级A": [85, 90, 78],  
    "班级B": [92, 88, 84],  
    "班级C": [79, 85, 91]  
}  
  
print("遍历嵌套字典和列表")  
for class_name, scores in nested_data.items():  
    print(f"  {class_name}:")  
    for i, score in enumerate(scores):  
        print(f"    学生{i+1}: {score}分")  
  
# 6. 使用条件语句的遍历  
print("\n【6】带条件判断的遍历")  
print("-" * 40)  
mixed_list = [1, "hello", 3.14, "world", 42, True, "python"]  
print(f"混合列表: {mixed_list}")  
  
print("只打印字符串类型的元素:")  
for item in mixed_list:  
    if isinstance(item, str):  
        print(f"  字符串: {item}")  
  
print("\n只打印数字类型的元素:")  
for item in mixed_list:  
    if isinstance(item, (int, float)):  
        print(f"  数字: {item}")  
  
print("\n" + "="*60)  
print("Python for循环遍历演示完成！")  
print("="*60)

while循环的基本格式如下

while 条件:
    循环体

break和continue的使用和其他语言一致，这里不过多讲述

函数

Python中的函数关键字为def，其格式如下

def 函数名(入参列表):
    """ 文档说明字符串 """
    函数体
    return 反参

首先我们来解释一下这个一开始文档说明字符串，这个需要搭配方法名.__doc__进行使用，当你在这个方法写了文档说明字符串的时候，你使用方法名.__doc__就能打印出这些内容，相当于做了方法说明文档，当然，这个不是必须的，如果不写，调用.__doc__会返回None

def add(x, y):  
    """计算x+y"""  
    return x + y  
  
print(add.__doc__) # 输出 计算x+y

函数的入参和反参可以是七种数据类型中的任意一种，并且Python的入参是值传递，也就是说函数入参是形参，不会对外部数据造成影响

def change(v):  
    v=v+1  
  
x = 10  
change(x)  
print(x) # 依旧是10

Python的函数可以多个入参和多个反参,多个反参可以利用多个变量接收，可以当作一个整体进行接收

def my_counter(a,b):  
    return a+b,a-b,a*b  
  
a,b,c= my_counter(1,2)  
print("和为",a,"差为",b,"积为",c)  
tuple_v = my_counter(1,2)  
print("和为",tuple_v[0],"差为",tuple_v[1],"积为",tuple_v[2])

需要传入可变数量的参数的时候，可以利用元组拆分法，利用*name作为入参

def my_counter(*args):  
    result = 0  
    for arg in args:  
        result += arg  
    return result  
  
print(my_counter(1, 2, 3, 4, 5))  #15
print(my_counter(1, 2, 3)) # 6

自然，也可以同时指定一个入参和剩下的不确定入参，需要注意的是，可变参数只能作为最后一个参数且一个函数只能有一个可变参数，虽然编译器不会报错，但是运行时会出错，因为无法确定边界

def my_counter(off,*args):  
    result = 0  
    for arg in args:  
        result += arg  
    return result+off  
  
print(my_counter(-10,1, 2, 3, 4, 5))  
print(my_counter(10,1, 2, 3))

上面通过*name实现不确定入参，可以理解为创建了一个name的列表然后允许我们一直往里面加东西，除此之外，还可以利用**name的方式，作为可变参数的键值对/字典

def plusDict(a,b,**dict_v):  
    """ 加入对Java和Golang的描述，也可以自定义加新的描述键值对 """    dict_v["Java"] = a  
    dict_v["Golang"] = b  
    return dict_v  
  
print(plusDict( "CRUD工程师","云原生的宠儿",Python="AI时代大哥大",Rust="高大上") )

在入参的时候，可以指定入参名从而不一定需要按照顺序传入参数

def my_counter(a, b, c):  
    return a + b * c  
print(my_counter(1,c=2,b=3))

在定义函数的时候，可以指定入参默认值，从而当不传入的时候，可以使用默认值

def yourSchool(name,level="本科"):  
    print("your school " + name + "is a " + level )  
  
yourSchool("HNUST")  # 不会报错
yourSchool("HNUST","985")

类

定义和普通使用

类的定义我们就不多说了，Python中的类一样具备封装，继承，多态的特性(据说在深度学习领域类一般是用来封装参数传递，其余特性用的少)，并且在Python中其实也是一切皆对象，就连基本数据类型int也是

a = 1
print(type(a)) # 输出：<class 'int'>

Python中类中的函数称之为方法，且约定俗成类的名称一般大写，Python的每个类必须包含一个__init__的初始化方法（简单理解为有参构造方法） init方法内的入参通过赋值就可以让类对象拥有成员a,b，也可以直接不通过入参来定义成员，这些成员具备默认值

class Counter:  
    """ 一个可以进行加减法的计算器 """    
    def __init__(self, a, b):  # 用于完成初始化的特殊方法  
        self.a = a  
        self.b = b
        self.name = "超级计算机"
  
  
    def plus(self):  # 类中的普通方法  
        return self.a + self.b  
    def minus(self):  # 类中的普通方法  
        return self.a - self.b
    def zwjs(self):  
        print("欢迎使用", self.name)

可以看到，无论是自定义普通方法还是init初始化方法，都有一个self参数，这个参数用于链接类内部和外部的信息，大家可以简单的理解为this指针，而且从上面也可也看到，Python的类的成员属性貌似可以不要定义，会根据__init__方法自动定义在self中，需要的话直接去self中拿就行了

类定义完成后，就可以创建类的对象以及调用其成员方法和成员属性

counter1 = Counter(1,2)  
print(counter1.a, counter1.b)  
print(counter1.plus())  
print(counter1.minus())  
counter1.zwjs()

继承

利用继承，可以让子类继承父类的属性和方法 Python的继承的表现形式为

class 类名(父类名):

在Python中还能多继承

class 类名(fu1,fu2)

子类需要在__init__方法中调用super()函数从而实现继承属性和方法，对于父类中已有属性和方法子类中再次定义的话就会覆盖重写

class Counter2(Counter):  
    """ 可以进行加减乘除的计算器 """  
    def __init__(self, a, b):  
        super().__init__(a, b)  # 这个不写其实也没事，不写的话就不能使用父类的东西，只要不使用父类的东西就不会报错
        self.name = "超级计算机二代"  
  
    def multiply(self):  
        return self.a * self.b  
    def divide(self):  
        return self.a / self.b  
  
    def zwjs(self):  
        print("您好,欢迎使用", self.name)
        
        
counter = Counter2(1, 2)  
print(counter.plus())  
print(counter.minus())  
print(counter.multiply())  
print(counter.divide())  
counter.zwjs()

我们知道如下几个点

1. Nacos客户端会和服务端进行心跳同步

2. Nacos服务端在集群环境下采用单个责任节点+多个从节点的方式管理，责任节点负责负责健康检查，心跳处理等操作，从节点仅仅担任数据同步工作

3. 一个微服务实例连接集群的条件下，请求可能会因为负载策略发送到任意一个Nacos节点上

那么综合上述，我们可以引出一个问题：如果客户端的心跳请求发送到了非责任节点会怎么处理？

这个地方可以参考Nacos仓库下面的一个issue

server端收到client beat请求后，不更新last beat时间，导致实际被判定为unhealthy · Issue #5363 · alibaba/nacos

针对上述问题，我们来举个例子：假设现在我们有三个集群节点，member1、member2、member3，又假设 member1 是负责 sotck-service 健康检查任务的节点。
​
stock-serivce 客户端发送心跳请求的时候，是随机发送到集群中某一个节点上的，假设 stock-service 没有给 member1 发送心跳请求，如果 lastBeat 属性不同步给集群节点，那么 member1 在做健康检查的时候，是不是会判断 stock-service 为不健康的实例？

我们可以看一下issue上大佬们关于这个问题的讨论与回复

按照大佬的意思就是：心跳请求应该是随机发送到集群中某一台上，然后通过distro协议转发到该服务的责任节点去统一更新实例心跳时间。且心跳时间不会进行同步。

我们可以自己扒一下源码来了解一下

我们来看到服务端对于心跳的处理这一块，可以看到有一个@CanDistro的注解

这个注解是一个自定义注解，但是他的作用好像不是很明了，我们可以看一下哪个地方用到了这个注解，发现这里有个Filter过滤器中用到了

我们来看一下这个过滤器，可以看到最终其匹配的URL是所有的/v1/ns/*的路径

接下来我们就可以来看一下Filter中的过滤逻辑，代码很长，但是我们主要看一下重要的部分，即有我写了注释的那一行其实就行了

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
        throws IOException, ServletException {
    ReuseHttpRequest req = new ReuseHttpServletRequest((HttpServletRequest) servletRequest);
    HttpServletResponse resp = (HttpServletResponse) servletResponse;
    
    String urlString = req.getRequestURI();
    
    if (StringUtils.isNotBlank(req.getQueryString())) {
        urlString += "?" + req.getQueryString();
    }
    
    try {
        String path = new URI(req.getRequestURI()).getPath();
        String serviceName = req.getParameter(CommonParams.SERVICE_NAME);
​
        if (StringUtils.isBlank(serviceName)) {
            serviceName = req.getParameter("dom");
        }
        
        if (StringUtils.isNotBlank(serviceName)) {
            serviceName = serviceName.trim();
        }
        Method method = controllerMethodsCache.getMethod(req);
        
        if (method == null) {
            throw new NoSuchMethodException(req.getMethod() + " " + path);
        }
        
        String groupName = req.getParameter(CommonParams.GROUP_NAME);
        if (StringUtils.isBlank(groupName)) {
            groupName = Constants.DEFAULT_GROUP;
        }
        
​
        String groupedServiceName = serviceName;
        if (StringUtils.isNotBlank(serviceName) && !serviceName.contains(Constants.SERVICE_INFO_SPLITER)) {
            groupedServiceName = groupName + Constants.SERVICE_INFO_SPLITER + serviceName;
        }
        
// 判断是否带有CanDistro注解 && responsible方法即判断是否为责任节点
        if (method.isAnnotationPresent(CanDistro.class) && !distroMapper.responsible(groupedServiceName)) {
            
            String userAgent = req.getHeader(HttpHeaderConsts.USER_AGENT_HEADER);
            
            if (StringUtils.isNotBlank(userAgent) && userAgent.contains(UtilsAndCommons.NACOS_SERVER_HEADER)) {
​
                Loggers.SRV_LOG.error("receive invalid redirect request from peer {}", req.getRemoteAddr());
                resp.sendError(HttpServletResponse.SC_BAD_REQUEST,
                        "receive invalid redirect request from peer " + req.getRemoteAddr());
                return;
            }
            // 得到目标的真正的责任节点
            final String targetServer = distroMapper.mapSrv(groupedServiceName);
            
            List<String> headerList = new ArrayList<>(16);
            Enumeration<String> headers = req.getHeaderNames();
            while (headers.hasMoreElements()) {
                String headerName = headers.nextElement();
                headerList.add(headerName);
                headerList.add(req.getHeader(headerName));
            }
            
            final String body = IoUtils.toString(req.getInputStream(), Charsets.UTF_8.name());
            final Map<String, String> paramsValue = HttpClient.translateParameterMap(req.getParameterMap());
            
            RestResult<String> result = HttpClient
                    .request("http://" + targetServer + req.getRequestURI(), headerList, paramsValue, body,
                            PROXY_CONNECT_TIMEOUT, PROXY_READ_TIMEOUT, Charsets.UTF_8.name(), req.getMethod());
            String data = result.ok() ? result.getData() : result.getMessage();
            try {
                WebUtils.response(resp, data, result.getCode());
            } catch (Exception ignore) {
                Loggers.SRV_LOG.warn("[DISTRO-FILTER] request failed: " + distroMapper.mapSrv(groupedServiceName)
                        + urlString);
            }
        } else {
            OverrideParameterRequestWrapper requestWrapper = OverrideParameterRequestWrapper.buildRequest(req);
            requestWrapper.addParameter(CommonParams.SERVICE_NAME, groupedServiceName);
            filterChain.doFilter(requestWrapper, resp);
        }
    } catch (AccessControlException e) {
        resp.sendError(HttpServletResponse.SC_FORBIDDEN, "access denied: " + ExceptionUtil.getAllExceptionMsg(e));
    } catch (NoSuchMethodException e) {
        resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED,
                "no such api:" + req.getMethod() + ":" + req.getRequestURI());
    } catch (Exception e) {
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                "Server failed," + ExceptionUtil.getAllExceptionMsg(e));
    }
    
}

那么可以看到，所有的标记了@CanDistro注解的请求，都会请求的时候判断：如果当前处理请求的集群节点，不是这个 service 的责任节点，那么这个过滤器就会转发到对应的责任节点上做处理。

那我们回到最开始的问题上：lastBeat 属性是如何同步的？

心跳检测在请求到达节点后就能自行检测是否责任节点上，如果不在则会直接发送给责任节点，而不是等待全体同步，所以可以理解为心跳时间是定向同步而非全体同步，心跳可能会发送到非责任节点，但是非责任节点一定会检测并且转发给责任节点，责任节点对于心跳的数据不会也没有必要去同步到别的节点上，因为别的节点完全不需要也不负责

整体结构分析

我们可以来看一下之前我们已经了解过的几个Event类对象，其实可以发现，都是继承自Event这个事件父类

同样的，我们再去看一下所有的Handler所在类，也可以发现，有些继承自SmartSubscriber，并且SmartSubscriber之上还有个顶级接口Subscriber，就是订阅者，在这里定义了顶级抽象方法

public abstract List<Class<? extends Event>> subscribeTypes();

该方法的主要作用就是返回该订阅者感兴趣的Event类型的List集合

除此之外在顶级接口中Subscriber中还有一个onEvent()方法，该方法就是当对应的Event来了之后进行处理回调的方法

在每个子类的构造方法上，还会调用一个registerSubscriber方法，该方法是NotifyCenter中的静态方法

NotifyCenter.registerSubscriber(this);
NotifyCenter.registerSubscriber(this, NamingEventPublisherFactory.getInstance());

根据如上的机构，其实我们完全可以自己基于Nacos提供的事件驱动架构，自己写一些事件和订阅者进行运行

如下，我们先写一个TestEvent测试事件类

import com.alibaba.nacos.common.notify.Event;
​
public class TestEvent extends Event {
}
​

然后写一个对应的订阅者TestSubscriber，实现subscribeTypes和onEvent方法，在构造方法中将该订阅者注册上去

​
import com.alibaba.nacos.common.notify.Event;
import com.alibaba.nacos.common.notify.NotifyCenter;
import com.alibaba.nacos.common.notify.listener.SmartSubscriber;
import org.springframework.stereotype.Component;
​
import java.util.LinkedList;
import java.util.List;
​
@Component
public class TestSubscriber extends SmartSubscriber {
​
    public TestSubscriber() {
        NotifyCenter.registerSubscriber(this);
    }
​
    @Override
    public List<Class<? extends Event>> subscribeTypes() {
        List<Class<? extends Event>> result = new LinkedList<>();
        result.add(TestEvent.class);
        return result;
    }
​
    @Override
    public void onEvent(Event event) {
        System.out.println("TestSubscriber onEvent");
    }
}
​

我们写一个测试类，来测试一下上面的代码，可以看到，调用完publishEvent之后，对应的订阅者的onEvent方法也成功被调用且打印了输出

源码分析

事件发布

上面我们了解一下事件驱动架构的大致结构，我们现在就可以开始分析，我们先从事件的发布这块入手

我们知道，发布事件用的是NotifyCenter.publishEvent这个方法，我们来看下这个方法的源码

NotifyCenter.publishEvent(new TestEvent());
​
​
public static boolean publishEvent(final Event event) {
    try {
        // 跟主线任务
        return publishEvent(event.getClass(), event);
    } catch (Throwable ex) {
        LOGGER.error("There was an exception to the message publishing : ", ex);
        return false;
    }
}
​
​
private static boolean publishEvent(final Class<? extends Event> eventType, final Event event) {
    if (ClassUtils.isAssignableFrom(SlowEvent.class, eventType)) {
        return INSTANCE.sharePublisher.publish(event);
    }
    
    // 根据Event的类型的到事件类型Topic
    final String topic = ClassUtils.getCanonicalName(eventType);
    // 根据发布事件类型获取 EventPublisher 对象，该对象中会包含订阅者信息
    // 订阅者怎么来的？ 从这里可以看到肯定是从一个Map中获取的，具体的在下文章节会讲到，publisherMap其实就是一个以Event全类名为key，EventPublisher对象(该对象成员属性subscribers会保存对应的订阅者类)为value的map，
    EventPublisher publisher = INSTANCE.publisherMap.get(topic);
    if (publisher != null) {
        // 跟主线任务
        return publisher.publish(event);
    }
    LOGGER.warn("There are no [{}] publishers for this event, please register", topic);
    return false;
}
​
​
@Override
public boolean publish(Event event) {
    checkIsStart();
    // 把事件放入到了一个 阻塞队列
    boolean success = this.queue.offer(event);
    // 如果没有放入成功则手动调用receiveEvent方法接收并通知Subscriber处理该事件
    if (!success) {
        LOGGER.warn("Unable to plug in due to interruption, synchronize sending time, event : {}", event);
        receiveEvent(event);
        return true;
    }
    return true;
}
​
​

可以看到，又是利用到了阻塞队列，自然我们就可以去找到队列中拿任务的逻辑

可以发现就在DefaultPublisher中，在这一段代码中，我们有看到 subscribers 一个 Set 集合，注意，这里并不是全部的订阅者，只是当前发布的事件对应的订阅者，并不会通知全部的订阅者哈

for (; ; ) {
    if (shutdown) {
        break;
    }
    // 从阻塞队列取数据
    final Event event = queue.take();
    // 处理事件
    receiveEvent(event);
    UPDATER.compareAndSet(this, lastEventSequence, Math.max(lastEventSequence, event.sequence()));
}
​
​
protected final ConcurrentHashSet<Subscriber> subscribers = new ConcurrentHashSet<>();
​
void receiveEvent(Event event) {
    final long currentEventSequence = event.sequence();
    
    if (!hasSubscriber()) {
        LOGGER.warn("[NotifyCenter] the {} is lost, because there is no subscriber.", event);
        return;
    }
    
    // 循环遍历通知发布事件对应的订阅者
    for (Subscriber subscriber : subscribers) {
        // Whether to ignore expiration events
        if (subscriber.ignoreExpireEvent() && lastEventSequence > currentEventSequence) {
            LOGGER.debug("[NotifyCenter] the {} is unacceptable to this subscriber, because had expire",
                    event.getClass());
            continue;
        }
        
        // Because unifying smartSubscriber and subscriber, so here need to think of compatibility.
        // Remove original judge part of codes.
        //通知
        notifySubscriber(subscriber, event);
    }
}
​

然后最后调用了 notifySubscriber(subscriber, event); 方法来通知订阅者，代码如下:

通过这段代码，我们能够知道，最后是使用线程异步的方式，来通知订阅者的。 事件发布流程我们就分析完了，核心关键还是利用了 阻塞队列 + 异步任务 来进行实现的，那么接下来我们一起来看看，订阅者注册的流程。

@Override
public void notifySubscriber(final Subscriber subscriber, final Event event) {
    
    LOGGER.debug("[NotifyCenter] the {} will received by {}", event, subscriber);
    
    // 创建一个任务，就是调用订阅者的 onEvent 方法
    final Runnable job = () -> subscriber.onEvent(event);
    final Executor executor = subscriber.executor();
    
    if (executor != null) {
        // 执行任务
        executor.execute(job);
    } else {
        try {
            job.run();
        } catch (Throwable e) {
            LOGGER.error("Event callback exception: ", e);
        }
    }
}
​

订阅者注册

看完了事件的发布，我们来看订阅者这边

每个订阅者在构造方法中都需要先将自己注册，所以我们先来看注册部分的代码，也就是NotifyCenter.registerSubscriber()

可以看到，首先这个就是调用subscribeTypes获取当前订阅者订阅的Event类型的List列表，然后遍历这个列表，调用INSTANCE.sharePublisher.addSubscriber封装保存或者调用addSubscriber这个方法(两种情况的底层都将内容保存到了subscribers这个Set中)

public TestSubscriber() {
    NotifyCenter.registerSubscriber(this);
}
​
public static void registerSubscriber(final Subscriber consumer) {
    registerSubscriber(consumer, DEFAULT_PUBLISHER_FACTORY);
}
​
public static void registerSubscriber(final Subscriber consumer, final EventPublisherFactory factory) {
    // If you want to listen to multiple events, you do it separately,
    // based on subclass's subscribeTypes method return list, it can register to publisher.
    if (consumer instanceof SmartSubscriber) {
        // 在这里会调用 subscribeTypes 方法，来获取我们需要监听的事件，然后进行遍历
        for (Class<? extends Event> subscribeType : ((SmartSubscriber) consumer).subscribeTypes()) {
            // For case, producer: defaultSharePublisher -> consumer: smartSubscriber.
            if (ClassUtils.isAssignableFrom(SlowEvent.class, subscribeType)) {
                INSTANCE.sharePublisher.addSubscriber(consumer, subscribeType);
            } else {
                // For case, producer: defaultPublisher -> consumer: subscriber.
                // 添加订阅者
                addSubscriber(consumer, subscribeType, factory);
            }
        }
        return;
    }
    
    // 这里代码省略
}
​
​

接下来我们继续看addSubscriber方法

private static void addSubscriber(final Subscriber consumer, Class<? extends Event> subscribeType,
        EventPublisherFactory factory) {
    
    final String topic = ClassUtils.getCanonicalName(subscribeType);
    synchronized (NotifyCenter.class) {
        // 这里很关键，会创建 EventPublisher 对象，一个事件会对应一个 EventPublisher 一个对象
        MapUtil.computeIfAbsent(INSTANCE.publisherMap, topic, factory, subscribeType, ringBufferSize);
    }
    // 获取事件对应的 EventPublisher 对象
    EventPublisher publisher = INSTANCE.publisherMap.get(topic);
    if (publisher instanceof ShardedEventPublisher) {
        ((ShardedEventPublisher) publisher).addSubscriber(consumer, subscribeType);
    } else {
        // 往 EventPublisher 对象添加订阅者信息
        publisher.addSubscriber(consumer);
    }
}
​

其中MapUtil.computeIfAbsent的逻辑如下，可以看到，在这里会利用传入的第三个参数，调用其apply方法，利用第四个和第五个参数创建出一个EventPublisher对象，这个对象内部会存储我们的订阅者信息，也就是 subscribers 属性

@NotThreadSafe
public static <K, C, V, T> V computeIfAbsent(Map<K, V> target, K key, BiFunction<C, T, V> mappingFunction, C param1,
        T param2) {
    
    Objects.requireNonNull(target, "target");
    Objects.requireNonNull(key, "key");
    Objects.requireNonNull(mappingFunction, "mappingFunction");
    Objects.requireNonNull(param1, "param1");
    Objects.requireNonNull(param2, "param2");
    
    V val = target.get(key);
    if (val == null) {
        V ret = mappingFunction.apply(param1, param2);
        target.put(key, ret);
        return ret;
    }
    return val;
}

在代码的最后，会调用 addSubscriber 方法往subscribers 属性中添加订阅者，完成注册。

总结

Nacos2.X中的事件驱动架构，整体基于Event(事件)-Subscriber(订阅者)-EventPublish(事件发布者)-NotifyCenter(事件中心)

订阅者通过注册中心进行注册，通过订阅者subscribeTypes()方法来获取其关注的Event事件类型的集合，对于非慢事件利用工厂创建对应的EventPublisher，并且将订阅者保存到EventPublisher 的 subscribers 集合，在publisherMap中保存事件-事件发布者的对应关系，EventPublisher 初始化时启动异步线程，监听阻塞队列，等待事件到来

通过事件中心发布事件的时候，根据事件的类型获得其全类名作为topic，利用topic从publisherMap中获取对应的EventPublisher，利用EventPublisher将任务写入到阻塞任务队列中

客户端的相关操作

怎么找到对应的代码块这边我们就不过多表述了，肯定还是主要围绕AbstractAutoServiceRegistration这个自动注册相关的类进行的操作

我们可以看到，在这个类下，有一个@PreDestroy注解标识的销毁方法，该方法内部就是调用了stop方法

stop方法的逻辑如下

可以看到，整体内容和Nacos1.4版本的逻辑操作相差不大，对客户端保存的注册实例遍历然后依次执行一些注销前置操作，注销后置操作等等

private List<RegistrationLifecycle<R>> registrationLifecycles = new ArrayList<>();
​
public void stop() {
    if (this.getRunning().compareAndSet(true, false) && isEnabled()) {
​
        this.registrationLifecycles.forEach(
                registrationLifecycle -> registrationLifecycle.postProcessBeforeStopRegister(getRegistration()));
        deregister();
        this.registrationLifecycles.forEach(
                registrationLifecycle -> registrationLifecycle.postProcessAfterStopRegister(getRegistration()));
        if (shouldRegisterManagement()) {
            this.registrationManagementLifecycles
                    .forEach(registrationManagementLifecycle -> registrationManagementLifecycle
                            .postProcessBeforeStopRegisterManagement(getManagementRegistration()));
            deregisterManagement();
            this.registrationManagementLifecycles
                    .forEach(registrationManagementLifecycle -> registrationManagementLifecycle
                            .postProcessAfterStopRegisterManagement(getManagementRegistration()));
        }
        this.serviceRegistry.close();
    }
}

在最后deregisterManagement()中最后会发送一个Rpc的请求发送给服务端

服务端处理Rpc请求

依旧是先找到对应的Handler，依旧是熟悉的switch-case对于不同类型的区分处理

对应的deregisterInstance()方法的代码如下

private InstanceResponse deregisterInstance(Service service, InstanceRequest request, RequestMeta meta) {
    clientOperationService.deregisterInstance(service, request.getInstance(), meta.getConnectionId());
    return new InstanceResponse(NamingRemoteConstants.DE_REGISTER_INSTANCE);
}
​
​
@Override
public void deregisterInstance(Service service, Instance instance, String clientId) {
    if (!ServiceManager.getInstance().containSingleton(service)) {
        Loggers.SRV_LOG.warn("remove instance from non-exist service: {}", service);
        return;
    }
    Service singleton = ServiceManager.getInstance().getSingleton(service);
    // 获取 client 对象
    Client client = clientManager.getClient(clientId);
    if (!clientIsLegal(client, clientId)) {
        return;
    }
    // 移除 instance 信息，在这里面会操作 publishers 那个Map，以及发 ClientChangedEvent 事件，来同步集群节点
    InstancePublishInfo removedInstance = client.removeServiceInstance(singleton);
    client.setLastUpdatedTime();
    if (null != removedInstance) {
        // 发布客户端注销事件
        NotifyCenter.publishEvent(new ClientOperationEvent.ClientDeregisterServiceEvent(singleton, clientId));
        NotifyCenter.publishEvent(
                new MetadataEvent.InstanceMetadataEvent(singleton, removedInstance.getMetadataId(), true));
    }
}
​

对于客户端注销事件的处理ClientDeregisterServiceEvent，同样的搜索对应的handler的相关逻辑

剩下的部分也就是对于内存注册表，订阅表等的一些remove操作以及同步集群了

总结-Nacos2.x注册中心部分

1. 对于临时实例，会采用RPC的方式进行通讯

2. 内存注册表的结构变化。由原本的嵌套式Map转化为了平铺式Map，结构更加i清晰

3. 客户端查询微服务实例列表的时候，调用的是客户端订阅的请求，在服务端会有订阅表，当我们被订阅的服务发生了变动，会来通知订阅者。

4. 可以明显感觉到，2.0中的事件发布操作明显更多了

注意，这里只是说服务端，即服务都安如何去检测客户端的健康状态，而不是客户端的心跳以及也不是集群中对于每个节点的健康检测。

我们可以来看到ConnectionManager，在这个类的内部有一个Map保存了所有的了所有的Connection连接对象，连接对象有个元数据的成员对象ConnectionMeta，他有一个成员属性为lastActiveTime(最后存活时间)

在ConnectionManager对象中，有个@PostConstruct注解标记的start方法，该方法会开启一个run任务，在该方法中，遍历上述的map并且用now和元数据中的lastActiveTime进行比较判断是否存活/过时,如果发现过时了，就会放入到outDatedConnections这个Set集合中

outDatedConnections在没有超出上限的时候，不会立马被清除，而是会统一在最后进行二次判断是否真正下线，如果没有下线，则会刷新activeTime并且加入到存活对象集合中，这个过程为了保证并发安全还是用了countDownLatch，这个被称之为探活机制

如果上述二次请求遍历完毕后依旧集合中依旧还有数据，则调用unregister()取消注册进行删除

unregister源码如下，首先会从connections这个管理了所有的连接的Map中remove，remove的时候会返回对应的Connection连接实例信息，根据实例信息中的Ip信息操作连接数，最后通知客户端注销连接

public synchronized void unregister(String connectionId) {
    // 移除客户端信息
    Connection remove = this.connections.remove(connectionId);
    if (remove != null) {
        String clientIp = remove.getMetaInfo().clientIp;
        AtomicInteger atomicInteger = connectionForClientIp.get(clientIp);
        if (atomicInteger != null) {
            int count = atomicInteger.decrementAndGet();
            if (count <= 0) {
                connectionForClientIp.remove(clientIp);
            }
        }
        remove.close();
        Loggers.REMOTE_DIGEST.info("[{}]Connection unregistered successfully. ", connectionId);
        // 通知客户端注销连接
        clientConnectionEventListenerRegistry.notifyClientDisConnected(remove);
    }
}

来看一下通知客户端注销连接的逻辑,可以看到最后是发布了一个ClientDisconnectEvent的事件，这个事件的处理我们在上一节的内容中分析过了，客户端会注销，同步到集群，当前节点关于该链接的数据，订阅者列表，注册表信息等等也都会被删除

// 1
clientConnectionEventListenerRegistry.notifyClientDisConnected(remove);
​
// 2
public void notifyClientDisConnected(final Connection connection) {
    
    for (ClientConnectionEventListener clientConnectionEventListener : clientConnectionEventListeners) {
        try {
        
            // 客户端注销，我们看这个实现类，ConnectionBasedClientManager
            clientConnectionEventListener.clientDisConnected(connection);
        } catch (Throwable throwable) {
            Loggers.REMOTE.info("[NotifyClientDisConnected] failed for listener {}",
                    clientConnectionEventListener.getName(), throwable);
        }
    }
}
​
// 3 ConnectionBasedClientManager 实现类
@Override
public void clientDisConnected(Connection connect) {
    clientDisconnected(connect.getMetaInfo().getConnectionId());
}
​
// 4
@Override
public boolean clientDisconnected(String clientId) {
    Loggers.SRV_LOG.info("Client connection {} disconnect, remove instances and subscribers", clientId);
    ConnectionBasedClient client = clients.remove(clientId);
    if (null == client) {
        return true;
    }
    client.release();
    // 最后发布客户端注销事件
    NotifyCenter.publishEvent(new ClientEvent.ClientDisconnectEvent(client));
    return true;
}
​

在看Nacos服务端处理服务注册的时候，我们最后是探索到了AbstractClient类下的addServiceInstance()方法

@Override
public boolean addServiceInstance(Service service, InstancePublishInfo instancePublishInfo) {
    // 把 instance 信息放入到 publishers 中
    if (null == publishers.put(service, instancePublishInfo)) {
        MetricsMonitor.incrementInstanceCount();
    }
    // 同步集群节点数据
    NotifyCenter.publishEvent(new ClientEvent.ClientChangedEvent(this));
    Loggers.SRV_LOG.info("Client change for service {}, {}", service, getClientId());
    return true;
}

在该方法的最后那个pushlishEvent()方法中，发布了一个ClientChangedEvent，从命名和业务逻辑来看，这一步肯定是发布客户端改变事件用于同步别的集群节点，所以我们这一篇的内容就是来了解一下这个

处理ClientChangedEvent

还是老样子，我们对于Event事件类型的处理，都是查找对应的处理Event的地方，利用Idea的全局搜索轻松实现

private void syncToAllServer(ClientEvent event) {
    Client client = event.getClient();
    // Only ephemeral data sync by Distro, persist client should sync by raft.
    // 临时实例是走 distro 协议，持久化实例走 raft 协议
    // isResponsibleClient 这里判断了只有该 client 的责任节点有权利进行集群数据同步
    if (null == client || !client.isEphemeral() || !clientManager.isResponsibleClient(client)) {
        return;
    }
    // 客户端注销集群节点同步事件
    if (event instanceof ClientEvent.ClientDisconnectEvent) {
        // 这里有常量默认值TYPE，其数值为 Nacos:Naming:v2:ClientData 
        DistroKey distroKey = new DistroKey(client.getClientId(), TYPE);
        distroProtocol.sync(distroKey, DataOperation.DELETE);
        
    // 客户端改变集群节点同步事件
    } else if (event instanceof ClientEvent.ClientChangedEvent) {
         // 这里有常量默认值TYPE，其数值为 Nacos:Naming:v2:ClientData 
        DistroKey distroKey = new DistroKey(client.getClientId(), TYPE);
        distroProtocol.sync(distroKey, DataOperation.CHANGE);
    }
}
​

通过上面这一段代码我们可以得知，不管是客户端注销了，还是客户端改变了，都会来同步集群节点，它们两个都是调用了 distroProtocol.sync 来进行同步，唯一的区别就是参数一个是 DELETE、一个是CHANGE。那么我们接下来一个看下同步的具体逻辑吧，代码如下：

public void sync(DistroKey distroKey, DataOperation action) {
    sync(distroKey, action, DistroConfig.getInstance().getSyncDelayMillis());
}
​
public void sync(DistroKey distroKey, DataOperation action, long delay) {
    // 遍历集群其他节点，除开自身节点
    for (Member each : memberManager.allMembersWithoutSelf()) {
        syncToTarget(distroKey, action, each.getAddress(), delay);
    }
}
​
public void syncToTarget(DistroKey distroKey, DataOperation action, String targetServer, long delay) {
    DistroKey distroKeyWithTarget = new DistroKey(distroKey.getResourceKey(), distroKey.getResourceType(),
            targetServer);
    // 创建了 DistroDelayTask 任务，并且把 targetServer(即集群节点的address) 包装成 DistroKey 当作参数传入了进去
    DistroDelayTask distroDelayTask = new DistroDelayTask(distroKeyWithTarget, action, delay);
   // 往执行引擎中添加任务
   distroTaskEngineHolder.getDelayTaskExecuteEngine().addTask(distroKeyWithTarget, distroDelayTask);
    if (Loggers.DISTRO.isDebugEnabled()) {
        Loggers.DISTRO.debug("[DISTRO-SCHEDULE] {} to {}", distroKey, targetServer);
    }
}
​

可以看到，这里最后利用distroTaskEngineHolder.getDelayTaskExecuteEngine()去执行distroDelayTask任务，这个地方的逻辑我们在上面就说过，实际上执行的就需要看对应的processor，而DistroTaskEngineHolder中的执行器就是DistroDelayTaskProcessor，我们看看对应的处理方法

@Override
public boolean process(NacosTask task) {
    if (!(task instanceof DistroDelayTask)) {
        return true;
    }
    DistroDelayTask distroDelayTask = (DistroDelayTask) task;
    DistroKey distroKey = distroDelayTask.getDistroKey();
    switch (distroDelayTask.getAction()) {
        case DELETE:
            // 删除任务
            DistroSyncDeleteTask syncDeleteTask = new DistroSyncDeleteTask(distroKey, distroComponentHolder);
            distroTaskEngineHolder.getExecuteWorkersManager().addTask(distroKey, syncDeleteTask);
            return true;
        case CHANGE:
        case ADD:
            // 改变、新增都会走这一段逻辑，封装为DistroSyncChangeTask
            DistroSyncChangeTask syncChangeTask = new DistroSyncChangeTask(distroKey, distroComponentHolder);
            distroTaskEngineHolder.getExecuteWorkersManager().addTask(distroKey, syncChangeTask);
            return true;
        default:
            return false;
    }
}

这一段逻辑，不管是删除，还是改变和新增的操作，都是创建了一个任务，添加到了 distro 任务执行引擎，这个引擎和之前看的延时任务执行实现有点不一样。

从逻辑上找下去，我们首先需要看到DistroExecuteTaskExecuteEngine中的addTask()的逻辑

可以发现，就是将task加入到TaskExecuteWorker类型的数组中，然后调用TaskExecuteWorker.process方法执行task

然后我们来看看process中的逻辑

可以看到这里面的主要逻辑就是将task放入到队列中。

在延时任务执行引擎实现原理是有一个 Map tasks 任务池，很多对应的任务处理器，然后定时从任务池获取任务，执行任务。而这个 distroTaskEngineHolder实现原理使用阻塞队列 + 异步任务的方式来实现的，所以最终这个任务肯定会被拿取并且执行

DistroSyncChangeTask

我们回到DistroDelayTaskProcessor中的process逻辑，可以知道无论是ADD还是CHANGE对应的都是封装为了DistroSyncChangeTask任务类型，我们查看其设计，可以发现继承自AbstractDistroExecuteTask，继续往上看其实就是实现了Runnable接口，所以我们来看看对应的run逻辑，因为我们是CHANGE类型，所以我们这里也肯定去看DistroSyncChangeTask下的doExecuteWithCallback的逻辑

@Override
protected void doExecuteWithCallback(DistroCallback callback) {
    
    String type = getDistroKey().getResourceType();
    // 获取请求数据
    DistroData distroData = getDistroData(type);
    if (null == distroData) {
        Loggers.DISTRO.warn("[DISTRO] {} with null data to sync, skip", toString());
        return;
    }
    // syncData 同步集群节点
    getDistroComponentHolder().findTransportAgent(type)
            .syncData(distroData, getDistroKey().getTargetServer(), callback);
}
​

此时我们应该去看syncData的逻辑，该方法也是接口中的方法，需要在对应的实现类中查找对应的实现，这里有两个实现类

怎么知道是哪个呢？我们可以回头来看一下，调用syncData的是findTransportAgent(type)的返回指，这个返回值其实在之前的run的逻辑中也有被调用，其返回类型是DistroTransportAgent，而DistroClientTransportAgent是DistroTransportAgent的子类

看到这里我们知道了，接下来要看的内容是DistroClientTransportAgent的syncData()的逻辑

@Override
public void syncData(DistroData data, String targetServer, DistroCallback callback) {
    if (isNoExistTarget(targetServer)) {
        callback.onSuccess();
        return;
    }
    // 创建请求对象
    DistroDataRequest request = new DistroDataRequest(data, data.getType());
    
    // 找到集群节点
    Member member = memberManager.find(targetServer);
    try {
        // 发送 rpc 异步请求
        clusterRpcClientProxy.asyncRequest(member, request, new DistroRpcCallbackWrapper(callback, member));
    } catch (NacosException nacosException) {
        callback.onFailed(nacosException);
    }
}
​

所以看到这里我们差不多知道了整个某个节点上的服务实例修改后，如果通知到其余节点的过程，捋一捋，一开始我们是从 ClientChangedEvent 事件开始分析，我们找到了处理这个事件的逻辑，调用了 sync 方法，在这个方法中会遍历其他集群节点进行数据同步，同步的逻辑如下。

1. 先是创建了 DistroDelayTask 延迟任务，放入到了延迟任务执行引擎，由 DistroDelayTaskProcessor 处理器来处理。

2. 在 DistroDelayTaskProcessor 处理器，处理的逻辑中又创建了 DistroSyncChangeTask 线程任务，执行引擎是先调用了 AbstractDistroExecuteTask 父类中的 run 方法，在 run 方法中又调用了子类的doExecuteWithCallback 方法。

3. doExecuteWithCallback 方法中会去获取最新的微服务实例列表，通过 rpc 发起异步请求进行数据同步。

集群其余节点处理DistroDataRequest

上述内容中，我们已经清楚了集群节点发其同步请求，那么现在我们来看看别的集群节点如何处理这个同步请求的。我们知道，对应的请求类型是DistroDataRequest,老规矩，利用IDEA全局搜索找到对应的Handler处理器

可以发现，无论是ADD 还是 CHANGE 还是 DELETE 的逻辑，最终都是执行的handlerSyncData(...)的逻辑，跟下去整个逻辑链路大概是handleSyncData()->onReceive()->processData->handlerClientSyncData()

private DistroDataResponse handleSyncData(DistroData distroData) {
    // 创建response对象
    DistroDataResponse result = new DistroDataResponse();
    // onReceive方法处理请求数据distroData
    if (!distroProtocol.onReceive(distroData)) {
        result.setErrorCode(ResponseCode.FAIL.getCode());
        result.setMessage("[DISTRO-FAILED] distro data handle failed");
    }
    return result;
}
​
​
/**
 * Receive synced distro data, find processor to process.
 *
 * @param distroData Received data
 * @return true if handle receive data successfully, otherwise false
 */
public boolean onReceive(DistroData distroData) {
    Loggers.DISTRO.info("[DISTRO] Receive distro data type: {}, key: {}", distroData.getType(),
            distroData.getDistroKey());
    String resourceType = distroData.getDistroKey().getResourceType();
    // 利用type找到对应的processor处理器
    DistroDataProcessor dataProcessor = distroComponentHolder.findDataProcessor(resourceType);
    if (null == dataProcessor) {
        Loggers.DISTRO.warn("[DISTRO] Can't find data process for received data {}", resourceType);
        return false;
    }
    // 调用处理器的processData方法处理请求数据
    return dataProcessor.processData(distroData);
}
​

processData也是接口中的方法，一样的有两个实现类，这里我们需要根据resourceType来进行确认，这个resourceType的值大家可以回过头看这一章的最开始那个地方，在syncToAllServer中，也就是我们Event创建和传入的地方，我们当前这个resourceType和DistroKey其实一开始就绑定了，那么其实这个resourceType就是我们上面提到的常量TYPE

然后这个地方通过findDataProcessor查找DistroComponentHolder中的Map成员dataProcessorMap，以TYPE为key的对应的value

private final Map<String, DistroDataProcessor> dataProcessorMap = new HashMap<>();
​
public DistroDataProcessor findDataProcessor(String processType) {
    return dataProcessorMap.get(processType);
}