Python中FontFile与FontFace类循环引用的解决及重构咨询

问题描述 #

我有两个存在循环引用的Python类，关系如下：

• FontFile类包含多个FontFace类（一对多关系）；
• FontFace类关联一个FontFile类。

是否需要重构代码以消除这两个类之间的循环引用？若需要，该如何操作？目前毫无思路。

注：FontFaceList可确保FontFace类的font_file属性始终被正确设置。

现有代码 #

FontFile及FontFaceList实现 #

from __future__ import annotations
from .factory_font_face import FactoryFontFace
from os import PathLike
from os.path import realpath
from time import time
from typing import Iterable, TYPE_CHECKING

if TYPE_CHECKING:
    from .font_face import FontFace


class FontFaceList(list):
    def __init__(self: FontFaceList, font_file: FontFile, font_faces: Iterable[FontFace]):
        self.font_file = font_file
        for font_face in font_faces:
            if not isinstance(font_face, FontFace):
                raise TypeError(f"The value is not of type {FontFace}")

            font_face.font_file = self.font_file
        super().__init__(font_faces)


    def append(self: FontFaceList, value: FontFace):
        if not isinstance(value, FontFace):
            raise TypeError(f"The value is not of type {FontFace}")

        value.font_file = self.font_file
        super().append(value)

    def extend(self: FontFaceList, iterable):
        for font_face in iterable:
            if not isinstance(font_face, FontFace):
                raise TypeError(f"The value is not of type {FontFace}")
            font_face.font_file = self.font_file
        super().extend(iterable)

    def insert(self: FontFaceList, i, value: FontFace):
        if not isinstance(value, FontFace):
            raise TypeError(f"The value is not of type {FontFace}")

        value.font_file = self.font_file
        super().insert(i, value)


class FontFile:

    def __init__(
        self: FontFile,
        filename: PathLike[str],
        font_faces: Iterable[FontFace],
        last_loaded_time: float = time()
    ) -> FontFile:
        self.filename = realpath(filename)
        self.font_faces = FontFaceList(self, font_faces)
        self.last_loaded_time = last_loaded_time


    @classmethod
    def from_font_path(cls: FontFile, filename: PathLike[str]) -> FontFile:
        font_faces = FactoryFontFace.from_font_path(filename)
        return cls(filename, font_faces)

FontFace实现 #

from __future__ import annotations

from .name import Name
from typing import List, Optional, TYPE_CHECKING

if TYPE_CHECKING:
    from .font_file import FontFile

class FontFace():

    def __init__(
        self: FontFace,
        font_index: int,
        family_names: List[Name],
        exact_names: List[Name],
        weight: int,
        is_italic: bool,
        is_glyph_emboldened: bool,
        font_type: FontType,
        font_file: Optional[FontFile] = None,
    ) -> FontFace:
        self.font_index = font_index
        self.family_names = family_names
        self.exact_names = exact_names
        self.weight = weight
        self.is_italic = is_italic
        self.is_glyph_emboldened = is_glyph_emboldened
        self.font_type = font_type
        self.font_file = font_file

分析与结论 #

首先明确：你当前的代码已经通过TYPE_CHECKING和from __future__ import annotations解决了编译时的循环引用问题，这种写法在Python里是完全合法且被官方推荐的。

是否需要重构？ #

• 如果只是为了避免循环引用本身，不需要。运行时不会出现依赖问题，且双向关联的设计符合你业务上的一对多关系需求。
• 如果是为了简化代码结构、降低类之间的耦合度，或者后续有独立复用FontFace的需求，则可以考虑重构。

可选重构方案 #

方案1：保留双向关联，简化重复代码 #

你的FontFaceList逻辑已经很完善，只是存在重复的类型检查和属性赋值逻辑，可以抽成私有方法简化：

class FontFaceList(list):
    def __init__(self, font_file: FontFile, font_faces: Iterable[FontFace]):
        self.font_file = font_file
        self._validate_and_bind_face(font_faces)
        super().__init__(font_faces)

    def _validate_and_bind_face(self, items: Iterable[FontFace]):
        for item in items:
            if not isinstance(item, FontFace):
                raise TypeError(f"值必须是{FontFace}类型")
            item.font_file = self.font_file

    def append(self, value: FontFace):
        self._validate_and_bind_face([value])
        super().append(value)

    def extend(self, iterable):
        self._validate_and_bind_face(iterable)
        super().extend(iterable)

    def insert(self, i, value: FontFace):
        self._validate_and_bind_face([value])
        super().insert(i, value)

方案2：消除双向关联，改为单向引用 #

如果业务逻辑不需要从FontFace反向访问FontFile，可以直接去掉FontFace的font_file属性：

• FontFile依然持有FontFace列表；
• 若FontFace需要访问FontFile的信息，可通过函数参数传递的方式获取，而非保存引用。

这种方案适合不需要反向访问的场景，能彻底消除循环依赖。

方案3：引入中间层解耦（适合复杂项目） #

如果需要保留双向访问能力，但想降低类之间的耦合，可以引入一个中间管理类：

class FontManager:
    def __init__(self):
        self._file_map: dict[str, FontFile] = {}
        self._face_to_file: dict[FontFace, FontFile] = {}

    def register_font_file(self, font_file: FontFile):
        self._file_map[font_file.filename] = font_file
        for face in font_file.font_faces:
            self._face_to_file[face] = font_file

    def get_font_file(self, face: FontFace) -> FontFile:
        return self._face_to_file[face]

然后修改FontFace，去掉font_file属性，需要时通过FontManager获取对应的FontFile。这种方式解耦了两个类，但增加了一层管理逻辑，适合大型项目。

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