Wie man ein dynamisches Array erstellt

Question

So wie ich das verstehe, ist die list Typ in Python ist ein dynamisches Zeigerarray, das seine Kapazität erhöht, wenn ihm Elemente hinzugefügt werden. Und ein Array in NumPy verwendet einen kontinuierlichen Speicherbereich, um alle Daten des Arrays zu speichern.

Gibt es irgendwelche Typen, die dynamisch seine Kapazität als eine Liste zu erhöhen, und speichert den Wert als ein NumPy-Array? So etwas wie List in C#. Und es ist toll, wenn der Typ die gleiche Schnittstelle wie ein NumPy-Array hat.

Ich kann eine Klasse erstellen, die ein NumPy-Array umhüllt und die Größe dieses Arrays ändert, wenn es voll ist, z. B.:

class DynamicArray(object):
    def __init__(self):
        self._data = np.zeros(100)
        self._size = 0

    def get_data(self):
        return self._data[:self._size]

    def append(self, value):
        if len(self._data) == self._size:
            self._data = np.resize(self._data, int(len(self._data)*1.25))
        self._data[self._size] = value
        self._size += 1

aber DynamicArray kann nicht als NumPy-Array verwendet werden, und ich denke, alle Ansichten, die von get_data() vor np.resize() zurückgegeben werden, enthalten das alte Array.

Bearbeiten: Array-Typ im Array-Modul ist dynamisches Array. Das folgende Programm testet den Vergrößerungsfaktor von Liste und Array:

from array import array
import time
import numpy as np
import pylab as pl

def test_time(func):
    arrs = [func() for i in xrange(2000)]
    t = []
    for i in xrange(2000):
        start = time.clock()
        for a in arrs:
            a.append(i)
        t.append(time.clock()-start)
    return np.array(t)

t_list = test_time(lambda:[])
t_array = test_time(lambda:array("d"))
pl.subplot(211)
pl.plot(t_list, label="list")
pl.plot(t_array, label="array")
pl.legend()
pl.subplot(212)
pl.plot(np.where(t_list>2*np.median(t_list))[0])
pl.plot(np.where(t_array>2*np.median(t_array))[0])
pl.show()

aus dem Diagramm: der Steigerungsfaktor von Liste ist größer als der von Array.

Answer 1

Es mag Sie interessieren, dass die Python-Standardbibliothek auch eine Array Modul, das genau das ist, was Sie wollen:

Dieses Modul definiert einen Objekttyp, mit dem sich die Array von Basiswerten kompakt darstellen kann: Zeichen, Ganzzahlen, Fließkommazahlen. Arrays sind Sequenztypen und verhalten sich ähnlich wie Listen, mit der Ausnahme, dass der Typ der in ihnen gespeicherten Objekte eingeschränkt ist.