Python基础篇_修饰符（Decorators）【中】

上一篇：Python基础篇_修饰符（Decorators）【上】(@decorator、@classmethod、@staticmethod)
下一篇：Python基础篇_修饰符（Decorators）【下】@abc.abstractmethod、@functools.singledispatch、@contextlib.contextmanager

Python基础篇_修饰符【中】

    Python中有多种修饰符，这些修饰符用于指定方法的特殊行为或属性，也是用于修改函数行为的特殊参数。

一、修饰符一般特点

1. 修饰符只能用于类定义中，不能用于普通函数中
2. 属性修饰符是可叠加的，也就是说，一个方法可以同时被多个属性修饰符修饰

二、常用的修饰符以及用法举例

4) @property，属性装饰器；@.setter，属性设置

    @property用于将方法变成属性。这允许我们以类似访问属性（即直接通过点运算符）的方式来调用方法，而不需要使用括号。当我们将@property装饰一个方法时，这个方法变成了所谓的"getter"，它在每次属性被读取时都会执行，并且会返回值。

    同时，我们还使用@.setter，允许我们为属性提供一个设置值的方法。如果一个@property没有与之对应的@.setter，则此属性为只读属性。

示例1：只读属性

class Person:
    def __init__(self, name):
        self._name = name

    @property
    def full_name(self):
        return self._name + " Doe"


# 在这个例子中，我们定义了一个人的类，其中有一个只读属性`full_name`。
# 每次访问这个属性时，它都会返回带有" Doe"后缀的全名。
# 我们没有为这个属性提供setter，所以它是一个只读属性。

示例2：带有计算值的属性

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def area(self):
        return 3.14 * self._radius ** 2

    @area.setter
    def area(self, new_area):
        self._radius = new_area / 3.14 ** 0.5

# 在这个例子中，我们有一个圆，它有一个半径属性。
# 我们还定义了一个计算面积的getter方法。为了设置面积
# 我们还定义了一个setter方法，它会根据给定的面积重新计算半径。

示例3：带有多个setter的属性

class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self._height = height

    @property
    def area(self):
        return self._width * self._height

    @area.setter  # 这个setter同时用于width和height的修改
    def area(self, new_area):
        width = new_area / self._height if self._height != 0 else 0
        height = new_area / self._width if self._width != 0 else 0
        self._width = width
        self._height = height
        
# 在这个例子中，我们有一个矩形类，它有两个属性：宽度和高度。
# 我们还定义了一个计算面积的getter方法。
# 为了设置面积，我们还定义了一个setter方法，它会根据给定的面积重新计算宽度和高度。
# 注意，这个setter方法同时用于宽度和高度属性的设置。        

5) @.deleter，删除属性

    @.deleter 是一个用于删除属性的装饰器，通常与 @property 和 @.setter 一起使用。它允许你定义一个方法来删除属性值。

示例1：删除Person类的name属性值

class Person:
    def __init__(self, name):
        self._name = name
 
    @property
    def name(self):
        return self._name
 
    @name.setter
    def name(self, new_name):
        self._name = new_name
 
    @name.deleter
    def name(self):
        print("Deleting name")
        del self._name

aPerson = Person('张三')
print(aPerson.name)
aPerson.name = '李四'
print(aPerson.name)
del aPerson.name
print(aPerson.name)

# 执行结果
张三
李四
Deleting name
AttributeError: 'Person' object has no attribute '_name'

示例2：删除User类的username属性值

class User:
    def __init__(self, username):
        self._username = username

    @property
    def username(self):
        return self._username

    @username.setter
    def username(self, new_username):
        if not isinstance(new_username, str):
            raise ValueError("Username must be a string")
        self._username = new_username

    @username.deleter
    def username(self):
        print("Deleting username")
        del self._username

User = User('张三')
print(User.username)
User.name = '李四'
print(User.username)
del User.name
print(User._username)

# 执行结果
张三
李四
Deleting username
AttributeError: 'User' object has no attribute '_username'

6) @functools.lru_cache(maxsize=None)，值缓存

    functools.lru_cache(maxsize=None) 是 Python 的内置函数，用于实现最近最少使用 (Least Recently Used, LRU) 缓存策略。LRU 缓存是一种常见的缓存替换策略，用于决定当缓存达到其最大容量时应该丢弃哪个元素。最近最少使用的元素将被丢弃。

    lru_cache 可以用于任何可调用的对象（例如函数）。当一个函数被装饰后，它会在第一次调用时被执行，并且结果会被缓存。在随后的调用中，如果函数的参数相同，它将直接从缓存中返回结果，而不会再次执行函数。

    maxsize 参数指定了缓存的最大容量。如果将其设置为 None，则表示缓存可以无限增长。

    在计算密集型函数中，缓存之前计算的结果，在以后的调用中直接使用它们，而不需要重新计算。这样即使在多次调用计算密集型函数时，也可以快速地获取结果，而不需要重复进行计算，可以大大提高其性能。

示例1：使用缓存计算斐波那契数列

import functools

@functools.lru_cache(maxsize=5)     # 缓存前5个斐波那契数
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 计算斐波那契数列的第 10 个数
print(fibonacci(10))  # 输出: 55

示例2：使用缓存计算子集合组合

import functools

@functools.lru_cache(maxsize=None) # None表示缓存无上限
def combinations(numbers):
    if len(numbers) == 0:
        return [[]]  
    else:
        results = []
        for i in range(len(numbers)):
            results += [x + [numbers[i]] for x in combinations(numbers[:i] + numbers[i+1:])]
        return results

# 测试函数
numbers = [1, 2, 3]
print(combinations(numbers))  
# 执行结果
[[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]

示例3：使用缓存计算字符串所有子串

import functools

@functools.lru_cache(maxsize=None) # None表示缓存无上限
def combinations(strings):
    if len(strings) == 0:
        return [""]
    else:
        results = []
        for i in range(len(strings)):
            results += [x + strings[i] for x in combinations(strings[:i] + strings[i+1:])]
        return results

# 测试函数
strings = ["a", "b", "c"]
print(combinations(strings))  
# 执行结果 
['', 'a', 'b', 'c', 'ab', 'ac', 'bc', 'abc']

---

may the odds be ever in your favor ~