Python-Zirkularpuffer

1. Effizienter Ringpuffer in Python
2. Implementieren Sie Circular Buffer in Python
3. Vorteile von Python Circular Buffer
4. Nachteile von Python Circular Buffer
5. Abschluss

Ein Ringpuffer ist die andere Bezeichnung für einen Ringpuffer. Ein Puffer ist eine Datenstruktur, die einen einzelnen Puffer fester Größe verwendet, als ob er Ende-zu-Ende verbunden wäre.

Diese Struktur hilft bei der Verwaltung von Datenströmen, bei denen an einem Ende ständig neue Daten hinzugefügt und am anderen alte Daten entfernt werden können. Wenn der Puffer voll ist, überschreiben neue Daten die ältesten Daten.

Effizienter Ringpuffer in Python

Ein effizienter Ringpuffer ist eine Datenstruktur, die ein effizientes Einfügen und Löschen von Daten ermöglicht.

Ein Ringpuffer wird typischerweise als Array implementiert. Der Array-Kopfzeiger zeigt auf das erste Element, und der Endzeiger zeigt auf das letzte Element im Array.

Die Head- und Tail-Zeiger laufen herum, wenn sie das Ende des Arrays erreichen. Das Einfügen in einen Ringpuffer erfolgt durch Inkrementieren des Kopfzeigers und Schreiben der Daten in das Array an dieser Stelle.

Das Löschen aus einem Ringpuffer erfolgt durch Inkrementieren des Endzeigers. Diese Daten werden nicht aus dem Array gelöscht, aber die Head- und Tail-Zeiger überspringen sie effektiv.

Ein Ringpuffer ist eine effiziente Datenstruktur, da er nur eine feste Speichermenge benötigt. Es ist auch einfach umzusetzen.

class Buffer:
    def __init__(self, size):
        self.data = [None for i in range(size)]

    def append(self, x):
        self.data.pop(0)
        self.data.append(x)

    def get(self):
        return self.data


buf = Buffer(4)
for i in range(10):
    buf.append(i)
    print(buf.get())

Ausgang:

[None, None, None, 0]
[None, None, 0, 1]
[None, 0, 1, 2]
[0, 1, 2, 3]
[1, 2, 3, 4]
[2, 3, 4, 5]
[3, 4, 5, 6]
[4, 5, 6, 7]
[5, 6, 7, 8]
[6, 7, 8, 9]

Implementieren Sie Circular Buffer in Python

Es gibt viele Möglichkeiten, effiziente Ringpuffer in Python zu implementieren. Ein gängiger Ansatz ist die Verwendung eines collections.dequeue-Objekts, das das Entfernen und Hinzufügen von Elementen sowohl von der Vorder- als auch von der Rückseite der Warteschlange effizient unterstützt.

Eine andere Methode besteht darin, eine Liste zu verwenden und die Head- und Tail-Indizes separat zu verfolgen.

Welcher Ansatz der beste ist, hängt von den spezifischen Anforderungen der Anwendung ab. Wenn zum Beispiel Elemente häufig hinzugefügt und aus dem Puffer entfernt werden müssen und die Reihenfolge nicht wesentlich ist, dann kann der dequeue-Ansatz am besten sein.

Wenn andererseits Elemente nur einmal dem Puffer hinzugefügt und dann viele Male ausgelesen werden oder wenn die Reihenfolge wesentlich ist, dann kann der Listenansatz besser sein.

Implementieren Sie Circular Queue mit collections.enqueue und collections.dequeue in Python

Zuerst fügen wir Werte in die Warteschlange ein, indem wir die Funktion collections.enqueue verwenden. Dann können wir collection.dequeue in der kreisförmigen Warteschlange verwenden, um ein Element aus der Warteschlange zu löschen.

Um die Funktionsweise zu verstehen, schauen wir uns das praktische Beispiel der kreisförmigen Warteschlange in Python an.

Beispielcode:

# implememting circular queue in python
class CircularQueue:
    def __init__(collections, k):
        collections.k = k
        collections.queue = [None] * k
        collections.head = collections.tail = -1

    # this function will insert (Enqueue) an element into the circular queue
    def enqueue1(collections, data):

        if (collections.tail + 1) % collections.k == collections.head:
            print("The queue is full\n")

        elif collections.head == -1:
            collections.head = 0
            collections.tail = 0
            collections.queue[collections.tail] = data
        else:
            collections.tail = (collections.tail + 1) % collections.k
            collections.queue[collections.tail] = data

    # this function will delete (dequeue) an element from the circular
    def dequeue1(collections):
        if collections.head == -1:
            print("The circular queue is empty\n")

        elif collections.head == collections.tail:
            temp = collections.queue[collections.head]
            collections.head = -1
            collections.tail = -1
            return temp
        else:
            temp = collections.queue[collections.head]
            collections.head = (collections.head + 1) % collections.k
            return temp

    # This function is used to print the queue
    def printCQueue1(collections):
        if collections.head == -1:
            print("Circular queue is empty")

        elif collections.tail >= collections.head:
            for i in range(collections.head, collections.tail + 1):
                print(collections.queue[i], end=" ")
            print()
        else:
            for i in range(collections.head, collections.k):
                print(collections.queue[i], end=" ")
            for i in range(0, collections.tail + 1):
                print(collections.queue[i], end=" ")
            print()


obj = CircularQueue(5)

# adding data to the queue
for i in range(1, 6):
    obj.enqueue1(i)

print("Display queue")
obj.printCQueue1()

# removing data from the queue
print("\nDelete Value:", obj.dequeue1())
print("Delete Value:", obj.dequeue1())


print("\nTwo values were deleted from the queue")
print("The new queue has 3 values now")
obj.printCQueue1()

Ausgang:

Display queue
1 2 3 4 5

Delete Value: 1
Delete Value: 2

Two values were deleted from the queue
The new queue has 3 values now
3 4 5

Vorteile von Python Circular Buffer

Es gibt viele Vorteile bei der Verwendung eines Ringpuffers bei der Arbeit mit Daten in Python.

1. Ein Vorteil besteht darin, dass es verwendet werden kann, um Daten in einer First In, First Out (FIFO)-Weise zu speichern. Dies kann hilfreich sein, wenn Sie Daten in der ursprünglichen Reihenfolge verarbeiten müssen, in der sie eingegangen sind.
2. Ein weiterer Vorteil besteht darin, dass ein Ringpuffer Daten in einer LIFO-Weise (Last In, First Out) speichern kann. Dies ist gut, wenn Sie Daten in der umgekehrten Reihenfolge verarbeiten müssen, in der sie empfangen wurden.
3. Zusätzlich kann ein Ringpuffer verwendet werden, um Daten mit wahlfreiem Zugriff zu speichern. Dies kann hilfreich sein, wenn Sie schnell und willkürlich auf Daten zugreifen müssen.

Nachteile von Python Circular Buffer

Die Verwendung eines Ringpuffers in Python hat einige Nachteile.

1. Erstens ist es nicht möglich, wahllos auf Elemente im Puffer zuzugreifen. Dies kann zu Schwierigkeiten beim Arbeiten mit Daten führen, die nicht in einer linearen Reihenfolge vorliegen.
2. Zweitens ist die Größe des Puffers festgelegt. Dies kann ein Problem verursachen, wenn Sie mehr Daten speichern müssen, als der Puffer aufnehmen kann.
3. Schließlich können kreisförmige Puffer schwieriger zu debuggen sein als andere Datenstrukturen.

Abschluss

Der Python-Ringpuffer ist eine schnelle und effiziente Methode zum Speichern von Daten. Ein kreisförmiger Datenpuffer ist eine Warteschlange, die als Container verwendet werden kann, der ein einzelnes Objekt enthält.

Ein Ringpuffer wird normalerweise verwendet, wenn Daten ständig hinzugefügt und entfernt werden, wie z. B. in einem Videospiel oder bei der Audioverarbeitung. Sie kann mit einem einzigen Zeiger implementiert werden, wohingegen eine lineare Warteschlange zwei Zeiger erfordert.

Ein Ringpuffer kann einfach auf mehrere Warteschlangen erweitert werden, was einen gleichzeitigen Datenzugriff ermöglicht.