Python Turtle随机游走：实现起点到终点最短路径绘制的技术咨询

Hey there! That’s such a clever question from your student—this is a fantastic way to connect random walks, graph theory, and Python visualization. Let’s walk through how to make this happen, including the library you’re looking for.

Step 1: Track the Random Walk’s Coordinates #

First, you’ll need to modify your existing turtle code to record every position the wandering turtle visits. Every time the turtle moves, capture its current position with turtle.pos() and store it in a list (let’s call it walk_path). This list will act as our record of all "nodes" in the walk, from start to finish.

Pro tip: Round the coordinates to 1-2 decimal places (like round(t.xcor(), 2)) to avoid tiny floating-point discrepancies treating identical spots as different nodes later.

Step 2: Use networkx to Build a Graph & Find the Shortest Path #

The library you’re thinking of is networkx—it’s the go-to Python tool for working with graphs and trees, and it has built-in functions to calculate shortest paths with zero manual algorithm writing.

Here’s what to do:

• Install it if you haven’t already: pip install networkx
• Turn your recorded path into a graph:
  • Each coordinate in walk_path is a node.
  • Add an edge between each consecutive pair of coordinates (since that’s the path the turtle took).
• Use nx.shortest_path() to find the shortest path from the first coordinate (start) to the last (end). Since all edges have the same "cost" (each step is a single move), this will use BFS under the hood—perfect for finding the shortest path in unweighted graphs.

Step 3: Draw the Shortest Path with a Second Turtle #

Once you have the shortest path coordinates, spin up a second turtle (give it a different color or thicker pen to stand out) and have it trace the path:

• Lift the pen, move to the start position, then put the pen down.
• Loop through each coordinate in the shortest path and call goto() to move the turtle between points.

Full Example Code #

Here’s a complete snippet tying it all together:

import turtle
import random
import networkx as nx

# Set up the screen and first turtle
screen = turtle.Screen()
walker = turtle.Turtle()
walker.speed(0)  # Fastest drawing
walk_path = []

# Record the starting position
start_pos = (round(walker.xcor(), 2), round(walker.ycor(), 2))
walk_path.append(start_pos)

# Run the random walk (100 steps here—adjust as needed)
for _ in range(100):
    angle = random.randint(0, 360)
    distance = random.randint(10, 30)
    walker.setheading(angle)
    walker.forward(distance)
    current_pos = (round(walker.xcor(), 2), round(walker.ycor(), 2))
    walk_path.append(current_pos)

end_pos = walk_path[-1]

# Build the graph from the walk path
G = nx.Graph()
for i in range(len(walk_path) - 1):
    G.add_edge(walk_path[i], walk_path[i+1], weight=1)

# Calculate the shortest path
shortest_path = nx.shortest_path(G, source=start_pos, target=end_pos)

# Set up the second turtle for the shortest path
path_drawer = turtle.Turtle()
path_drawer.color("red")
path_drawer.pensize(2)
path_drawer.speed(0)

# Trace the shortest path
path_drawer.penup()
path_drawer.goto(start_pos)
path_drawer.pendown()
for pos in shortest_path[1:]:
    path_drawer.goto(pos)

screen.exitonclick()

Bonus Notes for Teaching #

• If you want to avoid third-party libraries for a more hands-on lesson, you can implement BFS manually: treat each coordinate as a node, track neighbors (the positions before and after it in the walk), then traverse from start to end to find the shortest path. But networkx is great for showing students how existing tools solve common problems.
• Point out to students that the shortest path here ignores the random walk’s backtracking—this is a perfect way to introduce graph theory concepts like nodes, edges, and shortest path algorithms.

内容的提问来源于stack exchange，提问作者Eric