"""Где проходит граница области видимости включения — и что через неё ходит.

ЗАЧЕМ ЭТО. Про включения знают одно: «переменная цикла наружу не течёт». Это
верно и это половина правила. Вторая половина в справочнике сформулирована так:

    However, aside from the iterable expression in the leftmost `for` clause,
    the comprehension is executed in a separate implicitly nested scope.

То есть граница проходит не по скобкам включения, а внутри него: первый
итерируемый вычисляется СНАРУЖИ, всё остальное — внутри. Из этого следуют три
вещи, которые обычно узнают по ошибке, и все три проверяются здесь запуском.

  1. Переменная цикла не течёт наружу.
  2. Первый итерируемый видит имена внешней области, остальные части — нет.
  3. В теле класса это даёт NameError на имя, которое написано строкой выше.
"""
import sys

print("PY", sys.version.split()[0])


def rule(title):
    print()
    print(title)
    print("-" * len(title))


# ------------------------------------------------- 1. переменная не течёт
rule("1. Переменная цикла наружу не течёт")

y = "значение снаружи"
squares = [y for y in range(3)]
print(f"  [y for y in range(3)] -> {squares}")
print(f"  y после включения     -> {y!r}")
print("  Обычный цикл вёл бы себя иначе:")
for y2 in range(3):
    pass
print(f"  for y2 in range(3) -> y2 после цикла = {y2!r}")


# ------------------------------------- 2. первый итерируемый — снаружи
rule("2. Первый итерируемый вычисляется снаружи, остальное — внутри")


class Prices:
    """Тело класса — единственное место, где разницу видно без ухищрений.

    Функция сюда не годится: у неё есть замыкание, и включение внутри функции
    видит её локальные имена нормально. У класса замыкания нет — справочник
    говорит об этом прямо: «The scope of names defined in a class block is
    limited to the class block; it does not extend to the code blocks of
    methods. This includes comprehensions and generator expressions».
    """

    raw = [2, 3, 5]
    multiplier = 10
    limit = 3

    # Первый итерируемый — виден.
    ok_first = [x for x in raw]

    # Имя в выражении — не видно.
    try:
        bad_expr = [x * multiplier for x in raw]
    except NameError as e:
        bad_expr = f"NameError: {e}"

    # Имя в условии — не видно.
    try:
        bad_cond = [x for x in raw if x > limit]
    except NameError as e:
        bad_cond = f"NameError: {e}"

    # Второй итерируемый — не виден.
    try:
        bad_second = [x + y for x in raw for y in raw]
    except NameError as e:
        bad_second = f"NameError: {e}"

    # А обычный цикл в том же теле класса видит всё.
    loop = []
    for x in raw:
        loop.append(x * multiplier)


print(f"  [x for x in raw]                 -> {Prices.ok_first}")
print(f"  [x * multiplier for x in raw]    -> {Prices.bad_expr}")
print(f"  [x for x in raw if x > limit]    -> {Prices.bad_cond}")
print(f"  [x + y for x in raw for y in raw]-> {Prices.bad_second}")
print(f"  тот же цикл через for/append     -> {Prices.loop}")
print()
print("  Четыре строки подряд в одном теле класса. Первая работает, потому что")
print("  raw — первый итерируемый. Три следующие падают. Пятая работает,")
print("  потому что обычный цикл никакой отдельной области не заводит.")


# -------------------------------------------- 3. внутри функции всё иначе
rule("3. Внутри функции тех же ошибок нет")


def inside_function():
    raw = [2, 3, 5]
    multiplier = 10
    limit = 3
    return (
        [x * multiplier for x in raw],
        [x for x in raw if x > limit],
        [x + y for x in raw for y in raw][:3],
    )


expr, cond, second = inside_function()
print(f"  [x * multiplier for x in raw]     -> {expr}")
print(f"  [x for x in raw if x > limit]     -> {cond}")
print(f"  [x + y for x in raw for y in raw] -> {second} ...")
print()
print("  Ровно тот же код, что падал в теле класса. Разница не во включении,")
print("  а в том, что у функции есть замыкание, а у тела класса нет.")