如何在Python中建模共享几何对象（点、射线、直线）以避免数据重复？

你的问题本质是如何在面向对象设计中表示多对多的从属关系，同时避免数据冗余和不合理的所有权绑定——这在几何建模里是非常常见的场景，因为现实中的几何实体（比如点）本来就是独立的，可以同时属于多个更高层的对象（线、射线）。

你的当前设计用了“嵌套持有”的方式，让Line和Ray直接存储Point实例，这就导致了同一个Point被多次存储的问题。下面是一个更合理的方案，核心思路是把每个几何实体作为独立存在的对象，用双向关联+中央注册表来管理它们之间的关系：

1. 核心设计思路 #

• 所有几何对象（Point/Line/Ray）都只实例化一次，存储在一个中央注册表中，确保全局唯一。
• 放弃“父对象持有子对象实例”的嵌套结构，改为双向引用记录关联关系：比如Point记录它属于哪些Line/Ray，Line记录它包含哪些Point/Ray，Ray记录它的父Line和包含的Point。
• 提供专门的方法来建立/解除关联，保证双向引用的一致性（比如把Point添加到Ray时，同时把Ray添加到Point的关联列表里）。

2. 修改后的代码示例 #

class GeometryRegistry:
    """中央注册表，存储所有几何对象，确保每个对象唯一"""
    def __init__(self):
        self.points = {}
        self.lines = {}
        self.rays = {}
    
    def add_point(self, point):
        if point.name not in self.points:
            self.points[point.name] = point
    
    def add_line(self, line):
        if line.name not in self.lines:
            self.lines[line.name] = line
    
    def add_ray(self, ray):
        if ray.name not in self.rays:
            self.rays[ray.name] = ray

class Point:
    """独立的点实体，记录它关联的线和射线"""
    def __init__(self, name, registry):
        self.name = name
        self.registry = registry
        self.lines = set()  # 存储该点所属的Line对象
        self.rays = set()   # 存储该点所属的Ray对象
        registry.add_point(self)
    
    def __str__(self):
        lines_str = ", ".join([line.name for line in self.lines])
        rays_str = ", ".join([ray.name for ray in self.rays])
        return f"Point {self.name} | Lines: {lines_str or 'None'} | Rays: {rays_str or 'None'}"

class Line:
    """独立的线实体，记录它包含的点和射线"""
    def __init__(self, name, registry):
        self.name = name
        self.registry = registry
        self.points = set()  # 存储线上的Point对象
        self.rays = set()    # 存储线上的Ray对象
        registry.add_line(self)
    
    def add_point(self, point):
        """将点关联到这条线，同时更新点的反向引用"""
        if point not in self.points:
            self.points.add(point)
            point.lines.add(self)
    
    def add_ray(self, ray):
        """将射线关联到这条线，同时更新射线的父线引用"""
        if ray not in self.rays:
            self.rays.add(ray)
            ray.set_parent_line(self)
    
    def __str__(self):
        points_str = "\n  - ".join([p.name for p in self.points])
        rays_str = "\n  - ".join([r.name for r in self.rays])
        output = f"Line {self.name}:\n"
        if points_str:
            output += f"  Points:\n  - {points_str}\n"
        if rays_str:
            output += f"  Rays:\n  - {rays_str}\n"
        return output

class Ray:
    """独立的射线实体，记录它的父线和包含的点"""
    def __init__(self, name, registry):
        self.name = name
        self.registry = registry
        self.parent_line = None  # 射线所属的Line对象
        self.points = set()      # 射线上的Point对象
        registry.add_ray(self)
    
    def set_parent_line(self, line):
        """设置射线的父线，确保一条射线只属于一条线"""
        self.parent_line = line
    
    def add_point(self, point):
        """将点关联到这条射线，同时更新点的反向引用"""
        if point not in self.points:
            self.points.add(point)
            point.rays.add(self)
    
    def __str__(self):
        parent_str = self.parent_line.name if self.parent_line else "None"
        points_str = ", ".join([p.name for p in self.points])
        return f"Ray {self.name} | Parent Line: {parent_str} | Points: {points_str or 'None'}"

# 初始化注册表
registry = GeometryRegistry()

# 创建对象（自动注册到全局注册表）
L = Line("L", registry)
P = Point("P", registry)
R = Ray("R", registry)

# 建立关联
L.add_point(P)
R.add_point(P)
L.add_ray(R)

if __name__ == "__main__":
    print("=== Line L Details ===")
    print(L)
    print("\n=== Point P Details ===")
    print(P)
    print("\n=== Ray R Details ===")
    print(R)

3. 代码说明 #

• 中央注册表：GeometryRegistry确保每个名称的对象只存在一次，避免重复实例化。
• 双向引用：每个对象都记录自己的关联对象，比如Point.lines保存所有包含该点的线，Line.points保存该线上的所有点，这样从任何一端都能查询关联关系。
• 关联方法：add_point、add_ray这类方法负责同时更新双向引用，保证数据的一致性——比如把P添加到L时，既把P加入L的points集合，也把L加入P的lines集合。
• 合理的所有权：射线只能属于一条线（符合几何定义），但点可以属于多个线和射线，完全符合现实的几何概念。

4. 运行输出 #

=== Line L Details ===
Line L:
  Points:
  - P
  Rays:
  - R

=== Point P Details ===
Point P | Lines: L | Rays: R

=== Ray R Details ===
Ray R | Parent Line: L | Points: P

可以看到，Point P只实例化了一次，同时关联到Line L和Ray R，没有任何数据冗余，而且所有关联关系都能清晰查询。

这种设计也很容易扩展，比如后续添加Circle、Segment等几何对象，只需要在注册表中添加对应的存储结构，在对象类中添加对应的关联集合和方法即可。

内容的提问来源于stack exchange，提问作者Jasper