Python Dict Switcher导致内存泄漏

Question

I have extensively read about immutable and mutable objects in Python for a couple of months now and I seem to begin to understand the concept. Still I cannot spot the problem why my code below produces memory leaks. The dicts function as references to immutable records of specific type. In many cases, I get an update of an existing record, in this case, the existing record will only be updated if the two records ( oldrecord and newrecord ) are not equal. However, I have the feeling that newrecord gets never deleted if oldrecord and newrecord match, although all references appear to cease to exist in such a case.

My question: Is the code below good practice for selecting a reference to a dict based on record type or should I do it differently (eg through dictSwitcher )?

class myRecordDicts():
    def __init__(self, type1Dict=dict(), type2Dict=dict(),
                type3Dict=dict(),type4Dict=dict(),type5Dict=dict(),type6Dict=dict(), type7Dict=dict()):
        self.type1Dict = type1Dict
        self.type2Dict = type2Dict
        self.type3Dict = type3Dict
        self.type4Dict = type4Dict
        self.type5Dict = type5Dict
        self.type6Dict = type6Dict
        self.type7Dict = type7Dict

    def dictSelector(self, record):
        dictSwitcher = {
            myCustomRecordType1().name: self.type1Dict,
            myCustomRecordType2().name: self.type2Dict,
            myCustomRecordType3().name: self.type3Dict,
            myCustomRecordType4().name: self.type4Dict,
            myCustomRecordType5().name: self.type5Dict,
            myCustomRecordType6().name: self.type6Dict,
            myCustomRecordType7().name: self.type7Dict,
        }
        return dictSwitcher.get(record.name)

    def AddRecordToDict(self, newrecord):
        dict = self.dictSelector(newrecord)
        recordID = newrecord.id
        if recordID in dict:
            oldrecord = dict[recordID]
            self.MergeExistingRecords(oldrecord,newrecord)
        else:                                                                                        
            dict[recordID] = newrecord

    def MergeExistingRecords(self, oldrecord, newrecord):
        # Basic Compare function
        oldRecordString = oldrecord.SerializeToString()
        newRecordString = newrecord.SerializeToString()
        # no need to do anything if same length
        if not len(oldRecordString) == len(newRecordString):
            oldrecord.CustomMergeFrom(newrecord)

Answer 1

Well, it seems always like that: I was working for hours on this problem and could not make progress. 5 Minutes after formulating the question correctly on StackExchange, I found my issue:

I needed to remove the references in init since I was never passing dicts when instantiating myRecordsDicts() , the following code does not leak memory:

class myRecordDicts():
    def __init__(self):
        self.type1Dict = dict()
        self.type2Dict = dict()
        self.type3Dict = dict()
        self.type4Dict = dict()
        self.type5Dict = dict()
        self.type6Dict = dict()
        self.type7Dict = dict()