Wie python's 'Turtle' Funktion zu beschleunigen und es am Ende zu stoppen

Question

Ich habe ein Turtle-Programm in Python geschrieben, aber es gibt zwei Probleme.

1. Es geht viel zu langsam für größere Zahlen, ich frage mich, wie ich Schildkröte beschleunigen kann.
2. Es friert, nachdem es beendet und wenn darauf geklickt wurde, sagt: 'reagiert nicht'

Das bisher mein Code:

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

By the way: Ich bin auf Version 3.2!

Answer 1

1. Set turtle.speed zu den schnellsten.
2. Verwenden Sie die turtle.mainloop()-Funktionalität, um ohne Bildschirmaktualisierungen zu arbeiten.
3. Disable-Bildschirm mit turtle.tracer(0, 0) erfrischenden dann am Ende tut turtle.update()

Answer 2

Als Referenz Schildkröte langsam ist ein bestehendes Problem. Auch wenn die Geschwindigkeit auf Maximum eingestellt ist, kann Schildkröte bei Fraktalen ziemlich lange dauern. Nick ODell reimplementiert Schildkröte Geschwindigkeit hier: 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 Schildkröte geht sehr langsam, weil Bildschirm aktualisiert durchgeführt werden, nach jeder Änderung an einer Schildkröte gemacht wird.

Sie können Bildschirmauffrischung deaktivieren, bis die ganze Arbeit getan ist, dann malen Sie den Bildschirm, wird es die Millisekunden Verzögerungen beseitigen, wie der Bildschirm wütend versucht, den Bildschirm von jedem Turtle-Wechsel zu aktualisieren.

Zum Beispiel:

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) 

Dieser Code macht tausend Schildkröten an zufälligen Orten, und zeigt das Bild in etwa 200 Millisekunden.

Hätten Sie Bildschirmauffrischung mit turtle.tracer(0, 0) Befehl nicht deaktiviert, hätte es einige Minuten dauern müssen, wie es versucht, den Bildschirm 3000 mal zu aktualisieren.

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