这篇文章主要为大家详细介绍了计算机编程语言使用Tkinter实现机器人走迷宫，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

这本是课程的一个作业研究搜索算法，当时研究了一下Tkinter，然后写了个很简单的机器人走迷宫的界面，并且使用了各种搜索算法来进行搜索，如下图：

使用A*寻找最优路径：

由于时间关系，不分析了，我自己贴代码吧。希望对一些也要用Tkinter的人有帮助。

来自Tkinter导入*

从随机导入*

导入时间

将numpy作为铭牌导入

导入工具

课程方向：

北='北'

南方='南方'

东方='东'

西='西'

#检测地图中的元素

window=Tk()

window.title('CityBusPlanner ')

window.resizable(0，0)

宽度=25

(x，y)=(22，22)

totalsteps=0

buildings=[(0，0)，(1，0)，(2，0)，(3，0)，(7，0)，(8，0)，(11，0)，(12，0)，(13，0)，

(17, 0), (18, 0), (21, 0), (21, 1), (2, 2), (5, 2), (8, 2), (9, 2), (12, 2),

(14, 2), (15, 2), (16, 2), (17, 2), (21, 2), (2, 3), (4, 3), (5, 3), (7, 3),

(8, 3), (11, 3), (17, 3), (18, 3), (19, 3), (2, 4), (4, 4), (5, 4), (8, 4),

(9, 4), (14, 4), (15, 4),(17, 4), (18, 4), (19, 4), (0, 6), (2, 6), (4, 6),

(7, 6), (8, 6), (11, 6), (12, 6), (14, 6), (15, 6),(16, 6), (18, 6), (19, 6),

(2, 7), (5, 7), (21, 7), (0, 8), (2, 8), (11, 8), (14, 8), (15, 8), (17, 8),

(18, 8), (21, 8), (4, 9), (5, 9), (7, 9), (9, 9), (11, 9), (14, 9), (21, 9),

(2, 10), (7, 10), (14, 10), (17, 10), (19, 10), (0, 11), (2, 11), (4, 11),

(5, 11), (7, 11), (8, 11), (9, 11), (11, 11), (12, 11), (14, 11), (15, 11),

(16, 11), (17, 11), (18, 11), (19, 11), (0, 13), (2, 13), (3, 13), (5, 13),

(7, 13), (8, 13), (9, 13), (14, 13), (17, 13), (18, 13), (21, 13), (2, 14),

(3, 14), (5, 14), (7, 14),(9, 14), (12, 14), (14, 14), (15, 14), (17, 14),

(18, 14), (21, 14), (2, 15), (3, 15), (5, 15), (7, 15), (9, 15), (12, 15),

(15, 15), (19, 15), (21, 15), (0, 16), (21, 16), (0, 17), (3, 17), (5, 17),

(7, 17),(9, 17), (11, 17), (14, 17), (15, 17), (17, 17), (18, 17), (21, 17),

(2, 18), (3, 18), (5, 18), (7, 18),(9, 18), (11, 18), (14, 18), (17, 18),

(18, 18), (3, 19), (5, 19), (7, 19), (9, 19), (11, 19), (12, 19), (14, 19),

(17, 19), (18, 19), (0, 21), (1, 21), (2, 21), (5, 21), (6, 21), (9, 21),

(10, 21), (11, 21), (12, 21), (15, 21), (16, 21), (18, 21), (19, 21), (21, 21)]

墙壁=[(10,0),(0,12),(21,12),(14,21)]

park=[(14，0)，(15，0)，(16，0)]

robotPos=(21，12)

视图=画布（窗口，宽度=x *宽度，高度=y *宽度)

视图.网格(行=0,列=0)

searchMapButton=Button(window，text='search ')

searchMapButton.grid(行=0,列=1)

robotView=Canvas(窗口，宽度=x *宽度，高度=y *宽度)

robotView.grid(行=0,列=2)

定义格式颜色(r、g、b):

返回'#xxx' % (int(r * 255)，int(g * 255)，int(b * 255))

极好的城市地图():

全局宽度，x，y，建筑物，墙壁，公园，机器人

对于范围(十)中的我：

对于范围(y)中的j:

视图。创建矩形（

i * width，j * width，(i 1) * width，(j 1) * width，fill='白色，大纲='灰色宽度=1)

对于建筑物中的(I，j):

视图。创建矩形（

i * width，j * width，(i 1) * width，(j 1) * width，fill='黑色，大纲='灰色宽度=1)

对于墙中的(I，j):

视图。创建矩形（

i * width，j * width，(i 1) * width，(j 1) * width，fill='蓝色，大纲='灰色宽度=1)

对于公园中的(I，j):

视图。创建矩形（

i * width，j * width，(i 1) * width，(j 1) * width，fill='red '，outline='gray '，width=1)

极好的机器人城市地图():

全局宽度，x，y，建筑物，墙壁，公园，机器人，机器人位置

对于范围(十)中的我：

对于范围(y)中的j:

robotView.create_rectangle(

i * width，j * width，(i 1) * width，(j 1) * width，fill='black '，width=1)

robotView.create_rectangle(

robotPos[0] * width，robotPos[1] * width，(robotPos[0] 1) * width，(robotPos[1] 1) * width，fill='白色，大纲='灰色宽度=1)

#创建城市地图

城市地图()

#创建机器人视图

机器人城市地图()

#创造一个机器人

机器人=视图。create _ rectangle(机器人位置[0]*宽度宽度* 2/10，机器人位置[1] *宽度宽度* 2/10,

robotPos[0] *宽度宽度* 8/10，机器人位置[1] *宽度宽度* 8/10，填充='橙色'，宽度=1，标记='机器人')

机器人自我=机器人视角。create _ rectangle(机器人位置[0]*宽度宽度* 2/10，机器人位置[1] *宽度宽度* 2/10,

robotPos[0] *宽度宽度* 8/10，机器人位置[1] *宽度宽度* 8/10，填充='橙色'，宽度=1，标记='机器人')

已访问=[机器人位置]

定义移动(dx，dy):

全局机器人，x，y，机器人位置，机器人自身，视图

全球总步骤数

总计步骤=总计步骤一

newX=robotPos[0] dx

newY=robotPos[1] dy

if (not isEdge(newX，newY))和(不是isBlock(newX，newY)):

#print 'move %d' % totalsteps

视图.坐标(机器人，(newX) *宽度宽度* 2/10，(新)*宽度宽度* 2/10,

(纽克斯)*宽度宽度* 2010年8月(纽约)*宽度宽度* 8/10)

robotView.coords(robotSelf，(newX) * width width * 2/10，(newY) * width width * 2/10，

(纽克斯)*宽度宽度* 2010年8月(纽约)*宽度宽度* 8/10)

robotPos=(newX，newY)

如果机器人位置未被访问：

visited.append(robotPos)

访问面板=机器人视图。创建矩形(

robotPos[0] * width，robotPos[1] * width，(robotPos[0] 1) * width，(robotPos[1] 1) * width，fill='白色，大纲='灰色宽度=1)

机器人视角。tag _ lower(访问过的面板，robotSelf)

否则：

打印"移动错误"

定义调用（事件):

移动(0,-1)

定义调用（事件):

移动(0,1)

左定义调用(事件):

移动(-1,0)

定义调用权限（事件):

移动(1,0)

def isBlock(newX，newY):

全球建筑，x，y

对于建筑物中的(I，j):

if (i==newX)和(j==newY):

返回真实的

返回错误的

def isEdge(newX，newY):

全局x，y

如果newX=x或newY=y或newX 0或新0:

返回真实的

返回错误的

def getSuccessors(robotPos):

n=方向。北方

w=方向。西方的

s=方向。南方

e=方向。东方

继任者=[]

posX=robotPos[0]

posY=robotPos[1]

如果不是isBlock(posX - 1，posY)并且不是isEdge(posX - 1，posY):

后继者。追加(w)

如果不是isBlock(posX，posY 1)并且不是isEdge(posX，posY 1):

后继者。追加

如果不是isBlock(posX 1，posY)并且不是isEdge(posX 1，posY):

后继者。追加(五)

如果不是isBlock(posX，posY -1)并且不是isEdge(posX，posY - 1):

后继者。追加(名词)

返回继任者

def getNewPostion(位置，动作):

posX=位置[0]

posY=位置[1]

n=方向。北方

w=方向。西方的

s=方向。南方

e=方向。东方

如果动作==n:

返回(posX，posY - 1)

elif action==w:

返回(posX - 1，posY)

elif action==s:

返回(posX，posY 1)

否则如果动作==e:

返回(posX 1，posY)

延迟=假

定义运行操作（操作):

全局延迟

n=方向。北方

w=方向。西方的

s=方向。南方

e=方向。东方

对于行动中的我：

如果延迟：

时间。睡眠(0.05)

如果i==n:

#打印"北方"

移动(0,-1)

elif i==w:

#打印"西部"

移动(-1,0)

elif i==s:

#打印"南部"

移动(0,1)

elif i==e:

#冲刺'东'

移动(1,0)

view.update()

def searchMapTest(事件):

全球机器人刷卡机

动作=[]

位置=机器人位置

对于范围内的我(100):

继任者=getSuccessors(职位)

后继者=后继者[randint(0，len(successors) - 1)]

动作.追加(后续)

position=getNewPostion(职位，继任者)

打印操作

运行操作（操作)

定义反向成功(继任者):

n=方向。北方

w=方向。西方的

s=方向。南方

e=方向。东方

如果后继者==n:

返回s

否则如果继任者==w:

返回e

否则如果继任者==s:

返回

否则如果后继者==e:

返回w

roads=set()

detectedBuildings={}

blockColors={}

blockIndex=0

定义更新建筑物（检测到的建筑物):

全局机器人视图，宽度

对于block，detectedBuildings.items()中的建筑物：

color=blockColors[block]

对于建筑物中的建筑物：

robotView.create_rectangle(

建筑物[0] *宽度，建筑物[1] *宽度，(建筑物[0] 1) *宽度，(建筑物[1] 1) *宽度，填充=颜色，轮廓=颜色，宽度=1)

定义添加建筑（位置):

全局块索引，检测到个构建

isAdd=False

addBlock=' '

对于block，detectedBuildings.items()中的建筑物：

对于建筑物中的建筑物：

如果建筑==位置：

返回

如果util。曼哈顿距离(位置、建筑)==1:

如果不是isAdd:

buildings.add(位置)

isAdd=True

addBlock=block

破裂

否则：

#合并两个块

对于检测到的建筑物中的建筑物[块]:

检测到建筑物.添加（建筑)

detectedBuildings.pop(block)

如果不是isAdd:

newBlock=set([position])

块索引=块索引一

检测到的建筑物['块% d ' %块索引]=新块

color=formatColor(random()，random()，random())

块颜色[' Block % d ' % Block index]=颜色

更新建筑物（检测到的建筑物)

定义添加道路(位置):

全局机器人视图，宽度，机器人自身

访问面板=机器人视图。创建矩形(

位置[0] *宽度，位置[1] *宽度，(位置[0] 1) *宽度，(位置[1] 1) *宽度，填充='白色，轮廓='灰色，宽度=1)

机器人视角。tag _ lower(访问过的面板，robotSelf)

定义显示路径（位置一，位置b，路径):

全局机器人视图，宽度，视图

查看。create _ oval(位置a[0]*宽度宽度* 3/10，位置A[1] *宽度宽度* 3/10,

位置A[0] *宽度宽度* 7/10,位置A[1] *宽度宽度* 7/10,填充='黄色，宽度=1)

下一个位置=位置a

对于路径中的操作：

下一个位置=getnewposition(下一个位置，动作)

查看。create _ oval(下一个位置[0]*宽度宽度* 4/10，下一个位置[1] *宽度宽度* 4/10,

下一个位置[0]*宽度宽度* 6/10，下一个位置[1]*宽度宽度* 6/10，fill='黄色宽度=1)

查看。create _ oval(位置b[0]*宽度宽度* 3/10，位置B[1] *宽度宽度* 3/10,

位置B[0] *宽度宽度* 7/10,位置B[1] *宽度宽度* 7/10,填充='黄色，宽度=1)

hasDetected=set()

定义检测位置（位置):

如果检测到位置不在有中：

hasDetected.add(位置)

如果是块（位置[0],位置[1]):

添加建筑（位置)

elif not isEdge(位置[0],位置[1]):

添加道路(位置)

定义检测（位置):

posX=位置[0]

posY=位置[1]

检测位置((posX，posY 1))

检测位置((posX，posY - 1))

检测位置((posX 1，posY))

检测位置((posX - 1，posY))

定义启发式（位置一，位置b):

返回util。曼哈顿距离(位置a，位置b)

def AstarSearch(位置一，位置b):

步骤1:定义封闭：一个集合

closed=set()

步骤2:定义边缘：优先队列

边缘=效用。优先级队列()

步骤3:将初始节点插入边缘

'将节点构造为元组（位置，动作)'

initialNode=(positionA，[])

initCost=0启发式(initialNode[0]，位置b)

流苏. push(初始节点，初始成本)

第四步：循环搜索

while not fringe.isEmpty():

node=fringe.pop()

如果节点[0]==位置乙：

返回节点[1]

如果节点[0]未关闭：

closed.add(节点[0])

对于getSuccessors(节点[0])中的后继者：

操作=列表（节点[1])

动作.追加(后续)

newPosition=getNewPostion(节点[0],继任者)

子节点=(新位置，操作)

成本=贷款(操作)启发式（子节点[0],位置b)

流苏. push(子节点，成本)

return []

建筑物之间的定义（建筑物1、建筑物2):

步骤1:定义封闭：一个集合

closed=set()

步骤2:定义边缘：优先队列

边缘=效用。优先级队列()

步骤3:将初始节点插入边缘

'将节点构造为元组（位置，动作)'

initialNode=(building1，[])

initCost=0启发式(initialNode[0]，building2)

流苏. push(初始节点，初始成本)

第四步：循环搜索

while not fringe.isEmpty():

node=fringe.pop()

如果util.manhattanDistance(node[0]，building2)==1:

返回节点[1]

如果节点[0]未关闭：

closed.add(节点[0])

对于getSuccessors(节点[0])中的后继者：

操作=列表（节点[1])

动作.追加(后续)

newPosition=getNewPostion(节点[0],继任者)

子节点=(新位置，操作)

成本=len(操作)启发式（子节点[0],建筑物2)

流苏. push(子节点，成本)

return []

定义计算位置（建筑物一，路径):

位置=集合()

positions.add(buildingA)

nextPosition=buildingA

对于路径中的操作：

下一个位置=getnewposition(下一个位置，动作)

positions.add(nextPosition)

返回位置

def showRoad(全道路):

全局视图，宽度

对于富路中的道路：

view.create_oval(road[0] * width宽度* 4/10，道路[1] *宽度宽度* 4/10,

道路[0] *宽度宽度* 6/10,道路[1] *宽度宽度* 6/10,填充='黄色，宽度=1)

view.update()

定义搜索（节点):

继任者=getSuccessors(节点[0])

检测（节点[0])

对于继任者中的继任者：

nextPosition=getNewPostion(节点[0],继任者)

如果下一个位置不在道路上：

运行操作([后继]) #到下一个节点

roads.add(nextPosition)

搜索((下一个位置，[继任者]，[reverseSuccessor(继任者)])

运行操作(节点[2])#返回到顶层节点

def search counter visit(node，topWillVisit):

继任者=getSuccessors(节点[0])

检测（节点[0])

newtopwillsvisit=set(topwillsvisit)

对于继任者中的继任者：

nextPosition=getNewPostion(节点[0],继任者)

newtopwillsvisit。添加(下一个位置)

对于继任者中的继任者：

nextPosition=getNewPostion(节点[0],继任者)

如果下一个位置不在道路上，并且下一个位置不在顶部，将访问：

运行操作([后继]) #到下一个节点

roads.add(nextPosition)

newtopwillsvisit。移除(下一个位置)

searchConsiderTopVisit((下一个位置，[继任者]，[reverseSuccessor(继任者)])、newTopWillVisit)

运行操作(节点[2])#返回到顶层节点

def searchshortestpathbeangblocks(块1，块2):

shortestPath=[]

buildingA=(0，0)

buildingB=(0，0)

对于block1中的一号建筑：

对于block2中的2号建筑：

path=建筑物之间的星形搜索(建筑物1，建筑物2)

如果len(shortestPath)==0:

最短路径=路径

建筑A=建筑一

建筑B=建筑2

elif len(path) len(shortestPath):

最短路径=路径

建筑A=建筑一

建筑B=建筑2

返回（建筑物一，建筑物b，最短路径)

def addBuildingToBlocks(链接块，buildingA):

全球检测到的建筑

newLinkedBlock=链接块。复制()

对于block，detectedBuildings.items()中的建筑物：

对于建筑物中的建筑物：

如果util。曼哈顿距离(建筑a，建筑)==1:

建筑

破裂

返回newLinkedBlock

def bfs search next block(init building，linkedBlock):

全球检测到的建筑

closed=set()

边缘=效用。队列()

initNode=(initBuilding，[])

边缘推送（初始化节点)

while not fringe.isEmpty():

node=fringe.pop()

newLinkedBlock=addBuildingToBlocks(链接块，节点[0])

如果len(newLinkedBlock)==len(检测到的建筑物):

返回节点[1]

if len(newLinkedBlock)len(链接块):#查找新块

操作=列表（节点[1])

'''

如果len(node[1]) 0:

最后操作=节点[1][len(节点[1])-1]

对于getSuccessors(节点[0])中的后继者：

如果后继者==lastAction:

nextPosition=getNewPostion(节点[0],继任者)

动作.追加(后续)

返回操作bfsSearchNextBlock(下一个位置，newLinkedBlock)

'''

返回节点[1] bfsSearchNextBlock(节点[0]，newLinkedBlock)

如果节点[0]未关闭：

closed.add(节点[0])

对于getSuccessors(节点[0])中的后继者：

操作=列表（节点[1])

动作.追加(后续)

nextPosition=getNewPostion(节点[0],继任者)

childNode=(nextPosition，actions)

流苏. push(子节点)

return []

定义目标（节点):

全球检测建筑，机器人位置

linkedBlock={}

位置=计算位置(机器人位置，节点[1])

对于职位中的职位：

对于block，detectedBuildings.items()中的建筑物：

对于建筑物中的建筑物：

如果util。曼哈顿距离(位置、建筑)==1:

建筑

打印镜头（链接块)

如果len(linkedBlock)==17:

返回真实的

否则：

返回错误的

定义道路启发式（道路):

返回0

def AstarSearchRoad():

全球机器人位置，检测到的建筑

步骤1:定义封闭：一个集合

closed=set()

步骤2:定义边缘：优先队列

边缘=效用。优先级队列()

步骤3:将初始节点插入边缘

'将节点构造为元组（位置，动作)'

initRoad=(robotPos，[])

initCost=0道路启发式(初始道路)

fringe.push(initRoad，initCost)

第四步：循环搜索

while not fringe.isEmpty():

node=fringe.pop()

如果是目标（节点):

打印镜头（关闭)

返回节点[1]

如果节点[0]未关闭：

closed.add(节点[0])

对于getSuccessors(节点[0])中的后继者：

操作=列表（节点[1])

动作.追加(后续)

newPosition=getNewPostion(节点[0],继任者)

子节点=(新位置，操作)

成本=len(操作)roadHeuristic(子节点)

流苏. push(子节点，成本)

return []

定义搜索道路(建筑):

全球检测建筑，机器人位置

linkedBlock={}

initBuilding=建筑

返回bfs search next block(init building，linkedBlock)

def searchShortestRoad():

shortestRoad=[]

shortestPositions=set()

对于block，detectedBuildings.items()中的建筑物：

对于建筑物中的建筑物：

道路=搜索道路（建筑)

位置=计算位置（建筑、道路)

如果len(shortestPositions)==0或len(位置)len(最短位置):

shortestRoad=道路

最短仓位=仓位

打印镜头（最短位置)

秀道(最短位置)

定义搜索地图（事件):

打印"搜索地图"

全球机器人位置、道路、检测到的建筑物、延迟

动作=[]

#roads=set()s

#roads.add(robotPos)

#条纹=实用。堆栈()

initNode=(robotPos，[]，[]) # (position，forwardActions，backwarsdActions)

#条纹.推送(初始化节点)

roads.add(robotPos)

搜索（初始化节点)

# search counter visit(initNode，set())

打印检测到的建筑

打印镜头（检测建筑)

# path=astarsearch在建筑物之间((6，21)，(2，18))

#showPath((6，21)，(2，18)，Path)

'''

shortestRoad=set()

对于detectedBuildings.values()中的区块1:

roads=set()

对于detectedBuildings.values()中的区块2:

如果不是块1==块2:

(buildingA，buildingB，path)=searchshortestpatheblocks(block 1，block2)

#showPath(buildingA，buildingB，Path)

位置=计算位置（建筑物一，建筑物b，路径)

道路=道路|位置

如果len(shortestRoad)==0或len(roads) len(shortestRoad):

shortestRoad=道路

打印镜头（短距离)

showRoad(shortestRoad)

'''

'''

块1=检测到的建筑物。values()[3]

打印区块一

第2块=检测到的建筑物。values()[5]

打印区块2

(buildingA，buildingB，path)=searchshortestpatheblocks(block 1，block2)

打印建筑物一，建筑物b，路径

显示路径（建筑一，建筑b，路径)

块1=检测到的建筑物。values()[10]

打印区块一

第2块=检测到的建筑物。values()[20]

打印区块2

(buildingA，buildingB，path)=searchshortestpatheblocks(block 1，block2)

打印建筑物一，建筑物b，路径

显示路径（建筑一，建筑b，路径)

'''

searchShortestRoad()

'''

path=searchRoad()

#path=AstarSearchRoad()

位置=计算位置（机器人位置，路径)

打印镜头（位置)

展示道路（位置)

延迟=真

#runAction(路径)

'''

window.bind('Up '，callUp)

window.bind('Down '，callDown)

window.bind('Right '，callRight)

window.bind('Left '，callLeft)

window.bind('s '，searchMap)

searchMapButton.bind('Button-1 '，searchMap)

window.mainloop()

下面的util.py使用的是加州伯克利的代码：

# util.py

# -

#许可信息：您可以自由使用或扩展这些项目

#教育目的，前提是(1)您不分发或发布

#解决方案，(2)您保留本通知，以及(3)您提供清晰的

#署名加州大学伯克利分校，包括链接到http://ai.berkeley.edu .

#

#归属信息：吃豆人AI项目是在加州大学伯克利分校开发的。

#核心项目和签名主要由约翰德内罗创作

# (denero@cs.berkeley.edu)和丹克莱恩(klein@cs.berkeley.edu).

#学生签名由布拉德米勒、尼克海伊和

# Pieter ab beel(pabbeel @ cs。伯克利。edu).

导入系统

进口检验

导入堆，随机

'''

用于实现搜索代理的数据结构

'''

类别堆栈：

具有后进先出(后进先出法)排队策略的容器。

def __init__(self):

self.list=[]

定义推送（自身，项目):

将"项目"推送到堆栈上

self.list.append(项目)

定义弹出（自身):

'从堆栈中弹出最近推送的项目'

返回self.list.pop()

def isEmpty(self):

'如果堆栈为空，则返回“真的”

return len(self.list)==0

类别队列：

具有先进先出(先进先出)队列的容器

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。