理解decorator pattern in Python

• Overview

  From [1], Decorator pattern (or simply called a decorator) is a design pattern.

  Decoraters are simply functions, it performs a task, the difference to the common function is that decorators apply logic or change the behavior of other functions.

  Its the excellent way to reuse code.

• Decorator pattern

  In Object-Oriented programming, the decorator pattern is a design pattern that allows behavior to be added to an individual object, dynamically, without affecting the behavior of other objects from the same class.

  The decorator pattern is often useful for adhering to the Single Responsibility Principle, as it allows functionality to be divided between classes with unique areas of concern.

  The decorator design pattern is one of the twenty-three well-known GoF design patterns,

• Single Responsibility Principle

  The single responsibility principle (SRP) is a computer-programming principle that states that every module, class or function in a computer program should have responsibility over a single part of that program’s functionality, and it should encapsulate that part.

  The term was introduced by Robert C. Martin in the artical Principles of Object Oriented Desgin;

  Martin defines a responsibility as a reason to change, and concludes that a class or module should have one, and only one, reason to be changed.

• Python Design Patterns - Decorator

  Decorator pattern allows a user to add new functionality to an existing object without altering its structure.

  This type of design pattern comes under structural pattern as this pattern acts as a wrapper to existing class.

  This pattern creates a decorator class, which wraps the original class and provides additional functionality keeping the class methods signature intact.

  The motive of a decorator pattern is to attach additional responsibilities of an object dynamically.

• Decorators in Python

  RealPython: Primer on Python Decorators

  RealPython: Decorators 101 - Decorators Course Introduction and Overview

  Decorators provides a simple syntax for calling higher-order functions.

  理解first-order vs. higher-order function

  A decorator is a function that takes another function and extends the behavior of the latter function without explicitly modifying it.

  Decorators wrap a function, modifying its behavior.

  理解first-class objects in functional programming

  Python allows you to use decorators in a simpler way with the @ symbol which called the "pie" syntax.

  Make sure the wrapper function returns the return value of the decorated function.

  Use the @functools.wraps decorator to preserve information about the original function.

• Decorating Classes

  The @classmethod and @staticmethod decorators are used to define methods inside a class namespace that are not connected to a particular instance of that class.

  The @property decorators is used to customized getters and setters for class attributes.

• References

1. Instance vs. Static vs. Class Methods in Python: The Important Differences
2. TutorialsPoint: Python Design Patterns Tutorial