[PYTHON] Hériter de la bibliothèque standard pour trouver la valeur moyenne de Queue

introduction

J'avais l'habitude de vouloir trouver la moyenne des valeurs de file d'attente (je ne me souviens pas pourquoi j'en avais besoin). À ce moment-là, j'ai utilisé le code suivant pour trouver la valeur moyenne.

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:  #inversé pour la pile(queue_list)changer en
        q.put(value)
    return sum(queue_list) / len(queue_list)


#Contrôle de fonctionnement
q = queue.Queue()
q.put(1)
q.put(2)
q.put(6)
q.put(8)
print(queue_ave(q))  # 4.25

Le flux de ce code (fonction) est

1. Retirez tout de la file d'attente et placez-le dans une liste
2. Inversement, retour de liste à file d'attente
3. Transmettez la valeur moyenne de List comme valeur de retour

C'est quelque chose comme. Certes, la valeur moyenne de Queue peut encore être calculée. Cependant, bien sûr, il est inefficace car il coûte cher à calculer car il répète mettre et obtenir en vain.

Hériter de la bibliothèque standard

Par conséquent, une autre approche consiste à hériter de la classe Queue de la file d'attente de bibliothèque standard et à créer une classe personnalisée.

Pour ce faire, vérifiez comment la classe Queue gère les valeurs. Je pense que cela dépend de l'éditeur, mais vous pouvez voir le code source en "Ctrl + clic" la classe que vous souhaitez vérifier.

queue.py

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

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

    #~ Omis ~

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

En regardant la méthode put, elle dit diverses choses, mais il semble que la méthode \ _put soit utilisée pour stocker la valeur. Regardons maintenant la méthode \ _put et ainsi de suite.

queue.py

from collections import deque


class Queue:
    #~ Omis ~

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

De la méthode \ _put, j'ai trouvé que la valeur est stockée dans self.queue. De plus, la méthode \ _init utilisée lors de l'initialisation montre que self.queue est une instance deque.

En d'autres termes, il semble que la classe Queue utilise la classe deque des collections pour gérer les valeurs. Je n'entrerai pas dans cela ici, mais la classe deque semble être traitée comme un tableau (probablement).

Avec ces choses à l'esprit, héritez de la classe Queue et personnalisez-la à votre guise.

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


#Contrôle de fonctionnement
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

Vous avez maintenant créé une nouvelle classe MyQueue qui hérite de la classe Queue et développé ses fonctionnalités. Le coût est faible car il n'y a aucune opération inutile, et surtout, le code est propre. À ce niveau, si vous essayez de faire quelque chose de plus compliqué, cela fera une grande différence.

Résumé

Cette fois, j'ai hérité de la file d'attente de la bibliothèque existante et l'ai personnalisée à mon goût.

Il est également important d'avoir la capacité de pousser et de résoudre ce que vous pouvez faire maintenant. Cependant, si vous avez le temps et la solution, il est judicieux de choisir une méthode plus simple. Le code sera plus propre et sera bon pour l'avenir.