Python中对象属性变更引发父级数据结构更新的策略与实践

import pandas as pd

class Dataframe_Builder_Update():
    def __init__(self, column_builders):
        self._column_builders = column_builders
        self.build_dataframe() # 初始构建DataFrame

    def build_dataframe(self):
        self.result_df = pd.DataFrame()
        for column_builder in self._column_builders:
            # 假设 column_builder 有 calculated_output 属性
            if not column_builder.group:
                self.result_df = pd.concat([self.result_df, column_builder.calculated_output], axis=0)
            elif column_builder.group:
                self.result_df = pd.concat([self.result_df, column_builder.calculated_output], axis=1)

    @property
    def column_builders(self):
        return self._column_builders

    @column_builders.setter
    def column_builders(self, new_column_builders):
        self._column_builders = new_column_builders
        self.build_dataframe() # 当整个 column_builders 列表被替换时触发

# 假设 my_arr 是一个包含 column_builder 对象的列表
# dataframe_builder_obj = Dataframe_Builder_Update(my_arr)
# print(dataframe_builder_obj.result_df) # 旧的DataFrame

# 修改 column_builder 列表中某个对象的属性
# [setattr(obj, 'date', '12/29/2019') for obj in dataframe_builder_obj.column_builders]

# 此时 dataframe_builder_obj.result_df 不会更新
# print(dataframe_builder_obj.result_df) # 仍然是旧的DataFrame

import pandas as pd

class Dataframe_Builder():
    def __init__(self, column_builders):
        self._column_builders = column_builders
        self._result_df = self._build_dataframe() # 初始构建并赋值给内部属性

    @property
    def column_builders(self):
        return self._column_builders

    @property
    def result_df(self):
        """提供对内部 _result_df 的只读访问"""
        return self._result_df

    @column_builders.setter
    def column_builders(self, new_column_builders):
        """当整个 column_builders 列表被替换时，触发更新"""
        self._column_builders = new_column_builders
        self.update_dataframe() # 列表变更时更新DataFrame

    def _build_dataframe(self):
        """私有方法，负责根据当前 column_builders 列表构建DataFrame"""
        result_df = pd.DataFrame()
        for obj in self._column_builders:
            # 假设 obj 具有 calculated_output 和 group 属性
            if not obj.group:
                result_df = pd.concat([result_df, obj.calculated_output], axis=0)
            elif obj.group:
                result_df = pd.concat([result_df, obj.calculated_output], axis=1)
        return result_df

    def update_dataframe(self):
        """公共方法，用于显式触发DataFrame的重新构建和更新"""
        self._result_df = self._build_dataframe()

class Table_Builder():
    def __init__(self, df_builders: list, stack_horizontal=None, stack_vertical=None):
        self.df_builders = df_builders # 包含 Dataframe_Builder 对象的列表
        self.stack_horizontal = stack_horizontal
        self.stack_vertical = stack_vertical

        self.result_df = self._build_table(self.stack_horizontal, self.stack_vertical)

    def _build_table(self, stack_horizontal=None, stack_vertical=None):
        """私有方法，根据 Dataframe_Builder 列表构建最终的表格"""
        result_df = pd.DataFrame()
        for obj in self.df_builders:
            # 假设 obj 是 Dataframe_Builder 实例，具有 result_df 属性
            if stack_vertical:
                result_df = pd.concat([result_df, obj.result_df], axis=0)
            elif stack_horizontal:
                result_df = pd.concat([result_df, obj.result_df], axis=1)
        return result_df

    def update_dates(self, new_date):
        """
        更新所有 Dataframe_Builder 及其内部 column_builder 的日期，
        并触发所有相关DataFrame的更新。
        """
        for df_obj in self.df_builders:
            for col_obj in df_obj.column_builders:
                # 假设 col_obj 有 'date' 属性
                setattr(col_obj, 'date', new_date)
            # 关键：更新 Dataframe_Builder 自身的 DataFrame
            df_obj.update_dataframe()

        # 最后，重建 Table_Builder 自身的 result_df
        self.result_df = self._build_table(self.stack_horizontal, self.stack_vertical)

# 假设 ColumnBuilder 类的简化版本
class ColumnBuilder:
    def __init__(self, name, date, group=False):
        self.name = name
        self._date = date
        self.group = group
        self._calculate_output()

    @property
    def date(self):
        return self._date

    @date.setter
    def date(self, new_date):
        self._date = new_date
        self._calculate_output() # 日期变化时重新计算输出

    def _calculate_output(self):
        # 模拟根据日期生成DataFrame列
        # 实际中这里会有更复杂的计算
        self.calculated_output = pd.DataFrame({
            self.name: [f"Value for {self.name} on {self.date}"]
        })

# 1. 创建 ColumnBuilder 对象
col_builder1 = ColumnBuilder('colA', '2023-01-01')
col_builder2 = ColumnBuilder('colB', '2023-01-01', group=True)

# 2. 创建 Dataframe_Builder 对象列表
df_builder1 = Dataframe_Builder([col_builder1])
df_builder2 = Dataframe_Builder([col_builder2])

my_df_builders = [df_builder1, df_builder2]

# 3. 创建 Table_Builder 对象
table_builder_obj = Table_Builder(my_df_builders, stack_horizontal=True)

print("初始 Table_Builder result_df:")
print(table_builder_obj.result_df)

# 4. 调用 Table_Builder 的 update_dates 方法来更新所有日期
table_builder_obj.update_dates('2023-03-30')

print("\n更新日期后的 Table_Builder result_df:")
print(table_builder_obj.result_df)