（提问）关于操作系统空闲区的合并问题 #python

在完成操作系统的课程实验：可变分区管理方式下采用最先适应算法实现主存的分配与回收时，先进行作1业区和空闲区的初始化，然后逐条添加作1业，在释放任务时，需要将相连的空闲区合并，但是代码实现过程中出现了无法合并的现象，请大家帮帮忙

import ctypes


class Job(ctypes.Structure):
    _fields_ = [('jno', ctypes.c_int),
                ('jstart', ctypes.c_int),
                ('jlen', ctypes.c_int),
                ('flag',ctypes.c_int)]


class FileInfo(ctypes.Structure):
    _fields_ = [('fstart', ctypes.c_int),
                ('flen', ctypes.c_int),
                ('fstatus',ctypes.c_char),
                ('flag',ctypes.c_int)]


jt = (Job * 10)()  # 定义一个长度为10的数组jt
ft = (FileInfo * 10)()  # 定义一个长度为10的数组f

def vali():
    for i in range(10):
        if jt[i].jno == 0:
            break
        else:
            i = i + 1
    num1=i
    for j in range(10):
        if ft[j].flen == 0:
            break
        else:
            j = j + 1
    num2=j
    return num1,num2


def sort():
    jnum,snum=vali()
    for i in range(snum):
        for j in range(snum-i-1):
            if(ft[j].fstart>ft[j+1].fstart):
                s=ft[j].fstart
                l=ft[j].flen
                s1=ft[j+1].fstart
                l1=ft[j+1].flen
                ft[j].fstart=s1
                ft[j].flen=l1
                ft[j+1].fstart=s
                ft[j+1].flen=l
            else:
                break


def printJob():
    print("作业区表：\n""    作业号\t起始地址\t长度\n")
    for i in range(len(jt)):
       print("\t",jt[i].jno, "\t",jt[i].jstart, "\t" ,jt[i].jlen)
       print()


def printSpace():
    print("空闲区表：\n""    起始地址\t长度\t\t状态\n")
    for i in range(len(ft)):
       print("\t",ft[i].fstart, "\t",ft[i].flen,ft[i].fstatus.decode('utf-8').strip("'b'"))
       print()


def iniJob():
    print("初始化作业表")
    print("请输入作业信息")
    while(True):
        name, need_time,len = input().split()
        jno=int(name)
        jstart=int(need_time)
        jlen=int(len)
        if(jno==0):
            break
        for i in range(10):
            if jt[i].jno == 0:
                break
            else:
                i = i + 1
        jt[i].jno = jno
        jt[i].jstart = jstart
        jt[i].jlen =jlen

    # sort()
    printJob()


def iniSpace():
    print("初始化空闲区")
    print("请输入空闲区信息")
    while (True):
        start,len,status = input().split()
        fstart = int(start)
        flen = int(len)
        fstatus = bytes(status, 'utf-8')[0]
        if (flen == 0):
            break
        for i in range(10):
            if ft[i].flen == 0:
                break
            else:
                i = i + 1
        ft[i].fstart = fstart
        ft[i].flen = flen
        ft[i].fstatus = fstatus

    # sort()
    printSpace()


def putJob():
    print("请输入作业号和作业大小")
    number,length = input().split()
    num=int(number)
    len=int(length)
    jnum,snum= vali()
    j=0
    for i in range(snum):
        if(ft[i].flag==0):
            if(len<ft[i].flen):
                jt[jnum].jstart=ft[i].fstart
                ft[i].flen=ft[i].flen-len
                ft[i].fstart=ft[i].fstart+len
                jt[jnum].jno=num
                jt[jnum].flag=1
                jt[jnum].jlen=len
                jnum=jnum+1
                break
            elif(len==ft[i].flen):
                jt[jnum].jno=num
                jt[jnum].flag=1
                jt[jnum].jstart=ft[i].fstart
                jt[jnum].jlen=ft[i].flen
                jnum=jnum+1
                for j in range(i,snum):
                    ft[j]=ft[j+1]
                snum=snum-1
                break
            j=i
    if(j==snum):
        print("没有合适的空闲区，无法分配内存！")
    printJob()
    printSpace()

def merge():
    jnum, snum = vali()
    for i in range(snum-1):
        if(ft[i].fstart+ft[i].flen==ft[i+1].fstart):
            if(not ft[i].flag and not ft[i+1].flag):
                l1=ft[i+1].flen
                ft[i].flen+=l1
                for j in range(i+1,snum-1):
                    s = ft[j + 1].fstart
                    l = ft[j + 1].flen
                    ft[j].fstart = s
                    ft[j].flen = l
                ft[snum-1].fstart=0
                ft[snum-1].flen=0
                i=i-1
                snum=snum-1

def backJob():
    print("请输入作业序号")
    num=int(input())
    flag=0
    jnum, snum = vali()
    for i in range(jnum):
        if(jt[i].jno==num):
            ft[snum].fstart=jt[i].jstart
            ft[snum].flen=jt[i].jlen
            ft[snum].fstatus=b'F'
            ft[snum].flag=0
            snum=snum+1
            sort()
            merge()

            for j in range(i,jnum):
                jt[j]=jt[j+1]
            jnum=jnum-1
            flag=1
            break
    if(flag==0):
        print("没有您要撤销的作业，请重新输入！")
    printJob()
    printSpace()



def main():
    print("可变分区管理方式下采用最先适应算法实现主存的分配与回收\n1.初始化作业登记表和空闲区说明表\n2.主内存分配\n3.主内存回收\n4.退出\n5.输入错误")
    while(True):
        n=eval(input())
        if(n==1):
            print("请问您需要初始化作业（输入11）,还是初始化空闲区说明表（输入22)")
            m=eval(input())
            if(m==11):
                iniJob()
            else:
                iniSpace()
        elif(n==2):
            putJob()
        elif(n==3):
            backJob()
        elif(n==4):
            break
        elif(n==5):
            print("输入错误")




if __name__ == "__main__":
    main()

• 这有个类似的问题, 你可以参考下: https://ask.csdn.net/questions/7593995
• 这篇博客你也可以参考下：python计算正态分布曲线的置信区间：以投资组合收益置信区间为例，预测最大可能盈利及最大可能亏损
• 同时，你还可以查看手册：python- 定义扩展类型：已分类主题- 属性管理 中的内容
• 除此之外, 这篇博客: 基于Python的动物识别专家系统中的 3.2.2 整理好规则库之后，我们开始进行推理功能的编写，在这里我们根据相应的规则匹配模式，对用户输入的需要推理的信息进行相应的判断，然后一步步的询问用户相关的规则信息，进行进一步的推理，直到完全匹配出推理信息。代码如下： 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• def go(self, flag=True):
      self.Q = []
      self.P = []
      fo = open('RD.txt', 'r', encoding='utf-8')
      for line in fo:
          line = line.strip('\n')
          if line == '':
              continue
          line = line.split(' ')
          self.Q.append(line[line.__len__() - 1])
          del (line[line.__len__() - 1])
          self.P.append(line)
      fo.close()
      print("go按钮按下")
      self.lines = self.textEdit.toPlainText()
      self.lines = self.lines.split('\n')  # 分割成组
      self.DB = set(self.lines)
      print(self.DB)
      self.str = ""
      print(self.str)
      flag = True
      temp = ""
      for x in self.P:  # 对于每条产生式规则
          if ListInSet(x, self.DB):  # 如果所有前提条件都在规则库中
              self.DB.add(self.Q[self.P.index(x)])
              temp = self.Q[self.P.index(x)]
              flag = False  # 至少能推出一个结论
              # print("%s --> %s" %(x, self.Q[self.P.index(x)]))
              self.str += "%s --> %s\n" % (x, self.Q[self.P.index(x)])
  
      if flag:  # 一个结论都推不出
          print("一个结论都推不出")
          for x in self.P:  # 对于每条产生式
              if ListOneInSet(x, self.DB):  # 事实是否满足部分前提
                  flag1 = False       # 默认提问时否认前提
                  for i in x:  # 对于前提中所有元素
                      if i not in self.DB:  # 对于不满足的那部分
                          btn = s.quest("是否" + i)
                          if btn == QtWidgets.QMessageBox.Ok:
                              self.textEdit.setText(self.textEdit.toPlainText() + "\n" + i)  # 确定则增加到textEdit
                              self.DB.add(i)  # 确定则增加到规则库中
                              flag1 = True    # 肯定前提
                              # self.go(self)
                  if flag1:  # 如果肯定前提，则重新推导
                      self.go()
                      return
      self.textEdit_2.setPlainText(self.str)
      print("----------------------")
      print(self.str)
      if flag:
          btn = s.alert("啥也推不出来!!!")
          # if btn == QtWidgets.QMessageBox.Ok:  # 点击确定
          #     self.textEdit.setText(self.textEdit.toPlainText() + "\n确定")
      else:
          self.lineEdit.setText(temp)
  

• 您还可以看一下 李洪磊老师的线性回归与非线性回归分析简明教程（python版）-全程干货无废话课程中的 多项式非线性回归建模方法小节, 巩固相关知识点
  

引用chatgpt：

1. 确保在添加任务时正确地将任务分配到相应的作1业区和空闲区。如果没有正确地分配，那么在释放任务时就无法合并空闲区。

2. 在释放任务时，确保正确地合并相连的空闲区。可以尝试使用一个循环来遍历所有相邻的空闲区，并将它们合并为一个新的空闲区。

3. 检查是否存在内存泄漏或其他可能导致程序崩溃的问题。这些问题可能会导致程序在释放任务时出现异常行为。

4. 如果问题仍然存在，可以尝试使用调试工具(如gdb)来跟踪程序的执行过程，以便找到问题的根源。