编写一个进程调度程序，实现基于优先权的进程调度算法，要求：输入n个进程的信息:ID，进程名，优先级以及运行时间（以分钟计）。假设进程每等待1分钟，优先权提高1级。输出每经过1分钟间隔各个进程的运行状况。最后统计系统整体的平均周转时间，平均等待时间，平均响应时间。

以下是一个基于优先权的进程调度程序的代码示例：

class Process:
    def __init__(self, pid, name, priority, burst_time):
        self.pid = pid
        self.name = name
        self.priority = priority
        self.burst_time = burst_time
        self.wait_time = 0
        self.response_time = 0
        self.turnaround_time = 0

    def __repr__(self):
        return f"Process(pid={self.pid}, name='{self.name}', priority={self.priority}, burst_time={self.burst_time})"


def run_scheduler(processes):
    time_quantum = 1
    total_burst_time = sum(process.burst_time for process in processes)
    current_time = 0
    finished_processes = []

    while current_time < total_burst_time:
        runnable_processes = [process for process in processes if process.burst_time > 0]
        highest_priority = max(process.priority for process in runnable_processes)
        highest_priority_processes = [process for process in runnable_processes if process.priority == highest_priority]
        executing_process = min(highest_priority_processes, key=lambda process: process.burst_time)

        executing_process.burst_time -= time_quantum
        executing_process.priority += 1

        for process in runnable_processes:
            if process != executing_process:
                process.wait_time += time_quantum
                process.priority -= 1

        if executing_process.burst_time <= 0:
            executing_process.turnaround_time = current_time + time_quantum
            executing_process.response_time = executing_process.turnaround_time - executing_process.burst_time
            finished_processes.append(executing_process)

        current_time += time_quantum

    avg_turnaround_time = sum(process.turnaround_time for process in finished_processes) / len(finished_processes)
    avg_wait_time = sum(process.wait_time for process in finished_processes) / len(finished_processes)
    avg_response_time = sum(process.response_time for process in finished_processes) / len(finished_processes)

    print("进程\t运行时间\t等待时间\t响应时间\t周转时间")
    for process in finished_processes:
        print(f"{process.name}\t{process.burst_time}\t{process.wait_time}\t{process.response_time}\t{process.turnaround_time}")
    print(f"平均周转时间: {avg_turnaround_time}")
    print(f"平均等待时间: {avg_wait_time}")
    print(f"平均响应时间: {avg_response_time}")


if __name__ == '__main__':
    processes = [
        Process(1, "P1", 3, 10),
        Process(2, "P2", 1, 5),
        Process(3, "P3", 4, 8),
        Process(4, "P4", 2, 7),
    ]
    run_scheduler(processes)

在这个例子中，我们首先定义了一个 Process 类，用于存储每个进程的信息。然后，我们实现了一个 run_scheduler 函数，用于实现基于优先权的进程调度算法。

在调度算法中，我们首先计算出当前可运行的进程，并找到其中优先级最高的进程。然后，我们将该进程运行一段时间（这里设定为 1 分钟），并且将其优先级加 1。同时，我们将其他可运行进程的优先级减 1，以模拟等待时间的影响。

如果运行的进程在当前时间段内完成了所有工作，我们将其从可运行进程列表中移除，并记录其周转时间、等待时间和响应时间。最后，我们计算出所有进程的平均周转时间、平均等待时间和平均响应时间，并输出结果。

在上面的例子中，我们假设有 4 个进程，分别为 P1、P2、P3 和 P4。它们的优先级分别为 3、1、4 和 2，运行时间分别为 10、5、8 和 7 分钟。我们可以看到，程序会输出每个进程的运行状况，以及整体的平均周转时间、平均等待时间和平均响应时间。