1. from turtle import *
    2. import math
    4. def Acircle(x0,y0,r):
    5.     tracer(0)
    6.     clear()
    7.     for i in range(360):
    8.         a = i/180*math.pi
    9.         x = r*math.sin(a)+x0
    10.         y = r*math.cos(a)+y0
    11.         goto(x,y)
    12.     tracer(1)
    13. s = 10
    14. b = 0
    15. while True:
    16.     for i in range(10):
    17.         Acircle(b,0,20)
    18.         b = b + s
    19.         sleep(0.05)
    20.     s=-s

    运动的圆已经实现了，接下来使用键盘控制其运动方向。其中关键点就是控制圆的坐标，也就是上面程序的b=b+s;现在要实现的是当键盘按下时候再执行b=b+s；这里需要引入turtle库中的一个onkeypress()方法。

    1. from turtle import *
    2. def p():
    3.     print("test")
    4. onkeypress(p,"space")
    5. listen()
    6. done()

    onkeypress()方法需要打开监听事件listen()，onkeypress(函数名,”键盘标识”)

    “space”—-空格键 “Return”—-回车键 “Up”、”Down”、”Left”、”Right”—-方向键 “a”、”b”、”c”、”d”——字母键 “1”、”2”、”3”、”.”、”。”、”\”、—-数字、符号键

    接下来我们就使用键盘监听事件来控制小球的运动：

    1. from turtle import *
    2. import math
    4. def Acircle(x0,y0,r):
    5.     tracer(0)
    6.     clear()
    7.     for i in range(360):
    8.         a = i/180*math.pi
    9.         x = r*math.sin(a)+x0
    10.         y = r*math.cos(a)+y0
    11.         goto(x,y)
    12.     tracer(1)
    13. x=0
    14. y=0
    15. s=10
    16. def moveUp_Acircle():
    17.     global x,y
    18.     y=y+s
    19.     Acircle(x,y,20)
    21. onkeypress(moveUp_Acircle,"Up")
    22. listen()
    23. done()

    注意这里要在moveUp_Acircle()函数里把变量y声明成全局变量。
    现在已经能够上移键控制小球向上移动，继续丰富程序内容，实现上下左右移动控制。

    1. from turtle import *
    2. import math
    4. def Acircle(x0,y0,r):
    5.     tracer(0)
    6.     clear()
    7.     for i in range(360):
    8.         a = i/180*math.pi
    9.         x = r*math.sin(a)+x0
    10.         y = r*math.cos(a)+y0
    11.         goto(x,y)
    12.     tracer(1)
    13. x=0
    14. y=0
    15. s=10
    16. def moveUp_Acircle():
    17.     global x,y
    18.     y=y+s
    19.     Acircle(x,y,20)
    20. def moveDown_Acircle():
    21.     global x,y
    22.     y=y-s
    23.     Acircle(x,y,20)
    24. def moveLeft_Acircle():
    25.     global x,y
    26.     x=x-s
    27.     Acircle(x,y,20)
    28. def moveRight_Acircle():
    29.     global x,y
    30.     x=x+s
    31.     Acircle(x,y,20)
    34. onkeypress(moveUp_Acircle,"Up")
    35. onkeypress(moveDown_Acircle,"Down")
    36. onkeypress(moveLeft_Acircle,"Left")
    37. onkeypress(moveRight_Acircle,"Right")
    38. listen()
    39. done()

    程序优化：把Acircle()函数提出来，使用while True让程序一直循环执行起来。

    1. from turtle import *
    2. import math
    4. def Acircle(x0,y0,r):
    5.     tracer(0)
    6.     clear()
    7.     for i in range(360):
    8.         a = i/180*math.pi
    9.         x = r*math.sin(a)+x0
    10.         y = r*math.cos(a)+y0
    11.         goto(x,y)
    12.     tracer(1)
    13. x=0
    14. y=0
    15. s=10
    16. def moveUp_Acircle():
    17.     global y
    18.     y=y+s
    19. def moveDown_Acircle():
    20.     global y
    21.     y=y-s
    22. def moveLeft_Acircle():
    23.     global x
    24.     x=x-s
    25. def moveRight_Acircle():
    26.     global x
    27.     x=x+s
    28. while True:
    29.     listen()
    30.     onkeypress(moveUp_Acircle,"Up")
    31.     onkeypress(moveDown_Acircle,"Down")
    32.     onkeypress(moveLeft_Acircle,"Left")
    33.     onkeypress(moveRight_Acircle,"Right")
    34.     Acircle(x,y,20)

    注意这里onkeypress()方法中按键调用的函数不能带有参数，全局变量的声明必须紧邻该变量调用的地方。
    键盘控制移动的小球当作贪吃蛇的蛇头的话，接下来需要随机出现的食物。

    1. from turtle import *
    2. import math
    3. import random
    4. from time import sleep
    6. def foodBall(x0,y0,r):
    7.     tracer(0)
    8.     clear()
    9.     for i in range(360):
    10.         a = i/180*math.pi
    11.         x = r*math.sin(a)+x0
    12.         y = r*math.cos(a)+y0
    13.         goto(x,y)
    14.     tracer(1)
    15. while True:
    16.     foodBall(random.randint(-300,300),random.randint(-300,300),5)
    17.     sleep(0.5)

    程序运行结果如下，每次随机出现都会带有一个尾巴
    foodball.gif
    程序修改如下：

    1. from turtle import *
    2. import math
    3. import random
    4. from time import sleep
    6. def foodBall(x0,y0,r):
    7.     tracer(0)
    8.     penup()
    9.     goto(x0,y0+r)
    10.     pendown()
    11.     clear()
    12.     for i in range(360):
    13.         a = i/180*math.pi
    14.         x = r*math.sin(a)+x0
    15.         y = r*math.cos(a)+y0
    16.         goto(x,y)
    17.     tracer(1)
    18. while True:
    19.     foodBall(random.randint(-300,300),random.randint(-300,300),5)
    20.     sleep(0.5)

    对比发现，直线运动的小球和随机出现的小球的程序几乎是一样的，那么两个程序就可以合并如下：

    1. from turtle import *
    2. import math
    3. import random
    4. from time import sleep
    6. last_x0=0
    7. last_y0=0
    8. def Ball(x0,y0,r):
    9.     ht()#隐藏箭头画笔
    10.     global last_x0,last_y0
    11.     penup()
    12.     goto(x0,y0+r)
    13.     tracer(0)
    14.     # clear()
    15.     for i in range(360):
    16.         a = i/180*math.pi
    17.         x = r*math.sin(a)+x0
    18.         y = r*math.cos(a)+y0
    19.         pendown()
    20.         goto(x,y)
    21.     tracer(1)
    22. x=0
    23. y=0
    24. xr = random.randint(-200,200)
    25. yr = random.randint(-200,200)
    26. def moveUp():
    27.     global y
    28.     y=y+1
    29. def moveDown():
    30.     global y
    31.     y=y-1
    32. def moveLeft():
    33.     global x
    34.     x=x-1
    35. def moveRight():
    36.     global x
    37.     x=x+1
    39. def headBall():
    40.     listen()
    41.     onkeypress(moveUp,"Up")
    42.     onkeypress(moveDown,"Down")
    43.     onkeypress(moveLeft,"Left")
    44.     onkeypress(moveRight,"Right")
    45.     Ball(x,y,10)
    46. def foodBall():
    47.     global xr,yr
    48.     Ball(xr,yr,5)
    49. while True:
    50.     foodBall()
    51.     headBall()
    52.     print(xr,yr,x,y)