Pygame problème simulation orbite

Question

J'ai récemment été faire un simulateur d'orbite en utilisant cette équation:

Voici mon code:

import pygame, math 
from pygame.locals import * 
from random import randint 
pygame.init() 
screen = pygame.display.set_mode([500,500]) 
clock = pygame.time.Clock() 

class Planet(): 
    def __init__(self, vel = [1, 1], mass = 100000, pos = [100, 100], pathLength = 100000): 
     self.v = vel 
     self.m = mass 
     self.size = mass/1000000 
     self.pos = pos 
     self.pL = pathLength 
     self.path = [[pos[0], pos[1]]] 

    def update(self): 
     self.pos[0] += self.v[0] 
     self.pos[1] += self.v[1] 
     self.path.append([self.pos[0], self.pos[1]]) 
     if len(self.path) == self.pL: 
      self.path.pop(0) 

class World(): 
    def __init__(self, planetList, iterations, mass = 10000000, gravityConstant = (6 * 10 ** -9)): 
     self.plnt = planetList 
     self.iter = iterations 
     self.mass = mass 
     self.size = int(mass/1000000) 
     self.gC = gravityConstant 
    def draw(self): 
     pygame.draw.circle(screen, [0, 0, 0], [250, 250], self.size) 
     for p in self.plnt: 
      pygame.draw.rect(screen, [0, 0, 0], [p.pos[0], p.pos[1], p.size, p.size]) 
      pygame.draw.lines(screen, [0, 0, 0], False, p.path) 
    def update(self): 
     for i in range(self.iter): 
      for p in self.plnt: 
       d = math.sqrt((p.pos[0] - 250) ** 2 + (p.pos[1] - 250) ** 2) 
       f = (self.gC * self.mass * p.m)/(d ** 2) 
       vect = [((250 - p.pos[0])/d) * f, ((250 - p.pos[1])/d) * f] 
       p.v[0] += vect[0] 
       p.v[1] += vect[1] 
       p.update() 
     self.draw() 


a = Planet([4,0]) 
b = Planet([4, 0]) 
w = World([b], 100) 
while 1: 
    screen.fill([255, 255, 255]) 

    w.update() 

    for event in pygame.event.get(): 
     if event.type == QUIT: 
      pygame.quit() 

    pygame.display.update() 
    clock.tick(60) 

Si j'ai juste 1 planète dans la simulation, il fonctionne comme prévu, mais avec cela, il a des problèmes

a = Planet([4,0]) 
b = Planet([4, 0]) 
w = World([a, b], 100) 

les planètes volent hors de l'écran et continuer pour toujours, je ne vois pas où je l'ai fait une erreur.

Answer 1

Vous êtes tombé pour l'ancien piège Python de déclarer des arguments par défaut mutables. :)

Pour couper à la chasse afin que vous puissiez obtenir votre travail de code, copiez les remplacements que j'ai fait ci-dessous dans votre propre code:

class Planet(): 
    def __init__(self, vel = [1, 1], mass = 100000, pos = [100, 100], pathLength = 100000): 
     self.v = vel[:] # Added [:] to ensure the list is copied 
     self.m = mass 
     self.size = mass/1000000 
     self.pos = pos[:] # Added [:] here for the same reason 
     self.pL = pathLength 
     self.path = [[pos[0], pos[1]]] 

Explication

En Python, les listes mutable - vous pouvez modifier la même instance d'une liste. Une erreur courante que les gens font lors de l'utilisation de Python est de déclarer les arguments mutables comme valeurs par défaut dans les signatures de fonctions.

Le problème est que Python attribue cette valeur par défaut une fois au paramètre au moment où la définition de la fonction est traitée, puis réutilisation que la valeur attribuée à chaque fois que la fonction est invoquée et l'argument par défaut appelé .

Dans votre constructeur de la classe Planet, vous êtes en déclarant deux arguments par défaut mutables:

• vel = [1, 1]
• pos = [100, 100]

Chaque instance de Planet vous créez stocker une référence à ces listes, mais notez que à cause de ce que j'ai dit ci-dessus, chaque planète partagera le mêmevel liste et même listepos. Cela signifie que chaque instance interfère avec les données de vitesse et de position des autres.

Vous pouvez en savoir plus sur ce gotcha here.

Une manière alternative et préférée des situations de manipulation comme celui-ci serait de définir la valeur par défaut comme None puis attribuez-lui la valeur par défaut « réelle » si l'appelant ne fournit pas une valeur explicite pour elle:

class Planet(): 
    def __init__(self, vel = None, mass = 100000, pos = None, pathLength = 100000): 
     self.v = vel or [1, 1] 
     self.m = mass 
     self.size = mass/1000000 
     self.pos = pos or [100, 100] 
     self.pL = pathLength 
     self.path = [[self.pos[0], self.pos[1]]] 

Vous devrez alors documenter ce comportement de la fonction, car cela ne serait pas apparent à l'appelant autrement.