利用Python绘制随机游走图的详细过程

pip install networkx

import networkx as nx
import random
import matplotlib.pyplot as plt

def random_walk(graph, start_node, steps):
    current_node = start_node
    visited_nodes = [current_node]

    for _ in range(steps):
        neighbors = list(graph.neighbors(current_node))
        if not neighbors:
            break  # No neighbors, stop the walk
        current_node = random.choice(neighbors)
        visited_nodes.append(current_node)

    return visited_nodes

# 创建一个简单的图
G = nx.Graph()
G.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 1), (2, 4)])

# 随机游走
start_node = 1
steps = 10
walk_result = random_walk(G, start_node, steps)

# 打印结果
print("Random Walk Result:", walk_result)

# 可视化图和随机游走路径
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, font_weight='bold', node_color='lightblue')
plt.plot(walk_result, marker='o', color='red', label='Random Walk Path')
plt.legend()
plt.show()

import matplotlib.pyplot as plt
import random

def random_walk(steps):
    x = [0]  # 节点的 x 坐标
    y = [0]  # 节点的 y 坐标

    for _ in range(steps):
        # 随机决定下一步的方向（上、下、左、右）
        direction = random.choice(['up', 'down', 'left', 'right'])

        # 根据方向更新坐标
        if direction == 'up':
            y.append(y[-1] + 1)
            x.append(x[-1])
        elif direction == 'down':
            y.append(y[-1] - 1)
            x.append(x[-1])
        elif direction == 'left':
            x.append(x[-1] - 1)
            y.append(y[-1])
        elif direction == 'right':
            x.append(x[-1] + 1)
            y.append(y[-1])

    return x, y

# 设置步数
steps = 100

# 随机游走路径
x, y = random_walk(steps)

# 绘制随机游走图
plt.plot(x, y, marker='o', linestyle='-', color='b')
plt.title('Random Walk')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

from random import choice

class RandomWalk():
    '''一个生成随机漫步数据的类'''

    def __init__(self,num_points):
        '''初始化随机漫步的属性'''
        self.num_points = num_points

        # 定义出坐标系列表，所有随机漫步都始于（0，0）
        self.x_values = [0]
        self.y_values = [0]

    def fill_walks(self):
        '''计算随机漫步包含的所有点'''

        # 不断漫步，直到列表到达指定的长度
        while len(self.x_values) < self.num_points:
            # 决定 x 前进方向（可以更换成2，-2，甚至更大）
            x_direction = choice([1,-1])
            # 决定 x 前进的距离：1 2 3 4 5 6 7
            x_distance = choice([0,1,2,3,4,5,6,7])
            # 最终 x 的步长是：方向 * 距离
            x_step = x_direction * x_distance

            # 决定 y 前进方向以及沿这个方向前进的距离
            y_direction = choice([1,-1])
            y_distance = choice([0,1,2,3,4,5,6,7])
            y_step = y_direction * y_distance

            # 拒绝原地踏步
            if x_step == 0 and y_step == 0:
                continue

            # 计算下一个点的 x值 和 y值
            next_x = self.x_values[-1] + x_step
            next_y = self.y_values[-1] + y_step

            # 将计算好的下一个 x 和 y 加载到 坐标系列表中
            self.x_values.append(next_x)
            self.y_values.append(next_y)
            pass

import matplotlib.pyplot as plt
from random_walk import RandomWalk

# 只要程序处于活动状态，就不断地模拟随机漫步的过程
while True:
    # 创建一个 RandomWalk 实例，并将其包含的点都绘制出来
    # 这里的 30000 是可以随机更改的，建议不用太多，也不能太少
    rw = RandomWalk(30000)
    rw.fill_walks()

    point_numbers = list(range(rw.num_points))
    # 突出起点, 用绿色标注出来 ，尺寸大小为： 100
    plt.scatter(0,0,c = 'green',edgecolors = 'none',s = 100)
    # 绘制漫步过程，颜色越来越深，体现出前后顺序
    plt.scatter(rw.x_values,rw.y_values,c = point_numbers,cmap = plt.cm.Blues,edgecolor = 'none',s = 3)
    # plt.plot(rw.x_values, rw.y_values,linewidth = 3)
    # 突出终点，用红色标注出来，尺寸大小为：20
    # plt.scatter(rw.x_values[-1],rw.y_values[-1],c = 'red',edgecolors = 'none',s = 20)
    # 设置随机漫步图的样式
    plt.title('Random Walk',fontsize = 24)
    plt.xlabel('X Values',fontsize = 14)
    plt.ylabel('Y Values',fontsize = 14)

    # 隐藏坐标轴
    # plt.axes().get_xaxis().set_visible(False)
    # plt.axes().get_yaxis().set_visible(False)

    # plt.savefig('random_walk.png',bbox_inches = 'tight')
    # 现实图片
    plt.show()

    # 多次展示图片，如果不输入：n 或者 N，就一直输出图片
    keep_running = input('Make another walk?(Y/N):')
    if keep_running == 'N' or keep_running == 'n':
        break