Python类中装饰器classmethod,staticmethod,property,

`@classmethod`

有的时候在类中会有一种情况，就是这个方法并不需要使用每一个对象属性

因此这个方法中的self参数一个完全无用的参数，使用classmethod

class A:

    __count = 0  # 隐藏类count属性

    def __init__(self, name):

        self.name = name

        self.__add_count()  # 每一次实例化的时候掉

        # 用私有方法来对__count 进行累加

    @classmethod

    def __add_count(cls):  # 定义一个私有方法

        print(cls, A)

        A.__count += 1  # 让这个方法只能在类的内部被使用

    @classmethod

    def show_count(cls):  # 被classmethod 装饰去的方法，

        print(cls.__count)

        return A.__count  # 让用户可以从外部查看__count的值

    def show_count_self(self):  # 定义一个普通方法

        # print(self.__count)

        print(self)

        # print('_____')

        # print(self.show_count(),'fogogo')

        # return A.__count  # 让用户可以从外部查看__count的值

# show_count 是一个查看类中属性的方法，这样的方法和某一个对象并没有直接联系        

obj = A('baozi')

print(A._A__add_count) #

# 执行结果

<class '__main__.A'> <class '__main__.A'>

<bound method A.__add_count of <class '__main__.A'>>

本质上 :

@classmethod

一个方法不用对象属性但是使用静态属性 -- 类方法@classmethod

某一个方法被创造出来,就是为了进行对静态变量进行操作

@staticmehtod

根本不涉及到对象,所以这个方法就应该被定义成 类方法(被@classmethod装饰)

调用这个类方法,可以使用对象调用,也可以使用类调用

但是这个方法的默认参数永远是当前类的命名空间,而不是对象的

`@staticmethod`

如果一个类中的方法不用 对象属性 也不用 静态属性 -- 静态方法@staticmethod

那实际上这个方法就是一个普通的函数



class User(object):

    @staticmethod

    def login(arg1, arg2):#是User类中的名字函数的名字login就是一个类中的静态方法,本质上就是一个函数

        return (arg1 + arg2)

    def show(self):

        print('---->show')

        print('---self--',self.login(1, 3))

        print('class--',User.login(123, 31))

print(User.login(1,2)) ## 不需要实例化，当函数使用

print(User().show())

# 执行结果

3

---->show

---self-- 4

class-- 154

一个不需要用到对象命名空间中的变量的方法,就不是一个对象方法,就应该是一个普通的函数

方法的查找的顺序：

类是直接在自己的空间找到类类这个方法
对象先在自己的空间找，找不到，就到类的空间找

`classmethod` `staticmethod` 使用场景说明：

用哪一个命名空间的名字，就定义的不同的方法

self 只要用self 就是普通方法，只能用对象调
Classmethod 只要cls 就是类方法，可以用类，可以用对象
Staticmethod 啥用不用就是静态方法 ,可以用类，可以用对象

	普通的方法	类方法	静态方法
默认参数	`self`	cls	无
操作变量	操作对象属性	操作静态属性	既不操作对象属性,也不操作类的属性
所属的命名空间	类	类	类
调用方式	对象	类/对象	类/对象
对应的装饰器	无	@classmethod	@staticmethod

`@property`

把一个方法伪装成属性，

下面例子中计算圆面积的公式



class Cirecle:

    def __init__(self, r):

        self.r = r

    @property

    def area(self):  # 被property 装饰器 装饰的方法不能传递 除self以外参数

        return pi * self.r ** 2

    def perimeter(self):

        return self.r * pi * 2

c1 = Cirecle(5)

print(c1.area)

# 打印执行结果

78.53981633974483

某一个属性需要被私有，但是有需要可以被外部查看，这种情况，把这个属性通过方法,`property 伪装成属性

class Person:

    def __init__(self, name):

        self.__name = name  # 不让外面随便修改

    @property

    def get_name(self):

        return self.__name

ari = Person('arimiage')

print(ari.get_name)

# 执行结果

arimiage

Property 修改属性值

@funcname.setter
@funcname.deleter

class Person:

    def __init__(self, name):

        self.__name = name

    @property

    def name(self):

        return self.__name

    @name.setter  # 只能传一个参数。之前必须有一个同名的方法被property装饰过

    def name(self, new_name):

        if isinstance(new_name, str):

            # if type(new_name) is str:

            self.__name = new_name

            #setattr装饰的函数名叫什么

            #那么这个函数中绝对不可以对这个，函数名同名属性进行修改( 函数名)

    @name.deleter

    def name(self):

        print('gogoog')

        del self.__name #这里才执行删除属性操作

    def get_name(self):

        return self.__name

    # def set_name(self,new_name):

    # if type(new_name) is str:

    # if isinstance(new_name,str):

    #     self.__name == new_name

ari = Person('arimiage')

{'_Person__name': 'arimiage'}

# print(Person.__dict__)

print(ari.get_name)

ari.name = 'fgo'

{'_Person__name': 'fgo'} #对象空间

print(Person.__dict__)

print(ari.__dict__)

print(ari.name)

del ari.name # 只是相当于调用被deleter装饰的方法,并不相当于删除name属性

{} 对象空间为空

# print(ari.__dict__)  # 报错