类的内置方法

自定制格式化字符串__format__

__str__  ,   __repr__(优先使用,覆盖面广)

改变对象的字符串显示__str__,__repr__

class A:pass
a = A()
print(a) # <__main__.A object at 0x0000000001DD1D68>内存地址 自己找不到到父类找
l = list()
print(l)  # []  为什么打出来长上面的不一样,因为list里面有内置方法

print(a.__str__()) # <__main__.A object at 0x00000000021C7A20> # 打印一个对象的时候,实际上市调用了这个对象所在类的__str__方法,打印的是这个方法的返回值 print('%s'%a) # <__main__.A object at 0x0000000002197A58> # %s 就是__str__方法的返回值 # 类的双下划线方法 # __str__ 和 __repr__

自己定制str方法
class A: def __str__(self): return 'a的对象' # str必须return一个字符串 def __repr__(self): return 'repr:A的对象' a = A() print(a.__str__()) # a的对象 print(a.__repr__()) # repr:A的对象 repr是str的备胎,没有str就用repr # repr是str的备胎,没有str就用repr (repr比较随和) # str 却不能给repr做备胎 (str高冷 ) class A: # def __str__(self): # return 'a的对象' # str必须return一个字符串 def __repr__(self): return 'repr:A的对象' a = A() print(a) # repr:A的对象 # 本质调用 __str__, 如果没有实现,就调用__repr__,再找不到,用object父类的 print(a.__str__()) # repr:A的对象 print(a.__repr__()) # repr:A的对象 print('%s'%a) # repr:A的对象 # 打印一个对象的时候,实际上是调用了这个对象所在类的__str__方法,打印的是这个方法的返回值

%s  %r

class A:
    def __str__(self):
        return 'a的对象'  # str必须return一个字符串

    def __repr__(self):
        return 'repr:A的对象'

a = A()
print(a.__str__())  # a的对象
print(a.__repr__())  # repr:A的对象  repr是str的备胎,没有str就用repr
print('%s'%a)  # s -- 》 str  a的对象(自己有用自己)
print('%r'%a)  # r --》 repr  repr:A的对象

 

自定制格式化字符串__format__

格式

# format_dict={
#     'nat':'{o.name}-{o.addr}-{o.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'  相当与上面
        fmt='{obj.type}:{obj.name}:{obj.addr}'  # 做格式化输出
        return fmt.format(obj=self)  # 这里obj=self为固定写法

s1=School('oldboy1','北京','私立')
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))

例子

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'
        fmt='''=====================
姓名 : {obj.name}
班级 : {obj.addr}
====================='''
        return fmt.format(obj=self)

s1=School('oldboy1','北京','私立')
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))

# 输出的格式
# =====================
# 姓名 : oldboy1
# 班级 : 北京
# =====================
# =====================
# 姓名 : oldboy1
# 班级 : 北京
# =====================
# =====================
# 姓名 : oldboy1
# 班级 : 北京
# =====================
# =====================
# 姓名 : oldboy1
# 班级 : 北京
# =====================

 

__del__

析构方法

析构方法,当对象在内存中被释放时,自动触发执行。

注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

  析构方法(是执行删除对象的时候才执行)700百才启动
具有周期: 当没引用

须知道: 当你删除一个对象的时候,这个对象的相关内容,需做一些处理,就使用析构方法

# 用于高并发问题
class A:
    def __del__(self):
        '''
        析构方法
        这个方法只有在执行del A类的对象的时候才被触发
        且先执行代码中的内容,再删除对象
        如果我删除了这个对象,它跟着还有一些其他的附属的内容也没有用了
        我们就可以在这个方法中回收掉
        '''
        print('执行我啦!')
        self.b.close()
f = open('file','w')
a = A()  # 对象
a.b = f  # 给a的对象赋一个文件句柄
del a  # 即文件不需要了

 

item系列方法

__getitem__\__setitem__\__delitem__

需求:

使用[] 去获取对象里面内容的方法,实现,调用就使用item系列方法

 

#关于item : 对象访问 如果是 对象名[],是因为内部实现了item系列的方法

 

class Foo:
    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):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1 = Foo('sb')
# 访问属性的方式变了
# 对象名.属性
f1=Foo('sb')
f1['age']=18  #给f1添加一个属性
      #  触发 __setitem__(self, key, value)  ---》 key = age ,value = 18

del f1['age']  #删除属性  __delitem__(self, key)

print(f1['name'])  # f1.name 正常以前访问
       # 触发了__getitem__(self, item) --> item = name

f1.__dict__['age'] = 18
f1['age1']=19
del f1.age1   #删除属性

f1['name']='alex'
print(f1.__dict__)
class Foo:
    def __init__(self,name):
        self.name=name
    def __getitem__(self, item):
        if item == 1:
            print('hahaha')
    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1 = Foo('sb')
f1[1]

# 输出 hahha

 

__new__(面试)

是object替你执行new方法

对象的实例化
创造一个裸地对象 —— __new__ ****
初始化
单例模式 —— 设计模式(面试)
一个类 从头到尾 只创建 一个对象

class Singleton:
    def __new__(cls, *args):
        if not hasattr(cls, '_instance'):
            cls._instance = object.__new__(cls)  # 创造一个新对象
        return cls._instance

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

one = Singleton('alex') # object.__new__(elax)
print(one.name) # alex
two = one
two.name = 'egon'
two = Singleton('egon')
print(two.name)  # egon
print(one.name)  # egon
print(id(one),id(two))  # 38785880 38785880

__call__

()跟call是约定的

对象后面加括号,触发执行。


注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()

 
class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('__call__')

Foo()()   #对象名() ---> 调用call

 

__len__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __len__(self):
        return len(self.__dict__)
a = A()
print(len(a))

 

__hash__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))

 

__eq__

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)

例子

class A:
    def __eq__(self,obj):   #equal : 相等
        # if  self.a == obj.a and self.b == obj.b:
            return True
a = A()
b = A()
a.name = 'alex'
b.name = 'egon'
print(a == b)  # True

 

面试题

一个类 有 100个 对象,每一个对象都拥有三个属性:name,sex,age
如果两个对象的name和sex属性完全一致
我就认为这是一个对象
请对这100个对象进行去重
class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __hash__(self):
        return hash(self.name+self.sex)
    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:return True

p_lst = []
for i in range(84):
    p_lst.append(Person('egon',i,'male'))
print(set(p_lst))

 

 
posted @ 2017-11-25 01:54  小杜要加油  阅读(339)  评论(0编辑  收藏  举报