zoukankan      html  css  js  c++  java

  • 4.Python3标准库--算法

    （一）functools：管理函数的工具

    　　

    1.修饰符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    from functools import partial
     
     
    '''
    functools模块提供的主要工具就是partial类，可以用来包装一个有默认参数的callable对象。
    得到的对象本身就是callable，可以把它看作是原来的参数。
    '''
     
     
    # 举个栗子
    def foo(name, age, gender):
        print(name, age, gender)
     
     
    p = partial(foo, "mashiro", 16)
    p("female")  # mashiro 16 female
    '''
    可以看到p相当于是已经绑定了name和age的foo函数，name我们在传参的时候只需要传入一个gender就可以了
    这个函数的源码实现比较复杂，但是如果以简单的装饰器的方式实现就很清晰了
    '''
     
     
    def my_partial(f, name, age):
        def inner(gender):
            return f(name, age, gender)
        return inner
     
     
    p = my_partial(foo, "satori", 16)
    p("female")  # satori 16 female
    '''
    可以看到，当我调用my_partial(foo, "satori", 16)的时候，返回了inner函数
    此时的p相当于是inner，当我再调用p("female")的时候，等价于调用inner("female")
    然后将两次传入的参数，按照顺序组合起来传递给foo函数，如果不限制参数的话就是：
    def my_partial(f, *args1, **kwargs1):
        def inner(*args2, **kwargs2):
            from collections import ChainMap
            args = args1 + args2
            kwargs = dict(ChainMap(kwargs1, kwargs2))
            return f(*args, **kwargs)
        return inner
         
    所以一定要和原函数的参数顺序保持一致，如果我传入p = my_partial("mashiro", 16),此时"mashiro"会传给name，16传给age
    我再调用p(name="xxx")的话，肯定会报错的
    '''

    　　

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    from functools import partial
    import functools
     
     
    '''
    默认情况下，partial对象没有__name__属性的，如果没有这些属性，那么被修饰的函数会很难调试。
    '''
     
     
    def foo():
        # fucking
        pass
     
     
    print(foo.__name__)  # foo
    p = partial(foo)
    try:
        print(p.__name__)
    except AttributeError as e:
        print(e)  # 'functools.partial' object has no attribute '__name__'
     
     
    # 那么如何添加呢？首先增加到包装器的属性在WRAPPER_ASSIGNMENTS中定义，另外WRAPPER_UPDATES列出了要修改的值
    print("assign:", functools.WRAPPER_ASSIGNMENTS)  # assign: ('__module__', '__name__', '__qualname__', '__doc__', '__annotations__')
    print("update:", functools.WRAPPER_UPDATES)  # update: ('__dict__',)
     
    # 添加，表示从原函数将属性赋值或增加到partial对象
    functools.update_wrapper(p, foo)
    print(p.__name__)  # foo

    　　

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    from functools import partial
     
     
    '''
    可以把partial看成是一个简单的装饰器，装饰器不仅可以装饰函数，还可以装饰类，只要是callable对象，说白了只要是能加上()的都可以
    这就是Python的魅力，非常的动态。比如列表进行extend, 其实不仅仅可以extend一个列表,还可以是元组，甚至是字典，只要是iterable对象都可以。
    '''
     
     
    class A:
        def __init__(self, name, age, gender):
            self.name = name
            self.age = age
            self.gender = gender
     
        def print_info(self):
            print(f"name: {self.name}, age: {self.age}, gender: {self.gender}")
     
     
    p = partial(A, "mashiro", 16)
    a = p("female")  # 这两步等价于 a = A("mashiro", 16, "female")
    a.print_info()  # name: mashiro, age: 16, gender: female

    　　

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    from functools import partial, partialmethod
     
     
    '''
    partial返回一个可以直接使用的callable，partialmethod返回的callable则可以用做对象的非绑定方法
    '''
     
     
    # 举个例子
    def standalone(self):
        print(f"self = {self}")
     
     
    class A:
        method1 = partial(standalone)
        method2 = partialmethod(standalone)
     
     
    a = A()
    try:
        a.method1()
    except TypeError as e:
        # 由于standalone需要一个参数self，我们这里没有传，因此报错
        print(e)  # standalone() missing 1 required positional argument: 'self'
     
    # 但是我们调用method2呢？
    a.method2()  # self = <__main__.A object at 0x0000000002964588>
    '''
    得到了一个A的实例对象。
    所以，partial在哪里调用时没有区别的，必须手动显示地传递，该是几个就是几个。
    但是在类中如果使用partialmethod定义的话，那么在使用实例(a)调用的话，会自动将实例传进去。
    '''

    　　

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    from functools import wraps
     
     
    '''
    我们在知道在使用装饰器装饰完函数的时候，属性会变。比如：
    '''
     
     
    def deco(func):
        def inner(*args, **kwargs):
            return func(*args, **kwargs)
        return inner
     
     
    @deco
    def foo():
        pass
     
     
    # 函数从下到下执行，加上@deco等价于，foo = deco(foo) = inner,也就是说此时的foo不再是foo了，已经是inner了
    print(foo.__name__)  # inner
    # 那么如何在装饰的时候，还保证原来函数的信息呢
     
     
    def deco(func):
        @wraps(func)  # 只需要加上这一个装饰器即可，会自动对所修饰的函数应用update_wrapper
        def inner(*args, **kwargs):
            return func(*args, **kwargs)
        return inner
     
     
    @deco
    def bar():
        pass
     
     
    # 可以看到原来函数的信息并没有改变
    print(bar.__name__)  # bar

    　　

    2.比较

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    import functools
     
     
    '''
    在Python2中，类可以一个__cmp__()方法，它会根据这个对象小于、等于、或者大于所比较的元素而分别返回-1、0、1.
    Python2.1中引入了富比较(rich comparision)的方法。
    如：__lt__(),__gt__(),__le__(),__eq__(),__ne__(),__gt__()和__ge__()，可以完成一个比较操作并返回一个bool值。
    Python3已经废弃了__cmp__()方法。
    另外，functools提供了一些工具，从而能更容易地编写符合新要求的类，即符合Python3中新的比较需求。
    '''
     
     
    @functools.total_ordering
    class A:
        def __init__(self, val):
            self.val = val
     
        def __eq__(self, other):
            return self.val == other.val
     
        def __gt__(self, other):
            return self.val > other.val
     
     
    a1 = A(1)
    a2 = A(2)
    print(a1 < a2)
     
    '''
    这个类必须提供__eq__()和另外一个富比较方法的实现，这个修饰符会自动增加其余的方法。
    '''

    　　

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    import functools
     
    '''
    由于Python3废弃了老式的比较函数，sort()之类的函数中也不再支持cmp参数。
    对于使用了比较函数的较老的程序，可以使用cmp_to_key()将比较函数转换为一个比对键的函数，这个键用于确定元素在最终序列中的位置
    '''
     
     
    def compare_obj(a, b):
        if a < b:
            return -1
        elif a > b:
            return 1
        else:
            return 0
     
     
    l = [1, 5, 2, 11, 2, 44, 54, 5, 1]
     
    print(sorted(l, key=functools.cmp_to_key(compare_obj)))  # [1, 1, 2, 2, 5, 5, 11, 44, 54]

    　　

    3.缓存

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    import functools
     
    '''
    lru_cache()修饰符将一个函数包装在一个"最近最少使用的"缓存中。函数的参数用来建立一个散列键，然后映射到这个结果。
    后续调用如果有相同的参数，就会从这个缓存中获取值而不会再次调用这个函数。
    这个修饰符还会为函数增加方法来检查缓存的状态(cache_info)和清空缓存(cache_clear)
    '''
     
     
    @functools.lru_cache()  # 里面可以执行参数maxsize，默认是128
    def foo(a, b):
        print(f"foo({a} * {b})")
        return a * b
     
     
    print("第一次调用")
    for i in range(2):
        for j in range(2):
            foo(i, j)
    print(foo.cache_info())
     
    print(" 第二次调用")
    for i in range(3):
        for j in range(3):
            foo(i, j)
    print(foo.cache_info())
     
    print("清除缓存")
    foo.cache_clear()
    print(foo.cache_info())
     
    print(" 第三次调用")
    for i in range(2):
        for j in range(2):
            foo(i, j)
    print(foo.cache_info())
    '''
    第一次调用
    foo(0 * 0)
    foo(0 * 1)
    foo(1 * 0)
    foo(1 * 1)
    CacheInfo(hits=0, misses=4, maxsize=128, currsize=4)
     
    第二次调用
    foo(0 * 2)
    foo(1 * 2)
    foo(2 * 0)
    foo(2 * 1)
    foo(2 * 2)
    CacheInfo(hits=4, misses=9, maxsize=128, currsize=9)
    清除缓存
    CacheInfo(hits=0, misses=0, maxsize=128, currsize=0)
     
    第三次调用
    foo(0 * 0)
    foo(0 * 1)
    foo(1 * 0)
    foo(1 * 1)
    CacheInfo(hits=0, misses=4, maxsize=128, currsize=4)
    '''
    # 我们观察一下第二次调用，3 * 3应该是9次，为什么只有5次，因为第一次调用有4次执行过了，放到缓存里，因此不需要执行了

    　　

    4.reduce

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    import functools
     
    '''
    reduce这个函数无需介绍，在Python2中是内置的，但是在Python3中被移到functools下面
    '''
    l = range(100)
    print(functools.reduce(lambda x, y: x+y, l))  # 4950
    print(functools.reduce(lambda x, y: x+y, l, 10))  # 4960
    print(functools.reduce(lambda x, y: x+y, l, 100))  # 5050
     
     
    l = [1, 2, 3, 4, 5]
    print(functools.reduce(lambda x, y: x*y, l))  # 120

    　　

    5.泛型函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    import functools
     
    '''
    在类似Python的动态类型语言中，通常需要基于参数的类型完成稍有不同的操作，特别是在处理元素列表与单个元素的差别时。
    直接检查参数的类型固然很简单，但是有些情况下，行为差异可能被隔离到单个的函数中。
    对于这些情况，functools提供了singledispatch修饰符来注册一组泛型函数，可以根据函数第一个参数的类型自动切换
    '''
     
     
    @functools.singledispatch
    def myfunc(arg):
        print(f"default myfunc {arg}")
     
     
    @myfunc.register(int)
    def myfunc1(arg):
        print(f"myfunc1 {arg}")
     
     
    @myfunc.register(list)
    def myfunc2(arg):
        print(f"myfunc2 {arg}")
     
     
    myfunc("string")  # default myfunc string
    myfunc(123)  # myfunc1 123
    myfunc(["1", "2"])  # myfunc2 ['1', '2']
    '''
    可以看到使用signledispatch包装的是默认实现，在未指定其他类型特定函数的时候就用这个默认实现。
    然后使用包装的函数这里是myfunc,通过register(数据类型)进行注册，根据所传参数的类型，从而执行对应的函数
    '''

    　　

    （二）itertools：迭代器函数

    1.合并和分解迭代器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    import itertools
     
     
    '''
    chain函数可以接收多个可迭代对象(或者迭代器)作为参数，最后返回一个迭代器。
    它会生成所有输入迭代器的内容，就好像这些内容来自一个迭代器一样。
    类似于collections下的ChainMap，可以合并多个字典。chain可以合并多个可迭代对象
    '''
     
    c = itertools.chain([1, 2, 3], "abc", {"k1": "v1", "k2": "v2"})
    print(c)  # <itertools.chain object at 0x00000000029745F8>
    for i in c:
        print(i, end=" ")  # 1 2 3 a b c k1 k2
     
    print()
    # 还可以使用chain.from_iterable,参数接收多个可迭代对象组成的一个可迭代对象
    c = itertools.chain.from_iterable([[1, 2, 3], "abc", {"k1": "v1", "k2": "v2"}])
    for i in c:
        print(i, end=" ")  # 1 2 3 a b c k1 k2
     
     
    # 函数zip则是把多个迭代器对象组合到一个元组中
    name = ["古明地觉", "椎名真白", "雪之下雪乃"]
    where = ["东方地灵殿", "樱花张的宠物女孩", "春物"]
    z = zip(name, where)
    print(" ", z)  # <zip object at 0x0000000001DC03C8>
    print(list(z))  # [('古明地觉', '东方地灵殿'), ('椎名真白', '樱花张的宠物女孩'), ('雪之下雪乃', '春物')]
     
    # zip英文意思是拉链，很形象，就是把对应元素给组合起来
    # 但如果两者长度不一致怎么办？
    name = ["古明地觉", "椎名真白", "雪之下雪乃", "xxx"]
    where = ["东方地灵殿", "樱花张的宠物女孩", "春物"]
    print(list(zip(name, where)))  # [('古明地觉', '东方地灵殿'), ('椎名真白', '樱花张的宠物女孩'), ('雪之下雪乃', '春物')]
    # 可以看到，不一致的时候，当一方结束之后就停止匹配。
     
    # 如果想匹配长的，那么可以使用zip_longest,这个函数不像zip一样是内置的，它在itertools下面
    print(list(itertools.zip_longest(name, where)))  # [('古明地觉', '东方地灵殿'), ('椎名真白', '樱花张的宠物女孩'), ('雪之下雪乃', '春物'), ('xxx', None)]
    # 可以看到没有的默认赋值为None了，当然我们也可以指定填充字符
    print(list(itertools.zip_longest(name, where, fillvalue="你输入的是啥啊")))
    # [('古明地觉', '东方地灵殿'), ('椎名真白', '樱花张的宠物女孩'), ('雪之下雪乃', '春物'), ('xxx', '你输入的是啥啊')]
     
     
    # isslice返回一个迭代器，按照索引从迭代器返回所选择的元素
    num = range(20)
    # 从index=5的地方选到index=10(不包含)的地方
    s = itertools.islice(num, 5, 10)
    print(list(s))  # [5, 6, 7, 8, 9]
    #  从开头选到index=5的地方
    s = itertools.islice(num, 5)
    print(list(s))  # [0, 1, 2, 3, 4]
    # 从index=5的地方选择到index=15的地方，步长为3
    s = itertools.islice(num, 5, 15, 3)
    print(list(s))  # [5, 8, 11, 14]
    '''
    所以除了迭代器之外，
    如果只传一个参数，比如5，表示从index=0选到index=5(不包含)的地方
    如果传两个参数，比如5和10，表示从index=5选到index=10(不包含)的地方
    如果传三个参数，比如5和10和2，表示从index=5选到index=10(不包含)的地方，步长为2
    '''
    # 那么支不支持负数索引呢？答案是不支持的，因为不知道迭代器有多长，除非全部读取，可是那样的话干嘛不直接转化为列表之后再用[:]这种形式呢？
    # 之所以使用isslice这种形式，就是为了在不全部读取的情况下，也能选择出我们想要的部分，所以这种方式只支持从前往后，不能从后往前读。
     
     
    # tee()函数根据一个原输入迭代器返回多个独立、和原迭代器一模一样的迭代器(默认为两个)
    r = [1, 2, 3, 4, 5]
    i1, i2 = itertools.tee(r)
    print(list(i1))  # [1, 2, 3, 4, 5]
    print(list(i2))  # [1, 2, 3, 4, 5]

    　　

    2.转换输入

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    import itertools
     
     
    '''
    内置的map()函数返回一个迭代器，它对输入迭代器中的值调用一个函数并返回结果。
    输入迭代中的元素全部被消费时，map()函数就会停止
    '''
    l = [1, 2, 3]
    map_l = map(lambda x: str(x)+"a", l)
    print(list(map_l))  # ['1a', '2a', '3a']
     
    l1 = [(0, 5), (1, 6), (2, 7)]
    '''
    注意map里面的函数只能有一个参数，因此不可以写成以下格式
    map_l1 = map(lambda x, y: x*y, l1)
    但是可以这样
    '''
    map_l1 = map(lambda x: x[0]*x[1], l1)
    print(list(map_l1))  # [0, 6, 14]
     
    # 但是itertools下的startmap()是支持的
    l2 = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
    # 注意里面的函数的参数的参数个数是由我们后面传入对象决定的,这里每个元组显然有三个元素，所以需要三个参数
    map_l1 = itertools.starmap(lambda x, y, z: f"{x} + {y} + {z} = {x+y+z}", l2)
    print(list(map_l1))  # ['1 + 2 + 3 = 6', '4 + 5 + 6 = 15', '7 + 8 + 9 = 24']
    # map的话只能通过lambda x: x[0], x[1], x[2]这样的形式
    # starmap只能对类似于[(), (), ()]这种值进行处理,比如[1, 2, 3]使用starmap是会报错的，但是[(1, ), (2, ), (3, )]不会报错

    　　

    3.生成新值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    import itertools
     
     
    '''
    count(start=0, step=1)函数返回一个迭代器，该迭代器能够无限地生成连续的整数。
    接收两个参数：起始（默认为0）和步长（默认为1）
    等价于：
    def count(firstval=0, step=1):
        x = firstval
        while 1:
            yield x
            x += step
    '''
     
    '''
    cycle(iterable)返回一个迭代器，会无限重复里面的内容，直到内存耗尽
    '''
    c2 = itertools.cycle("abc")
    print(list(itertools.islice(c2, 0, 10)))  # ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a']
     
     
    '''
    repeat(obj, times=None),无限重复obj，除非指定times。
    '''
    print(list(itertools.repeat("abc", 3)))  # ['abc', 'abc', 'abc']

    　　

    4.过滤

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    import itertools
     
    l = [1, 2, 3, 4, 5]
    drop_l = itertools.dropwhile(lambda x: x < 3, l)
    print(list(drop_l))  # [3, 4, 5]
    take_l = itertools.takewhile(lambda x: x < 3, l)
    print(list(take_l))  # [1, 2]
    filter_l = filter(lambda x: x < 3, l)
    print(list(filter_l))  # [1, 2]
    filterfalse_l = itertools.filterfalse(lambda x: x < 3, l)
    print(list(filterfalse_l))  # [3, 4, 5]
    '''
    filter和takewhile一样，过滤出条件为True的值
    filterfalse和dropwhile一样，过滤出条件为False的值 
    '''
     
     
    # compress则提供了另一种过滤可迭代对象内容的方法。
    # 举个栗子
    condition = [True, False, True, True, False]
    data = [1, 2, 3, 4, 5]
    print(list(itertools.compress(data, condition)))  # [1, 3, 4]
    # 或者
    condition = [1, 0, "x", "x", {}]
    print(list(itertools.compress(data, condition)))  # [1, 3, 4]

    　　

    5.合并输入

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    import itertools
     
     
    '''
    accumulate函数处理输入迭代器，得到一个类似于斐波那契的结果
    '''
    print(list(itertools.accumulate(range(5))))  # [0, 1, 3, 6, 10]
    print(list(itertools.accumulate("abcde")))  # ["a", "ab", "abc", "abcd", "abcde"]
    # 所以这里的相加还要看具体的含义
     
    try:
        print(list(itertools.accumulate([[1, 2], (3, 4)])))
    except TypeError as e:
        print(e)  # can only concatenate list (not "tuple") to list
        # 这里就显示无法将列表和元组相加
     
     
    # 当然也可以自定义
    data = [1, 2, 3, 4, 5]
    method = lambda x, y: x*y
    print(list(itertools.accumulate(data, method)))  # [1, 2, 6, 24, 120]
    # 可以看到这里的结果就改变了
     
     
    '''
    product则是会将多个可迭代对象组合成一个笛卡尔积
    '''
    print(list(itertools.product([1, 2, 3], [2, 3])))  # [(1, 2), (1, 3), (2, 2), (2, 3), (3, 2), (3, 3)]
     
     
    '''
    permutations函数从输入迭代器生成元素，这些元素以给定长度的排列形成组合。默认会生成所以排列的全集
    '''
    data = [1, 2, 3, 4]
    print(list(itertools.permutations(data)))
    '''
    [(1, 2, 3, 4), (1, 2, 4, 3), (1, 3, 2, 4), (1, 3, 4, 2), (1, 4, 2, 3), (1, 4, 3, 2),
    (2, 1, 3, 4), (2, 1, 4, 3), (2, 3, 1, 4), (2, 3, 4, 1), (2, 4, 1, 3), (2, 4, 3, 1),
    (3, 1, 2, 4), (3, 1, 4, 2), (3, 2, 1, 4), (3, 2, 4, 1), (3, 4, 1, 2), (3, 4, 2, 1),
    (4, 1, 2, 3), (4, 1, 3, 2), (4, 2, 1, 3), (4, 2, 3, 1), (4, 3, 1, 2), (4, 3, 2, 1)]
    '''
     
    print(list(itertools.permutations(data, 2)))
    # [(1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3)]
     
     
    # permutations只要顺序不同就看做一种结果，combinations则保证只要元素相同就是同一种结果
    data = "abcd"
    print(list(itertools.combinations(data, 3)))  # [('a', 'b', 'c'), ('a', 'b', 'd'), ('a', 'c', 'd'), ('b', 'c', 'd')]
    # 尽管combinations不会重复单个的输入元素，但是有时候可能也需要考虑包含重复元素的组合。
    # 对于这种情况，可以使用combination_with_replacement
    print(list(itertools.combinations_with_replacement(data, 3)))
    '''
    [('a', 'a', 'a'), ('a', 'a', 'b'), ('a', 'a', 'c'), ('a', 'a', 'd'), ('a', 'b', 'b'),
    ('a', 'b', 'c'), ('a', 'b', 'd'), ('a', 'c', 'c'), ('a', 'c', 'd'), ('a', 'd', 'd'),
    ('b', 'b', 'b'), ('b', 'b', 'c'), ('b', 'b', 'd'), ('b', 'c', 'c'), ('b', 'c', 'd'),
    ('b', 'd', 'd'), ('c', 'c', 'c'), ('c', 'c', 'd'), ('c', 'd', 'd'), ('d', 'd', 'd')]
    '''

    　　

    （三）operator：内置操作符的函数接口

    1
    2
    3
    4
    5
    6
    7
    8
    import operator
     
     
    '''
    使用迭代器编程时，有时需要为简单的表达式创建小函数。
    operator模块提供了一些函数，可以对应标准API中内置的算术、比较和其他操作。
    注意：operator中提供的操作，都可以通过lambda函数实现，就我个人而言更喜欢lambda函数
    '''

    　　

    1.逻辑操作

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    import operator
     
     
    '''
    有些函数可以用来确定一个值得相应布尔值，将其取反以创建相反的布尔值，以及比较对象以查看它们是否相等
    '''
    a = -1  # 为真
    b = 5  # 为真
     
    # not为关键字，所以是not_,判断值是否为假。由于a=-1为真，不为假，所以是False
    print(operator.not_(a))  # False
    # truth，判断值是否为真
    print(operator.truth(b))  # True
    # is_, 等价于a is b
    print(operator.is_(a, b))  # False
    # is_not,等价于a is not b
    print(operator.is_not(a, b))  # True

    　　

    2.比较操作符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    import operator
     
     
    '''
    支持所有的富比较操作符
    '''
    a = -1
    b = 5
    for func in ("lt", "le", "gt", "ge", "eq", "ne"):  # <, <=, >, >=, ==, !=
        print(f"{func}(a, b): {getattr(operator, func)(a, b)}")
    '''
    lt(a, b): True
    le(a, b): True
    gt(a, b): False
    ge(a, b): False
    eq(a, b): False
    ne(a, b): True
    '''

    　　

    3.算术操作符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    import operator
     
     
    '''
    支持处理数字值的算术操作符
    '''
    a = -1
    b = 5.0
    c = 2
    d = 6
     
    print("abs(a): ", operator.abs(a))
    print("neg(a): ", operator.neg(a))
    print("neg(b): ", operator.neg(b))
    print("pos(a): ", operator.pos(a))
    print("pos(b): ", operator.pos(b))
    print("add(a, b): ", operator.add(a, b))
    print("floordiv(a, b): ", operator.floordiv(a, b))
    print("floordiv(a, c): ", operator.floordiv(a, c))
    print("mod(a, b): ", operator.mod(a, b))
    print("mul(a, b): ", operator.mul(a, b))
    print("pow(c, d): ", operator.pow(c, d))
    print("sub(b, a): ", operator.sub(b, a))
    print("truediv(a, b): ", operator.truediv(a, b))
    print("truediv(d, c): ", operator.truediv(d, c))
    print("and_(c, d): ", operator.and_(c, d))
    print("invert(c): ", operator.invert(c))
    print("lshift(c, d): ", operator.lshift(c, d))
    print("or_(c, d): ", operator.or_(c, d))
    print("rshift(d, c): ", operator.rshift(d, c))
    print("xor(c, d): ", operator.xor(c, d))
     
    '''
    a = -1
    b = 5.0
    c = 2
    d = 6
     
    abs(a):  1
    neg(a):  1 
    neg(b):  -5.0
    pos(a):  -1
    pos(b):  5.0
    add(a, b):  4.0
    floordiv(a, b):  -1.0
    floordiv(a, c):  -1
    mod(a, b):  4.0
    mul(a, b):  -5.0
    pow(c, d):  64
    sub(b, a):  6.0
    truediv(a, b):  -0.2
    truediv(d, c):  3.0
    and_(c, d):  2
    invert(c):  -3
    lshift(c, d):  128
    or_(c, d):  6
    rshift(d, c):  1
    xor(c, d):  4
    '''

    　　

    4.序列操作符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    import operator
     
     
    '''
    处理序列的操作符可以分为四组：建立序列，搜索元素，访问内容，以及从序列删除元素
    '''
    a = [1, 2, 3]
    b = ['a', 'b', 'c']
    print("a =", a)
    print("b =", b)
    print("concat(a, b): ", operator.concat(a, b))
    print("contains(a, 1): ", operator.contains(a, 1))
    print("contains(b, 'd'): ", operator.contains(b, 'd'))
    print("countOf(a, 1): ", operator.countOf(a, 1))
    print("countOf(b, 'd'): ", operator.countOf(b, 'd'))
    print("indexOf(a, 5): ", operator.indexOf(a, 1))
    print("getitem(b, 1): ", operator.getitem(b, 1))
    print("getitem(b slice(1, 3): ", operator.getitem(b, slice(1, 3)))
    print("setitem(b, 1, 'd'): ", end=' ')
    operator.setitem(b, 1, 'd')
    print(b)
    print("setitem(a, slice(1, 3), [4, 5]): ", end=' ')
    operator.setitem(a, slice(1, 3), [4, 5])
    print(a)
     
    print("delitem(b, 1)", end=' ')
    operator.delitem(b, 1)
    print(b)
    print("delitem(a, slice(1, 3): ", end=' ')
    operator.delitem(b, slice(1, 3))
    print(a)
    # 其中的一些操作（setitem()和delitem()）会原地修改序列，返回的是None
    '''
    a = [1, 2, 3]
    b = ['a', 'b', 'c']
    concat(a, b):  [1, 2, 3, 'a', 'b', 'c']
    contains(a, 1):  True
    contains(b, 'd'):  False
    countOf(a, 1):  1
    countOf(b, 'd'):  0
    indexOf(a, 5):  0
    getitem(b, 1):  b
    getitem(b slice(1, 3):  ['b', 'c']
    setitem(b, 1, 'd'):  ['a', 'd', 'c']
    setitem(a, slice(1, 3), [4, 5]):  [1, 4, 5]
    delitem(b, 1) ['a', 'c']
    delitem(a, slice(1, 3):  [1, 4, 5]
    '''
     
    # 个人觉得这些都没有什么乱用，可以直接实现的，没必要使用这个库

    　　

    5.原地操作符

    略

    6.排序

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    import operator
     
     
    '''
    这一节书上没有，是我自己加的。个人觉得这个库只有在这一方面会有用。
    '''
    l = [
        [1, 3],
        [7, 4],
        [6, 2],
        [3, 5]
    ]
    # 现在我要将这个列表进行排序，怎么排呢？里面里面列表的第一个元素的顺序从小到大排
    # 也就是说，排完序之后应该是这样的, [[1, 3], [3, 5], [6, 2], [7, 4]]
    l.sort(key=operator.itemgetter(0))
    # 按照key来排序，itemgetter(0)，表示获取各自索引为0的元素，进行比较
    print(l)  # [[1, 3], [3, 5], [6, 2], [7, 4]]
     
     
    # 但是我们可以使用lambda函数来实现，而且还可以实现更加复杂的效果
    l1 = [
        [1, 3],
        [7, 4],
        [6, 2],
        [3, 5]
    ]
    l1.sort(key=lambda x: x[0])
    print(l1)  # [[1, 3], [3, 5], [6, 2], [7, 4]]
     
     
    l2 = [-3, -5, 3, -9, 8, 2]
    # 对l2我想这样排序，首先按照正负数排序，负数排左边，正数排右边。
    # 然后按照绝对值得大小排， 绝对值大的排左边，小的排右边
    # 也就是说排完之后应该是这样的，[-9, -5, -3, 8, 3, 2]
    l2.sort(key=lambda x: (x > 0, ~abs(x)))
    print(l2)  # [-9, -5, -3, 8, 3, 2]
    # 因此可以看到这个x代表的就是序列里面的元素
    # 如果是字典的话，那么x就是字典里面的key
     
    d = {"a": 4, "c": 3, "b": 2}
    # 可是字典没有sort，我们如何验证呢？
    import heapq
    # 按照value选择两个最大的
    # 参数：选择几个，从哪里选择，按照什么规则去选择
    print(heapq.nlargest(2, d, key=lambda x: d[x]))  # ['a', 'c']
     
     
    '''
    个人总结一下哈，我个人觉得这个库是真的没有什么用，完全可以使用其他的方法代替，而且更容易理解。
    当然也可能是我能力不够，这个库的更高级的用法我没有看到(雾)
    '''

    　　

    （四）contextlib：上下文管理器工具

    1
    2
    3
    4
    5
    6
    import contextlib
     
     
    '''
    contextlib模块包含的工具用于处理上下文管理器和with语句
    '''

    1.上下文管理器API

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    import contextlib
     
     
    '''
    上下文管理器(context manager)负责管理一个代码块中的资源，会在进入代码块时创建资源，然后再退出代码后清理这个资源。
    比如：文件就支持上下文管理器API，可以确保文件读写后关闭文件。
    with open("xxx") as f:
        f.read()
    '''
     
     
    # 那么这是如何实现的呢？我们可以手动模拟一下
    class Open:
     
        def __init__(self, filename, mode='r', encoding=None):
            self.filename = filename
            self.mode = mode
            self.encoding = encoding
     
        def __enter__(self):
            print("__enter__,有了这个就可以使用with Open() as xx语句，这里的xx就是我return的内容")
            return self
     
        def read(self):
            print(f"文件进行读操作,读取文件：{self.filename}, 模式：{self.mode}, 编码：{self.encoding}")
     
        def __exit__(self, exc_type, exc_val, exc_tb):
            print("__exit__,我是用来清理资源的，当操作执行完毕之后就会执行我，比如：关闭文件")
     
     
    with Open("1.xxx") as f:
        f.read()
    '''
    __enter__,有了这个就可以使用with Open() as xx语句，这里的xx就是我return的内容
    文件进行读操作,读取文件：1.xxx, 模式：r, 编码：None
    __exit__,我是用来清理资源的，当操作执行完毕之后就会执行我，比如：关闭文件
    '''

    　　

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    import contextlib
     
     
    # 相较于try:finally语法，结合上下文管理器和with语句是一种更加紧凑的写法，因为__exit__这个方法总是会被调用的，即使产生了异常
     
    class Open:
     
        def __init__(self, filename, mode='r', encoding=None):
            self.filename = filename
            self.mode = mode
            self.encoding = encoding
     
        def __enter__(self):
            return 123
     
        def __exit__(self, exc_type, exc_val, exc_tb):
            # 注意到这里有三个参数，使用pycharm的时候，会很智能地自动帮我们加上去
            print(exc_type)
            print(exc_val)
            print(exc_tb)
            return True
     
     
    with Open("1.xx") as f:
        print(f)
    '''
    123
    None
    None
    None
    '''
     
    with Open("1.xx") as f:
        print(f)
        1 / 0
        print(123)
        print(456)
        print(789)
    print("你猜我会被执行吗？")
    '''
    123
    <class 'ZeroDivisionError'>
    division by zero
    <traceback object at 0x0000000009EDD848>
    你猜我会被执行吗？
    '''
     
    '''
    可以看到当我们程序没有出错的时候，打印的值全为None。一旦with语句里面出现了异常，那么会立即执行__exit__函数。
    里面的参数就是：异常的类型，异常的值，异常的信息栈。
    因此：当with语句结束之后会调用__exit__函数，如果with语句里面出现了错误则会立即调用__exit__函数。
    但是__exit__函数返回了个True是什么意思呢？
    当with语句里面出现了异常，理论上是会报错的，但是由于要执行__exit__函数，所以相当于暂时把异常塞进了嘴里。
    如果__exit__函数最后返回了一个布尔类型为True的值，那么会把塞进嘴里的异常吞下去，程序不报错正常执行。如果返回布尔类型为False的值，会在执行完__exit__函数之后再把异常吐出来，引发程序崩溃。
    这里我们返回了True，因此程序正常执行，最后一句话被打印了出来。
    但是1/0这句代码后面的几个print却没有打印，为什么呢？
    因为上下文管理执行是有顺序的，
    with Open("1.xxx") as f:
        code1
        code2
    先执行Open函数的__init__函数，再执行__enter__函数，把其返回值给交给f，然后执行with语句里面的代码，最后执行__exit__函数。
    只要__exit__函数执行结束，那么这个with语句就算结束了。
    而with语句里面如果有异常会立即进入__exit__函数，因此异常语句后面的代码是无论如何都不会被执行的。
    '''

    　　

    2.上下文管理器作为函数修饰符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    import contextlib
     
    '''
    类ContextDecorator增加了对常规上下文管理器类的支持，因此不仅可以作为上下文管理器，也可以作为函数修饰符
    '''
     
     
    class Context(contextlib.ContextDecorator):
        def __init__(self, how_used):
            self.how_used = how_used
            print(f"__init__({self.how_used})")
     
        def __enter__(self):
            print(f"__enter__({self.how_used})")
            return self
     
        def __exit__(self, exc_type, exc_val, exc_tb):
            print(f"__exit__({self.how_used})")
     
     
    # 一旦继承了ContextDecorator这个类，那么便可以作为装饰器去装饰。
    # 说白了Context("as decorator")返回了Context的一个实例对象，理论上是不可调用的，但是父类实现了call方法。
    # 因此如果我们自己实现了一个定义了__call__方法的类，让Context去继承，也是可以达到类似的效果
    @Context("as decorator")
    def func(message):
        print(message)
        '''
        __init__(as decorator)
        '''
     
     
    # 当我执行执行func的时候，此时的func已经不再是原来的那个func了
    # func = self(func),从而调用Context的__call__方法，可是Context没有这个方法，那么它的父类肯定有。
    # 我们看看contextlib.ContextDecorator的源码,去掉了注释
    '''
    class ContextDecorator(object):
     
        def _recreate_cm(self):
            return self
     
        def __call__(self, func):
            @wraps(func)
            def inner(*args, **kwds):
                with self._recreate_cm():
                    return func(*args, **kwds)
            return inner
     
    可以看到首先@Context("as decorator")会执行Context的__init__方法，打印__init__(as decorator)，得到实例对象self
    此时等价于@self, -->func = self(func)，执行__call__方法，-->func = inner
    当执行inner的时候，会先调用__enter__方法，然后执行inner，最后执行__exit__方法
    '''
     
    func("doing work i the wrapped function")
     
     
    # 这个无需解释
    with Context("as contetx manager"):
        print("doing work in the context")
        '''
        __init__(as contetx manager)
        __enter__(as contetx manager)
        doing work in the context
        __exit__(as contetx manager)
        '''
     
     
     
        

    　　

    3.从生成器到上下文管理器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    import contextlib
     
    '''
    采用传统方式创建上下文管理器并不难，只需要包含一个__enter__方法和一个__exit__方法的类即可。
    不过某些时候，如果只有很少的上下文需要管理，那么完整地写出所以代码便会成为额外的负担。
    在这些情况下，可以使用contextmanager修饰符将一个生成器函数转换为上下文管理器。
    代码结构：
    @contextlib.contextmanager
    def foo():
        print(123)
        yield 456
        print(789)
         
    with foo() as f:
        print(f)
         
    123
    456
    789
     
    只要给函数加上这个装饰器，那么便可以使用with   as  语句。
    当中的yield相当于将代码块分隔为两个战场，yield上面的代码相当于__exter__会先执行，然后将yield的值交给f，然后执行yield下面的代码块
    '''
     
     
    @contextlib.contextmanager
    def bar(name, age):
        print(f"name is {name}, age is {age}")
        yield list
        print("我是一匹狼，却变成了狗")
     
     
    with bar("mashiro", 16) as b:
        print(b("abcde"))
    '''
    name is mashiro, age is 16
    ['a', 'b', 'c', 'd', 'e']
    我是一匹狼，却变成了狗
    '''
    # 先执行yield上面的内容，然后yield list，那么b = list，最后执行yield下面的内容
     
     
    # contextmanager返回的上下文管理器排成子ContextDecorator,所以也可以被用作函数修饰符
    @bar("satori", 16)
    def foo():
        print("猜猜我会在什么地方输出")
     
     
    foo()
    '''
    name is satori, age is 16
    猜猜我会在什么地方输出
    我是一匹狼，却变成了狗
    '''
    # bar中含有yield，肯定是一个生成器，所以直接@bar("satori", 16)是不会输出的。当我执行foo的时候，还会先执行bar里面yield上面的内容，
    # 然后执行foo代码的内容，最后执行yield下面的内容

    　　

    4.关闭打开的句柄

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    import contextlib
     
    '''
    file类直接支持上下文管理器API，但另外一些表示打开句柄的对象却并不支持。
    为了确保关闭句柄，要是用closing为它创建一个上下文管理器
    '''
     
     
    class Door:
        def __init__(self):
            print("__init__()")
            self.status = "open"
     
        def close(self):
            print("close()")
            self.status = "closed"
     
     
    with contextlib.closing(Door()) as door:
        print(f"{door.status}")
    # 先不急看结果，先来分析一下。首先contextlib.closing本身就是一个上下文管理器
    '''
    class closing(AbstractContextManager):
        def __init__(self, thing):
            self.thing = thing
        def __enter__(self):
            return self.thing
        def __exit__(self, *exc_info):
            self.thing.close()
    '''
    # 可以看到当我with contextlib.closing(Door()) as door的时候，直接将Door的实例对象传入了closing这个类中
    # 然后enter返回了self.thing也就是我们传进去的Door的实例对象，__enter__返回self.thing交给door
    # 然后执行我们的逻辑，最后__exit__函数再调用self.thing.close函数，所以我们定义的类中一定要实现close函数
     
    # 执行结果
    '''
    __init__()
    open
    close()
    '''
    # 先执行__init__函数，再执行我们自己的逻辑，打印"open"，最后执行close函数，将状态改为"closed"。
    # 怎么证明这一点呢？
    print(door.status)  # closed
     
     
    # 如果出现了异常怎么办呢？不用怕，依旧会执行close语句.
    # 由于contextlib.closing的__exit__函数并没有返回布尔类型为True的值，所以最后还是会抛出异常，我们手动捕获一下
    try:
        with contextlib.closing(Door()) as boy_next_door:
            print(123)
            1/0
            print(456)
     
    except Exception:
        pass
     
    print(boy_next_door.status)
    '''
    __init__()
    123
    close()
    closed
    '''
    # 最后还是打印了"closed"，所以还是执行了close()方法

    　　

    5.忽略异常

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    import contextlib
     
    '''
    很多情况下，忽略库产生的异常很有用，因为这个错误可能会显示期望的状态已经被实现，否则该错误就可以被忽略。
    要忽略异常，最常用的办法就是利用一个try except语句。
    但是在我们此刻的主题中，try except也可以被替换成contextlib.suppress()，以更显示地抑制with块中产生的异常
    '''
    def foo():
        print(123)
        1 / 0
        print(456)
     
     
    with contextlib.suppress(ZeroDivisionError):
        foo()
        print(789)
    '''
    123
    '''
    # 最终只输出了123，可以看到不仅1/0中下面的456没有被打印，连foo()下面的789也没有被打印
     
     
    # 可以传入多个异常
    with contextlib.suppress(ZeroDivisionError, BaseException, Exception):
        foo()
    '''
    123
    '''
    # 出现异常之后，会将异常全部丢弃

    　　

    6.重定向到输出流

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    import contextlib
    import io
    import sys
     
    '''
    设计不当的代码可能会直接写sys.stdout或sys.stderr，而没有提供参数来配置不同的输出目标。
    可以用redirect_stdout和redirect_stderr上下文管理器从这些函数中捕获输出，因为无法修改这个函数的源代码来接收新的输出参数
    '''
     
     
    def func(a):
        sys.stdout.write(f"stdout :{a}")
        sys.stderr.write(f"stderr :{a}")
     
     
    capture = io.StringIO()
    '''
    我们执行func本来是要往sys.stdout和sys.stderr里面写的
    但这是在with语句contextlib.redirect_stdout(capture), contextlib.redirect_stderr(capture)下面，
    因此可以理解往sys.stdout和sys.stderr里面写的内容就被捕获到了，然后会将捕获到的内容输入到capture里面，因为我们指定了capture
    '''
    with contextlib.redirect_stdout(capture), contextlib.redirect_stderr(capture):
        func("蛤蛤蛤蛤")
     
     
    print(capture.getvalue())  # stdout :蛤蛤蛤蛤stderr :蛤蛤蛤蛤
     
     
    '''
    redirect_stdout和redirect_stderr会修改全局状态，替换sys模块中的对象，可以想象gevent里面的patch_all会将Python里面socket，ssl等都换掉。
    因此要使用这两个函数，必须要注意。这些函数并不保证线程安全，所以在多线程应用中调用这些函数可能会有不确定的结果。
    如果有其他希望标准输出流关联到终端设备，那么redirect_stdout和redirect_stderr将会干扰和影响那些操作。
    '''

    　　

    7.动态上下文管理器栈

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    import contextlib
     
     
    '''
    大多数上下文管理器都一次处理一个对象，如单个文件或数据库句柄。
    在这些情况下，对象是提前已知的，并且使用上下文管理器的代码可以建立这一对象上。
    另外一些情况下，程序可能需要在一个上下文中创建未知数目的对象，控制流退出这个上下文时所有这些对象都要清理，ExitStack就是用来处理这些更动态的情况。
     
    ExitStack实例会维护清理回调的一个栈数据结构，这些回调显示地填充在上下文中，在控制流退出上下文时会以逆序调用所有注册的回调。
    结果类似于有多个嵌套的with语句，只不过它们是动态建立的。
    '''
     
     
    # 可以使用多种方法填充ExitStack，比如
    @contextlib.contextmanager
    def make_context(i):
        print(f"{i}: entering")
        yield {}
        print(f"{i}: exiting")
     
     
    def variable_stack(n, msg):
        with contextlib.ExitStack() as stack:
            for i in range(n):
                stack.enter_context(make_context(i))
            print(msg)
     
     
    variable_stack(2, "inside stack")
    '''
    contextlib.ExitStack()相当于创建了上下文管理器栈
    stack.enter_context将上下文管理器放入到栈中，注意此时已经执行了
    会先输出：
        0: entering
        1: entering
    等于是把yield之后的结果压入栈中
    然后执行后面的代码，所以会打印出msg
    当里面的代码执行完毕之后，会继续执行栈里面的数据，但是栈是后入先出的。i=1后入栈，所以先执行
    随意最后输出：
        1: exiting
        0: exiting
    '''
    # 输出结果
    ''''
    0: entering
    1: entering
    inside stack
    1: exiting
    0: exiting
    '''

    　　
  • 相关阅读:
    MFC中，什么是CALLBACK函数，什么是WINAPI函数，二者有什么区别和联系？
    浙江移动话费计算－js代码
    [转]C#网页自动登录和提交POST信息的多种方法
    JavaScript小数四舍五入toFixed
    C#.NET应用程序实现网页自动登录
    VC改变对话框按钮字体颜色和背景的解决方案（转）
    WPF窗口阴影
    用MVVM模式开发中遇到的零散问题总结（1）
    NPOI之Excel——合并单元格、设置样式、输入公式
    近距离接触RAC DRM
  • 原文地址：https://www.cnblogs.com/valorchang/p/11395767.html
Copyright © 2011-2022 走看看