索引到字典并在Python中迭代

我正在使用以下代码将一个大型CSV（5000多行）文件索引到Python中：

index = {}
df = open('file.csv', encoding='UTF-8')

fp = 0
l = df.readline()
while l:
    r = l.split(',')
    index[r[0]] = fp
    fp = df.tell()
    l = df.readline()
df.seek(index["Sarah"])
print(df.readline())
df.close()

以下是文件内容的示例：

John, Always wears a blue hat
Alex, Always wears a red shirt
Sarah, Hates the colour pink

以下是如何编制索引的示例：

{'John': 26389, 'Alex': 217059, 'Sarah': 142108...}

我正在尝试将索引数据添加到我使用interactivepython教程构建的二进制搜索树中。以下是英国标准时间：

class TreeNode:
    def __init__(self,key,val,left=None,right=None,parent=None):
        self.key = key
        self.payload = val
        self.leftChild = left
        self.rightChild = right
        self.parent = parent

    def hasLeftChild(self):
        return self.leftChild

    def hasRightChild(self):
        return self.rightChild

    def isLeftChild(self):
        return self.parent and self.parent.leftChild == self

    def isRightChild(self):
        return self.parent and self.parent.rightChild == self

    def isRoot(self):
        return not self.parent

    def isLeaf(self):
        return not (self.rightChild or self.leftChild)

    def hasAnyChildren(self):
        return self.rightChild or self.leftChild

    def hasBothChildren(self):
        return self.rightChild and self.leftChild

    def replaceNodeData(self,key,value,lc,rc):
        self.key = key
        self.payload = value
        self.leftChild = lc
        self.rightChild = rc
        if self.hasLeftChild():
            self.leftChild.parent = self
        if self.hasRightChild():
            self.rightChild.parent = self


class BinarySearchTree:

    def __init__(self):
        self.root = None
        self.size = 0

    def length(self):
        return self.size

    def __len__(self):
        return self.size

    def put(self,key,val):
        if self.root:
            self._put(key,val,self.root)
        else:
            self.root = TreeNode(key,val)
        self.size = self.size + 1

    def _put(self,key,val,currentNode):
        if key < currentNode.key:
            if currentNode.hasLeftChild():
                   self._put(key,val,currentNode.leftChild)
            else:
                   currentNode.leftChild = TreeNode(key,val,parent=currentNode)
        else:
            if currentNode.hasRightChild():
                   self._put(key,val,currentNode.rightChild)
            else:
                   currentNode.rightChild = TreeNode(key,val,parent=currentNode)

    def __setitem__(self,k,v):
       self.put(k,v)

    def get(self,key):
       if self.root:
           res = self._get(key,self.root)
           if res:
                  return res.payload
           else:
                  return None
       else:
           return None

    def _get(self,key,currentNode):
       if not currentNode:
           return None
       elif currentNode.key == key:
           return currentNode
       elif key < currentNode.key:
           return self._get(key,currentNode.leftChild)
       else:
           return self._get(key,currentNode.rightChild)

    def __getitem__(self,key):
       return self.get(key)

    def __contains__(self,key):
       if self._get(key,self.root):
           return True
       else:
           return False

    def delete(self,key):
      if self.size > 1:
         nodeToRemove = self._get(key,self.root)
         if nodeToRemove:
             self.remove(nodeToRemove)
             self.size = self.size-1
         else:
             raise KeyError('Error, key not in tree')
      elif self.size == 1 and self.root.key == key:
         self.root = None
         self.size = self.size - 1
      else:
         raise KeyError('Error, key not in tree')

    def __delitem__(self,key):
       self.delete(key)

    def spliceOut(self):
       if self.isLeaf():
           if self.isLeftChild():
                  self.parent.leftChild = None
           else:
                  self.parent.rightChild = None
       elif self.hasAnyChildren():
           if self.hasLeftChild():
                  if self.isLeftChild():
                     self.parent.leftChild = self.leftChild
                  else:
                     self.parent.rightChild = self.leftChild
                  self.leftChild.parent = self.parent
           else:
                  if self.isLeftChild():
                     self.parent.leftChild = self.rightChild
                  else:
                     self.parent.rightChild = self.rightChild
                  self.rightChild.parent = self.parent

    def findSuccessor(self):
      succ = None
      if self.hasRightChild():
          succ = self.rightChild.findMin()
      else:
          if self.parent:
                 if self.isLeftChild():
                     succ = self.parent
                 else:
                     self.parent.rightChild = None
                     succ = self.parent.findSuccessor()
                     self.parent.rightChild = self
      return succ

    def findMin(self):
      current = self
      while current.hasLeftChild():
          current = current.leftChild
      return current

    def remove(self,currentNode):
         if currentNode.isLeaf(): #leaf
           if currentNode == currentNode.parent.leftChild:
               currentNode.parent.leftChild = None
           else:
               currentNode.parent.rightChild = None
         elif currentNode.hasBothChildren(): #interior
           succ = currentNode.findSuccessor()
           succ.spliceOut()
           currentNode.key = succ.key
           currentNode.payload = succ.payload

         else: # this node has one child
           if currentNode.hasLeftChild():
             if currentNode.isLeftChild():
                 currentNode.leftChild.parent = currentNode.parent
                 currentNode.parent.leftChild = currentNode.leftChild
             elif currentNode.isRightChild():
                 currentNode.leftChild.parent = currentNode.parent
                 currentNode.parent.rightChild = currentNode.leftChild
             else:
                 currentNode.replaceNodeData(currentNode.leftChild.key,
                                    currentNode.leftChild.payload,
                                    currentNode.leftChild.leftChild,
                                    currentNode.leftChild.rightChild)
           else:
             if currentNode.isLeftChild():
                 currentNode.rightChild.parent = currentNode.parent
                 currentNode.parent.leftChild = currentNode.rightChild
             elif currentNode.isRightChild():
                 currentNode.rightChild.parent = currentNode.parent
                 currentNode.parent.rightChild = currentNode.rightChild
             else:
                 currentNode.replaceNodeData(currentNode.rightChild.key,
                                    currentNode.rightChild.payload,
                                    currentNode.rightChild.leftChild,
                                    currentNode.rightChild.rightChild)

我试图做的是迭代索引字典，但我不断得到一个错误

下面是我如何反复浏览字典的：

for k, v in index.items():
    mytree[k] = v

---

我认为您的意思是根据csv位置在二叉树中添加元素。如果是这样，那么尝试根据元素的值（而不是键）添加元素

编辑：根据注释，OP似乎试图根据元素的名称（而不是值）在树中输入元素。为了捕获导致此异常的键值对，添加此代码如何？这将至少将问题缩小到导致此异常的特定键值对。一种可能性是，在某些情况下，键是字符串，而在其他情况下，键可能是int（只是猜测！）

def\u put（self、key、val、currentNode）：
尝试：
如果key

我认为您的意思是根据csv位置在二叉树中添加元素。如果是这样，那么尝试根据元素的值（而不是键）添加元素

编辑：根据注释，OP似乎试图根据元素的名称（而不是值）在树中输入元素。为了捕获导致此异常的键值对，添加此代码如何？这将至少将问题缩小到导致此异常的特定键值对。一种可能性是，在某些情况下，键是字符串，而在其他情况下，键可能是int（只是猜测！）

def\u put（self、key、val、currentNode）：
尝试：
如果key

一旦一些键是int，一些键是字符串，它们就不可比较，所以这是行不通的

你真的用电话了吗

ytree[1] = "One"

---

?？因为它使用一个int键，其余的代码将字符串作为键插入。应该是另一种情况。

一旦一些键是int，一些键是字符串，它们就不可比较，所以这是行不通的

你真的用电话了吗

ytree[1] = "One"

---

---

?？因为它使用一个int键，其余的代码将字符串作为键插入。应该是另一种方式。

请填写完整的stacktrace。谢谢回复。我该怎么做呢？我要冒险去猜这是一行错误：

如果key

？@leaf我就不会花时间读代码墙了。一定是这样@叶：强大的占卜能力：）但是我没有看到整数到字符串的转换。请填写完整的stacktrace。谢谢回复。我该怎么做呢？我要冒险去猜这是一行错误：

如果key

？@leaf我就不会花时间读代码墙了。一定是这样@leaf:强大的占卜能力：）但是我没有看到整数到字符串的转换。这可以将数据转换到二叉树中，但我不能用这种方式按名称搜索，或者可以吗？如果你想按名称查找某个内容，请使用dict。在使用以下格式将其添加到BST之前，它在字典中

{name:index number in csv}

如果我使用值而不是键将其导入BST，我将无法使用键搜索BST，可以吗？据我所知，它可以工作，只是不是这句话。你能推荐一句话吗？这样我就可以开始学习搜索等。这句话可以把数据放到二叉树中，但我不能用这种方式按名称搜索，或者我可以吗？如果你想按名称搜索，使用dict。在使用以下格式将其添加到BST之前，它在字典中

{name:index number in csv}

如果我使用值而不是键将其导入BST，我无法使用键搜索BST，可以吗？据我所知，它可以工作，只是不是这句话。你能推荐一句有用的话，让我开始学习搜索等。有没有更合适的方法来使用CSV索引并添加到BST？@128K:我不明白你为什么要做BST，这只是一个练习吗？这是一个基本上玩BST的练习，看看他们是如何工作的。有一种更合适的方法来使用CSV索引并添加到BST中？@128K:我不明白你为什么要做BST，这只是一个练习吗？这是一个基本上玩BST的练习，看看他们是如何工作的

def _put(self,key,val,currentNode):
    try:
        if key < currentNode.key:
            if currentNode.hasLeftChild():
               self._put(key,val,currentNode.leftChild)
            else:
               currentNode.leftChild = TreeNode(key,val,parent=currentNode)
        else:
            if currentNode.hasRightChild():
               self._put(key,val,currentNode.rightChild)
            else:
               currentNode.rightChild = TreeNode(key,val,parent=currentNode)
    except TypeError as e:
        print "key = ", key
        print "currentNode key = ", currentNode.key
        print "val = ", val
        raise e

ytree[1] = "One"