How does the property decorator work in Python

Question

I would like to understand how the built-in function property works  What confuses me is that property can also be used as a decorator  but it only takes arguments when used as a built-in function and not when used as a decorator  This example is from the documentation  class C      def   init   self           self  x   None      def getx self           return self  x     def setx self  value           self  x   value     def delx self           del self  x     x   property getx  setx  delx   quot I m the  x  property  quot    property s arguments are getx  setx  delx and a doc string  In the code below property is used as a decorator  The object of it is the x function  but in the code above there is no place for an object function in the arguments  class C      def   init   self           self  x   None       property     def x self            quot  quot  quot I m the  x  property  quot  quot  quot          return self  x       x setter     def x self  value           self  x   value       x deleter     def x self           del self  x  How are the x setter and x deleter decorators created in this case

User · Answer

The best explanation can be found here   Python  Property Explained     How to Use and When   Full Examples  by Selva Prabhakaran   Posted on November 5  2018  It helped me understand WHY not only HOW    https   www machinelearningplus com python python-property

User · Answer

Decorator is a function that takes a function as an argument and returns closure  Closure is a set of inner function and free variable  Inner function is closing over free variable and that is why it is called  closure   Free variable is variable that outside the inner function and passed in to inner via docorator  As the name says  decorator is decorating the received function  function decorator undecorated func       print  quot calling decorator func quot       inner           print  quot I am inside inner quot          return undecorated func     return inner  this is a simple decorator function  It received  quot undecorated func quot  and passed it to inner   as a free variable  inner   printed  quot I am inside inner quot  and returned undecorated func  When we call decorator undecorated func   it is returning the inner  Here is the key  in decorators we are naming the inner function as the name of the function that we passed     undecorated function  decorator undecorated func    now inner function is called  quot undecorated func quot   Since inner is now named as  quot undecorated func quot   we passed  quot undecorated func quot  to the decorator and we returned  quot undecorated func quot  plus printed out  quot I am inside inner quot   so this print statement decorated our  quot undecorated func quot   now lets define a class with property decorator  class Person      def   init   self name           self  name name      property     def name self           return self  name      name setter     def name self value           self  name value  when we decorated name   with  property    this is what happened  name property name    Person   dict   you ll see name   first argument of property   is getter  this is what happened in the second decoration     name name setter name    As I mentioned above  decorator returns the inner function  and we name the inner function with the name of the function that we passed  Here is an important thing to be aware of   quot name quot  is immutable  in the first decoration we got this    name property name   in the second one we got this   name name setter name   We are not modifying name obj  In the second decoration  python sees that this is property object and it already had getter  So python creates a new  quot name quot  object  adds the  quot fget quot  from the first obj and then sets the  quot fset quot

User · Answer

Here is another example         Python Properties Example    class GetterSetterExample  object           Set the default value for x   we reference it using self x  set a value using self x   value         x   None         On Class Initialization - do something    if we want      def   init    self           Set a value to   x through the getter   setter    Since   x is defined above  this doesn t need to be set        self x   1234      return None         Define x as a property  ie a getter - All getters should have a default value arg  so I added it - it will not be passed in when setting a value  so you need to set the default here so it will be used       property def x  self   default   None           I added an optional default value argument as all getters should have this - set it to the default value you want to return         value     self   x   default    self   x    None           Debugging - so you can see the order the calls are made        print     Test Class   Get x       str   value             Return the value - we are a getter afterall        return  value         Define the setter function for x        x setter def x  self   value   None           Debugging - so you can see the order the calls are made        print     Test Class   Set x       str   value             This is to show the setter function works     If the value is above 0  set it to a negative value    otherwise keep it as is   0 is the only non-negative number  it can t be negative or positive anyway       if    value  gt  0            self   x   - value     else          self   x    value         Define the deleter function for x        x deleter def x  self           Unload the assignment   data for x     if   self   x    None            del self   x         To String   Output Function for the class - this will show the property value for each property we add       def   str    self           Output the x property data        print     x       str  self x              Return a new line - technically we should return a string so it can be printed where we want it  instead of printed early if  data   str  C      is used         return   n             test   GetterSetterExample    print   test       For some reason the deleter isn t being called    del  test x   Basically  the same as the C  object   example except I m using x instead    I also don t initialize in   init -     well   I do  but it can be removed because   x is defined as part of the class      The output is     Test Class   Set x   1234   Test Class   Get x   -1234   x   -1234   and if I comment out the self x   1234 in init then the output is     Test Class   Get x   None   x   None   and if I set the  default   None to  default   0 in the getter function   as all getters should have a default value but it isn t passed in by the property values from what I ve seen so you can define it here  and it actually isn t bad because you can define the default once and use it everywhere   ie  def x  self   default   0       Test Class   Get x   0   x   0   Note  The getter logic is there just to have the value be manipulated by it to ensure it is manipulated by it - the same for the print statements     Note  I m used to Lua and being able to dynamically create 10  helpers when I call a single function and I made something similar for Python without using properties and it works to a degree  but  even though the functions are being created before being used  there are still issues at times with them being called prior to being created which is strange as it isn t coded that way    I prefer the flexibility of Lua meta-tables and the fact I can use actual setters   getters instead of essentially directly accessing a variable    I do like how quickly some things can be built with Python though - for instance gui programs  although one I am designing may not be possible without a lot of additional libraries - if I code it in AutoHotkey I can directly access the dll calls I need  and the same can be done in Java  C   C    and more - maybe I haven t found the right thing yet but for that project I may switch from Python    Note  The code output in this forum is broken - I had to add spaces to the first part of the code for it to work - when copy   pasting ensure you convert all spaces to tabs     I use tabs for Python because in a file which is 10 000 lines the filesize can be 512KB to 1MB with spaces and 100 to 200KB with tabs which equates to a massive difference for file size  and reduction in processing time     Tabs can also be adjusted per user - so if you prefer 2 spaces width  4  8 or whatever you can do it meaning it is thoughtful for developers with eye-sight deficits   Note  All of the functions defined in the class aren t indented properly because of a bug in the forum software - ensure you indent it if you copy   paste

User · Answer

This following   class C object       def   init   self           self  x   None       property     def x self              I m the  x  property             return self  x       x setter     def x self  value           self  x   value       x deleter     def x self           del self  x   Is the same as   class C object       def   init   self           self  x   None      def  x get self           return self  x      def  x set self  value           self  x   value      def  x del self           del self  x      x   property  x get   x set   x del                        I m the  x  property      Is the same as   class C object       def   init   self           self  x   None      def  x get self           return self  x      def  x set self  value           self  x   value      def  x del self           del self  x      x   property  x get  doc  I m the  x  property        x   x setter  x set      x   x deleter  x del    Is the same as   class C object       def   init   self           self  x   None      def  x get self           return self  x     x   property  x get  doc  I m the  x  property         def  x set self  value           self  x   value     x   x setter  x set       def  x del self           del self  x     x   x deleter  x del    Which is the same as    class C object       def   init   self           self  x   None       property     def x self              I m the  x  property             return self  x       x setter     def x self  value           self  x   value       x deleter     def x self           del self  x

User · Answer

The property   function returns a special descriptor object    gt  gt  gt  property    lt property object at 0x10ff07940 gt    It is this object that has extra methods    gt  gt  gt  property   getter  lt built-in method getter of property object at 0x10ff07998 gt   gt  gt  gt  property   setter  lt built-in method setter of property object at 0x10ff07940 gt   gt  gt  gt  property   deleter  lt built-in method deleter of property object at 0x10ff07998 gt    These act as decorators too  They return a new property object    gt  gt  gt  property   getter None   lt property object at 0x10ff079f0 gt    that is a copy of the old object  but with one of the functions replaced   Remember  that the  decorator syntax is just syntactic sugar  the syntax    property def foo self   return self  foo   really means the same thing as  def foo self   return self  foo foo   property foo    so foo the function is replaced by property foo   which we saw above is a special object  Then when you use  foo setter    what you are doing is call that property   setter method I showed you above  which returns a new copy of the property  but this time with the setter function replaced with the decorated method   The following sequence also creates a full-on property  by using those decorator methods   First we create some functions and a property object with just a getter    gt  gt  gt  def getter self   print  Get          gt  gt  gt  def setter self  value   print  Set to   r    format value         gt  gt  gt  def deleter self   print  Delete          gt  gt  gt  prop   property getter   gt  gt  gt  prop fget is getter True  gt  gt  gt  prop fset is None True  gt  gt  gt  prop fdel is None True   Next we use the  setter   method to add a setter    gt  gt  gt  prop   prop setter setter   gt  gt  gt  prop fget is getter True  gt  gt  gt  prop fset is setter True  gt  gt  gt  prop fdel is None True   Last we add a deleter with the  deleter   method    gt  gt  gt  prop   prop deleter deleter   gt  gt  gt  prop fget is getter True  gt  gt  gt  prop fset is setter True  gt  gt  gt  prop fdel is deleter True   Last but not least  the property object acts as a descriptor object  so it has    get         set     and    delete     methods to hook into instance attribute getting  setting and deleting    gt  gt  gt  class Foo  pass       gt  gt  gt  prop   get   Foo    Foo  Get   gt  gt  gt  prop   set   Foo     bar   Set to  bar    gt  gt  gt  prop   delete   Foo    Delete    The Descriptor Howto includes a pure Python sample implementation of the property   type    class Property       Emulate PyProperty Type   in Objects descrobject c       def   init   self  fget None  fset None  fdel None  doc None           self fget   fget         self fset   fset         self fdel   fdel         if doc is None and fget is not None              doc   fget   doc           self   doc     doc      def   get   self  obj  objtype None           if obj is None              return self         if self fget is None              raise AttributeError  unreadable attribute           return self fget obj       def   set   self  obj  value           if self fset is None              raise AttributeError  can t set attribute           self fset obj  value       def   delete   self  obj           if self fdel is None              raise AttributeError  can t delete attribute           self fdel obj       def getter self  fget           return type self  fget  self fset  self fdel  self   doc         def setter self  fset           return type self  self fget  fset  self fdel  self   doc         def deleter self  fdel           return type self  self fget  self fset  fdel  self   doc

User · Answer

I read all the posts here and realized that we may need a real life example  Why  actually  we have  property  So  consider a Flask app where you use authentication system   You declare a model User in models py   class User UserMixin  db Model         tablename      users      id   db Column db Integer  primary key True      email   db Column db String 64   unique True  index True      username   db Column db String 64   unique True  index True      password hash   db Column db String 128                  property     def password self           raise AttributeError  password is not a readable attribute         password setter     def password self  password           self password hash   generate password hash password       def verify password self  password           return check password hash self password hash  password    In this code we ve  hidden  attribute password by using  property which triggers AttributeError assertion when you try to access it directly  while we used  property setter to set the actual instance variable password hash   Now in auth views py we can instantiate a User with        auth route   register   methods   GET    POST    def register        form   RegisterForm       if form validate on submit            user   User email form email data                      username form username data                      password form password data          db session add user          db session commit         Notice attribute password that comes from a registration form when a user fills the form  Password confirmation happens on the front end with EqualTo  password   message  Passwords must match    in case if you are wondering  but it s a different topic related Flask forms    I hope this example will be useful

User · Answer

This point is been cleared by many people up there but here is a direct point which I was searching  This is what I feel is important to start with the  property decorator  eg -  class UtilityMixin         property     def get config self           return  This is property    The calling of function  get config    will work like this   util   UtilityMixin   print util get config    If you notice I have not used      brackets for calling the function  This is the basic thing which I was searching for the  property decorator  So that you can use your function just like a variable

User · Answer

Let s start with Python decorators   A Python decorator is a function that helps to add some additional functionalities to an already defined function    In Python  everything is an object  Functions in Python are first-class objects which means that they can be referenced by a variable  added in the lists  passed as arguments to another function etc   Consider the following code snippet   def decorator func fun       def wrapper func            print  Wrapper function started           fun           print  Given function decorated             Wrapper function add something to the passed function and decorator            returns the wrapper function     return wrapper func  def say bye        print  bye      say bye   decorator func say bye  say bye      Output     Wrapper function started    bye    Given function decorated   Here  we can say that decorator function modified our say hello function and added some extra lines of code in it   Python syntax for decorator  def decorator func fun       def wrapper func            print  Wrapper function started           fun           print  Given function decorated             Wrapper function add something to the passed function and decorator            returns the wrapper function     return wrapper func   decorator func def say bye        print  bye      say bye     Let s Concluded everything than with a case scenario  but before that let s talk about some oops priniciples   Getters and setters are used in many object oriented programming languages to ensure the principle of data encapsulation is seen as the bundling of data with the methods that operate on these data    These methods are of course the getter for retrieving the data and the setter for changing the data    According to this principle  the attributes of a class are made private to hide and protect them from other code   Yup   property is basically a pythonic way to use getters and setters   Python has a great concept called property which makes the life of an object-oriented programmer much simpler   Let us assume that you decide to make a class that could store the temperature in degree Celsius    class Celsius  def   init   self  temperature   0       self set temperature temperature   def to fahrenheit self       return  self get temperature     1 8    32  def get temperature self       return self  temperature  def set temperature self  value       if value  lt  -273          raise ValueError  Temperature below -273 is not possible       self  temperature   value   Refactored Code  Here is how we could have achieved it with property   In Python  property   is a built-in function that creates and returns a property object   A property object has three methods  getter    setter    and delete     class Celsius  def   init   self  temperature   0       self temperature   temperature  def to fahrenheit self       return  self temperature   1 8    32  def get temperature self       print  Getting value       return self temperature  def set temperature self  value       if value  lt  -273          raise ValueError  Temperature below -273 is not possible       print  Setting value       self temperature   value  temperature   property get temperature set temperature    Here   temperature   property get temperature set temperature    could have been broken down as     make empty property temperature   property     assign fget temperature   temperature getter get temperature    assign fset temperature   temperature setter set temperature    Point To Note    get temperature remains a property instead of a method    Now you can access the value of temperature by writing   C   Celsius   C temperature   instead of writing C get temperature     We can further go on and not define names get temperature and set temperature as they are unnecessary and pollute the class namespace   The pythonic way to deal with the above problem is to use  property   class Celsius      def   init   self  temperature   0           self temperature   temperature      def to fahrenheit self           return  self temperature   1 8    32       property     def temperature self           print  Getting value           return self temperature       temperature setter     def temperature self  value           if value  lt  -273              raise ValueError  Temperature below -273 is not possible           print  Setting value           self temperature   value   Points to Note -   A method which is used for getting a value is decorated with   property   The method which has to function as the setter is decorated with   temperature setter   If the function had been called  x   we would have to decorate it with   x setter   We wrote  two  methods with the same name and a different number of parameters  def temperature self   and  def temperature self x      As you can see  the code is definitely less elegant   Now let s talk about one real-life practical scenerio   Let s say you have designed a class as follows   class OurClass       def   init   self  a           self x   a   y   OurClass 10  print y x    Now  let s further assume that our class got popular among clients and they started using it in their programs  They did all kinds of assignments to the object   And One fateful day  a trusted client came to us and suggested that  x  has to be a value between 0 and 1000  this is really a horrible scenario   Due to properties it s easy  We create a property version of  x    class OurClass       def   init   self x           self x   x       property     def x self           return self   x       x setter     def x self  x           if x  lt  0              self   x   0         elif x  gt  1000              self   x   1000         else              self   x   x   This is great  isn t it  You can start with the simplest implementation imaginable  and you are free to later migrate to a property version without having to change the interface  So properties are not just a replacement for getters and setter    You can check this Implementation here

User · Answer

The first part is simple    property def x self         is the same as  def x self       x   property x     which  in turn  is the simplified syntax for creating a property with just a getter    The next step would be to extend this property with a setter and a deleter  And this happens with the appropriate methods    x setter def x self  value         returns a new property which inherits everything from the old x plus the given setter   x deleter works  the same way

User · Answer

Here is a minimal example of how  property can be implemented   class Thing      def   init   self  my word           self  word   my word       property     def word self           return self  word   gt  gt  gt  print  Thing  ok   word    ok    Otherwise word remains a method instead of a property   class Thing      def   init   self  my word           self  word   my word     def word self           return self  word   gt  gt  gt  print  Thing  ok   word      ok

User · Answer

Below is another example on how  property can help when one has to refactor code which is taken from here  I only summarize it below    Imagine you created a class Money like this   class Money      def   init   self  dollars  cents           self dollars   dollars         self cents   cents   and an user creates a library depending on this class where he she uses e g   money   Money 27  12   print  I have    dollar and    cents   format money dollars  money cents     prints I have 27 dollar and 12 cents    Now let s suppose you decide to change your Money class and get rid of the dollars and cents attributes but instead decide to only track the total amount of cents   class Money      def   init   self  dollars  cents           self total cents   dollars   100   cents   If the above mentioned user now tries to run his her library as before  money   Money 27  12   print  I have    dollar and    cents   format money dollars  money cents     it will result in an error     AttributeError   Money  object has no attribute  dollars    That means that now everyone who relies on your original Money class would have to change all lines of code where dollars and cents are used which can be very painful    So  how could this be avoided  By using  property    That is how   class Money      def   init   self  dollars  cents           self total cents   dollars   100   cents        Getter and setter for dollars         property     def dollars self           return self total cents    100       dollars setter     def dollars self  new dollars           self total cents   100   new dollars   self cents        And the getter and setter for cents       property     def cents self           return self total cents   100       cents setter     def cents self  new cents           self total cents   100   self dollars   new cents   when we now call from our library  money   Money 27  12   print  I have    dollar and    cents   format money dollars  money cents     prints I have 27 dollar and 12 cents    it will work as expected and we did not have to change a single line of code in our library  In fact  we would not even have to know that the library we depend on changed   Also the setter works fine   money dollars    2 print  I have    dollar and    cents   format money dollars  money cents     prints I have 29 dollar and 12 cents   money cents    10 print  I have    dollar and    cents   format money dollars  money cents     prints I have 29 dollar and 22 cents    You can use  property also in abstract classes  I give a minimal example here

User · Answer

A property can be declared in two ways    Creating the getter  setter methods for an attribute and then passing these as argument to property function Using the  property decorator    You can have a look at few examples I have written about properties in python

User · Answer

Documentation says it s just a shortcut for creating readonly properties  So   property def x self       return self  x   is equivalent to  def getx self       return self  x x   property getx

User · Answer

property is a class behind  property decorator   You can always check this   print property    lt class  property  gt    I rewrote the example from help property  to show that the  property syntax  class C      def   init   self           self  x None       property      def x self           return self  x       x setter      def x self  value           self  x   value       x deleter     def x self           del self  x  c   C   c x  a  print c x    is functionally identical to property   syntax   class C      def   init   self           self  x None      def g self           return self  x      def s self  v           self  x   v      def d self           del self  x      prop   property g s d   c   C   c x  a  print c x    There is no difference how we use the property as you can see   To answer the question  property decorator is implemented via property class     So  the question is to explain the property class a bit  This line   prop   property g s d    Was the initialization  We can rewrite it like this   prop   property fget g fset s fdel d    The meaning of fget  fset and fdel         fget         function to be used for getting an attribute value       fset         function to be used for setting an attribute value       fdel         function to be used for del ing an attribute       doc         docstring   The next image shows the triplets we have  from the class property       get      set    and   delete   are there to be overridden  This is the implementation of the descriptor pattern in Python      In general  a descriptor is an object attribute with    binding behavior     one whose attribute access has been overridden by methods in the descriptor protocol     We can also use property setter  getter and deleter methods to bind the function to property  Check the next example  The method s2 of the class C will set the property doubled    class C      def   init   self           self  x None      def g self           return self  x      def s self  x           self  x   x      def d self           del self  x      def s2 self x           self  x x x       x property g      x x setter s      x x deleter d          c   C   c x  a  print c x    outputs  a   C x property C g  C s2  C x C x deleter C d  c2   C   c2 x  a  print c2 x    outputs  aa

[python] How does the @property decorator work in Python?

Examples related to python

Examples related to properties

Examples related to decorator

Examples related to python-decorators

Examples related to python-internals