python3练习，做一个迷宫生成程序

直接上代码：

#!/usr/bin/python3
#coding=utf-8
import random
import tkinter as tk

class Cell():
    TOP = (0)
    RIGHT = (1)
    BOTTOM = (2)
    LEFT = (3)
    def __init__(self, x, y):
        self.index = 0
        self.x = x
        self.y = y
        self.walls = [True, True, True, True]
        self.visited = False
    def __str__(self):
        return 'x:{}-y:{}, walls:{}'.format(self.x, self.y, self.walls)
    def Walls(self):
        return self.walls
    def delTop(self):
        self.walls[0] = False 
    def delRight(self):
        self.walls[1] = False
    def delBottom(self):
        self.walls[2] = False
    def delLeft(self):
        self.walls[3] = False
    def setWall(self, isWall, index):
        if index not in [0, 1, 2, 3]:
            return
        self.walls[index] = isWall
    def XY(self):
        return [self.x, self.y]
    def X(self):
        return self.x
    def Y(self):
        return self.y
    def isVisited(self):
        return self.visited
    def setVisited(self):
        self.visited = True

class Maze():
    SIZE = (18)
    START = (0, 0)
    def __init__(self):
        self.size = self.SIZE
        self.bfsBuffer = []
        self.cells = 
                [[Cell(y, x) for x in range(self.SIZE)] 
                for y in range(self.SIZE)]

        self.current = self.cells[self.START[0]][self.START[1]]


    def __str__(self):
        info = '' 
        for rows in self.cells:
            for cell in rows:
                info += str(cell)
        return info 
    def trblWalls(self, x, y):
        return self.cells[x][y].Walls()
    def visited(self, x, y):
        return self.cells[x][y].isVisited()
    def CurrentCell(self):
        return self.current
    def setCurrent(self, cell):
        self.current = cell
    def topCell(self):
        if 0 == self.current.Y():
            return None
        return self.cells[self.current.X()][self.current.Y() - 1]
    def rightCell(self):
        if self.current.X() == (self.SIZE - 1):
            return None
        return self.cells[self.current.X() + 1][self.current.Y()]
    def bottomCell(self):
        if self.current.Y() == (self.SIZE - 1):
            return None
        return self.cells[self.current.X()][self.current.Y() + 1]
    def leftCell(self):
        if 0 == self.current.X():
            return None
        return self.cells[self.current.X() - 1][self.current.Y()]
    def delWall(self, current, neighbor):
        x = current.X()
        y = current.Y()
        x2 = neighbor.X()
        y2 = neighbor.Y()
        #print("({}x{}) and ({}x{})".format(x, y, x2, y2))

        if (1 == (x - x2)):
            current.delLeft()
            neighbor.delRight()
        elif (-1 == (x - x2)):
            current.delRight()
            neighbor.delLeft()
        if (1 == (y - y2)):
            current.delTop()
            neighbor.delBottom()
        elif (-1 == (y - y2)):
            current.delBottom()
            neighbor.delTop()

    def checkNeighbor(self):
        neighbor = []
        top = self.topCell()
        right = self.rightCell()
        bottom = self.bottomCell()
        left = self.leftCell()
        if (None != top and not top.isVisited()):
            neighbor.append(self.topCell())
        if (None != right and not right.isVisited()):
            neighbor.append(self.rightCell())
        if (None != bottom and not bottom.isVisited()):
            neighbor.append(self.bottomCell())
        if (None != left and not left.isVisited()):
            neighbor.append(self.leftCell())
        count = len(neighbor)
        if 0 == count:
            
            if (len(self.bfsBuffer) == 0):
                return
            self.current = self.bfsBuffer.pop()
            self.checkNeighbor()
            
            return
            
        old = self.current
               
        self.current = neighbor[random.randint(0, count - 1)]

        self.delWall(old, self.current)
        #print('neighbor count:{} ->{}'.format(count, str(self.current)))
        self.setUp()
    
    def setUp(self):
        self.current.setVisited()
        self.bfsBuffer.append(self.current)
        self.checkNeighbor()
        
class MazeUI():
    winWidth = (600)
    winHeight = (600)
    def __init__(self):
        self.maze = Maze()
        self.ui = tk.Tk()
        self.centeredDisplay()

        self.createMaze()

        self.ui.mainloop()
    def centeredDisplay(self):
        self.ui.title('Maze by jianc')
        self.ui.geometry('{}x{}+{}+{}'.format( 
                self.winWidth, self.winHeight, 
                int((self.ui.winfo_screenwidth() - self.winWidth)/2), 
                int((self.ui.winfo_screenheight() - self.winHeight)/2)))
        self.ui.resizable(False, False)
    def createMaze(self):
        self.cs = tk.Canvas(self.ui, bg = '#5f3c23')

        self.cs.pack(side = tk.TOP, fill = 'both', expand=1, 
                padx=0, ipadx=0, pady=0, ipady=0)

        self.maze.setUp()

        #print(self.maze)
        self.drawCells()
        
    def drawCells(self):
        w = float(self.winWidth / self.maze.SIZE)
        h = float(self.winHeight / self.maze.SIZE)
        current = self.maze.CurrentCell()
        y = current.X()
        x = current.Y()
        self.cs.create_rectangle(y * w + 4, x * h + 4, (y + 1) * w - 4, (x + 1) * h - 4, 
                fill='#ff0000', width = 0)


       
        for rows in range(self.maze.SIZE):
            for cols in range(self.maze.SIZE):
                top, right, bottom, left = self.maze.trblWalls(cols, rows)
                #print("top:{} right:{} bottom:{} left:{}".format(top, right, bottom, left))
                bVisited = self.maze.visited(rows, cols)

                """if bVisited:
                    self.cs.create_rectangle(rows * w + 10, cols * h + 10, 
                            (rows + 1) * w - 10, (cols+ 1) * h - 10, fill='#00ff00', width = 0) 
                """
                if top:
                    self.cs.create_line(cols * w, rows * h, 
                            (cols + 1) * w, rows * h, width=5)
                if right:
                    self.cs.create_line((cols + 1) * w, rows * h, 
                            (cols + 1) * w, (rows + 1) * h, width=5)
                if bottom:
                    self.cs.create_line((cols + 1) * w, (rows + 1) * h, 
                            cols * w, (rows + 1) * h, width=5)
                if left:
                    self.cs.create_line(cols * w, (rows + 1) * h, 
                            cols * w, rows * h, width=5)
        
        current = self.maze.CurrentCell()
        y = current.X()
        x = current.Y()
        self.cs.create_rectangle(y * w + 5, x * h + 5, (y + 1) * w - 5, (x + 1) * h - 5, 
                fill='#ff0000', width = 0)



maze = MazeUI()