面向对象编程（5）

__ new __()

当使用“类名（[实参]）”创建实例对象时，python解释器主要处理过程包括两大类：
1、调用特殊方法 __ new __ ()创建实例对象 首先会查找该类对象是否实现了特殊方法 __ new __ ()，如果没有实现，则去其父类中依次查找，直到找到类对象object 。
2、调用特殊方法 __ init __ ()对创建实例对象进行初始化 __ new __ 返回的实例对象会作为实参自传递底给 __ init __ 的第一个形参self。

class Parent(object):
    def __new__(cls,*args,**kwargs):
        print("父类的__new__被调用，其形参cls对应实参的id:",id(cls))
        obj = super().__new__(cls)
        print("创建的实例对象的id:",id(obj))
        return obj
class Child(Parent):
    def __init__(self,name):
        print("子类的__new__被调用，其形参self对应实参的id:",id(self))
        self.name = name
        
child = Child("Mike")

##
父类的__new__被调用，其形参cls对应实参的id: 2091367773080
创建的实例对象的id: 2091373859728
子类的__new__被调用，其形参self对应实参的id: 2091373859728

print("父类Parent的id",id(Parent))
print("子类Child的id",id(Child))
print("创建的实例化对象id",id(child))
##
父类Parent的id 2091367772136
子类Child的id 2091367773080
创建的实例化对象id 2091373859728

__ getitem __ ()、 __ setitem __ ()、__ delitem __()

对于定义类对象的实例对象，在默认情况下，是不能像列表和字典一样使用中括号语法来操作数据的。

如果想让自定义类对象的实例对象可以像列表和字典那样，使用中括号语法来操作数据，必须自定义类对象中实现以下特殊方法：

1、getitem(self,key)当
执行obj(key)时会自动调用该方法

2、setitem(self,key,value)
当执行操作obj[key] = value时，会自动调用该特殊方法。

3、delitem(self,key)
当执行操作del obj[key]时，会自动调用改特殊方法。

class MyDict(object):
    def __init__(self):
        self.data = {}
        
    def __getitem__(self,key):
        return self.data[key]
    
    def __setitem__(self,key,value):
        self.data[key] = value
        
    def __delitem__(self,key):
        del self.data[key]
        
md = MyDict()
md["one"] = 18
md["two"] = 32
print(md.data)
##
{'one': 18, 'two': 32}

__ call __ ()与callable()

如果在类对象中实现特殊方法__ call __ ()，那么就可以调用函数一样直接直接用这个类对象的实例对象，从而会自定调用特殊方法__ call __()

class MyClass(object):
    def __call__(self,*args,**kwargs):
        print(args,kwargs)
        
mc = MyClass()
mc()
##
() {}

mc(1,2,x=3,y=4)
##
(1, 2) {'x': 3, 'y': 4}

内置函数callable用于判断指定对象是否可调用，除了函数对象是可调用之外，对于实现特殊方法 __ call __ () 的类对象，其实例对象也是可调用的。

callable(print)#内置函数是可以调用的
##
True

def my_fun():
    pass
print(callable(my_fun))#自定义函数也是可以调用的
##
True

print(callable(MyClass()))#实现了特殊方法__call__()的类对象，其实例对象也是可以调用的
##
True

__ doc __ 与__ dict __ ()

调用内置函数dir得到的类对象的所有属性中，有一个特殊属性叫 __ doc__ ，用于表示类对象的文档字符串。

1、什么是类对象的文档字符串(docstring)
与函数的文档字符串类似，位于类对象的第一 -行的字符串被称为类对象的文档字符串，通常用三个引号表示。类对象的文档字符串是对类对象的功能的简要描述。

2、访问类对象的文档字符串
通过类对象的特殊属性 __ doc __ 可以访问类对象的文档字符串。调用内置函数help( )得到的帮助信息中会包含类对象的文档字符串。

class MyClass(object):
    """这是类对象的文档字符串
    1
    3
    3
    4
    """
    pass
print(MyClass.__doc__)
##
这是类对象的文档字符串
    1
    3
    3
    4


print(help(MyClass))
##
Help on class MyClass in module __main__:

class MyClass(builtins.object)
 |  这是类对象的文档字符串
 |  1
 |  3
 |  3
 |  4
 |  
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

None

对于指定的类对象或实例对象，可以访问特殊属性__ dict __ 获得该类对象键或实例对象所绑定的所有属性和方法的字典。其中，字典中的键为属性名或方法名。

class MyClass(object):
    ca = "ca"
    
    def __init__(self):
        self.ia = "ia"
        
    def im(self):
        pass
    @classmethod
    def cm(cls):
        pass
    @staticmethod
    def sm():
        pass

MyClass.ca2 = "ca2"
MyClass.__dict__
##
mappingproxy({'__module__': '__main__',
              'ca': 'ca',
              '__int__': <function __main__.MyClass.__int__(self)>,
              'im': <function __main__.MyClass.im(self)>,
              'cm': <classmethod at 0x2b9166f0748>,
              'sm': <staticmethod at 0x2b9166f07b8>,
              '__dict__': <attribute '__dict__' of 'MyClass' objects>,
              '__weakref__': <attribute '__weakref__' of 'MyClass' objects>,
              '__doc__': None,
              'ca2': 'ca2'})

mc = MyClass()
mc.ia2 = "ia2"
print(mc.__dict__)
##
{'ia': 'ia', 'ia2': 'ia2'}

__ slots __

Python是动态语言，所以，在创建对象之后，可以对其动态地绑定属性和方法。如果想要对实例对象动态绑定的属性和方法的名称进行限制，可以在其对应的类对象中定义特殊属性__ slots __ ，并给__ slots __ 赋值一个所有 元素都为字符串的列表或元组，这样，对实例对象动态绑定的属性和方法的名称就只能来自于__ slots __ 中的元素。

class MyClass(object):
    __slots__ = ("attr1","do_sth1")
    
mc == MyClass()
mc.attr1=18
print(mc.attr1)
##
18


def do_sth1(self):
    print("do_sth1被调用了")
    
from types import MethodType
mc.do_sth1 = MethodType(do_sth1,mc)
mc.do_sth1()
##
do_sth1被调用了

默认情况下，访问实例对象的属性是通过访问该实例对象的特殊属性__ dict __ 来实现的。例如:访问obj.x其实访问的是obj.__ dict __ [‘x’]

在类对象中定义了特殊属性__slots __ 后，其实例对象就不会在创建特殊属性 dict__ 了，而是为每个属性创建一个描述器， 访问属性时就会直接调用这个描述器。调用描述器比访问__ dict __ 要快。因此，在类对象中定义特殊属性__ slots__ 可 以提高属性的访问速度。

此外，在类对象中定义了特殊属性__slots __ 后， 由于其实例对象不再创建特殊属性__ dict__ ， 同时特殊属性__ dict__ 是一个字典，字典的本质是哈希表，是一种用空间换取时间的数据结构，因此，在类对象中定义特殊属性__ slots__ 可以减少内存消耗。

print(MyClass().__dict__)
##
AttributeError                            Traceback (most recent call last)
<ipython-input-32-11a41545445d> in <module>
----> 1 print(MyClass().__dict__)

AttributeError: 'MyClass' object has no attribute '__dict__'

特殊属性__ slots __ 只对其所在类对象起作用，对其所在类对象的子类的实例对象是不起作用的。

class MyClass(object):
    __slots__ = ("attr1","do_sth1")
    
mc = MyClass()

class ChildClass1(MyClass):
    pass
    
mc_child = ChildClass1()
mc_child.attr3 = 66

print(mc_child.attr3)
##
66

如果子类也定义了特殊属性__ slots __ ,那么子类的实例对象可以动态绑定的属性和方法的名称为子类的__ slots __加上父类的 __ slots __。

class MyClass(object):
    __slots__ = ("attr1","do_sth1")
    
mc = MyClass()

class ChildClass2(MyClass):
    __slots__ = ("attr2","do_sth2")
    
mc_child2 = ChildClass2()
mc_child2.attr1 = 18
mc_child2.attr2 = 18
mc_child2.do_sth1 = 18
mc_child2.do_sth2 = 18
print(mc_child2.attr1,end = '\t')
print(mc_child2.attr2,end = '\t')
print(mc_child2.do_sth1,end = '\t')
print(mc_child2.do_sth2,end = '\t')
##
18	18	18	18	

__ len __()

内置函数len()用于返回对象长度。

内置函数len()的实参在默认情况下不能是自定义类对象的实例对象。

print(len([1,2,3,4,5]))
##
5

print(len('abcde'))
##
5

print(len({'a':1,'b':2,'c':3}))
##
3

如果想让内置函数len()的实参可以是自定义类对象的实例对象，必须在自定义类对象中实现特殊方法__ len __ ()。这样，调用内置函数len()时，在其内部会自动调用实参所对应类对象的特殊方法__ len __ ()。之所以，内置函数len()的实参可以是上述内置类对象的实例对象，是因为上述的内置类对象中都实现了特殊方法__ len __ ()。

class MyClass(object):
    def __len__(self):
        return 18
    
print(len(MyClass()))
##
18

生成器

[i*i for i in range(8)]
##
[0, 1, 4, 9, 16, 25, 36, 49]

(i*i for i in range(8))#生成器表达式
##
<generator object <genexpr> at 0x000001E6EFA037C8>

查看生成器对应的所有元素，有两种方式：

1、多次调用内置函数next()，每次调用都返回生成器的下一个元素，直到抛出异常StopIteration时表示。

a = (i*i for i in range(5))
print(next(a))
##
0

print(next(a))
##
1

print(next(a))
##
4

print(next(a))
##
9

print(next(a))
##
16

print(next(a))
##
StopIteration                             Traceback (most recent call last)
<ipython-input-53-94b12d3903f7> in <module>
----> 1 print(next(a))

StopIteration: 

2、使用语句对生成器进行迭代，这样就不需要关心异常StopIteration了。

a = (i*i for i in range(5))

for j in a:
    print(j)
##
0
1
4
9
16

生成器中保存的并不是其对应的所有元素，而是如何推算出所有元素的算法。将生成器用于for-in语句时，元素是在循环的过程中不断被推算出来的。将生成器作为内置函数next()的实参时，返回的下一个元素也是在调用函数时被推算出来的，因此，生成器是惰性推算的，也就是说，只有当用到生成器中的某个元素时，才会临时进行推算，而并不会提前进行推算。

如果需要创建一个元素个数较大的容器，就可以考虑使用生成器，从而节省大量的存储空间。

生成器函数(yield)

上面使用类似生成式的语法得到的生成器被称为生成器表达式，此外，当推算的语法比较复杂时，还可以使用生成器函数得到生成器。 生成器函数中通过关键字yield返回推算数的元素。生成器函数与普通函数的区别在于：当调用内置函数next()或使用for-in语句进行迭代时，执行完yield语句就会将生成器函数挂起，下次会从挂起的地方继续执行。

def fib(n):
    i = 0
    a,b = 1,1
    while i<n:
        print(a,end = ',')
        a,b = b,a+b
        i += 1
fib(6)
##
1,1,2,3,5,8,


def fib(n):
    i = 0
    a,b = 1,1
    while i<n:
        yield a
        a,b = b,a+b
        i += 1
        
gf = fib(6)
for item in gf:
    print(item)
##
1
1
2
3
5
8

注：函数中出现多个yield，也称为生成器函数。

迭代器

1、可以用于for-in语句的对象被称为可迭代(Iterable)对象。 例如：range、列表、元组、字符串、字典、集合、生成器， 都是可迭代对象。

2、可以调用内置函数isinstance()判断一个对象是否是可迭代 对象。标准库模块collections中的类Iterable用于表示可迭代对象。

from collections import Iterable
print(isinstance([1,2,3],Iterable))
##
True

print(isinstance('abc',Iterable))
##
True

print(isinstance((i*i for i in range(1,7)),Iterable))
##
True

如果一个迭代对象可以作为内置函数next()的实参从而支持惰性推算，那么该对象被称为迭代器(Iterator)对象。

对于range、列表、元组、字符串、字典和集合等可迭代对象，都不可以作为内置函数next()的实参，而生成器可以。所以，生成器是迭代器的一种。

可以调用内置函数isinstance()判断一个对象是否是迭代对象。标准库模块collection中的类Iterator用于表示迭代器对象。

L = [1,2,3,4]
next(L)
##
TypeError                                 Traceback (most recent call last)
<ipython-input-61-f3700fab1ac6> in <module>
      1 L = [1,2,3,4]
----> 2 next(L)

TypeError: 'list' object is not an iterator


s = 'abc'
next(s)
TypeError                                 Traceback (most recent call last)
<ipython-input-62-2f65d1300ea3> in <module>
      1 s = 'abc'
----> 2 next(s)

TypeError: 'str' object is not an iterator

from collections import Iterator
print(isinstance(L,Iterator))
print(isinstance(s,Iterator))
##
False
False

可以调用内置函数iter()把不支持惰性推算的可迭代对象转化为迭代器对象。

iter_L = iter(L)
iter_s = iter(s)
print(isinstance(iter_L,Iterator))
print(isinstance(iter_s,Iterator))
##
True
True

如果一个对象同时实现了特殊方法__ iter __ ()和__ next __ ()，那么该对象也被称为迭代对象，如果该对象用于for-in语句首先会被调用特殊方法__ iter __ 返回一个可迭代对象，然后不断调用该可迭代对象的特殊方法__ next __ ()返回下一次迭代的值，知道遇到StopIteration时退出循环。

class MyIterator(object):
    def __init__(self):
        self.data = 0
        
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.data>5:
            raise StopIteration()
        else:
            self.data += 1
            return self.data
        
for item in MyIterator():
    print(item)
##
1
2
3
4
5
6

for-in语句在默认情况下不能用于自定义类対象的实例对象。

如果想让for-in语句可以用于自定义类对象的实例对象，必需在自定义类对象中实现特殊方法__ iter __ ()和 __ next __ ()。for-in语句首先会调用特殊方法__ iter __ ( )返回一个可迭代对象,然后不断调用可迭代对象的特殊方法__ next__ ()返回下一次迭代的值，直到遇到StopIteration吋退出循环。

只实现了特殊方法__ iter __ () 的类对象，被称为可迭代类对象;同吋实现了特殊方法__ iter __ ( )和__ next __ () 的类对象，被称为迭代器类对象。

之所以for-in语句可以用于某些内置类对象(例如: list、 tuple、 str等)的实例对象,是因为这些内置类对象中都同时实现了特殊方法__ iter__ ()和__ next __ ()。