面向对象之内置方法续集

接上一篇，内置方法续集：

　　六、__str__，__repr__ 和 __format__

　　　　1、作用：__str__，__repr__ 改变对象的字符串显示

　　　　　　　　__format__ 自定制格式化字符串

　　　　2、示例：

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong

format_dict={
    'way1':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
    'way2':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
    'way3':'{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 not format_spec or format_spec not in format_dict:
            format_spec = 'way1'
        fmt =format_dict[format_spec]
        return fmt.format(obj=self)

s1 = School('lufei','上海','培训机构')

print('from repr:',repr(s1)) # from repr: School(lufei,上海)
print('from str:',str(s1)) #  from str: (lufei,上海)
print(s1) # (lufei,上海)

print(format(s1,'way2'))# 培训机构:lufei:上海
print(format(s1,'way3')) # 培训机构/上海/lufei
print(format(s1,'abcdef')) # 培训机构/上海/lufei
'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
'''

　　注意：__str__和__repr__方法的返回值必须是字符串,否则抛出异常。

　　七、slots的用法

　　　　1、__slots__是什么？

　　　　　　__slots__是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)。

　　　　2、使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)。

　　　　3、使用__slots__方法的好处？

　　　　　　字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__

当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个

字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给

实例添加新的属性了,只能使用在__slots__中定义的那些属性名。

　　　　4、注意：__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。

大多数情况下,你应该只在那些经常被使用到 的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。它更多的是

用来作为一个内存优化工具。

　　　　5、示例：

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong

class Test:
    __slots__ = ['name','age']

f1 = Test()
f1.name = 'cc'
f1.age = 21
print(f1.__slots__) # ['name', 'age']
#print(f1.__dict__) 报错，f1不再有__dict__

# f1.sex = 'male' 报错，f1不能再添加属性
print(f1.__slots__) # ['name', 'age']

f2 = Test()
f2.name = 'zm'
f2.age = 19
print(f2.__slots__) # ['name', 'age']

 #f1与f2都没有属性字典__dict__了,统一归__slots__管,节省内存
print(Test.__dict__)# {'__module__': '__main__', '__slots__': ['name', 'age'], 'age': <member 'age' of 'Test' objects>, 'name': <member 'name' of 'Test' objects>, '__doc__': None}

　

　　

　　八、__next__和__iter__实现迭代器协议　　　　

　　　　1、关于__next__和__iter__方法的几点解释

　　　　Python中关于迭代有两个概念，第一个是Iterable，第二个是Iterator，协议规定Iterable的__iter__方法会返回一个Iterator,

Iterator的__next__方法（Python 2里是next）会返回下一个迭代对象，如果迭代结束则抛出StopIteration异常。同时，Iterator自己也是一种Iterable，

所以也需要实现Iterable的接口，也就是__iter__，这样在for当中两者都可以使用。Iterator的__iter__只需要返回自己就行了。

　　这样，下面的代码就可以工作：

　　for i in my_list:
    ...

　　for i in iter(mylist):
    ...

　　for i in (v for v in mylist if v is not None):
    ...
　　　　
      2、示例1--迭代器：

class Range:
    def __init__(self,n,stop,step): # n为起点，stop为终点，step为步长
        self.n=n
        self.stop=stop
        self.step=step

    def __next__(self):
        if self.n >= self.stop:
            raise StopIteration
        x=self.n
        self.n+=self.step
        return x

    def __iter__(self):
        return self

for i in Range(1,7,3): #
    print(i)

　  3、示例2--斐波拉契数列：

# 斐波那契数列
class Fib:
    def __init__(self):
        self._a=0
        self._b=1

    def __iter__(self):
        return self

    def __next__(self):
        self._a,self._b=self._b,self._a + self._b
        return self._a

f1=Fib()

print(f1.__next__())
print(next(f1))
print(next(f1))

for i in f1:
    if i > 100:
        break
    print('%s ' %i,end='')

　　九、 __module__和__class__

　　　　1、__module__ 表示当前操作的对象在那个模块、__class__ 表示当前操作的对象的类是什么

　　　　2、示例： 

#lib/a.py

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong

class C:

    def __init__(self):
        self.name = 'cc'


# index.py

#from lib.a import C
obj = C()
print(obj.__module__) # 输出 lib.a，即输出模块
print(obj.__class__) # 输出lib.a.C ,输出类

　　十、__del__方法

　　　　1、含义：析构方法，当对象在内存中被释放时，自动触发执行。

　　　　2、为什么用__del__方法？

　　　　　　如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，

即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__。

　　　　3、应用场景　　　　　

　　　　　　创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，

　　　　存放于内核空间内存中当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，

　　　　这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源

　　　　4、示例： 

class Foo:

    def __del__(self):
        print('执行到我啦')

f1=Foo()
del f1
print('------->')
'''
#输出结果
执行我到啦
------->
'''

　　　十一、 __enter__和__exit__方法　　

with open('a.txt') as f:
    pass
# 上述叫做上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法
class Open:
    def __init__(self,filepath,mode='r',encoding='utf-8'):
        self.filepath=filepath
        self.mode=mode
        self.encoding=encoding

    def __enter__(self):
        # print('enter')
        self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        '''
        with语句中代码块出现异常，则with后的代码都无法执行
        如果__exit__()返回值为True,那么异常会被清空，就好像啥都没发生一样，with后的语句正常执行
        :param exc_type: 异常类型
        :param exc_val: 异常值
        :param exc_tb: 追溯信息
        :return:
        '''
        # print('exit')
        self.f.close()
        return True
    def __getattr__(self, item): #属性不存在时触发
        return getattr(self.f,item)

with Open('a.txt','w') as f:
    print(f)
    f.write('aaaaaa')
    f.wasdf #抛出异常，交给__exit__处理

　　　　使用with语句的好处：

　　　　　　使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预

在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，

你无须再去关心这个问题。

　　

　　十二、__call__方法

　　　　1、使用方法：对象后面加括号，触发执行。

　　　　2、注意事项：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；

　　　　而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()。

　　　　3、示例：

class Foo:

    def __init__(self):
        pass

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

        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

　　十三、__doc__方法

　　　　1、作用：查看类的描述信息。

　　　　2、示例：

class Foo:
    '我是匆匆'
    pass
class Bar(Foo):
    pass
print(Foo.__doc__) # 我是匆匆
print(Bar.__doc__) # None 该属性无法继承给子类