• itertools常用函数


    Python 内置的 itertools 模块包含了一系列用来产生不同类型迭代器的函数或类,这些函数的返回都是一个迭代器,我们可以通过 for 循环来遍历取值,也可以使用 next() 来取值。

    itertools模块提供了一下三种类型的迭代器

    • 无穷迭代器:生成一个无限序列,比如像自然数1,2,3,4......
    • 有限迭代器:接收一个或多个序列(可迭代对象)作为参数,进行组合、分组或过滤等;
    • 组合生成器:序列(可迭代对象)的排序、组合等运算。

    无穷迭代器

    1.count(firstval=0,step=1):

    接收两个参数,创建一个以firstval为起始,step为步长的无限序列,默认下这两个参数分别为0,1

    import itertools
    #什么都没传,默认参数
    nums=itertools.count()
    for i in nums:
        if i >6:
            break
        print(i)
        
    #count()传入两个参数,起始值,和步长
    nums=itertools.count(2,3)
    for i in nums:
        if i>10:
            break
        print('i',i)
    View Code

    2.cycle(iterable):

    创建一个迭代器,返回iterable中所有元素并保存一个副本,当取玩iterable中所有元素,返回副本中所有元素,无限重复

    #cycle()用于对itertools中的元素反复循环
    import itertools
    cycle_strings=itertools.cycle('ABC')
    k=0
    for i in cycle_strings:
        k+=1
        if k>7:
            break
        print(i)
    
    #输出
    # A
    # B
    # C
    # A
    # B
    # C
    # A
    View Code

    3.repeat(object[,times]):

    创建一个迭代器,不断重复object,若设置了times,则将object重复times次,否则无限循环重复

    #反复生成object,若给定times,则重复次数为times,否则为无限次
    import itertools
    for item in itertools.repeat('hello world',3):
        print(item)
        
    # 输出
    # hello world
    # hello world
    # hello world
    View Code

    有限迭代器

    1.accumulate(iterable[,func]):

    生成一个迭代器,若没有指定func这默认将iterable中各个部分进行累加

    from itertools import accumulate
    import operator
    a=[1,2,3,4,5]
    print(list(accumulate(a)))
    #输出[1, 3, 6, 10, 15],
    print(list(accumulate(a,operator.mul)))
    #输出[1, 2, 6, 24, 120]
    View Code

    2.chain(iter1,iter2,...):

    可以将多个iter1,iter2...中的元素进行连接输出

    from itertools import chain
    
    for item in chain([1,2,3],['a','b','c','d']):
        print(item)
    # 1
    # 2
    # 3
    # a
    # b
    # c
    # d
    View Code

    3.compress(data,selectors):

    创建一个迭代器,返回经selectors进行真值测试后为True相应位置的值,若输入两个参数长短不一,那么在按照短的进行输出。

    from itertools import compress
    list(compress("ABCDE",[1,-1,1,0,1,1,1,1]))
    # ['A', 'B', 'C', 'E']
    View Code

    4.dropwhile(predicate,iterable):

    创建一个迭代器,若predicate为true,丢弃iterable中相应位置的元素,这相当于一个元素筛选过程。

    from itertools import dropwhile
    list(dropwhile(lambda x :x<5,[1,3,6,2,1,6]))
    # [6, 2, 1, 6]
    View Code

    5.filterfalse(predicate,iterable):

    只返回iterable中predicate为False的元素,如果predicate为None,返回真值测试为false的元素。

    from itertools import filterfalse
    print(list(filterfalse(None,range(1,10))))
    #[]
    print(list(filterfalse(lambda x: x%2,range(1,10))))
    #[2, 4, 6, 8]
    View Code

    6.groupby(iterable,key=None):

    返回iterable中连续的键和组,key 是一个计算元素键值函数。如果未指定或为 Nonekey 缺省为恒等函数(identity function),返回元素不变。一般来说,iterable 需用同一个键值函数预先排序。

    from itertools import groupby
    for key,value_iter in groupby('aaabbbbaaccd'):
        print(key,":",list(value_iter))
    print('-------------------------------')
    data=['a','bb','ccc','dd','eeee','f']
    for key,value_iter in groupby(data,len):
        print(key,":",list(value_iter))
        
    # a : ['a', 'a', 'a']
    # b : ['b', 'b', 'b', 'b']
    # a : ['a', 'a']
    # c : ['c', 'c']
    # d : ['d']
    # -------------------------------
    # 1 : ['a']
    # 2 : ['bb']
    # 3 : ['ccc']
    # 2 : ['dd']
    # 4 : ['eeee']
    # 1 : ['f']
    View Code

    7.islice(iterable,stop)或islice(iterable,start,stop[,step]):

    相当于切片

    from itertools import islice
    print(list(islice([10,6,2,8,1,3,9],5)))#选择前5个元素,包括第五个
    #[10, 6, 2, 8, 1]
    print(list(islice([10,6,2,8,1,3,9],1,5)))
    # [6, 2, 8, 1]
    View Code

    8.startmap(func,iterable):

    创建一个迭代器,使用从可迭代对象中获取的参数来计算该函数。当参数对应的形参已从一个单独可迭代对象组合为元组时(数据已被“预组对”)可用此函数代替 map()。

    from itertools import starmap
    list(starmap(pow,[(2,5),[3,2],[10,3]]))
    # [32, 9, 1000]
    View Code

    9.takewhile(predicate,iterable):

    创建一个迭代器,只要 predicate 为真就从可迭代对象中返回元素

    from itertools import takewhile
    list(takewhile(lambda x:x<5,[1,2,3,6,2,1]))
    # [1, 2, 3]
    View Code

    10.tee(iterable,n=2):

    从一个可迭代对象中返回 n 个独立的迭代器

    from itertools import tee
    iter1 = tee('abcde')
    for key,item in enumerate(iter1):
        print(list(item))
    # ['a', 'b', 'c', 'd', 'e']
    # ['a', 'b', 'c', 'd', 'e']
    View Code

    11.zip_longest(*iterables,fillvalue=None):

    创建一个迭代器,从每个可迭代对象中收集元素。如果可迭代对象的长度未对齐,将根据 fillvalue 填充缺失值。迭代持续到耗光最长的可迭代对象。

    from itertools import zip_longest
    list(zip_longest('a','bbbb','dabcfd',fillvalue='-'))
    # 输出:
    # [('a', 'b', 'd'),
    #  ('-', 'b', 'a'),
    #  ('-', 'b', 'b'),
    #  ('-', 'b', 'c'),
    #  ('-', '-', 'f'),
    #  ('-', '-', 'd')]
    View Code

    组合生成器

    1.product(*iterables,repeat=1):

    可迭代对象输入的笛卡儿积。用于求解多个可迭代对象的笛卡尔积。与嵌套for循环等价。其中,repeat 是一个关键字参数,用于指定重复生成序列的次数。

    from itertools import product
    for item in product('ab','c'):
        print(item)
    # ('a', 'c')
    # ('b', 'c')
    
    print(list(product('ab','c',repeat=2)))
    
    # [('a', 'c', 'a', 'c'), ('a', 'c', 'b', 'c'), ('b', 'c', 'a', 'c'), ('b', 'c', 'b', 'c')]
    View Code

    2.permutations(iterable,r=None):

    连续返回由 iterable 元素生成长度为 r 的排列。

    如果 r 未指定或为 None ,r 默认设置为 iterable 的长度,这种情况下,生成所有全长排列。

    排列依字典序发出。因此,如果 iterable 是已排序的,排列元组将有序地产出。

    即使元素的值相同,不同位置的元素也被认为是不同的。如果元素值都不同,每个排列中的元素值不会重复。

    from itertools import permutations
    print(list(permutations('ABC',2)))
    # [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
    list(permutations('ABC'))
    # [('A', 'B', 'C'),
    #  ('A', 'C', 'B'),
    #  ('B', 'A', 'C'),
    #  ('B', 'C', 'A'),
    #  ('C', 'A', 'B'),
    #  ('C', 'B', 'A')]
    View Code

    3.combinations(iterable,r):

    返回由输入 iterable 中元素组成长度为 r 的子序列。

    组合按照字典序返回。所以如果输入 iterable 是有序的,生成的组合元组也是有序的。

    即使元素的值相同,不同位置的元素也被认为是不同的。如果元素各自不同,那么每个组合中没有重复元素。

    from itertools import combinations,permutations
    
    print("permutations:",list(permutations('ABC',2)))
    print("combinations:",list(combinations("ABC",2)))
    
    # permutations: [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
    # combinations: [('A', 'B'), ('A', 'C'), ('B', 'C')]
    View Code

    4.combinations_with_replacement(iterable, r)

    返回由输入 iterable 中元素组成的长度为 r 的子序列,允许每个元素可重复出现。

    组合按照字典序返回。所以如果输入 iterable 是有序的,生成的组合元组也是有序的。

    不同位置的元素是不同的,即使它们的值相同。因此如果输入中的元素都是不同的话,返回的组合中元素也都会不同。

    from itertools import combinations_with_replacement,permutations
    
    print('permutations:',list(permutations('ABC',2)))
    print('combinations_with_replacement:',list(combinations_with_replacement("ABC",2)))
    
    # permutations: [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
    # combinations_with_replacement: [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
    View Code
  • 相关阅读:
    学习Linux shell脚本中连接字符串的方法
    使用 ffmpeg 转换视频格式
    一点不懂到小白的linux系统运维经历分享
    linux利用scp远程上传下载文件/文件夹
    angular ui-select
    JavaScript sort()方法
    js性能优化
    layer弹出层
    JS复制对象
    某天修改了啥bat批处理
  • 原文地址:https://www.cnblogs.com/2019zjp/p/13231686.html
Copyright © 2020-2023  润新知