Python因大量输入而崩溃

我正在尝试运行一个包含大量输入的python程序。 它可以使用1k输入，但当我尝试1M时，它会永远冻结

以下是我读取输入的方式：

这是我的主要观点：

def main():

  global raiz  
  inputs = raw_input()
  output = []
  inputs = inputs.lower()
  split = inputs.split(" ")
  while (inputs!=""):
      if (split[0] == "pass"):
          if (split[2] == "r"):
              novo = No(split[1].upper(), 1, True)
          else:
              novo = No(split[1].upper(), 1, False)

          if raiz == None:
              raiz = novo
          else:
              encontraNo(novo)

      elif (split[0] == "status"):
          if (raiz == None):
              output.append(split[1].upper()+" NO RECORD")
          else:
              novo = No(split[1].upper(), 0, False)
              output.append(procuraStatus(novo))
      elif (split[0] == "unflag"):
          if (raiz != None):
              novo = No(split[1].upper(),0, False)
              actualizaEstado(novo)
      inputs = raw_input()
      inputs = inputs.lower()
      split = inputs.split(" ")        


  for out in output:
      print out    
main()

我可以“输入”到我的程序的输入是否有限制？ 我正在使用WingIDE5.0。 我可以发布其余的代码，但我不认为这个问题与它有关，而是与我可以提供给python程序的输入限制有关

编辑：

我试着在控制台上运行它，它在50k输入下运行良好。 然而，当我运行100万个输入并让它工作（大约2小时）时，我没有得到任何结果，所以我停止了程序。以下是我在控制台中得到的信息：

C:\Users\Tomás\Documents\Engenharia Informática\PYTHON>python TP2C.py
Traceback (most recent call last):
  File "TP2C.py", line 210, in <module>
    main()


C:\Users\Tomás\Documents\Engenharia Informática\PYTHON>python TP2C.py < F50K.txt

A15833 5 R

C:\Users\Tomás\Documents\Engenharia Informática\PYTHON>python TP2C.py < F1M.txt
Traceback (most recent call last):
  File "TP2C.py", line 210, in <module>
    main()
  File "TP2C.py", line 191, in main
    encontraNo(novo)
  File "TP2C.py", line 84, in encontraNo
    valor_matricula_noActual = ''.join(str(ord(c)) for c in so)
  File "TP2C.py", line 84, in <genexpr>
    valor_matricula_noActual = ''.join(str(ord(c)) for c in so)
KeyboardInterrupt

C:\Users\Tomás\Documents\Engenharia Informática\PYTHON>

C:\Users\Tomás\Documents\Engenharia Informática\PYTHON>PYTHON TP2C.py
回溯（最近一次呼叫最后一次）：
文件“TP2C.py”，第210行，在
main（）
C:\Users\Tomás\Documents\Engenharia Informática\PYTHON>PYTHON TP2C.pyPYTHON TP2C.py

这是我的完整代码，如果你想查看

class No_Avl(object):




    def __init__(self, matricula, estado, numero):
        self.filhoDireito = None
        self.filhoEsquerdo = None
        self.matricula = matricula
        self.numero = numero
        self.estado = estado
        self.altura = 0


class Arvore_Avl(object):
    global raiz




    def __init__(self):
        global raiz
        raiz = None

    def altura(self,noActual):
        if (noActual == None):
            return (-1)
        return noActual.altura

    def adicionaNoo(self, matricula, estado, numero):
        global raiz
        raiz = self.adicionaNo(matricula, estado, numero, raiz)

    def adicionaNo(self,matricula, estado, numero, noActual):

        if (noActual == None):
            noActual = No_Avl(matricula, estado, numero)
        elif (noActual != None):
            s = matricula
            valor_matricula = ''.join(str(ord(c)) for c in s)
            s = noActual.matricula
            valor_matricula_noActual = ''.join(str(ord(c)) for c in s)            
            if(valor_matricula < valor_matricula_noActual):
                noActual.filhoEsquerdo = self.adicionaNo(matricula, estado, numero, noActual.filhoEsquerdo)
                if (self.altura(noActual.filhoEsquerdo) - self.altura(noActual.filhoDireito) == 2):
                    s = matricula
                    valor_matricula = ''.join(str(ord(c)) for c in s)
                    s = noActual.matricula
                    valor_matricula_noActual = ''.join(str(ord(c)) for c in s)                
                    if (valor_matricula < valor_matricula_noActual):
                        noActual = self.rotateWithLeftChild(noActual)
                    else:
                        noActual = self.doubleWithLeftChild(noActual)

            elif (valor_matricula > valor_matricula_noActual):
                noActual.filhoDireito = self.adicionaNo(matricula, estado, numero, noActual.filhoDireito)
                if (self.altura(noActual.filhoDireito) - self.altura(noActual.filhoEsquerdo) == 2):
                    s = matricula
                    valor_matricula = ''.join(str(ord(c)) for c in s)
                    s = noActual.matricula
                    valor_matricula_noActual = ''.join(str(ord(c)) for c in s)                    
                    if (valor_matricula > valor_matricula_noActual):
                        noActual = self.rotateWithRightChild(noActual)
                    else:
                        noActual = self.doubleWithRightChild(noActual)

            else:
                return None
        noActual.altura = max(self.altura(noActual.filhoEsquerdo), self.altura(noActual.filhoDireito)) +1

        return noActual

    def encontraNoo(self, matricula):

        global raiz
        return self.encontraNo(matricula, raiz)    


    def encontraNo(self, matricula, noActual):

        while (noActual != None):
            s = matricula
            valor_matricula = ''.join(str(ord(c)) for c in s) 
            so = noActual.matricula
            valor_matricula_noActual = ''.join(str(ord(c)) for c in so)
            if (valor_matricula < valor_matricula_noActual):
                noActual = noActual.filhoEsquerdo
            elif (valor_matricula > valor_matricula_noActual):
                noActual = noActual.filhoDireito
            else:
                return noActual
        return None



    def rotateWithLeftChild(self, k2):
        k1 = k2.filhoEsquerdo
        k2.filhoEsquerdo = k1.filhoDireito
        k1.filhoDireito = k2
        k2.altura = max(self.altura(k2.filhoEsquerdo), self.altura(k2.filhoDireito))+1
        k1.altura = max(self.altura(k1.filhoEsquerdo), k2.altura) +1

        return k1

    def rotateWithRightChild(self, k1):
        k2 = k1.filhoDireito
        k1.filhoDireito = k2.filhoEsquerdo
        k2.filhoEsquerdo = k1
        k1.altura = max(self.altura(k1.filhoEsquerdo), self.altura(k1.filhoDireito))+1

        return k2

    def doubleWithLeftChild(self, k3):
        k3.filhoEsquerdo = rotateWithRightChild(k3.leftChild)
        return rotateWithLeftChild(k3)

    def doubleWithRightChild(self, k1):
        k1.filhoDireito = rotateWithLeftChild(k1.filhoDireito)
        return rotateWithRightChild(k1)

def main():

    global raiz
    arvore = Arvore_Avl()

    inputs = raw_input()
    inputs = inputs.lower()
    split = inputs.split(" ")
    while (inputs!=""):

        if (split[0] == "pass"):

            if(arvore.encontraNoo(split[1]) != None):
                arvore.encontraNoo(split[1]).numero += 1
                arvore.encontraNoo(split[1]).estado = split[2]
            else:
                arvore.adicionaNoo(split[1], split[2], 1)

        elif (split[0] == "status"):
            mat = split[1]

            if (arvore.encontraNoo(mat)!= None):
                print(split[1].upper() + " "+ str(arvore.encontraNoo(split[1]).numero) + " "+arvore.encontraNoo(split[1]).estado.upper())

            else:
                print(split[1].upper()+" NO RECORD")

        elif (split[0] == "unflag"):
            if (arvore.encontraNoo(split[1]) != None):
                arvore.encontraNoo(split[1]).estado = "R"
        inputs = raw_input()
        inputs = inputs.lower()
        split = inputs.split(" ")        


main()

class No\u Avl（对象）：
定义初始（自我、矩阵、状态、数字）：
self.filhoDireito=无
self.filhoEsquerdo=无
self.matricula=matricula
self.numero=numero
self.estado=estado
self.altura=0
类Arvore_Avl（对象）：
全球raiz
定义初始化（自）：
全球raiz
raiz=无
def altura（自身，非实际）：
如果（无实际==无）：
返回（-1）
返回无实际阿尔图拉
def adicionano（自我、母体、estado、数字）：
全球raiz
raiz=自我。阿迪西奥纳诺（matricula，estado，numero，raiz）
def adicionaNo（自身、母体、estado、数字、非实际）：
如果（无实际==无）：
无实际值=无平均值（矩阵、状态、数字）
elif（无实际值！=无）：
s=母体
勇气矩阵=''。连接（str（ord（c））表示s中的c）
s=无实际母体
勇气（矩阵）实际值=''。连接（str（ord（c））表示s中的c）
如果（勇气<勇气）：
noActual.filhoEsquerdo=self.adicionaNo（matricula，estado，numero，noActual.filhoEsquerdo）
如果（self.altura（noActual.filhoeskerdo）-self.altura（noActual.filhoDireito）==2）：
s=母体
勇气矩阵=''。连接（str（ord（c））表示s中的c）
s=无实际母体
勇气（矩阵）实际值=''。连接（str（ord（c））表示s中的c）
如果（勇气<勇气）：
noActual=self.rotateWithLeftChild（noActual）
其他：
noActual=self.doubleWithLeftChild（noActual）
elif（勇气>勇气）：
noActual.filhoDireito=self.adicionaNo（matricula，estado，numero，noActual.filhoDireito）
如果（self.altura（noActual.filhoDireito）-self.altura（noActual.filhoeskerdo）==2）：
s=母体
勇气矩阵=''。连接（str（ord（c））表示s中的c）
s=无实际母体
勇气（矩阵）实际值=''。连接（str（ord（c））表示s中的c）
如果（勇气>勇气）：
noActual=self.rotateWightChild（noActual）
其他：
noActual=self.doubleWithRightChild（noActual）
其他：
一无所获
noActual.altura=max（self.altura（noActual.filhoEsquerdo），self.altura（noActual.filhoDireito））+1
无实际回报
def encontraNoo（自我，母体）：
全球raiz
返回自我。安孔塔诺（matricula，raiz）
def encontraNo（自我、母体、非实际）：
而（无实际！=无）：
s=母体
勇气矩阵=''。连接（str（ord（c））表示s中的c）
因此=没有实际的母体
勇气（矩阵）实际值=''。在so中加入（str（ord（c））代表c）
如果（勇气<勇气）：
noActual=noActual.filhoEsquerdo
elif（勇气>勇气）：
noActual=noActual.filhoDireito
其他：
无实际回报
一无所获
def rotateWithLeftChild（自身，k2）：
k1=k2.Filhoeskerdo
k2.Filhoeskerdo=k1.filhoDireito
k1.filhoDireito=k2
k2.altura=最大值（self.altura（k2.Filhoeskerdo），self.altura（k2.filhoDireito））+1
k1.altura=最大值（自altura（k1.Filhoeskerdo），k2.altura）+1
返回k1
def RotateWithChild（自身，k1）：
k2=k1.filhoDireito
k1.filhoDireito=k2.Filhoeskerdo
k2.Filhoeskerdo=k1
k1.altura=最大值（self.altura（k1.Filhoeskerdo），self.altura（k1.filhoDireito））+1
返回k2
def doubleWithLeftChild（自我，k3）：
k3.filhoEsquerdo=旋转第三个孩子（k3.leftChild）
返回旋转的第三个孩子（k3）
def doubleWithRightChild（自身，k1）：
k1.filhoDireito=旋转到第四排（k1.filhoDireito）
返回旋转第三个孩子（k1）
def main（）：
全球raiz
arvore=arvore_Avl（）
输入=原始输入（）
inputs=inputs.lower（）
拆分=输入。拆分（“”）
while（输入！=“”）：
如果（拆分[0]=“通过”）：
如果（阿弗）