# your code goes here
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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