学习方法：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') 报错！！！