is this code truly private? (python)

Question

I am trying to make python allow private variable, so I made this decorator that you put at the begging of a class so that every function will get an additional private parameter that they can modify to be what they want. as far as I can tell, it is impossible to get the variables from outside the class, but I'm not a pro.

can anyone find a way to hack into the private object and get the values from it? is there a better way to do it than this?

python 2.7

#this is a decorator that decorates another decorator. it makes the decorator
#not loose things like names and documentation when it creates a new function
def niceDecorator(decorator):
    def new_decorator(f):
        g = decorator(f)
        g.__name__ = f.__name__
        g.__doc__ = f.__doc__
        g.__dict__.update(f.__dict__)
        return g
    new_decorator.__name__ = decorator.__name__
    new_decorator.__doc__ = decorator.__doc__
    new_decorator.__dict__.update(decorator.__dict__)
    return new_decorator

@niceDecorator
#this is my private decorator
def usePrivate(cls):

    prv=type('blank', (object,), {})
    #creates a blank object in the local scope
    #this object will be passed into every function in
    #the class along with self which has been renamed
    #as pbl (public).

    @niceDecorator
    #this is the decorator that gets applied to every function
    #in the class. in makes it also accept the private argument
    def decorate(func):
        def run(pub, *args, **kwargs):
            return func(pub,prv, *args, **kwargs)
        return run

    #this loops through every function in the class and applies the decorator
    for func in cls.__dict__.values():
        if callable(func):
            setattr(cls, func.__name__, decorate(getattr(cls, func.__name__)))

    return cls

#this is the class we are testing the private decorator with.
#this is what the user would program
@usePrivate
class test():

    #sets the value of the private variable
    def setValue(pbl,prv,arg):
        #pbl (public) is another name for self
        #prv (private) acts just like self except its private
        prv.test=arg

    #gets the value of the private variable
    def getValue(pbl,prv):
        return prv.test
a=test()
a.setValue(3)
print a.getValue()

Answer 1

In short: Don't do this.

There is no need to make things truly private in Python. The people using your software can see if something is marked as private (variable name begins with _), so they know. If they still want to access it, why stop them?

I'm sure there is also a way around your code - Python has incredible amounts of introspective code, and modifying classes is easy to do. It's virtually impossible to lock anything down if someone really wants to get to it.

It's also worth noting that in Python, setters/getters are pointless. The aim is to allow you to add in code on setting/getting an attribute, which python allows you to do using the property() builtin.