python 设计模式之 -- 迭代模式

淡淡的烟草味﹌ 2023-07-01 08:40 3阅读 0赞

### 前言 ###

去年买了一本《图解设计模式》，是用 java 写的，今年不写 java了，已经入了python 的坑，现在打算把书拿起来研读，把里面的 java 代码全部转成 python，这样设计模式基本可以入门了。如果大家对设计模式感兴趣的话，可以买一本看看，不过程序员的经典之作还是 GoF（the gang of four），翻译成中文 “四人帮”，最开始就是四个人的论文整合的，不得不说老外起名字很有特点。

#### 1.为啥用迭代 ####

萌新程序猿一般都对设计模式不大感冒，项目不大的话压根就用不上。迭代模式的意义就是降低内存，你建了10个对象都存 list，一点问题没有，1000万个对象貌似对内存有点压力了，所以迭代一般都涉及稍微大点的项目。

#### 2.初识迭代 ####

迭代就是建一个对象，然后不断的用 next 方法获取里面的数据，听起来和列表很像的，但是列表是占内存的，可以改造一下列表让它变成迭代器，如下：

import sys
    
    if __name__ == '__main__':
        list_ = []
        list_iter = iter(list_)
        for i in xrange(100000):
            list_.append(i)
        print 'list size:', sys.getsizeof(list_)
        print type(list_)
        print 'list iter size:', sys.getsizeof(list_iter)
        print type(list_iter)
        count = 0
        for i in list_iter:
            print i
            count = count + 1
            if count == 2:
                break

结果：

list size: 824464
    <type 'list'>
    list iter size: 56
    <type 'listiterator'>
    0
    1

首先说一下 sys.getsizeof() 函数（单位byte），它是获取对象占用内存的（计算方式有不精确的地方，但是整体上没有大问题）  
我们创建了10万个数字放到列表里面，总共占内存 824464，把列表转成迭代器以后占比只有 56，不及万分之一。  
这是调用 python 已有的方式转成迭代器，如果对象比较复杂不能用已有的方法怎么办，就需要自己建一个迭代器。

#### 2.实现迭代器 ####

python 中迭代器有两个关键函数，如下，实现这两个函数就可以了

__iter__	用于生成迭代器
    next		用于获取遍历获取内容

给大家举一个普遍的例子，几乎在所有的迭代模式里面都会有这个例子

import sys
    
    class MyIter(object):
        def __init__(self, n):
            self.index = 0
            self.n = n
    
        def __iter__(self):
            return self
    
        def next(self):
            if self.index < self.n:
                value = self.index ** 2
                self.index += 1
                return value
            else:
                raise StopIteration()
    
    if __name__ == '__main__':
        my_iter = MyIter(100000000)
        print 'my_iter size:', sys.getsizeof(my_iter)
        print type(my_iter)
        print my_iter.next()
        print my_iter.next()

结果：

my_iter size: 56
    <class '__main__.MyIter'>
    0
    1

我们创建了一个有1亿数据的迭代对象，其内存占比只有 56 （其实不止56，可能400左右，具体可以把迭代类的隐藏函数内存占比都加起来，但是400仍然很小），如果建1亿的对象存起来，内存肯定达到 M 单位，所以迭代类很省空间。

#### 3.迭代类 ####

其实看上面那个例子是有点懵的，例子很简单，有时候搞不懂咋变换使用，所以下面建一个类，然后把类封装成迭代类，这样好看懂一些。  
首先，建一个 Book 类，里面写一些需要的操作函数，get 等。

class Book(object):
        def __init__(self, name, page):
            self.name = name
            self.page = page
    
        def get_name(self):
            return self.name
    
        def get_page(self):
            return self.page

把Book类当内容主体，实现迭代有两种方式：  
第一种借助已有的迭代生成器工具类，例如1中的 listiterator，另外还有 itertools、enumerate、map、filter等

if __name__ == '__main__':
        list_ = []
        list_iter = iter(list_)
        for i in xrange(100000):
            list_.append(Book(name=str(i), page=10))
        print type(list_iter)
        print list_iter.next().get_name()
        print list_iter.next().get_name()

结果：

<type 'listiterator'>
    0
    1

第二种是自己实现迭代类，下面这个是我仿照 java 的迭代设计模式写的：

import sys
    
    class BookShelf(object):
        book_shelf = []
        length = 0
    
        def add(self, name, page):
            self.book_shelf.append(Book(name=name, page=page))
            self.length = self.length + 1
    
        def __iter__(self):
            return self
    
        def next(self):
            if self.length > 0:
                return self.book_shelf.pop(0)
            else:
                raise StopIteration()
    
    if __name__ == '__main__':
        book_iter = BookShelf()
        for i in xrange(1000000):
            book_iter.add(name=str(i), page=11)
        print sys.getsizeof(book_iter)
        print type(book_iter)
        print book_iter.next().get_name()
        print book_iter.next().get_name()

结果：

56
    <class '__main__.BookShelf'>
    0
    1

#### 4.note ####

为了节约内存有些函数建议少用，上面在生成列表的时候用的是 xrange，为啥呢，因为xrange是一个生成器，range少用，它生成的是列表，举例说明：

import sys
    
    if __name__ == '__main__':
        a = xrange(1, 100000000, 2)
        print sys.getsizeof(a)
        print type(a)
        b = range(1, 100000000, 2)
        print sys.getsizeof(b)
        print type(b)

结果：

32
    <type 'xrange'>
    400000064
    <type 'list'>

另外，上面巴拉巴拉说那么多，其实python最好的迭代方式是用yield生成器，仔细研究一下yield用法你就会发现它存在的意义就是为了实现迭代。