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

好的，我可以为你提供一个简单的Python程序，实现进程与内存管理模拟。

class Process:
    def __init__(self, pid, time, size):
        self.pid = pid
        self.time = time
        self.size = size
        self.status = "ready"
        self.mem_start = None
        self.mem_end = None

class Memory:
    def __init__(self, size):
        self.size = size
        self.free_mem = [{"start": 0, "end": size-1}]
        self.used_mem = []

    def allocate(self, size):
        for i in range(len(self.free_mem)):
            if self.free_mem[i]["end"] - self.free_mem[i]["start"] + 1 >= size:
                mem_start = self.free_mem[i]["start"]
                mem_end = mem_start + size - 1
                self.used_mem.append({"start": mem_start, "end": mem_end})
                self.free_mem[i]["start"] = mem_end + 1
                if self.free_mem[i]["start"] > self.free_mem[i]["end"]:
                    self.free_mem.pop(i)
                return mem_start, mem_end
        return None, None

    def deallocate(self, mem_start):
        for i in range(len(self.used_mem)):
            if self.used_mem[i]["start"] == mem_start:
                mem_end = self.used_mem[i]["end"]
                self.free_mem.append({"start": mem_start, "end": mem_end})
                self.used_mem.pop(i)

class OS:
    def __init__(self, mem_size):
        self.processes = []
        self.memory = Memory(mem_size)

    def create_process(self, time, size):
        pid = len(self.processes) + 1
        process = Process(pid, time, size)
        process.mem_start, process.mem_end = self.memory.allocate(size)
        if process.mem_start is not None and process.mem_end is not None:
            self.processes.append(process)
            print("Process {} created".format(pid))
        else:
            print("Memory allocation failed")

    def kill_process(self, pid):
        for process in self.processes:
            if process.pid == pid:
                self.memory.deallocate(process.mem_start)
                self.processes.remove(process)
                print("Process {} killed".format(pid))
                break
        else:
            print("Process {} not found".format(pid))

    def block_process(self, pid):
        for process in self.processes:
            if process.pid == pid and process.status == "running":
                process.status = "blocked"
                print("Process {} blocked".format(pid))
                break
        else:
            print("Process {} not found or not running".format(pid))

    def unblock_process(self, pid):
        for process in self.processes:
            if process.pid == pid and process.status == "blocked":
                process.status = "ready"
                print("Process {} unblocked".format(pid))
                break
        else:
            print("Process {} not found or not blocked".format(pid))

    def show_processes(self):
        for process in self.processes:
            print("Process ID: {}\nStatus: {}\nMemory start: {}\nMemory end: {}\n".format(process.pid, process.status, process.mem_start, process.mem_end))

    def show_memory(self):
        free_mem = self.memory.free_mem
        used_mem = self.memory.used_mem
        print("Free memory blocks:")
        for block in free_mem:
            print("Start: {}, End: {}".format(block["start"], block["end"]))
        print("Used memory blocks:")
        for block in used_mem:
            print("Start: {}, End: {}".format(block["start"], block["end"]))

os = OS(100)

while True:
    command = input("Enter a command: ")
    if command.startswith("creatproc"):
        time, size = command.split()[1:]
        os.create_process(int(time), int(size))
    elif command.startswith("killproc"):
        pid = int(command.split()[1])
        os.kill_process(pid)
    elif command.startswith("iostrartproc"):
        pid = int(command.split()[1])
        os.block_process(pid)
    elif command.startswith("iofinishproc"):
        pid = int(command.split()[1])
        os.unblock_process(pid)
    elif command == "psproc":
        os.show_processes()
    elif command == "mem":
        os.show_memory()
    else:
        print("Invalid command")

上述程序中，首先定义了一个 `Process` 类来存储进程的信息，包括进程ID、运行时间、内存占用大小、状态以及所占用的存储空间的起始地址和结束地址。接着定义了一个 `Memory` 类来管理内存的分配和回收，其中 `allocate` 方法用于分配内存空间，`deallocate` 方法用于回收内存空间。最后定义了一个 `OS` 类来实现各种命令的解释执行，包括创建进程、撤销进程、阻塞进程、唤醒进程、显示进程状态以及显示内存空间使用情况。在主程序中，使用一个 `while` 循环来不断等待用户输入命令，并根据命令调用相应的方法进行处理。

注意：上述程序只是一个简单的示例，还有很多细节问题需要考虑和完善，比如进程的调度策略、内存空间的分配算法等等。