转载请注明出处：https://www.cnblogs.com/oceanicstar/p/9030121.html
想直接看结论先提前列出：
1、存储一个对象，文件不是真的给你存储的了对象这种东西，存储的都是一些代码而已。
具体是哪些代码呢？
想想看，我们保存对象的目的，是为了方便以后从文件里加载回来时，能让计算机自动帮你构建回之前的那个对象。那么文件里头会存储一些什么代码呢？
①要加载文件时，能够重构回之前的那个对象，至少能够实例化出这个对象的类的定义代码得存储到文件里头吧
②如果这个类继承了一些父类的东西，或者跟其他类有组合关系之类的blabla…那么这些类的定义代码也会储存到文件里头
③这个对象自己的属性和方法（在类定义之外自己定义的）得存储到文件里头吧
总之，一切目的都是为了重构时找到所有必须的素材（各种类、函数、变量的定义代码，还有相互之间的实例化、引用等关系），就跟只有集齐七颗龙珠才能召唤神龙一样……
2、我们将每个对象pickle到不同文件后再加载load回来时，pickle反序列化load加载回来都是重构了一个原来对象的副本，pickle文件里存储了构建出这些对象需要引用的类、方法、对象等引用关系。
3、如果想要加载回来后的对象组合关系还能对应上的话，是不能把这多个对象分开dump到不同文件的，必要要同时dump到一个文件内。
4、由于上述原因，实际应用中，我们要储存多个对象间的组合引用关系，往往需要使用字典/列表/元组等容器来盛放这些有组合关系的对象，然后将这个容器一次dump到一个文件中去。
——以下故事纯属虚构，如有雷同，怕是你转载我的吧！转载请注明出处，谢谢！
大海：我X，这选课系统咋这么难写啊，写了我10几天，老是有bug出来，明明我保存了老师、学员和班级间的组合关系，怎么加载回来进行值的更改，就不会相互自动关联地改变值了呢？
流星：要想讲明白pickle储存多个对象之间的组合关系问题，要先从一个面向对象的例子开始说起。。。
大海：啥例子？
流星：是一个简化了的例子，你看下面
class A:
def __init__(self, name):
self.name = name
self.b_list = [] class B:
def __init__(self, name):
self.name = name
self.a_list = [] # 各实例化一个对象
a1 = A('A类1号')
b1 = B('B类1号') # 打印 2个实例各自的列表属性
print('-------当前各自的列表属性-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list属性：', b1.a_list) # 在实例b1的列表属性中建立组合关系
b1.a_list.append(a1) # 打印对象组合关系
print('\n-------当前的组合关系-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list中的A对象的b_list属性：', b1.a_list[0].b_list) # pickle序列化保存到 2个文件里
import pickle
with open('a1.pk', 'wb') as f1:
pickle.dump(a1, f1)
with open('b1.pk', 'wb') as f2:
pickle.dump(b1, f2)
运行结果
-------当前各自的列表属性-------
a1的b_list属性： []
b1的a_list属性： [] -------当前的组合关系-------
a1的b_list属性： []
b1的a_list中的A对象的b_list属性： []
大海：哈哈，我看懂了，b1的a_list列表属性添加了a1对象，建立了组合关系！
流星：是的，而且我们还把a1对象和b1对象分别存到了文件里头
大海：（满怀自信地）对！都用的是pickle序列化dump到文件，再load回来的话，他们组合关系肯定还是在的吧！
流星：是吗？那么让我们来验证一下吧
import pickle class A:
def __init__(self, name):
self.name = name
self.b_list = [] class B:
def __init__(self, name):
self.name = name
self.a_list = [] # 将a1和b1加载回来
with open('a1.pk', 'rb') as f1:
a1 = pickle.load(f1)
with open('b1.pk', 'rb') as f2:
b1 = pickle.load(f2) # 打印对象组合关系
print('-------加载回来的组合关系-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list中的A对象的b_list属性：', b1.a_list[0].b_list) # 再实例化一个b2
b2 = B('B类2号')
a1.b_list.append(b2) # 打印对象组合关系
print('\n-------给a1列表属性添加b2后的组合关系-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list中的A对象的b_list属性：', b1.a_list[0].b_list)
运行结果
-------加载回来的组合关系-------
a1的b_list属性： []
b1的a_list中的A对象的b_list属性： [] -------给a1列表属性添加b2后的组合关系-------
a1的b_list属性： [<__main__.B object at 0x00000000025C2A90>]
b1的a_list中的A对象的b_list属性： []
大海：咦？怎么回事？我们不是已经建立了b1和a1间的组合关系吗？那b1中的a_list里的A类对象就应该是a1啊？
那么我们给a1对象的b_list属性列表添加上了对象b2（上面结果确实添加了一个B object对象），
同样的b1中的a_list里的A类对象的b_list属性不也应该添加上对象b2了吗，为啥上面结果打印结果还是个空列表 [ ] 呢？
额……不明白……
到底现在加载回来的a1对象，跟b1中的a_list里的那个A类对象还是同一个么？
流星：那我们打印a1对象和b1的a_list列表属性看看？
# 打印 a1对象
print('\na1对象：')
print(a1) # 打印 b1对象中a_list列表
print('b1对象的a_list列表：')
print(b1.a_list)
运行结果
a1对象：
<__main__.A object at 0x00000000025F24E0> b1对象的a_list列表：
[<__main__.A object at 0x000000000367D278>]
大海：#%&*#@（）&%#@，X！……果然不是同一个对象了！
怎么搞的，我们不是把a1和b1这2个对象都pickle了吗？组合关系怎么乱了呢？
流星：稍等片刻，答案即将揭晓。。。来条华丽的分割线吧
大海：这分割线一点都不华丽啊！
流星：……或许等我学完前端就华丽了吧
大海：……
流星：其实，这里首先要理解的是我们将每个对象pickle到不同文件后再加载load回来时，每个对象被恢复到一个与原来对象值相等的对象，但本质上不是同一个对象，而是重构了个新的对象。
换句话说，每次pickle反序列化load加载回来都是原来对象的一个副本，那么我们从把两个有组合关系的对象a1和b1分别用pickle序列化dump到两个文件里头就是不对的，这样加载回来的时候，a1和b1对象的属性也都是在各自文件load加载过程中独立复制生成的。
具体来解释，就是：
a1对象的b_list属性，在a1.pk文件load加载回来的过程，可以理解为：a1对象加载回来时，计算机开辟一个内存空间放a1对象，发现a1里头有个b_list属性啊，值是空列表[ ]，好的，那么给他开辟一个内存空间放这个空列表属性吧
b1对象的a_list属性里头有值，并且是个A类的实例对象（在保存到文件之前的程序里是a1），而在b1.pk文件load加载回来的过程中python重构了一个与A类的实例对象(但不是现在的a1了)间的组合关系，可以理解为：b1对象加载回来时，python要重构一个b1对象，发现b1里头有个a_list属性啊，值是个列表，里头居然还装了个A类的实例对象，但是这文件里头没有说明这个A类的实例对象是谁呀，只告诉我了有个b1对象要返回，这个A类的实例对象返回给谁呢？算了，给b1开辟一个内存空间放这个列表属性吧，并且去构造一个A类的新的实例对象，这样至少保留了b1的属性值不变吧，嗯！就这么干！
好了，这下a1对象和b1对象都各自加载完成了，但是这样计算机并没有把b1对象的a_list属性中的A类实例对象当成是a1来关联。。。
大海：那么，怎么才能在pickle序列化保存后，a1与b1间的组合关系还能加载回来呢？
流星：再来条华丽的……
大海：……
流星：其实，上面的pickle保存有个关键问题是，有组合关系的多个对象在pickle序列化保存到文件时，如果想要加载回来后的对象组合关系还能对应上的话，是不能把这多个对象分开dump到不同文件的！
这的原因就像上面解释的一样
大海：前面说的太啰嗦，我听不懂啊！
流星：……
大海：能简单用人话解释下可以吗？
流星：好吧，作为神的我就尽量……
大海：……
流星：其实，当a1和b1对象分开dump到不同的文件时，加载回来是分开独立加载的，因为pickle反序列化重构对象间的关系是在load方法执行时一次性加载回来生成的，所以在load加载回b1对象时（也就是运行b1 = pickle.load(f2)时），就独立地把b1对象的关系建立好了，即b1的a_list属性里头有组合关系需要关联的对象的那个A类的实例对象占用的内存地址也分配好了，这个过程是与运行 a1 = pickle.load(f1)相互独立的，毫无关系，所以load加载回a1对象的内存地址也是另外独立分配的，也就是说，现在加载回来的b1与a1对象已经没有组合关系了，跟b1有组合关系的是在运行b1 = pickle.load(f2)时，计算机在内存里自动生成的一个A类的实例对象，这个A类的实例对象被放在了b1的a_list属性列表里头。
流星：这下明白了吧……？
大海：好像有点点明白了……可是，那我该怎么做才能在文件里加载回a1与b1组合关系呢？
流星：那就再来一条华……
大海：别来了，算我求你了好嘛？
流星：好吧！那就最后再来一条吧！
大海：……
流星：答案是——把a1与b1dump到同一个文件里头！
大海：哦，我知道，pickle是可以多次dump到一个文件的！我们可以先把a1对象dump到文件里，然后再把b1对象也dump到同一个文件里头呗，然后load回来的时候，load两次对吧，我聪明吧？哈哈~
流星：拉倒吧，你去试试看，这样能还原回来我们要的组合关系吗？
大海：肯定行，你等着……这就运行给你看！
class A:
def __init__(self, name):
self.name = name
self.b_list = [] class B:
def __init__(self, name):
self.name = name
self.a_list = [] # 各实例化一个对象
a1 = A('A类1号')
b1 = B('B类1号') # 打印 2个实例各自的列表属性
print('-------当前各自的列表属性-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list属性：', b1.a_list) # 在实例b1的列表属性中建立组合关系
b1.a_list.append(a1) # 打印对象组合关系
print('\n-------当前的组合关系-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list中的A对象的b_list属性：', b1.a_list[0].b_list) # pickle序列化分两次dump到 1个文件里
import pickle
with open('a1b1.pk', 'wb') as f:
pickle.dump(a1, f)
pickle.dump(b1, f)
运行结果
-------当前各自的列表属性-------
a1的b_list属性： []
b1的a_list属性： [] -------当前的组合关系-------
a1的b_list属性： []
b1的a_list中的A对象的b_list属性： []
大海：嘿嘿，马上要load回来啦，看好了啊！
class A:
def __init__(self, name):
self.name = name
self.b_list = [] class B:
def __init__(self, name):
self.name = name
self.a_list = [] # 将a1和b1加载回来
import pickle
with open('a1b1.pk', 'rb') as f:
a1 = pickle.load(f)
b1 = pickle.load(f) # 打印对象组合关系
print('-------加载回来的组合关系-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list中的A对象的b_list属性：', b1.a_list[0].b_list) # 再实例化一个b2
b2 = B('B类2号')
a1.b_list.append(b2) # 打印对象组合关系
print('\n-------给a1列表属性添加b2后的组合关系-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list中的A对象的b_list属性：', b1.a_list[0].b_list) # 打印 a1对象
print('\na1对象：')
print(a1) # 打印 b1对象中a_list列表
print('\nb1对象的a_list列表：')
print(b1.a_list)
运行结果
-------加载回来的组合关系-------
a1的b_list属性： []
b1的a_list中的A对象的b_list属性： [] -------给a1列表属性添加b2后的组合关系-------
a1的b_list属性： [<__main__.B object at 0x00000000024A32B0>]
b1的a_list中的A对象的b_list属性： [] a1对象：
<__main__.A object at 0x0000000002571470> b1对象的a_list列表：
[<__main__.A object at 0x0000000002572A90>]
大海：我X，怎么还是不行啊！a1对象和b1.a_list里的那个A类实例对象还是不同！到底要怎么才行啊！啊！啊！
流星：大哥，别鸡冻……
大海：啊！啊！啊！解决不了问题，我就鸡冻！
流星：你鸡冻起来也别拍我行吗？我都快被你拍死了……
大海：啊！啊！啊！怎么回事啊！
流星：我直接告诉你行了吧= =！
大海：你倒是快讲啊！
流星：好好好……那就再来一条……
大海：%￥&#@*！￥&*
流星：别拍了，不来了……
大海：快说！
流星：其实答案就是——把a1与b1对象dump到同一个文件里头！……
大海：你大爷，刚刚不就是这么说的吗？
流星：那是因为我话还没说完呢，你就是没耐性，不等我把话说完你就吵着说明白了……
大海：那你继续说完啊！
流星：你别打断我……除了要把a1与b1对象dump到同一个文件里头，还要保证，是同一次dump命令序列化的
大海：说人话！
流星：= =！我的意思就是，可以把a1与b1合并成一个元组，这样就可以通过这个元组把a1与b1对象一次性dump到文件里了
大海：我X，这也行啊。。。我怎么没想到。。。
流星：是啊，不信我运行下你看看。先dump文件……
class A:
def __init__(self, name):
self.name = name
self.b_list = [] class B:
def __init__(self, name):
self.name = name
self.a_list = [] # 各实例化一个对象
a1 = A('A类1号')
b1 = B('B类1号') # 打印 2个实例各自的列表属性
print('-------当前各自的列表属性-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list属性：', b1.a_list) # 在实例b1的列表属性中建立组合关系
b1.a_list.append(a1) # 打印对象组合关系
print('\n-------当前的组合关系-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list中的A对象的b_list属性：', b1.a_list[0].b_list) # pickle序列化用元组1次dump到同1个文件
import pickle
with open('a1b1.pk', 'wb') as f:
pickle.dump((a1, b1), f)
流星：打印结果当然还是
-------当前各自的列表属性-------
a1的b_list属性： []
b1的a_list属性： [] -------当前的组合关系-------
a1的b_list属性： []
b1的a_list中的A对象的b_list属性： []
流星：再一次load回来
class A:
def __init__(self, name):
self.name = name
self.b_list = [] class B:
def __init__(self, name):
self.name = name
self.a_list = [] # 将a1和b1加载回来
import pickle
with open('a1b1.pk', 'rb') as f:
a1, b1 = pickle.load(f) # 打印对象组合关系
print('-------加载回来的组合关系-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list中的A对象的b_list属性：', b1.a_list[0].b_list) # 再实例化一个b2
b2 = B('B类2号')
a1.b_list.append(b2) # 打印对象组合关系
print('\n-------给a1列表属性添加b2后的组合关系-------')
print('a1的b_list属性：', a1.b_list)
print('b1的a_list中的A对象的b_list属性：', b1.a_list[0].b_list) # 打印 a1对象
print('\na1对象：')
print(a1) # 打印 b1对象中a_list列表
print('\nb1对象的a_list列表：')
print(b1.a_list)
运行结果
-------加载回来的组合关系-------
a1的b_list属性： []
b1的a_list中的A对象的b_list属性： [] -------给a1列表属性添加b2后的组合关系-------
a1的b_list属性： [<__main__.B object at 0x00000000025D2A90>]
b1的a_list中的A对象的b_list属性： [<__main__.B object at 0x00000000025D2A90>] a1对象：
<__main__.A object at 0x00000000025D1470> b1对象的a_list列表：
[<__main__.A object at 0x00000000025D1470>]
大海：我去，真的一样了！牛X！
流星：那必须的！这里同时把a1，b1对象dump到一个文件时，储存的组合关系是在这个文件里头的，再load出来返回给新程序的a1和b1对象，也是直接把组合关系指定重构给了新的a1和b1对象，没有再去单独开辟内存空间去生成其他的对象了
大海：原来是这样，厉害！
流星：哈哈，为了庆祝，再来条华丽的分割线吧？
大海：来吧，随便你来！
流星：其实再来个分割线是为了再举2个pickle序列化的例子的，或许看了下面2个例子，会更好地理解这个问题
大海：好！你发出来，我研究研究
流星：嗯，先看个列表对象“递归引用”的例子
大海：啥？“递归引用”？我瞅瞅……
>>> l = [1, 2, 3]
>>> l.append(l)
>>> l
[1, 2, 3, [...]]
>>> l[3]
[1, 2, 3, [...]]
>>> l[3][3]
[1, 2, 3, [...]]
>>> p = pickle.dumps(l)
>>> l2 = pickle.loads(p)
>>> l2
[1, 2, 3, [...]]
>>> l2[3]
[1, 2, 3, [...]]
>>> l2[3][3]
[1, 2, 3, [...]]
大海：我去，原来列表还能这么玩啊！？
流星：是啊，看过“递归引用”了，那么也能有点接受下面这个“循环引用”的例子了吧……
大海：还有……“循环引用”……？
>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> b.append(a)
>>> a
[1, 2, [3, 4, [...]]]
>>> b
[3, 4, [1, 2, [...]]]
>>> a[2]
[3, 4, [1, 2, [...]]]
>>> b[2]
[1, 2, [3, 4, [...]]]
>>> a[2] is b
1
>>> b[2] is a
1
>>> f = file('temp.pkl', 'w')
>>> pickle.dump((a, b), f)
>>> f.close()
>>> f = file('temp.pkl', 'r')
>>> c, d = pickle.load(f)
>>> f.close()
>>> c
[1, 2, [3, 4, [...]]]
>>> d
[3, 4, [1, 2, [...]]]
>>> c[2]
[3, 4, [1, 2, [...]]]
>>> d[2]
[1, 2, [3, 4, [...]]]
>>> c[2] is d
1
>>> d[2] is c
1
大海：咦，这个“循环引用”也用到了把a、b两个列表对象合并成一个元组dump到同一个文件里头啊
流星：是的！之所以这么做，是因为“递归引用”和“循环引用”也类似对象间的组合关系，本质都是一个对象与一个对象建立了内存地址的引用(递归引用是引用自己)关系。要用元组的形式，同时一次性将2个对象序列化dump到同一个文件，保留指定的2个对象的引用关系，并且反序列化时就能把这个引用关系把指定返回给重构的2个对象了。
大海：原来如此……
流星：嗯，我们可以看看，如果“循环引用”的例子，改成将a与b分2次dump到1个文件里头，结果会怎样？
>>> f = file('temp.pkl', 'w')
>>> pickle.dump(a, f)
>>> pickle.dump(b, f)
>>> f.close()
>>> f = file('temp.pkl', 'r')
>>> c = pickle.load(f)
>>> d = pickle.load(f)
>>> f.close()
>>> c
[1, 2, [3, 4, [...]]]
>>> d
[3, 4, [1, 2, [...]]]
>>> c[2]
[3, 4, [1, 2, [...]]]
>>> d[2]
[1, 2, [3, 4, [...]]]
>>> c[2] is d
0
>>> d[2] is c
0
流星：你看，这里分2次dump到1个文件的话，第一次由a对象单独dump进文件的字符串信息load回的对象c，c[2]引用的不再是对象d了（d是由b对象dump进文件的字符串信息load回的），d[2]引用的也不再是对象c了，所以a与b本身的相互引用关系，已经在分开2次dump时丢失掉了。那这里c[2]，d[2]引用的是谁呢？是各自从文件load重构成列表对象c和d时，为了保证c[2]和d[2]的值与之前相等，计算机自己用list类重新生成的两个新的列表对象让他们各自引用
大海：明白了！
流星：最后，推荐个详细讲解pickle模块的博客文章：《python pickle模块》