双下方法

双下方法

1. 定义：

   1. 双下方法是特殊方法
   2. 原来是Python这个语言的程序员用于源码使用的
   3. 一种特殊的机制：你不知道你干了什么就触发了某个双下方法

2. len

   1. # class B:
      #
      #     def __init__(self,name,age):
      #         self.name = name
      #         self.age =age
      #
      #     def __len__(self):
      #         print(self.__dict__)
      #
      #         return len(self.__dict__)  # 2
      #
      # b = B('leye',28)
      #
      # print(len(b))
      

3. hash

   1. 类的实例化对象也是可哈希的

   2. 可哈希对象得到哈希值

      1. # class A(object):
         #
         #     pass
         #
         # obj = A()
         
         # print(hash(obj))
         # print(hash('fdsaf'))
         -9223371858122639079
         8102982483253201962
         
         

4. str

   1. 开发应用比较多

   2. 打印对象触发__str__方法

   3. print(对象)默认输出该方法的返回值

   4. # class A:
      #
      #     def __init__(self,name,age):
      #         self.name = name
      #         self.age =age
      #
      #     def __str__(self):
      #         return f'姓名: {self.name} 年龄: {self.age}'
      a = A('DAVID',12)
      b = A('ASDF',13)
      c = A('QWER',14)
      print(a)
      print(b)
      print(c)
      姓名: DAVID 年龄: 12
      姓名: ASDF 年龄: 13
      姓名: QWER 年龄: 14
      print(str(a))
      
      

   5. 直接str转化也可以触发

5. repr

   1. 原形毕露：是什么就打印什么，包括引号

   2. 和str类似，但是优先级低于str

   3. 如果一个类中定义了__repr__方法，那么在print(repr(对象))时默认的到该方法的返回值

   4. class A:
        
          def __init__(self,name,age):
              self.name = name
              self.age =age
          def __repr__(self):
          	return 666
          def __str__(self):
              return f'姓名: {self.name} 年龄: {self.age}'
      a = A('DAVID',12)
      b = A('ASDF',13)
      c = A('QWER',14)
      print(a)
      print(b)
      print(c)
      优先执行——str——
      姓名: DAVID 年龄: 12
      姓名: ASDF 年龄: 13
      姓名: QWER 年龄: 14
      
      

6. call

   1. 对象+（）：自动触发对象从属于类（父类）的__call__方法

   2. class Foo:
      
          def __init__(self):
              pass
      
          def __call__(self, *args, **kwargs):
              print('__call__')
      
      obj = Foo()
      obj()
      __call__
      
      

7. ep

   1. class A:
          def __init__(self):
              self.a = 1
              self.b = 2
      
          def __eq__(self,obj):
              if  self.a == obj.a and self.b == obj.b:
                  return True
      a = A()
      b = A()
      print(a == b)
      True
      
      

8. del

   1. 析构方法：对象在内存中被释放时，自动触发执行
   2. 析构函数的调用时由解释器在进行垃圾回收时自动触发的

9. new

   1. 对象是object类的__new__方法，产生了一个对象

   2. 类名（）

      1. 先触发object的__new__方法，此方法在内存中开辟一个对象空间
      2. 执行__init__方法，（给对象封装属性）

   3. obj = 类名（）

      1. 接上面

      2. 自动将对象地址传给__init__的self

      3. 运行__init__方法中的代码，给对象封装属性

      4. class A(object):					#步骤
             def __init__(self):				 #5
                 self.x = 1
                 print('in init function')	    #6
         
             def __new__(cls, *args, **kwargs):	#2
                 print('in new function')	    #3
                 return object.__new__(A)	    #4
         a = A()							  #1
         print(a)						   #7
         打印结果
         in new function
         in init function
         <__main__.A object at 0x0000019399779198>
         
         

10. item

    1. class Func():
       	def __init__(self,name):
       		self.name = name
       		
       	def __getitem__(self,item):
       		print(self.__dict__[item])
       	def __setitem__(self,key,value):
       		self.__dict__[key] = value
       	def __delitem__(self,key):
       self.__dicy__.pop(key)
       	def __delattr__(self,key):
       		self.__dict__.pop(key)
       obj = A('alwx')
       obj['age'] = 18
       obj['hobby'] = 19
       del obj['age']
       del obj['hobby']
       del obj.age
       obj['name'] = 'david'
       
       		
       
       

11. 上下文管理

    1. enter ,exit
    2. 必须同时使用