Python 为什么我的红黑树搜索功能不工作？

我必须为红黑树创建和完成函数。搜索功能尤其令人头疼，因为它总是给我这个错误：

  File "C:\Users\YOLO246\Desktop\2211 Assignment 2\Code\rbtree.py", line 135, in insert
    (wasFound, node) = self.search(key)
TypeError: 'NoneType' object is not iterable

有人能帮我吗

#!/bin/python

### Module that implements a Red-Black Tree

BLACK = 1
RED = 0

class RBTree:

    class Node:
        """Nodes specific to this RBTree.  Nodes point at trees and trees
        point at nodes.  This will allow rotations that change the
        root.

        """
        def __init__(self, parent, key, value, colour=RED, sentinel=None):
            self._parent = parent
            self._key = key
            self._value = value
            self._colour = colour
            self._left = sentinel
            self._right = sentinel

        parent = property(fget=lambda self: self._parent,
                          doc="The node's parent")
        @parent.setter
        def set_parent(self, p):
            self._parent = p

        key = property(fget = lambda self: self._key,
                       doc="The node's key")
        @key.setter
        def set_key(self, k):
            self._key = k

        @property
        def value(self):
            """The value associated with this node's key"""
            return self._value

        @value.setter
        def set_value(self, v):
            self._value = v

        colour = property(fget=lambda self: self._colour,
                          doc="The node's colour, RED = 0, BLACK = 1")

        @colour.setter
        def set_colour(self, c):
            self._colour = c

        left = property(fget=lambda self: self._left,
                        doc="The node's left child")
        @left.setter
        def set_left(self, l):
            self._left = l


        right = property(fget=lambda self: self._right,
                         doc="The node's right child")

        @right.setter
        def set_right(self, r):
            self._right = r


        def __str__(self):
            return ("<value: %s, colour: %s,%n  parent: %s,%n  left: %s,%n  right: %s%n>" %
                    (self.key, self.colour, 
                     self.parent, self.left, self.right))

    ## --- Start of RB-Tree methods ---

    def __init__(self):
        self._NIL = list()
        self._root = self._NIL

    NIL = property(fget=lambda self: self._NIL, doc="Constant sentinel NIL")
    root = property(fget=lambda self: self._root, doc="The current root node")

    @root.setter
    def set_root(self, r):
        self._root = r

    def isRoot(self, node):
        return self.root == node

    def search(self, key):
        """Returns a tuple in the format (Found?, Node).  The first part of
        the tuple is True if the node was found and False
        otherwise. The node component of the result is the node
        containing key if it was already present, otherwise returns the
        node that would be the parent of where key would have been
        found in the tree.  (This latter choice of returned node
        avoids having to search the tree twice when inserting a new
        key into the tree)

        """
        parent = self.NIL
        curr = self._root
        while curr != self.NIL:
            # Implement the rest of this loop body below
            if key == curr.key:
                return (True, curr)
            elif key < curr.key:                                    
                 parent=curr.left          # code missing
                 curr=parent
            else:
                 parent=curr.right           # code missing
                 curr=parent
            return (False, parent)

#/bin/python
###实现红黑树的模块
黑色=1
红色=0
类RBTree：
类节点：
“”“特定于此RBTree的节点。节点指向树和树
指向节点。这将允许旋转以更改
根。
"""
定义初始化（自身、父项、键、值、颜色=红色、哨兵=无）：
self.\u parent=父
self.\u key=key
自我价值=价值
自身颜色=颜色
自左=哨兵
自我。右=哨兵
父项=属性（fget=lambda self:self.\u父项，
doc=“节点的父节点”）
@父设置器
def set_父级（自我，p）：
自我。_父母=p
键=属性（fget=lambda self:self.\u键，
doc=“节点的密钥”）
@键设定器
def设置_键（自，k）：
自。_键=k
@财产
def值（自身）：
“”“与此节点的键关联的值”“”
返回自我值
@价值设定者
def设置_值（自身，v）：
自我价值=v
颜色=属性（fget=lambda self:self.\u颜色，
doc=“节点的颜色，红色=0，黑色=1”）
@颜色设定器
def设置颜色（自身，c）：
自身颜色=c
左=属性（fget=lambda self:self.\u左，
doc=“节点的左子节点”）
@左二传手
def设置_左（自，左）：
自左=左
右=属性（fget=lambda self:self.\u右，
doc=“节点的右子节点”）
@右二传手
def设置为右（自，右）：
自我。_右=r
定义（自我）：
返回（“%”
（自钥匙、自彩色、，
self.parent，self.left，self.right）
##---RB树方法的开始---
定义初始化（自）：
self.\u NIL=list（）
self.\u root=self.\u NIL
NIL=属性（fget=lambda self:self.\u NIL，doc=“常数哨兵NIL”）
root=property（fget=lambda self:self.\u root，doc=“当前根节点”）
@根设置器
def set_根（自身，r）：
self.\u根=r
def isRoot（自身，节点）：
返回self.root==节点
def搜索（自我，密钥）：
“”“返回一个元组，其格式为（找到？、节点）。的第一部分
如果找到节点，则元组为True，如果为False，则元组为False
否则。结果的节点组件是节点
如果已存在，则包含键，否则返回
节点，该节点将是密钥所在位置的父节点
在树中找到。（返回节点的后一个选择
避免在插入新树时必须搜索树两次
（将钥匙插入树中）
"""
parent=self.NIL
curr=self.\u根
而咖喱！=self.NIL：
#实现下面这个循环体的其余部分
如果key==curr.key：
返回（真，当前）
elif键<当前键：
父项=当前左#缺少代码
curr=父级
其他：
父项=当前右侧#缺少代码
curr=父级
返回（False，父级）

您应该使用调试器逐步完成此操作。当您在第一步中点击return False时，无论发生什么情况，这都是非常明显的（除非他们搜索根键本身）。可能的缩进错误。我还认为你在循环中混淆了父母和咖喱，但既然没有循环，我想这没关系：）谢谢，伙计，我会试试你的建议，看看会发生什么