Python中实现多DataFrame联动的方法：一个的变换自动同步到其他

这个需求我太懂了！想要让两个DataFrame的结构/元素变换自动同步，Pandas本身确实没有内置这种“绑定联动”的功能（毕竟DataFrame设计成独立的数据容器，自动联动容易引入意外的副作用），但我们可以用几种巧妙的方法实现，我给你拆解一下～

方法1：封装同步函数，显式处理联动 #

这是最直接的入门方法：每次对其中一个DataFrame做变换时，先记录下变换的规则（比如排序后的元素索引顺序），再把这个规则套用到另一个DataFrame上。

拿你的示例场景来说，对df1的第0行按值降序排序，然后同步df2的第0行，代码可以这么写：

import pandas as pd

# 先创建示例中的两个DataFrame
data1 = {'A': [1, 4, 7], 'B': [2, 5, 8], 'C': [3, 6, 9]}
df1 = pd.DataFrame(data1)
data2 = {'A': ['apple', 'banana', 'cherry'], 'B': ['dog', 'elephant', 'fox'], 'C': ['grape', 'honeydew', 'kiwi']}
df2 = pd.DataFrame(data2)

# 封装一个同步排序行的函数
def sort_row_sync(source_df, target_df, row_idx, ascending=False):
    # 对源df的指定行排序，拿到排序后的元素原索引顺序
    sorted_row = source_df.iloc[row_idx].sort_values(ascending=ascending)
    # 重排源df的该行
    source_df.iloc[row_idx] = sorted_row.values
    # 用同样的索引顺序重排目标df的该行
    target_df.iloc[row_idx] = target_df.iloc[row_idx][sorted_row.index].values

# 调用函数：对df1的第0行降序排序，自动同步df2
sort_row_sync(df1, df2, row_idx=0, ascending=False)

# 查看结果
print("排序后的df1：")
print(df1)
print("\n同步后的df2：")
print(df2)

运行后就能得到你想要的效果，逻辑清晰，新手也能快速上手。

方法2：自定义类封装，实现“一键联动” #

如果需要频繁做这类联动操作，把逻辑封装成一个自定义类会更优雅，使用起来就像操作绑定好的对象一样，不用每次手动调用同步函数。

比如我们写一个LinkedDataFrames类，把两个DataFrame绑定在一起，类里的方法会自动处理同步逻辑：

import pandas as pd

class LinkedDataFrames:
    def __init__(self, df1, df2):
        # 复制传入的DataFrame，避免修改原数据
        self.df1 = df1.copy()
        self.df2 = df2.copy()
        # 校验两个df的形状必须一致，不然没法联动
        assert self.df1.shape == self.df2.shape, "两个DataFrame的形状必须完全一致！"
    
    def sort_row(self, row_idx, ascending=False, from_df='df1'):
        # 确定源df（触发变换的对象）和目标df（同步的对象）
        if from_df == 'df1':
            src, target = self.df1, self.df2
        elif from_df == 'df2':
            src, target = self.df2, self.df1
        else:
            raise ValueError("from_df只能是'df1'或'df2'哦")
        
        # 拿到排序后的行和对应的原索引顺序
        sorted_series = src.iloc[row_idx].sort_values(ascending=ascending)
        # 重排源df的该行
        src.iloc[row_idx] = sorted_series.values
        # 用同样的索引顺序同步目标df的该行
        target.iloc[row_idx] = target.iloc[row_idx][sorted_series.index].values
    
    # 还可以扩展其他联动方法，比如按列排序同步
    def sort_column(self, col_name, ascending=False, from_df='df1'):
        if from_df == 'df1':
            src, target = self.df1, self.df2
        else:
            src, target = self.df2, self.df1
        
        # 拿到排序后的行索引
        sorted_idx = src.sort_values(by=col_name, ascending=ascending).index
        # 重排源df并同步目标df
        self.df1 = src.loc[sorted_idx]
        self.df2 = target.loc[sorted_idx]

# 用法示例
if __name__ == "__main__":
    # 初始化示例df
    data1 = {'A': [1, 4, 7], 'B': [2, 5, 8], 'C': [3, 6, 9]}
    df1 = pd.DataFrame(data1)
    data2 = {'A': ['apple', 'banana', 'cherry'], 'B': ['dog', 'elephant', 'fox'], 'C': ['grape', 'honeydew', 'kiwi']}
    df2 = pd.DataFrame(data2)

    # 创建联动对象
    linked_dfs = LinkedDataFrames(df1, df2)
    
    # 对df1的第0行降序排序，自动同步df2
    linked_dfs.sort_row(row_idx=0, ascending=False, from_df='df1')
    
    print("排序后的df1：")
    print(linked_dfs.df1)
    print("\n同步后的df2：")
    print(linked_dfs.df2)

    # 试试按列排序的联动
    linked_dfs.sort_column(col_name='B', ascending=False, from_df='df1')
    print("\n按B列降序后的df1：")
    print(linked_dfs.df1)
    print("\n同步后的df2：")
    print(linked_dfs.df2)

这个类的好处是，所有联动逻辑都封装在内部，你只需要调用对应的方法就行，还能根据需求扩展更多功能，比如交换元素同步、批量行排序同步等等，非常灵活。

为什么不推荐用共享列表/字典？ #

你提到之前用元组实现，那共享列表或者字典行不行？其实不太方便：因为Pandas的DataFrame在创建时会复制输入的数据，修改原来的列表，df里的数据不会自动更新；就算用NumPy数组（引用类型），修改数组会同步到df，但联动另一个数组还是需要手动写逻辑，反而不如上面的方法清晰。

总结 #

如果只是偶尔需要同步，用方法1的封装函数就足够简单；如果需要频繁做各种联动操作，方法2的自定义类是最清晰、最易维护的选择。Pandas本身不支持自动联动，但通过这些自定义逻辑，完全能实现你想要的“绑定”效果～

备注：内容来源于stack exchange，提问作者Victorbug