python - 在两个连续执行的函数之间添加延迟

Question

我希望，如果用户连续调用两个函数，两个函数之间应该有某种类型的“延迟”，以便在执行第一个调用的函数时不会中断按键。也许像队列这样的东西就可以了。为了形象化我所说的内容，以下是我要调用的函数，这些函数根据按键，在 turtle 图形窗口中绘制其相应的字母:

def draw_H():
    # Draw the left leg of H.
    # The turtle starts at the bottom left of the letter, pointing right.
    left(90)
    forward(letter_height)
    # Draw the bar of the H.
    # The turtle starts at the top of the left leg, pointing up.
    forward(-letter_height/2)
    right(90)
    forward(letter_width)
    # Draw the right leg of the H.
    # The turtle starts at the right side of the bar, pointing right.
    left(90)
    forward(letter_height/2)
    forward(-letter_height)
    right(90)
    # The H is drawn.
    # The turtle is in the top right, pointing right.
    draw_space()


def draw_E():
    # Draw an E.
    left(90)
    forward(letter_height)
    right(90)
    forward(letter_width)
    forward(-letter_width)
    right(90)
    forward(letter_height/2)
    left(90)
    forward(letter_width)
    forward(-letter_width)
    right(90)
    forward(letter_height/2)
    left(90)
    forward(letter_width)
    draw_space()

def draw_L():
    # Draw an L
    left(90)
    forward(letter_height)
    forward(-letter_height)
    right(90)
    forward(letter_width)
    draw_space()

def draw_O():
    # Draw an O
    forward(letter_width)
    left(90)
    forward(letter_height)
    left(90)
    forward(letter_width)
    left(90)
    forward(letter_height)
    left(90)
    forward(letter_width)
    draw_space()

def draw_W():
    # This function will draw a W
    left(105)
    forward(letter_height)
    backward(letter_height)
    right(40)
    forward(letter_height/2)
    right(131)
    forward(letter_height/2)
    left(141)
    forward(letter_height)
    right(165)
    penup()
    forward(letter_height)
    left(90)
    draw_space()        

def draw_R(letter_width, letter_height):
    # This function will draw an R

    slant_height = (math.sqrt(letter_width**2 + (letter_height/2)**2))
    slant_angle = (90+(90-(math.degrees(math.acos(letter_width/slant_height)))))
    space_angle = (180 - slant_angle)

    left(90)
    forward(letter_height)
    right(90)
    forward(letter_width)
    right(90)
    forward(letter_height/2)
    right(90)
    forward(letter_width)
    left(slant_angle)
    forward(slant_height)
    left(space_angle)
    draw_space()

def draw_D(letter_width, letter_height):
    # This function will draw a REAL D

    angle_height = math.sqrt(letter_width**2 + (letter_height/2)**2)
    D_angle = (90+(math.degrees(math.acos(letter_width/angle_height))))
    Second_D_angle = ((90 - (D_angle-90)) + (90-(math.degrees(math.acos(letter_width/angle_height)))))
    D_space_angle = (math.degrees(math.atan(letter_width/(letter_height/2))))

    left(90)
    forward(letter_height)
    right(D_angle)
    forward(angle_height)
    right(Second_D_angle)
    forward(angle_height)
    left(90+D_space_angle)
    penup()
    forward(letter_width)
    draw_space()

以下是如何调用函数来绘制相应的字母:

onkey(draw_H, "h")
onkey(draw_E, "e")
onkey(draw_L, "l")
onkey(draw_O, "o")
onkey(draw_W, "w")
onkey(lambda: draw_R(letter_width, letter_height), "r")
onkey(lambda: draw_D(letter_width, letter_height), "d")

现在发生的情况是，当调用该函数并且用户重复按住/按下相应函数的同一键时，会发生这种情况:

^这就是当我按住调用 H 的键时发生的情况。另外:

^这就是我快速连续输入 R 和 H 时发生的情况。我希望在调用这些函数和激活它们之间有一点延迟，这样每个函数都能够完成其过程，并且 turtle 不会到处发疯。非常感谢有关此问题的任何帮助! :)

Answer 1

欢迎来到事件编程的世界!

让我们暂时忘记 turtle 吧。您希望您的程序在键盘上敲击某些字符时绘制绘图。但是，当您正在绘制某些内容时，您不希望点击另一个角色来开始新的绘制。因此，如果一个绘图程序处于事件状态，您希望它不要进入新的绘图程序。您只需要一点同步。

由于所有操作都发生在同一个线程中(无论如何，如果不同的线程尝试访问屏幕，大多数 GUI 都会表现得很糟糕)，因此您实际上应该使用队列来保存绘图请求，并且如果您已经在绘图，则只需将请求排队即可:

q = Queue.Queue()
drawing = False
drawingLock = threading.Lock()

def draw(x):
    global drawing
    q.put(x)
    process = False:
    drawingLock.acquire()
    if not drawing:
        process = True
        drawing = True
    drawingLock.release()
    if process:
        while not q.empty():
            do_draw(q.get())  # call the actual drawings here
        drawingLock.acquire()
        drawing = False
        drawingLock.release()

应该从 onclick 事件调用此 draw 函数，并将绘图分派(dispatch)到实际的绘图函数。