Как оптимизировать бесконечный итератор спирали улама?

Вы уже рассмотрели "memoize"/"skip". Вот более быстрые бесконечные итераторы. Время для первых 16384 координат (как в вашем тесте):

  1.01 ± 0.00 ms  gen_Kelly_4
  1.03 ± 0.00 ms  gen_Kelly_3
  1.06 ± 0.00 ms  gen_Kelly_2
  1.20 ± 0.00 ms  gen_Kelly_1
  1.57 ± 0.00 ms  gen_original

Python: 3.11.4 (main, Jun 24 2023, 10:18:04) [GCC 13.1.1 20230429]

Вы объединяете все итераторы zip со своим собственным генератором. Мой gen_Kelly_1 вместо этого использует chain.from_iterable для этого.

Вы используете функцию range для создания объектов int снова и снова. Мой gen_Kelly_2 вместо этого сохраняет их в списке и повторно использует.

Мой gen_Kelly_3 далее повторно использует итераторы repeat, а gen_Kelly_4 переворачивает мой список вместо использования обратных итераторов.

Полный код (Попробуйте онлайн!):

from timeit import timeit
from statistics import mean, stdev
from itertools import islice, repeat, cycle, chain, count
import sys

def gen_original():
    xc = yc = length = 0
    yield 0, 0
    while True:
        length += 1
        yield from zip(range(xc + 1, (xc := xc + length) + 1, 1), repeat(yc))
        yield from zip(repeat(xc), range(yc + 1, (yc := yc + length) + 1, 1))
        length += 1
        yield from zip(range(xc - 1, (xc := xc - length) - 1, -1), repeat(yc))
        yield from zip(repeat(xc), range(yc - 1, (yc := yc - length) - 1, -1))


def gen_Kelly_1():
    def parts():
        xc = yc = length = 0
        yield (0, 0),
        while True:
            length += 1
            yield zip(range(xc + 1, (xc := xc + length) + 1, 1), repeat(yc))
            yield zip(repeat(xc), range(yc + 1, (yc := yc + length) + 1, 1))
            length += 1
            yield zip(range(xc - 1, (xc := xc - length) - 1, -1), repeat(yc))
            yield zip(repeat(xc), range(yc - 1, (yc := yc - length) - 1, -1))
    return chain.from_iterable(parts())


def gen_Kelly_2():
    def parts():
        i = 0
        range = []
        while True:
            yield zip(repeat(-i), reversed(range))
            range.insert(0, -i)
            yield zip(range, repeat(-i))
            i += 1
            yield zip(repeat(i), range)
            range.append(i)
            yield zip(reversed(range), repeat(i))
    return chain.from_iterable(parts())


def gen_Kelly_3():
    def parts():
        i = 0
        range = []
        while True:
            rep = repeat(-i)
            yield zip(rep, reversed(range))
            range.insert(0, -i)
            yield zip(range, rep)
            i += 1
            rep = repeat(i)
            yield zip(rep, range)
            range.append(i)
            yield zip(reversed(range), rep)
    return chain.from_iterable(parts())


def gen_Kelly_4():
    def parts():
        i = 0
        range = []
        while True:
            rep = repeat(-i)
            yield zip(rep, range)
            range.append(-i)
            range.reverse()
            yield zip(range, rep)
            i += 1
            rep = repeat(i)
            yield zip(rep, range)
            range.append(i)
            range.reverse()
            yield zip(range, rep)
    return chain.from_iterable(parts())


funcs = gen_original, gen_Kelly_1, gen_Kelly_2, gen_Kelly_3, gen_Kelly_4

n = 16384

# Correctness
expect = list(islice(funcs[0](), n))
for f in funcs[1:]:
    result = list(islice(f(), n))
    assert result == expect

# Speed
times = {f: [] for f in funcs}
def stats(f):
    ts = [t * 1e3 for t in sorted(times[f])[:10]]
    return f'{mean(ts):6.2f} ± {stdev(ts):4.2f} ms '
for _ in range(1000):
    for f in funcs:
        t = timeit(lambda: list(islice(f(), n)), number=1)
        times[f].append(t)
for f in sorted(funcs, key=stats):
    print(stats(f), f.__name__)
print('\nPython:', sys.version)