按随机顺序进行遍历的python代码

以下是一个简单的示例代码，可以随机遍历一个列表中的元素：

import random

my_list = [1, 2, 3, 4, 5]

random.shuffle(my_list)

for item in my_list:
    print(item)

该代码首先导入了 Python 的随机模块 `random`，然后定义了一个列表 `my_list`。接着使用 `shuffle()` 方法将列表中的元素随机打乱顺序。最后使用 `for` 循环遍历列表中的元素，并输出每个元素的值。由于 `my_list` 已经随机打乱了顺序，因此循环输出的顺序也是随机的。

相关问题

生成十个随机目标点，用麻雀搜索算法求解遍历每个目标点的最短路径，Python代码

以下是生成随机目标点并使用麻雀搜索算法求解遍历每个目标点的最短路径的 Python 代码：

import random
import math

# 生成随机目标点
n = 10  # 目标点数量
points = []
for i in range(n):
    x = random.uniform(0, 100)
    y = random.uniform(0, 100)
    points.append((x, y))

# 计算两点之间的距离
def distance(point1, point2):
    return math.sqrt((point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2)

# 麻雀搜索算法
def sparrow_search(points):
    n = len(points)
    visited = [False] * n
    visited[0] = True
    path = [0]
    for i in range(n - 1):
        min_distance = float('inf')
        next_point = None
        for j in range(n):
            if not visited[j]:
                d = distance(points[path[-1]], points[j])
                if d < min_distance:
                    min_distance = d
                    next_point = j
        visited[next_point] = True
        path.append(next_point)
    return path

# 输出结果
path = sparrow_search(points)
print('目标点顺序：', [p+1 for p in path])
print('最短距离：', sum(distance(points[path[i]], points[path[i+1]]) for i in range(n-1)))

输出结果类似于：

目标点顺序： [1, 6, 7, 2, 3, 4, 8, 5, 10, 9]
最短距离： 455.2809094521412

利用麻雀搜索算法求解遍历十个目标点的最短路径 python代码

以下是利用麻雀搜索算法求解遍历十个目标点的最短路径的Python代码：

import random
import math

# 计算两点之间的距离
def distance(city1, city2):
    x1, y1 = city1
    x2, y2 = city2
    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

# 计算路径长度
def path_length(path, cities):
    total = 0
    for i in range(len(path) - 1):
        total += distance(cities[path[i]], cities[path[i + 1]])
    return total

# 随机生成一条路径
def generate_path(num_cities):
    path = list(range(num_cities))
    random.shuffle(path)
    return path

# 随机生成一只麻雀
def generate_sparrow(num_cities):
    return generate_path(num_cities)

# 取得一只麻雀的邻居
def get_neighbor(sparrow):
    i = random.randint(0, len(sparrow) - 1)
    j = random.randint(0, len(sparrow) - 1)
    neighbor = sparrow.copy()
    neighbor[i], neighbor[j] = neighbor[j], neighbor[i]
    return neighbor

# 计算一只麻雀的适应度
def fitness(sparrow, cities):
    return 1 / path_length(sparrow, cities)

# 麻雀搜索算法
def sparrow_search(cities, num_sparrows, max_iterations):
    # 随机生成一些麻雀
    sparrows = [generate_sparrow(len(cities)) for i in range(num_sparrows)]
    # 记录最优解
    best_sparrow = sparrows[0]
    # 迭代
    for iteration in range(max_iterations):
        # 对每只麻雀进行搜索
        for sparrow in sparrows:
            # 取得当前麻雀的邻居
            neighbor = get_neighbor(sparrow)
            # 计算适应度
            sparrow_fitness = fitness(sparrow, cities)
            neighbor_fitness = fitness(neighbor, cities)
            # 如果邻居更优，则更新当前麻雀
            if neighbor_fitness > sparrow_fitness:
                sparrow = neighbor
                sparrow_fitness = neighbor_fitness
            # 如果当前麻雀更优，则更新最优解
            if sparrow_fitness > fitness(best_sparrow, cities):
                best_sparrow = sparrow
        # 输出当前迭代的最优解
        print("Iteration {}: {}".format(iteration, path_length(best_sparrow, cities)))
    # 返回最优解
    return best_sparrow

# 测试
num_cities = 10
cities = [(random.uniform(0, 1), random.uniform(0, 1)) for i in range(num_cities)]
# 随机生成目标点
targets = random.sample(range(num_cities), 10)
# 将目标点按顺序排列
targets.sort()
# 将目标点插入到城市列表中
for target in targets:
    cities[target] = (random.uniform(0, 1), random.uniform(0, 1))
best_path = sparrow_search(cities, num_sparrows=50, max_iterations=1000)
print("Best path: {}, length: {}".format(best_path, path_length(best_path, cities)))

在上述代码中，首先定义了一些辅助函数，如计算两点之间的距离、计算路径长度、随机生成一条路径等。然后定义了麻雀搜索算法的几个关键步骤，包括随机生成一些麻雀、对每只麻雀进行搜索、取得当前麻雀的邻居、计算适应度等。接着在测试中随机生成了一些城市，并随机选取了十个目标点，将这些目标点插入到城市列表中。最后调用麻雀搜索算法求解遍历这些目标点的最短路径，并输出最优解的路径和长度。