Python Multiple Turtles bewegen (scheinbar) gleichzeitig

Question

Ich arbeite daran, etwas für meinen Lehrer zu testen, er möchte sehen, wie das Programm unter Umständen schneller laufen könnte, wenn wir Simultan simulieren (ich weiß, dass es nicht perfekt simultan sein kann, Dies ist nur ein Experiment zum Lernen/Üben) der Bewegung mehrerer Schildkröten. Ich habe versucht, Module wie Multiprocessing, Threading, und sogar einige verrückte dumme Versuch zu Zeit und Verzögerung (ich bin in der High School und ich habe gerade über Klassen in Python wegen einer vorherigen Frage ich fragte, ich denke, letzte Woche) Also nach vielen gescheiterten versuchen, ich frage, ob jemand ein paar Ideen, was anderes zu versuchen, hat, oder eine Richtung gehen gleichzeitige Bewegung der Schildkröten

Import Schildkröte

Import Schildkröte von Schildkröte

turtle.getscreen().delay(0) 
class MyTurtle(Turtle): 
    def petal(self): 
     for i in range(90): 
      self.fd(1) 
      self.rt(1) 
     self.rt(90) 
     for i in range(90): 
      self.fd(1) 
      self.rt(1) 

    def stem(self): 
     self.pencolor('green') 
     self.fd(250) 

    def flowerhead(self): 
     for i in range(9): 
      self.pencolor('red') 
      self.begin_fill() 
      self.petal() 
      self.lt(230) 
      self.end_fill() 

    def stempetal(self): 
     self.seth(90) 
     self.rt(15) 
     self.fillcolor('green') 
     self.begin_fill() 
     self.petal() 
     self.end_fill() 



tony = MyTurtle(shape='turtle') 
todd = MyTurtle(shape='turtle') 
tina = MyTurtle(shape='turtle') 
tiny = MyTurtle(shape='turtle') 
tweeny = MyTurtle(shape='turtle') 


def flower1(): 
    todd.speed('fastest') 
    todd.fillcolor('blue') 
    todd.flowerhead() 
    todd.seth(270) 
    todd.stem() 
    todd.stempetal() 

def flower2(): 
    tony.speed('fastest') 
    tony.setpos(80, -15) 
    tony.pencolor('green') 
    tony.goto(0, -200) 
    tony.fillcolor('purple') 
    tony.goto(80,-15) 
    tony.rt(40) 
    tony.flowerhead() 


def flower3(): 
    tina.speed('fastest') 
    tina.setpos(-80, -15) 
    tina.pencolor('green') 
    tina.goto(0, -200) 
    tina.fillcolor('teal') 
    tina.goto(-80,-15) 
    tina.lt(40) 
    tina.flowerhead() 


def flower4(): 
    tiny.speed('fastest') 
    tiny.setpos(160, -25) 
    tiny.pencolor('green') 
    tiny.goto(0, -200) 
    tiny.fillcolor('black') 
    tiny.goto(160, -25) 
    tiny.flowerhead() 


def flower5(): 
    tweeny.speed('fastest') 
    tweeny.setpos(-160, -25) 
    tweeny.pencolor('green') 
    tweeny.goto(0, -200) 
    tweeny.fillcolor('pink') 
    tweeny.goto(-160,-25) 
    tweeny.lt(40) 
    tweeny.flowerhead() 


flower2() 
tony.hideturtle() 
flower4() 
tiny.hideturtle() 
flower3() 
tina.hideturtle() 
flower5() 
tweeny.hideturtle() 
flower1() 
todd.hideturtle() 

zu simulieren

danke für Ihre Zeit

Answer 1

Sie haben nach zwei verschiedenen Dingen gefragt, 'schneller laufen' und 'gleichzeitige Bewegung simulieren'. Ich glaube, wir können beide (separat) aber ich nicht glaube, dass tracer() und update() sind die Antwort in dieser Situation, da sie nur ein Pflaster sein würden, um über das eigentliche Problem zu decken.

will sehen, wie das Programm unter möglicherweise schneller

Wenn Sie es schneller ausführen möchten laufen konnte, fixieren Sie die Engpass, die die petal() Funktion ist. Ersetzen Sie es durch etwas, das die eingebaute Funktion circle() der Schildkröte verwendet, die schneller ist. Zum Beispiel:

def petal(self): 
    self.circle(-60, 90) 
    self.rt(90) 
    self.circle(-60, 90) 

Dies beschleunigt den Code um einen Faktor von 25X ohne weitere Änderungen auf.

simulieren gleichzeitige Bewegung der Schildkröten

Dies kann mit Schildkröte eigenen ontimer() Event Hander und einigen sorgfältige Programmierung erfolgen.Überraschenderweise nutzen wir Ihre ursprüngliche petal() Logik, wie es die Grafiken in Minutenschritten aufbricht, zwischen denen wir die Verarbeitung zu einem anderen terminiertes Ereignis ausschalten kann:

from random import randint 
from turtle import Turtle, Screen 

class MyTurtle(Turtle): 

    def petals(self, size=30, count=8, speed=100): 
     if size == 30: 
      self.begin_fill() 

     if size > 0: # drawing leading edge of petal 
      self.fd(3) 
      self.rt(3) 

      screen.ontimer(lambda: self.petals(size - 1, count, speed), speed) 
      return 

     if size == 0: # switch to other edge of petal 
      self.rt(90) 

     if size > -30: # drawing trailing edge of petal 
      self.fd(3) 
      self.rt(3) 

      screen.ontimer(lambda: self.petals(size - 1, count, speed), speed) 
      return 

     self.end_fill() # finish this petal 
     self.lt(230) # prepare for the next petal 

     if count > 0: # drawing the next petal 
      screen.ontimer(lambda: self.petals(count=count - 1, speed=speed), speed) 
      return 

     self.hideturtle() # finished drawing 

    def stem(self): 
     self.pencolor('green') 
     self.fd(250) 

    def flowerhead(self): 
     self.pencolor('red') 

     self.petals(speed=randint(50, 250)) 

def flower2(): 
    tony.color('green', 'purple') 
    tony.penup() 
    tony.goto(0, -200) 
    tony.pendown() 
    tony.showturtle() 
    tony.goto(80, -15) 
    tony.rt(40) 
    tony.flowerhead() 

def flower3(): 
    tina.color('green', 'turquoise') 
    tina.penup() 
    tina.goto(0, -200) 
    tina.pendown() 
    tina.showturtle() 
    tina.goto(-80, -15) 
    tina.lt(40) 
    tina.flowerhead() 

def flower5(): 
    tweeny.color('green', 'pink') 
    tweeny.penup() 
    tweeny.goto(0, -200) 
    tweeny.pendown() 
    tweeny.showturtle() 
    tweeny.goto(-160, -25) 
    tweeny.lt(40) 
    tweeny.flowerhead() 

tony = MyTurtle(shape='turtle', visible=False) 
tina = MyTurtle(shape='turtle', visible=False) 
tweeny = MyTurtle(shape='turtle', visible=False) 

screen = Screen() 

screen.ontimer(flower2, 100) 
screen.ontimer(flower3, 120) 
screen.ontimer(flower5, 100) 

screen.mainloop() 

RUNNING IMAGE

Es wird nicht schneller sein, da es nur eine Simulation ist. (Nun, es geht ein wenig schneller, als ich die Blütenblattzeichnung als Reaktion auf die Geschwindigkeit etwas gröber machte.) Wenn man genau hinsieht, kann man sehen, dass sich die Schildkröten (absichtlich) in ihrer eigenen Geschwindigkeit bewegen.

Answer 2

Die Lösung ist disable updating the position of each turtle und erzwingen Sie dann die Aktualisierung des gesamten Bildschirms, sobald die neue Position berechnet wurde.

import turtle 

# our two turtle instances 
first, second = turtle.Turtle(), turtle.Turtle() 

first.tracer(False) # disable updating view on screen for this turtle! 
second.tracer(False) 

# make one move - note this will not appear on screen. 
first.forward(50) 
second.left(20) 

# when you are ready to see the whole screen update 
turtle.update() 

tun, was Sie wollen, müssen Sie im Wesentlichen machen, so dass jede neue Aktion vor einem turtle.update() erfolgt. Sie können es nicht wie jetzt in einer seriellen Ausführung beibehalten - mit anderen Worten, Sie können flower1, dann flower2 nicht nacheinander ausführen.

Hier ist ein Beispiel eines Paares von Schildkröten, die ein zufälliges Muster auf dem Bildschirm zur gleichen Zeit generieren:

import turtle 
import random 

# our two turtle instances 
turtles = [turtle.Turtle(), turtle.Turtle()] 
for turtle_object in turtles: 
    turtle_object.tracer(False) 

for _ in range(10000): # make ten thousand moves. 

    for t in turtles: 
     # list the possible moves available 
     possible_moves = [t.forward, t.back, t.right, t.left] 
     # give it a random value 
     random_value = random.randint(0, 100) 
     # make a random move 
     random.choice(possible_moves)(random_value) 

    # update the whole screen now that the new positions have been calculated 
    turtle.update() 

Der hier Trick ist zu beachten, dass jede neue Position für jede Schildkröte berechnet , dann wird der Bildschirm als Ganzes aktualisiert, und erst dann geht es weiter zum nächsten Zug. Jede Bewegung muss so granular wie möglich sein.