请给出一个python语言写的，A*算法求解八数码问题的可运行的代码，并且要能输出初始状态、目标状态、完整的最优解、扩展节点数和生成节点数，要求时间复杂度不是太大，不能陷入较长的等待运行结果。并且，不能出现unhashable的错误，以及其他语法错误

由于A*算法是一种启发式搜索算法，其时间复杂度与启发函数的选择有关，因此无法保证时间复杂度不会太大，但我们可以优化算法以尽可能减少运行时间。以下是一个可能的Python代码实现：

from queue import PriorityQueue

# 定义目标状态
goal_state = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]

# 定义启发函数，这里采用曼哈顿距离
def heuristic(state):
    distance = 0
    for i in range(3):
        for j in range(3):
            if state[i][j] != 0:
                distance += abs(i - (state[i][j]-1)//3) + abs(j - (state[i][j]-1)%3)
    return distance

# 定义状态类
class State:
    def __init__(self, state, g, parent=None):
        self.state = state
        self.g = g
        self.h = heuristic(state)
        self.parent = parent

    def __lt__(self, other):
        return self.g + self.h < other.g + other.h

    def __eq__(self, other):
        return self.state == other.state

    def __hash__(self):
        return hash(str(self.state))

    def get_children(self):
        children = []
        i, j = self.get_blank_position()
        if i > 0:
            child_state = self.get_copy()
            child_state[i][j], child_state[i-1][j] = child_state[i-1][j], child_state[i][j]
            children.append(State(child_state, self.g+1, self))
        if i < 2:
            child_state = self.get_copy()
            child_state[i][j], child_state[i+1][j] = child_state[i+1][j], child_state[i][j]
            children.append(State(child_state, self.g+1, self))
        if j > 0:
            child_state = self.get_copy()
            child_state[i][j], child_state[i][j-1] = child_state[i][j-1], child_state[i][j]
            children.append(State(child_state, self.g+1, self))
        if j < 2:
            child_state = self.get_copy()
            child_state[i][j], child_state[i][j+1] = child_state[i][j+1], child_state[i][j]
            children.append(State(child_state, self.g+1, self))
        return children

    def get_blank_position(self):
        for i in range(3):
            for j in range(3):
                if self.state[i][j] == 0:
                    return i, j

    def get_copy(self):
        return [row[:] for row in self.state]

# 定义A*算法
def astar(start_state):
    start = State(start_state, 0)
    queue = PriorityQueue()
    queue.put(start)
    closed_set = set()
    generated_count = 0
    while not queue.empty():
        current = queue.get()
        if current.state == goal_state:
            path = []
            while current is not None:
                path.append(current.state)
                current = current.parent
            path.reverse()
            return path, generated_count, len(closed_set)
        closed_set.add(current)
        for child in current.get_children():
            generated_count += 1
            if child in closed_set:
                continue
            queue.put(child)
    return None, generated_count, len(closed_set)

# 测试代码
start_state = [[2, 8, 3], [1, 6, 4], [7, 0, 5]]
path, generated_count, closed_count = astar(start_state)
if path is not None:
    print("Initial state:")
    print(start_state)
    print("Goal state:")
    print(goal_state)
    print("Path:")
    for state in path:
        print(state)
    print("Total steps:", len(path)-1)
    print("Generated nodes:", generated_count)
    print("Closed nodes:", closed_count)
else:
    print("Failed to find a solution.")

在上述代码中，我们首先定义了目标状态和启发函数，然后定义了状态类，其中包含了状态、g值、h值和父节点等信息。我们重载了状态类的一些方法，如小于运算符、等于运算符和哈希函数等，以便于后续的比较和存储。同时，我们还定义了一个方法用于获取状态的所有子节点，这里采用了四联通的移动方式，即上下左右四个方向。

在A*算法的实现中，我们使用了优先队列来存储待扩展的节点，每次取出h+g值最小的节点进行扩展。同时，我们维护了一个closed集合，用于存储已经扩展过的节点。由于我们采用了哈希函数来对状态进行哈希，因此不会出现unhashable的错误。在算法结束后，我们可以根据父节点指针，从最终状态一直回溯到初始状态，得到完整的最优解，并输出相关信息。