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

以下是基本粒子群算法的python代码实现：

import random

# 目标函数，即需要求最大值的函数
def f(x):
    return x**2 - pow(2.71828, x)

class Particle:
    def __init__(self, dim, x_min, x_max):
        self.position = [random.uniform(x_min, x_max) for i in range(dim)]
        self.velocity = [random.uniform(x_min, x_max) for i in range(dim)]
        self.best_position = self.position
        self.best_fitness = f(self.position)
        
    def update_position(self):
        for i in range(len(self.position)):
            self.position[i] += self.velocity[i]
            
    def update_velocity(self, global_best_position, omega, phi_p, phi_g):
        for i in range(len(self.velocity)):
            rp, rg = random.uniform(0, 1), random.uniform(0, 1)
            cognitive = phi_p * rp * (self.best_position[i] - self.position[i])
            social = phi_g * rg * (global_best_position[i] - self.position[i])
            self.velocity[i] = omega * self.velocity[i] + cognitive + social
            
    def evaluate_fitness(self):
        fitness = f(self.position)
        if fitness > self.best_fitness:
            self.best_fitness = fitness
            self.best_position = self.position

class PSO:
    def __init__(self, num_particles, dim, x_min, x_max, num_iterations, omega, phi_p, phi_g):
        self.num_particles = num_particles
        self.dim = dim
        self.x_min = x_min
        self.x_max = x_max
        self.num_iterations = num_iterations
        self.omega = omega
        self.phi_p = phi_p
        self.phi_g = phi_g
        self.particles = [Particle(dim, x_min, x_max) for i in range(num_particles)]
        self.global_best_position = self.particles[0].position
        self.global_best_fitness = f(self.global_best_position)
        
    def optimize(self):
        for i in range(self.num_iterations):
            for particle in self.particles:
                particle.update_velocity(self.global_best_position, self.omega, self.phi_p, self.phi_g)
                particle.update_position()
                particle.evaluate_fitness()
                if particle.best_fitness > self.global_best_fitness:
                    self.global_best_fitness = particle.best_fitness
                    self.global_best_position = particle.best_position
            print("Iteration:", i+1, "Best Position:", self.global_best_position, "Best Fitness:", self.global_best_fitness)

if __name__ == '__main__':
    pso = PSO(num_particles=20, dim=1, x_min=-5, x_max=5, num_iterations=100, omega=0.5, phi_p=0.5, phi_g=0.9)
    pso.optimize()

程序代码和结构分析：

该程序实现了一个基本的粒子群算法，并用于求解目标函数f(x)=x^2-e^x的最大值。程序中包含两个类：Particle和PSO。

Particle类表示一个粒子，它有一个当前位置、一个当前速度、一个最佳位置和一个最佳适应度。在初始化时，位置和速度都被初始化为随机数，最佳位置和最佳适应度都被初始化为当前位置和适应度。

Particle类有三个方法。update_position方法用于更新粒子的位置，即根据当前速度更新当前位置。update_velocity方法用于更新粒子的速度，即根据全局最佳位置和个体最佳位置计算出新的速度。evaluate_fitness方法用于评估粒子的适应度，即计算当前位置的函数值，并将当前位置和适应度与最佳位置和最佳适应度进行比较，如果当前位置的适应度更好，则更新最佳位置和最佳适应度。

PSO类表示整个粒子群算法，它有一个粒子数、一个维度、一个位置范围、一个迭代次数、一个惯性权重、一个个体学习因子和一个全局学习因子。在初始化时，所有粒子被初始化为随机位置和速度，全局最佳位置和最佳适应度被初始化为第一个粒子的位置和适应度。

PSO类有一个optimize方法，用于运行整个粒子群算法。在每次迭代中，PSO类遍历所有粒子，更新它们的速度、位置和最佳值，并将全局最佳位置和最佳适应度与每个粒子的最佳位置和最佳适应度进行比较。在迭代结束时，程序输出全局最佳位置和最佳适应度。

程序结果分析：

在运行程序时，我们可以看到每次迭代的全局最佳位置和最佳适应度。经过100次迭代，程序输出的全局最佳位置为[1.4602838992240491]，最佳适应度为0.9147018260880058。这个结果表明，当x=1.4602838992240491时，目标函数f(x)=x^2-e^x取得了最大值0.9147018260880058。