Python迭代器大全

本文代码大都来源于：
http://www.wklken.me/posts/2013/08/20/python-extra-itertools.html#itertoolsisliceiterable-stop

from itertools import *
from operator import *
import os
def main():
    #itertools.count(start=0, step=1)
    '''创建一个迭代器，生成从n开始的连续整数，如果忽略n，则从0开始计算（注意：此迭代器不支持长整数）
    如果超出了sys.maxint，计数器将溢出并继续从-sys.maxint-1开始计算。'''
    print("itertools.count")
    for i in zip(count(1),['a','b','c','d']):
        print(i)

    #itertools.cycle(iterable)
    '''创建一个迭代器，对iterable中的元素反复执行循环操作，内部会生成iterable中的元素的一个副本，
    此副本用于返回循环中的重复项。'''
    print("itertools.cycle")
    i = 0
    for item in cycle(['a', 'b', 'c']):
        i += 1
        if i == 10:
            break
        print(i, item)

    #itertools.repeat(object[, times])
    '''创建一个迭代器，重复生成object，times（如果已提供）指定重复计数，如果未提供times，将无止尽返回该对象。'''
    for i in repeat('over-and-over', 5):
        print(i)

    #itertools.chain(*iterables)
    '''将多个迭代器作为参数, 但只返回单个迭代器, 它产生所有参数迭代器的内容, 就好像他们是来自于一个单一的序列.'''
    for i in chain([1, 2, 3], ['a', 'b', 'c']):
        print(i)

    #itertools.compress(data, selectors)
    '''提供一个选择列表，对原始数据进行筛选'''
    print("compress")
    for iter1 in compress('ABCDEF', [1,0,1,0,1,1]):
        print(iter1)

    #itertools.dropwhile(predicate, iterable)
    '''创建一个迭代器，只要函数predicate(item)为True，就丢弃iterable中的项，
    如果predicate返回False，就会生成iterable中的项和所有后续项。'''
    print("dropwhile")
    def should_drop(x):
        print('Testing:', x)
        return (x < 1)
    for i in dropwhile(should_drop, [-1, 0, 1, 2, 3, 4, 1, -2]):
        print('Yielding:', i)

    #itertools.groupby(iterable[, key])
    '''返回一个产生按照key进行分组后的值集合的迭代器.'''
    qs = [{'date': 1}, {'date': 2}]
    for i in [(name, list(group)) for name, group in groupby(qs, lambda p: p['date'])]:
        print(i)
    a = ['aa', 'ab', 'abc', 'bcd', 'abcde']
    for i, k in groupby(a, len):
        print(i, list(k))

    d = dict(a=1, b=2, c=1, d=2, e=1, f=2, g=3)
    di = sorted(d.items(), key=itemgetter(1))
    for k, g in groupby(di, key=itemgetter(1)):
        print(k, map(itemgetter(0), g))

    #itertools.filter(predicate, iterable)
    '''返回的是迭代器类似于针对列表的内置函数 filter() , 它只包括当测试函数返回true时的项. 它不同于 dropwhile()'''
    print("filter")
    def check_item(x):
        print('Testing:', x)
        return (x < 1)

    for i in filter(check_item, [-1, 0, 1, 2, 3, 4, 1, -2]):
        print('Yielding:', i)

    #itertools.filterfalse(predicate, iterable)
    '''和filter(函数相反 ， 返回一个包含那些测试函数返回false的项的迭代器)'''
    print("filterfalse")
    for i in filterfalse(check_item, [-1, 0, 1, 2, 3, 4, 1, -2]):
        print('Yielding:', i)

    #itertools.islice(iterable, stop)
    '''创建一个迭代器，生成项的方式类似于切片返回值： iterable[start : stop : step]，将跳过前start个项，迭代在stop所指定的位置停止，step指定用于跳过项的步幅。 与切片不同，负值不会用于任何start，stop和step， 如果省略了start，迭代将从0开始，如果省略了step，步幅将采用1.'''
    print('By tens to 100:')
    for i in islice(count(), 0, 100, 10):
        print(i)

    #itertools.imap(function, *iterables)
    '''返回一个迭代器, 它是调用了一个其值在输入迭代器上的函数, 返回结果. 它类似于内置函数 map() , 只是前者在任意输入迭代器结束后就停止(而不是插入None值来补全所有的输入).'''
    print('Doubles:')
    for i in map(lambda x: 2 * x, range(5)):
        print(i)

    print('Multiples:')
    for i in map(lambda x, y: (x, y, x * y), range(5), range(5, 10)):
        print('%d * %d = %d' % i)

    #itertools.starmap(function, iterable)
    '''创建一个迭代器，生成值func(*item),其中item来自iterable，只有当iterable生成的项适用于这种调用函数的方式时，此函数才有效。'''
    print("starmap")
    values = [(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]
    for i in starmap(lambda x, y: (x, y, x * y), values):
        print('%d * %d = %d' % i)

    #itertools.tee(iterable[, n=2])
    '''从iterable创建n个独立的迭代器，创建的迭代器以n元组的形式返回，n的默认值为2，此函数适用于任何可迭代的对象，
    但是，为了克隆原始迭代器，生成的项会被缓存，并在所有新创建的迭代器中使用，一定要注意，
    不要在调用tee()之后使用原始迭代器iterable，否则缓存机制可能无法正确工作。'''
    r = islice(count(), 5)
    i1, i2 = tee(r)

    for i in i1:
        print('i1:', i)
    for i in i2:
        print('i2:', i)

    #itertools.takewhile(predicate, iterable)
    '''和dropwhile相反,创建一个迭代器，生成iterable中predicate(item)为True的项，
    只要predicate计算为False，迭代就会立即停止。'''
    print("dropwhile")
    def should_take(x):
        print('Testing:', x)
        return (x < 2)

    for i in takewhile(should_take, [-1, 0, 1, 2, 3, 4, 1, -2]):
        print('Yielding:', i)

    #itertools.izip(*iterables)
    '''返回一个合并了多个迭代器为一个元组的迭代器. 它类似于内置函数zip(), 只是它返回的是一个迭代器而不是一个列表'''
    print("zip")
    for i in zip([1, 2, 3], ['a', 'b', 'c']):
        print(i)

    #itertools.product(*iterables[, repeat])
    '''创建一个迭代器，生成表示item1，item2等中的项目的笛卡尔积的元组，repeat是一个关键字参数，指定重复生成序列的次数。'''
    a = (1, 2, 3)
    b = ('A', 'B', 'C')
    c = product(a, b)
    for elem in c:
        print(elem)

    #itertools.permutations(iterable[, r])
    '''创建一个迭代器，返回iterable中所有长度为r的项目序列，如果省略了r，那么序列的长度与iterable中的项目数量相同： 
    返回p中任意取r个元素做排列的元组的迭代器'''
    for iter_element in permutations('ABCD', 2):
        print(iter_element)

    #itertools.combinations(iterable, r)
    '''创建一个迭代器，返回iterable中所有长度为r的子序列，返回的子序列中的项按输入iterable中的顺序排序 (不带重复)'''
    print("combinations")
    for iter_element in combinations('BACD', 2):
        print(iter_element)

    #itertools.combinations_with_replacement(iterable, r)
    '''创建一个迭代器，返回iterable中所有长度为r的子序列，返回的子序列中的项按输入iterable中的顺序排序 (带重复)'''
    print("combinations_with_replacement")
    for iter_element in combinations_with_replacement('BACD', 2):
        print(iter_element)



if __name__ == '__main__':
    main()