Variable scopes in Python classes
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 hav开发者_JAVA百科e 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, a
and b
are only variables defined for the class itself - accessible via Test.a
and Test.b
and not specific to any instance.
When creating an instance of that class (which results in __init__
being executed):
print self.a
doesn't find an instance variable and thus returns the class variableself.a = a
: a new instance variablea
is created. This shadows the class variable soself.a
will now reference the instance variable; to access the class variable you now have to useTest.a
- The assignment to
self._x
creates 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.__y
creates 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
b
creates 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 _classname__foo
.
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)
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 (it's in that function's scope):
If the variable is declared without self
then it is accessible within that function only, like a local variable. However, if it was 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 fromglobal (variable name)
?)
See answer 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
Yes, but we can use single underscore to tell the world this variable is private, but technically that actually doesn't 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
print(t._test__elements)
this will print the change value of a
精彩评论