What s the pythonic way to use getters and setters

Question

I m doing it like   def set property property value     def get property property       or   object property   value   value   object property   I m new to Python  so i m still exploring the syntax  and i d like some advice on doing this

User · Answer

Properties are pretty useful since you can use them with assignment but then can include validation as well. You can see this code where you use the decorator @property and also @<property_name>.setter to create the methods:

# Python program displaying the use of @property 
class AgeSet:
    def __init__(self):
        self._age = 0

    # using property decorator a getter function
    @property
    def age(self):
        print("getter method called")
        return self._age

    # a setter function
    @age.setter
    def age(self, a):
        if(a < 18):
            raise ValueError("Sorry your age is below eligibility criteria")
        print("setter method called")
        self._age = a

pkj = AgeSet()

pkj.age = int(input("set the age using setter: "))

print(pkj.age)

There are more details in this post I wrote about this as well: https://pythonhowtoprogram.com/how-to-create-getter-setter-class-properties-in-python-3/

User · Answer

You can use accessors mutators  i e   attr setter and  property  or not  but the most important thing is to be consistent   If you re using  property to simply access an attribute  e g   class myClass      def   init   a           self  a   a       property     def a self           return self  a    use it to access every  attribute  It would be a bad practice to access some attributes using  property and leave some other properties public  i e  name without an underscore  without an accessor  e g  do not do  class myClass      def   init   a  b           self a   a         self b   b       property     def a self           return self a    Note that self b does not have an explicit accessor here even though it s public   Similarly with setters  or mutators   feel free to use  attribute setter but be consistent  When you do e g   class myClass      def   init   a  b           self a   a         self b   b        a setter     def a self  value           return self a   value   It s hard for me to guess your intention  On one hand you re saying that both a and b are public  no leading underscore in their names  so I should theoretically be allowed to access mutate  get set  both  But then you specify an explicit mutator only for a  which tells me that maybe I should not be able to set b  Since you ve provided an explicit mutator I am not sure if the lack of explicit accessor   property  means I should not be able to access either of those variables or you were simply being frugal in using  property     The exception is when you explicitly want to make some variables accessible or mutable but not both or you want to perform some additional logic when accessing or mutating an attribute  This is when I am personally using  property and  attribute setter  otherwise no explicit acessors mutators for public attributes    Lastly  PEP8 and Google Style Guide suggestions   PEP8  Designing for Inheritance says      For simple public data attributes  it is best to expose just the attribute name  without complicated accessor mutator methods  Keep in mind that Python provides an easy path to future enhancement  should you find that a simple data attribute needs to grow functional behavior  In that case  use properties to hide functional implementation behind simple data attribute access syntax    On the other hand  according to Google Style Guide Python Language Rules Properties the recommendation is to      Use properties in new code to access or set data where you would normally have used simple  lightweight accessor or setter methods  Properties should be created with the  property decorator    The pros of this approach      Readability is increased by eliminating explicit get and set method calls for simple attribute access  Allows calculations to be lazy  Considered the Pythonic way to maintain the interface of a class  In terms of performance  allowing properties bypasses needing trivial accessor methods when a direct variable access is reasonable  This also allows accessor methods to be added in the future without breaking the interface    and cons      Must inherit from object in Python 2  Can hide side-effects much like operator overloading  Can be confusing for subclasses

User · Answer

This is an old question but the topic is very important and always current  In case anyone wants to go beyond simple getters setters i have wrote an article about superpowered properties in python with support for slots  observability and reduced boilerplate code  from objects import properties  self properties   class Car      with properties locals     meta   as meta            meta prop read only True          def brand self  - gt  str               quot  quot  quot Brand quot  quot  quot            meta prop read only True          def max speed self  - gt  float               quot  quot  quot Maximum car speed quot  quot  quot            meta prop listener   on acceleration           def speed self  - gt  float               quot  quot  quot Speed of the car quot  quot  quot              return 0    Default stopped           meta prop listener   on off listener           def on self  - gt  bool               quot  quot  quot Engine state quot  quot  quot              return False      def   init   self  brand  str  max speed  float   200           self properties self  locals         def  on off listener self  prop  old  on           if on              print f quot  self brand  Turned on  Runnnnnn quot           else              self  speed   0             print f quot  self brand  Turned off  quot        def  on acceleration self  prop  old  speed           if self on              if speed  gt  self max speed                  print f quot  self brand   speed km h Bang  Engine exploded  quot                   self on   False             else                  print f quot  self brand  New speed   speed km h quot           else              print f quot  self brand  Car is off  no speed change quot    This class can be used like this  mycar   Car  Ford      Car is turned off for speed in range 0  300  50       mycar speed   speed    Car is turned on mycar on   True for speed in range 0  350  50       mycar speed   speed  This code will produce the following output  Ford Car is off  no speed change Ford Car is off  no speed change Ford Car is off  no speed change Ford Car is off  no speed change Ford Car is off  no speed change Ford Car is off  no speed change Ford Turned on  Runnnnnn Ford New speed  0km h Ford New speed  50km h Ford New speed  100km h Ford New speed  150km h Ford New speed  200km h Ford 250km h Bang  Engine exploded  Ford Turned off  Ford Car is off  no speed change  More info about how and why here  https   mnesarco github io blog 2020 07 23 python-metaprogramming-properties-on-steroids

User · Answer

What s the pythonic way to use getters and setters    The  Pythonic  way is not to use  getters  and  setters   but to use plain attributes  like the question demonstrates  and del for deleting  but the names are changed to protect the innocent    builtins    value    something   obj attribute   value   value   obj attribute del obj attribute   If later  you want to modify the setting and getting  you can do so without having to alter user code  by using the property decorator   class Obj         property demo               property              first decorate the getter method     def attribute self     This getter method name is  the  name         return self  attribute            attribute setter      the property decorates with   setter  now     def attribute self  value       name  e g   attribute   is the same         self  attribute   value     the  value  name isn t special            attribute deleter       decorate with   deleter      def attribute self       again  the method name is the same         del self  attribute    Each decorator usage copies and updates the prior property object  so note that you should use the same name for each set  get  and delete function method   After defining the above  the original setting  getting  and deleting code is the same   obj   Obj   obj attribute   value   the value   obj attribute del obj attribute   You should avoid this    def set property property value     def get property property        Firstly  the above doesn t work  because you don t provide an argument for the instance that the property would be set to  usually self   which would be   class Obj       def set property self  property  value     don t do this                 def get property self  property            don t do this either               Secondly  this duplicates the purpose of two special methods    setattr   and   getattr     Thirdly  we also have the setattr and getattr builtin functions   setattr object   property name   value  getattr object   property name   default value     default is optional   The  property decorator is for creating getters and setters   For example  we could modify the setting behavior to place restrictions the value being set   class Protective object         property     def protected value self           return self  protected value       protected value setter     def protected value self  value           if acceptable value     e g  type or range check             self  protected value   value   In general  we want to avoid using property and just use direct attributes    This is what is expected by users of Python  Following the rule of least-surprise  you should try to give your users what they expect unless you have a very compelling reason to the contrary   Demonstration  For example  say we needed our object s protected attribute to be an integer between 0 and 100 inclusive  and prevent its deletion  with appropriate messages to inform the user of its proper usage   class Protective object          protected property demo              def   init   self  start protected value 0           self protected value   start protected value             property     def protected value self           return self  protected value            protected value setter     def protected value self  value           if value    int value               raise TypeError  protected value must be an integer           if 0  lt   value  lt   100              self  protected value   int value          else              raise ValueError  protected value must be                                   between 0 and 100 inclusive              protected value deleter     def protected value self           raise AttributeError  do not delete  protected value can be set to 0      Note that   init   refers to self protected value but the property methods refer to self  protected value  This is so that   init   uses the property through the public API  ensuring it is  protected     And usage    gt  gt  gt  p1   Protective 3   gt  gt  gt  p1 protected value 3  gt  gt  gt  p1   Protective 5 0   gt  gt  gt  p1 protected value 5  gt  gt  gt  p2   Protective -5  Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt    File   lt stdin gt    line 3  in   init     File   lt stdin gt    line 15  in protected value ValueError  protectected value must be between 0 and 100 inclusive  gt  gt  gt  p1 protected value   7 3 Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt    File   lt stdin gt    line 17  in protected value TypeError  protected value must be an integer  gt  gt  gt  p1 protected value   101 Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt    File   lt stdin gt    line 15  in protected value ValueError  protectected value must be between 0 and 100 inclusive  gt  gt  gt  del p1 protected value Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt    File   lt stdin gt    line 18  in protected value AttributeError  do not delete  protected value can be set to 0   Do the names matter   Yes they do   setter and  deleter make copies of the original property  This allows subclasses to properly modify behavior without altering the behavior in the parent   class Obj         property demo               property     def get only self           return self  attribute            get only setter     def get or set self  value           self  attribute   value            get or set deleter     def get set or delete self           del self  attribute   Now for this to work  you have to use the respective names   obj   Obj     obj get only    value    would error obj get or set    value    obj get set or delete    new value  the value   obj get only del obj get set or delete   del obj get or set   would error   I m not sure where this would be useful  but the use-case is if you want a get  set  and or delete-only property  Probably best to stick to semantically same property having the same name   Conclusion  Start with simple attributes   If you later need functionality around the setting  getting  and deleting  you can add it with the property decorator   Avoid functions named set     and get     - that s what properties are for

User · Answer

Using  property and  attribute setter helps you to not only use the  pythonic  way but also to check the validity of attributes both while creating the object and when altering it   class Person object       def   init   self  p name None           self name   p name       property     def name self           return self  name       name setter     def name self  new name           if type new name     str   type checking for name property             self  name   new name         else              raise Exception  Invalid value for name     By this  you actually  hide   name attribute from client developers and also perform checks on name property type  Note that by following this approach even during the initiation the setter gets called  So   p   Person 12    Will lead to   Exception  Invalid value for name   But    gt  gt  gt p   person  Mike    gt  gt  gt print p name  Mike  gt  gt  gt p name    George   gt  gt  gt print p name  George  gt  gt  gt p name   2 3   Causes an exception

User · Answer

You can use the magic methods   getattribute   and   setattr     class MyClass      def   init   self  attrvalue           self myattr   attrvalue     def   getattribute   self  attr           if attr     myattr                Getter for myattr     def   setattr   self  attr           if attr     myattr                Setter for myattr   Be aware that   getattr   and   getattribute   are not the same    getattr   is only invoked when the attribute is not found

User · Answer

In  1   class test object       def   init   self           self pants    pants       property     def p self           return self pants      p setter     def p self  value           self pants   value   2           In  2   t   test   In  3   t p Out 3    pants  In  4   t p   10 In  5   t p Out 5   20

User · Answer

Try this  Python Property  The sample code is   class C object       def   init   self           self  x   None       property     def x self              I m the  x  property             print  getter of x called           return self  x       x setter     def x self  value           print  setter of x called           self  x   value       x deleter     def x self           print  deleter of x called           del self  x   c   C   c x    foo     setter called foo   c x      getter called del c x        deleter called

User · Answer

Check out the  property decorator

[python] What's the pythonic way to use getters and setters?

Examples related to python

Examples related to getter-setter