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

好的，下面是一个基于 Python 的进程与内存管理模拟程序的实现，包括交互界面和以上提到的命令：

import os

# 进程控制块 PCB 的数据结构
class PCB:
    def __init__(self, pid, runtime, mem_size):
        self.pid = pid
        self.status = "ready"
        self.runtime = runtime
        self.mem_size = mem_size
        self.mem_start = None # 进程所占用的内存起始地址

# 内存块的数据结构
class MemoryBlock:
    def __init__(self, start, size):
        self.start = start
        self.size = size
        self.status = "free"

# 存储 PCB 的列表
pcb_list = []

# 存储内存块的列表
memory_list = [MemoryBlock(0, 1024)]

# 进程 ID 计数器
pid_counter = 0

# 创建进程命令
def creatproc():
    global pid_counter
    pid_counter += 1
    runtime = int(input("请输入作业估计运行时长："))
    mem_size = int(input("请输入内存大小需求："))
    # 查找空闲内存块
    mem_start = None
    for block in memory_list:
        if block.status == "free" and block.size >= mem_size:
            mem_start = block.start
            break
    if mem_start is None:
        print("内存不足，创建进程失败！")
        return
    # 创建 PCB
    pcb = PCB(pid_counter, runtime, mem_size)
    pcb.mem_start = mem_start
    pcb_list.append(pcb)
    # 更新内存块列表
    if mem_size < block.size:
        block.start += mem_size
        block.size -= mem_size
    else:
        block.status = "used"
    print(f"创建进程成功，进程 ID 为 {pid_counter}")

# 终止进程命令
def killproc(pid):
    global pcb_list
    # 查找 PCB
    for i in range(len(pcb_list)):
        if pcb_list[i].pid == pid:
            # 更新内存块列表
            mem_start = pcb_list[i].mem_start
            mem_size = pcb_list[i].mem_size
            for j in range(len(memory_list)):
                if memory_list[j].start + memory_list[j].size == mem_start:
                    memory_list[j].size += mem_size
                    break
                elif memory_list[j].start == mem_start + mem_size:
                    memory_list[j].start = mem_start
                    memory_list[j].size += mem_size
                    break
                elif memory_list[j].start > mem_start:
                    memory_list.insert(j, MemoryBlock(mem_start, mem_size))
                    break
            # 删除 PCB
            del pcb_list[i]
            print(f"进程 {pid} 终止成功！")
            break
    else:
        print(f"进程 {pid} 不存在！")

# 阻塞进程命令
def iostrartproc(pid):
    global pcb_list
    # 查找 PCB
    for pcb in pcb_list:
        if pcb.pid == pid:
            pcb.status = "blocked"
            print(f"进程 {pid} 阻塞成功！")
            break
    else:
        print(f"进程 {pid} 不存在！")

# 唤醒进程命令
def iofinishproc(pid):
    global pcb_list
    # 查找 PCB
    for pcb in pcb_list:
        if pcb.pid == pid:
            pcb.status = "ready"
            print(f"进程 {pid} 唤醒成功！")
            break
    else:
        print(f"进程 {pid} 不存在！")

# 显示所有进程状态命令
def psproc():
    print("进程 ID\t状态\t运行时间\t内存起始地址\t内存大小")
    for pcb in pcb_list:
        print(f"{pcb.pid}\t{pcb.status}\t{pcb.runtime}\t\t{pcb.mem_start}\t\t{pcb.mem_size}")

# 显示内存空间使用情况命令
def mem():
    print("内存起始地址\t内存大小\t\t状态")
    for block in memory_list:
        print(f"{block.start}\t\t{block.size}\t\t{block.status}")

# 交互界面
while True:
    os.system("cls")
    print("欢迎使用进程与内存管理模拟程序！")
    print("命令列表：")
    print("creatproc：提交作业命令")
    print("killproc 进程号：终止进程命令")
    print("iostrartproc 进程号：阻塞进程命令")
    print("iofinishproc 进程号：唤醒进程命令")
    print("psproc：显示所有进程状态命令")
    print("mem：显示内存空间使用情况命令")
    cmd = input("请输入命令：")
    if cmd.startswith("creatproc"):
        creatproc()
    elif cmd.startswith("killproc"):
        pid = int(cmd.split()[1])
        killproc(pid)
    elif cmd.startswith("iostrartproc"):
        pid = int(cmd.split()[1])
        iostrartproc(pid)
    elif cmd.startswith("iofinishproc"):
        pid = int(cmd.split()[1])
        iofinishproc(pid)
    elif cmd == "psproc":
        psproc()
    elif cmd == "mem":
        mem()
    else:
        print("无效命令！")
    input("按任意键继续...")

在这个程序中，我们使用了类来定义 PCB 和内存块的数据结构，使用了列表来存储 PCB 和内存块的信息。此外，我们还使用了一个进程 ID 计数器，来确保每个进程的 ID 都是唯一的。

在交互界面中，我们使用了 `os.system("cls")` 函数来清空命令行窗口，使得控制台输出更加清晰。在每次执行命令后，我们还使用了 `input("按任意键继续...")` 函数来暂停程序的执行，等待用户按下任意键继续。这样可以使得用户更好地观察程序的执行情况。

最后需要注意的是，这个程序只是一个简单的模拟程序，没有考虑到多进程并发等问题。如果您需要进行更加复杂的模拟，建议使用专业的模拟工具或框架。