我也尝试开发这种方法，但这样的事情并不奏效，因为我需要叶子prendrend决定位置的值（x， y），这里是类QuadTree（object）：

def __init__(self, items=[], depth=6, boundingRect=None):
    # The sub-quadrants are empty to start with.
    self.nw = self.ne = self.se = self.sw = None

    # If we've reached the maximum depth then insert all items into this
    # quadrant.
    self.depth = depth
    if self.depth == 0:
        self.items = items
        return

    # Find this quadrant's centre.
    if boundingRect:
        l, t, r, b = self.l, self.t, self.r, self.b = boundingRect
    else:
        # If there isn't a bounding rect, then calculate it from the items.
        l = self.l = min(item.rect.left for item in items)
        t = self.t = min(item.rect.top for item in items)
        r = self.r = max(item.rect.right for item in items)
        b = self.b = max(item.rect.bottom for item in items)
    cx = self.cx = (l + r) * 0.5
    cy = self.cy = (t + b) * 0.5

    self.items = []
    if not items:
        return
    nw_items = []
    ne_items = []
    se_items = []
    sw_items = []

    for item in items:
        # Which of the sub-quadrants does the item overlap?
        in_nw = item.rect.left <= cx and item.rect.top <= cy
        in_sw = item.rect.left <= cx and item.rect.bottom >= cy
        in_ne = item.rect.right >= cx and item.rect.top <= cy
        in_se = item.rect.right >= cx and item.rect.bottom >= cy

        # If it overlaps all 4 quadrants then insert it at the current
        # depth, otherwise append it to a list to be inserted under every
        # quadrant that it overlaps.
        if in_nw and in_ne and in_se and in_sw:
            self.items.append(item)
        else:
            if in_nw: nw_items.append(item)
            if in_ne: ne_items.append(item)
            if in_se: se_items.append(item)
            if in_sw: sw_items.append(item)

    # Create the sub-quadrants, recursively.
    if nw_items:
        self.nw = QuadTree(nw_items, self.depth-1, (l, t, cx, cy))
    if ne_items:
        self.ne = QuadTree(ne_items, self.depth-1, (cx, t, r, cy))
    if se_items:
        self.se = QuadTree(se_items, self.depth-1, (cx, cy, r, b))
    if sw_items:
        self.sw = QuadTree(sw_items, self.depth-1, (l, cy, cx, b))

def insert(self, item):
    # If we've reached the maximum depth then insert item in this quadrant.
    if self.depth == 0:
        self.items.append(item)
        return

    in_nw = item.rect.left <= self.cx and item.rect.top <= self.cy
    in_sw = item.rect.left <= self.cx and item.rect.bottom >= self.cy
    in_ne = item.rect.right >= self.cx and item.rect.top <= self.cy
    in_se = item.rect.right >= self.cx and item.rect.bottom >= self.cy

    # If it overlaps all 4 quadrants then insert it at the current
    # depth, otherwise append it to the item list of every quadrant
    # that it overlaps.
    if in_nw and in_ne and in_se and in_sw:
        self.items.append(item)
    else:
        if in_nw:
            if self.nw:
                self.nw.insert(item)
            else:
                self.nw = QuadTree([item], self.depth-1,
                                   (self.l, self.t, self.cx, self.cy))
        if in_ne:
            if self.ne:
                self.ne.insert(item)
            else:
                self.ne = QuadTree([item], self.depth-1,
                                   (self.cx, self.t, self.r, self.cy))
        if in_se:
            if self.se:
                self.se.insert(item)
            else:
                self.se = QuadTree([item], self.depth-1,
                                   (self.cx, self.cy, self.r, self.b))
        if in_sw:
            if self.sw:
                self.sw.insert(item)
            else:
                self.sw = QuadTree([item], self.depth-1,
                                   (self.l, self.cy, self.cx, self.b))

def remove(self, item):
    # If we've reached the maximum depth remove the itam from this quadrant.
    if self.depth == 0:
        self.items.remove(item)
        return

    in_nw = item.rect.left <= self.cx and item.rect.top <= self.cy
    in_sw = item.rect.left <= self.cx and item.rect.bottom >= self.cy
    in_ne = item.rect.right >= self.cx and item.rect.top <= self.cy
    in_se = item.rect.right >= self.cx and item.rect.bottom >= self.cy

    # If it overlaps all 4 quadrants remove it, otherwise
    # search the lower quadrants for it
    if in_nw and in_ne and in_se and in_sw:
        self.items.remove(item)
    else:
        if in_nw and self.nw:
                self.nw.remove(item)
        if in_ne and self.ne:
                self.ne.remove(item)
        if in_se and self.se:
                self.se.remove(item)
        if in_sw and self.sw:
                self.sw.remove(item)

类类Item（object）：

    def __init__(self, left, top, right, bottom):
        self.left = left
        self.top = top
        self.right = right
        self.bottom = bottom