NMT Data Mining & Big Data

面向对象编程（OOP）之系列5

2019-06-09
NMt
Python
 

new、getitem()、call()&callable()、doc&dict、特殊属性之__slots__、特殊方法之__len__()、迭代器与生成器

@@@@

本文是来源于雷俊丽老师python课的课件。

19.__new__

当使用”类名([实参])”创建实例对象时，Python解释器的主要处理过程包括两大步:

  1. 调用特殊方法__new__()创建实例对象。
    首先会查找该类对象是否实现了特殊方法__new__ ()，如果没有实现，则去其父类中依次查找，直到类对象object。
  2. 调用特殊方法__init__()对创建的实例对象进行初始化。
    __new__()返回的实例对象会作为实参被自动传递给__init__()的第一个形参self。
class Parent(object):
    def __new__(cls, *grgs, **kwargs):
        print("父类", id(cls))
        obj = super().__new__(cls)
        print("创建的实例", id(obj))
        return obj


class Child(Parent):
    def __init__(self, name):
        print("子类__init__()", id(self))
        self.name = name


child = Child("mike")
[out]
父类 2600992705016
创建的实例 2601027697184
子类__init__() 2601027697184

print(id(Parent), id(Child), id(child))
[out]  
2600992721064 2600992705016 2601027697184

子类地址传给父类，返回实例化的对象child，

20.__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, value):
        del self.data[key]


md = MyDict()
md["one"] = 18
md["two"] = 32
print(md.data)
[out]
{'one': 18, 'two': 32, 'two': 32}

21.__call__() & callable()

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

class MyClass(object):
    def __call__(self, *args, **kwargs):
        print(args, kwargs)


mc = MyClass()
mc(12, 23, y=12, x=99)
[out]
(12, 23) {'y': 12, 'x': 99}

内置函数callable用于判断指定对象是否是可调用的。

除了函数对象是可调用的之外，对于实现了特殊方法__call__()的类对象，其实例对象也是可调用的。

callable(mc)
[out]
True

实现了特殊方法__call__()的类对象，其实例对象也是可调用的。

22.__doc__ & __dict__

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

一、什么是类对象的文档字符串（docstring）

与函数的文档字符串类似，位于类对象的第一行的字符串被称为类对象的文档字符串，通常用三个引号表示。

类对象的文档字符串是对类对象的功能的简要描述。

二、访问类对象的文档字符串

通过类对象的特殊属性__doc__可以访问类对象的文档字符串。

调用内置函数help()得到的帮助信息中会包含类对象的文档字符串。

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

23.特殊属性之 __slots__

python 是动态语言，所以，在创建对象之后，可以对其动态的绑定属性和方法。

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

class MyClass(object):
    __slots__ = ('attr1', 'do_sth1')

mc = MyClass()
mc.attr1 = 18
print(mc.attr1)
[out]
18

mc.attr2 = 56
[out]
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-10-3306c77433c9> in <module>
----> 1 mc.attr2 = 56

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

def do_sth1(self):
    print('do_sth1')


from types import MethodType

mc.do_sth1 = MethodType(do_sth1, mc)

mc.do_sth1()
[out]
do_sth1

def do_sth2(self):
    print('do_sth2')

mc.do_sth2 = MethodType(do_sth2, mc)
[out]
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-12-e6d1c7abe0a1> in <module>
----> 1 mc.do_sth2 = MethodType(do_sth2, mc)

NameError: name 'do_sth2' is not defined

默认情况下，访问实例对象的属性是通过访问该实力对象的特殊属性__dict__来实现的。

e.g. 访问obj.x其实访问的是obj.__dict__['x']

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

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

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

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

24.特殊方法之 __len__()

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

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

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

class MyClass(object): 
    pass

print(len(MyClass()))
[out]
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-16-5496185e655d> in <module>
      2     pass
      3 
----> 4 print(len(MyClass()))

TypeError: object of type 'MyClass' has no len()

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

class MyClass(object):
    def __len__(self):
	    return 18

print(len(MyClass()))
[out]
18

25.迭代器与生成器

生成器

#列表推导式：
[i for i in range(8)]
[out]
[0, 1, 2, 3, 4, 5, 6, 7]

#生成器表达式：
(i for i in range(8))
[out]
<generator object <genexpr> at 0x000002403EB20620>

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

  1. 多次调用内置函数next()，每次调用都返回生成器的下一个元素，直到抛出异常StopIteration时表示没有更多元素了。
  2. 使用for-in语句对生成器进行迭代，这样就不需要关心异常StopIteration了。

生成器中保存的并不是其对应的所有元素，而是如何推算出所有元素的算法。将生成器用于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)
[out]
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

fib(6)
[out]
<generator object test at 0x000001837A277D00>

迭代器

可以用于for-in语句的对象被称为可迭代(Iterable)对象。

例如：range、列表、元组、字符串、字典、集合、生成器都是可迭代对象。

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

from collections import Iterable

print(isinstance([1, 2, 3], Iterable))
[out]
True

print(isinstance((i * i for i in range(1, 7)), Iterable))
[out]
True

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

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

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

L = [1, 2, 3]
next(L)
[out]
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-1-27940d533bee> in <module>
      1 L = [1, 2, 3]
----> 2 next(L)

TypeError: 'list' object is not an iterator

from collections import Iterator

print(isinstance(L, Iterator))
[out]
False

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

iter_L = iter(L)

print(isinstance(iter_L, Iterator))
[out]
True

print(next(iter_L))
[out]
1

如果一个对象同时实现了特殊方法__iter__()和__next__(), 那么该对象也被称为迭代器对象。如果将该对象用于for-in语句，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)
[out]
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__()。

yield与return

在生成器中，如果没有return，则默认执行到函数完毕时返回Stop Iteration。这一点特征在讲生成器运行机制的时候，已经有所体现。但是，如果在生成器中遇到return，那么程序会直接抛出Stop Iteration异常终止迭代。示例代码如下：

def test():
    n = 0
    while n < 10:
        yield n
        n += 2
        return 

a = test()
print(a)

[out]
<generator object test at 0x000001572A886830>

next(a)
[out]
0

next(a)
[out]
Traceback (most recent call last):

  File "<ipython-input-87-15841f3f11d4>", line 1, in <module>
    next(a)

StopIteration: 1

注：如果return后返回一个值，这个值不是程序的返回值，而是Stop Iteration异常的说明。

转载请注明：南梦婷的博客 » 点击阅读原文

Similar Posts

上一篇 面向对象编程（OOP）之系列4

下一篇 IDEA安装教程

Comments

Content