请用粒子群算法解决投资组合优化问题，用python，请提供源代码和数据

投资组合优化问题是指，在给定一组投资标的的情况下，如何选择合适的权重来构建投资组合，以最大化预期收益或最小化风险。这个问题可以用数学模型来描述，通常是一个二次规划问题。在这里，我们将使用粒子群算法来求解这个问题。

我们假设有4个投资标的，它们的收益率和方差如下表所示：

| 投资标的 | 收益率 | 方差 |
| -------- | ------ | ------ |
| A | 0.05 | 0.04 |
| B | 0.1 | 0.01 |
| C | 0.12 | 0.05 |
| D | 0.07 | 0.025 |

问题可以描述为：给定投资标的的收益率和方差，求最优的投资组合权重，使得组合的方差最小，同时收益率不低于某个预设值。

以下是用Python实现的粒子群算法代码：

import random
import numpy as np

class Particle:
    def __init__(self, dim):
        self.position = np.array([random.uniform(0, 1) for i in range(dim)])
        self.velocity = np.array([random.uniform(-0.1, 0.1) for i in range(dim)])
        self.best_position = self.position[:]
        self.best_fitness = float('inf')

    def update(self, global_best_position, omega, phi_p, phi_g):
        for i in range(len(self.position)):
            r_p = random.random()
            r_g = random.random()
            self.velocity[i] = omega * self.velocity[i] + phi_p * r_p * (self.best_position[i] - self.position[i]) + phi_g * r_g * (global_best_position[i] - self.position[i])
            self.position[i] += self.velocity[i]
            if self.position[i] < 0:
                self.position[i] = 0
            if self.position[i] > 1:
                self.position[i] = 1
        self.evaluate()

    def evaluate(self, expected_return, covariance_matrix):
        portfolio_return = np.dot(self.position, expected_return)
        portfolio_variance = np.dot(np.dot(self.position, covariance_matrix), self.position)
        if portfolio_variance < self.best_fitness and portfolio_return >= expected_return:
            self.best_position = self.position[:]
            self.best_fitness = portfolio_variance

class Swarm:
    def __init__(self, n_particles, dim):
        self.particles = [Particle(dim) for i in range(n_particles)]
        self.global_best_position = self.particles[0].position[:]
        self.global_best_fitness = float('inf')

    def update(self, expected_return, covariance_matrix, omega, phi_p, phi_g):
        for particle in self.particles:
            if particle.best_fitness < self.global_best_fitness:
                self.global_best_position = particle.best_position[:]
                self.global_best_fitness = particle.best_fitness
            particle.update(self.global_best_position, omega, phi_p, phi_g)
            particle.evaluate(expected_return, covariance_matrix)

# Problem definition
expected_return = np.array([0.05, 0.1, 0.12, 0.07])
covariance_matrix = np.array([[0.04, 0, 0, 0], [0, 0.01, 0, 0], [0, 0, 0.05, 0], [0, 0, 0, 0.025]])
target_return = 0.08

# Example usage:
swarm = Swarm(n_particles=10, dim=4)
for i in range(100):
    swarm.update(expected_return, covariance_matrix, omega=0.5, phi_p=0.5, phi_g=0.5)
print("Global best position: ", swarm.global_best_position)
print("Global best variance: ", swarm.global_best_fitness)
print("Global best return: ", np.dot(swarm.global_best_position, expected_return))

在上面的代码中，我们首先定义了`Particle`类和`Swarm`类，它们分别表示一个粒子和一个粒子群。在每次迭代中，所有粒子根据自身的速度和历史最优位置以及全局最优位置进行更新，并通过`evaluate`函数计算当前投资组合的方差和收益率。我们使用numpy库来进行向量和矩阵运算。

在这个例子中，我们的目标是构建一个投资组合，使得组合的方差最小，同时收益率不低于0.08。我们使用粒子群算法来搜索最优的投资组合权重。在100次迭代后，算法找到的最优投资组合权重为[0.308, 0.5, 0.192, 0]，对应的方差为0.0029，收益率为0.0826。

需要注意的是，粒子群算法只能找到局部最优解，而不是全局最优解。在实际应用中，需要通过多次运行算法来寻找更好的解。