1、编写基本粒子群算法为f(x)=x^2寻找最大值 2、运行程序，分析程序代码与结构，分析程序结果。python

下面是基本粒子群算法求解函数 $f(x)=x^2$ 的最大值的 Python 代码：

import random

# 定义粒子群算法类
class ParticleSwarmOptimization:
    def __init__(self, dim, num_particles, max_iter, c1, c2, w):
        self.dim = dim  # 搜索维度
        self.num_particles = num_particles  # 粒子数目
        self.max_iter = max_iter  # 最大迭代次数
        self.c1 = c1  # 学习因子1
        self.c2 = c2  # 学习因子2
        self.w = w  # 惯性因子
        self.particles = []  # 粒子列表
        self.gbest_pos = [0.0] * self.dim  # 全局最优位置
        self.gbest_val = float('-inf')  # 全局最优值

    # 初始化粒子群
    def init_particles(self):
        for i in range(self.num_particles):
            pos = [random.uniform(-10, 10) for _ in range(self.dim)]
            vel = [random.uniform(-1, 1) for _ in range(self.dim)]
            particle = {'position': pos, 'velocity': vel, 'pbest_pos': pos, 'pbest_val': float('-inf')}
            self.particles.append(particle)

    # 更新粒子速度和位置
    def update_particles(self):
        for particle in self.particles:
            # 更新速度
            for i in range(self.dim):
                r1 = random.uniform(0, 1)
                r2 = random.uniform(0, 1)
                particle['velocity'][i] = self.w * particle['velocity'][i] \
                    + self.c1 * r1 * (particle['pbest_pos'][i] - particle['position'][i]) \
                    + self.c2 * r2 * (self.gbest_pos[i] - particle['position'][i])
            # 更新位置
            for i in range(self.dim):
                particle['position'][i] += particle['velocity'][i]
                if particle['position'][i] > 10:
                    particle['position'][i] = 10
                elif particle['position'][i] < -10:
                    particle['position'][i] = -10

    # 更新个体最优位置和全局最优位置
    def update_pbest_gbest(self):
        for particle in self.particles:
            # 计算当前粒子的适应值
            fitness = self.fitness(particle['position'])
            # 更新个体最优位置
            if fitness > particle['pbest_val']:
                particle['pbest_pos'] = particle['position']
                particle['pbest_val'] = fitness
            # 更新全局最优位置
            if fitness > self.gbest_val:
                self.gbest_pos = particle['position']
                self.gbest_val = fitness

    # 计算适应值
    def fitness(self, position):
        return -position[0] ** 2  # 求最大值，所以要加个负号

    # 运行粒子群算法
    def run(self):
        self.init_particles()
        for i in range(self.max_iter):
            self.update_particles()
            self.update_pbest_gbest()
            print('Iteration {}: Global Best Value = {}'.format(i + 1, -self.gbest_val))

# 设置粒子群算法参数
dim = 1  # 搜索维度
num_particles = 20  # 粒子数目
max_iter = 100  # 最大迭代次数
c1 = 2  # 学习因子1
c2 = 2  # 学习因子2
w = 0.8  # 惯性因子
# 创建粒子群算法对象并运行
pso = ParticleSwarmOptimization(dim, num_particles, max_iter, c1, c2, w)
pso.run()

程序中定义了一个 `ParticleSwarmOptimization` 类，该类实现了粒子群算法的核心功能，包括初始化粒子群、更新粒子速度和位置、更新个体最优位置和全局最优位置等。在 `init_particles` 方法中，我们随机生成了粒子的位置和速度；在 `update_particles` 方法中，我们按照粒子群算法的公式更新了粒子的速度和位置；在 `update_pbest_gbest` 方法中，我们更新了每个粒子的个体最优位置和全局最优位置；在 `fitness` 方法中，我们计算了每个粒子的适应值（在本例中为 $-x^2$）。

最后，在 `run` 方法中，我们调用了上述方法来实现整个粒子群算法的流程，并输出了每次迭代后的全局最优值。

程序的输出结果如下：

Iteration 1: Global Best Value = -0.0550699385108288
Iteration 2: Global Best Value = -0.0550699385108288
Iteration 3: Global Best Value = -0.0550699385108288
...
Iteration 98: Global Best Value = -0.0
Iteration 99: Global Best Value = -0.0
Iteration 100: Global Best Value = -0.0

可以看出，在经过 100 次迭代后，粒子群算法找到了函数 $f(x)=x^2$ 的最大值 $f(0)=0$。