Python: different behavior using gc module in interactive mode

Question

I wanted to be able to get a tuple of references to any existing object instances of a class. What I came up with was:

import gc

def instances(theClass):
    instances = []
    gc.collect()
    for i in gc.get_referrers(theClass):
        if isinstance(i, theClass):
            instances.append(i)
    return tuple(instances)

If the above code is entered at the Python intepreter prompt, then you can do the below:

>>> class MyClass(object):
>>>     pass

>>> c = MyClass()
>>> instances(MyClass)
(<__main__.MyClass object at 0x100c616d0>,)

Hooray. But then it seems as though gc.collect() doesn't actually do anything inside the function:

>>> del c
>>> instances(MyClass)
(<__main__.MyClass object at 0x100c616d0>,)

But gc.collect() works when outside the function:

>>> del c
>>> gc.collect()
>>> instances(MyClass)
()

So, my question is: How do I make gc.collect() actually do a full collection when inside the function (and why doesn't it work as is)? With corollary question: Is there a better way to accomplish the same goal of returning a tuple with references to object instances for a specific class?

NB: This was all tried in Python 2.7.3. I haven't yet tried it in Python 3, but my goal would be to have a function that works in either (or at least which can be converted with 2to3).

Edited (per answer below) to clarify that the issue was really about interactive mode, not the gc.collect() function per se.

Answer 1

When you work in interactive mode, there's a magic built-in variable _ that holds the result of the last expression statement you ran:

>>> 3 + 4
7
>>> _
7

When you delete the c variable, del c isn't an expression, so _ is unchanged:

>>> c = MyClass()
>>> instances(MyClass)
(<__main__.MyClass object at 0x00000000022E1748>,)
>>> del c
>>> _
(<__main__.MyClass object at 0x00000000022E1748>,)

_ is keeping a reference to the MyClass instance. When you call gc.collect(), that's an expression, so the return value of gc.collect() replaces the old value of _, and c finally gets collected. It doesn't have anything to do with the garbage collector; any expression would do:

>>> 4
4
>>> instances(MyClass)
()