Búfer circular de Python

1. Búfer circular eficiente en Python
2. Implementar búfer circular en Python
3. Ventajas del búfer circular de Python
4. Desventajas del búfer circular de Python
5. Conclusión

Un búfer circular es el otro nombre para un búfer de anillo. Un búfer es una estructura de datos que utiliza un solo búfer de tamaño fijo como si estuviera conectado de extremo a extremo.

Esta estructura ayuda a administrar los flujos de datos en los que se pueden agregar nuevos datos constantemente en un extremo y los datos antiguos se pueden eliminar en el otro. Cuando el búfer está lleno, los datos nuevos sobrescribirán los datos más antiguos.

Búfer circular eficiente en Python

Un búfer circular eficiente es una estructura de datos que permite la inserción y eliminación eficiente de datos.

Un búfer circular normalmente se implementa como una matriz. El puntero de la cabeza de la matriz apunta al primer elemento y el puntero de la cola indica el último elemento de la matriz.

Los punteros de la cabeza y la cola se envuelven cuando llegan al final de la matriz. La inserción en un búfer circular se realiza incrementando el puntero principal y escribiendo los datos en la matriz en esa ubicación.

La eliminación de un búfer circular se realiza incrementando el puntero de cola. Esos datos no se eliminan de la matriz, pero los punteros de cabeza y cola los omiten efectivamente.

Un búfer circular es una estructura de datos eficiente porque solo requiere una cantidad fija de memoria. También es fácil de implementar.

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())

Producción :

[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]

Implementar búfer circular en Python

Hay muchas formas de implementar buffers circulares eficientes en Python. Un enfoque común es usar un objeto colecciones.dequeue diseñado para admitir de manera eficiente la eliminación y adición de elementos tanto al principio como al final de la cola.

Otro método es utilizar una lista y realizar un seguimiento de los índices de cabeza y cola por separado.

Si desea saber cuál es el mejor enfoque, depende de los requisitos específicos de la aplicación. Por ejemplo, si los elementos deben agregarse y eliminarse del búfer con frecuencia y el orden no es esencial, entonces el enfoque de “quitar la cola” puede ser el mejor.

Por otro lado, si los elementos se agregan al búfer solo una vez y luego se leen muchas veces, o si el orden es esencial, entonces el enfoque de lista puede ser mejor.

Implementar cola circular usando colecciones.enqueue y colecciones.dequeue en Python

Primero, agregaremos valores en la cola usando la función colecciones.encolar. Luego, podemos usar collection.dequeue en la cola circular para eliminar un elemento de la cola.

Para entender su funcionamiento, veamos el ejemplo práctico de la cola circular en Python.

Código de ejemplo:

# 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()

Producción :

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

Ventajas del búfer circular de Python

Hay muchas ventajas en el uso de un búfer circular cuando se trabaja con datos en Python.

1. Una de las ventajas es que se puede utilizar para almacenar datos del modo Primero en entrar, primero en salir (FIFO). Esto puede ayudar cuando necesite procesar datos en el orden original en que se recibieron.
2. Otra ventaja es que un búfer circular puede almacenar datos en forma de último en entrar, primero en salir (LIFO). Esto será bueno cuando necesite procesar datos en el orden inverso al que se recibieron.
3. Además, se puede usar un búfer circular para almacenar datos de forma aleatoria. Esto puede ser útil cuando necesita acceder a los datos de forma rápida y aleatoria.

Desventajas del búfer circular de Python

Hay algunas desventajas en el uso de un búfer circular en Python.

1. Primero, no es posible acceder aleatoriamente a elementos en el búfer. Esto puede causar dificultad al trabajar con datos que no están en un orden lineal.
2. En segundo lugar, el tamaño del búfer es fijo. Esto puede causar un problema si necesita almacenar más datos de los que puede contener el búfer.
3. Finalmente, los búferes circulares pueden ser más difíciles de depurar que otras estructuras de datos.

Conclusión

El búfer circular de Python es una forma rápida y eficiente de almacenar datos. Un búfer de datos circular es una cola que se puede usar como un contenedor que contiene un solo objeto.

Un búfer circular generalmente se usa cuando los datos se agregan y eliminan constantemente, como en un videojuego o procesamiento de audio. Se puede implementar con un solo puntero, mientras que una cola lineal requiere dos punteros.

Un búfer circular se puede extender fácilmente a varias colas, lo que permite el acceso simultáneo a los datos.