Python 循环缓冲区

循环缓冲区是环形缓冲区的另一个名称。 缓冲区是一种数据结构，它使用单个固定大小的缓冲区，就好像它是端到端连接的一样。

这种结构有助于管理数据流，其中可以在一端不断添加新数据，而可以从另一端删除旧数据。 当缓冲区已满时，新数据将覆盖最旧的数据。

---

Python 中的高效循环缓冲区

高效的循环缓冲区是一种允许高效插入和删除数据的数据结构。

循环缓冲区通常作为数组实现。 数组头指针指向第一个元素，尾指针指向数组中的最后一个元素。

头指针和尾指针在到达数组末尾时回绕。 插入循环缓冲区是通过递增头指针并将数据写入该位置的数组来完成的。

从循环缓冲区中删除是通过递增尾指针来完成的。 该数据并未从数组中删除，但头指针和尾指针有效地跳过了它。

循环缓冲区是一种高效的数据结构，因为它只需要固定数量的内存。 它也很容易实现。

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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出:

[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]
1
2
3
4
5
6
7
8
9
10

---

在 Python 中实现循环缓冲区

在 Python 中有很多方法可以实现高效的循环缓冲区。 一种常见的方法是使用 collections.dequeue 对象，该对象旨在有效地支持从队列的前端和后端移除和添加元素。

另一种方法是使用列表并分别跟踪头部和尾部索引。

如果您想知道哪种方法最好，则取决于应用程序的具体要求。 例如，如果元素需要频繁地从缓冲区中添加和删除，并且顺序不是必需的，那么出列方法可能是最好的。

另一方面，如果元素只被添加到缓冲区一次然后多次读出，或者如果顺序是必要的，那么列表方法可能更好。

在 Python 中使用 collections.enqueue 和 collections.dequeue 实现循环队列

首先，我们将使用函数 collections.enqueue 在队列中添加值。 然后，我们可以在循环队列中使用 collection.dequeue 从队列中删除一个元素。

为了理解它的工作原理，让我们看一下 Python 中循环队列的实际例子。

示例代码：

# 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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

输出:

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
1
2
3
4
5
6
7
8
9

---

Python循环缓冲区的优点

在 Python 中处理数据时使用循环缓冲区有很多优点。

1. 一个优点是它可以用于以先进先出 (FIFO) 方式存储数据。 当您需要按照接收数据的原始顺序处理数据时，这会有所帮助。
2. 另一个优点是循环缓冲区可以以后进先出 (LIFO) 的方式存储数据。 当您需要以接收数据的相反顺序处理数据时，这会很好。
3. 此外，循环缓冲区可用于以随机访问方式存储数据。 当您需要快速随机访问数据时，这会很有帮助。

---

Python循环缓冲区的缺点

在 Python 中使用循环缓冲区有一些缺点。

1. 首先，不可能随机访问缓冲区中的元素。 这可能会导致难以处理非线性顺序的数据。
2. 其次，缓冲区的大小是固定的。 如果您需要存储的数据多于缓冲区可以容纳的数据，这可能会导致问题。
3. 最后，循环缓冲区比其他数据结构更难调试。

---

总结

Python 循环缓冲区是一种快速高效的数据存储方式。 循环数据缓冲区是一个队列，可以用作容纳单个对象的容器。

当不断添加和删除数据时，例如在视频游戏或音频处理中，通常会使用循环缓冲区。 它可以用单个指针实现，而线性队列需要两个指针。

循环缓冲区可以很容易地扩展到多个队列，允许并发数据访问。