Python global keyword vs. Pylint W0603
Question:
Pylint W0603 states:
Using the global statement. Used when you use the “global” statement to
update a global variable. PyLint just try to discourage this usage.
That doesn’t mean you can not use it !
I wonder why is it so? Is there any more Pythonic way of modifying immutable, module-wide variables inside a function? Is it recommended to pack them inside mutable variables like dictionaries? Or maybe turn entire module into class?
In my opinion this warning should disappear when variable is suggested to be “private” (prefixed with _ or __).
Answers:
In python, a module sharing global data like this is pretty much a singleton. you could accomplish the same thing with a singleton class, or ask yourself whether there is any reason you actually need a singleton. If you don’t need a singleton — use a regular class (instance). If you do need a singleton, google/search SO to figure out which pattern you think will suit you best. Maybe you do want a module — there is a niche for global — Otherwise Guido would have cut it out of the language a long time ago — That niche just happens to be pretty small…
Generalized use of global variables can make maintenance a nightmare, because they make tracing the flow of your program, and sometimes you get weird bug, because some module has read the variable and acted on its value before some other module changed the value of the variable (and this can result from inverting two import statements in some unrelated 3rd module). See also the wikipedia entry on Global variables.
This is why you should avoid mutable global variables, IMO, and why Pylint issues a warning (and probably should issue more of them. Detecting the use of the global keyword is just an easy way of spotting some of them).
Don’t take me wrong: I am not saying you must not use global variables. Only that you should avoid using them. There are lots of legit cases for global variables in Python. As long as you don’t get more than a couple W0603, you should fare OK.
Now, Logilab (the company maintaining Pylint, and where I used to work) once had to take over maintenance of a piece of > 50kloc of Python code, with heavy duplication and 100+ mutable global variables. And this was hell.
Solutions to work around global variables include:
- adding a parameter to the functions which need to access the variable
- using class attributes
- using instance attributes (by passing the value you need to the constructor of the class)
- centralizing mutable global values in a Configuration object which is build so that it is instantiated once at program startup (using environment variables, command line, configuration file…) and never mutated after this.
I would replace this:
the_file = None
def open_the_file(fname):
global the_file
the_file = open(fname)
def write_to_the_file(data):
the_file.write(data)
open_the_file("boo")
write_to_the_file("Hi!")
with this:
class FileProgram(object):
def __init__(self):
self.the_file = None
def open_the_file(fname):
self.the_file = open(fname)
def write_to_the_file(data):
self.the_file.write(data)
if __name__ == "__main__":
prog = FileProgram()
prog.open_the_file("boo")
prog.write_to_the_file("Hi!")
You might say, “that’s too complicated for my simple task!” OK, then don’t run pylint on your program. You can’t ask that pylint understand that your program is too small to use good structure.
Agree that refactor it to class is the way. There are some special cases, where class is not optimal, then i recommend to use dataclass
from dataclasses import dataclass
@dataclass
class Files:
the_file = "fname"
files = Files()
def open_the_file():
files.the_file = "123" # You can edit it here
This has a big advantage that if you import it from other module, it’s not copy, but reference, so if you change value somewhere, you got still correct value everywhere.
But… usually making a class is the way. When to use this way? Personally I use it if I expect only one instance will ever exists (kind of singleton). Or if in public api (_init_.py) I want to use only the function to take the complexity out of the user.
Pylint W0603 states:
Using the global statement. Used when you use the “global” statement to
update a global variable. PyLint just try to discourage this usage.
That doesn’t mean you can not use it !
I wonder why is it so? Is there any more Pythonic way of modifying immutable, module-wide variables inside a function? Is it recommended to pack them inside mutable variables like dictionaries? Or maybe turn entire module into class?
In my opinion this warning should disappear when variable is suggested to be “private” (prefixed with _ or __).
In python, a module sharing global data like this is pretty much a singleton. you could accomplish the same thing with a singleton class, or ask yourself whether there is any reason you actually need a singleton. If you don’t need a singleton — use a regular class (instance). If you do need a singleton, google/search SO to figure out which pattern you think will suit you best. Maybe you do want a module — there is a niche for global — Otherwise Guido would have cut it out of the language a long time ago — That niche just happens to be pretty small…
Generalized use of global variables can make maintenance a nightmare, because they make tracing the flow of your program, and sometimes you get weird bug, because some module has read the variable and acted on its value before some other module changed the value of the variable (and this can result from inverting two import statements in some unrelated 3rd module). See also the wikipedia entry on Global variables.
This is why you should avoid mutable global variables, IMO, and why Pylint issues a warning (and probably should issue more of them. Detecting the use of the global keyword is just an easy way of spotting some of them).
Don’t take me wrong: I am not saying you must not use global variables. Only that you should avoid using them. There are lots of legit cases for global variables in Python. As long as you don’t get more than a couple W0603, you should fare OK.
Now, Logilab (the company maintaining Pylint, and where I used to work) once had to take over maintenance of a piece of > 50kloc of Python code, with heavy duplication and 100+ mutable global variables. And this was hell.
Solutions to work around global variables include:
- adding a parameter to the functions which need to access the variable
- using class attributes
- using instance attributes (by passing the value you need to the constructor of the class)
- centralizing mutable global values in a Configuration object which is build so that it is instantiated once at program startup (using environment variables, command line, configuration file…) and never mutated after this.
I would replace this:
the_file = None
def open_the_file(fname):
global the_file
the_file = open(fname)
def write_to_the_file(data):
the_file.write(data)
open_the_file("boo")
write_to_the_file("Hi!")
with this:
class FileProgram(object):
def __init__(self):
self.the_file = None
def open_the_file(fname):
self.the_file = open(fname)
def write_to_the_file(data):
self.the_file.write(data)
if __name__ == "__main__":
prog = FileProgram()
prog.open_the_file("boo")
prog.write_to_the_file("Hi!")
You might say, “that’s too complicated for my simple task!” OK, then don’t run pylint on your program. You can’t ask that pylint understand that your program is too small to use good structure.
Agree that refactor it to class is the way. There are some special cases, where class is not optimal, then i recommend to use dataclass
from dataclasses import dataclass
@dataclass
class Files:
the_file = "fname"
files = Files()
def open_the_file():
files.the_file = "123" # You can edit it here
This has a big advantage that if you import it from other module, it’s not copy, but reference, so if you change value somewhere, you got still correct value everywhere.
But… usually making a class is the way. When to use this way? Personally I use it if I expect only one instance will ever exists (kind of singleton). Or if in public api (_init_.py) I want to use only the function to take the complexity out of the user.