在 python 中创建具有多个可变向量属性的类

Question

类方法是否正确使用？

我正在开发一个程序来为 3-D N 体问题创建数据输入。目标是创建一个具有 50000 个粒子的均匀密度球体。每个粒子类实例必须具有质量、位置和速度。位置矢量必须是球形的，因此当创建粒子实例时，它位于半径为 1 的球体内。速度必须在 3 个方向上随机化。这将在稍后通过添加轨道速度进行更改。所有数据稍后将导出到 3 个列表中，质量、位置和速度均采用笛卡尔坐标。

我无法创建具有此类属性的粒子。

第一次运行的代码是：

import math
import numpy as np

class Particle:

    def__init__(self,mass,position,velocity):
        self.mass = 1/50000
        self.position = position
        self.velocity=velocity

    def position(self):
        self.position = (self.r, self.theta, self.phi)

    @classmethod
    def set_r(cls, r):
        cls.r = np.rand.uniform(0,1)

    @classmethod
    def set_theta(cls, theta):
        cls.theta = np.rand.uniform(-(math.pi)/2 ,(math.pi)/2)

    @classmethod
    def set_phi(cls, phi):
        cls.phi = np.rand.uniform(0,2*math.pi)  

    def velocity(self):
        self.velocity = (self.Vx, self.Vy, self.Vz)

    @classmethod
    def set_Vx(cls, Vx):
        cls.Vx = np.rand.uniform(0,0.001)

    @classmethod
    def set_Vy(cls, Vy):
        cls.Vy = np.rand.uniform(0,0.001)

    @classmethod
    def set_Vz(cls, Vz):
        cls.Vz = np.rand.uniform(0,0.001)

在与 CS 部门的朋友交谈后，代码被编辑为：

import math
import numpy as np

class Particle():

    def __init__(self,mass,position,velocity):
        self.mass = 1/50000
        self.position = position[]
        self.velocity = velocity[]


    @classmethod
    def getPosition(cls):
        return [cls.r, cls.theta, cls.phi]

    @classmethod
    def set_r(cls, r):
        cls.position[0] = np.rand.uniform(0,1)

    @classmethod
    def set_theta(cls, theta):
        cls.position[1] = np.rand.uniform(-(math.pi)/2 ,(math.pi)/2)

    @classmethod
    def set_phi(cls, phi):
        cls.position[2] = np.rand.uniform(0,2*math.pi)  

    def getVelocity(cls):
        return [cls.Vx, cls.Vy, cls.Vz]

    @classmethod
    def set_Vx(cls, Vx):
        cls.velocity[0] = np.rand.uniform(0,0.001)

    @classmethod
    def set_Vy(cls, Vy):
        cls.velocity[1] = np.rand.uniform(0,0.001)

    @classmethod
    def set_Vz(cls, Vz):
        cls.velocity[2] = np.rand.uniform(0,0.001)

是否需要在 init 中定义向量的各个部分，然后使用类方法创建数组以供以后使用和更改？

编辑 1：该类将通过 for 循环运行，以创建 50000 个粒子，每个粒子具有相同的质量（归一化为 1/50000）、位置向量和速度向量。所以导出到一个列表中的.dat文件

Answer 1

如果我理解正确，我认为您在这里不需要classmethods，而是要单独处理每个Particle。如果我是正确的，我相信您正在寻找一个每个实例都知道它自己的类mass、position 和velocity。我创建了一个类似于你的类，但我使用namedtuples 来表示position 和velocity。

import math
import numpy as np
from collections import namedtuple

Position = namedtuple('Position', ('r', 'theta', 'phi'))
Velocity = namedtuple('Velocity', ('Vx', 'Vy', 'Vz'))

class Particle():
    #With 50,000 instances being created, I suggest using __slots__ if possible.
    #This will cut down some on memory consumption.
    __slots__ = ('mass', 'position', 'velocity')

    def __init__(self, *args, **kwargs):
        self.mass = kwargs.get('mass', None)
        self.position = kwargs.get('position', None)
        self.velocity = kwargs.get('velocity', None)

        #Note! This will automatically set random values if any
        #of mass, position, velocity are None when initialized
        #so this may need to be altered if this is undesired
        #this is just a skeleton example and if it works for you it works
        if not any((self.mass, self.position, self.velocity)):
              self.setup_random()

    def setup_random(self):
      self.mass = 1/1500
      self.position = Position(
          r = np.random.uniform(0,1),
          theta = np.random.uniform(-(math.pi)/2 ,(math.pi)/2),
          phi = np.random.uniform(0,2*math.pi)
      )
      self.velocity = Velocity(
          Vx = np.random.uniform(0,0.001),
          Vy = np.random.uniform(0,0.001),
          Vz = np.random.uniform(0,0.001)
      )

    def set_r(self, r):
        self.position = self.position.replace(r = r)

    def set_theta(self, theta):
        self.position = self.position.replace(theta = theta)

    def set_phi(self, phi):
        self.position = self.position.replace(phi = phi)  

    def set_Vx(self, Vx):
        self.velocity = self.velocity.replace(Vx = Vx)

    def set_Vy(self, Vy):
        self.velocity = self.velocity.replace(Vy = Vy)

    def set_Vz(self, Vz):
        self.velocity = self.velocity.replace(Vz = Vz)

    def __str__(self):
      return('Mass: {}\nPosition: {}\nVelocity: {}'.format(
          self.mass,
          self.position,
          self.velocity))

    def __repr__(self):
      return('Mass: {}\nPosition: {}\nVelocity: {}'.format(
          self.mass,
          self.position,
          self.velocity))

您可以在此处使用 Particle() 制作任意数量的粒子

p = Particle()
print(p)

然后打印出来：

Mass: 0.0006666666666666666
Position: Position(r=0.8122849235862195, theta=-0.060787026289457646, phi=3.415049614503205)
Velocity: Velocity(Vx=0.0006988289817776562, Vy=0.00040214068163074246, Vz=0.0003347218438727625)

感谢namedtuples，您也可以很容易地获得价值：

print(p.position.r)
#0.8122849235862195

您可以使用如下预定义的值来制作粒子：

p = Particle(
      mass = 2/5000,
      position = Position(r=1, theta = 2, phi = 3),
      velocity = Velocity(Vx = 4, Vy = 5, Vz = 6))
print(p)

结果：

Mass: 0.0004
Position: Position(r=1, theta=2, phi=3)
Velocity: Velocity(Vx=4, Vy=5, Vz=6)

您仍然需要 setter 方法来设置单个值，例如 r、theta...，因为元组是不可变的，尽管您也可以轻松设置全新的位置 Ex ：

#to set an individual value
p.set_r(1)

#setting a whole new position/velocity
p.position = Position(r = 1, theta = 2, phi = 3)
#or
p.position = Position(r = p.position.r, theta = 2, phi = 3)
#as an example

如果您想使用不同的集合类型或其他任何东西，我认为namedtuples 很适合这里。

编辑

允许从数据文件加载和卸载；你可以创建to_json 和from_json 方法。

假设您的一个粒子的数据如下所示：

d = {'mass': 0.0006666666666666666,
     'r': 0.8122849235862195,
     'theta': -0.060787026289457646,
     'phi': 3.415049614503205,
     'Vx': 0.0006988289817776562,
     'Vy': 0.00040214068163074246,
     'Vz': 0.0003347218438727625
}

您的方法如下所示：

def to_json(self):
    json_particle = {'mass': self.mass}
    json_particle.update(dict(self.position._asdict()))
    json_particle.update(dict(self.velocity._asdict()))

    return json_particle

#here we finally use @classmethod
#as we are creating a new instance of the class
@classmethod
def from_json(cls, data):
    pos = Position(r = data['r'], theta = data['theta'], phi = data['phi'])
    vel = Velocity(Vx = data['Vx'], Vy = data['Vy'], Vz = data['Vz'])

    return cls(data['mass'], pos, vel)