Using class attributes as globals in Python - is there a catch?

Question

I have found myself in the habit of using code like this.

class glb: "just for holding globals" args = None # from argparse conf = None # from configparser def main(): ... glb.args = parser.parse_args() glb.conf = loadconf(fn) 

Assuming there is a case for using globals, I feel that this is a nice and clean way of doing it. It's a kind of a singleton pattern.

It’s simpler to spot thee glb. prefix than standard globals. However, I don't write that much object-oriented Python or larger projects, so I'm uncertain if there could be side effects or other gotchas that I'm not aware of.

So in short: Are there any downsides to doing it like this? Does it smell? Is there a better more pythonic way?

Answer 1

Using a class merely as a namespace rather than as a construct for objects strikes me as a bit unpythonic. Yes, it works just fine. But that's not how classes are normally used, and therefore potentially confusing.

Other than grouping the application state, there seems to be no advantage over just using ordinary globals:

ARGS = None CONF = None def main(): ARGS = parser.parse_args() CONFG = loadconf(fn) 

If you want an object that represents the application state, consider creating such an object as usual. For example:

@dataclass class AppState: args: Args conf: Config APP: Optional[AppState] = None def main(): APP = AppState( args=parser.parse_args(), config=loadconf(fn), ) 

Answer 2

Zen of python says "Namespaces are one honking great idea -- let's do more of those!".

Implies the following is pythonic.

do_thing(vars.important_value) 

When we include the import of vars as a module in our example; is this still pythonic?

import vars do_thing(vars.important_value) 

How about if we change how it's imported; is it still pythonic?

from some_module import vars do_thing(vars.important_value) 

How about when we use an instance of a class?

class Vars: def __init__(iv): self.important_value = iv vars = Vars(1234) do_thing(vars.important_value) 

That last bit is what got me. If instantiating a class is the key to creating a namespace outside of a module in order be pythonic, that would seem to contradict "simple is better"

It's for this reason I say using an uninstantiated class as a namespace is indeed pythonic, even if not often used.