[PYTHON] Erben Sie die Standardbibliothek, um den Durchschnittswert der Warteschlange zu ermitteln

Einführung

Früher wollte ich den Durchschnitt der Warteschlangenwerte ermitteln (ich erinnere mich nicht, warum ich ihn brauchte). Zu diesem Zeitpunkt habe ich den folgenden Code verwendet, um den Durchschnittswert zu ermitteln.

queue_test.py

import queue


def queue_ave(q):
    queue_list = []
    while not q.empty():
        queue_list.append(q.get())
    for value in queue_list:  #für Stapel umgekehrt(queue_list)ändern
        q.put(value)
    return sum(queue_list) / len(queue_list)


#Funktionsprüfung
q = queue.Queue()
q.put(1)
q.put(2)
q.put(6)
q.put(8)
print(queue_ave(q))  # 4.25

Der Ablauf dieses Codes (Funktion) ist

1. Nehmen Sie alles aus der Warteschlange und fügen Sie es in eine Liste ein
2. Kehren Sie umgekehrt von Liste zu Warteschlange zurück
3. Übergeben Sie den Durchschnittswert von List als Rückgabewert

Es ist so etwas wie. Natürlich kann der Durchschnittswert der Warteschlange noch berechnet werden. Selbstverständlich ist es jedoch sehr ineffizient, da die Berechnung viel kostet, weil es Put und Get vergeblich wiederholt.

Von der Standardbibliothek erben

Daher besteht ein anderer Ansatz darin, die Warteschlangenklasse von der Standardbibliothekswarteschlange zu erben und eine angepasste Klasse zu erstellen.

Überprüfen Sie dazu, wie die Queue-Klasse die Werte verwaltet. Ich denke, es hängt vom Editor ab, aber Sie können den Quellcode durch "Strg + Klicken" der Klasse sehen, die Sie überprüfen möchten.

queue.py

class Queue:
    '''Create a queue object with a given maximum size.

    If maxsize is <= 0, the queue size is infinite.
    '''

    #~ Ausgelassen ~

    def put(self, item, block=True, timeout=None):
        '''Put an item into the queue.

        If optional args 'block' is true and 'timeout' is None (the default),
        block if necessary until a free slot is available. If 'timeout' is
        a non-negative number, it blocks at most 'timeout' seconds and raises
        the Full exception if no free slot was available within that time.
        Otherwise ('block' is false), put an item on the queue if a free slot
        is immediately available, else raise the Full exception ('timeout'
        is ignored in that case).
        '''
        with self.not_full:
            if self.maxsize > 0:
                if not block:
                    if self._qsize() >= self.maxsize:
                        raise Full
                elif timeout is None:
                    while self._qsize() >= self.maxsize:
                        self.not_full.wait()
                elif timeout < 0:
                    raise ValueError("'timeout' must be a non-negative number")
                else:
                    endtime = time() + timeout
                    while self._qsize() >= self.maxsize:
                        remaining = endtime - time()
                        if remaining <= 0.0:
                            raise Full
                        self.not_full.wait(remaining)
            self._put(item)
            self.unfinished_tasks += 1
            self.not_empty.notify()

Wenn man die put-Methode betrachtet, sagt sie verschiedene Dinge aus, aber es scheint, dass die \ _put-Methode zum Speichern des Werts verwendet wird. Schauen wir uns nun die \ _put-Methode an und so weiter.

queue.py

from collections import deque


class Queue:
    #~ Ausgelassen ~

    # Put a new item in the queue
    def _put(self, item):
        self.queue.append(item)

    # Initialize the queue representation
    def _init(self, maxsize):
        self.queue = deque()

Bei der \ _put-Methode habe ich festgestellt, dass der Wert in self.queue gespeichert ist. Darüber hinaus zeigt die während der Initialisierung verwendete \ _init-Methode, dass self.queue eine Deque-Instanz ist.

Mit anderen Worten, es scheint, dass die Queue-Klasse die deque-Klasse von Sammlungen verwendet, um Werte zu verwalten. Ich werde hier nicht darauf eingehen, aber die Deque-Klasse scheint (wahrscheinlich) wie ein Array behandelt zu werden.

Erben Sie vor diesem Hintergrund die Queue-Klasse und passen Sie sie nach Ihren Wünschen an.

queue_test.py

import queue


class MyQueue(queue.Queue):
    def show_value(self, i):
        print(self.queue[i])

    def sum(self):
        return sum(self.queue)

    def ave(self):
        return self.sum() / self.qsize()


#Funktionsprüfung
q = MyQueue()
q.put(1)
q.put(2)
q.put(6)
q.put(8)
q.show_value(2)  # 6
print(q.sum())  # 17
print(q.ave())  # 4.25

Sie haben jetzt eine neue MyQueue-Klasse erstellt, die von der Queue-Klasse erbt, und ihre Funktionalität erweitert. Die Kosten sind gering, da keine unnötigen Vorgänge erforderlich sind und der Code vor allem sauber ist. Auf dieser Ebene macht es einen großen Unterschied, wenn Sie versuchen, etwas Komplizierteres zu tun.

Zusammenfassung

Dieses Mal habe ich die vorhandene Bibliothekswarteschlange geerbt. Warteschlange und sie nach meinen Wünschen angepasst.

Es ist auch wichtig, die Fähigkeit zu haben, zu pushen und zu lösen, was Sie jetzt tun können. Wenn Sie jedoch die Zeit und die Lösung haben, ist es klug, eine einfachere Methode zu wählen. Der Code wird sauberer und gut für die Zukunft sein.