仅在本地范围内更改全局变量

Question

假设我有一个to_json函数，它接受给定对象和相关字段（全局定义）并返回以json格式序列化的对象。

我们还要说一些对象将其他对象作为值。 to_json函数是递归的，可以很好地解析这些嵌套对象。

但是让我们说，在某些情况下，父对象和值对象可以有循环引用。为了防止to_json函数执行无限递归，我需要在特定调用的上下文中修改那些全局定义的字段，以便不考虑对象字段。

以下是一个快速概念，而不是以语法为中心的示例：

global fields_1 
fields_1 = ['name', 'id', 'status']

global fields_2
fields_2 = ['id', 'text', 'user']

class User():
    self.name = str() # type declarations, these aren't syntactically correct
    self.id = int()
    self.status = Status()

class Status():
    self.id = int()
    self.text = str()
    self.user = User()

def to_json(object, fields):
    global fields_1
    global fields_2
    outDict = {}
    for field in fields:
        tmp = object[field]
        if type(tmp) == User:
            tmp = to_json(tmp, fields_1)
        elif type(tmp) == Status:
            tmp = to_json(tmp, fields_2)
        outDict[field] = tmp
    return json.dumps(outDict)

def showUser(user):
    global fields_1
    return to_json(user, fields_1)

def showStatus(status):
    global fields_2
    return to_json(status, fields_2)

通过遵循上面的伪代码示例，很明显会有循环递归。我的问题是，有没有办法创建一个不会影响实际全局值的global的修改后的本地范围版本？这样的事情（我知道这改变了全局，这只是为了演示的目的）：

def showStatus(status):
    global fields_2
    global fields_1
    fields_1.remove('status')
    return to_json(status, fields_2)

或者我坚持做一些像这样愚蠢的事情：

def showStatus(status):
    global fields_2
    global fields_1
    fields_1.remove('status')
    tmp = to_json(status, fields_2)
    fields_1.append('status')
    return tmp

我不认为跟踪递归深度会非常有用，因为无法知道这些调用时的深度是多少，因为在我的实际代码中有超过2个带有此循环引用问题的类

我已经考虑过制作第二组fields全局变量，其中第二个to_json函数引用那些，但这似乎可能有效，但它可能不是最好的解决方案。

谢谢，对不起，如果这没有多大意义。