0419 内置方法

学习方法：wwwh

内置方法
__len__   len(obj)
obj对应的类中含有__len__方法，len(obj)才能正常执行

__hash__  hash(obj)   是object类自带的
只有实现了 __hash__方法，hash(obj)才能正常执行

 __str__和__repr__

class List:
    def __init__(self,*args):
        self.l = list(args)
    def __str__(self):
        return '[%s]'%(','.join([str(i) for i in self.l]))
l = List(1,2,3,4,5)
print(l)   #--> l.__str__()   # object类中的__str__就是返回一个数据的内存地址
print(l)
print(str(l))
print('%s'%l)
print(obj)   的结果 是 obj.__str__()的结果
str(obj)   的结果 也是 obj.__str__()的结果
'%s'%obj   的结果 也是 obj.__str__()的结果  %s的s就是str的s

class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return "Teacher's object %s"%self.name
    def __repr__(self):
        return 'repr function %s'%self.name
a = Teacher('alex',80)
b = Teacher('egon',80)
print(a)
print(b)
def repr(obj):
    return obj.__repr__()

print(repr(a))   # 函数  打印repr的返回值
print(a.__repr__())
print('%r'%a)
print(str(a))   # 函数 打印str函数的返回值

repr(obj)的结果和obj.__repr__()是一样的
'%r'%(obj)的结果和obj.__repr__()是一样的

class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return "Teacher's object %s"%self.name
    def __repr__(self):
        return 'repr function %s'%self.name
a = Teacher('alex',80)
b = Teacher('egon',80)
print(a)
print(repr(a))
当需要使用__str__的场景时找不到 __str__就找__repr__
当需要使用__repr__的场景时找不到__repr__的时候就找父类的repr
双下repr是双下str的备胎

len()  obj.__len__()  返回值是一致的
len() 的结果是依赖 obj.__len__()
hash() 的结果是依赖 obj.__hash__()

str() 的结果是依赖 obj.__str__()
print(obj) 的结果是依赖 obj.__str__()
%s 的结果是依赖 obj.__str__()    # 语法糖

repr() 的结果是依赖 obj.__repr__()
%r 的结果是依赖 obj.__repr__()

__format__
class A:
    def __init__(self,name,school,addr):
        self.name = name
        self.school = school
        self.addr = addr
    def __format__(self,format_spec):
        return format_spec.format(obj=self)
a = A('大表哥','oldboy','沙河')
format_spec = '{obj.name}-{obj.addr}-{obj.school}'
print(format(a,format_spec))     #大表哥-沙河-oldboy

format_dict={
    'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
    'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
    'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
 }
class School:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type
    def __format__(self, format_spec):   #format_spec = 'nat'
        if not format_spec or format_spec not in format_dict:
            format_spec='nat'
        fmt=format_dict[format_spec]     #'{obj.name}-{obj.addr}-{obj.type}'
        return fmt.format(obj=self)     #'{obj.name}-{obj.addr}-{obj.type}'.format(obj=self)
s1=School('oldboy1','北京','私立')
print(format(s1,'nat'))  #s1.__format__('nat')   #oldboy1-北京-私立
print(format(s1,'tna'))                          #私立:oldboy1:北京
print(format(s1,'tan'))                          #私立/北京/oldboy1
print(format(s1,'asfdasdffd'))                   #oldboy1-北京-私立

__call__
class Teacher():
    def __call__(self):
        print(123)
    def call(self):print(123)
t = Teacher()
t.call()  123
t()   #   123  对象名() 相当于调用类内置的__call__
一个对象是否可调用 完全取决于这个对象对应的类是否实现了__call__
callable
print(callable(Teacher))   True
print(callable(t))         True

class A:
    def __eq__(self, other):
        if self.__dict__ == other.__dict__:
            return True
 __eq__()
a = A()
a.name = 'alex'
b = A()
b.name = 'egon'
print(a)    　 　<__main__.A object at 0x006420D0>
print(b)  　　   <__main__.A object at 0x00642270>
print(a == b)　　None

== 是由__eq__的返回值来决定的

__del__ 析构方法:  在删除一个对象的时候做一些首尾工作
此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交
给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo:
    def __del__(self):
        print('执行我啦')
f1=Foo()
del f1
print('------->')   #执行我啦 ------->

__new__ 构造方法
实例化的时候
创造对象的过程  __new__
__init__ 初始化

设计模式 —— 单例模式
单例模式 就是 一个类 只能有一个实例

class B:
    __instance = None
    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(self.name)
a = B('alex',80)
b = B('egon',20)
print(a)    <__main__.B object at 0x003722F0>
print(b)    <__main__.B object at 0x003722F0>
print(a.name)  egon
print(b.name)  egon

item系列
__getitem__
__setitem__
__delitem__
class Foo:
    def __init__(self,name):
        self.name=name
    def __getitem__(self,item):
        return  self.__dict__[item]
    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
f = Foo('alex')
# f.name = ...
print(f['name'])    # f.__getitem__('name')
f['age']  = 18      # 赋值
print(f.age)         # 自带的语法
print(f['age'])     # 修改
f['age']  = 80
print(f['age'])     # 通过实现__getitem__得到的
del f['age']
# print(f.age)      # 删除

class Foo: # 删除
    def __init__(self,name):
        self.name=name
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)
f = Foo('alex')
del f.name     #相当于执行了__delattr__
delattr(f,'name')   报错！！！