使用字典来引用函数内的全局变量（Python）

Question

I'm using a dictionary to refer to a global variable in Python inside a function. I want to use the function to update the global variable. (In reality my global variables are more complicated than this.)

global_variable_A=5
global_variable_B=1
dictionary={'A':global_variable_A,'B':global_variable_B}

def f(x,glob):
    global global_variable_A
    dictionary[glob]+=x

f(2,'A')
print(global_variable_A)

This returns 5 rather than 7. I understand why, is there anyway to let Python know that I mean the variable dictionary[glob] to refer to the global rather than the local variable, while still referring to the variable through a dictionary?

Thanks for your time, and apologies if I've missed something completely obvious.

Answer 1

If you think you need to do this, there's a design flaw in your code. I really wouldn't recommend doing this.

global_a = 5

def add_to_global(key, value):
    globals()[key] += value

add_to_global("global_a", 2)
print(global_a)

Output:

7

Answer 2

When you assign a value to a name name = 5 , you're creating a reference to 5 that you can use the identifier name to access. Normally, if you then have some code with a narrower scope, you can either use that reference

def f():
    print(name)

or create a local reference using the same identifier, potentially to an unrelated value

def g():
    name = 100
    print(name)

The global keyword allows you to instead manipulate the identifier as if you weren;t in the more narrow scope, allowing you to reassign the global name to a different reference:

def h():
    global name
    name = 100

h()
print(name) # 100

However, when you use a reference to create another reference, there isn't any relation ship between those two references. So

name = 5
l = [name]

leaves us with two references to the value 5 : one from the identifier name , and one from the first position of l . Crucially, those two references are not related; we can change one without changing the other.

name = 6
print(l)  # [5]

One way to accomplish what you want is to use a boxed type. That means that you create an object that points to another object. All of your references can then point to the first object (the box) and you can freely change what it points to (the thing "inside" the box), by only updating a single reference:

class Box:
    def __init__(self, value):
        self.value = value

box = Box(5)
l = [box]
box.value = 10
print(l[0].value)  # 10