Python进阶-XVIV 类的内置方法：__str__ 、__repr__、析构函数（__del__）、双下的call,eq,new,hash 以及item相关的三个方法

类的内置方法
　　它与内置函数有紧密的联系，有的内置函数就是调用的内置方法。
　　在顶级父类obj中有：
　　两个双下方法
　　　　obj.__str__  str(obj)
　　　　obj.__repr__ repr(obj)

1、__str__ 与 __repr__

 class Teacher:
     def __init__(self, name, salary):
         self.name = name
         self.salary = salary

     def __str__(self):
         return "Teacher's object :%s" % self.name

     def __repr__(self):
         return str(self.__dict__)

     def func(self):
         return 'wahaha'

 nezha = Teacher('哪吒', 250)
 print(nezha)  # 打印一个对象的时候，就是调用a.__str__
 print(repr(nezha))
 print('>>> %r' % nezha)

a.__str__ --> object
object  里有一个__str__，一旦被调用，就返回调用这个方法的对象的内存地址
l = [1,2,3,4,5]   # 实例化 实例化了一个列表类的对象
print(l)
%s str()  直接打印 实际上都是走的__str__
%r repr()  实际上都是走的__repr__
repr 是str的备胎，但str不能做repr的备胎

print(obj)/'%s'%obj/str(obj)的时候，实际上是内部调用了obj.__str__方法，如果str方法有，那么他返回的必定是一个字符串
如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类中的__str__。
repr(),只会找__repr__,如果没有找父类的

内置的方法有很多，但是不一定全都在object中

 class Classes:
     def __init__(self, name):
         self.name = name
         self.student = [ ]

     def __len__(self):
         return len(self.student)  # obj中没有该方法，因为obj只存所有对象共有的！

     def __str__(self):
         return 'classes'

 py_s9 = Classes('九年级三班')
 py_s9.student.append('董青')
 py_s9.student.append('久美')
 print(len(py_s9))
 print(py_s9)

 # 1、__str__
 print(str(12))  # 其实就是调用int类型的__str__方法

 # 为了验证，可以来一个例子:
 class StrDemo:
     def __init__(self, name):
         self.name = name

     # def __str__(self):
     #     print('调用我的str双下方法了！')
     #     return self.name
     def __repr__(self):
         print('调用我的repr双下方法了！')
         return self.name

 s = StrDemo("string")
 print(str(s))

 # 2、__repr__
 print(repr(''))
 print(repr(1))
 # 我们将StrDemo类中的__str__方法注释掉，看看发生什么？
 print(repr(s))

 # 当一个类没有重写__str__方法，但是重写了__repr__方法，当使用str（本类实例）的时候，就调用了__repr__
 # 即__repr__是__str__的备胎，但是反过来就不行！

2、析构函数（__del__）

功能是在回收内存中的对象，并在回收前做一些收尾工作，如打开的文件没关闭，将其关闭等！

 class A:
     def __init__(self, f):
         self.f = f

     def __del__(self):
         print('it deling')
         self.f.close()  # 析构函数: 在删除一个对象之前进行一些收尾工作

 a = A(open('2_反射进阶.py'))
 del a  # del 既执行了这个方法，又删除了变量

 # del a   NameError: name 'a' is not defined

 # 引用计数中用到该内置方法

3、item相关方法：__getitem__ 　　 __setitem__ 　　 __delitem__

 class Person:
     def __init__(self, name,age,ginder):
         self.name = name
         self.age = age
         self.ginder = ginder

     def __getitem__(self, item):
         if hasattr(self, item):
             return self.__dict__[item]

     def __setitem__(self, key, value):
         self.__dict__[key] = value

     def __delitem__(self, key):
         print('it is calling me !')
         self.__dict__.pop(key)

 tom = Person('tom', 22, 'male')
 # 得到属性
 print(tom['ginder'])  # __getitem__可以用访问字典中的元素一样访问对象的属性！
 # 设置属性
 tom['kind'] = 'superman'
 print(tom.kind, tom['kind'])
 #del tom.kind    # object 原生支持  __delattr__
 del tom['kind']  # 通过自己实现的
 print(tom.kind, tom['kind'])

4、__hash__        对应 hash()内置函数 　　

查看hash值，可以修改hash规则，是的本来有不同hash值的两个对象有一样的hash值

 lass Hash:
     def __init__(self, name):
         self.name = name

     def __hash__(self):
         return hash(self.name)

 ha_a = Hash('a_Hash')
 hah = Hash('a_Hash')
 print(hash(ha_a), hash(hah))  # 两个对象虽然名字一样，但是hash值不同：-9223371888545262739 148309513073
 # 实现object中的__hash__方法，并只返回name的hash值，就相等了：-9184190014575666570 -9184190014575666570

5、__new__ 构造函数，在初始化函数前，将self构造出来。
　　典型使用：单例模式（23种设计模式第一个）
　　即：一个类在内存中，始终只有一个实例

　　__init__ 初始化方法
　　__new__ 构造方法 : 创建一个对象

 class Singleton():
     __instance = False
     def __init__(self, name):
         self.name = name

     def __new__(cls, *args, **kwargs):
         '''实现单例'''
         if cls.__instance:
             return cls.__instance
         else:
             cls.__instance = object.__new__(cls)
             return cls.__instance

 a = Singleton('a')
 a.nm = '单例'
 b = Singleton('b')
 print(b.nm)
 print(id(a), id(b))  # 没有实现__new__方法前的结果是：2681905465888 2681905467232 地址不同，说明是两个对象
 # __实现__new__方法后，即使不写具体操作，直接pass，也返回相同的地址：1760945392 1760945392
 # 实现单例的操作后，地址变为：2491487242000 2491487242000 还是相同，即为同一对象！

6、 __eq__方法

 class Equal:
     def __init__(self, name):
         self.name = name

     def __eq__(self, other):
         if self.name == other.name:
             return True

 double_eq = Equal('双等于号')
 eq = Equal('双等于号')
 # 问：两个对象相等吗？
 print(double_eq, eq, double_eq == eq)
 #  <__main__.Equal object at 0x0000027726CA3828> <__main__.Equal object at 0x0000027726CA3860> False
 # 内存地址不一样，是两个对象，所以不等，双下eq方法，是继承自顶级的object类，原来就是比较内存地址的！
 # 实现该方法的其他类，如str，int等，改为值等就是相等了！
 # 如何让两个相同的名字的Equal对象，变为相等了？只有重写eq方法了
 print(double_eq == eq)

7、__call__ 方法

 class B:
     def __init__(self, name):
         self.name = name

     def __call__(self):
         for k in self.__dict__:
             print(k, self.__dict__[ k ])

 B('sb')()  # 最后一个()就是在调用该类中的双下call方法!