import time
 
 
"""我的迭代器"""
class Myiterator:
    def __init__(self, array: list, reverse: bool):
        self.array = array
        self.reverse = reverse
 
    def __iter__(self):
        return self
 
    def __next__(self):
        if len(self.array) == 0 and not self.array:
            raise StopIteration
        else:
            if self.reverse:
                return self.array.pop(0)
            else:
                return self.array.pop()
 
 
myiterator = Myiterator([i for i in range(1, 41)], reverse=False)
print("\033[32m%s开始反向循环%s\033[0m" % ("-"*10, "-"*10))
 
ends = []
for i in myiterator:
    ends.append(i)
    # 判断列表长度并输出对应片段
    if len(ends) == 10:
        print(f"{ends[:10]}") 
    elif len(ends) == 20:
        print(f"{ends[10:20]}")
    elif len(ends) == 30:
        print(f"{ends[20:30]}")
    elif len(ends) == 40:
        print(f"{ends[30:41]}")
    time.sleep(0.1)
print(f"\n\033[32m反向循环结果：{ends}\033[0m")
 
print("\033[32m反向循环结束！\033[0m\n")
print("\033[32m%s开始正向循环%s\033[0m" % ("-"*10, "-"*10)) 
 
starts = []
for j in Myiterator([i for i in range(1, 41)], reverse=True):
    starts.append(j)
    if len(starts) == 10:
        print(f"{starts[:10]}") 
    elif len(starts) == 20:
        print(f"{starts[10:20]}")
    elif len(starts) == 30:
        print(f"{starts[20:30]}")
    elif len(starts) == 40:
        print(f"{starts[30:41]}")
    time.sleep(0.1)
print(f"\n\033[32m正向循环结果：{starts}\033[0m")
 
print("\033[32m正向循环结束！\033[0m")
 
try:
    results = []
    # 这里存在变量作用域问题，修改后使用双循环计算
    for x in range(len(starts)):
        start = starts[x]
        for c in range(len(ends)):
            if x == c:  # 保证索引对应
                end = ends[c]
                result = start + end
                results.append(result)
    print(f"\n\033[32m计算结果：{results}\033[0m")
    results.reverse()
    print(f"\n\033[33m结果排序：{results}\033[0m")
 
except Exception as e:
    print(f"\033[31m发生错误：{e}\033[0m")
 
 
 
 
class Customize:
    def __new__(cls, Array, reverse: bool):
        print("\033[32m我是构造函数\033[0m\n")
        instance = super().__new__(cls)
        return instance
 
    def __init__(self, Array, reverse: bool):
        print("\033[32m我是初始化函数\033[0m")
        self.Array = Array
        self.reverse = reverse
 
    def __iter__(self):
        return self
 
    def __next__(self):
        if len(self.Array) == 0:
            raise StopIteration
        else:
            if self.reverse:
                return self.Array.pop(0)
            else:
                return self.Array.pop()
 
 
customize = Customize([v for v in range(1, 41)], reverse=True)
 
custs = []
print("\n\033[32m%s构造函数%s\033[0m" % ("-"*10, "-"*10))
for cust in customize:
    custs.append(cust)
    if len(custs) == 10:
        print(f"{custs[:10]}") 
    elif len(custs) == 20:
        print(f"{custs[10:20]}")
    elif len(custs) == 30:
        print(f"{custs[20:30]}")
    elif len(custs) == 40:
        print(f"{custs[30:41]}")
 
 
print("\n\033[32m%s反向循环%s" % ("-"*10, "-"*10))
 
custos = []
for n in Customize([v for v in range(41, 61)], reverse=False):
    custos.append(n)
    if len(custos) == 10:
        print(f"{custos[:10]}") 
    elif len(custos) == 20:
        print(f"{custos[10:20]}")
    elif len(custos) == 30:
        print(f"{custos[20:30]}")
    elif len(custos) == 40:
        print(f"{custos[30:41]}")
 
 
class Callable:
    def __init__(self, *args, **kwargs):
        self.args = args
        self.kwargs = kwargs
 
    def __call__(self):
        try:
            results = []
            results.append([self.args, self.kwargs])
            return [result for result in results]
        except Exception as e:
            print(e)
 
 
callable = Callable([i for i in range(3)], [j for j in range(4)], {"count": i for i in range(3)})  # 注意：这里i未定义，会报错
print(callable())

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