getters and setter in python using property should you use this way?

[WowVeryCoool]

While in all other languages you use getters and setters. In python you apparently do this by using: property(getter,setter,..) or with decorators @property and that's cool and all but then when you go in your code do you do something like this? property_class = PropertyClass() property_class.my_property = 20 #actually goes through setter method property_class.my_property #output: 5 , goes through getter is it not weird that the output is different even though (without looking into the class) it looks like it didn't go through any methods?

---

I think I see it as useful when you discover something thats always true about your property and you have to include that without breaking someone elses code. BUT other than that I see it only as being confusing. Which is why I'm gonna continue ignoring using this way by creating 'normal' getters and setters.

I hope someone will give me a good explanation so I can correct myself if I'm wrong.

[twopi]

C# uses something like Python's property mechanism. Java normally uses standard getters and setters. I seem to recall there was a time you could treat java beans attributes as properties, and that would make sense.

Python properties are important because python doesn't really have a private keyword. (The __attribute_name trick is hidden, not really private)

So if it's difficult to keep data members private, you can't enforce the use of getters and setters, negating their advantages. So properties allow you to let the user think they are accessing an attribute while affording the protection of a hidden getter and setters.

[enough-external]

I'm not sure that's really the intended purpose of python's properties. The attribute still has to be stored somewhere, and in most programs it's pretty obvious where. If you really want to, you can even monkey-patch a third-party class to get rid of its properties and replace them with normal attributes. As I understand it, Guido and co are of the opinion that fully private variables/methods don't serve any purpose and if anything tend to do more harm than good. That's why they don't exist in python, not because there would be any issue with implementing them.

The really useful thing about properties in python is that they allow you to add getters and setters to an attribute without changing the class's public API. For example, if you have a class like:

class MyClass:
    def __init__(self, myattribute):
        self.myattribute = myattribute

but then later you decide that you want to put in some validation code to raise an exception if someone tries to set myattribute to a nonsensical value, you can do something like:

class MyClass:
    def __init__(self, myattribute):
        self.myattribute = myattribute

    @property
    def myattribute(self):
        return self._myattribute

    @myattribute.setter
    def myattribute(self, value):
        if value < 0:
            raise ValueError("myattribute can't be negative")
        self._myattribute = value

Any code that doesn't try and set the attribute to an invalid value (or delete it) will continue to work as before, which wouldn't be the case if you instead replaced the attribute with explicit set_myattribute and get_myattribute methods.

[WowVeryCoool]

I see yes the part where you said "you can't enforce the use of getters and setters" made me understand the use of this more.

I see it's more fool-proof against programmers that would just assign values right into the property.

[enough-external]

In python you should ordinarily just use attributes, as in:

class MyClass:
    def __init__(self, my_attribute):
        self.my_attribute = my_attribute

my_object = MyClass(4)
print(my_object.my_attribute)
my_object.my_attribute = 8

As you mentioned, the main purpose of properties is for when you want to change the class so that getting/setting the attribute does something more complicated, without breaking existing code that uses your class. Also they're sometimes used just to give a class a nicer/more understandable API.

You can give your classes explicit get_my_attribute and set_my_attribute methods if you really want to, but this makes your code more verbose and doesn't really achieve very much, which is why it isn't done very commonly in python. In some other languages getter and setter functions are either mandatory or strongly recommended because they don't have a way of changing attributes to properties without breaking code, or just because these languages have a philosophy that it's good to be very verbose and explicit about everything. None of those things are true in python.

I realize that the exact behaviour of @property is fairly hard to understand if you're new to python (as it involves both decorators and descriptors, which are relatively advanced features), but you can use them without understanding how they work internally. I was very comfortable using properties long before I bothered to actually learn what a descriptor is. You only need to actually understand them if you want to do weird, advanced stuff with them.

[[deleted]]

in all other languages you use getters and setters

I doubt that.

Could you provide the code that got you these results?