Why would people use globals() to define variables

Question

I've come across recently a number of places in our code which do things like this

...
globals()['machine'] = otherlib.Machine()
globals()['logger'] = otherlib.getLogger()
globals()['logfile'] = datetime.datetime.now().strftim('logfiles_%Y_%m_%d.log')

and I am more than a little confused as to why people would do that, rather than doing

global machine
machine = otherlib.Machine()

and so on.

Here is a slightly anonymised function which does this, in full:

def openlog(num)
    log_file = '/log_dir/thisprogram.' + num
    if os.path.exists(log_file):
        os.rename(log_file, log_file + '.old')

    try:
        globals()["log"] = open(log_file, 'w')
        return log
    except:
       print 'Unable to open ' + log_file
       sys.exit(1)

It confuses the hell out of pylint (0.25) as well me.

Is there any reason for coding it that way? There's minimal usage of eval in our code, and this isn't in a library

PS I checked Reason for globals() in python but it doesn't really answer as to why you'd use this for setting globals in a program

typically you wouldnt ... unless you were scripting it and you had those as strings ... then you would have to (or come up with a better way to create the variables from strings(there are lots of better ways imho)) ... — Joran Beasley, Jan 15 '14 at 17:16
possible duplicate of [Reason for globals() in Python?](http://stackoverflow.com/questions/12693606/reason-for-globals-in-python) — brandonscript, Jan 15 '14 at 17:17
Why are you asking us? Why don't you ask the people that wrote the code?! — David Heffernan, Jan 15 '14 at 17:18
Maybe a way to sidestep code-checking tools which want GLOBALS_IN_CAPS (of course, it is the wrong way to do that :) — wim, Jan 15 '14 at 17:18
@DavidHeffernan cos they aren't around (and I suspect the answer would be 'because xxxx who left did it' even if they were) — Tom Tanner, Jan 15 '14 at 17:20
@remus - I know why globals() is there. I read that question, but it doesn't explain why people would use it like this — Tom Tanner, Jan 15 '14 at 17:21
Ah OK -- might want to mention/link to that in your question so it doesn't get flagged/closed. — brandonscript, Jan 15 '14 at 17:21
one line instead of two? (I know its not a good reason, but it could be THE reason) — cmd, Jan 15 '14 at 17:32
Ooch my eyes... Given the SquareWheeled(tm) reinvention of `logging.RotatingFileHandler` and the totally braindead exception handling scheme, I suspect this is merely out of incompentence. — bruno desthuilliers, Jan 15 '14 at 17:55

Henry Keiter · Accepted Answer · 2014-01-15T18:35:33.510

Maybe the function uses a local variable with the same name as the global one, and the programmer didn't want to bother changing the variable name?

def foo(bar):
    global bar # SyntaxError
    bar = bar + 1

def foo(bar):
    globals()['bar'] = bar + 1 
foo(1)
print(bar) # prints 2

Another use case, albeit still a bit specious (and clearly not the case in the example function you gave), is for defining variable names dynamically. This is rarely, if ever, a good idea, but it does come up a lot in questions on this site, at least. For example:

>>> def new_variable():
...     name = input("Give your new variable a name! ")
...     value = input("Give your new variable a value! ")
...     globals()[name] = value
...
>>> new_variable()
Give your new variable a name! foo
Give your new variable a value! bar
>>> print(foo)
bar

Otherwise, I can think of only one reason to do this: perhaps some supervising entity requires that all global variables be set this way, e.g. "in order to make it really, really clear that these variables are global". Or maybe that same supervising entity has placed a blanket ban on the global keyword, or docks programmer pay for each line.

I'm not saying that any of these would be a good reason, but then again, I truly can't conceive of a good reason to define variables this way if not for scoping purposes (and even then, it seems questionable...).

Just in case, I did a timing check, to see if maybe the globals() call is faster than using the keyword. I'd expect the function call + dictionary access to be significantly slower, and it is.

>>> import timeit
>>> timeit.timeit('foo()', 'def foo():\n\tglobals()["bar"] = 1',number=10000000)
2.733132876863408
>>> timeit.timeit('foo()', 'def foo():\n\tglobal bar\n\tbar = 1',number=10000000)
1.6613818077011615

Given the code you posted and my timing results, I can think of no legitimate reason for the code you're looking at to be written like this. Looks like either misguided management requirement, or simple incompetence.

That's what the OP is asking about; why not use `global x` on the line before it? — Martijn Pieters, Jan 15 '14 at 17:23
Right, wanting to avoid clashing with a local name makes more sense. If only a little. — Martijn Pieters, Jan 15 '14 at 17:25
@Tom How *are* they using it, then? Can you give us any more info that might provide clues? — Henry Keiter, Jan 15 '14 at 17:35
@HenryKeiter seriously, I cannot see why it is being done, and the code I've posted is pretty representative. I've posted a copy of a complete function doing this. — Tom Tanner, Jan 15 '14 at 17:44
@TomTanner Given that function definition, I'm forced to conclude that the reason behind that code has nothing to do with good coding practice or efficiency or any other "real" reason. — Henry Keiter, Jan 15 '14 at 17:55
as long as it's not likely to be a real reason, I can be not to worried about changing it... — Tom Tanner, Jan 23 '14 at 13:26

score 2 · Answer 2 · answered Jan 15 '14 at 18:04

Are the authors PHP converts? This is a valid code in PHP:

$GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];

See this for more examples. If someone was used to this way of writing the code, maybe they just used the closest matching way of doing it in Python and didn't bother to check for alternatives.

You'd sometimes use a superglobal $GLOBAL variable to define something, because although global keyword exists in PHP, it will only import existing variables - it cannot create a new variable as far as I know.

Why would people use globals() to define variables

2 Answers2