Question

现在是时候提出我的第一个问题了。我面临以下问题：

我正在使用pickle模块转储一个大字典，然后从磁盘上加载它。问题是，在拆开后两个对象不一样。实际上这就是我在做的事情：

在文件A.py中，我定义了具有一些属性和方法的类。

在文件B.py中，我创建了一个字典，其中的值是A.py

中类的实例

同样在文件B.py中，我挑选了这本字典并再次取消它。

这两个词不一样。我检查了钥匙，是一样的。问题在于价值观。

有什么想法吗？

Answer 1

两个不同的词典，键和键相同值不会被视为相同：

>>> d1 = {'k1': 12345}
>>> d2 = {'k1': 12345}
>>> d1 is d2
False
>>> d1['k1'] is d2['k1']
False

即使您实际上将值从一个复制到另一个：

>>> d1['k1'] = d2['k1']
>>> d1['k1'] is d2['k1']
True
>>> d1 is d2
False

那是因为每个人都是一个单独的容器。另一方面，您可以使用如下表达式检查所有键和值是否具有相等值而不是字面上相同的对象：

(set(d1) == set(d2)) and all(d1[k] == d2[k] for k in d1)

第一个子表达式确保每个键都具有相同值的键，第二个子表达式与每个键相关的值相等。

当您从保存的数据重构字典时，会创建一个新字典。它不是同一个字典，但它的所有键和值都应该等于原始字典。如果确实不是这种情况，请至少向我们提供您用来确定它们不相同的代码。

Answer 2

实际上是字典值的类的实例如下所示：

class SchemaObject:
def __init__(self):
    self.type = ''
    self.name = ''
    self.parentdn = ''
    self.dn = ''
    self.oclass = ''

def initWithXMLNode(self, xmlnode, parentdn):
    self.type = ''
    self.name = ''
    self.parentdn = parentdn
    if xmlnode.nodeName=='fragments':
        self.dn = parentdn
    if xmlnode.nodeName=='fragment':
        self.initFragment(xmlnode)
    elif xmlnode.nodeName=='configGroupLdap':
        self.initGroup(xmlnode)
    elif xmlnode.nodeName=='configObjectLdap':
        self.initObject(xmlnode)

def initWithFragment(self, dn, parentdn, name):
    self.type = 'object'
    self.name = name
    self.parentdn = parentdn
    self.dn = dn
    self.oclass = name

def initFragment(self, xmlnode):
    self.type = 'fragment'
    self.dn = 'fsFragmentId=' + xmlnode.firstChild.nodeValue + ',' + self.parentdn
    self.oclass = 'FSFragment'

def initGroup(self, xmlnode):
    self.type = 'group'
    self.name = 'group-' + xmlnode.getAttribute('name')
    self.dn = xmlnode.getAttribute('dn')
    self.oclass = 'FSFragment'

def initObject(self, xmlnode):
    self.type = 'object'
    self.name = xmlnode.getAttribute('name')
    self.oclass = self.name
    if not xmlnode.hasAttribute('rdnname'):
        self.type = 'no_rdnname'
        return
    else:
        rdnname = xmlnode.getAttribute('rdnname')
    parts = rdnname.split(',')
    if xmlnode.getAttribute('multiple')!='true':
        dn = self.parentdn
        for part in reversed(parts):
            dn = 'fsFragmentId=' + part + ',' + dn
        self.dn = dn
    else:
        self.type = ''
        self.dn = 'fsFragmentId=' + parts[len(parts)-1] + ',' + self.parentdn
        dynamicStatics.append(self.oclass)

并在文件B.py中创建一个字典，其值基于此类。 dict是my_dict。我还检查了钥匙是否相等。只有当我尝试比较这些词典之间的两个值时，它才会失败。

所以我试着用它来腌制它：

 with open('my_dumped.pkl','wb') as schema:
    pickle.dump(my_dict,schema)

并尝试从磁盘恢复时：

with open('my_dumped.pkl','rb') as schema:
    b = pickle.load(schema)

如果现在我发出my_dumped == b不应该返回True吗？我不关心identity.just是否相等。因为marteanu说密钥都在那里，并且每个密钥都有正确的值。

不幸的是，上述等式返回False。

pickle一个字典，其中的值是一些自定义类

2 个答案: