turtle - Cómo acelerar la función de "tortuga" de Python y detenerla congelando al final

turtle python 3

Question

He escrito un programa de tortugas en Python, pero hay dos problemas.

1. Va demasiado lento para números más grandes, me pregunto cómo puedo acelerar la tortuga.
2. Se congela después de que termina y cuando se hace clic en, dice ''no responde''

Este es mi código hasta ahora:

import turtle
#Takes user input to decide how many squares are needed
f=int(input("How many squares do you want?"))
c=int(input("What colour would you like? red = 1, blue = 2 and green =3"))
n=int(input("What background colour would you like? red = 1, blue = 2 and green =3"))
i=1
x=65
#Draws the desired number of squares.
while i < f:
i=i+1
x=x*1.05
print ("minimise this window ASAP")
if c==1:
turtle.pencolor("red")
elif c==2:
turtle.pencolor("blue")
elif c==3:
turtle.pencolor("green")
else:
turtle.pencolor("black")
if n==1:
turtle.fillcolor("red")
elif n==2:
turtle.fillcolor("blue")
elif n==3:
turtle.fillcolor("green")
else:
turtle.fillcolor("white")
turtle.bk(x)
turtle.rt(90)
turtle.bk(x)
turtle.rt(90)
turtle.bk(x)
turtle.rt(90)
turtle.bk(x)
turtle.rt(90)
turtle.up()
turtle.rt(9)
turtle.down()

Por cierto: ¡estoy en la versión 3.2!

Answer 1

1. Establezca tortuga.velocidad al más rápido.
2. Use la funcionalidad turtle.mainloop() para trabajar sin actualizaciones de pantalla.
3. Desactive la actualización de la pantalla con turtle.tracer(0, 0) luego al final do turtle.update()

Answer 2

La tortuga pitón va muy despacio porque las actualizaciones de pantalla se realizan después de que cada modificación se hace a una tortuga.

Puede desactivar la actualización de la pantalla hasta que todo el trabajo esté terminado, luego pintar la pantalla, eliminará las demoras de milisegundos, ya que la pantalla intenta actualizar la pantalla con furia de cada cambio de tortuga.

Por ejemplo:

import turtle
import random
import time
screen = turtle.Screen()
turtlepower = []
turtle.tracer(0, 0)
for i in range(1000):
t = turtle.Turtle()
t.goto(random.random()*500, random.random()*1000)
turtlepower.append(t)
for i in range(1000):
turtle.stamp()
turtle.update()
time.sleep(3)

Este código hace mil tortugas en ubicaciones aleatorias y muestra la imagen en aproximadamente 200 milisegundos.

Si no hubiera desactivado la actualización de la pantalla con el turtle.tracer(0, 0) , habría necesitado varios minutos para intentar actualizar la pantalla 3000 veces.

https://docs.python.org/2/library/turtle.html#turtle.delay

Answer 3

Como referencia, la tortuga siendo lenta es un problema existente. Incluso con la velocidad establecida al máximo, la tortuga puede tardar bastante tiempo en cosas como fractales. Nick ODell reimplementó la tortuga por velocidad aquí: Hide Turtle Window?

import math
class UndrawnTurtle():
def __init__(self):
self.x, self.y, self.angle = 0.0, 0.0, 0.0
self.pointsVisited = []
self._visit()
def position(self):
return self.x, self.y
def xcor(self):
return self.x
def ycor(self):
return self.y
def forward(self, distance):
angle_radians = math.radians(self.angle)
self.x += math.cos(angle_radians) * distance
self.y += math.sin(angle_radians) * distance
self._visit()
def backward(self, distance):
self.forward(-distance)
def right(self, angle):
self.angle -= angle
def left(self, angle):
self.angle += angle
def setpos(self, x, y = None):
"""Can be passed either a tuple or two numbers."""
if y == None:
self.x = x[0]
self.y = x[1]
else:
self.x = x
self.y = y
self._visit()
def _visit(self):
"""Add point to the list of points gone to by the turtle."""
self.pointsVisited.append(self.position())
# Now for some aliases. Everything that''s implemented in this class
# should be aliased the same way as the actual api.
fd = forward
bk = backward
back = backward
rt = right
lt = left
setposition = setpos
goto = setpos
pos = position
ut = UndrawnTurtle()