Solving problem is about exposing yourself to as many situations as possible like Variable scopes in Python classes and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.
In this post, my aim is to share an overview the topic about Variable scopes in Python classes, which can be followed any time. Take easy to follow this discuss.
Declaring a variable in a class (outside of a function): all class functions can access it (basically a public variable)
Declaring a variable inside a function inside a class: only that function can access it (it’s in that function’s scope)
Declaring a variable with
self.(variable name) inside a function inside a class: all class functions can access it (how is this different from
global (variable name)?)
And since there is no private/protected, everything is public, so everything accessible from inside a class is accessible from outside the class.
Are there any other nuances I should know, or have I pretty much got it?
Since the listing in your question is not 100% clear, I’ve decided to explain it with a simple example. It also includes some things like
__something variables you did not mention in your list.
class Test: a = None b = None def __init__(self, a): print self.a self.a = a self._x = 123 self.__y = 123 b = 'meow'
At the beginning,
b are only variables defined for the class itself – accessible via
Test.b and not specific to any instance.
When creating an instance of that class (which results in
__init__ being executed):
print self.adoesn’t find an instance variable and thus returns the class variable
self.a = a: a new instance variable
ais created. This shadows the class variable so
self.awill now reference the instance variable; to access the class variable you now have to use
- The assignment to
self._xcreates a new instance variable. It’s considered “not part of the public API” (aka protected) but technically it has no different behaviour.
- The assignment to
self.__ycreates a new instance variable named
_Test__y, i.e. its name is mangled so unless you use the mangled name it cannot be accessed from outside the class. This could be used for “private” variables.
- The assignment to
bcreates a local variable. It is not available from anywhere but the
__init__function as it’s not saved in the instance, class or global scope.
Declaring a variable at the top level of the class is like declaring a static or class variable. Qualifying it with self is declaring an instance variable. Class variables can be modified by referring to them by class name (e.g.
Class.x = 5) and all instances will inherit these changes. Instance variables are private to an instance and can only be modified by that instance.
You can achieve some level of access control using underscores. See private variables in the Python tutorial. By convention, variables starting with one underscore, e.g.
_foo are non-public parts of an API, and names starting with two underscores e.g.
__foo will have it’s name mangled to be
Although answered, let me add some comments to your questions:
declaring a variable in a class (outside of a function) : all class functions can access it (basically a public variable):
comment:this is like a static variable and can be called using the class name. These variables are available to all functions, any functions can modify it and print it.
declaring a variable inside a function inside a class : only that function can access it (its in that functions scope):
comment: if the variable is declared without self then it is accessible within that function only, kinda local variable. However if it declared using self like self.var= ‘somevalue’,, then it is accessible via any object but not via the class name.
declaring a variable with self.(variable name) inside a function inside a class : all class functions can access it (how is this different from global (variable name)?):
comment: see asnswer in the above part.
and since there is no private / protected, everything is public, so everything accessible from inside a class is accessible from outside the class.:
comment: yes, but we can use single underscore to tell world this variable is private but technically that actually doesnt make it private.
we can use the scope in this for as :
case 1: In the Class
class test: def __init__(self, a): self.__elements = a def change_a(self): self.__elements = 5
case 2 : Outside class
t = test(5)
This will access by as object._classname__privatevaribalename
this will print the change value of a