1def count_up():
2    n = 1
3    while True:
4        yield n
5        n += 1
6
7gen = count_up()
8
9# Pick the first item
10first = next(gen)
11print(first)  # 1
12
13# Pick the second item (generator remembers its position)
14second = next(gen)
15print(second)  # 2
16
17# Pick the third
18third = next(gen)
19print(third)  # 3

1def limited():
2    yield "a"
3    yield "b"
4
5gen = limited()
6print(next(gen))  # "a"
7print(next(gen))  # "b"
8
9# Generator is exhausted
10# next(gen)  # Raises StopIteration
11
12# Use a default value to avoid the exception
13print(next(gen, "nothing"))  # "nothing"
14print(next(gen, None))       # None

1# Generator expression with a condition
2numbers = iter(range(100))
3first_even_over_50 = next(x for x in numbers if x > 50 and x % 2 == 0)
4print(first_even_over_50)  # 52
5
6# Finding a matching item in a large dataset
7def read_large_file(path):
8    with open(path) as f:
9        for line in f:
10            yield line.strip()
11
12# Stops reading as soon as the first match is found
13first_error = next(
14    (line for line in read_large_file("app.log") if "ERROR" in line),
15    "No errors found"
16)
17print(first_error)

1from itertools import islice
2
3def fibonacci():
4    a, b = 0, 1
5    while True:
6        yield a
7        a, b = b, a + b
8
9# Get the 10th Fibonacci number (0-indexed)
10gen = fibonacci()
11tenth = next(islice(gen, 10, 11))
12print(tenth)  # 55
13
14# Get the first 5 items as a list
15gen = fibonacci()
16first_five = list(islice(gen, 5))
17print(first_five)  # [0, 1, 1, 2, 3]
18
19# Skip the first 100 items, take the next one
20gen = fibonacci()
21item_101 = next(islice(gen, 100, 101))
22print(item_101)  # 354224848179261915075

1import random
2from itertools import islice
3
4def data_stream():
5    for i in range(1000):
6        yield f"item-{i}"
7
8# Method 1: Reservoir sampling (O(n) memory: O(1))
9def random_from_generator(gen):
10    chosen = next(gen)
11    for i, item in enumerate(gen, start=2):
12        if random.randint(1, i) == 1:
13            chosen = item
14    return chosen
15
16result = random_from_generator(data_stream())
17print(result)  # Random item from the stream
18
19# Method 2: If you know the length, pick an index
20gen = data_stream()
21n = 1000
22idx = random.randrange(n)
23random_item = next(islice(gen, idx, idx + 1))
24print(random_item)

1from collections import deque
2
3def limited_gen():
4    yield 1
5    yield 2
6    yield 3
7
8# Method 1: deque with maxlen=1
9last = deque(limited_gen(), maxlen=1)[0]
10print(last)  # 3
11
12# Method 2: Loop to the end
13gen = limited_gen()
14for last_item in gen:
15    pass
16print(last_item)  # 3
17
18# Method 3: Consume and return last (functools.reduce)
19from functools import reduce
20last = reduce(lambda _, x: x, limited_gen())
21print(last)  # 3

1from itertools import islice
2
3def infinite_stream():
4    i = 0
5    while True:
6        yield f"event-{i}"
7        i += 1
8
9gen = infinite_stream()
10
11# Pick first 3
12batch1 = list(islice(gen, 3))
13print(batch1)  # ['event-0', 'event-1', 'event-2']
14
15# Pick next 3 (generator remembers position)
16batch2 = list(islice(gen, 3))
17print(batch2)  # ['event-3', 'event-4', 'event-5']
18
19# Batch processing pattern
20def batched(gen, size):
21    while True:
22        batch = list(islice(gen, size))
23        if not batch:
24            break
25        yield batch
26
27for batch in batched(infinite_stream(), 5):
28    print(batch)
29    if batch[-1] == "event-14":
30        break