finder算法python代码

以下是一个简单的使用Finder算法的Python代码示例：

import math

class Node:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Finder:
    def __init__(self, start, end, obstacles):
        self.start = start
        self.end = end
        self.obstacles = obstacles

    def find_path(self):
        path = []
        open_list = [self.start]
        closed_list = []

        while len(open_list) > 0:
            current_node = open_list[0]
            for node in open_list:
                if self.distance(node, self.end) < self.distance(current_node, self.end):
                    current_node = node

            open_list.remove(current_node)
            closed_list.append(current_node)

            if current_node == self.end:
                while current_node != self.start:
                    path.append(current_node)
                    current_node = current_node.parent
                path.append(self.start)
                break

            neighbors = self.get_neighbors(current_node)
            for neighbor in neighbors:
                if neighbor in closed_list or neighbor in open_list:
                    continue
                neighbor.parent = current_node
                neighbor.g = current_node.g + self.distance(current_node, neighbor)
                neighbor.h = self.distance(neighbor, self.end)
                neighbor.f = neighbor.g + neighbor.h
                open_list.append(neighbor)

        path.reverse()
        return path

    def get_neighbors(self, node):
        neighbors = []
        for i in range(-1, 2):
            for j in range(-1, 2):
                if i == 0 and j == 0:
                    continue
                x = node.x + i
                y = node.y + j
                if x < 0 or y < 0 or x >= len(self.obstacles) or y >= len(self.obstacles[0]):
                    continue
                if self.obstacles[x][y] == 1:
                    continue
                neighbors.append(Node(x, y))
        return neighbors

    def distance(self, node1, node2):
        return math.sqrt((node1.x - node2.x)**2 + (node1.y - node2.y)**2)

这个代码实现了一个Finder类，用于在给定起点、终点和障碍物的情况下搜索路径。在调用`find_path`方法时，它将返回一个包含路径节点的列表，每个节点都包含`x`和`y`坐标属性。