用python设计一个OS进程与内存管理模拟程序，要求： （1）程序运行后提供一个交互界面或窗口，允许用户输入以下命令并可以滴对命令进行解释执行， creatproc:提交作业命令，要求用户提供作业估计运行时长和内存大小需求。该命令的解释执行过程为对该作业创建对应的进程，完成PCB建立、存储空间分配等工作。（既执行OS的创建进程原语） killproc 进程号:终止进程命令。该命令的解释执行过程为对进程进行撤销，回收存储空间和PCB。 iostrartproc 进程号:阻塞进程命令。该命令的解释执行过程为对处于运行状态的进程进行阻塞操作，进程状态转为阻塞状态。 iofinishproc 进程号:阻塞进程命令。该命令的解释执行过程为对处于阻塞状态的进程进行唤醒操作，进程状态转为就绪状态。 psproc:显示所有进程状态命令。该命令的解释执行过程为显示出所有进程的状态信息，主要包括进程id，进程状态，存储空间地址。 mem:显示内存空间使用情况信息。该命令的解释执行过程为显示内存空间的占用和空闲情况。

好的，我可以帮你解答这个问题。下面是一个简单的OS进程与内存管理模拟程序的代码，你可以参考一下：

class PCB:
    def __init__(self, pid, runtime, memsize):
        self.pid = pid
        self.runtime = runtime
        self.memsize = memsize
        self.status = "ready"
        self.memstart = 0
        
class Memory:
    def __init__(self, size):
        self.size = size
        self.bitmap = [0] * size
        
    def allocate(self, size):
        start = -1
        count = 0
        for i in range(self.size):
            if self.bitmap[i] == 0:
                count += 1
                if count == size:
                    start = i - size + 1
                    break
            else:
                count = 0
        if start != -1:
            for i in range(start, start+size):
                self.bitmap[i] = 1
            return start
        else:
            return -1
        
    def free(self, start, size):
        for i in range(start, start+size):
            self.bitmap[i] = 0
        
class OS:
    def __init__(self, memsize):
        self.procs = []
        self.mem = Memory(memsize)
        self.pid = 0
        
    def creatproc(self, runtime, memsize):
        pid = self.pid
        self.pid += 1
        pcb = PCB(pid, runtime, memsize)
        memstart = self.mem.allocate(memsize)
        if memstart == -1:
            print("Memory allocation failed!")
            return
        pcb.memstart = memstart
        self.procs.append(pcb)
        print("Process created with PID", pid)
        
    def killproc(self, pid):
        for i in range(len(self.procs)):
            if self.procs[i].pid == pid:
                self.mem.free(self.procs[i].memstart, self.procs[i].memsize)
                del self.procs[i]
                print("Process", pid, "killed")
                return
        print("Process not found")
        
    def iostrartproc(self, pid):
        for i in range(len(self.procs)):
            if self.procs[i].pid == pid:
                if self.procs[i].status == "running":
                    self.procs[i].status = "blocked"
                    print("Process", pid, "blocked")
                else:
                    print("Process", pid, "is not running")
                return
        print("Process not found")
        
    def iofinishproc(self, pid):
        for i in range(len(self.procs)):
            if self.procs[i].pid == pid:
                if self.procs[i].status == "blocked":
                    self.procs[i].status = "ready"
                    print("Process", pid, "unblocked")
                else:
                    print("Process", pid, "is not blocked")
                return
        print("Process not found")
        
    def psproc(self):
        print("PID\tSTATUS\tMEMSTART\tMEMSIZE\tRUNTIME")
        for proc in self.procs:
            print(proc.pid, "\t", proc.status, "\t", proc.memstart, "\t\t", proc.memsize, "\t", proc.runtime)
            
    def mem(self):
        print("MEMORY SPACE:")
        for i in range(self.mem.size):
            if self.mem.bitmap[i] == 0:
                print("0", end="")
            else:
                print("1", end="")
        print("")

在上面的代码中，我们定义了三个类：PCB、Memory和OS。PCB类存储进程的信息，Memory类模拟内存的分配和释放，OS类实现进程管理的各种操作。

creatproc方法用于创建进程，首先生成一个唯一的pid，然后创建一个PCB对象并分配内存空间。如果内存空间不足，则输出错误信息。

killproc方法用于终止进程，首先查找该进程是否存在，然后释放其占用的内存空间。

iostrartproc方法用于阻塞进程，首先查找该进程是否处于运行状态，然后将其状态改为阻塞状态。

iofinishproc方法用于唤醒进程，首先查找该进程是否处于阻塞状态，然后将其状态改为就绪状态。

psproc方法用于显示所有进程的状态信息。

mem方法用于显示内存空间的占用和空闲情况。

你可以在交互界面或窗口中输入以上命令并查看程序的执行效果。