How should we use global variables correctly?
On 23Aug2019 14:43, Windson Yang <wiwindson at gmail.com> wrote:
>I also want to know what is the difference between "using 'global
>variables' in a py module" and "using a variable in class". For example:
> foo = 1
> def bar():
> global foo
> return foo + 1
> class Example:
> def __init__(self):
> self.foo = 1
> def bar()
> return self.foo + 1
This isn't a class variable. The .foo attribute will be attached to
"self", which is an instance of the class, not the class itself.
You probably want:
foo = 1
So what's happening here? When the class is defined, in addition to
defining the .__init__ method we also define .foo. These are attributes
of the class: there's just one of each.
In your code you're setting .foo on "self", so there's one per instance
of the class.
So in my Example2 there's a foo:
Compared to a global, this is nicely contained in the class' namespace.
But otherwise it is the same: it gets defined just once as the module is
imported (which defines the class Example2, which defines Example2.foo).
However, it _is_ harder to use as a local by accident. Here:
from example_module import Example2
z = 1
z = 3
Example2.foo = 3
Here, "z" is local to "f" because it is assigned to. Example2.foo is
still the one from inside the class - we're not assigning to a function
local name, but to a name _accessed_ via Example2.
>Expect the syntax, why using class variable self.foo would be better
>(or more common)? I think the 'global' here is relative, foo is global in
>global.py and self.foo is global in Example class.
As mentioned, in your Example class self.foo is an attribute of the
instance, not the class. My Example2 class shows how to put it on the
>If the global.py is
>short and clean enough (didn't have a lot of other class), they are pretty
>much the same. Or I missed something?
Making a class level name has the nice aspect that it has a better
Cameron Simpson <cs at cskk.id.au>