日志还没读完，怎样只留三条，又让每条都有同样机会？

"""Algorithm R plus exact small-case probability checks; no third parties."""
import itertools
import json
import math
import random
from collections import defaultdict
from fractions import Fraction


def reservoir(items, k, rng):
    if type(k) is not int or k < 0:
        raise ValueError("k must be a nonnegative integer")
    sample = []
    for seen, item in enumerate(items, start=1):
        if seen <= k:
            sample.append(item)
        else:
            slot = rng.randrange(seen)
            if slot < k:
                sample[slot] = item
    return sample


class Choices:
    """Supply an exhaustive choice path instead of a pseudorandom generator."""
    def __init__(self, choices):
        self.choices = iter(choices)

    def randrange(self, stop):
        value = next(self.choices)
        if not 0 <= value < stop:
            raise AssertionError("invalid exact branch")
        return value


def exact_distribution(n, k):
    # Every path has probability 1 / ((k+1) * ... * n).
    branches = [range(seen) for seen in range(k + 1, n + 1)]
    denominator = math.prod(len(branch) for branch in branches)
    distribution = defaultdict(Fraction)
    for choices in itertools.product(*branches):
        chosen = reservoir(range(n), k, Choices(choices))
        distribution[tuple(sorted(chosen))] += Fraction(1, denominator)
    return dict(distribution)


def wrong_half_distribution(n):
    probabilities = [Fraction(1)]
    for _ in range(1, n):
        probabilities = [prob / 2 for prob in probabilities] + [Fraction(1, 2)]
    return [str(prob) for prob in probabilities]


def main():
    checks = 0
    for n in range(7):
        for k in range(n + 1):
            distribution = exact_distribution(n, k)
            expected = {subset: Fraction(1, math.comb(n, k))
                        for subset in itertools.combinations(range(n), k)}
            assert distribution == expected, (n, k)
            checks += 1
    assert reservoir([], 3, random.Random(17)) == []
    checks += 1
    assert reservoir(iter(["same", "same"]), 3, random.Random(17)) == ["same", "same"]
    checks += 1
    try:
        reservoir([1], -1, random.Random(17))
        raise AssertionError("negative k was accepted")
    except ValueError:
        checks += 1
    consumed = []

    def stream():
        for item in range(20):
            consumed.append(item)
            yield item

    sampled = reservoir(stream(), 3, random.Random(17))
    assert consumed == list(range(20)) and len(set(sampled)) == 3
    checks += 1
    exact = exact_distribution(5, 2)
    inclusion = {str(item): str(sum(prob for subset, prob in exact.items() if item in subset))
                 for item in range(5)}
    wrong = wrong_half_distribution(4)
    assert wrong == ["1/8", "1/8", "1/4", "1/2"]
    checks += 1
    report = {"checks_passed": checks,
              "one_pass_seed_17_sample_from_20": sampled,
              "N5_K2_subset_count": len(exact),
              "probability_of_each_pair": sorted({str(prob) for prob in exact.values()}),
              "inclusion_probability": inclusion,
              "wrong_half_replacement_N4_K1": wrong,
              "boundary": "exact enumeration checks algorithm branches, not RNG quality"}
    print(json.dumps(report, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()