python creates everything from heap?

Question

in c/c++, you have variables in stack when you create a local variable inside a function.

http://effbot.org/zone/call-by-object.htm

CLU objects ex

Answer 1

As a supplement to the other answers, here's one way to track when garbage-collection happens, using the special method __del__:

class Test(object):
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print "deleting {0}".format(self.name)

print "discarded instance creation"
Test("hello")

print "saved instance creation"
myList = Test("bye")

print "program done"

Output:

discarded instance creation
deleting hello
saved instance creation
program done
deleting bye

For more in-depth data, see the gc module.

Answer 2

Yes, all Python objects live on the heap (at least on CPython.) They are reference-counted: they are de-allocated when the last reference to the object disappear. (CPython also has a garbage collector to break cycles.)

In CPython your first list disappears as soon as the function returns since you did not bind the return value to a name and the reference count dropped to zero. In other implementation the object may live longer until the garbage-collector kicks in.

Some objects (like open files) have resources attached that are automatically freed when the object is deallocated, but because of the above it is not recommended to rely on this. Resources should be closed explicitly when you are done with them.

Answer 3

Yes, all values in CPython are allocated on the heap and reference-counted to know when to deallocate them. Unlike in C, there is no way to know in most cases if a value will outlive its function, so the only safe thing to do is to heap-allocate everything.

Certainly you could do some analysis and determine that certain values are never passed to functions and thus couldn't escape, but that's of limited use in Python and the extra overhead probably wouldn't be worth it.