python@classmethod类装饰器_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) #

# 执行结果

>

本质上 :

@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__) # 报错