Donc, je suis un débutant récent en python et pour ma classe, je suis chargé de faire une course de tortues avec 10 tortues qui bougent toutes et devraient s'arrêter à la ligne d'arrivée. On m'a donné des instructions pour faire une liste des tortues et avoir une boucle while pour les faire déplacer un montant aléatoire et une boucle if imbriquée pour vérifier le gagnant. J'ai du mal à faire bouger toutes les tortues en même temps, quand j'exécute mon code, il déplace les tortues une par une au lieu de toutes ensemble, des idées?
import turtle as trtl
import random as rand
zoomers = []
zom = [0,1,2,3,4,5,6,7,8,9]
tloc = -130
trtl.penup()
trtl.goto(-150, 150)
trtl.pendown()
trtl.goto(-150,-140)
trtl.penup()
trtl.goto(180,150)
trtl.pendown()
trtl.goto(180,-140)
trtl.hideturtle()
for z in zom:
zoom = trtl.Turtle("turtle")
zoom.penup()
zoom.goto(-150,-tloc)
tloc += 25
robux = rand.randrange(0,20)
zoomers.append(zoom)
for n in zoomers:
cash = 0
while cash < 100:
zoom.forward(robux)
cash = cash + 1
if zoom.xcor() == 180:
print("We have a winner!")
break```
5 Réponses :
Nous pouvons modéliser cela sans même utiliser la bibliothèque de turtle :
import turtle as trtl
import random
finishline = 30
twerbles = [(trtl.Turtle("turtle"), 0) for i in range(10)]
for i,(twerble,position) in enumerate(twerbles):
twerble.penup()
twerble.goto(-150,150 - i*25)
while True:
twerbles = [(twerble, position+random.randint(1,2)) for twerble, position in twerbles]
for twerble, position in twerbles:
twerble.forward(position)
winners = [twerble for twerble, position in twerbles if position >= finishline]
if winners:
break
[(0, 1), (1, 2), (2, 1), (3, 2), (4, 1), (5, 2), (6, 1), (7, 1), (8, 1), (9, 2)] [(0, 2), (1, 3), (2, 2), (3, 3), (4, 2), (5, 4), (6, 3), (7, 3), (8, 3), (9, 3)] [(0, 4), (1, 5), (2, 4), (3, 4), (4, 4), (5, 6), (6, 5), (7, 5), (8, 4), (9, 5)] [(0, 5), (1, 7), (2, 6), (3, 5), (4, 6), (5, 8), (6, 6), (7, 7), (8, 5), (9, 6)] [(0, 6), (1, 8), (2, 8), (3, 6), (4, 7), (5, 9), (6, 7), (7, 9), (8, 7), (9, 7)] [(0, 8), (1, 9), (2, 10), (3, 7), (4, 9), (5, 11), (6, 8), (7, 11), (8, 8), (9, 9)] [2, 5, 7] #winning turtles
se déplacer avec des tortues
import random
twerbles = list(zip(range(10), [0]*10)) #list of turtles all starting at position 0 (numbered 0-10)
finishline = 10 #the threshold they must pass
while True:
twerbles = [(twerble, position+random.randint(1,2)) for twerble, position in twerbles] #move each turtle up a random amount.
print(twerbles) #this can be removed if you dont want to see their positions as they go
winners = [twerble for twerble, position in twerbles if position >= finishline] #list of turtles that passed the threshold (if any)
if winners: print(winners); break #if there are winners print them and stop looping
Il n'y a pas de moyen direct de le faire, mais voici la meilleure chose à faire.
Créez un Screen tortue. Définissez son tracer() sur 0 et mettez à jour l'écran à chaque itération de la boucle. Cela peut devenir trop rapide, alors importez le sleep du module de time pour ralentir un peu les choses.
Exemple minimal:
from turtle import Turtle, Screen
from random import randrange
from time import sleep
wn = Screen()
wn.tracer(0)
t1 = Turtle('turtle')
t2 = Turtle('turtle')
t1.penup()
t2.penup()
t1.goto(-100, 50)
t2.goto(-100, -50)
while True:
sleep(0.1)
t1.forward(randrange(0, 20))
t2.forward(randrange(0, 20))
wn.update()
Vous devez créer une collection de tortues. Mouvement en boucle (une seule étape) pour chaque tortue jusqu'à ce qu'une tortue finisse.
Essayez ce code:
import turtle as trtl
import random as rand
zoomers = []
zom = [0,1,2,3,4,5,6,7,8,9]
tloc = -130
trtl.penup()
trtl.goto(-150, 150)
trtl.pendown()
trtl.goto(-150,-140)
trtl.penup()
trtl.goto(180,150)
trtl.pendown()
trtl.goto(180,-140)
trtl.hideturtle()
zoomers = [trtl.Turtle("turtle") for z in zom]
for i,t in enumerate(zoomers):
t.penup()
t.goto(-150,150 - i*25)
for i,z in enumerate(zom):
zoom = zoomers[i] #trtl.Turtle("turtle")
tloc += 25
# zoomers.append(zoom)
running = True
while running:
for zoom in zoomers:
robux = rand.randrange(0,20)
zoom.forward(robux)
if zoom.xcor() >= 180:
print("We have a winner!")
running = False
break
input('Press enter to exit...')
Vous utilisez une seule tortue. Vous pouvez facilement le faire en créant plusieurs objets tortue. J'ai utilisé 3 objets tortues et ils ont une petite race.
Essayez ce code et vous pouvez implémenter votre logique gagnant dans ce code.
import turtle as trtl import random as rand zoom1 = trtl.Turtle() zoom2 = trtl.Turtle() zoom3 = trtl.Turtle() zoomers = [zoom1, zoom2, zoom3] for zoom in zoomers: zoom.penup() zoom1.goto(-150, 150) zoom2.goto(-120, 150) zoom3.goto(-90, 150) for zoom in zoomers: zoom.pendown() zoom.right(90) for zoom in zoomers: robux = rand.randrange(10,50) zoom.forward(robux)
Edit : Vous avez besoin d'un code non bloquant pour implémenter des tortues se déplaçant simultanément et indépendamment les unes des autres. Vous pouvez le faire en utilisant le multi-threading. Essayez ceci .
@AnnZen Je pense déplacer les tortues simultanément, implémenter le multi-threading et démarrer ces tortues? Parce que les exécuter tous en boucle, c'est bloquer la prochaine tortue. Pouvez-vous suggérer quelque chose de plus simple?
Oui, mais la mise à jour de l'écran à chaque itération est précise. Le problème est toujours que les tortues se déplacent une à une, leur mouvement n'est pas indépendant les uns des autres. J'ai trouvé ça au fait
Toutes les autres solutions jusqu'à présent déplacent les tortues sur une distance aléatoire dans une tranche de temps fixe. Retournons cela et déplaçons les tortues sur une distance constante dans une tranche de temps aléatoire:
from turtle import Turtle, Screen
from random import randrange
def run(turtle):
turtle.forward(5)
if turtle.xcor() < half_width:
screen.ontimer(lambda: run(turtle), randrange(20, 150))
screen = Screen()
half_width = screen.window_width() / 2
lane_width = 20
for order, color in enumerate(['red', 'green', 'blue']):
turtle = Turtle('turtle')
turtle.speed('fastest')
turtle.color(color)
turtle.penup()
turtle.goto(-half_width, (order | 1) * lane_width)
lane_width *= -1
run(turtle)
screen.exitonclick()
Supposez-vous qu'elles se déplacent en parallèle, par exemple si deux tortues atteignent la ligne d'arrivée dans la même itération en boucle, elles sont toutes les deux gagnantes? ou ira-t-il dans l'ordre, par exemple, la tortue trouvée pour la première fois au-delà du seuil l'emporte
Veuillez fournir l' exemple minimal et reproductible attendu. Montrez où les résultats intermédiaires diffèrent de ce que vous attendiez. Nous devrions être en mesure de copier et coller un bloc contigu de votre code, d'exécuter ce fichier et de reproduire votre problème avec le traçage de la sortie pour les points problématiques. Cela nous permet de tester nos suggestions par rapport à vos données de test et à la sortie souhaitée. «Cela ne fait pas ce que je veux» ne suffit pas, dans ce cas.
On ne sait pas exactement comment vous vous attendez à ce que cela fonctionne. Il semble que vous ayez écrit environ 30 lignes de code avant de le tester. Veuillez décrire correctement votre approche: vos boucles triple imbriquées (pendant un certain temps) semblent aller à l'encontre du résultat souhaité. Votre
whileen boucle est simplement une boucle de 100 itération; que faites-vous et pourquoi n'avez-vous pas utilisé unfor? Je crains que "résoudre" votre problème décrit impliquerait d'écrire le corps principal de votre programme pour vous, ce qui est hors de portée ici.Je dois utiliser une instruction while pour les faire avancer d'un montant aléatoire, et la boucle while étant à 100 est quelque chose que j'ai mis qui sera probablement changé en quelque chose de plus bas.