在 python 中，array.array 插入是如何工作的？

Question

In python, array.array is a mutable structure.

However, I am not sure how the insertion operation works in array.array structure.

Since array.array uses a contiguous memory, does it create a new memory block and copy all the elements of the array if the new element cannot be placed in the contiguous manner? Does it reserve additional unused space just in case for insertion operations?

Answer 1

Listing [Python 3.Docs]: array - Efficient arrays of numeric values just in case.

Any decent container that under the hood keeps the data in a contiguous memory zone, allocates more memory than required to hold the current number of elements.
What would happen if there would be no room for additional elements when inserting (appending is a particular case) an element:

1. Allocate memory area (current size + one (element size))
2. Copy data to the new area
3. Free old area
4. Additional small operations done anyway (like size (counters) update, ...)

As seen, when appending (which is the most common operation to add elements), there would be a lot of work which takes time and resources ( CPU power, memory).

Modern containers have a growing policy algorithm: every time that the memory zone needs to be reallocated (container is getting full), a number N of elements is added to the existing size to compute the new size, and more: N gets bigger every time such a reallocation takes place . That is to minimize the (expensive) memory operations.
Of course, at the other end of the interval would be the possibility to allocate a huge amount of memory (eg 500 MiB ) for a container, but that wouldn't be feasible, as a lot of memory would just be "sitting" there as reserved in case the owning container might need it.
After all, it's just a matter of compromise.

You can check [CPPReference]: std::vector as an example ( size and capacity methods).

Back to our problem: array.array is indeed a modern container that does allocate unused space. From [GitHub]: python/cpython - (master) cpython/Modules/arraymodule.c :

 /* This over-allocates proportional to the array size, making room * for additional growth. The over-allocation is mild, but is * enough to give linear-time amortized behavior over a long * sequence of appends() in the presence of a poorly-performing * system realloc(). * The growth pattern is: 0, 4, 8, 16, 25, 34, 46, 56, 67, 79, ... * Note, the pattern starts out the same as for lists but then * grows at a smaller rate so that larger arrays only overallocate * by about 1/16th -- this is done because arrays are presumed to be more * memory critical. */

As for the insertion algorithm itself, check the ins1 function:

• Size is checked (and updated), and if needed the memory is increased
• Elements following the insertion position are shifted towards the end ("right") with one position
• New element is placed at the insertion position

As a side note, other Python containers use this technique, check [SO]: Why does list ask about __len__? (@CristiFati's answer) for more details.