DEV Community: shivambats

Python Descriptors: A practical guide to understand the core

shivambats — Mon, 17 Aug 2020 11:03:11 +0000

Descriptors are somewhat of an advanced concept but easy to implement once understood, let’s understand the core of it with some real world example.

What are Python Descriptors?

Descriptor in python is an object which implements any of the method in the descriptor protocol. Descriptors are a powerful and useful protocol and behind some of the most useful concepts of python such as classmethods, staticmethods, properties etc.. The descriptor protocol is said to be the implementation of any of the below methods:
__get__(self, instance, type) __set__(self, instance, value) __delete__(self, instance)

That means any of the object which contains the implementation of any of the given methods, that object is said to be a descriptor. The object for the class DescriptorExample below will be a descriptor.

The output of the following code will be,
setting the value to 5
{}

Note that the value of some_attr has not been set as of yet, since we have just put the print statement in its get and set methods. And that’s why your_class_obj.dict gives us an empty dict.

Let’s add the functionality to achieve the set and get behavior for the attribute of the instance.

The output of the following code will be,
setting the value to 5
{}

As we instantiate the object of YourClass and in init method we are trying to set the value of some_attr, and some_attr is the attribute which has been attached to the Descriptor and hence its behavior which is setting and retrieval will be overridden by the methods of the DescriptorExample.
Note that the value of some_attr has not been set as of yet, since we have just put the print statement in its get and set methods. And that’s why your_class_obj.dict gives us an empty dict.
Let’s add the functionality to achieve the set and get behavior for the attribute of the instance.

The output of the following code will be,
setting the value to 5 getting the value of the object's attribute 5 setting the value to 10 getting the value of the object's attribute 10

As you can see, we have extended the behavior of getting and setting the some_attr attribute.

Types of Descriptors

Data Descriptor: If an object defines set() or delete(), it is considered as a data descriptor. All the descriptors defined earlier are data descriptor as we have implemented set method in them.
Non Data Descriptor: If an object defines only get(), it is considered as a non data descriptor. We can also restrict the value assignment to the attribute.

Usage of Descriptor

Let’s say we have orders data with its order_id, shipping_price, and order_price. And we need to store the pretax values of shipping_price and order_price. Also, the tax calculated for Europe region and US region are different. In this example, we will be assuming the tax rates for EU and US region to be 19 and 12 respectively.
The usual way of doing this could be having a method to calculate pretax values of EU and US region. Something like this,

The output of the snippet is given below, as you can see we do get the pretax value after the first assignment of the attribute, but once the value of shipping_price is assigned again, we do not get the pretax value.

25.0 20

However the problem with this approach is if we assign a value to shipping_price or order_price later to the instance, it will not have a pretax value and instead the value which is assigned to it. Hence we will have sort of a broken class.
We can try to solve this problem by using descriptors, and having descriptors for both EU and US attributes. Something like this.

The output of the following will be, note that setting the value of shipping_price to be 11 and 22, we get the pretax values for both the attributes.

20.0 25.0 10.0 20.0

As you can see that we have reused the code for the marketplaces in the US, this way any new marketplace added for any of the US or EU region can simply attach their attribute whose pretax value need to be stored. This is nothing less than the magic of descriptors.
Descriptors can have a lot of other uses such as

Data Validation — Validating the data before setting the value of the attribute.
Restrict Access — As shown above, we can restrict the assignment of any attribute by using non data descriptor.
Lazy Loading — We can put the business logic in the get method rather than set so we only compute while getting the data.

Using Python’s Magic Methods to compare Tesla and Ford

shivambats — Sat, 15 Aug 2020 19:58:34 +0000

Magic Methods are the special methods which gives us the ability to access built in syntactical features such as ‘<’, ‘>’, ‘==’, ‘+’ etc..

You must have worked with such methods without knowing them to be as magic methods. Magic methods can be identified with their names which start with __ and ends with __ like __init__, __call__, __str__ etc. These methods are also called Dunder Methods, because of their name starting and ending with Double Underscore (Dunder).

Now there are a number of such special methods, which you might have come across too, in Python. We will just be taking an example of a few of them to understand how they work and how we can use them.

1. `init`

class AnyClass:
    def __init__():
        print("Init called on its own")
obj = AnyClass()

The first example is init, and as the name suggests, it is used for initializing objects. Init method is called on its own, ie. whenever an object is created for the class, the init method is called on its own.

The output of the above code will be given below. Note how we did not call the init method and it got invoked as we created an object for class AnyClass.
Init called on its own

2. `add`

Let’s move to some other example, add gives us the ability to access the built in syntax feature of the character +. Let’s see how,

class AnyClass:
    def __init__(self, var):
        self.some_var = var
    def __add__(self, other_obj):
        print("Calling the add method")
        return self.some_var + other_obj.some_var
obj1 = AnyClass(5)
obj2 = AnyClass(6)
obj1 + obj2

As we use the + character, it will call the add method. Now observe the add, it expects the second argument to be other_obj, and hence we have the access to add not just some_var of the other object but any other variable as well. The output would be,

"Calling the add method"
11

Similar to add, we can have

__eq__(self, other_obj)Defines behavior for the equality operator, ==.
__ne__(self, other_obj)Defines behavior for the inequality operator, !=.
__lt__(self, other_obj)Defines behavior for the less-than operator, <.
__gt__(self, other_obj)Defines behavior for the greater-than operator, >.
__le__(self, other_obj)Defines behavior for the less-than-or-equal-to operator, <=.
__ge__(self, other_obj)Defines behavior for the greater-than-or-equal-to operator, >=.

3. `repr`

It is used to represent the object. It gives all the representation of all the information of the object. We will understand more about it in the example later.
If we create an object of the class AnyClass from the previous example, and do repr(obj) or print(obj) it will return
'<__main__.AnyClass object at 0x0000025B8FB75048>'
Let’s add the repr method to our AnyClass, and see the ‘magic’.

class AnyClass:
    def __init__(self, var):
        self.some_var = var
def __repr__(self):
        print(f"AnyClass with some_var value as {self.some_var}")
obj = AnyClass(5)
print(obj)

The output of the above example will be,
AnyClass with some_var value as 5

Now, let’s use these magic methods and compare Tesla Model 3 and Ford Mustang

Lets create a class Car and define these magic methods to get the ability to use the operators and compare the Car’s attributes such as Top Speed, Horsepower and Price.

class Car:
    def __init__(self, name, manufacturer, horsepower, top_speed, cost, length):
        self.name = name
        self.manufacturer = manufacturer
        self.horsepower = horsepower
        self.top_speed = top_speed
        self.cost = cost
        self.length = length
    def __sub__(self, other):
        print(f"Difference In Price: {self.cost - other.cost}")
        print(f"Difference in Horsepower: {self.horsepower -     other.horsepower}")
        print(f"Difference in Top Speed: {self.top_speed -   other.top_speed}")
    def __len__(self):
        return f"{self.length}m"

If we run this program and command,

tesla = Car(name='Model 3', manufacturer='Tesla', horsepower=283, top_speed=129, cost=35000, length=4.69)
ford = Car(name='Mustang Mach E', manufacturer='Ford', horsepower=282, top_speed=132, cost=25100, length=4.72)
ford - tesla
len(ford)
len(tesla)

Will return us,
Difference In Price: $8895
Difference in Horsepower: -1
Difference in Top Speed: 3
4.72m
4.69m

The ‘-’ operator gave us the difference in price, power and speed, it’s nothing less of a ‘magic’ if you don’t know how it works. But now we do know, and lets implement other methods. And len gave us the lengths of the cars ie. the length attribute of the Car object.

By this program, we will be able to run commands such as,tesla == ford tesla != ford, tesla < ford etc..

Note this might not be something that you will have to do in real life but this is one of the examples to showcase how we can make use of the built in features of Python, and understand the concepts behind them.

Handling exceptions in Python a cleaner way, using Decorators

shivambats — Fri, 14 Aug 2020 20:21:06 +0000

Functions in Python

Functions in Python are first class objects, which means they can be assigned to a variable, passed as an argument, and return from another function and store that in any data structure.

def example_function():
    print("Example Function called")
some_variable = example_function
some_variable()

As you can see we have assigned example_function to some_variable which makes some_variable callable. The output for the following will be:
Example Function called

Decorators

The first class object property of function helps us to use the concept of Decorators in Python. Decorators are functions which take as argument another function as an object, which enables us to put our logic either at the start and end of the execution of the argument function.

def decorator_example(func):
    print("Decorator called")

    def inner_function(*args, **kwargs):
            print("Calling the function")
            func(*args, **kwargs)
            print("Function's execution is over")
    return inner_function
@decorator_example
def some_function():
    print("Executing the function")
    # Function logic goes here

As you can see we are using the decorator by using @decorator_example on top of the function which needs to be passed as the argument to the Decorator function. In this case, some_function will be passed as an argument to decorator_example. The output of the above snippet will be:

Decorator called Calling the function Executing the function Function's execution is over

Error Handling Using Decorators

You can use Decorators for quite a lot of purposes like logging, validations, or any other common logic which needs to be put in multiple functions. One of the many areas where Decorators can be used is the exception handling.
Let’s take an example of such functions, which require handling of the same exceptions.

We will take a simple example of calculating areas. And we will be for now printing the errors if an unsupported type is passed as the argument which in this case will be a string.

Errors should never pass silently.
Unless explicitly silenced.

The normal way to do this would be to have all such functions in a try-catch, somewhat like this,

def area_square(length):
    try:
        print(length**2)
    except TypeError:
        print("area_square only takes numbers as the argument")


def area_circle(radius):
    try:
        print(3.142 * radius**2)
    except TypeError:
        print("area_circle only takes numbers as the argument")


def area_rectangle(length, breadth):
    try:
        print(length * breadth)
    except TypeError:
        print("area_rectangle only takes numbers as the argument")

Now, this looks repetitive which we should avoid to the extent we can. So we can use the magic of Decorators here and observe that the code looks a lot cleaner this way. And a clean code goes a long way.

def exception_handler(func):
    def inner_function(*args, **kwargs):
        try:
            func(*args, **kwargs)
        except TypeError:
            print(f"{func.__name__} only takes numbers as the argument")
    return inner_function


@exception_handler
def area_square(length):
    print(length * length)


@exception_handler
def area_circle(radius):
    print(3.14 * radius * radius)


@exception_handler
def area_rectangle(length, breadth):
    print(length * breadth)


area_square(2)
area_circle(2)
area_rectangle(2, 4)
area_square("some_str")
area_circle("some_other_str")
area_rectangle("some_other_rectangle")

The output of the following will be:

4 12.568 8 area_square only takes numbers as the argument area_circle only takes numbers as the argument area_rectangle only takes numbers as the argument

We can extend the capability of raising errors in the exception_handler by having custom exceptions and further expand its usages. This was one of the examples which enables us to handle the exceptions cleanly.