8. 类的成员描述符（属性）

• 类的成员形容是为了在类中对类的成员属性进行相干操作而创立的一种形式

  • get：获取属性的操作
  • set：批改或增加属性操作
  • delete：删除属性的操作

• 如果想应用类的额成员描述符，大略有三种办法

  • 应用类实现形容器
  • 应用属性修饰符

  • 应用 property 函数

    • property 函数很简略
    • property(fget, fset, fdel, doc)

• 无论哪种修饰符都是为了对成员属性进行相应的管制

  • 类的形式：实用多个类中的多个属性共用同一个描述符
  • property：实用以后类中应用，能够管制一个类中多个属性
  • 属性修饰符：实用于以后类中应用，管制一个类中的一个属性

9. 类的内置属性

    __dict__: 以字典的形式显示类的成员组成
    __doc__: 获取类的文档信息
    __name__: 获取类的名称，如果在模块中应用，获取模块的名称
    __bases__: 获取某个类的所有父类，以元组的形式显示
    

10. 类的罕用魔术办法

• 魔术办法就是不须要人为调用的办法，根本是在特定的工夫主动触发
• 魔术办法的对立特色，办法名被前后各两个下划线包裹

• 操作类

  • __init__：构造函数
  • __new__：对象实例化办法，此魔术办法较非凡，个别不须要应用
  • __call__：对象当函数应用的时候触发
  • __str__：当对象被当作字符串应用的时候
  • __repr__：返回字符串

• 描述符相干

  • __set__
  • __get__
  • __delete__

• 属性操作相干

  • __getattr__：拜访一个不存在的属性时触发

  • __setattr__：对成员属性进行设置的时候触发

    • 参数：

      • self 用来获取以后对象
      • 被设置的属性名称，以字符串模式呈现
      • 须要对属性名称设置的值
    • 作用：进行属性设置的时候进行验证或者批改
    • 留神：在该办法中不能对属性进行赋值操作，否则死循环

• 运算类相干魔术办法

  • __gt__：进行大于判断的时候触发的函数

    • 参数

      • self
      • 第二个参数是第二个对象
      • 返回值能够是任意值，举荐返回布尔值

11. 类和对象的三种办法

• 实例办法

  • 须要实例化对象能力应用的办法，应用过程中可能须要截至对象的其余对象的办法实现

• 静态方法

  • 不须要实例化，通过类间接拜访

• 类办法

  • 不须要实例化

# 属性案例
# 创立 Student 类，形容学生类
# 学生具备 Student.name 属性
# 但 name 格局并不对立
# 能够用减少一个函数，而后主动调用的形式，但很蠢
class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
        # 如果不想批改代码
        self.setName(name)
        
    # 介绍下本人
    def intro(self):
        print("Hai, my name is {0}".format(self.name))
        
    def setName(self, name):
        self.name = name.upper()
        
s1 = Student("RUO Chen", 19.8)
s2 = Student("michi stangle", 24.0)
s1.intro()
s2.intro()

Hai, my name is RUO CHEN
Hai, my name is MICHI STANGLE

# propertya 案例
# 定义一个 Person 类，具备 name，age 属性
# 对于任意输出的姓名，咱们心愿用大写形式保留
# 年龄，咱们心愿外部对立用整数保留
# x = property(fget, fset, fdel, doc)
class Person():
    '''
    这是一个人，一个崇高的人，一个脱离了低俗趣味的人
    他还他妈的有属性
    '''
    # 函数名称能够任意
    def fget(self):
        return self._name * 2
    
    def fset(self, name):
        # 所有输出的姓名以大写形式 保留
        self.name = name.upper()
    def fdel(self):
        self._name = "NoName"
        
    name = property(fget, fset, fdel, "对 name 进行操作")

# 类的内置属性举例
print(Person.__dict__)
print(Person.__doc__)
print(Person.__name__)
# 元组模式显示所有的父类
print(Person.__bases__) 

{'__module__': '__main__', '__doc__': '\n    这是一个人，一个崇高的人，一个脱离了低俗趣味的人 \n    他还他妈的有属性 \n', 'fget': <function Person.fget at 0x000001FBBD3AFBF8>, 'fset': <function Person.fset at 0x000001FBBD3AF9D8>, 'fdel': <function Person.fdel at 0x000001FBBD3AF8C8>, 'name': <property object at 0x000001FBBD3B7BD8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}

    这是一个人，一个崇高的人，一个脱离了低俗趣味的人
    他还他妈的有属性
    
Person
(<class 'object'>,)

# init 举例
class A():
    def __init__(self, name = 0):
        print("哈哈，我被调用了")
        
a = A()

 哈哈，我被调用了

# __call__ 举例
class A():
    def __init__(self, name = 0):
        print("哈哈，我被调用了")
        
    def __call__(self):
        print("我被调用 again")
        
a = A()
a()

 哈哈，我被调用了
我被调用 again

# __str__ 举例
class A():
    def __init__(self, name = 0):
        print("哈哈，我被调用了")
        
    def __call__(self):
        print("我被调用 again")
        
    def __str__(self):
        return '666'
        
a = A()
print(a)

 哈哈，我被调用了
666

# __getattr__
class A():
    name = "NoName"
    age = 18
    
    def __getattr__(self, name):
        print("没找到")
        print(name)
    

        
a = A()
print(a.name)
print(a.addr)

NoName
没找到
addr
None

# __setattr__ 案例
class Person():
    def __init__(self):
        pass
    
    def __setattr__(self, name, value):
        print("设置属性：{0}".format(name))
        # 上面语句会导致问题，死循环
        # self.name = value
        # 此种状况，为了防止死循环，规定对立调用父类魔法函数
        super().__setattr__(name, value)
p = Person()
print(p.__dict__)
p.age = 18

{}
设置属性：age

# __gt__

class Student():
    def __init__(self, name):
        self._name = name
        
    def __gt__(self, obj):
        print("哈哈，{0} 会比 {1} 大吗？".format(self, obj))
        return self._name > obj._name
    
stu1 = Student("one")
stu2 = Student("two")
print(stu1 > stu2)

 哈哈，<__main__.Student object at 0x000001C15772EB38> 会比 <__main__.Student object at 0x000001C15772E550> 大吗？False

# 三种办法的案例
class Person():
    # 实例办法
    def eat(self):
        print(self)
        print("Eating......")
    # 类办法
    # 类办法的第一个参数，个别命名为 cls，区别于 self
    @classmethod
    def play(cls):
        print(cls)
        print("Playing......")
        
    # 静态方法
    # 不须要用第一个参数示意本身或者类
    @staticmethod
    def say():
        print("Saying......")
        
yueyue = Person()

# 实例办法
yueyue.eat()
# 类办法
Person.play()
yueyue.play()
# 静态方法
Person.say()
yueyue.say()

<__main__.Person object at 0x000001C157766710>
Eating......
<class '__main__.Person'>
Playing......
<class '__main__.Person'>
Playing......
Saying......
Saying......