Python笔记【十一】

2023-05-16

本文为博主原创，未经授权，严禁转载及使用。
本文链接：https://blog.csdn.net/zyooooxie/article/details/123655926

继续学习Python，继续更新。

这是我自己学习Python的系列博客： https://blog.csdn.net/zyooooxie/category_9592654.html

个人博客：https://blog.csdn.net/zyooooxie

_init_()

https://docs.python.org/zh-cn/3.8/reference/datamodel.html#object._init_

"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@wechat: 153132336
"""

def test_0():
    # object.__init__(self[, ... ])
    # 在实例(通过__new__()) 被创建之后，返回调用者之前调用。其参数与传递给类构造器表达式的参数相同。

    # 因为对象是由__new__() 和__init__() 协作构造完成的(由__new__() 创建， 并由__init__() 定制)，
    # 所以__init__() 返回的值只能是None， 否则会在运行时引发TypeError。

    # 一个基类如果有 __init__() 方法，则其所派生的类如果也有 __init__() 方法，
    # 就必须显式地调用它以确保 实例基类部分的正确初始化；例如: super().__init__([args...])；

    # __init__方法 支持带参数类的初始化，也可为声明该类的属性（类中的变量）。
    # __init__方法的第一个参数必须为self，后续参数为自己定义。

    # __init__()  可以包含多个参数，但必须包含一个名为 self 的参数，且必须作为第一个参数。
    # __init__() 的参数列表会在开头多出一项，它永远指代新建的那个实例对象，Python语法要求这个参数必须要有，而名称随意，习惯上就命为self。

    pass


# 如果一个类【父类为object】中 定义了__init__方法，那么在实例化类时，会自动调用类中定义的__init__方法；
# 如果一个类【父类为object】中 未定义__init__方法，那么在实例化类时，会自动调用 根类object中无参的__init__方法；


# 当然，__init__() 方法还可以有额外参数以实现更高灵活性。
# 在这种情况下，提供给类实例化运算符的参数将被传递给 __init__()。
# __init__() 方法可以包含多个参数，但必须包含一个名为self的参数，且必须作为第一个参数；
# 参数类型可以是：位置参数、默认参数、可变参数；
# 参数的定义与传入 与普通函数一样；


# 使用__init__()方法来定义实例对象独有的属性：实例变量；
# 实例变量是每个实例对象独有的；
# 在定义实例变量时，必须是：self.实例的变量名 = 外部形参名(通过self 将变量 绑定当前实例对象)；
# (有时候会给某些实例变量 赋 默认值，类似 self.abc =0，实际这样 无法通过外部传值来修改其的值)；
# 与定义变量一样，实例变量的值不仅可以是具体的值，还可以是函数返回值、方法返回值、类的实例名；


# 在类中任意地方(所有方法中)都可以使用"self.实例属性名"来调用实例属性；
# 在类外任意地方都可以使用"实例名.实例属性名"来调用实例属性；

# 某个属性是每个实例同共有的就可以定义为类属性；


# 在类的内部，访问自己的属性和方法，都需要通过self，self就是外部对象在类内部的表示（self指的是类实例对象本身）；


def func_1(arg_str: str):
    return arg_str * 2


class A(object):

    def print_(self):
        Log.info('A')

        return self


class ClassA(object):

    def __init__(self, str_a, tuple_=(1,)):
        Log.info(self)
        Log.info(str_a)
        Log.info(tuple_)

        self.str_a = str_a  # 等号左边的那个 是实例的属性，后面那个是 __init__()的参数

        self.str_a2 = func_1(str_a)
        Log.info(self.str_a2)

        self.ins_A = A()
        Log.info(self.ins_A)

        self.func_A = A().print_()
        Log.info(self.func_A)

    def print_(self):
        Log.info(self)
        Log.info(f'{self.str_a, self.str_a2, self.ins_A, self.func_A}')

        # Log.info(tuple_)  # NameError: name 'tuple_' is not defined


if __name__ == '__main__':
    pass

    # 我们没有专门调用__init__方法，只是在创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给__init__方法。
    ca1 = ClassA('zyooooxie')

    Log.info('********')

    ca1.print_()

    Log.info('********')

    a = A()
    a.print_()  # self在调用时不必传入相应的参数。

    Log.info('********')

    A.print_(a)

_init_() + super() + 单继承

super() 的用法可以参考 https://blog.csdn.net/zyooooxie/article/details/123639025

"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@wechat: 153132336
"""

# 当在Python中出现继承的情况时，一定要注意初始化函数_init_的行为:

# 1.如果子类没有定义自己的初始化函数，父类的初始化函数会被默认调用；但是如果要实例化子类的对象，则只能传入父类的初始化函数对应的参数，否则会出错。
# 【子类如果没有构造方法时，按括号内父类的继承顺序去继承父类构造方法，只继承一个:哪个父类在最前面且它又有自己的构造函数，就继承它的构造函数】

# 2.如果子类定义了自己的初始化函数，而在子类中没有显式调用父类的初始化函数，则父类的属性不会被初始化（子类实例化只会调用自己的构造方法，父类的构造方法不会调用）。
# 【如需使用父类__init__中的变量，则需要在子类__init__中显式调用】

# 3.如果子类定义了自己的初始化函数，在子类中显式地调用父类的，子类和父类的属性都会被初始化。


# 在子类的__init__方法中使用 super().__init__() , 就相当于把父类的 __init__方法拿过来用, 并且可以对父类的__init__方法进行补充(比如添加成员属性/方法) ,也就相当于把父类的__init__方法继承过来了,
# 之后用子类实例化一个对象后, 这个对象可以点出父类对象的成员属性/方法, 当然也可以点出自己类对象的成员属性/方法。


class Parent0(object):

    def __init__(self):
        Log.info('Parent0 的 __init__()')
        self.p = 'Parent0 的 属性p'


class Parent1(object):

    def __init__(self, arg1):
        Log.info('Parent1 的 __init__()')
        self.p = 'Parent1 的 属性p'
        self.arg1 = arg1


class Parent2(object):
    pass


class Parent3(object):

    def __init__(self, arg1, arg2=(1,)):
        self.arg1 = arg1
        self.arg2 = arg2

        Log.info('Parent3 的 __init__()')
        self.p = 'Parent3 的 属性p'


class Parent4(object):

    def __init__(self, arg1, *args, **kwargs):
        self.arg1 = arg1
        self.arg2 = args
        self.kwargs = kwargs

        Log.info('Parent4 的 __init__()')
        self.p = 'Parent4 的 属性p'


class Son(Parent0):
    pass


class Son1(Parent1):
    pass


class Son2(Parent2):
    pass


class Son3(Parent2, Parent1):
    pass


class Son4(Parent0, Parent1):
    pass


class Son5(Parent2):
    def __init__(self):
        Log.info('Son5 的 __init__()')

        self.pp = 'Son5'


class Son6(Parent1):
    def __init__(self):
        Log.info('Son6 的 __init__()')
        # Log.info(self.arg1)  # AttributeError: 'Son6' object has no attribute 'arg1'

        self.pp = 'Son6'


class Son7(Parent0):
    def __init__(self):
        Log.info('Son7 的 __init__()')
        super(Son7, self).__init__()
        Log.info(self.p)

        self.pp = 'Son7'


class Son8(Parent1):
    def __init__(self, arg1):
        Log.info('Son8 的 __init__()')
        super().__init__(arg1)
        Log.info(self.p)
        Log.info(self.arg1)

        self.pp = 'Son8'


class NewSon1(Parent3):
    pass


class NewSon2(Parent4):
    pass


class NewSon3(Parent4):

    def __init__(self, arg1):
        Log.info('NewSon3 的 __init__()')

        super().__init__(arg1)

        self.pp = 'NewSon3'


class NewSon4(Parent4):

    def __init__(self, arg1):
        Log.info('NewSon4 的 __init__()')
        self.pp = 'NewSon4'

        super(NewSon4, self).__init__(arg1, 'NewSon4给的')
        Log.info(self.__dict__)

        super().__init__('再来一次')
        Log.info(self.__dict__)


class Grandchild(Son):
    def __init__(self):
        Log.info('Grandchild 的 __init__()')

        self.ppp = 'Grandchild'


class Grandchild2(Son1):

    def __init__(self, arg1, arg11):
        Log.info('Grandchild2 的 __init__()')

        super(Grandchild2, self).__init__(arg1)
        self.arg11 = arg11

        self.ppp = 'Grandchild2'


class Grandchild3(Son2):
    pass


class Grandchild4(Son3):

    def __init__(self, arg1):
        Log.info('Grandchild4 的 __init__()')

        super().__init__(arg1)

        self.ppp = 'Grandchild4'


class Grandchild5(Son4):

    def __init__(self):
        Log.info('Grandchild5 的 __init__()')
        super().__init__()

        self.ppp = 'Grandchild5'


class Grandchild6(Son5):
    pass


class Grandchild7(Son6):

    def __init__(self):
        Log.info('Grandchild7 的 __init__()')

        super(Grandchild7, self).__init__()
        self.ppp = 'Grandchild7'


class Grandchild8(Son7):

    def __init__(self):
        Log.info('Grandchild8 的 __init__()')

        super(Grandchild8, self).__init__()
        self.ppp = 'Grandchild8'


class Grandchild8_A(Son7):
    pass


class Grandchild9(Son8):

    def __init__(self):
        Log.info('Grandchild9 的 __init__()')

        self.ppp = 'Grandchild9'


class NewGrandchild(NewSon1):

    def __init__(self, arg1, *args):
        Log.info('NewGrandchild 的 __init__()')
        Log.info(args)

        super(NewGrandchild, self).__init__(arg1, args[0] if len(args) > 1 else '没有多传的参数')

        self.ppp = 'NewGrandchild'


class NewGrandchild2(NewSon2):

    def __init__(self, arg1, *args):
        Log.info('NewGrandchild2 的 __init__()')

        super(NewGrandchild2, self).__init__(arg1, *args)


class NewGrandchild2_A(NewSon2):

    def __init__(self, *args, **kwargs):
        Log.info('NewGrandchild2_A 的 __init__()')
        super(NewGrandchild2_A, self).__init__(*args, **kwargs)


# super().__init__() 的好处就是统一进行所有父类构造方法的调用，调用的先后根据类型的mro顺序决定，将自动调用所有父类的构造方法【所有父类中 都有使用super().__init__()】


def test_1():
    s = Son()
    Log.info(s.__dict__)

    Log.info('*')

    s1 = Son1('--Son1--')
    Log.info(s1.__dict__)

    Log.info('**')

    s2 = Son2()
    Log.info(s2.__dict__)

    Log.info('***')

    s3 = Son3('--Son3--')
    Log.info(s3.__dict__)

    Log.info('****')

    s4 = Son4()
    Log.info(s4.__dict__)

    Log.info('*****')

    s5 = Son5()
    Log.info(s5.__dict__)

    Log.info('******')

    s6 = Son6()
    Log.info(s6.__dict__)

    Log.info('*******')

    s7 = Son7()
    Log.info(s7.__dict__)

    Log.info('********')

    s8 = Son8('--Son8--')
    Log.info(s8.__dict__)


def test_2():
    Log.info('-')

    ns1 = NewSon1('NewSon1传的')
    Log.info(ns1.__dict__)

    ns1 = NewSon1('NewSon1传的', '这个是新arg2')
    Log.info(ns1.__dict__)

    Log.info('--')

    ns2 = NewSon2('NewSon2传的')
    Log.info(ns2.__dict__)

    ns2 = NewSon2('NewSon2传的', '传一个')
    Log.info(ns2.__dict__)

    ns2 = NewSon2('NewSon2传的', '随便', '给', key1='v1', key2='v2')
    Log.info(ns2.__dict__)

    Log.info('---')

    ns3 = NewSon3('NewSon3传的')
    Log.info(ns3.__dict__)

    Log.info('----')

    ns4 = NewSon4('NewSon4传的')


def test_3():
    Log.info('+')

    g1 = Grandchild()
    Log.info(g1.__dict__)

    Log.info('++')

    g2 = Grandchild2('g2', 'g2 的 arg11')
    Log.info(g2.__dict__)

    Log.info('+++')

    g3 = Grandchild3()
    Log.info(g3.__dict__)

    Log.info('++++')

    g4 = Grandchild4('g4')
    Log.info(g4.__dict__)

    Log.info('+++++')

    g5 = Grandchild5()
    Log.info(g5.__dict__)

    Log.info('++++++')

    g6 = Grandchild6()
    Log.info(g6.__dict__)

    Log.info('+++++++')

    g7 = Grandchild7()
    Log.info(g7.__dict__)

    Log.info('++++++++')

    g8 = Grandchild8()
    Log.info(g8.__dict__)

    Log.info('++++++++')

    g8 = Grandchild8_A()
    Log.info(g8.__dict__)

    Log.info('+++++++++')

    g9 = Grandchild9()
    Log.info(g9.__dict__)


def test_4():
    Log.info('/')

    ng = NewGrandchild('NewGrandchild')
    Log.info(ng.__dict__)

    ng = NewGrandchild('NewGrandchild', 'ng的arg2', 'ng的arg3')
    Log.info(ng.__dict__)

    Log.info('//')

    ng2 = NewGrandchild2('NewGrandchild2')
    Log.info(ng2.__dict__)

    ng2 = NewGrandchild2('NewGrandchild2', 'ng2的arg2')
    Log.info(ng2.__dict__)

    ng2 = NewGrandchild2('NewGrandchild2', 'ng2的arg2', 'ng2的arg3', 'ng2的arg4')
    Log.info(ng2.__dict__)

    ng2 = NewGrandchild2_A('NewGrandchild2_A', 'ng2的arg2', ng2='ng2的value', ng2222='ng2的value2222')
    Log.info(ng2.__dict__)

    ng2 = NewGrandchild2_A('NewGrandchild2_A', ng2='ng2的value')
    Log.info(ng2.__dict__)

x =+ 1 、x = x + 1 、x += 1

"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@wechat: 153132336
"""

# 如果 x 是具有 __iadd__() 方法的类的一个实例，则 x += y 就等价于 x = x.__iadd__(y)。否则就如 x + y 的求值一样选择 x.__add__(y) 和 y.__radd__(x)。

# 求表达式 x + y 的值，其中 x 是具有 __add__() 方法的类的一个实例，则会调用 x.__add__(y)。

# object.__iadd__(self, other)
# object.__add__(self, other)

def test_0302a():
    # x += 1

    # += 加法赋值运算符

    abc = 999
    Log.info(f'{abc, type(abc)}')
    Log.info(id(abc))

    abc += 0
    Log.info(f'{abc, type(abc)}')
    Log.info(id(abc))

    abc += 10
    Log.info(f'{abc, type(abc)}')
    Log.info(id(abc))

    abc += 0
    Log.info(f'{abc, type(abc)}')
    Log.info(id(abc))

    Log.info('-----')

    list_abc = list()
    Log.info(f'{list_abc, type(list_abc)}')
    Log.info(id(list_abc))

    list_abc += []
    Log.info(f'{list_abc, type(list_abc)}')
    Log.info(id(list_abc))

    list_abc += [1]
    Log.info(f'{list_abc, type(list_abc)}')
    Log.info(id(list_abc))

    Log.info('-----')

    str_abc = 'ABC'
    Log.info(f'{str_abc, type(str_abc)}')
    Log.info(id(str_abc))

    str_abc += 'abc'
    Log.info(f'{str_abc, type(str_abc)}')
    Log.info(id(str_abc))


def test_0302b():
    # x = x + 1

    abc = 999
    Log.info(f'{abc, type(abc)}')
    Log.info(id(abc))

    abc1 = abc + 1
    Log.info(f'{abc1, type(abc1)}')
    Log.info(id(abc1))

    abc = abc + 1
    Log.info(f'{abc, type(abc)}')
    Log.info(id(abc))

    abc2 = abc + 1
    Log.info(f'{abc2, type(abc2)}')
    Log.info(id(abc2))

    Log.info('-----')

    list_abc = list()
    Log.info(f'{list_abc, type(list_abc)}')
    Log.info(id(list_abc))

    list_abc1 = list_abc + [1]
    Log.info(f'{list_abc1, type(list_abc1)}')
    Log.info(id(list_abc1))

    list_abc = list_abc + [1]
    Log.info(f'{list_abc, type(list_abc)}')
    Log.info(id(list_abc))

    list_abc2 = list_abc + [1]
    Log.info(f'{list_abc2, type(list_abc2)}')
    Log.info(id(list_abc2))

    Log.info('-----')

    str_abc = 'ABC'
    Log.info(f'{str_abc, type(str_abc)}')
    Log.info(id(str_abc))

    str_abc1 = str_abc + 'abc'
    Log.info(f'{str_abc1, type(str_abc1)}')
    Log.info(id(str_abc1))

    str_abc = str_abc + 'abc'
    Log.info(f'{str_abc, type(str_abc)}')
    Log.info(id(str_abc))


def test_0302c():
    # x =+ 1
    # x = + 1
    # 这个+号这里就代表一个正数

    abc = 999
    Log.info(f'{abc, type(abc)}')
    Log.info(id(abc))

    abc = + 1
    Log.info(f'{abc, type(abc)}')
    Log.info(id(abc))

    abc1 = + 1
    Log.info(f'{abc1, type(abc1)}')
    Log.info(id(abc1))

    abc = - 1
    Log.info(f'{abc, type(abc)}')
    Log.info(id(abc))

    abc2 = - 1
    Log.info(f'{abc2, type(abc2)}')
    Log.info(id(abc2))

    Log.info('-----')

    list_abc = list()
    Log.info(f'{list_abc, type(list_abc)}')
    Log.info(id(list_abc))

    list_abc = + 1
    Log.info(f'{list_abc, type(list_abc)}')
    Log.info(id(list_abc))

    list_abc1 = + 1
    Log.info(f'{list_abc1, type(list_abc1)}')
    Log.info(id(list_abc1))

    list_abc = - 1
    Log.info(f'{list_abc, type(list_abc)}')
    Log.info(id(list_abc))

    list_abc2 = - 1
    Log.info(f'{list_abc2, type(list_abc2)}')
    Log.info(id(list_abc2))

itertools模块

https://docs.python.org/zh-cn/3.8/library/itertools.html

介绍些我自己常用：

"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@wechat: 153132336
"""

def test_itertools():
    # itertools.count(start, step) 返回一个等分的无限数据流。初始值默认为0，间隔默认为1，
    # 你也选择可以指定初始值和间隔

    #

    # itertools.cycle(iter) 保存一份所提供的可迭代对象的副本，并返回一个能产生整个可迭代对象序列的新迭代器。
    # 新迭代器会无限重复这些元素。

    #

    # itertools.repeat(elem, [n]) 返回n 次所提供的元素，当n 不存在时，返回无数次所提供的元素。

    #

    # itertools.chain(iterA, iterB, ...) 接受任意数量的可迭代对象作为输入，
    # 首先返回第一个迭代器的所有元素，然后是第二个的所有元素，如此一直进行下去，直到消耗掉所有输入的可迭代对象。

    #

    # itertools.islice(iter, [start], stop, [step]) 返回一个所输入的迭代器切片的数据流。
    # 如果只单独给定stop 参数的话，它会返回从起始算起stop 个数量的元素。
    # 如果你提供了起始下标start，你会得到stop-start 个元素；
    # 如果你给定了step 参数，数据流会跳过相应的元素。
    # 和Python 里的字符串和列表切片不同，你不能在start, stop 或者step 这些参数中使用负数。

    #

    # itertools.tee(iter, [n]) 可以复制一个迭代器；
    # 它返回n 个能够返回源迭代器内容的独立迭代器。
    # 如果你不提供参数n，默认值为2。
    # 复制迭代器需要保存源迭代器的一部分内容，因此在源迭代器比较大的时候会显著地占用内存；
    # 同时，在所有新迭代器中，有一个迭代器会比其他迭代器占用更多的内存。

    #

    # itertools.starmap(func, iter) 假定可迭代对象能够返回一个元组的流，并且利用这些元组作为参数来调用func:

    abc = itertools.starmap(os.path.join, [('/bin', 'python'), ('/usr', 'bin', 'java')])
    Log.info(abc)
    Log.info(list(abc))

    #

    # itertools.filterfalse(predicate, iter) 和filter() 相反，返回所有让predicate 返回false的元素

    #

    # itertools.takewhile(predicate, iter) 返回一直让predicate 返回true 的元素。
    # 一旦predicate 返回false，迭代器就会发出终止结果的信号

    #

    # itertools.dropwhile(predicate, iter) 在predicate 返回true 的时候丢弃元素，并且返回可迭代对象的剩余结果

    #

    # itertools.compress(data, selectors) 接受两个迭代器，然后返回data中 使相应地selector中的元素为真的元素；它会在任一个迭代器耗尽的时候停止:
    abc = itertools.compress([1, 2, 3, 4, 5], [True, True, False, False, True])
    Log.info(abc)
    Log.info(list(abc))

    #

    # itertools.combinations(iterable, r) 返回一个迭代器，它能给出输入迭代器中所包含的元素的所有可能的r 元元组的组合
    # 每个元组中的元素保持着可迭代对象返回他们的顺序

    #

    # itertools.permutations(iterable, r=None)，取消了保持顺序的限制，返回所有可能的长度为r 的排列:
    # 如果你不提供r 参数的值，它会使用可迭代对象的长度，也就是说会排列所有的元素。

    #

    # itertools.groupby(iter,key_func=None)， 是最复杂的函数。
    # key_func(elem) 是一个可以对迭代器返回的每个元素计算键值的函数。如果你不提供这个键值函数，它就会简化成每个元素自身。

    # groupby() 从所依据的可迭代对象中连续地收集具有相同值的元素，然后返回一个长度为2 的元组的数据流, 每个元组包含键值以及对应这个键值的元素所组成的迭代器。
    # groupby() 假定了所依据的可迭代对象的内容已经根据键值排序。注意，返回的迭代器也会使用所依据的可迭代对象，所以在请求迭代器2 和相应的键之前你必须先消耗迭代器1 的结果。

    pass


#
#
#

# 无穷迭代器：

def test_2():
    from itertools import count
    # itertools.count(start=0, step=1)
    # 创建一个迭代器，它从start 值开始，返回均匀间隔的值。常用于map() 中的实参来生成连续的数据点。此外，还用于zip() 来添加序列号。
    # start: int | float, 起始值
    # step: int | float, 步长

    # count() 传参：start, [step]
    # start, start+step, start+2*step, ...

    list_1 = [1, 22, 333, 444, 555, 666, 777, 8]
    abc = zip(list_1, count(5))
    Log.info(type(abc))
    Log.info(list(abc))

    # 使用时必须格外小心itertools.count()因为很容易陷入无限循环

    c1 = count(100, step=5)
    Log.info(type(c1))

    Log.info(next(c1))
    Log.info(next(c1))
    Log.info(next(c1))
    Log.info(next(c1))
    Log.info(next(c1))
    Log.info(next(c1))
    Log.info(next(c1))
    Log.info(next(c1))
    Log.info(next(c1))
    Log.info(next(c1))

    abc = map(lambda x: x if x < 12 else -x, count(5, 2))
    Log.info(type(abc))

    Log.info(next(abc))
    Log.info(next(abc))
    Log.info(next(abc))
    Log.info(next(abc))
    Log.info(next(abc))
    Log.info(next(abc))
    Log.info(next(abc))
    Log.info(next(abc))
    Log.info(next(abc))


def test_5():
    from itertools import repeat
    # itertools.repeat(object[, times ])
    # 创建一个迭代器，不断重复object 。除非设定参数times ，否则将无限重复。

    # object: python 对象, 可以是任何数据
    # times: int, 迭代次数, 可选参数, 默认为无限次

    # 可用于map() 函数中的参数，被调用函数可得到一个不变参数。也可用于zip() 的参数以在元组记录中创建一个不变的部分。

    # repeat() 传参：elem [,n]
    # elem, elem, elem, ... 重复无限次 或n 次

    abc = repeat(22, times=5)
    Log.info(type(abc))
    Log.info(list(abc))

    abc = repeat([22, 23, 24], 8)
    Log.info(type(abc))
    Log.info(list(abc))

    # repeat 最常见的用途就是在map 或zip 提供一个常量流：
    abc = map(pow, range(10), repeat(2, 5))
    Log.info(type(abc))
    Log.info(list(abc))  # 长度为5

    abc = map(pow, range(10), repeat(2, 15))
    Log.info(type(abc))
    Log.info(list(abc))  # 长度为10

    abc = zip(range(8), repeat([0, 1, 2, 3, 4]))
    Log.info(type(abc))
    Log.info(list(abc))

    for i_index, i in enumerate(repeat(88)):
        print(i_index, i)

        if i_index >= 30:
            print('结束')
            break


#
#
#

# 根据最短输入序列长度停止的迭代器：

def test_0():
    from itertools import accumulate
    # itertools.accumulate(iterable[, func, *, initial=None ])
    # 创建一个迭代器，返回累积汇总值或其他双目运算函数的累积结果值（通过可选的func 参数指定）。
    # 如果提供了func，它应当为带有两个参数的函数。
    # 通常，输出的元素数量与输入的可迭代对象是一致的。但是，如果提供了关键字参数initial，则累加会以initial 值开始，这样输出就比输入的可迭代对象多一个元素。

    # iterable: 可迭代对象
    # func: 带有两个参数的函数, 可选参数
    # initial: 关键字参数, 默认为 None, 若此参数传参, 则此参数作为 iterable 的第一个元素

    # accumulate() 传参：p [,func]
    # p0, p0+p1, p0+p1+p2, ...

    list_ = [1, 200, 5, 3000, 60, 40000]

    iter_1 = accumulate(list_)
    print(type(iter_1))
    Log.info(list(iter_1))  # 默认的加法运算

    iter_2 = accumulate(list_, initial=800000)
    Log.info(list(iter_2))

    # func 参数有几种用法。它可以被设为min() 最终得到一个最小值，或者设为max() 最终得到一个最大值，或设为operator.mul() 最终得到一个乘积
    iter_3 = accumulate(list_, initial=70000, func=operator.mul)
    Log.info(list(iter_3))

    iter_4 = accumulate(list_, min)
    Log.info(list(iter_4))

    iter_5 = accumulate(list_, max)
    Log.info(list(iter_5))


def test_1():
    from itertools import chain
    # itertools.chain(*iterables)
    # 创建一个迭代器，它首先返回第一个可迭代对象中所有元素，接着返回下一个可迭代对象中所有元素，直到耗尽所有可迭代对象中的元素。可将多个序列处理为单个序列
    # *iterables: 多个可迭代对象, 以逗号隔开

    # chain() 传参：p, q, ...
    # p0, p1, ... p_last, q0, q1, ... q_last, ...

    i_1 = [1, 2]
    i_2 = (3, 4, 5, 6)
    i_3 = 'a'
    i_7 = 'ABC'
    i_4 = {'blog': 'zyooooxie', 'qq': '153132336'}
    i_5 = [{77, 78, 79}, {88, 89}]
    i_6 = {99, 999, 999, 999}

    chain_1 = chain(i_2, i_3, i_7, i_1, i_4, i_5, i_6)
    Log.info(type(chain_1))
    Log.info(list(chain_1))


def test_1_chain():
    pass


def test_7():
    from itertools import takewhile
    # itertools.takewhile(predicate, iterable)
    # 创建一个迭代器，根据perdicate 函数计算 iterable 中的元素，当计算结果第一次为 false 时，迭代器丢弃 此元素与之后的元素，然后返回其他元素。

    # 实际结果：首次False 之前的

    # predicate: 只需要一个参数的函数
    # iterable: 可迭代对象

    # takewhile() 传参：pred, seq
    # seq seq[0], seq[1], ..., 直到pred 真值测试失败

    list_ = [1, 0, True, False, None, (), (1,), [], [2], '']

    abc = takewhile(bool, list_)
    Log.info(type(abc))
    Log.info(list(abc))

    for i in list_:
        Log.info(f'结果：{bool(i)}, 元素：{i}')

    list_1 = [1, True, (1,), [3], [2], '456']
    abc = takewhile(bool, list_1)  # 结果中 无False
    Log.info(type(abc))
    Log.info(list(abc))


def test_8():
    from itertools import dropwhile
    # itertools.dropwhile(predicate, iterable)
    # 创建一个迭代器，根据perdicate 函数计算 iterable 中的元素，当计算结果第一次为 false 时，迭代器丢弃此元素之前的元素，然后返回其他元素。

    # 实际结果：首次False 之后的

    # predicate: 只需要一个参数的函数
    # iterable: 可迭代对象

    # dropwhile() 传参：pred, seq
    # seq[n], seq[n+1], ... 从pred首次真值测试失败开始

    list_ = [1, 0, True, False, None, (), (1,), [], [2], '']

    abc = dropwhile(bool, list_)
    Log.info(type(abc))
    Log.info(list(abc))

    for i in list_:
        Log.info(f'结果：{bool(i)}, 元素：{i}')

    list_1 = [1, True, (1,), [3], [2], '456']
    abc = dropwhile(bool, list_1)  # 结果中 无False
    Log.info(type(abc))
    Log.info(list(abc))


def test_3():
    from itertools import filterfalse
    # itertools.filterfalse(predicate, iterable)
    # 创建一个迭代器，只返回iterable 中predicate 为False 的元素。
    # 如果predicate 是None，返回 真值测试 [bool] 为false 的元素。

    # predicate: 只需要一个参数的函数
    # iterable: 可迭代对象

    # filterfalse() 传参：pred, seq
    # seq 中pred(x) 为假值的元素，x 是seq 中的元素。

    list_1 = [1, 22, 3333, 4, 55, 666, 77777, 8, 999999]

    abc = filter(lambda x: x % 2, list_1)  # %代表取模，返回除法的余数
    Log.info(type(abc))
    Log.info(list(abc))

    abc = filterfalse(lambda x: x % 2, list_1)
    Log.info(type(abc))
    Log.info(list(abc))

    list_1 = ['', 0, 1, 22, (), set(), dict()]
    abc = filterfalse(None, list_1)
    Log.info(type(abc))
    Log.info(list(abc))


def test_6():
    from itertools import repeat
    from itertools import starmap

    # itertools.starmap(function, iterable)

    # function: 函数
    # iterable: 可迭代对象

    # 创建一个迭代器，将 iterable 中的元素当作 function 的参数计算，并将结果保留在新迭代器中。iterable 中的每个元素都是元组，元组内包含了 function 所需的参数。
    # 可用此函数代替map()。
    # map() 与starmap()之间的区别 可以类比function(a,b) 与function(*c) 的区别。

    # starmap() 传参：func, seq
    # func(*seq[0]),func(*seq[1]), ...

    zip_ = zip(range(10), repeat(2, 5))
    abc = starmap(pow, zip_)
    Log.info(type(abc))
    Log.info(list(abc))

    abc = map(pow, range(10), repeat(3, 15))
    Log.info(type(abc))
    Log.info(list(abc))

    zip_ = (0, 3), (1, 3), (2, 3), (3, 3), (4, 3), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1)
    abc = starmap(pow, zip_)
    Log.info(type(abc))
    Log.info(list(abc))


def test_9():
    from itertools import islice
    # itertools.islice(iterable, stop)
    # itertools.islice(iterable, start, stop[, step ])
    # 创建一个迭代器，返回从 iterable 中被选中的元素，被选中的元素从 start 索引位置开始，以 step 为步长，直到 stop 索引位置结束。类似列表、字符串等的切片操作。

    # iterable: 可迭代对象
    # start: 起始位置
    # stop: 结束位置
    # step: 步长

    # islice() 传参：seq, [start,] stop [, step]
    # seq[start:stop:step] 中的元素

    # 与普通的切片不同，islice() 不支持将start，stop，或step 设为负值。
    # 如果start 为None，迭代从0 开始。如果step 为None ，步长缺省为1。如果stop 为None，迭代器耗光为止；

    list_ = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
    abc = islice(list_, 5)
    Log.info(type(abc))
    Log.info(list(abc))

    abc = islice(list_, 3, 30)
    Log.info(type(abc))
    Log.info(list(abc))

    abc = islice(list_, 7, None)
    Log.info(type(abc))
    Log.info(list(abc))

    abc = islice(list_, None, 20, 2)
    Log.info(type(abc))
    Log.info(list(abc))


def test_10():
    from itertools import zip_longest
    # itertools.zip_longest(*iterables, fillvalue=None)
    # 创建一个迭代器，从每个可迭代对象中收集元素。如果可迭代对象的长度未对齐，将根据fillvalue填充缺失值。迭代持续到耗光最长的可迭代对象。

    # *iterables: 一个或多个可迭代对象
    # fillvalue: 关键字参数, 填充值, 默认为 None

    # zip_longest() 传参：p, q, ...
    # (p[0], q[0]), (p[1], q[1]), ...

    list_ = [11, 21, 31]
    str_ = 'abcd'
    list_1 = [12, 22, 32, 42, 52]
    str_1 = 'ABCDEF'
    list_2 = [13, 23, 33, 43, 53, 63, 73]

    abc = zip_longest(list_, list_1, list_2, str_, str_1)
    Log.info(type(abc))
    Log.info(list(abc))

    abc = zip_longest(list_, list_1, str_, str_1, fillvalue='zyooooxie')
    Log.info(type(abc))
    Log.info(list(abc))

    matrix = [[1, 2, 3, 4, 44],
              [5, 6, 7, 8],
              [9, 10, 11, 12, 12, 12, 12]]

    # 将交换其行和列

    abc1 = list(zip_longest(*matrix))
    Log.info(abc1)

    # 如果其中一个可迭代对象有无限长度，zip_longest() 函数应封装在限制调用次数的场景中（例如 islice() 或takewhile()）


#
#
#

# 排列组合迭代器：

def test_4():
    from itertools import product
    # itertools.product(*iterables, repeat=1) 可迭代对象输入的笛卡儿积。
    # 大致相当于生成器表达式中的嵌套循环。例如，product(A, B) 和((x,y) for x in A for y in B) 返回结果一样。

    # *iterables: 一个或多个可迭代对象
    # repeat: 关键字参数, 重复次数, 默认为 1

    # product() 传参p, q, ... [repeat=1]
    # 笛卡尔积，相当于嵌套的for 循环

    list_ = [1, 2, 3]
    tuple_ = ('987', '654')
    set_ = {100, 100101}
    abc = product(list_, tuple_, set_)
    Log.info(type(abc))
    Log.info(list(abc))

    abc = product(list_, tuple_, repeat=2)
    Log.info(type(abc))
    Log.info(list(abc))

    # 要计算可迭代对象自身的笛卡尔积，将可选参数repeat 设定为要重复的次数
    abc = product(list_, repeat=3)
    Log.info(type(abc))
    Log.info(list(abc))

    abc = product(list_, list_, list_)
    Log.info(type(abc))
    Log.info(list(abc))

本文链接：https://blog.csdn.net/zyooooxie/article/details/123655926

个人博客 https://blog.csdn.net/zyooooxie

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

python