Wrapper Class in Python

Decoration is a way to specify management code for functions and classes. Decorators themselves take the form of callable objects that process other callable objects. A Class Decorator is similar to function decorators, but they are run at the end of a class statement to rebind a class name to a callable (e.g functions). As such, they can be used to either manage classes just after they are created or insert a layer of wrapper logic to manage instances when they are later created. Class decorator can be used to manage class object directly, instead of instance calls – to increase/modify a class with new methods. Class decorators are strongly related to function decorators, in fact, they use nearly the same syntax and very similar coding pattern but somewhere logic differs.

Note: For more information, refer to Decorators in Python

Syntax:
Syntactically, class decorators appear just before class statements.

@decorator
class Class_Name:       
      ...

inst = Class_Name(50)

This piece of code is equivalent to

class Class_Name:
      ...

Class_Name = decorator(Class_Name)
inst = Class_Name(50);

Let’s understand the syntax, and how its works with an example:

Example:



filter_none

edit
close

play_arrow

link
brightness_4
code

# decorator accepts a class as 
# a parameter
def decorator(cls):
      
    class Wrapper:
          
        def __init__(self, x):
              
            self.wrap = cls(x)
              
        def get_name(self):
              
            # fetches the name attribute
            return self.wrap.name
          
    return Wrapper
  
@decorator
class C:
    def __init__(self, y):
        self.name = y
  
# its equivalent to saying
# C = decorator(C)
x = C("Geeks")
print(x.get_name())   

chevron_right


OUTPUT:

Geeks

In this example, the decorator rebinds the class C to another class Wrapper, which retains the original class in an enclosing scope and creates and embeds an instance (wrap) of the original class when it’s called. In more easy language, @decorator is equivalent to C = decorator(C) which is executed at the end of the definition of class C. In the decorator body, wrapper class modifies the class C maintaining the originality or without changing C. cls(x) return an object of class C (with its name attribute initialized with the value of x). The method get_name return the name attribute for the wrap object. And finally in the output “Geeks” gets printed.

So, this was an overview of the decorator or wrapper for the class. The class decorators are used to add additional functionality to the class without changing the original class to use as required in any situation.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :

1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.