python符号意义,python标识符的作用

　　你也许经常会听到「描述符」这个概念，但是由于大多数的程序员很少会使用到他，所以可能你并不太清楚了解它的原理，python视频教程栏目将详细介绍

　　推荐(免费):python视频教程

　　但是如果你想让自己的职业生涯更上一层楼，更熟练的使用python，我觉得你应该对描述符的概念有一个清晰的认识，这对你以后的发展有很大的帮助，还有你以后对python设计的更深入的理解。

　　虽然我们没有在开发过程中直接使用描述符，但它在底层的应用非常频繁。例如，以下内容：

　　函数、绑定方法、未绑定方法安装程序属性、staticmethod、classmethod

　　这些都熟悉吗？

　　其实这些都和描述符有着千丝万缕的联系。因此，让我们通过下面的文章来探索描述符背后的工作原理。什么是描述符？

　　在我们知道描述符是什么之前，我们可以找一个例子。

　　A:级

　　X=10print(A.x) # 10这个例子非常简单。我们先在A类中定义一个类属性X，然后求出它的值。

　　除了这种直接定义类属性的方法，我们还可以像这样定义一个类属性：

　　十类：

　　def __get__(self，obj，objtype=None):

　　返回10舱A:

　　X=Ten() #属性更改为类print(A.x) # 10。我们可以发现，这一次，类属性x不是一个具体的值，而是一个类Ten，通过它定义了一个__get__方法来返回一个具体的值。

　　因此，可以得出结论，在python中，我们可以把一个类的属性，托管给一个类，而这样的属性就是一个描述符

　　简而言之，描述符是一个绑定行为属性。

　　这意味着什么？

　　回想一下，我们在发展的时候，通常把行为叫做什么？也就是行为是一种方法。

　　所以我们也可以把这个描述符理解为：对象的属性并非一个具体的值，而是交给了一个方法去定义。.

　　想象一下，如果我们用一个方法来定义一个属性，会有什么好处？

　　有了方法，我们可以在方法中实现自己的逻辑。最简单的方法是，我们可以根据不同的条件给方法中的属性赋予不同的值，就像下面这样：

　　班级年龄：

　　def __get__(self，obj，objtype=None):

　　:

　　返回20

　　elif obj.name==lisi:

　　返回25

　　else:

　　返回值error(“unknow”)类Person:

　　年龄=年龄()

　　def __init__(self，name):

　　self.name=name

　　P1=Person(张三)print(P1 . name)# 20p 2=Person( Lisi )print(p2 . age)# 25p 3=Person(吴王)print (p3.age) # unknown在本例中，age类的属性由另一个类管理，在

　　通过这样一个例子，我们可以看到，通过使用描述符，我们可以很容易地改变一个类属性的定义。

　　an class="header-link octicon octicon-link">描述符协议

　　了解了描述符的定义，现在我们把重点放到托管属性的类上。

　　其实，一个类属性想要托管给一个类，这个类内部实现的方法不能是随便定义的，它必须遵守「描述符协议」，也就是要实现以下几个方法：

• __get__(self, obj, type=None) -> value
• __set__(self, obj, value) -> None
• __delete__(self, obj) -> None

　　另外，描述符又可以分为「数据描述符」和「非数据描述符」：

• 只定义了 __get___，叫做非数据描述符
• 除了定义 __get__ 之外，还定义了 __set__ 或 __delete__，叫做数据描述符

　　现在我们来看一个包含 __get__ 和 __set__ 方法的描述符例子：

# coding: utf8class Age:
　　 def __init__(self, value=20):
　　 self.value = value
　　 def __get__(self, obj, type=None):
　　 print('call __get__: obj: %s type: %s' % (obj, type))
　　 return self.value
　　 def __set__(self, obj, value):
　　 if value <= 0:
　　 raise ValueError("age must be greater than 0")
　　 print('call __set__: obj: %s value: %s' % (obj, value))
　　 self.value = valueclass Person:
　　 age = Age()
　　 def __init__(self, name):
　　 self.name = name
　　p1 = Person('zhangsan')print(p1.age)# call __get__: obj: <__main__.Person object at 0x1055509e8> type: <class '__main__.Person'># 20print(Person.age)# call __get__: obj: None type: <class '__main__.Person'># 20p1.age = 25# call __set__: obj: <__main__.Person object at 0x1055509e8> value: 25print(p1.age)# call __get__: obj: <__main__.Person object at 0x1055509e8> type: <class '__main__.Person'># 25p1.age = -1# ValueError: age must be greater than 0

　　从输出结果来看，当我们获取或修改 age 属性时，调用了 Age 的 __get__ 和 __set__ 方法：

• 当调用 p1.age 时，__get__ 被调用，参数 obj 是 Person 实例，type 是 type(Person)
• 当调用 Person.age 时，__get__ 被调用，参数 obj 是 None，type 是 type(Person)
• 当调用 p1.age = 25时，__set__ 被调用，参数 obj 是 Person 实例，value 是25
• 当调用 p1.age = -1时，__set__ 没有通过校验，抛出 ValueError

　　这就需要我们了解一下描述符的工作原理。

　　描述符的工作原理

　　要解释描述符的工作原理，首先我们需要先从属性的访问说起。

　　在开发时，不知道你有没有想过这样一个问题：通常我们写这样的代码 a.b，其背后到底发生了什么？

　　这里的 a 和 b 可能存在以下情况：

1. a 可能是一个类，也可能是一个实例，我们这里统称为对象
2. b 可能是一个属性，也可能是一个方法，方法其实也可以看做是类的属性

1. 先调用 __getattribute__ 尝试获得结果
2. 如果没有结果，调用 __getattr__

def getattr_hook(obj, name):
　　 try:
　　 return obj.__getattribute__(name)
　　 except AttributeError:
　　 if not hasattr(type(obj), '__getattr__'):
　　 raise return type(obj).__getattr__(obj, name)

1. 要查找的属性，在类中是否是一个描述符
2. 如果是描述符，再检查它是否是一个数据描述符
3. 如果是数据描述符，则调用数据描述符的 __get__
4. 如果不是数据描述符，则从 __dict__ 中查找
5. 如果 __dict__ 中查找不到，再看它是否是一个非数据描述符
6. 如果是非数据描述符，则调用非数据描述符的 __get__
7. 如果也不是一个非数据描述符，则从类属性中查找
8. 如果类中也没有这个属性，抛出 AttributeError 异常

# 获取一个对象的属性
　　def __getattribute__(obj, name):
　　 null = object()
　　 # 对象的类型 也就是实例的类
　　 objtype = type(obj)
　　 # 从这个类中获取指定属性
　　 cls_var = getattr(objtype, name, null)
　　 # 如果这个类实现了描述符协议
　　 descr_get = getattr(type(cls_var), '__get__', null)
　　 if descr_get is not null:
　　 if (hasattr(type(cls_var), '__set__')
　　 or hasattr(type(cls_var), '__delete__')):
　　 # 优先从数据描述符中获取属性 return descr_get(cls_var, obj, objtype)
　　 # 从实例中获取属性 if hasattr(obj, '__dict__') and name in vars(obj):
　　 return vars(obj)[name]
　　 # 从非数据描述符获取属性 if descr_get is not null:
　　 return descr_get(cls_var, obj, objtype)
　　 # 从类中获取属性 if cls_var is not null:
　　 return cls_var
　　 # 抛出 AttributeError 会触发调用 __getattr__
　　 raise AttributeError(name)

　　到这里我们可以看到，在一个对象中查找一个属性，都是先从 __getattribute__ 开始的。

　　在 __getattribute__ 中，它会检查这个类属性是否是一个描述符，如果是一个描述符，那么就会调用它的 __get__ 方法。但具体的调用细节和传入的参数是下面这样的：

• 如果 a 是一个实例，调用细节为：

type(a).__dict__['b'].__get__(a, type(a))复制代码

• 如果 a 是一个类，调用细节为：

a.__dict__['b'].__get__(None, a)复制代码

　　数据描述符和非数据描述符

　　了解了描述符的工作原理，我们继续来看数据描述符和非数据描述符的区别。

　　从定义上来看，它们的区别是：

• 只定义了 __get___，叫做非数据描述符
• 除了定义 __get__ 之外，还定义了 __set__ 或 __delete__，叫做数据描述符

　　在之前的例子中，我们定义了 __get__ 和 __set__，所以那些类属性都是数据描述符。

　　我们再来看一个非数据描述符的例子：

class A:
　　 def __init__(self):
　　 self.foo = 'abc'
　　 def foo(self):
　　 return 'xyz'print(A().foo) # 输出什么？
　　复制代码

　　答案是 abc。

　　为什么打印的是实例属性 foo 的值，而不是方法 foo 呢？

　　这就和非数据描述符有关系了。

　　我们执行 dir(A.foo)，观察结果：

print(dir(A.foo))# [... '__get__', '__getattribute__', ...]复制代码

　　所以，在一个类中，如果存在相同名字的属性和方法，按照上面所讲的 __getattribute__ 中查找属性的顺序，这个属性就会优先从实例中获取，如果实例中不存在，才会从非数据描述符中获取，所以在这里优先查找的是实例属性 foo 的值。

　　到这里我们可以总结一下关于描述符的相关知识点：

• 描述符必须是一个类属性
• __getattribute__ 是查找一个属性（方法）的入口
• __getattribute__ 定义了一个属性（方法）的查找顺序：数据描述符、实例属性、非数据描述符、类属性
• 如果我们重写了 __getattribute__ 方法，会阻止描述符的调用
• 所有方法其实都是一个非数据描述符，因为它定义了 __get__

　　了解了描述符的工作原理，那描述符一般用在哪些业务场景中呢？

　　在这里我用描述符实现了一个属性校验器，你可以参考这个例子，在类似的场景中去使用它。

　　首先我们定义一个校验基类 Validator，在 __set__ 方法中先调用 validate 方法校验属性是否符合要求，然后再对属性进行赋值。

class Validator:
　　 def __init__(self):
　　 self.data = {}
　　 def __get__(self, obj, objtype=None):
　　 return self.data[obj]
　　 def __set__(self, obj, value):
　　 # 校验通过后再赋值
　　 self.validate(value)
　　 self.data[obj] = value
　　 def validate(self, value):
　　 pass 
　　复制代码

class Number(Validator):
　　 def __init__(self, minvalue=None, maxvalue=None):
　　 super(Number, self).__init__()
　　 self.minvalue = minvalue
　　 self.maxvalue = maxvalue
　　 def validate(self, value):
　　 if not isinstance(value, (int, float)):
　　 raise TypeError(f'Expected {value!r} to be an int or float')
　　 if self.minvalue is not None and value < self.minvalue:
　　 raise ValueError(
　　 f'Expected {value!r} to be at least {self.minvalue!r}'
　　 )
　　 if self.maxvalue is not None and value > self.maxvalue:
　　 raise ValueError(
　　 f'Expected {value!r} to be no more than {self.maxvalue!r}'
　　 )class String(Validator):
　　 def __init__(self, minsize=None, maxsize=None):
　　 super(String, self).__init__()
　　 self.minsize = minsize
　　 self.maxsize = maxsize
　　 def validate(self, value):
　　 if not isinstance(value, str):
　　 raise TypeError(f'Expected {value!r} to be an str')
　　 if self.minsize is not None and len(value) < self.minsize:
　　 raise ValueError(
　　 f'Expected {value!r} to be no smaller than {self.minsize!r}'
　　 )
　　 if self.maxsize is not None and len(value) > self.maxsize:
　　 raise ValueError(
　　 f'Expected {value!r} to be no bigger than {self.maxsize!r}'
　　 )复制代码

class Person:
　　 # 定义属性的校验规则 内部用描述符实现
　　 name = String(minsize=3, maxsize=10)
　　 age = Number(minvalue=1, maxvalue=120)
　　 def __init__(self, name, age):
　　 self.name = name
　　 self.age = age
　　# 属性符合规则
　　p1 = Person('zhangsan', 20)print(p1.name, p1.age)# 属性不符合规则
　　p2 = person('a', 20)# ValueError: Expected 'a' to be no smaller than 3p3 = Person('zhangsan', -1)# ValueError: Expected -1 to be at least 1复制代码

　　function与method

　　我们再来看一下，在开发时经常看到的 function、unbound method、bound method 它们之间到底有什么区别？

　　来看下面这段代码：

class A:
　　 def foo(self):
　　 return 'xyz'print(A.__dict__['foo']) # <function foo at 0x10a790d70>print(A.foo) # <unbound method A.foo>print(A().foo) # <bound method A.foo of <__main__.A object at 0x10a793050>>复制代码

• function 准确来说就是一个函数，并且它实现了 __get__ 方法，因此每一个 function 都是一个非数据描述符，而在类中会把 function 放到 __dict__ 中存储
• 当 function 被实例调用时，它是一个 bound method
• 当 function 被类调用时， 它是一个 unbound method

　　而 bound method 和 unbound method 的区别就在于调用方的类型是什么，如果是一个实例，那么这个 function 就是一个 bound method，否则它是一个 unbound method。

　　property/staticmethod/classmethod

　　我们再来看 property、staticmethod、classmethod。

　　这些装饰器的实现，默认是 C 来实现的。

　　其实，我们也可以直接利用 Python 描述符的特性来实现这些装饰器，

　　property 的 Python 版实现：

class property:
　　 def __init__(self, fget=None, fset=None, fdel=None, doc=None):
　　 self.fget = fget
　　 self.fset = fset
　　 self.fdel = fdel
　　 self.__doc__ = doc
　　 def __get__(self, obj, objtype=None):
　　 if obj is None:
　　 return self.fget if self.fget is None:
　　 raise AttributeError(), "unreadable attribute"
　　 return self.fget(obj)
　　 def __set__(self, obj, value):
　　 if self.fset is None:
　　 raise AttributeError, "can't set attribute"
　　 return self.fset(obj, value)
　　 def __delete__(self, obj):
　　 if self.fdel is None:
　　 raise AttributeError, "can't delete attribute"
　　 return self.fdel(obj)
　　 def getter(self, fget):
　　 return type(self)(fget, self.fset, self.fdel, self.__doc__)
　　 def setter(self, fset):
　　 return type(self)(self.fget, fset, self.fdel, self.__doc__)
　　 def deleter(self, fdel):
　　 return type(self)(self.fget, self.fset, fdel, self.__doc__)复制代码

class staticmethod:
　　 def __init__(self, func):
　　 self.func = func
　　 def __get__(self, obj, objtype=None):
　　 return self.func
　　复制代码

class classmethod:
　　 def __init__(self, func):
　　 self.func = func
　　 def __get__(self, obj, klass=None):
　　 if klass is None:
　　 klass = type(obj)
　　 def newfunc(*args):
　　 return self.func(klass, *args)
　　 return newfunc
　　复制代码

　　由此可见，通过描述符我们可以实现强大而灵活的属性管理功能，对于一些要求属性控制比较复杂的场景，我们可以选择用描述符来实现。

　　总结

　　这篇文章我们主要讲了 Python 描述符的工作原理。

　　首先，我们从一个简单的例子了解到，一个类属性是可以托管给另外一个类的，这个类如果实现了描述符协议方法，那么这个类属性就是一个描述符。此外，描述符又可以分为数据描述符和非数据描述符。

　　之后我们又分析了获取一个属性的过程，一切的入口都在 __getattribute__ 中，这个方法定义了寻找属性的顺序，其中实例属性优先于数据描述符调用，数据描述符要优先于非数据描述符调用。

　　另外我们又了解到，方法其实就是一个非数据描述符，如果我们在类中定义了相同名字的实例属性和方法，按照 __getattribute__ 中的属性查找顺序，实例属性优先访问。

　　最后我们分析了 function 和 method 的区别，以及使用 Python 描述符也可以实现 property、staticmethod、classmethod 装饰器。

　　Python 描述符提供了强大的属性访问控制功能，我们可以在需要对属性进行复杂控制的场景中去使用它。

　　本作品采用《CC 协议》，转载必须注明作者和本文链接以上就是介绍python描述符的意义的详细内容，更多请关注盛行IT软件开发工作室其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。