Based on the following example how come I can print the var xyz from within a class as I always thought the class was stored in its own namespace.
xyz = 123
>>> class test:
... def __init__(self):
... pass
... def example(self):
... print xyz
...
>>> test().example()
123
Thanks
Classes are not stored in their own namespace, instead they define their own namespace, i.e variables defined inside a class are local to it and can't be accessed directly outside of it. But, a class can access variables from global scope if required.
Python uses LEGB rule to find the value of a variable:
L: Local scope
E: Enclosing scope
G: Glocal scope
B: Built-ins
Example of LEGB:
z = 3
def enclosing():
y = 2
def local_func():
x = 1
print x #fetch this from local scope
print y #fetch this from enclosing scope
print z #fetch this from global scope
print sum #fetch this from builtins
local_func()
enclosing()
output:
1
2
3
<built-in function sum>
So, in your case as xyz is not found in both local and enclosing scope, so global scope is used to fetch the value.
Why am I getting an UnboundLocalError when the variable has a value?
What are the rules for local and global variables in Python?
execing new code or modifying locals behind the compiler's back).Classes are not stored in their own namespace. They are stored in the namespace they are defined in; in your case, that's the global namespace of the interpreter session.
Methods within classes can still refer to names in that same namespace.
Perhaps you were confused with the scope at class definition time. The class body is executed as if it is a function; the local namespace of that function then forms the attributes of the resulting class. You can still reach names from outer scopes from there, however:
foo = 'bar'
class Spam(object):
baz = foo # works, foo can be referenced
def ham(self):
xyz = foo # works, foo is a global and can be referenced
xyz = baz # does **not** work, baz is part of the class now.
xyz = self.baz or Spam.baz # these do work
The class is in a namespace, but that is besides the point. Your question is more about accessibility of variables/members. The class's members are encapsulated, meaning that access is through the class.
xyz is in global namespace. This means that the variable is accessible throughout without going through a class. This is a thing to avoid. Classes are easy to create (both in defining them and instantiating them).
A namespace is easier to understand as simply being the name that is pre-pended to the classes contained within that namespace. Thought of this way, much more remains class-focused, a primary goal of OOP.
