descriptors_in_python.ipynb

{
 "metadata": {
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python_defaultSpec_1598282915217",
   "display_name": "Python 3.6.10 64-bit (conda)"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What Are Python Descriptors?\n",
    "\n",
    "Descriptors are Python objects that implement a method of the descriptor protocol, which gives you the ability to create objects that have special behavior when they’re accessed as attributes of other objects. Here you can see the correct definition of the descriptor protocol:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "__get__(self, obj, type=None) -> object\n",
    "__set__(self, obj, value) -> None\n",
    "__delete__(self, obj) -> None\n",
    "__set_name__(self, owner, name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If your descriptor implements just .__get__(), then it’s said to be a non-data descriptor. If it implements .__set__() or .__delete__(), then it’s said to be a data descriptor. Note that this difference is not just about the name, but it’s also a difference in behavior. That’s because data descriptors have precedence during the lookup process, as you’ll see later on.\n",
    "\n",
    "Take a look at the following example, which defines a descriptor that logs something on the console when it’s accessed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "accessing the attribute to get the value\n42\n"
    }
   ],
   "source": [
    "# descriptors.py\n",
    "class Verbose_attribute():\n",
    "    def __get__(self, obj, type=None) -> object:\n",
    "        print(\"accessing the attribute to get the value\")\n",
    "        return 42\n",
    "    def __set__(self, obj, value) -> None:\n",
    "        print(\"accessing the attribute to set the value\")\n",
    "        raise AttributeError(\"Cannot change the value\")\n",
    "\n",
    "class Foo():\n",
    "    attribute1 = Verbose_attribute()\n",
    "\n",
    "my_foo_object = Foo()\n",
    "x = my_foo_object.attribute1\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "42\n"
    }
   ],
   "source": [
    "# descriptors.py\n",
    "class Foo():\n",
    "    attribute1 = 42\n",
    "\n",
    "my_foo_object = Foo()\n",
    "x = my_foo_object.attribute1\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, Verbose_attribute() implements the descriptor protocol. Once it’s instantiated as an attribute of Foo, it can be considered a descriptor.\n",
    "\n",
    "As a descriptor, it has binding behavior when it’s accessed using dot notation. In this case, the descriptor logs a message on the console every time it’s accessed to get or set a value:\n",
    "\n",
    "    When it’s accessed to .__get__() the value, it always returns the value 42.\n",
    "    When it’s accessed to .__set__() a specific value, it raises an AttributeError exception, which is the recommended way to implement read-only descriptors.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How Descriptors Work in Python’s Internals\n",
    "\n",
    "If you have experience as an object-oriented Python developer, then you may think that the previous example’s approach is a bit of overkill. You could achieve the same result by using properties. While this is true, you may be surprised to know that properties in Python are just… descriptors! You’ll see later on that properties are not the only feature that make use of Python descriptors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Descriptors in Properties\n",
    "\n",
    "If you want to get the same result as the previous example without explicitly using a Python descriptor, then the most straightforward approach is to use a property. The following example uses a property that logs a message to the console when it’s accessed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "accessing the attribute to get the value\n42\n"
    }
   ],
   "source": [
    "# property_decorator.py\n",
    "class Foo():\n",
    "    @property\n",
    "    def attribute1(self) -> object:\n",
    "        print(\"accessing the attribute to get the value\")\n",
    "        return 42\n",
    "\n",
    "    @attribute1.setter\n",
    "    def attribute1(self, value) -> None:\n",
    "        print(\"accessing the attribute to set the value\")\n",
    "        raise AttributeError(\"Cannot change the value\")\n",
    "\n",
    "my_foo_object = Foo()\n",
    "x = my_foo_object.attribute1\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example above makes use of decorators to define a property, but as you may know, decorators are just syntactic sugar. The example before, in fact, can be written as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "accessing the attribute to get the value\n42\n"
    }
   ],
   "source": [
    "# property_function.py\n",
    "class Foo():\n",
    "    def getter(self) -> object:\n",
    "        print(\"accessing the attribute to get the value\")\n",
    "        return 42\n",
    "\n",
    "    def setter(self, value) -> None:\n",
    "        print(\"accessing the attribute to set the value\")\n",
    "        raise AttributeError(\"Cannot change the value\")\n",
    "\n",
    "    attribute1 = property(getter, setter)\n",
    "\n",
    "my_foo_object = Foo()\n",
    "x = my_foo_object.attribute1\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can see that the property has been created by using property(). The signature of this function is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "property(fget=None, fset=None, fdel=None, doc=None) -> object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "property() returns a property object that implements the descriptor protocol. It uses the parameters fget, fset and fdel for the actual implementation of the three methods of the protocol."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How Attributes Are Accessed With the Lookup Chain\n",
    "\n",
    "To understand a little more about Python descriptors and Python internals, you need to understand what happens in Python when an attribute is accessed. In Python, every object has a built-in __dict__ attribute. This is a dictionary that contains all the attributes defined in the object itself. To see this in action, consider the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "{'color': 'red'}\n<class '__main__.Car'>\n{'__module__': '__main__', 'number_of_weels': 4, '__init__': <function Car.__init__ at 0x0000020519AAEAE8>, '__doc__': None}\n"
    }
   ],
   "source": [
    "class Vehicle():\n",
    "    can_fly = False\n",
    "    number_of_weels = 0\n",
    "\n",
    "class Car(Vehicle):\n",
    "    number_of_weels = 4\n",
    "\n",
    "    def __init__(self, color):\n",
    "        self.color = color\n",
    "\n",
    "my_car = Car(\"red\")\n",
    "print(my_car.__dict__)\n",
    "print(type(my_car))\n",
    "print(type(my_car).__dict__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code creates a new object and prints the contents of the __dict__ attribute for both the object and the class. Now, run the script and analyze the output to see the __dict__ attributes set:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The __dict__ attributes are set as expected. Note that, in Python, everything is an object. A class is actually an object as well, so it will also have a __dict__ attribute that contains all the attributes and methods of the class.\n",
    "\n",
    "So, what’s going on under the hood when you access an attribute in Python? Let’s make some tests with a modified version of the former example. Consider this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "red\n4\nFalse\n"
    }
   ],
   "source": [
    "# lookup.py\n",
    "class Vehicle(object):\n",
    "    can_fly = False\n",
    "    number_of_weels = 0\n",
    "\n",
    "class Car(Vehicle):\n",
    "    number_of_weels = 4\n",
    "\n",
    "    def __init__(self, color):\n",
    "        self.color = color\n",
    "\n",
    "my_car = Car(\"red\")\n",
    "\n",
    "print(my_car.color)\n",
    "print(my_car.number_of_weels)\n",
    "print(my_car.can_fly)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, when you access the attribute color of the instance my_car, you’re actually accessing a single value of the __dict__ attribute of the object my_car. When you access the attribute number_of_wheels of the object my_car, you’re really accessing a single value of the __dict__ attribute of the class Car. Finally, when you access the can_fly attribute, you’re actually accessing it by using the __dict__ attribute of the Vehicle class.\n",
    "\n",
    "This means that it’s possible to rewrite the above example like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "red\n4\nFalse\n"
    }
   ],
   "source": [
    "# lookup2.py\n",
    "class Vehicle():\n",
    "    can_fly = False\n",
    "    number_of_weels = 0\n",
    "\n",
    "class Car(Vehicle):\n",
    "    number_of_weels = 4\n",
    "\n",
    "    def __init__(self, color):\n",
    "        self.color = color\n",
    "\n",
    "my_car = Car(\"red\")\n",
    "\n",
    "print(my_car.__dict__['color'])\n",
    "print(type(my_car).__dict__['number_of_weels'])\n",
    "print(type(my_car).__base__.__dict__['can_fly'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, what happens when you access the attribute of an object with dot notation? How does the interpreter know what you really need? Well, here’s where a concept called the lookup chain comes in:\n",
    "\n",
    "    First, you’ll get the result returned from the __get__ method of the data descriptor named after the attribute you’re looking for.\n",
    "\n",
    "    If that fails, then you’ll get the value of your object’s __dict__ for the key named after the attribute you’re looking for.\n",
    "\n",
    "    If that fails, then you’ll get the result returned from the __get__ method of the non-data descriptor named after the attribute you’re looking for.\n",
    "\n",
    "    If that fails, then you’ll get the value of your object type’s __dict__ for the key named after the attribute you’re looking for.\n",
    "\n",
    "    If that fails, then you’ll get the value of your object parent type’s __dict__ for the key named after the attribute you’re looking for.\n",
    "\n",
    "    If that fails, then the previous step is repeated for all the parent’s types in the method resolution order of your object.\n",
    "\n",
    "    If everything else has failed, then you’ll get an AttributeError exception.\n",
    "\n",
    "Now you can see why it’s important to know if a descriptor is a data descriptor or a non-data descriptor? They’re on different levels of the lookup chain, and you’ll see later on that this difference in behavior can be very convenient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to Use Python Descriptors Properly\n",
    "\n",
    "If you want to use Python descriptors in your code, then you just need to implement the descriptor protocol. The most important methods of this protocol are .__get__() and .__set__(), which have the following signature:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "__get__(self, obj, type=None) -> object\n",
    "__set__(self, obj, value) -> None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you implement the protocol, keep these things in mind:\n",
    "\n",
    "    self is the instance of the descriptor you’re writing.\n",
    "    obj is the instance of the object your descriptor is attached to.\n",
    "    type is the type of the object the descriptor is attached to.\n",
    "\n",
    "In .__set__(), you don’t have the type variable, because you can only call .__set__() on the object. In contrast, you can call .__get__() on both the object and the class.\n",
    "\n",
    "Another important thing to know is that Python descriptors are instantiated just once per class. That means that every single instance of a class containing a descriptor shares that descriptor instance. This is something that you might not expect and can lead to a classic pitfall, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "3\n3\n3\n"
    }
   ],
   "source": [
    "# descriptors2.py\n",
    "class OneDigitNumericValue():\n",
    "    def __init__(self):\n",
    "        self.value = 0\n",
    "    def __get__(self, obj, type=None) -> object:\n",
    "        return self.value\n",
    "    def __set__(self, obj, value) -> None:\n",
    "        if value > 9 or value < 0 or int(value) != value:\n",
    "            raise AttributeError(\"The value is invalid\")\n",
    "        self.value = value\n",
    "\n",
    "class Foo():\n",
    "    number = OneDigitNumericValue()\n",
    "\n",
    "my_foo_object = Foo()\n",
    "my_second_foo_object = Foo()\n",
    "\n",
    "my_foo_object.number = 3\n",
    "print(my_foo_object.number)\n",
    "print(my_second_foo_object.number)\n",
    "\n",
    "my_third_foo_object = Foo()\n",
    "print(my_third_foo_object.number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, you have a class Foo that defines an attribute number, which is a descriptor. This descriptor accepts a single-digit numeric value and stores it in a property of the descriptor itself. However, this approach won’t work, because each instance of Foo shares the same descriptor instance. What you’ve essentially created is just a new class-level attribute.\n",
    "\n",
    "Try to run the code and examine the output:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that all the instances of Foo have the same value for the attribute number, even though the last one was created after the my_foo_object.number attribute was set.\n",
    "\n",
    "So, how can you solve this problem? You might think that it’d be a good idea to use a dictionary to save all the values of the descriptor for all the objects it’s attached to. This seems to be a good solution since .__get__() and .__set__() have the obj attribute, which is the instance of the object you’re attached to. You could use this value as a key for the dictionary.\n",
    "\n",
    "Unfortunately, this solution has a big downside, which you can see in the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "3\n0\n0\n"
    }
   ],
   "source": [
    "# descriptors3.py\n",
    "class OneDigitNumericValue():\n",
    "    def __init__(self):\n",
    "        self.value = {}\n",
    "\n",
    "    def __get__(self, obj, type=None) -> object:\n",
    "        try:\n",
    "            return self.value[obj]\n",
    "        except:\n",
    "            return 0\n",
    "\n",
    "    def __set__(self, obj, value) -> None:\n",
    "        if value > 9 or value < 0 or int(value) != value:\n",
    "            raise AttributeError(\"The value is invalid\")\n",
    "        self.value[obj] = value\n",
    "\n",
    "class Foo():\n",
    "    number = OneDigitNumericValue()\n",
    "\n",
    "my_foo_object = Foo()\n",
    "my_second_foo_object = Foo()\n",
    "\n",
    "my_foo_object.number = 3\n",
    "print(my_foo_object.number)\n",
    "print(my_second_foo_object.number)\n",
    "\n",
    "my_third_foo_object = Foo()\n",
    "print(my_third_foo_object.number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unfortunately, the downside here is that the descriptor is keeping a strong reference to the owner object. This means that if you destroy the object, then the memory is not released because the garbage collector keeps finding a reference to that object inside the descriptor!\n",
    "\n",
    "You may think that the solution here could be the use of weak references. While that may, you’d have to deal with the fact that not everything can be referenced as weak and that, when your objects get collected, they disappear from your dictionary.\n",
    "\n",
    "The best solution here is to simply not store values in the descriptor itself, but to store them in the object that the descriptor is attached to. Try this approach next:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "3\n0\n0\n"
    }
   ],
   "source": [
    "# descriptors4.py\n",
    "class OneDigitNumericValue():\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def __get__(self, obj, type=None) -> object:\n",
    "        return obj.__dict__.get(self.name) or 0\n",
    "\n",
    "    def __set__(self, obj, value) -> None:\n",
    "        obj.__dict__[self.name] = value\n",
    "\n",
    "class Foo():\n",
    "    number = OneDigitNumericValue(\"number\")\n",
    "\n",
    "my_foo_object = Foo()\n",
    "my_second_foo_object = Foo()\n",
    "\n",
    "my_foo_object.number = 3\n",
    "print(my_foo_object.number)\n",
    "print(my_second_foo_object.number)\n",
    "\n",
    "my_third_foo_object = Foo()\n",
    "print(my_third_foo_object.number)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "{'name': 5}"
     },
     "metadata": {},
     "execution_count": 16
    }
   ],
   "source": [
    "d={}\n",
    "d['name']=5\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, when you set a value to the number attribute of your object, the descriptor stores it in the __dict__ attribute of the object it’s attached to using the same name of the descriptor itself.\n",
    "\n",
    "The only problem here is that when you instantiate the descriptor you have to specify the name as a parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = OneDigitNumericValue(\"number\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wouldn’t it be better to just write number = OneDigitNumericValue()? It might, but if you’re running a version of Python less than 3.6, then you’ll need a little bit of magic here with metaclasses and decorators. If you use Python 3.6 or higher, however, then the descriptor protocol has a new method .__set_name__() that does all this magic for you, as proposed in PEP 487:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "__set_name__(self, owner, name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this new method, whenever you instantiate a descriptor this method is called and the name parameter automatically set.\n",
    "\n",
    "Now, try to rewrite the former example for Python 3.6 and up:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "3\n0\n0\n"
    }
   ],
   "source": [
    "# descriptors5.py\n",
    "class OneDigitNumericValue():\n",
    "    def __set_name__(self, owner, name):\n",
    "        self.name = name\n",
    "\n",
    "    def __get__(self, obj, type=None) -> object:\n",
    "        return obj.__dict__.get(self.name) or 0\n",
    "\n",
    "    def __set__(self, obj, value) -> None:\n",
    "        obj.__dict__[self.name] = value\n",
    "\n",
    "class Foo():\n",
    "    number = OneDigitNumericValue()\n",
    "\n",
    "my_foo_object = Foo()\n",
    "my_second_foo_object = Foo()\n",
    "\n",
    "my_foo_object.number = 3\n",
    "print(my_foo_object.number)\n",
    "print(my_second_foo_object.number)\n",
    "\n",
    "my_third_foo_object = Foo()\n",
    "print(my_third_foo_object.number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why Use Python Descriptors?\n",
    "\n",
    "Now you know what Python descriptors are and how Python itself uses them to power some of its features, like methods and properties. You’ve also seen how to create a Python descriptor while avoiding some common pitfalls. Everything should be clear now, but you may still wonder why you should use them.\n",
    "\n",
    "In my experience, I’ve known a lot of advanced Python developers that have never used this feature before and that have no need for it. That’s quite normal because there are not many use cases where Python descriptors are necessary. However, that doesn’t mean that Python descriptors are just an academic topic for advanced users. There are still some good use cases that can justify the price of learning how to use them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## D.R.Y. Code\n",
    "\n",
    "Another typical use case for descriptors is to write reusable code and make your code D.R.Y. Python descriptors give developers a great tool to write reusable code that can be shared among different properties or even different classes.\n",
    "\n",
    "Consider an example where you have five different properties with the same behavior. Each property can be set to a specific value only if it’s an even number. Otherwise, it’s value is set to 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "0\n4\n"
    }
   ],
   "source": [
    "# properties.py\n",
    "class Values:\n",
    "    def __init__(self):\n",
    "        self._value1 = 0\n",
    "        self._value2 = 0\n",
    "        self._value3 = 0\n",
    "        self._value4 = 0\n",
    "        self._value5 = 0\n",
    "\n",
    "    @property\n",
    "    def value1(self):\n",
    "        return self._value1\n",
    "\n",
    "    @value1.setter\n",
    "    def value1(self, value):\n",
    "        self._value1 = value if value % 2 == 0 else 0\n",
    "\n",
    "    @property\n",
    "    def value2(self):\n",
    "        return self._value2\n",
    "\n",
    "    @value2.setter\n",
    "    def value2(self, value):\n",
    "        self._value2 = value if value % 2 == 0 else 0\n",
    "\n",
    "    @property\n",
    "    def value3(self):\n",
    "        return self._value3\n",
    "\n",
    "    @value3.setter\n",
    "    def value3(self, value):\n",
    "        self._value3 = value if value % 2 == 0 else 0\n",
    "\n",
    "    @property\n",
    "    def value4(self):\n",
    "        return self._value4\n",
    "\n",
    "    @value4.setter\n",
    "    def value4(self, value):\n",
    "        self._value4 = value if value % 2 == 0 else 0\n",
    "\n",
    "    @property\n",
    "    def value5(self):\n",
    "        return self._value5\n",
    "\n",
    "    @value5.setter\n",
    "    def value5(self, value):\n",
    "        self._value5 = value if value % 2 == 0 else 0\n",
    "\n",
    "my_values = Values()\n",
    "my_values.value1 = 1\n",
    "my_values.value2 = 4\n",
    "print(my_values.value1)\n",
    "print(my_values.value2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, you have a lot of duplicated code here. It’s possible to use Python descriptors to share behavior among all the properties. You can create an EvenNumber descriptor and use it for all the properties like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "0\n4\n"
    }
   ],
   "source": [
    "# properties2.py\n",
    "class EvenNumber:\n",
    "    def __set_name__(self, owner, name):\n",
    "        self.name = name\n",
    "\n",
    "    def __get__(self, obj, type=None) -> object:\n",
    "        return obj.__dict__[self.name]# or 0\n",
    "\n",
    "    def __set__(self, obj, value) -> None:\n",
    "        obj.__dict__[self.name] = (value if value % 2 == 0 else 0)\n",
    "\n",
    "    def __delete__(self, obj) -> None:\n",
    "        del obj.__dict__[self.name]\n",
    "\n",
    "class Values:\n",
    "    value1 = EvenNumber()\n",
    "    value2 = EvenNumber()\n",
    "    value3 = EvenNumber()\n",
    "    value4 = EvenNumber()\n",
    "    value5 = EvenNumber()\n",
    "\n",
    "my_values = Values()\n",
    "my_values.value1 = 1\n",
    "my_values.value2 = 4\n",
    "print(my_values.value1)\n",
    "print(my_values.value2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "del my_values.value2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "KeyError",
     "evalue": "'value2'",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-40-e3f079de5006>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmy_values\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalue2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-37-82c8c9629d01>\u001b[0m in \u001b[0;36m__get__\u001b[1;34m(self, obj, type)\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__get__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[0mobject\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mobj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;31m# or 0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__set__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'value2'"
     ]
    }
   ],
   "source": [
    "my_values.value2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}