Python - Binding and the Static, Class, Abstract Method

Something about parameter binding

Function is stored as the attribute of class, as you can see in the code followed.

class Pizza(object):
    def __init__(self, size):
        self.size = size
    def get_size(self):
        return self.size
print(Pizza.get_size)

You can find the result like this, <unbound method Pizza.get_size>. It shows the attribute of the function get_size is not bound to any class. And if we try to make this fuction work like this.

Pizza.get_size() 

Will traceback unbound method get_size() must be called with Pizza instance as first argument. And it is clear that, if we can’t call this function because it’s not bound to any instance of Pizza. And we need to make it like this.

Pizza.get_size(Pizza(42))
or
Pizza(42).get_size()  #self parameter will pass to Pizza(42), this instance
or
m = Pizza(42).get_size
m()

If you want to see where the bound function binds to, try this.

m = Pizza(42).get_size
m.__self__

I will give some codes about staticmethod of Python

Some codes to learn Staticmethod of Python

class Pizza:
    def __init__(self):
        self.cheese = 3
        self.vegetables = 4
    @staticmethod # Here if you delete this code, program will go well too, because it runs as dynamic method
    def mix_ingredients(x, y):
        return x + y
    def cook(self):
        return Pizza.mix_ingredients(self.cheese, self.vegetables)
print(Pizza.mix_ingredients(1, 2))
print(Pizza().cook())

Here @staticmethod is a marker to begin the staticmethod which lead the defination of mix_ingredients a static fuction. When we make it a staticmethod, we can make the instance x, y not self. In this way, when we have the function, we don’t need to input Pizza().mix_ingredients(1, 2) again, input Pizza.mix_ingredients(1, 2)is OK. To make a comparation, we give another function, cook, which is not a statcimethod, and in this situation, we must define a instance to Pizza(), and only in this way, the function of self will pass to Pizza().

The class method

See this code.

import math
class Pizza(object):
    def __init__(self, radius, height):
        self.radius = radius
        self.height = height
    @staticmethod
    def compute_circumference(radius):
        return math.pi * (radius ** 2)
    @classmethod
    def compute_volume(cls, height, radius):
        return height * cls.compute_circumference(radius)

print(Pizza.compute_volume(2, 3))

What is a class method, it’s a function bound to class not instance. And the first parameter must be the cls class itself. And when the function is bound to cls, if we delelte the base_class, the classmethod will still work well. The other side, the staticmethod will not be that lucky, it will call a error as seen followed:

# Using the staticmethod
class Pizza(object):
    key = ['A']
    @staticmethod
    def sta(new_key):
        Pizza.key.append(new_key)
        return Pizza.key
print(Pizza.sta('B'))
del Pizza
print(Pizza.sta('B'))
#Output will be error:  
> NameError: name 'Pizza' is not defined

# Using the classmethod
class Pizza(object):
    key = ['A']
    @classmethod
    def Cls(cls, new_key):
        cls.new_key = new_key
        cls.key.append(new_key)
        return Pizza.key
print(Pizza.Cls('B'))
del Pizza
print(Pizza.Cls('B'))
# Everything will go well (maybe)

The abstract method

The abstract method is defined in a base_class, but will not get any achievement until this function is inherited to the subclass.

import abc
class BasePizza(object):
    __meta__ = abc.abstractmethod
    @abc.abstractmethod
    def get_radius(self):
        {Method that should do something}
BasePizza()
# it will make typeerr
> TypeError: Can't instantiate abstract class BasePizza with abstract mehtods get_radius

Ok let’s make an exercise mixed with all of the methods:

import abc
class BasePizza(object):
    __metaclass__ = abc.ABCMeta
    ingredient = ['cheese']
    @classmethod
    @abc.abstractmethod
    def get_ingredients(cls):
    {Returns the ingredient list}}
        return cls.ingredient

class Pizza(BasePizza):
    def get_ingredients(self):
        return['egg'] + super(Pizza, self).get_ingredients()
a = Pizza()
print(a.get_ingredients())