类的常用方法贰

Posted 2020-09-14

__setitem__,__getitem__,__delitem__

这三个方法和__setattr__,__getattr__,__delattr__类似,都是设定,获取,删除时触发,不同的是这三个方法触发的情况是通过字典键值对赋值的方式.

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[‘age‘]=18
f1[‘age1‘]=19
del f1.age1
del f1[‘age‘]
f1[‘name‘]=‘alex‘
print(f1.__dict__)

__str__,__repr__,__format__

往往我们直接打印一个对象的时候,返回的是一个__str__,__repr__是实现对象的字符串显示

自定制格式化字符串__format__

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘
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 __repr__(self):
        return ‘School(%s,%s)‘ %(self.name,self.addr)
    def __str__(self):
        return ‘(%s,%s)‘ %(self.name,self.addr)

    def __format__(self, format_spec):
        # if format_spec
        if not format_spec or format_spec not in format_dict:
            format_spec=‘nat‘
        fmt=format_dict[format_spec]
        return fmt.format(obj=self)

s1=School(‘oldboy1‘,‘北京‘,‘私立‘)
print(‘from repr: ‘,repr(s1))
print(‘from str: ‘,str(s1))
print(s1)

‘‘‘
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
‘‘‘
print(format(s1,‘nat‘))
print(format(s1,‘tna‘))
print(format(s1,‘tan‘))
print(format(s1,‘asfdasdffd‘))

__slots__限制属性

如果要限制添加的属性，例如，Student类只允许添加 name、gender和score 这3个属性，就可以利用Python的一个特殊的__slots__来实现。

class Student(object):
__slots__ = (‘name‘, ‘gender‘, ‘score‘)
def __init__(self, name, gender, score):
    self.name = name
    self.gender = gender
    self.score = score

__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用__slots__也能节省内存。

__next__和__iter__实现迭代器协议

class Range:
    "自定义类模仿range函数"
    def __init__(self,s_num,e_num,step=1):
        self.s_num = s_num
        self.e_num = e_num
        self.step=step

    def __iter__(self):
        return self

    def __next__(self):
        if self.s_num==self.e_num:
            raise StopIteration
        n = self.s_num
        self.s_num+=1*self.step
        return n

    def __del__(self):
        print("dadada")

f = Range(2,20,2) 
for i in f :
    print(i)

__doc__,描述信息

class Foo:
    ‘我是描述信息‘
    pass

print(Foo.__doc__

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

class Foo:

def __del__(self):
    print(‘执行我啦‘)

f1=Foo()
del f1
print(‘------->‘)

#输出结果
执行我啦
------->

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

__enter__和__exit__

为了对象兼容 with...as 语句,必须在这个对象的类中声明enter和exit方法

当一个对象被用作上下文管理器时：

__enter__ 方法将在进入代码块前被调用。

__exit__ 方法则在离开代码块之后被调用(即使在代码块中遇到了异常)。

class My_open:

    def __init__(self, filename, mode):#接受参数
        self.filename = filename
        self.mode = mode

    def __enter__(self):#打开文件是会运行__enter__
        self.openedFile = open(self.filename, self.mode)#获取真实文件句柄
        return self.openedFile#返回句柄

    def __exit__(self, exc_type, exc_val, exc_tb):#文件关闭时会运行__exit__
        self.openedFile.close()

    """此处如果不对exc_type, exc_val, exc_tb进行处理的话,with下的程序出错了就会报错
       可以在这里加上处理机制,如果返回非False的值就不会报错了"""



    def __getattr__(self, item):#其余的方法还是直接使用原来的
        return getattr(self,item)


with My_open("a.txt", "w+") as writer:
    writer.write("11111111111111")

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

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Fib(object):
    "求一定长度的斐波那契数列"
    def __call__(self, num):
        l = []
        a,b = 0,1
        for i in range(num):
            l.append(a)
            a,b=b,a+b
        return l

f = Fib()
print (f(10))