В любом случае, чтобы изменить рекурсивную функцию, чтобы вернуть значение и не иметь глобальных переменных?

Question

Я изучаю python всего около месяца. Это рекурсивная функция, в которой я пишу, чтобы мой Pygame нашел правильный путь в полигоне без отступления. Это всего лишь Пентагон, (0,1,2,3,4) - число вершин.

Однако, этот код работает с двумя глобальными переменными:

last_poses = {} 
route_all = [] 

Это означает, что я должен инициализировать этим двум переменным каждый раз, когда я называю его. И я также пытаюсь вернуть все доступные маршруты, но это не сработало.

Этот результат происходит от глобальной переменной, это правильно:

[{0: 0, 1: 4, 2: 3, 3: 2, 4: 1, 5: 0}, {0: 0, 1: 4, 2: 3, 3: 2, 4: 1, 5: 0}] 

Этот результат происходит от возвращаемого значения:

[{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 0}] 

Мой вопрос, чтобы вернуть правильное значение без глобальных переменных. Любой, кто может помочь мне разрешить это, я действительно ценю это.

legal_action = ((4,1),(0,2),(1,3),(2,4),(0,3)) 

def route_cal(start_pos, steps): 
    global last_poses,route_all 
    last_poses[steps] = start_pos 
    steps -= 1 
    dest_all = list(legal_action[start_pos]) 

    if len(last_poses) >= 2: 
     for i in dest_all: 
      if i == last_poses[steps+2]: 
       dest_all.remove(i) 
    if steps > 0: 
     for pos in dest_all: 
      # route_cal(pos,steps) 
      return route_cal(pos,steps) 
    elif steps == 0: 
     last_poses[steps] = dest_all[0] 
     route_all.append(last_poses) 
     return route_all 
    # return route_all 

last_poses = {} 
route_all = [] 
# route_cal(0, 5) 
# print route_all 

routelines = route_cal(0,5) 
print routelines 

Circuit of my game

Answer 1

У вас есть несколько вариантов. Один из них использует необязательный параметр. Похоже, вы можете использовать route_all в качестве необязательных параметров.

например.

def route_cal(start_pos, steps, route_all = {}): 

Помните, что необязательные параметры инициализируются один раз (при первом вызове функции).

Другой способ - избавиться от dest_all и last_poses и использовать только одну переменную route_all и добавить к ней все, что вы достигнете точки вашего полигона, и только вернуть эту точку.

return [route_all] + [recursive_call_here] 

Вы также можете посмотреть в не используя ваше legal_actions переменного и создать «сосед» значение по мере необходимости в зависимости от номера шага вы находитесь.

Есть другие способы, чтобы свести к минимуму проблемы, и я рекомендую переместив этот вопрос в раздел Code Review, чтобы получить больше информации о вашем коде. Например, я попытался бы избежать использования множества циклов и вместо этого использовать формулу, которая будет вычислять «соседей» при повторении каждого шага. Кроме того, не допустить исключения исключений из диапазона и/или исключения KeyError, убедившись, что вы не имеете доступа к тому, чего он не существует.

Answer 2

Самый простой ответ заключается в использовании нелокальной вместо глобального. Это та же самая сделка, но переменная находится в родительской области, а не глобальной.

Для вашего примера, однако, похоже, что основная область этой функции является глобальной, поэтому она ничего не изменит.

Более правильный, но более сложный ответ - если вы хотите избавиться от использования внешней переменной, вам придется либо передать значения в вашу функцию в качестве параметров, либо возвратить кортеж, содержащий оба ваших текущих глобальных переменные и исходную возвращаемую переменную.

This вопрос может помочь вам начать работу.

Answer 3

В соответствии с моим предыдущим комментарием, здесь приведен простой итерационный способ пересечения многоугольника. Кажется, он дает то, что вы указали, без использования глобальной переменной или даже рекурсии. Это все, что вам нужно?

def route_cal(start_node, move_list): 
    # For each step in the circuit 
    here = start_node 
    path = [here] 
    for step in range(len(move_list)): 
     # Find any legal move to an adjacent vertex 
     dest = move_list[here] 
     for here in dest: 
      if here not in path: # Don't repeat a vertex 
       path.append(here) 
       break 
    path.append(start_node) 

    # Now that we've found the full circuit, build a dictionary in each direction 
    path_len = len(path) 
    forward = {n: path[n] for n in range(path_len)} 
    reverse = {n: path[path_len-n-1] for n in range(path_len)} 
    return [forward, reverse] 


legal_action = ((4,1), (0,2), (1,3), (2,4), (0,3)) 
print route_cal(0, legal_action)