FIFO：import queue
创建一个队列长度为10的对象：q=queue.queue(maxsize=10)
队尾插入数据x：q.put(x)
队首删除数据：q.get()，并返回该数据
返回队列的大小：q.qsize()
判断队列是否为空：q.empty()，若为空则返回True，反之则FALSE
判断是否为满：q.full与maxsize相呼应　　　

（1）新建一个deque对象：q=deque(‘abcdefgh‘)，或者创建一个大小为5的队列q=deque(5)
（1）q.appendleft(x)：在列表左侧插入【O（1）】
（2）q.popleft()：弹出列表左侧的值【O（1）】
（3）extendleft：在左侧扩展【O（k）】
（4）q.append(x)：在列表右侧插入【O（1）】
（5）q.pop()：弹出列表右侧的值【O（1）】
（6）extend：在右侧扩展【O（k）】
（7）q.rotate(-n)：将左端的n个元素移动到右端【O（k）】
　　 q.rotate(n)：将右端的n个元素移动到左端
　　 q=deque(‘abcdef‘)
　　 q.rotate(-2)
　　 print(q)//deque([‘c‘,‘d‘,‘e‘,‘f‘,‘a‘,‘b‘])
　　 q.rotate(2)
　　 print(q)//deque([‘e‘,‘f‘,‘a‘,‘b‘,‘c‘,‘d‘])
（8）q.remove(‘c‘)：删除一个指定元素【O（n）】
（9）q.clear()：清空链表所有元素，使其长度为0
（10）q.reverse()：将队列反转
（11）q.count(x)：返回q中x的数量
（12）len(q)：返回q的长度

class MyQueue (object):
    def __init__(self):
        self.stack1 = []
        self.stack2 = []

    def push(self, x):
        self.stack1.append(x)

    def pop(self):
        if self.stack2 != []: # 栈2不为空
            self.stack2.pop()
        elif self.stack2 == [] and self.stack1 != []:
                while self.stack1 != []:
                    tmp = self.stack1[-1]
                    self.stack1.pop()
                    self.stack2.append(tmp)
                self.stack2.pop()
        else: # 栈2为空，栈1为空
            print(‘query is empty‘)

    def top(self):
        return self.stack1[-1]

    def empty(self):
        if len(self.stack1) == 0 and len(self.stack2) == 0:
            return True
        else:
            return False

queue = MyQueue()
queue.push(1)
queue.push(2)
queue.pop()
queue.push(3)
print(queue)

class MyQueue(object):
    def __init__(self):
        self.queue1 = []
        self.queue2 = []

    def push(self, x):
        if len(self.queue2) == 0:
            self.queue1.append(x)
        if len(self.queue1) == 0:
            self.queue2.append(x)

    def pop(self):
        # 将queue的数放入另一个queue中，然后将当前queue里面的数一个个放入另一个queue，直到当前queue的长度为1时，删除当前queue最后一个数
        if len(self.queue1) != 0 and len(self.queue2) == 0:
            while len(self.queue1) != 1:
                tmp = self.queue1[-1]
                self.queue1.pop()
                self.queue2.append(tmp)
        else:
            while len(self.queue2) != 1:
                tmp = self.queue2[-1]
                self.queue2.pop()
                self.queue1.append(tmp)

    def peek(self):
        if len(self.queue1) == 0:
            return self.queue2[-1]
        else:
            return self.queue1[-1]

    def empty(self):
        if len(self.queue1) == 0 and len(self.queue2) == 0:
            return True
        else:
            return False

Queue = MyQueue()
Queue.push(1)
Queue.push(2)
print(Queue.peek())
Queue.pop()
print(Queue)

‘‘‘
下面的例子是用queue中的FIFO实现一个功能，6个人传土豆，每数到7就淘汰手中有土豆的人，直到最后只剩一个人。
‘‘‘

# 循环队列，num一定要比人数多
import queue
def hotpotato(namelist,num):
    que=queue.Queue(len(namelist))
    for name in namelist:
        que.put(name)
    while que.qsize()>1:
        for item in range(num-1):
            que.put(que.get()) # put队尾插入,get队首删除
        que.get()
    return que.get()

namelist=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
print(hotpotato(namelist,7))