Lặp lười, sequence vô hạn và toolset itertools

# Python viết:
for x in [10, 20, 30]:
    print(x)

# Ngầm tương đương:
_it = iter([10, 20, 30])   # lấy iterator
while True:
    try:
        x = next(_it)               # lấy giá trị kế tiếp
    except StopIteration:
        break                      # hết → thoát vòng
    print(x)

it = iter([1, 2, 3])
next(it)        # 1
next(it)        # 2
next(it)        # 3
next(it)        # StopIteration

# next có default — tránh exception
it = iter([1])
next(it, 'hết')   # 1
next(it, 'hết')   # 'hết'  (không raise)

class Countdown:
    """Đếm ngược từ start về 0."""

    def __init__(self, start: int):
        self.current = start

    def __iter__(self):
        return self        # chính nó là iterator

    def __next__(self):
        if self.current < 0:
            raise StopIteration
        v = self.current
        self.current -= 1
        return v

# Sử dụng
for n in Countdown(3):
    print(n)     # 3, 2, 1, 0

# Gotcha: chạy lại không reset
c = Countdown(3)
list(c)        # [3, 2, 1, 0]
list(c)        # []   ← state đã hết

class Range:
    def __init__(self, stop: int):
        self.stop = stop

    def __iter__(self):
        return _RangeIter(self.stop)  # iterator MỚI mỗi lần

class _RangeIter:
    def __init__(self, stop):
        self.i = 0
        self.stop = stop

    def __iter__(self):
        return self

    def __next__(self):
        if self.i >= self.stop:
            raise StopIteration
        v = self.i
        self.i += 1
        return v

r = Range(3)
list(r)        # [0, 1, 2]
list(r)        # [0, 1, 2]   ← lặp lại OK

def count_up_to(n: int):
    for i in range(n):
        yield i

g = count_up_to(3)   # KHÔNG chạy — chỉ tạo generator object
print(type(g))         # <class 'generator'>

next(g)               # 0   (chạy đến yield đầu, pause)
next(g)               # 1
next(g)               # 2
next(g)               # StopIteration

# Hoặc consume bằng for / list
list(count_up_to(5))   # [0, 1, 2, 3, 4]

for i in count_up_to(3):
    print(i)            # 0, 1, 2

def vai_buoc():
    print('A')
    yield 1
    print('B')
    yield 2
    print('C')

g = vai_buoc()
next(g)    # in 'A', trả 1
next(g)    # in 'B', trả 2
next(g)    # in 'C', rồi StopIteration

# List comprehension — EAGER, tạo cả list ngay
squares_list = [x**2 for x in range(10)]
type(squares_list)        # <class 'list'>
len(squares_list)         # 10

# Generator expression — LAZY, không compute trước
squares_gen = (x**2 for x in range(10))
type(squares_gen)         # <class 'generator'>
len(squares_gen)          # TypeError — generator không có len

# Khi truyền vào hàm nhận iterable, có thể bỏ () thừa:
sum(x**2 for x in range(10))    # 285  — đẹp, gọn
max(len(w) for w in words)

import sys

# 10 triệu int
lst = [i for i in range(10_000_000)]
gen = (i for i in range(10_000_000))

sys.getsizeof(lst)      # ~80,000,056 bytes  (~80MB)
sys.getsizeof(gen)      # 200 bytes  ← chênh 400,000 lần

def count():
    i = 0
    while True:
        yield i
        i += 1

# Cách 1: break khi đủ
for x in count():
    if x > 5:
        break
    print(x)        # 0, 1, 2, 3, 4, 5

# Cách 2: itertools.islice (slicing iterator)
from itertools import islice
list(islice(count(), 6))   # [0, 1, 2, 3, 4, 5]

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

list(islice(fibonacci(), 10))
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# Cách dài
def chain_old(*iterables):
    for it in iterables:
        for x in it:
            yield x

# Cách gọn — yield from
def chain(*iterables):
    for it in iterables:
        yield from it

list(chain([1, 2], (3, 4), range(5, 7)))
# [1, 2, 3, 4, 5, 6]

def flatten(items):
    for x in items:
        if isinstance(x, list):
            yield from flatten(x)   # đệ quy gọn
        else:
            yield x

list(flatten([1, [2, [3, [4, 5]], 6]]))
# [1, 2, 3, 4, 5, 6]

def echo():
    while True:
        received = yield          # yield không có giá trị bên phải
        print(f'Nhận: '{received}')

g = echo()
next(g)              # PHẢI prime — chạy đến yield đầu tiên
g.send('hello')    # in 'Nhận: hello'
g.send('world')    # in 'Nhận: world'
g.close()           # raise GeneratorExit bên trong → thoát

def safe_gen():
    try:
        while True:
            x = yield
            print(x)
    except ValueError:
        print('Bắt ValueError trong generator')
    finally:
        print('Cleanup')

g = safe_gen()
next(g)
g.send(1)               # in 1
g.throw(ValueError)     # inject exception
# → 'Bắt ValueError trong generator'
# → 'Cleanup'

from itertools import chain

list(chain([1, 2], (3, 4), range(5, 7)))
# [1, 2, 3, 4, 5, 6]

# chain.from_iterable — flatten 1 cấp
list(chain.from_iterable([[1, 2], [3], [4, 5]]))
# [1, 2, 3, 4, 5]

from itertools import count, cycle, repeat, islice

# count(start, step) — như range nhưng vô hạn
list(islice(count(10, 3), 5))     # [10, 13, 16, 19, 22]

# cycle — duyệt vòng vô hạn
list(islice(cycle(['A', 'B', 'C']), 7))
# ['A', 'B', 'C', 'A', 'B', 'C', 'A']

# repeat — lặp value
list(repeat('x', 3))                  # ['x', 'x', 'x']
list(islice(repeat(0), 4))           # [0, 0, 0, 0]

# Pattern: enumerate kết hợp count với offset
for i, ch in zip(count(100), 'abc'):
    print(i, ch)    # 100 a, 101 b, 102 c

from itertools import islice, count

list(islice(count(), 5))           # [0, 1, 2, 3, 4]   stop=5
list(islice(count(), 5, 10))       # [5, 6, 7, 8, 9]   start=5, stop=10
list(islice(count(), 0, 10, 2))    # [0, 2, 4, 6, 8]   start, stop, step

# LƯU Ý: không hỗ trợ index âm — vì iterator không biết "cuối"

from itertools import groupby

data = [1, 1, 2, 2, 1, 1]
for key, group in groupby(data):
    print(key, list(group))

# 1 [1, 1]
# 2 [2, 2]
# 1 [1, 1]    ← 3 group vì các nhóm "1" tách biệt

students = [
    {'name': 'An',    'class': 'A'},
    {'name': 'Bình',  'class': 'B'},
    {'name': 'Cường', 'class': 'A'},
    {'name': 'Dung',   'class': 'B'},
]

# PHẢI sort theo key trước!
keyfn = lambda s: s['class']
students.sort(key=keyfn)

for cls, group in groupby(students, key=keyfn):
    print(cls, [s['name'] for s in group])

# A ['An', 'Cường']
# B ['Bình', 'Dung']

from itertools import combinations, permutations, product

# combinations — chọn r, KHÔNG quan trọng thứ tự
list(combinations([1, 2, 3], 2))
# [(1, 2), (1, 3), (2, 3)]

# permutations — chọn r, CÓ quan trọng thứ tự
list(permutations([1, 2, 3], 2))
# [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

# product — tích Đề-các (thay nested loop)
list(product(['a', 'b'], [1, 2]))
# [('a', 1), ('a', 2), ('b', 1), ('b', 2)]

# product có repeat — duyệt mọi chuỗi length n
list(product([0, 1], repeat=3))
# [(0,0,0), (0,0,1), (0,1,0), ..., (1,1,1)]   ← bit pattern length 3

from itertools import accumulate
import operator

list(accumulate([1, 2, 3, 4]))
# [1, 3, 6, 10]    ← prefix sum (mặc định toán tử +)

list(accumulate([1, 2, 3, 4], operator.mul))
# [1, 2, 6, 24]    ← prefix product (factorial-like)

list(accumulate([5, 2, 8, 1], max))
# [5, 5, 8, 8]     ← running max

# Có thể truyền initial (Py 3.8+)
list(accumulate([1, 2, 3], initial=100))
# [100, 101, 103, 106]

from itertools import count, islice, takewhile

# Lấy 5 số chẵn đầu > 100
result = list(islice(
    (x for x in count(100) if x % 2 == 0),
    5
))
# [100, 102, 104, 106, 108]

# takewhile — lấy đến khi false (KHÁC filter ở chỗ dừng hẳn)
result = list(takewhile(lambda x: x < 50, count(40, 2)))
# [40, 42, 44, 46, 48]