What's wrong with this? From objective, and functional standpoints?

import sys
class EncapsulationClass(object):
 
 def __init__(self):
 self.privates = ["__dict__", "privates", "protected", "a"]
 self.protected = ["b"]
 
 print self.privates
 
 self.a = 1
 self.b = 2
 self.c = 3
 pass
 
 def __getattribute__(self, name):
 if sys._getframe(1).f_code.co_argcount == 0:
 if name in self.privates:
 raise Exception("Access to private attribute \"%s\" is not allowed" % name)
 else:
 return object.__getattribute__(self, name)
 else:
 return object.__getattribute__(self, name)
 
 def __setattr__(self, name, value):
 if sys._getframe(1).f_code.co_argcount == 0:
 if name in self.privates:
 raise Exception("Setting private attribute \"%s\" is not allowed" % name)
 elif name in self.protected:
 raise Exception("Setting protected attribute \"%s\" is not allowed" % name)
 else:
 return object.__setattr__(self, name, value)
 else:
 return object.__setattr__(self, name, value)
 
example = EncapsulationClass()
example.a = 10 # Exception: Setting private attribute "a" is not allowed
example.b = 10 # Exception: Setting protected attribute "b" is not allowed
example.c = 10 # example.c == 10
example.__dict__["privates"] # Exception: Setting protected attribute "b" is not allowed

What would actualyl be wrong with doing something like this?

What's wrong with this? From objective, and functional standpoints?

import sys
class EncapsulationClass(object):
 
 def __init__(self):
 self.privates = ["__dict__", "privates", "protected", "a"]
 self.protected = ["b"]
 
 print self.privates
 
 self.a = 1
 self.b = 2
 self.c = 3
 pass
 
 def __getattribute__(self, name):
 if sys._getframe(1).f_code.co_argcount == 0:
 if name in self.privates:
 raise Exception("Access to private attribute \"%s\" is not allowed" % name)
 else:
 return object.__getattribute__(self, name)
 else:
 return object.__getattribute__(self, name)
 
 def __setattr__(self, name, value):
 if sys._getframe(1).f_code.co_argcount == 0:
 if name in self.privates:
 raise Exception("Setting private attribute \"%s\" is not allowed" % name)
 elif name in self.protected:
 raise Exception("Setting protected attribute \"%s\" is not allowed" % name)
 else:
 return object.__setattr__(self, name, value)
 else:
 return object.__setattr__(self, name, value)
 
example = EncapsulationClass()
example.a = 10 # Exception: Setting private attribute "a" is not allowed
example.b = 10 # Exception: Setting protected attribute "b" is not allowed
example.c = 10 # example.c == 10
example.__dict__["privates"] # Exception: Setting protected attribute "b" is not allowed

What would actually be wrong with doing something like this?

Is there any better way to achieve encapsulation in Python?

What's wrong with this? From objective, and functional standpoints?

import sys
class EncapsulationClass(object):
 
 privates = ["a"]
 protected = ["b"]
 
 def __init__(self):
 self.a = 1
 self.b = 2
 self.c = 3
 pass
 
 def __getattribute__(self, name):
 if sys._getframe(1).f_code.co_argcount == 0:
 if name in EncapsulationClass.privates:
 raise Exception("Access to private attribute \"%s\" is not allowed" % name)
 else:
 return object.__getattribute__(self, name)
 else:
 object.__getattribute__(self, name, value)
 
 def __setattr__(self, name, value):
 if sys._getframe(1).f_code.co_argcount == 0:
 if name in EncapsulationClass.privates:
 raise Exception("Setting private attribute \"%s\" is not allowed" % name)
 elif name in EncapsulationClass.protected:
 raise Exception("Setting protected attribute \"%s\" is not allowed" % name)
 else:
 object.__setattr__(self, name, value)
 else:
 object.__setattr__(self, name, value)
 

example = EncapsulationClass()
example.a = 10 // Exception: Setting private attribute "a" is not allowed
example.b = 10 // Exception: Setting protected attribute "b" is not allowed
example.c = 10 // example.c == 10

What would actualyl be wrong with doing something like this?

What's wrong with this? From objective, and functional standpoints?

import sys
class EncapsulationClass(object):
 
 def __init__(self):
 self.privates = ["__dict__", "privates", "protected", "a"]
 self.protected = ["b"]
 
  print self.privates
 self.a = 1
 self.b = 2
 self.c = 3
 pass
 
 def __getattribute__(self, name):
 if sys._getframe(1).f_code.co_argcount == 0:
 if name in self.privates:
 raise Exception("Access to private attribute \"%s\" is not allowed" % name)
 else:
 return object.__getattribute__(self, name)
 else:
 return object.__getattribute__(self, name)
 
 def __setattr__(self, name, value):
 if sys._getframe(1).f_code.co_argcount == 0:
 if name in self.privates:
 raise Exception("Setting private attribute \"%s\" is not allowed" % name)
 elif name in self.protected:
 raise Exception("Setting protected attribute \"%s\" is not allowed" % name)
 else:
 return object.__setattr__(self, name, value)
 else:
 return object.__setattr__(self, name, value)
 
example = EncapsulationClass()
example.a = 10 # Exception: Setting private attribute "a" is not allowed
example.b = 10 # Exception: Setting protected attribute "b" is not allowed
example.c = 10 # example.c == 10
example.__dict__["privates"] # Exception: Setting protected attribute "b" is not allowed

What would actualyl be wrong with doing something like this?