在带有和不带有'：'运算符的python中删除列表

Question

I've been working with python for quite a bit of time and I'm confused regarding few issues in the areas of Garbage Collection, memory management as well as the real deal with the deletion of the variables and freeing memory.

>>> pop = range(1000)
>>> p = pop[100:700]
>>> del pop[:]
>>> pop
[]
>>> p
[100.. ,200.. 300...699]

In the above piece of code, this happens. But,

>>> pop = range(1000)
>>> k = pop   
>>> del pop[:]
>>> pop 
[]
>>> k
[]

Here in the 2nd case, it implies that the k is just pointing the list 'pop'.

First Part of the question :

But, what's happening in the 1st code block? Is the memory containing [100:700] elements not getting deleted or is it duplicated when list 'p' is created?

Second Part of the question :

Also, I've tried including gc.enable and gc.collect statements in between wherever possible but there's no change in the memory utilization in both the codes. This is kind of puzzling. Isn't this bad that python is not returning free memory back to OS? Correct me if I'm wrong in the little research I've did. Thanks in advance.

Answer 1

Slicing a sequence results in a new sequence, with a shallow copy of the appropriate elements.

Returning the memory to the OS might be bad, since the script may turn around and create new objects, at which point Python would have to request the memory from the OS again.

Answer 2

1st part:

In the 1st code block, you create a new object where the elements of the old one are copied before deleting that one.

In the 2nd code block, however, you just assign a reference to the same object to another variable. Then you empty the list, which, of course, is visible via both references.

2nd part: Memory is returned when appropriate, but not always. Under the hood of Python, there is a memory allocator which has control over where the memory comes from. There are 2 ways: via the brk()/sbrk() mechanism (for smaller memory blocks) and via mmap() (larger blocks).

Here we have rather smaller blocks which get allocated directly at the end of the data segment:

datadatadata object1object1 object2object2

If we only free object1, we have a memory gap which can be reused for the next object, but cannot easily freed and returned to the OS.

If we free both objects, memory could be returned. But there probably is a threshold for keeping memory back for a while, because returning everything immediately is not the very best thing.