how to "free" an object/var ?

[Stef Mientki]

If I create a large array of data or class,
how do I destroy it (when not needed anymore) ?

Assign it to an empty list ?

thanks,
Stef Mientki

[James Stroud]

Stef Mientki wrote:

If I create a large array of data or class,
how do I destroy it (when not needed anymore) ?

Assign it to an empty list ?

thanks,
Stef Mientki

It will be gc'd when you leave the scope or you can call del() to
explicitly get rid of the object if its existence bothers you.

James

[Stef Mientki]

James Stroud wrote:

Stef Mientki wrote:

>If I create a large array of data or class,
how do I destroy it (when not needed anymore) ?

Assign it to an empty list ?

thanks,
Stef Mientki

It will be gc'd when you leave the scope or you can call del() to
explicitly get rid of the object if its existence bothers you.

James

thanks James,
indeed, large objects, are sometimes bothering me,
and assigning it to an empty list requires comment ;-)
cheers,
Stef

[Ben Finney]

Stef Mientki <S.************ **@mailbox.kun. nlwrites:

If I create a large array of data or class, how do I destroy it
(when not needed anymore) ?

Python comes with garbage collection, which is enabled by default.
Some time after your code stops needing the object, the garbage
collector will clean it up.

To check whether your Python has garbage collection enabled, you can
use the 'gc' interface module:

Python 2.4.4 (#2, Jan 13 2007, 17:50:26)
[...]

>>import gc
gc.isenabled( )

True

>>help(gc)

This module is only needed if you want to *interact* with the garbage
collector, which you won't unless you want to tune it or turn it off.

--
\ "Immorality : The morality of those who are having a better |
`\ time." -- Henry L. Mencken |
_o__) |
Ben Finney

[Aahz]

In article <df************ **************@ news.speedlinq. nl>,
Stef Mientki <S.************ **@mailbox.kun. nlwrote:

>
If I create a large array of data or class, how do I destroy it (when
not needed anymore) ?

You should be aware that releasing memory may not cause the size of your
process to shrink -- many OSes keep memory assigned to an application for
its lifetime.
--
Aahz (aa**@pythoncra ft.com) <* http://www.pythoncraft.com/

"I disrespectfully agree." --SJM

[Steven D'Aprano]

On Tue, 30 Jan 2007 15:48:37 -0800, James Stroud wrote:

Stef Mientki wrote:

>If I create a large array of data or class,
how do I destroy it (when not needed anymore) ?

Assign it to an empty list ?

thanks,
Stef Mientki

It will be gc'd when you leave the scope or you can call del() to
explicitly get rid of the object if its existence bothers you.

That is not quite correct.

big_list = ["data"]*1000000
another_referen ce = big_list
del big_list

At this point, the list of one million "data" strings still exists.

del big_list doesn't delete the list object, it removes the name
"big_list". Then, only if the list has a reference count of zero, Python
will dispose of the object and free the memory (if your OS allows that).
If there are still references to it, like "another_refere nce" above, it
will not be disposed of.

As far as I know there is no way to force the deletion of an object even
if it is in use. This is a Good Thing.
--
Steven D'Aprano

[Paddy]

On Jan 31, 6:52 am, Steven D'Aprano <s...@REMOVEME. cybersource.com .au>
wrote:

On Tue, 30 Jan 2007 15:48:37 -0800, James Stroud wrote:

Stef Mientki wrote:

If I create a large array of data or class,
how do I destroy it (when not needed anymore) ?

Assign it to an empty list ?

thanks,
Stef Mientki

It will be gc'd when you leave the scope or you can call del() to
explicitly get rid of the object if its existence bothers you.

That is not quite correct.

big_list = ["data"]*1000000
another_referen ce = big_list
del big_list

At this point, the list of one million "data" strings still exists.

del big_list doesn't delete the list object, it removes the name
"big_list". Then, only if the list has a reference count of zero, Python
will dispose of the object and free the memory (if your OS allows that).
If there are still references to it, like "another_refere nce" above, it
will not be disposed of.

As far as I know there is no way to force the deletion of an object even
if it is in use. This is a Good Thing.

--
Steven D'Aprano

The folowing will make the data available for garbage collection no
matter what references it:

>>l = ["data"] *10
l

['data', 'data', 'data', 'data', 'data', 'data', 'data', 'data',
'data', 'data']

>>l2 = l
l[:] = []
l2

[]

>>>

- Paddy.

[John Nagle]

Steven D'Aprano wrote:

On Tue, 30 Jan 2007 15:48:37 -0800, James Stroud wrote:

>>Stef Mientki wrote:

>>>If I create a large array of data or class,
how do I destroy it (when not needed anymore) ?

If your data structure has no backlinks, it will go away
as soon as the last reference to it disappears. If your
data structure has backlinks, it will hang around until
garbage collection runs. If your backlinks are
weak references (see "weakref"), the data structure will
be released much sooner.

If you generate structures with backlinks, like
parse trees, use weak references for all links that point
backwards toward the root, and you'll use less memory.

In Python, garbage collection is mostly a backup to
the reference counting system. If your app really
needs periodic GC to run, you're leaking memory.
On servers, this sometimes matters.

John Nagle

[Steven D'Aprano]

On Tue, 30 Jan 2007 23:22:52 -0800, Paddy wrote:

>As far as I know there is no way to force the deletion of an object
even if it is in use. This is a Good Thing.

--
Steven D'Aprano

The folowing will make the data available for garbage collection no
matter what references it:

>>>l = ["data"] *10
l

['data', 'data', 'data', 'data', 'data', 'data', 'data', 'data', 'data',
'data']

>>>l2 = l
l[:] = []
l2

[]

Sort of.

What happens is that both l and l2 are names referring to the same list.
After executing l[:] the *contents* of the list change, from lots of
"data" to nothing. Naturally both l and l2 see the change, because they
both point to the same list. But the original contents of the list still
exist until the garbage collector sees that they are no longer in use,
and then frees them.

You can prove this by doing something like this:

data = "\0"*100000 0 # one (decimal) megabyte of data
L = [data] # put it in a list
L[:] = [] # "free" the contents of the list
assert len(data) == 1000000
# but the megabyte of data still there

Again, you can't force Python to free up memory that is still in use.
If you could, that would be a bug.

--
Steven D'Aprano

[Paddy]

On Jan 31, 7:34 am, Steven D'Aprano <s...@REMOVEME. cybersource.com .au>
wrote:

On Tue, 30 Jan 2007 23:22:52 -0800, Paddy wrote:

As far as I know there is no way to force the deletion of an object
even if it is in use. This is a Good Thing.

--
Steven D'Aprano

The folowing will make the data available for garbage collection no
matter what references it:

>>l = ["data"] *10
l

['data', 'data', 'data', 'data', 'data', 'data', 'data', 'data', 'data',
'data']

>>l2 = l
l[:] = []
l2

[]

Sort of.

What happens is that both l and l2 are names referring to the same list.
After executing l[:] the *contents* of the list change, from lots of
"data" to nothing. Naturally both l and l2 see the change, because they
both point to the same list. But the original contents of the list still
exist until the garbage collector sees that they are no longer in use,
and then frees them.

You can prove this by doing something like this:

data = "\0"*100000 0 # one (decimal) megabyte of data
L = [data] # put it in a list
L[:] = [] # "free" the contents of the list
assert len(data) == 1000000
# but the megabyte of data still there

Again, you can't force Python to free up memory that is still in use.
If you could, that would be a bug.

--
Steven D'Aprano

Thanks Stephen for explaining my answer a bit more.

The [:] = [] trick should be of most use when you go on to allocate
large amounts of data in your program once again, when the gc coud
then make some of the same memory available for the new objects.
As others have said, getting Python to give back memory to the
underlying OS is murder - The best way I have of doing that is to
split your program into two and chain their execution, which allows
the OS to reclaim the memory used by the first Python process when it
finishes.

- Paddy.