def priority_queue(input_data):
    # 解析输入数据
    elements = []
    # 处理输入字符串，移除所有空格和中文括号
    input_data = input_data.replace(' ', '').replace('（', '(').replace('）', ')')
    
    # 分割输入数据
    input_parts = input_data.split('),(')
    # 清理多余的括号
    input_parts = [part.replace('(', '').replace(')', '') for part in input_parts if part]
    
    # 存储 (priority, data) 和插入顺序
    queue = []
    insertion_order = 0  # 用于记录插入顺序
    
    for part in input_parts:
        if not part:
            continue
        
        # 处理分隔符可能是逗号或斜杠的情况
        if ',' in part:
            data, priority = part.split(',', 1)
        elif '/' in part:
            data, priority = part.split('/', 1)
        else:
            continue  # 跳过无效格式
            
        try:
            data = int(data)
            priority = int(priority)
        except ValueError:
            continue  # 跳过无法转换为整数的数据
            
        # 检查是否已存在相同的 (data, priority)
        duplicate = False
        for item in queue:
            if item[1] == data and item[0] == priority:
                duplicate = True
                break
        if not duplicate:
            queue.append((priority, data, insertion_order))
            insertion_order += 1
    
    # 排序：先按优先级降序，同优先级按插入顺序升序
    queue.sort(key=lambda x: (-x[0], x[2]))
    
    # 提取 data 部分
    result = [str(item[1]) for item in queue]
    return ','.join(result)

# 自定义输入测试
if __name__ == "__main__":
    print("请输入队列数据，格式如：(10,1),(20,1),(30,2)")
    print("输入完成后按Enter键执行")
    user_input = input("请输入: ")
    output = priority_queue(user_input)
    print("输出结果:")
    print(output)

队列的 Python 代码实现

队列是一种先进先出的数据类型。

应用场景：我们的计算机实验室有 30 台计算机与一台打印机联网。当学生想要打印时，他们的打印任务与正在等待的所有其他打印任务 “一致”。第一个进入的任务是先完成。如果你是最后一个，你必须等待你前面的所有其他任务打印。

queue 模块即队列，特别适合处理信息在多个线程间安全交换的多线程程序中。下面我们对 queue 模块进行一个详细的使用介绍。

queue 模块定义的类和异常

queue模块：消息安全地在多线程间交换，实现了多生产者、多消费者队列

看源码 queue 模块包含四个实用的类：

一、三种队列：

1、Queue()、SimpleQueue()：先进先出队列

import heapq

def simulate_message_queue():
    # 读取输入
    message_line = input().strip().split()
    consumer_line = input().strip().split()
    
    # 解析发布者的消息
    messages = []
    for i in range(0, len(message_line), 2):
        time = int(message_line[i])
        content = int(message_line[i + 1])
        messages.append((time, content))
    
    # 解析消费者的订阅和取消订阅
    consumers = []
    for i in range(0, len(consumer_line), 2):
        subscribe_time = int(consumer_line[i])
        unsubscribe_time = int(consumer_line[i + 1])
        consumers.append((subscribe_time, unsubscribe_time, i // 2))  # 消费者编号为i//2
    
    # 收集所有事件
    events = []
    for time, content in messages:
        events.append((time, 'message', content))
    for sub_time, unsub_time, consumer_id in consumers:
        events.append((sub_time, 'subscribe', consumer_id))
        events.append((unsub_time, 'unsubscribe', consumer_id))
    
    # 按时间排序事件，同一时刻的事件按订阅、取消订阅、消息的顺序处理
    events.sort(key=lambda x: (x[0], 0 if x[1] == 'subscribe' else (1 if x[1] == 'unsubscribe' else 2)))
    
    # 当前订阅的消费者，使用最小堆模拟最大优先级队列（优先级是负数）
    active_consumers = []
    consumer_messages = [[] for _ in range(len(consumers))]
    
    for event in events:
        time, event_type, data = event
        if event_type == 'subscribe':
            consumer_id = data
            # 使用负数模拟最大堆，因为消费者按优先级升序排列
            heapq.heappush(active_consumers, (-consumer_id, consumer_id))
        elif event_type == 'unsubscribe':
            consumer_id = data
            # 需要从堆中移除该消费者，这里简化处理，假设取消订阅时消费者一定在堆顶
            if active_consumers and active_consumers[0][1] == consumer_id:
                heapq.heappop(active_consumers)
            else:
                # 如果消费者不在堆顶，需要遍历整个堆来移除
                temp = []
                found = False
                while active_consumers:
                    item = heapq.heappop(active_consumers)
                    if item[1] == consumer_id:
                        found = True
                        break
                    temp.append(item)
                if not found:
                    for item in temp:
                        heapq.heappush(active_consumers, item)
        elif event_type == 'message':
            if active_consumers:
                # 获取优先级最高的消费者
                _, consumer_id = active_consumers[0]
                consumer_messages[consumer_id].append(data)
    
    # 输出结果
    for messages in consumer_messages:
        if messages:
            print(' '.join(map(str, messages)))
        else:
            print(-1)

simulate_message_queue()

进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道(不推荐使用)，这两种方式都是使用消息传递的

选自towardsdatascience

作者：Farhad Malik

机器之心编译

编辑：陈萍

Python中的队列源代码位于 lib/queue.py 「链接」中

前言

上篇文章介绍了 Python 中的多线程。今天来介绍下编程中常会用到的一个数据结构 - 队列。

不知道大家是否还记得什么是数据结构呢？在很早很早以前，Python小课堂的初期，讲了许多 Python 原生的数据结构。比如 list、tuple、dict 等。。。

既然叫数据结构，实际上就是为了给计算机存储数据用的一种结构体。不同的数据结构都有其不同的特点。那今天就来简单地聊聊队列！