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