Search for Metaclases in Uzar: Undoing the power of class creation

Image by editor

. Introduction

In Azar, there is a concept called Object -based programming (OOP). This programming sample revolves around data and items. It works by combining the related conditions (attributes) and practices (methods) within the classes and creating objects from these classes.

For many data scientists, Azgar is the first programming language that he learns, and it becomes the basis of most of his operating data. However, to solve the problems immediately, OOP is sometimes focused on writing the code code. For data scientists, the OOP allows complex work to break into manageable components. By creating a code in the class, data scientists can reduce spare and improve maintaining.

. Class in azagar

Classes are easy to create. A fundamental example is shown below.

class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def speak(self):
        return f"{self.name} makes a sound {self.sound}."

We use the class syntax to describe the class name (“animal”) and to achieve the concept of an animal in which we can pass as parameters, as well as a method that it can use.

With the above class, we can create examples of this item.

dog = Animal("Dog", "Bark")
print(dog.speak())

The output is shown below.

Animal The class accepts the two arguments that we had previously fixed, and could use the object speak After that we have done it. This is a class power: explain it once and reuse it in many situations.

. What are Metaclas?

Metaclas take more things by controlling how they create themselves. You can think of Metaclas as a Blue Print of Classes, just as classes are blueprints for items. Just as an item is an example of the class, so is an example of a class metaclas. Regularly make metaches on how classes behave.

When we create a class, the aggregation processes the body and then the result is to the metaches. By default, it is built by the built -in type Through class sub -classing typeWe can create our metacles and over -rid methods to customize the class creation.

Why do we want Metaclas? There are numerous reasons for data scientists, including:

• To provide a standard framework for the then classes that have been created
• To ensure all classes describe the desired methods
• To avoid repeated boiler plate setup code

Let’s see how the Code of Azigar works for Metaclas, and then we will break it.

. Metaclasses in azagar

When you make Metaclas, it seems to be a regular class, but you will inherit it with typeAs shown below.

class ExampleMetaclass(type):
    def __new__(mcs, name, bases, namespace):
        def greet(self):
            return f"Hello from {self.__class__.__name__}!"
        namespace('greet') = greet
        return super().__new__(mcs, name, bases, namespace)

Next, create a class like the previous example, but add the metacles as an extra parameter.

class Animal(metaclass=ExampleMetaclass):
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def speak(self):
        return f"{self.name} makes a sound {self.sound}."

Instant one to the same Animal Objection as before, but now use the method provided by metaches.

dog = Animal("Dog", "Bark")
print(dog.greet())

Output would be the same:

As you can see, Animal Initially lacking class A greet Method, but Metaclas enters the class during creation. Let’s break it a little.

First, make Metaclas we inherit this type Class provided. type There is a default metaclass for all classes in Ujjar and allows us to overcome how new classes are formed.

Next, __new__ When a new class is developed, the procedure is requested in Metaclas. The parameters he received are:

• mcs: Self -Metaclas
• name: Class name is being appreciated (eg, “animal”)
• bases: A tuple of twenty classes (the classes from where the new class inherits)
• namespace: A dictionary containing all attributes and methods described within the class body

Along with these four parameters, we can control how Metaclas builds the target class.

Then, we explain it greet Insert it in place of class names and injections. By doing so, greet Becomes part of the class, and creates with each class ExampleMetaclass Will add it.

Finally, the Metaclas creates a new class by calling the super class __new__ Method

It is the essence of metachesis in Azar, and you can increase them with any methods or regulations that you need to standardize and control the class creation.

. Wrap

Statistics are widely used by scientists. A valuable theme in Azar is the object -based programming, especially metaches. By using metaches, we can control and edit the class creation process, help maintain consistency in the code base and improve the workflow performance.

I hope it has helped!

Cornelius Yodha Vijaya Data Science is Assistant Manager and Data Writer. Elijan, working in Indonesia for a full time, likes to share indicators of data and data through social media and written media. CorneLius writes on various types of AI and machine learning titles.