lines = open("file.txt").readlines()

diskcache.commonvar = 10   # gets from in-memory cache (a dict)
diskcache.rarevar += 10  # gets from disk (via shelve), stores in memory cache

...  # more stuff

# rarevar hasn't been access for some time,
# so it's removed when diskcache is accessed again:
diskcache.x += 1     # rarevar removed as x is returned

import shelve

shelf = shelve.open("somefile.dbm")

# "dog" is read from disk and made into an object, then printed out. Because
# the object has not been assigned a name, it is destroyed the moment the
# print command ends.
print shelf["dog"]

# This line will read the same data in again, and store it only briefly in
# memory before discarding it again.
print shelf["dog"]

# "cat" is read from disk, but this time it is assigned a reference. This means
# that the "cat" object will persist in memory.
cat = shelf["cat"]
print cat

# This command doesn't reread the data from disk - it uses the in-memory
# version of "cat"
print cat

# Now, we can wait for "cat" to fall out of scope, or we can delete it
# manually:
del cat

# No more cat instances exist now

>>> class x:
...     def __init__(self):
...         self.mem = "-" * 1024*100

>>> shelf = shelve.open("test_shelve.dbm")
>>> shelf["a"] = x()

class main:

    def __init__(self):

        self.shelf = shelve.open("link_db.dbm")

...

        self.last_db_dump  = self.last_save
        self.db_dump_every = 60
        self.db_dump_age   = 30
        
        self.grab("queue", list)
        self.grab("active", list)
        self.grab("max_link_id", int)

        self.links  = dict()
        self.db_fetch_times = dict()
            
...

    def fetch_link(self, link_id):

        date = int(time.time())
        self.db_fetch_times[link_id] = date

        if not self.links.has_key(link_id):
            # load
            print "Loaded :", link_id
            self.links[link_id] = self.shelf["instance_%s"%(link_id)]

        # do a routine check for unused RAM
        if date >= self.last_db_dump + self.db_dump_every:
            for dump_link_id in self.db_fetch_times.keys():
                if date >= self.db_fetch_times[dump_link_id] + self.db_dump_age:
                    # save
                    self.shelf["instance_%s"%(dump_link_id)] = self.links[dump_link_id]
                    del self.links[dump_link_id]
                    del self.db_fetch_times[dump_link_id]
                    print "Saved :", dump_link_id
            self.last_db_dump = date
            
        return self.links[link_id]
              
    def grab(self, var_name, var_type):
        
        try:
            setattr(self, var_name, self.shelf[var_name])
        except KeyError:
            setattr(self, var_name, var_type())

...

    def add_to_queue(self, link_id):

        link = self.fetch_link(link_id)
        if link.points > 0:
            self.queue.append(link_id)
            link.points -= 1

...

x = "-" * 100 * 1024
del x    # x deleted, but OS doesn't bother to reassign 100M straight away

# The following code will likely result in an out of memory error:
l = []
for i in range(100):
    l.append("-" * 100 * 1024)

# The following code will not, since the OS will reassign the freed bits of
# memory when it deems it necessary:
for i in range(100):
    x = "-" * 100 * 1024