面向对象进阶-类的内置方法 __str__ 、__repr__、__len__、__del__、__call__（三）

# 内置的类方法 和 内置的函数之间有着千丝万缕的联系
# 双下方法
# obj.__str__  str(obj)
# obj.__repr__ repr(obj)


#     def __str__(self):
#         return "Teacher's object"
      def func(self):
          return  "不打印我"
  
# a=Teacher（）
# print(str(a))  在这里如果注释def __str__(self)，a=Teacher,print(str(Teacher))打印object里的执行_str_返回的内存地址
# ，因为Teacher里没__str__方法就找(内置）父类object的_str_方法
  
# print（a） >>  Teacher's object   对象a只和_str_有关，所以不会执行func函数

# class Teacher:#一切对象的父类都是object



#     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))  >{"name":"哪吒","salary":250}
# print('>>> %r'%nezha) >    >>>{"name":"哪吒","salary":250}

# %r 走的__repr__如果注释掉__repr__方法，就找父类object的__repr__方法，返回内存地址


# 如果注释_str_方法，然后print（str（nezha）） 》》{"name":"哪吒","salary":250}返回_repr_的返回值
#   repr 是str的备胎，但str不能做repr的备胎

#a.__str__ --> object
# object  里有一个__str__，一旦被调用，就返回调用这个方法的对象的内存地址
# l = [1,2,3,4,5]   # 实例化 实例化了一个列表类的对象
# print(l)应该返回的是内存地址，但人看不到，所以内部有个转换，转换成我们看得懂得1/2/3/4/3/5（python内部处理机制）
# %s str()  直接打印 实际上都是走的__str__

# %r repr()  实际上都是走的__repr__

# repr 是str的备胎，但str不能做repr的备胎



# print(obj)/'%s'%obj/str(obj)三种情况是一样的
# str(obj)的时候，实际上是内部调用了obj.__str__方法，如果str方法有，那么他返回的必定是一个字符串
# 如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类中的__str__，还是没有就找object中内置的。
# repr(),只会找__repr__,如果没有找父类的
# 两个方法二选一时，优选__repr__

# 内置的方法有很多
# 不一定全都在object中
# class Classes:
#     def __init__(self,name):
#         self.name = name
#         self.student = []
#     def __len__(self):
#         return len(self.student)
#     def __str__(self):

#         return 'classes'

# py_s9= Classes('python全栈9期')
# py_s9.student.append('二哥')
# py_s9.student.append('泰哥')
# print(len(py_s9))
# print(py_s9)



#__del__

# class A:
#     pass            
# del a 
# print（a）会报错，因为不存在了

# class A:
#     def __del__(self):
#         print（“执行我了”）
# del a   # del 既既执行了这个方法，又删除了变量
# print（a）会报错，因为不存在了

# class A:
#     def __del__(self):   # 析构函数: 在删除一个对象之前进行一些收尾工作
#         self.f.close()
# a = A()
# a.f = open()   # 打开文件 第一 在操作系统中打开了一个文件 拿到了文件操作符存在了内存中
# del a          # a.f 拿到了文件操作符消失在了内存中,但操作系统文件没关，所以定义一个def __del__(self):  方法
# del a   # del 既执行了这个方法，又删除了变量（先执行关闭close，再删除a）
# 引用计数


# __call__
class A:
    def __init__(self,name):
        self.name = name
    def __call__(self):
        '''
        打印这个对象中的所有属性
        :return:
        '''
        for k in self.__dict__:
            print(k,self.__dict__[k])
a = A('alex')()  ==  a()  一个对象加（）相当于执行了_call_方法，没有这个方法就会报错