为什么变量I'；我已经将“显示”定义为；“未定义”；用Python？

我正在测试一个写在网站上并发布的代码

代码部分位于网页的底部。运行测试代码mainpova.py时，出现语法错误

语法错误是

python mainprova4.py
 Traceback (most recent call last):
 File "mainprova4.py", line 1, in <module>
 import generation as gn
 File "/home/adam/DocumentsNew2/MathCode/SymbolicRegression/WebpageCode /generation.py", line 105, in <module>
  for i in range(0, numCrossover):
  NameError: name 'numCrossover' is not defined

python mainprova4.py
回溯（最近一次呼叫最后一次）：
文件“mainprova4.py”，第1行，在
将生成导入为gn
文件“/home/adam/DocumentsNew2/MathCode/symboliccregression/WebpageCode/generation.py”，第105行，在
对于范围内的i（0，numCrossover）：
NameError:未定义名称“numCrossover”

代码是

import random as rnd
import generator as gtr
import treeOperations as trop

class Generation(object):
def __init__(self):
self.membersWithErrors = []

def addMember(self, member):
  """ Add a tree to the generation """
  self.membersWithErrors.append([member, 0])

def setMember(self, member, index):
  """ Updates the member at the specified position """
   self.membersWithErrors[index] = member

def setError(self, index, error):
""" Sets the error of the member at the specified position """
  self.membersWithErrors[index][1] = error

def getMember(self, index):
""" Returns the member at the specified position """
  return self.membersWithErrors[index][0]

def getError(self, index):
""" Returns the error of the member at the specified position """
  return self.membersWithErrors[index][1]

def size(self):
""" Returns the number of members curently in the generation """
  return len(self.membersWithErrors)

def clear(self):
""" Clears the generation, i.e. removes all the members """
  self.membersWithErrors.clear()

def sort(self, descending):
""" Sorts the members of the generation according the their score """
  self.membersWithErrors.sort(key = lambda l: l[1], reverse = descending)

def getMembersForReproduction(self, numMembers, pickProb):
""" Returns a certain number of distinct members from the generation.
 The first member is selected with probability pickProb. If it's not          chosen, the 
  second member is selected with probability pickProb, and so on. """
  selectedMembers = []
  while len(selectedMembers) < numMembers: 
    indexSelected = 0  
    while rnd.randint(0, 100) > int(pickProb * 100) and indexSelected !=           len(self.membersWithErrors) - 1:
indexSelected += 1
memberWithErrorSelected = self.membersWithErrors[indexSelected]
if memberWithErrorSelected[0] not in selectedMembers:
   selectedMembers.append(memberWithErrorSelected[0])
return selectedMembers 

def next(self, crossoverPerc, mutationPerc, randomPerc, copyPerc,        shouldPruneForMaxHeight, minHeight, maxHeight, minValue, maxValue,   variables, operators):
""" It proceeds to the next generation with the help of genetic   operations """
oldMembersWithError = self.membersWithErrors
newMembersWithError = []
maxMembers = len(oldMembersWithError)
numCrossover = int(maxMembers * crossoverPerc)
numMutation = int(maxMembers * mutationPerc)
numRandom = int(maxMembers * randomPerc)
numCopy = maxMembers - numCrossover - numMutation - numRandom

# Crossover
for i in range(0, numCrossover):
 members = self.getMembersForReproduction(2, 0.3)
 m1 = members[0]
 m2 = members[1]
 newMember = trop.crossover(m1, m2)
 newMembersWithError.append([newMember, 0])

# Mutation
for i in range(0, numMutation):
 m1 = self.getMembersForReproduction(1, 0.3)[0]
 newMembersWithError.append([trop.mutation(m1, minValue, maxValue, variables, operators), 0])

# Random
for i in range(0, numRandom):
 newMembersWithError.append([gtr.getTree(minHeight, maxHeight, minValue,  maxValue, variables, operators), 0])

# Copy
members = self.getMembersForReproduction(numCopy, 0.3)
for m in members:
 newMembersWithError.append([m.clone(), 0])

 self.membersWithErrors = newMembersWithError

 # No side effects
 def pruneTreeForMaxHeight(tree, maxHeight, minValue, maxValue,   variables):
 """ Returns a new tree that is like the specified tree
 but pruned so that its height is maxHeight """
 def pruneTreeAux(tree, maxHeight, counter, minValue, maxValue,    variables):
 if tree.height() == 1:
    return tree.clone()
 if counter == maxHeight:
    return gtr.getLeaf(minValue, maxValue, variables)
pruned1 = pruneTreeAux(tree.op1, maxHeight, counter + 1, minValue, maxValue, variables)
  pruned2 = pruneTreeAux(tree.op2, maxHeight, counter + 1, minValue, maxValue, variables)
   return tr.BinaryOperatorInternalNode(tree.operator, pruned1, pruned2)
  return pruneTreeAux(tree, maxHeight, 1, minValue, maxValue, variables)

# Crossover
for i in range(0, numCrossover):
 members = self.getMembersForReproduction(2, 0.3)
 m1 = members[0]
 m2 = members[1]
 newMember = trop.crossover(m1, m2)
 if shouldPruneForMaxHeight and newMember.height() > maxHeight:
 newMember = trop.pruneTreeForMaxHeight(newMember, maxHeight, minValue,    maxValue, variables)
 newMembersWithError.append([newMember, 0])

随机导入为rnd
作为全球技术法规进口发电机
将treeOperations作为trop导入
类生成（对象）：
定义初始化（自）：
self.membersWithErrors=[]
def addMember（self，member）：
“”“将树添加到生成中”“”
self.membersWithErrors.append（[member，0]）
def集合成员（自身、成员、索引）：
“”“在指定位置更新成员”“”
self.membersWithErrors[索引]=成员
def setError（自身、索引、错误）：
“”“在指定位置设置成员的错误”“”
self.membersWithErrors[index][1]=错误
def getMember（自身，索引）：
“”“返回指定位置的成员”“”
返回self.membersWithErrors[索引][0]
def getError（自身，索引）：
“”“返回指定位置的成员的错误”“”
返回self.membersWithErrors[索引][1]
def大小（自身）：
“”“返回当前生成中的成员数”“”
返回len（自身成员错误）
def清除（自）：
“”“清除生成，即删除所有成员”“”
self.membersWithErrors.clear（）
def排序（自、递减）：
“”“根据分数对这一代的成员进行排序”“”
self.membersWithErrors.sort（key=lambda l:l[1]，reverse=descending）
def GetMembersForReconduction（自身、numMembers、pickProb）：
“”“从生成中返回一定数量的不同成员。
使用概率pickProb选择第一个成员。如果未选择，则
使用概率pickProb选择第二个成员，依此类推
selectedMembers=[]
而len（selectedMembers）int（pickProb*100）和indexSelected！=len（自身成员错误）-1：
indexSelected+=1
memberWithErrorSelected=self.membersWithErrors[indexSelected]
如果未在selectedMembers中选择成员[0]：
selectedMembers.append（memberWithErrorSelected[0]）
返回所选成员
def next（self、crossoverPerc、mutationPerc、randomPerc、copyPerc、shouldlruneformaxheight、minHeight、maxHeight、minValue、maxValue、变量、运算符）：
“在遗传操作的帮助下，它将继续发展到下一代”
oldMembersWithError=self.MembersWitherRor
新成员SwitherRor=[]
maxMembers=len（oldMembersWithError）
numCrossover=int（maxMembers*crossoverPerc）
numMutation=int（maxMembers*mutationPerc）
numRandom=int（maxMembers*randomPerc）
numCopy=maxMembers-numCrossover-numMutation-numRandom
#交叉
对于范围内的i（0，numCrossover）：
members=self.getmembersforreduction（2,0.3）
m1=成员[0]
m2=成员[1]
新成员=过渡渡线（m1，m2）
newMembersWithError.append（[newMember，0]）
#突变
对于范围内的i（0，numMutation）：
m1=自.GetMembersForeProduction（1,0.3）[0]
newMembersWithError.append（[trop.mutation（m1，minValue，maxValue，变量，运算符），0]）
#随机的
对于范围内的i（0，numRandom）：
newMembersWithError.append（[gtr.getTree（minHeight，maxHeight，minValue，maxValue，变量，运算符），0]）
#抄袭
members=self.getmembersforreduction（numCopy，0.3）
对于m in成员：
newMembersWithError.append（[m.clone（），0]）
self.memberswitherror=新成员switherror
#无副作用
def pruneTreeForMaxHeight（树、最大高度、最小值、最大值、变量）：
“”“返回与指定树相似的新树
但修剪后其高度为maxHeight“”
def PRUNETREAUX（树、最大高度、计数器、最小值、最大值、变量）：
如果tree.height（）==1：
return tree.clone（）
如果计数器==最大高度：
返回gtr.getLeaf（minValue、maxValue、变量）
pruned1=pruneTreeAux（tree.op1，maxHeight，计数器+1，minValue，maxValue，变量）
pruned2=pruneTreeAux（tree.op2，maxHeight，计数器+1，minValue，maxValue，变量）
返回tr.BinaryOperatorInternalNode（tree.operator，pruned1，pruned2）
返回pruneTreeAux（树，最大高度，1，最小值，最大值，变量）
#交叉
对于范围内的i（0，numCrossover）：
members=self.getmembersforreduction（2,0.3）
m1=成员[0]
m2=成员[1]
新成员=过渡渡线（m1，m2）
如果shouldRuneformaxheight和newMember.height（）>maxHeight：
newMember=trop.pruneTreeForMaxHeight（newMember、maxHeight、minValue、maxValue、变量）
newMembersWithError.append（[newMember，0]）

---

numCrossover已经定义。我在这里遗漏了什么？

第117行为您的for循环添加注释#交叉超出了next（）中的定义范围

随机导入为rnd
作为全球技术法规进口发电机
将treeOperations作为trop导入
类生成（对象）：
定义初始化（自）：
self.membersWithErrors=[]
def addMember（self，member）：
“”“将树添加到生成中”“”
self.membersWithErrors.append（[member，0]）
def集合成员（自身、成员、索引）：
“”“在指定位置更新成员”“”
self.membersWithErrors[索引]=成员
def setError（自身、索引、错误）：
“”“在指定位置设置成员的错误”“”
self.membersWithErrors[index][1]=错误
def getMember（自身，索引）：
“”“返回指定位置的成员”“”
返回self.membersWithErrors[索引][0]
def getError（自身，索引）：
“”“返回指定位置的成员的错误”“”
返回self.membersWithErrors[索引][1]
def大小（自身）：
“返回”
import random as rnd
import generator as gtr
import treeOperations as trop

class Generation(object):
    def __init__(self):
      self.membersWithErrors = []

def addMember(self, member):
  """ Add a tree to the generation """
  self.membersWithErrors.append([member, 0])

def setMember(self, member, index):
   """ Updates the member at the specified position """
   self.membersWithErrors[index] = member

def setError(self, index, error):
    """ Sets the error of the member at the specified position """
    self.membersWithErrors[index][1] = error

def getMember(self, index):
    """ Returns the member at the specified position """
    return self.membersWithErrors[index][0]

def getError(self, index):
    """ Returns the error of the member at the specified position """
    return self.membersWithErrors[index][1]

def size(self):
    """ Returns the number of members curently in the generation """
    return len(self.membersWithErrors)

def clear(self):
    """ Clears the generation, i.e. removes all the members """
    self.membersWithErrors.clear()

def sort(self, descending):
    """ Sorts the members of the generation according the their score """
    self.membersWithErrors.sort(key = lambda l: l[1], reverse = descending)

def getMembersForReproduction(self, numMembers, pickProb):
    """ Returns a certain number of distinct members from the generation.
    The first member is selected with probability pickProb. If it's not          chosen, the
    second member is selected with probability pickProb, and so on. """
    selectedMembers = []
    while len(selectedMembers) < numMembers:
      indexSelected = 0
      while rnd.randint(0, 100) > int(pickProb * 100) and indexSelected != len(self.membersWithErrors) - 1:
        indexSelected += 1
        memberWithErrorSelected = self.membersWithErrors[indexSelected]
        if memberWithErrorSelected[0] not in selectedMembers:
           selectedMembers.append(memberWithErrorSelected[0])
    return selectedMembers

def next(self, crossoverPerc, mutationPerc, randomPerc, copyPerc, shouldPruneForMaxHeight, minHeight, maxHeight, minValue, maxValue, variables, operators):
    """ It proceeds to the next generation with the help of genetic operations """
    oldMembersWithError = self.membersWithErrors
    newMembersWithError = []
    maxMembers = len(oldMembersWithError)

    numCrossover = int(maxMembers * crossoverPerc)
    numMutation = int(maxMembers * mutationPerc)
    numRandom = int(maxMembers * randomPerc)
    numCopy = maxMembers - numCrossover - numMutation - numRandom

    # Crossover
    for i in range(0, numCrossover):
        members = self.getMembersForReproduction(2, 0.3)
        m1 = members[0]
        m2 = members[1]
        newMember = trop.crossover(m1, m2)
        newMembersWithError.append([newMember, 0])

    # Mutation
    for i in range(0, numMutation):
        m1 = self.getMembersForReproduction(1, 0.3)[0]
        newMembersWithError.append([trop.mutation(m1, minValue, maxValue, variables, operators), 0])

    # Random
    for i in range(0, numRandom):
        newMembersWithError.append([gtr.getTree(minHeight, maxHeight, minValue, maxValue, variables, operators), 0])

    # Copy
    members = self.getMembersForReproduction(numCopy, 0.3)
    for m in members:
        newMembersWithError.append([m.clone(), 0])

    self.membersWithErrors = newMembersWithError

# No side effects
def pruneTreeForMaxHeight(tree, maxHeight, minValue, maxValue, variables):
    """ Returns a new tree that is like the specified tree
    but pruned so that its height is maxHeight """
    def pruneTreeAux(tree, maxHeight, counter, minValue, maxValue, variables):
        if tree.height() == 1:
            return tree.clone()
        if counter == maxHeight:
            return gtr.getLeaf(minValue, maxValue, variables)
        pruned1 = pruneTreeAux(tree.op1, maxHeight, counter + 1, minValue, maxValue, variables)
        pruned2 = pruneTreeAux(tree.op2, maxHeight, counter + 1, minValue, maxValue, variables)
        return tr.BinaryOperatorInternalNode(tree.operator, pruned1, pruned2)
    return pruneTreeAux(tree, maxHeight, 1, minValue, maxValue, variables)

def pruneTreeAux(tree, maxHeight, counter, minValue, maxValue,    variables):
    if tree.height() == 1:
        return tree.clone()
    if counter == maxHeight:
        return gtr.getLeaf(minValue, maxValue, variables)
        pruned1 = pruneTreeAux(tree.op1, maxHeight, counter + 1, minValue, maxValue, variables)
        pruned2 = pruneTreeAux(tree.op2, maxHeight, counter + 1, minValue, maxValue, variables)
        return tr.BinaryOperatorInternalNode(tree.operator, pruned1, pruned2)
    return pruneTreeAux(tree, maxHeight, 1, minValue, maxValue, variables)

# Crossover
for i in range(0, numCrossover):
    members = self.getMembersForReproduction(2, 0.3)
    m1 = members[0]
    m2 = members[1]
    newMember = trop.crossover(m1, m2)
    if shouldPruneForMaxHeight and newMember.height() > maxHeight:
        newMember = trop.pruneTreeForMaxHeight(newMember, maxHeight, minValue,    maxValue, variables)
        newMembersWithError.append([newMember, 0])