Let's say I have a class A
class A:
__slots__ = ['_x']
def __init__(self):
self._x = 10
@property
def x(self):
return self._x
And I want to restrcit assigning to a._x from anywhere except other instance's methods.
How do I do that? Is that even possible in Python?
The thing is to write a class which attributes is changeable only within particular methods and never directly from outside.
Python doesn't really have "private" variables like C++. Even if you set the variable as private by using a the _ prefix from PEP8 (as you have done). You can always access the variable using A._x.
If you want to emulate private variables for some reason, you can use __ (double underscore) prefix as it mangles the name. Similarly you can use @property decorator to make a getter and setter function and prevent access to the attribute. However, even these fail as you can access the variables directly using __dict__.
So the Pythonic way is to leave it the way it is. Python is like perl in this respect. To paraphrase a famous line about privacy from the Perl book,
the philosophy is that you should stay out of the living room because you weren't invited, not because it is defended with a shotgun.
I totally agree with @kinshukdua on this. However, just to explore more options available to you. you can override the setattr by placing some condition
This might not be the most pythonic way, but i am open to a more cleaner way to acheive this.
class A:
_x = 10 #dont think you need an init method since you are not adding any data
def __setattr__(self, key, value):
if 'yes' in value[1]:
super().__setattr__(key,value[0])
else:
raise TypeError('You should not have access to this')
def change(self, value,loc= 'yes'):
self._x = value,loc
return self._x
