class SimpleIterator:
    """自定義迭代器示例"""
    def __init__(self, max_value):
        self.max = max_value
        self.current = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current < self.max:
            self.current += 1
            return self.current
        raise StopIteration

# 手動(dòng)訪問(wèn)
it = SimpleIterator(5)
print(next(it))  # 1
print(next(it))  # 2
print(next(it))  # 3
print(next(it))  # 4
print(next(it))  # 5
try:
    print(next(it))  # 拋出StopIteration
except StopIteration:
    print("迭代結(jié)束")

def manual_iteration(iterable):
    """手動(dòng)迭代通用模式"""
    it = iter(iterable)
    try:
        while True:
            item = next(it)
            # 處理元素
            print(f"處理: {item}")
    except StopIteration:
        print("迭代完成")

# 使用示例
manual_iteration([1, 2, 3, 4, 5])

class StatefulIterator:
    """帶狀態(tài)的手動(dòng)迭代器"""
    def __init__(self, data):
        self.data = data
        self.index = 0
        self.state = 'active'
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.state == 'paused':
            raise StopIteration("迭代器已暫停")
        if self.index >= len(self.data):
            self.state = 'completed'
            raise StopIteration
        item = self.data[self.index]
        self.index += 1
        return item
    
    def pause(self):
        """暫停迭代"""
        self.state = 'paused'
    
    def resume(self):
        """恢復(fù)迭代"""
        if self.state == 'paused':
            self.state = 'active'
    
    def rewind(self, steps=1):
        """回退迭代"""
        self.index = max(0, self.index - steps)

# 使用示例
it = StatefulIterator([10, 20, 30, 40, 50])
print(next(it))  # 10
print(next(it))  # 20
it.rewind()      # 回退1步
print(next(it))  # 20
it.pause()
try:
    print(next(it))  # 拋出異常
except StopIteration as e:
    print(e)
it.resume()
print(next(it))  # 30

def multi_iterator_control(iterators):
    """多迭代器協(xié)同控制"""
    # 創(chuàng)建迭代器列表
    its = [iter(it) for it in iterators]
    active = [True] * len(its)
    
    while any(active):
        for i, it in enumerate(its):
            if not active[i]:
                continue
            try:
                item = next(it)
                yield (i, item)
            except StopIteration:
                active[i] = False

# 使用示例
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c', 'd']
list3 = [10.5, 20.5]

for source, value in multi_iterator_control([list1, list2, list3]):
    print(f"來(lái)源 {source}: {value}")

def process_large_file(file_path, chunk_size=1024):
    """手動(dòng)迭代處理大文件"""
    with open(file_path, 'r') as f:
        # 創(chuàng)建迭代器
        it = iter(lambda: f.read(chunk_size), '')
        
        try:
            while True:
                chunk = next(it)
                # 處理數(shù)據(jù)塊
                process_chunk(chunk)
                
                # 條件中斷
                if should_stop_processing():
                    print("處理中斷")
                    break
        except StopIteration:
            print("文件處理完成")

def process_chunk(chunk):
    """處理數(shù)據(jù)塊（示例）"""
    # 實(shí)際處理邏輯
    print(f"處理 {len(chunk)} 字節(jié)數(shù)據(jù)")

def should_stop_processing():
    """檢查是否停止處理（示例）"""
    # 實(shí)際條件檢查
    return False

# 使用示例
process_large_file('large_data.txt')

class StreamProcessor:
    """網(wǎng)絡(luò)流手動(dòng)迭代處理器"""
    def __init__(self, stream, buffer_size=4096):
        self.stream = stream
        self.buffer_size = buffer_size
        self.buffer = b''
        self.position = 0
        self.eof = False
    
    def __iter__(self):
        return self
    
    def __next__(self):
        """獲取下一個(gè)完整數(shù)據(jù)包"""
        while not self.eof:
            # 檢查緩沖區(qū)是否有完整數(shù)據(jù)包
            packet = self._extract_packet()
            if packet:
                return packet
            
            # 讀取更多數(shù)據(jù)
            self._fill_buffer()
        
        # 處理剩余數(shù)據(jù)
        if self.buffer:
            packet = self.buffer
            self.buffer = b''
            return packet
        
        raise StopIteration
    
    def _fill_buffer(self):
        """填充緩沖區(qū)"""
        data = self.stream.read(self.buffer_size)
        if not data:
            self.eof = True
        else:
            self.buffer += data
    
    def _extract_packet(self):
        """從緩沖區(qū)提取數(shù)據(jù)包（示例）"""
        # 查找結(jié)束符
        end_pos = self.buffer.find(b'\n', self.position)
        if end_pos == -1:
            return None
        
        # 提取數(shù)據(jù)包
        packet = self.buffer[self.position:end_pos]
        self.position = end_pos + 1
        return packet

# 使用示例（模擬網(wǎng)絡(luò)流）
class MockStream:
    def __init__(self, data):
        self.data = data
        self.position = 0
    
    def read(self, size):
        if self.position >= len(self.data):
            return b''
        chunk = self.data[self.position:self.position+size]
        self.position += size
        return chunk

# 模擬數(shù)據(jù)流
data = b'packet1\npacket2\npartial'
stream = MockStream(data)
processor = StreamProcessor(stream)

for packet in processor:
    print(f"收到數(shù)據(jù)包: {packet.decode()}")

class TreeNode:
    """樹(shù)節(jié)點(diǎn)"""
    def __init__(self, value):
        self.value = value
        self.children = []
    
    def add_child(self, node):
        self.children.append(node)

class TreeIterator:
    """樹(shù)結(jié)構(gòu)手動(dòng)迭代器（深度優(yōu)先）"""
    def __init__(self, root):
        self.stack = [root]
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if not self.stack:
            raise StopIteration
        
        # 彈出棧頂節(jié)點(diǎn)
        node = self.stack.pop()
        
        # 子節(jié)點(diǎn)逆序入棧（保證順序）
        for child in reversed(node.children):
            self.stack.append(child)
        
        return node.value

# 使用示例
root = TreeNode('A')
b = TreeNode('B')
c = TreeNode('C')
d = TreeNode('D')
root.add_child(b)
root.add_child(c)
b.add_child(d)

it = TreeIterator(root)
print("深度優(yōu)先遍歷:")
for value in it:
    print(value)

class GraphIterator:
    """圖結(jié)構(gòu)手動(dòng)迭代器（廣度優(yōu)先）"""
    def __init__(self, graph, start):
        self.graph = graph
        self.queue = collections.deque([start])
        self.visited = set([start])
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if not self.queue:
            raise StopIteration
        
        node = self.queue.popleft()
        
        # 添加未訪問(wèn)鄰居
        for neighbor in self.graph[node]:
            if neighbor not in self.visited:
                self.visited.add(neighbor)
                self.queue.append(neighbor)
        
        return node

# 使用示例
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

print("廣度優(yōu)先遍歷:")
it = GraphIterator(graph, 'A')
for node in it:
    print(node)

def coroutine_example():
    """協(xié)程手動(dòng)控制示例"""
    print("協(xié)程啟動(dòng)")
    try:
        while True:
            value = yield
            print(f"接收值: {value}")
    except GeneratorExit:
        print("協(xié)程退出")

# 手動(dòng)控制
coro = coroutine_example()
next(coro)  # 啟動(dòng)協(xié)程
coro.send(10)  # 發(fā)送值
coro.send(20)
coro.close()  # 關(guān)閉協(xié)程

import asyncio

class AsyncIterator:
    """異步迭代器"""
    def __init__(self, n):
        self.n = n
        self.current = 0
    
    def __aiter__(self):
        return self
    
    async def __anext__(self):
        if self.current >= self.n:
            raise StopAsyncIteration
        await asyncio.sleep(0.1)  # 模擬IO
        self.current += 1
        return self.current

async def manual_async_iteration():
    """手動(dòng)控制異步迭代"""
    aiter = AsyncIterator(5)
    try:
        while True:
            value = await aiter.__anext__()
            print(f"異步值: {value}")
    except StopAsyncIteration:
        print("異步迭代結(jié)束")

# 運(yùn)行
asyncio.run(manual_async_iteration())

def large_data_iterator(data_size=1000000):
    """內(nèi)存高效迭代器"""
    for i in range(data_size):
        # 生成數(shù)據(jù)（避免一次性加載）
        data = generate_data(i)
        yield data

def generate_data(index):
    """生成數(shù)據(jù)（示例）"""
    return f"數(shù)據(jù)項(xiàng)-{index}"

# 手動(dòng)處理
it = large_data_iterator()
count = 0
try:
    while True:
        item = next(it)
        process_item(item)
        count += 1
        if count % 100000 == 0:
            print(f"已處理 {count} 項(xiàng)")
except StopIteration:
    print(f"總共處理 {count} 項(xiàng)")

def process_item(item):
    """處理數(shù)據(jù)項(xiàng)（示例）"""
    # 實(shí)際處理邏輯
    pass

class DataPipeline:
    """手動(dòng)迭代數(shù)據(jù)管道"""
    def __init__(self):
        self.processors = []
    
    def add_processor(self, processor):
        """添加處理器"""
        self.processors.append(processor)
    
    def process(self, data_iter):
        """處理數(shù)據(jù)流"""
        it = iter(data_iter)
        for processor in self.processors:
            it = processor(it)
        return it

# 處理器示例
def filter_processor(predicate):
    """過(guò)濾處理器"""
    def process(input_iter):
        for item in input_iter:
            if predicate(item):
                yield item
    return process

def map_processor(mapper):
    """映射處理器"""
    def process(input_iter):
        for item in input_iter:
            yield mapper(item)
    return process

# 使用示例
pipeline = DataPipeline()
pipeline.add_processor(filter_processor(lambda x: x % 2 == 0))
pipeline.add_processor(map_processor(lambda x: x * 2))

data = [1, 2, 3, 4, 5, 6]
result_iter = pipeline.process(data)

# 手動(dòng)控制
print(next(result_iter))  # 4 (2 * 2)
print(next(result_iter))  # 8 (4 * 2)
print(next(result_iter))  # 12 (6 * 2)

class RealTimeMonitor:
    """實(shí)時(shí)監(jiān)控系統(tǒng)手動(dòng)迭代"""
    def __init__(self, data_source):
        self.data_source = data_source
        self.iterator = None
        self.running = False
    
    def start(self):
        """啟動(dòng)監(jiān)控"""
        self.iterator = iter(self.data_source)
        self.running = True
    
    def stop(self):
        """停止監(jiān)控"""
        self.running = False
    
    def process_next(self):
        """處理下一個(gè)數(shù)據(jù)點(diǎn)"""
        if not self.running or self.iterator is None:
            return None
        
        try:
            data = next(self.iterator)
            self._analyze(data)
            return data
        except StopIteration:
            self.stop()
            return None
    
    def _analyze(self, data):
        """數(shù)據(jù)分析（示例）"""
        print(f"分析數(shù)據(jù): {data}")
        # 實(shí)際分析邏輯

# 使用示例
class DataSource:
    """模擬數(shù)據(jù)源"""
    def __init__(self, max_count=5):
        self.count = 0
        self.max = max_count
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.count >= self.max:
            raise StopIteration
        self.count += 1
        return f"數(shù)據(jù)-{self.count}"

monitor = RealTimeMonitor(DataSource())
monitor.start()

# 手動(dòng)控制處理
while True:
    data = monitor.process_next()
    if data is None:
        break
    print(f"處理數(shù)據(jù): {data}")
    # 可以在此添加控制邏輯
    if data == "數(shù)據(jù)-3":
        print("暫停處理")
        break

# 繼續(xù)處理
print("繼續(xù)處理")
monitor.start()  # 重新啟動(dòng)
while True:
    data = monitor.process_next()
    if data is None:
        break
    print(f"處理數(shù)據(jù): {data}")

# 使用上下文管理器確保資源釋放
class SafeIterator:
    def __init__(self, resource):
        self.resource = resource
        self.it = iter(resource)

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.resource.close()

    def __next__(self):
        return next(self.it)

with SafeIterator(open('file.txt')) as it:
    print(next(it))

def robust_next(iterator, default=None):
    """健壯的next函數(shù)"""
    try:
        return next(iterator)
    except StopIteration:
        return default
    except Exception as e:
        log_error(e)
        return default

# 使用
it = iter([1, 2])
print(robust_next(it))  # 1
print(robust_next(it))  # 2
print(robust_next(it))  # None

# 避免不必要的屬性查找
def optimized_iteration(data):
    it = iter(data)
    next_item = it.__next__  # 緩存方法
    try:
        while True:
            item = next_item()
            process(item)
    except StopIteration:
        pass

# 使用生成器表達(dá)式
large_iter = (x * 2 for x in range(1000000))
# 手動(dòng)處理
item = next(large_iter)

class CustomIterator:
    """
    自定義迭代器文檔

    功能:
    - 支持手動(dòng)next調(diào)用
    - 支持狀態(tài)查詢
    - 支持回退操作

    示例:
        it = CustomIterator(data)
        item = next(it)
    """
    # 實(shí)現(xiàn)代碼

import unittest

class TestManualIteration(unittest.TestCase):
    def test_basic_next(self):
        it = iter([1, 2, 3])
        self.assertEqual(next(it), 1)
        self.assertEqual(next(it), 2)
        self.assertEqual(next(it), 3)
        with self.assertRaises(StopIteration):
            next(it)

    def test_custom_iterator(self):
        it = StatefulIterator([10, 20, 30])
        self.assertEqual(next(it), 10)
        it.rewind()
        self.assertEqual(next(it), 10)
        it.pause()
        with self.assertRaises(StopIteration):
            next(it)