0基础学Python装饰器封装、类成员与静态方法、魔术方法

装饰器封装

装饰器（decorators）是一种高阶函数，用于在不修改原有函数或方法定义的情况下，动态地扩展或修改函数或方法的行为。装饰器通常用于日志记录、权限检查、事务处理等横切关注点（cross-cutting concerns）。
装饰器的基本语法是使用 @ 符号来应用装饰器到一个函数或方法上。下面是一个简单的装饰器示例，以及如何封装一个更复杂的装饰器。

class Student:
    def __init__(self, name, age, sex):
        self.__name = name
        # 属性私有化
        self.__age = age
        self.__sex = sex

    @property  # get方法必须在set方法之前
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, age):
        if age < 0 or age > 150:
            print('age不合法,初始化为1')
            self.age = 1
        self.__age = age

    @property  # get方法必须在set方法之前
    def sex(self):
        return self.__sex

    @sex.setter
    def sex(self, sex):
        self.__sex = sex

    @sex.deleter  # 删除属性被调用
    def sex(self):
        print('=====')
        del self.__sex

    # 私有方法,仅供其他实例方法调用
    def __show(self):
        print('私有方法')

    def show2(self):
        self.__show()


if __name__ == '__main__':
    zs = Student('张三', 20, '男')
    print(zs.name) # 张三
    zs.name = '李四'
    print(zs.name) # 李四
    zs.age = 50
    print(zs.age) # 50

    del zs.sex
    # print(zs.sex)

    zs.show2()

类成员和静态方法

实例属性和方法

每一实例都有各自的一份，互不影响
实例方法第一个参数是 self,代表当前实例
实例方法可以访问类属型和类方法

---

类属性和类方法

属于类，只有一份
类方法第一个参数是 cls,代表当前类,没有self
类方法不能访问实例属性和方法

---

静态方法

属于类，只有一份
静态方法没有 cls，没有self
静态方法不能访问实例属性和方法，可以访问类属型和类方法

---

使用场景

静态方法使用场景: 工具方法（不需要访问类属性和类方法）
类方法使用场景: 工具方法（需要访问类属性和类方法）

---

代码演示:

import functools # 导入工具函数包


class Student:
    # 4.类属性
    PI = 3.14
    gradeId = 'js0003'

    # 7、魔术方法
    def __init__(self, name, no):
        self.__name = name  # 1.私有化实例属性
        self.no = no

    # 2.get方法
    @property
    def name(self):
        return self.__name
	# 2.set方法
    @name.setter
    def name(self, name):
        self.__name = name

    # 3.实例方法
    def show(self):
        print(f'{self.__name}调用了实例方法', self.PI, Student.gradeId)

    # 5.类方法
    @classmethod
    def he(cls, a, b):
        print(a + b, cls.PI)

    # 6.静态方法
    @staticmethod
    def ceng(a, b):
        print(a * b)


zs = Student('张三', 101)
ls = Student('李四', 102)

zs.no += 2
print(ls.no)  # 102
print(zs.no)  # 103
# 调用实例方法两种方式
ls.show()
Student.show(ls)

# 访问类实例: 类名.属性名
print(ls.PI)
print(Student.PI)
# 访问类方法：类名.方法名
Student.he(10, 20)  # 30

# 访问静态方法：类名.方法名
Student.ceng(10, 20)  # 200

魔术方法

定义

魔术方法（Magic Methods）是那些在对象上调用时，Python解释器会自动执行的方法。这些方法的名称前后都有双下划线（__），例如 init、str、add 等。
魔术方法用于定义对象的内置行为，比如对象的初始化、比较、表示、数学运算等。通过重写这些魔术方法，你可以自定义类的行为，使其表现得像内置类型一样。

---

初始化与表示方法

1、__new__： 创建实例并返回，在init之前
2、__init__： 初始化实例属性,初始化新创建的对象
3、__del__： 对象不被引用，自动销毁
4、__str__： 字符串显示， 阅读，返回对象的“非正式”或可打印的字符串表示。
5、__repr__: 官方 显示，原有的样式，返回对象的“正式”字符串表示，通常用于调试。

---

比较运算方法

1、__lt__(self, other)：定义小于行为（<）。
2、__le__(self, other)：定义小于等于行为（<=）。
3、__eq__(self, other)：定义等于行为（==）。
4、__ne__(self, other)：定义不等于行为（!=）。
5、__gt__(self, other)：定义大于行为（>）。
6、__ge__(self, other)：定义大于等于行为（>=）。

---

算术运算方法

1、__add__(self, other)：定义加法行为（+）。
2、__sub__(self, other)：定义减法行为（-）。
3、__mul__(self, other)：定义乘法行为（*）。
4、__truediv__(self, other)：定义真除法行为（/）。
5、__floordiv__(self, other)：定义地板除法行为（//）。
6、__mod__(self, other)：定义取模行为（%）。
7、__pow__(self, power, modulo=None)：定义幂运算行为（）。**
8、__divmod__: divmod(x,y) 返回商和余数。

---

代码演示

class Student:
    def __new__(cls, *args, **kwargs):
        print('1.new=====')
        return super().__new__(cls)

    def __init__(self, name, age):
        print('2.init====')
        self.name = name
        self.age = age

    def __gt__(self, other):
        return self.age > other.age

    def __le__(self, other):
        return self.age <= other.age

    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

    def __ne__(self, other):
        return self.name != other.name or self.age != other.age

    def __sub__(self, other):
        return self.age - other.age

    def __floordiv__(self, other):
        return self.age // other.age

    def __divmod__(self, other):
        return divmod(self.age, other.age)


zs = Student('张三', 20)
ls = Student('张三', 30)
zs2 = Student('张三', 20)
ww = Student('王五', 15)

print(zs == zs2)  # True(重写了eq)
print(zs is zs2)  # False

print(zs > ls)  # False
print(zs <= zs2)  # True
print(zs == ls)  # False

print(zs - ww)  # 5
print(zs // ww)  # 1
print(divmod(zs, ww))(1, 5)