Create python list backup

I have a problem in this code, I'm trying to solve the 8puzzle, the problem arises when generating the possible configurations of the current configuration, when I start to create them to the function that creates them I send as an argument the current state and must generate a new one for each possible movement,
in the first call it does fine, but when I call it back the argument that is supposed to be the current state has the value of the new state that had been created
and I do not understand why this happens if someone could help me find where my mistake would be very much appreciated.

This is my code.

init_ = [[1, 2, 3], [0, 5, 6], [4, 7, 8]]ending_ = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]print ('Initial state')
for k in init_:
    print (k)
notrepet = [] #nodes created
_patch = [] #path
Open_tail = [] # from where the nodes sacaremso
#defining movements
'' '
up = 1
down = 0
left = 2
right = 3
'' '
lista_mov = [("arriba", 1), ("abajo", 0), ("izquierda", 2), ("derecha", 3)]

'' '
COMPLEMETO FUNCTION TO THE VALIDAR_MOV FUNCTION
'' '

def Validate_pos (pos, xy):
    if xy == 0: # we see pos in x
        if pos[0] > = 0 and pos[0] < 3:
            return True
        else:
            return False
    elif xy == 1: #verificamos posicion en y
        if pos[1] >= 0 and pos[1] <3:
            return True
        else:
            return False

'' '
FUNCTION TO VALIDATE A MOVEMENT IF YOU ARE INSIDE THE BOARD, if it is valid we return the new post
'' '
def validate_mov (mov, current_state):
    if mov == 1: #if we move up
        new_pos = (current_state[0]-1, current_state[1]) # we create new position
        if Validar_pos (new_pos, 0): # if True returns because the pos is valid
            return new_pos
        else:
            return False
    elif mov == 0: #if we move down
        new_pos = (current_state[0]+1, current_state[1]) # we create new position
        if Validar_pos (new_pos, 0): # if True returns because the pos is valid
            return new_pos
        else:
            return False
    elif mov == 2: #if we move left
        new_pos = (current_state[0], Actual state[1]-1) # we create new position
        if Validar_pos (new_pos, 1): # if True returns because the pos is valid
            return new_pos
        else:
            return False
    if mov == 3: #if we move right
        new_pos = (current_state[0], Actual state[1]+1) # we create new position
        if Validar_pos (new_pos, 1): # if True returns because the pos is valid
            return new_pos
        else:
            return

def create_tab (current_state, new_pos, old_pos):
    new_estado = list (current_state)
    back_num = current_state[new_pos[new_pos[new_pos[new_pos[0]][new_pos[new_pos[new_pos[new_pos[1]]# we save the value that was in the pos where we will move the 0
    new_estado[new_pos[new_pos[new_pos[new_pos[0]][new_pos[new_pos[new_pos[new_pos[1]]= 0 #set the 0 in the new position
    new_estado[old_pos[old_pos[old_pos[old_pos[0]][old_pos[old_pos[old_pos[old_pos[1]]= back_num # and the value that was in new_pos we passed it to old_pos
    return new_estado.copy ()

def calculate_heuristic (state):
    hueristica = 0
    for lis1, lis2 in zip (status, ending_):
        for p1, p2 in zip (lis1, lis2):
            if p1! = 1:
                if p1! = p2:
                    h + 1
    return hueristica

Def Create_sucesor (current_status, mov, pos_cero):
    successor = set ()
    test_pos = validate_mov (mov, pos_cero[0]) #as it is a list that contains a single element we take it out and send it as a set
    if test_pos: #if it is not false, it is a position within the board
        new_state = create_tab (current_state, test_pos, pos_cero[0]) # I create a new board
        print ("generated status")
        for l in new_estado:
            print (l)
        if new_stated not in notrepet: #verify if this configuration is not repeated
            h = calculate_heuristic (new_status)
            successor = (new_state, h) #We create the set
            return successor
        else:
            return False
    else:
        return False

Open_tail.append ((init_, 3)) #We save the initial state of the board and pass its heuristic

def Generate_susers (state):
    current_state = state.copy ()
    successors = []
    pos_cero = [(estado_actual.index(sub_l),sub_l.index(0)) for sub_l in estado_actual if 0 in sub_l] #get the coordinate where the zero is
    for mov in lista_mov: #we will apply all movements and analyze which ones are valid
        state_test = Create_sucesor (current_status, mov[1], post_cero)
        if state_test: #if a state returns to me we save it in the list to successors that we are going to create
            status_test = list (test_state)
            sucesores.append (estado_test.copy ()) # Save
    if successors: #if the list is not empty
        return successors
    else: #if I do not believe successors
        return False


node = Open_tail[0][0] 
 
 
 
s = Generate_susers (init_)

print ("")
print (s)
for state in s:
    print ("state")
    for cel in state[0]:
        print (cel)