Is This Code Truly Private? (python)

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 t

Solution 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.

Solution 2:

That's an interesting idea, but the wrapper functions you're using for the decorator will have a reference to the "private" object in their func_closure attribute. So your "private" variable is accessible as a.getValue.func_closure[0].cell_contents.test. (You can use any wrapped function to get to your "private" object, not just getValue.)

Generally this sort of technique will only serve to annoy other programmers who are using your code.

Solution 3:

There's always a way to get at things in Python, especially if you have the original source to read. Using kindall's example, add these lines to the end of your file:

print a.getValue.im_func.func_closure[0].cell_contents.test
a.getValue.im_func.func_closure[0].cell_contents.test = 17
print a.getValue()

Really, don't do this. There's a reason Python people say, "don't bother with private variables."

Solution 4:

As others have said, there is still a way to get to the private variables. However, you can still get to private variables in c++. Consider this C++ example:

classPrivateEye
{
    private:
    int a;
    double b;
    char c;

    public:
    // ... public functions ...
};

PrivateEye detective;

double privateB = *((double *) ((void *) &detective + sizeof(detective.a)));

As you can see, it takes alot of work to get access to the private varible, so the person doing it needs to know enough to know the risks. So, if you have programmers using your _attribute private attribute, the solution you posted will be effective in making them think about it before messing with the private attributes. Using __attribute (double-underscore) will cause some name mangling, which also has the same effect of cause people to do a little more thinking before deciding to access the "private" attributes.

Edit: According to the second answer in Accessing private members , the C++ standard doesn't guarantee the order of member variables in a class, so you might have to experiment a little bit to get access to the private variable you want in the C++ example above.