如何在函数外部访问Python函数内创建的随机生成对象？

你碰到的是Python函数作用域的典型问题：opponent是dm_roll内部的局部变量，外部的fight函数根本看不到它。虽然global关键字能强行把它变成全局变量，但这种做法会让代码耦合度变高，后续维护起来很麻烦，确实不建议用。下面给你两个更优雅的解决方案：

方案一：让dm_roll返回怪物对象，调用fight时传参 #

这是最直接的函数式解决思路，把生成的怪物对象作为返回值传递出去，然后在调用fight时把它和英雄对象一起传进去。

修改后的完整代码示例：

import random

class Monster:
    def __init__(self, name, hp, attack):
        self.name = name
        self.hp = hp
        self.attack = attack
    
    def alive(self):
        return self.hp > 0
    
    def print_status(self):
        print(f"{self.name}: HP {self.hp}")

class Hero:
    def __init__(self, name, hp, attack):
        self.name = name
        self.hp = hp
        self.attack = attack
    
    def alive(self):
        return self.hp > 0
    
    def print_status(self):
        print(f"{self.name}: HP {self.hp}")

def dm_roll():
    roll = random.randint(1, 20)
    print(roll)
    if 0 < roll <= 10:
        opponent = Monster('Goblin', 6, 2)
    elif 10 < roll <= 16:
        opponent = Monster('Zombie', 8, 3)
    elif 16 < roll <= 19:
        opponent = Monster('Ogre', 15, 5)
    else:
        opponent = Monster('Dragon', 1000000, 10)

    print("You have run into a {}!".format(opponent.name))
    return opponent  # 返回生成的怪物对象

def fight(hero, opponent):
    while opponent.alive() and hero.alive():
        hero.print_status()
        opponent.print_status()
        # 补充战斗逻辑示例：英雄和怪物互相攻击
        hero.hp -= opponent.attack
        opponent.hp -= hero.attack

# 游戏启动逻辑
if __name__ == "__main__":
    hero = Hero("Adventurer", 25, 4)
    enemy = dm_roll()
    fight(hero, enemy)

这样做的好处是函数职责清晰：dm_roll只负责生成怪物，fight只负责处理战斗逻辑，它们之间通过参数传递数据，完全没有耦合。

方案二：用类封装游戏状态（适合复杂游戏） #

如果你的游戏后续会添加更多功能（比如背包、任务系统），用类来封装所有游戏状态会更合理。把hero、opponent作为类的实例属性，这样类里的所有方法都能直接访问它们。

示例代码：

import random

class Monster:
    def __init__(self, name, hp, attack):
        self.name = name
        self.hp = hp
        self.attack = attack
    
    def alive(self):
        return self.hp > 0
    
    def print_status(self):
        print(f"{self.name}: HP {self.hp}")

class Hero:
    def __init__(self, name, hp, attack):
        self.name = name
        self.hp = hp
        self.attack = attack
    
    def alive(self):
        return self.hp > 0
    
    def print_status(self):
        print(f"{self.name}: HP {self.hp}")

class GameSession:
    def __init__(self):
        self.hero = Hero("Adventurer", 25, 4)
        self.current_opponent = None
    
    def dm_roll(self):
        roll = random.randint(1, 20)
        print(roll)
        if 0 < roll <= 10:
            self.current_opponent = Monster('Goblin', 6, 2)
        elif 10 < roll <= 16:
            self.current_opponent = Monster('Zombie', 8, 3)
        elif 16 < roll <= 19:
            self.current_opponent = Monster('Ogre', 15, 5)
        else:
            self.current_opponent = Monster('Dragon', 1000000, 10)

        print("You have run into a {}!".format(self.current_opponent.name))
    
    def fight(self):
        if not self.current_opponent:
            print("You need to find an enemy first! Roll for an opponent.")
            return
        
        while self.current_opponent.alive() and self.hero.alive():
            self.hero.print_status()
            self.current_opponent.print_status()
            # 战斗逻辑
            self.hero.hp -= self.current_opponent.attack
            self.current_opponent.hp -= self.hero.attack

# 启动游戏
if __name__ == "__main__":
    game = GameSession()
    game.dm_roll()
    game.fight()

这种方式把所有游戏相关的状态都放在GameSession类里，代码结构更清晰，后续扩展功能也更容易。

为什么不推荐用global？ #

global关键字会把局部变量提升为全局变量，带来两个明显问题：

1. 隐式依赖：其他函数可以随意修改这个全局变量，你很难追踪到哪里出了问题；
2. 可维护性差：当项目变大时，全局变量会让代码逻辑变得混乱，调试和修改都很麻烦。

所以尽量避免使用全局变量，优先选择上面两种方案。

内容的提问来源于stack exchange，提问作者Katherine Gibson