我不熟悉 queue 在 python 中是循环的

Question

提供队列中每个人的字符串表示的最佳方法是什么。值为 0 或更小的人将有无限的轮次。当一个人从队列中移除时，如果他们还有剩余的轮次，他们将被重新添加到队列中。我的队列是空的。目标是在排队时遵循 FIFO 规则。

class Queue:
    
# implementation of a Queue
    def __init__(self):
    #    empty queue.
        self.queue = []

    def enqueue(self, value):
        # Add an item to the queue - run code queue is empty
        self.queue.insert(0, value)

    def dequeue(self):
       
        # Remove the next item from the queue. 
       
        value = self.queue[0]
        del self.queue[0]
        return value

    def is_empty(self):
        # check to see if queue is empty
        return len(self.queue) == 0
    
    def __len__(self):
        
        return len(self.queue)

    def __str__(self):
       
        result = "["
        for item in self.queue:
            result += str(item) + ", "
            result += ", "
        result += "]"
        return result


class Taking_Turns_Queue:
   
    
    class Person:
    #    define name and turns

        def __init__(self, name, turns):
           
            self.name = name
            self.turns = turns

        def __str__(self):
            # display a person
            if self.turns <= 0:
                result = "({}:Forever)".format(self.name)
            else:
                # Add zero and 1 below. THe orginal code had zero.
                result = "({}:{})".format(self.name, self.turns)
            return result

    def __init__(self):
        """ 
        Start with an empty queue
        """
        self.people = Queue()

    def add_person(self, name, turns):
        """
        Add new people to the queue with a name and number of turns
        """
        person = Taking_Turns_Queue.Person(name, turns)
        self.people.enqueue(person)

    def get_next_person(self):
        
        if self.people.is_empty():
            print("No one in the queue.")
        else:
            person = self.people.dequeue()
            if person.turns > 1:  
                person.turns -= 1 
                self.people.enqueue(person)
            print(person.name)

    def __len__(self):
        """
        Support the len() function
        """
        return len(self.people)

    def __str__(self):
        """
        Provide a string representation of everyone in the queue
        """
        return str(self.people)

# Test Cases

# Test 1
# Scenario: Create a queue with the following people and turns: Bob (2), Tim (5), Sue (3) and
#           run until the queue is empty
# Exepcted Result: Bob, Tim, Sue, Bob, Tim, Sue, Tim, Sue, Tim, Tim
print("Test 1")
players = Taking_Turns_Queue()
players.add_person("Bob", 2)
players.add_person("Tim", 5)
players.add_person("Sue", 3)
print(players)   
while len(players) > 0:
    players.get_next_person()
# Defect(s) Found: 

print("=================")

# Test 2
# Scenario: Create a queue with the following people and turns: Bob (2), Tim (5), Sue (3)
#           After running 5 times, add George with 3 turns.  Run until the queue is empty.
# Exepcted Result: Bob, Tim, Sue, Bob, Tim, Sue, Tim, George, Sue, Tim, George, Tim, George
print("Test 2")
players = Taking_Turns_Queue()
players.add_person("Bob", 2)
players.add_person("Tim", 5)
players.add_person("Sue", 3)
for i in range(5):
    players.get_next_person()
print(players)
players.add_person("George", 3)
print(players)
while len(players) > 0:
    players.get_next_person()
# Defect(s) Found: 

print("=================")

# Test 3
# Scenario: Create a queue with the following people and turns: Bob (2), Tim (Forever), Sue (3)
#           Run 10 times.
# Exepcted Result: Bob, Tim, Sue, Bob, Tim, Sue, Tim, Sue, Tim, Tim
print("Test 3")
players = Taking_Turns_Queue()
players.add_person("Bob", 2)
players.add_person("Tim", 0)
players.add_person("Sue", 3)
print(players)
for i in range(10):
    players.get_next_person()
print(players)    
# Defect(s) Found: 

print("=================")

# Test 4
# Scenario: Try to get the next person from an empty queue
# Exepcted Result: Error message should be displayed
print("Test 4")
players = Taking_Turns_Queue()
players.get_next_person()
# Defect(s) Found:
    

Answer 1

您的 FIFO 不是 FIFO。先从这样的事情开始，然后再让事情与人和回合数复杂化。

class FIFO:
    def __init__(self):
        self.buffer = []
    def add(self,item):
        self.buffer.insert(0,item)
    def get(self):
        return self.buffer.pop()
    def __str__(self):
        if len(self.buffer) == 0:
            return "[]"
        out = "[" + ''.join([f'{item},' for item in self.buffer])
        return out[:-1]+"]"

mybuf = FIFO()
mybuf.add("one")
mybuf.add("two")
mybuf.add("three")
assert mybuf.buffer == ["three", "two", "one"]

_item = mybuf.get()
mybuf.add(_item)
assert mybuf.buffer ==  ["one", "three", "two"]

print("All tests passed.")

# All tests passed.

一旦成功，您就可以朝着您的目标迈出一小步。

class FIFO:
    def __init__(self):
        self.buffer = []
    def add(self,item):
        if item["Turns"] > 0:
            self.buffer.insert(0,item)
    def get(self):
        person = self.buffer.pop()
        person["Turns"] -= 1
        return person
    def __str__(self):
        if len(self.buffer) == 0:
            return "[]"
        out = "[" + ''.join([f'{item},' for item in self.buffer])
        return out[:-1]+"]"
    def items(self):
        return len(self.buffer)

# Test 1
# Expected result: Bob Tim Sue Bob Tim Sue Tim Sue Tim Tim
mybuf = FIFO()
mybuf.add({"Name":"Bob","Turns":2})
mybuf.add({"Name":"Tim","Turns":5})
mybuf.add({"Name":"Sue","Turns":3})

debug = False # Set this to true for more information
output = []
while mybuf.items() > 0:
    person = mybuf.get()
    if debug:
        print(f"Got: {person['Name']}, Remaining turns: {person['Turns']}")
    output.append(person["Name"])
    mybuf.add(person)
    if debug:
        print(f"Buffer is: {mybuf}
")

print(' '.join(output))
# Bob Tim Sue Bob Tim Sue Tim Sue Tim Tim