如何在函数外部获取initiative_phase内的三个回合顺序变量值？

你遇到的问题根源是：initiative_phase里的三个变量是局部变量，函数外部的first_turn等函数无法直接访问——要么报“变量未定义”错误，要么如果全局存在同名初始0值，就会错误使用0值导致逻辑失效。以下是三种可行的解决方案：

方案1：返回计算值并作为参数传递（推荐） #

修改initiative_phase让它返回三个回合值，调用first_turn等函数时把这些值传进去。这是最规范的函数式编程方式，避免全局状态混乱。

修改后的initiative_phase：

import random

def initiative_phase():
    # 直接计算，省略冗余的初始0赋值
    WarriorTurnOrder = random.randint(0,20) + warrior[4]
    PriestTurnOrder = random.randint(0,20) + priest[4]
    enemy_turnOrder = random.randint(0,20) + vampire[4]
    
    print("\nThe warrior got " + str(WarriorTurnOrder)) 
    print("The vampire got " + str(enemy_turnOrder))
    print("The priest got " + str(PriestTurnOrder))
    
    # 返回三个计算结果
    return WarriorTurnOrder, PriestTurnOrder, enemy_turnOrder

修改first_turn等函数，让它们接收参数：

def first_turn(warrior_t, priest_t, enemy_t):
    if warrior_t > enemy_t and warrior_t > priest_t:
        warrior_turn()
    elif priest_t > enemy_t and priest_t > warrior_t:
        priest_turn()
    elif enemy_t > warrior_t and enemy_t > priest_t:
        enemy_turn()
    # 简化平局判断：任意两个值相等就重新计算回合顺序
    elif warrior_t == enemy_t or warrior_t == priest_t or enemy_t == priest_t:
        new_warrior, new_priest, new_enemy = initiative_phase()
        first_turn(new_warrior, new_priest, new_enemy)

def second_turn(warrior_t, priest_t, enemy_t):
    if enemy_t < warrior_t < priest_t:
        warrior_turn()
    elif enemy_t < priest_t < warrior_t:
        priest_turn()
    elif warrior_t < enemy_t < priest_t:
        enemy_turn()

def third_turn(warrior_t, priest_t, enemy_t):
    if warrior_t < enemy_t and warrior_t < priest_t:
        warrior_turn()
    elif priest_t < enemy_t and priest_t < warrior_t:
        priest_turn()
    else:
        enemy_turn()

调用方式：

# 先获取回合顺序值
warrior_turn_val, priest_turn_val, enemy_turn_val = initiative_phase()
# 依次执行各回合
first_turn(warrior_turn_val, priest_turn_val, enemy_turn_val)
second_turn(warrior_turn_val, priest_turn_val, enemy_turn_val)
third_turn(warrior_turn_val, priest_turn_val, enemy_turn_val)

方案2：使用全局变量（不推荐，适合简单场景） #

在函数内部声明变量为全局变量，这样initiative_phase修改的是全局作用域的变量，其他函数可以直接访问。但全局变量容易导致代码逻辑混乱，不建议在复杂项目中使用。

示例：

import random

# 定义全局变量
WarriorTurnOrder = 0
PriestTurnOrder = 0
enemy_turnOrder = 0

def initiative_phase():
    # 声明要修改全局变量
    global WarriorTurnOrder, PriestTurnOrder, enemy_turnOrder
    WarriorTurnOrder = random.randint(0,20) + warrior[4]
    PriestTurnOrder = random.randint(0,20) + priest[4]
    enemy_turnOrder = random.randint(0,20) + vampire[4]
    
    print("\nThe warrior got " + str(WarriorTurnOrder)) 
    print("The vampire got " + str(enemy_turnOrder))
    print("The priest got " + str(PriestTurnOrder))

此时first_turn等函数无需修改，直接就能访问这三个全局变量。

方案3：封装为类（适合复杂游戏逻辑） #

把回合系统相关的变量和逻辑封装到类中，变量作为实例属性，方法可以直接访问。这种方式更易维护，适合逻辑复杂的游戏。

示例：

import random

class TurnSystem:
    def __init__(self, warrior, priest, vampire):
        self.warrior = warrior
        self.priest = priest
        self.vampire = vampire
        self.warrior_turn = 0
        self.priest_turn = 0
        self.enemy_turn = 0
    
    def initiative_phase(self):
        self.warrior_turn = random.randint(0,20) + self.warrior[4]
        self.priest_turn = random.randint(0,20) + self.priest[4]
        self.enemy_turn = random.randint(0,20) + self.vampire[4]
        
        print("\nThe warrior got " + str(self.warrior_turn)) 
        print("The vampire got " + str(self.enemy_turn))
        print("The priest got " + str(self.priest_turn))
        
        # 平局时重新计算
        if self.warrior_turn == self.enemy_turn or self.warrior_turn == self.priest_turn or self.enemy_turn == self.priest_turn:
            self.initiative_phase()
    
    def first_turn(self):
        if self.warrior_turn > self.enemy_turn and self.warrior_turn > self.priest_turn:
            self.warrior_turn_action()
        elif self.priest_turn > self.enemy_turn and self.priest_turn > self.warrior_turn:
            self.priest_turn_action()
        elif self.enemy_turn > self.warrior_turn and self.enemy_turn > self.priest_turn:
            self.enemy_turn_action()
    
    def second_turn(self):
        if self.enemy_turn < self.warrior_turn < self.priest_turn:
            self.warrior_turn_action()
        elif self.enemy_turn < self.priest_turn < self.warrior_turn:
            self.priest_turn_action()
        elif self.warrior_turn < self.enemy_turn < self.priest_turn:
            self.enemy_turn_action()
    
    def third_turn(self):
        if self.warrior_turn < self.enemy_turn and self.warrior_turn < self.priest_turn:
            self.warrior_turn_action()
        elif self.priest_turn < self.enemy_turn and self.priest_turn < self.warrior_turn:
            self.priest_turn_action()
        else:
            self.enemy_turn_action()
    
    # 替换原有的warrior_turn等函数为类方法
    def warrior_turn_action(self):
        # 这里写战士回合的具体逻辑
        pass
    
    def priest_turn_action(self):
        # 这里写牧师回合的具体逻辑
        pass
    
    def enemy_turn_action(self):
        # 这里写敌人回合的具体逻辑
        pass

使用方式：

# 假设warrior, priest, vampire是已定义的角色数据
turn_system = TurnSystem(warrior, priest, vampire)
turn_system.initiative_phase()
turn_system.first_turn()
turn_system.second_turn()
turn_system.third_turn()

内容的提问来源于stack exchange，提问作者Rafael José