(1）以文件的方式读入需要模拟的进程信息;(2）编写程序，模拟短作业调度算法、时间片轮转算法和优先数算法，均为可抢占的; (3）动态画出每个算法下每个进程的Gantt图，并计算以上算法中的每个进程的响应时间和周转时间

好的，这是一个比较复杂的问题，需要分步骤来实现。我们可以先从输入进程信息的部分开始，然后逐步实现三种算法，最后是输出Gantt图和计算各个进程的响应时间和周转时间。

1. 读入进程信息

首先，我们需要定义进程的数据结构。假设每个进程有进程ID，到达时间，需要执行的时间和优先级四个属性。

class Process:
    def __init__(self, pid, arrival_time, burst_time, priority):
        self.pid = pid
        self.arrival_time = arrival_time
        self.burst_time = burst_time
        self.priority = priority

然后，我们可以从文件中读取进程信息，并将其存储在一个列表中：

with open("input.txt", "r") as f:
    lines = f.readlines()

processes = []
for line in lines:
    pid, arrival_time, burst_time, priority = map(int, line.split())
    processes.append(Process(pid, arrival_time, burst_time, priority))

2. 短作业调度算法

短作业调度算法是一种非抢占式调度算法，它会按照进程的需要执行的时间来排序，然后依次执行每个进程。如果有多个进程需要同时执行，那么就按照它们的到达时间来排序。

我们可以先对进程列表进行按到达时间排序，然后按照需要执行的时间排序，最后依次执行每个进程并记录下相应的时间戳。

processes.sort(key=lambda p: (p.arrival_time, p.burst_time))

current_time = processes[0].arrival_time
for p in processes:
    if current_time < p.arrival_time:
        current_time = p.arrival_time
    print(f"Process {p.pid} starts at time {current_time}")
    current_time += p.burst_time
    print(f"Process {p.pid} finishes at time {current_time}")

3. 时间片轮转算法

时间片轮转算法是一种抢占式调度算法，它将CPU时间分成若干个时间片，每个进程在一个时间片内执行，如果在这个时间片内没有执行完，则剩余的部分会被放入队列末尾，等待下一个时间片继续执行。

我们可以使用一个队列来模拟这个过程。首先将所有进程按照到达时间排序，然后轮流执行每个进程，每个进程执行一个时间片，如果在这个时间片内没有执行完，则将其放入队列末尾，等待下一个时间片继续执行。如果队列为空，则表示所有进程已经执行完毕。

processes.sort(key=lambda p: p.arrival_time)

time_quantum = 2
queue = []
current_time = 0
while True:
    if not processes and not queue:
        break
    for p in processes:
        if p.arrival_time <= current_time:
            queue.append(p)
            processes.remove(p)
    if not queue:
        current_time += 1
        continue
    p = queue.pop(0)
    print(f"Process {p.pid} starts at time {current_time}")
    if p.burst_time <= time_quantum:
        current_time += p.burst_time
        print(f"Process {p.pid} finishes at time {current_time}")
    else:
        current_time += time_quantum
        p.burst_time -= time_quantum
        queue.append(p)

4. 优先数算法

优先数算法是一种非抢占式调度算法，它会按照进程的优先级来排序，优先级高的进程先执行。如果有多个进程的优先级相同，则按照它们的到达时间来排序。

我们可以先对进程列表进行按到达时间排序，然后按照优先级排序，最后依次执行每个进程并记录下相应的时间戳。

processes.sort(key=lambda p: (p.arrival_time, -p.priority))

current_time = processes[0].arrival_time
for p in processes:
    if current_time < p.arrival_time:
        current_time = p.arrival_time
    print(f"Process {p.pid} starts at time {current_time}")
    current_time += p.burst_time
    print(f"Process {p.pid} finishes at time {current_time}")

5. 输出Gantt图和计算响应时间和周转时间

最后，我们可以输出Gantt图，并计算各个进程的响应时间和周转时间。

gantt_chart = []
current_time = 0
for p in processes:
    if current_time < p.arrival_time:
        current_time = p.arrival_time
    gantt_chart.append((p.pid, current_time))
    current_time += p.burst_time

response_time_sum = 0
turnaround_time_sum = 0
for p in processes:
    for i, (pid, start_time) in enumerate(gantt_chart):
        if pid == p.pid:
            response_time = start_time - p.arrival_time
            turnaround_time = start_time + p.burst_time - p.arrival_time
            response_time_sum += response_time
            turnaround_time_sum += turnaround_time
            print(f"Process {p.pid}: response time = {response_time}, turnaround time = {turnaround_time}")

print(gantt_chart)

以上就是模拟三种调度算法的完整代码。需要注意的是，这里只是演示了如何实现这三种算法，实际上它们还有很多细节需要考虑，比如如何处理进程抢占、如何处理队列等，读者可以根据自己的需求进行修改和完善。