Jak przyspieszyć funkcję "żółwia" Pythona i zatrzymać go na końcu

Question

Napisałem program żółwia w Pythonie, ale są dwa problemy.

1. To idzie zbyt wolno dla większych liczb, zastanawiałem się, jak mogę przyspieszyć żółwia.
2. ona zamarza po jej zakończeniu i po kliknięciu, mówi „nie odpowiada”

To jest mój kod do tej pory:

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() 

Przy okazji: jestem od wersji 3.2!

Answer 1

1. Set turtle.speed do najszybciej.
2. Użyj funkcji turtle.mainloop() do pracy bez odświeżania ekranu.
3. Wyłącz ekran odświeża turtle.tracer(0, 0) następnie na koniec zrobić turtle.update()

Answer 2

Dla porównania, żółw jest powolny jest istniejący problem. Nawet przy maksymalnej prędkości, żółw może zajmować sporo czasu na przykładach fraktali. Nick Odell przepisany do prędkości żółwia tu: 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() 

Answer 3

Python żółw idzie bardzo powoli, ponieważ odświeża ekran wykonywane są po każdej modyfikacji się do żółwia.

Możesz wyłączyć odświeżanie ekranu, dopóki cała praca nie zostanie wykonana, następnie pomaluj ekran, wyeliminuje opóźnienia milisekund, gdy ekran z furią próbuje zaktualizować ekran od każdej zmiany żółwia.

Na przykład:

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) 

Ten kod sprawia tysiąc żółwi w przypadkowych miejscach i wyświetla obraz w około 200 milisekund.

Jeśli nie wyłączyłeś odświeżania ekranu za pomocą polecenia turtle.tracer(0, 0), odtworzyłoby to kilka minut, próbując odświeżyć ekran 3000 razy.

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