Python 如何使用fig.canvas.draw（）制作动画？

我正在做我的计算生物学作业，它要求我们通过一个群集的例子来说明群集智能。当每个代理1）被其他代理吸引，2）太靠近其他代理时被排斥，以及3）与其他代理执行速度对齐时，可以实现群的一致涌现行为（群集）。本作业的目的是在2D中检查这种行为；该群由N个agent组成；每个代理将由其位置（p）和速度（v）定义

我写了下面的代码，但我无法得到一个互动的情节。我猜我没有正确使用figure.canvas.draw（）。是这样吗

我需要的是一个情节动画，它显示了集群中所有Boid的移动。这是我的密码：

import numpy as np
import math
import matplotlib.pyplot as plt

class flock():
    def flocking_python(self):
        N = 400 #No. of Boids
        frames = 100 #No. of frames
        limit = 100 #Axis Limits
        L  = limit*2
        P = 10 #Spread of initial position (gaussian)
        V = 10 #Spread of initial velocity (gaussian)
        delta = 1 #Time Step
        c1 = 0.00001 #Attraction Scaling factor
        c2 = 0.01 #Repulsion scaling factor
        c3 = 1 #Heading scaling factor
        c4 = 0.01 #Randomness scaling factor
        vlimit = 1 #Maximum velocity

        #Initialize
        p = P*np.random.randn(2,N)
        v = V*np.random.randn(2,N)

        #Initializing plot
        plt.ion()
        fig = plt.figure()
        ax = fig.add_subplot(111)


        for i in range(0, frames):
            v1 = np.zeros((2,N))
            v2 = np.zeros((2,N))
            sum_1 = ((np.sum(v[0,:]))/N)*c3
            sum_2 = ((np.sum(v[1,:]))/N)*c3
            v3 = np.array([[sum_1], [sum_2]]) #Calculate Average Velocity

            if (np.linalg.norm(v3) > vlimit): #limit maximum velocity
                v3 = v3*vlimit/np.linalg.norm(v3)

            for n in range(0, N):
                for m in range(0, N):
                    if m!=n:
                        r = p[:,m]-p[:,n] #Vector from one agent to the next

                        if r[0] > L/2:
                            r[0] = r[0]-L
                        elif r[0] < -L/2:
                            r[0] = r[0]+L

                        if r[1] > L/2:
                            r[1] = r[1]-L
                        elif r[1] < -L/2:
                            r[1] = r[1]+L

                        rmag = math.sqrt(r[0]**2+r[1]**2) #Distance between agents
                        v1[:,n] = v1[:,n] + c1*r #Attraction
                        v2[:,n] = v2[:,n] - c2*r /(rmag**2) #Repulsion [non-linear scaling]

                v4 = np.random.randn(2,1)*c4 #Add randomness to motion
                v[:,n] = v1[:,n]+v2[:,n]+v4[:,0]+v3[:,0] #update velocity


            p = p+v*delta #update position

            #Periodic boundary
            tmp_p = p

            tmp_p[0, p[0,:]>L/2] = tmp_p[0,p[0,:]> (L/2)] - L
            tmp_p[1, p[1,:] > L/2] = tmp_p[1, p[1,:] > (L/2)] - L
            tmp_p[0, p[0,:] < -L/2]  = tmp_p[0, p[0,:] < (-L/2)] + L
            tmp_p[1, p[1,:] < -L/2]  = tmp_p[1, p[1,:] < (-L/2)] + L

            p = tmp_p
            # Can Also be written as:
            # p[p > limit] -= limit * 2
            # p[p < -limit] += limit * 2

            line1, = ax.plot(p[0, 0], p[1, 0])

            #update plot
            ax.clear()
            ax.quiver(p[0,:], p[1,:], v[0,:], v[1,:]) # For drawing velocity arrows
            plt.xlim(-limit, limit)
            plt.ylim(-limit, limit)
            line1.set_data(p[0,:], p[1,:])

            fig.canvas.draw()

flock_py = flock()
flock_py.flocking_python()

将numpy导入为np
输入数学
将matplotlib.pyplot作为plt导入
类flock（）：
def植绒_python（自身）：
N=400#锅炉数量
框架=100个框架
极限=100#轴极限
L=极限*2
P=10#初始位置的扩展（高斯）
V=10#初始速度扩散（高斯）
delta=1#时间步长
c1=0.00001#吸引力比例因子
c2=0.01#排斥比例因子
c3=1#航向比例因子
c4=0.01#随机性比例因子
vlimit=1#最大速度
#初始化
p=p*np.random.randn（2，N）
v=v*np.random.randn（2，N）
#初始化绘图
plt.ion（）
图=plt.图（）
ax=图添加_子批次（111）
对于范围内的i（0，帧）：
v1=np.零（（2，N））
v2=np.零（（2，N））
sum_1=（（np.sum（v[0，：]）/N）*c3
sum_2=（（np.sum（v[1，：]）/N）*c3
v3=np.数组（[[sum_1]，[sum_2]]）#计算平均速度
如果（np.linalg.norm（v3）>vlimit）：#极限最大速度
v3=v3*vlimit/np.linalg.norm（v3）
对于范围（0，n）中的n：
对于范围（0，N）内的m：
如果我=n:
r=p[：，m]-p[：，n]#从一个代理到下一个代理的向量
如果r[0]>L/2：
r[0]=r[0]-L
elif r[0]<-L/2：
r[0]=r[0]+L
如果r[1]>L/2：
r[1]=r[1]-L
elif r[1]<-L/2：
r[1]=r[1]+L
rmag=math.sqrt（r[0]**2+r[1]**2）#代理之间的距离
v1[：，n]=v1[：，n]+c1*r#吸引力
v2[：，n]=v2[：，n]-c2*r/（rmag**2）#排斥[非线性标度]
v4=np.random.randn（2,1）*c4#将随机性添加到运动中
v[：，n]=v1[：，n]+v2[：，n]+v4[：，0]+v3[：，0]#更新速度
p=p+v*delta#更新位置
#周期边界
tmp_p=p
tmp_p[0，p[0，：]>L/2]=tmp_p[0，p[0，：]>L/2]-L
tmp_p[1，p[1，：]>L/2]=tmp_p[1，p[1，：]>L/2]-L
tmp_p[0，p[0，：]<-L/2]=tmp_p[0，p[0，：]<-L/2]+L
tmp_p[1，p[1，：]<-L/2]=tmp_p[1，p[1，：]<-L/2]+L
p=tmp\u p
#也可以写成：
#p[p>极限]-=极限*2
#p[p<-极限]+=极限*2
第1行，=ax.plot（p[0,0]，p[1,0]）
#更新图
ax.clear（）
用于绘制速度箭头的最大震颤（p[0，：]，p[1，：]，v[0，：]，v[1，：]）
plt.xlim（-limit，limit）
plt.ylim（-limit，limit）
第1行。设置_数据（p[0，：]，p[1，：]）
图canvas.draw（）
flock_py=flock（）
植绒py.植绒python（）

如果需要动画matplotlib图，请查看此图。