👩‍💻 Как Python хранит переменные: ссылки, а не значения

В Python переменные — это не “коробки с данными”, а имена, указывающие на объекты в памяти.

Когда ты присваиваешь значение, создаётся объект, а имя просто ссылается на него.

➡️ Пример:

x = [1, 2, 3]
y = x
y.append(4)

print(x)  # [1, 2, 3, 4]
print(x is y)  # True

x и y указывают на один и тот же объект — изменения отражаются в обоих. Чтобы создать независимую копию, нужно использовать copy() или модуль copy.

📌 В Python важно понимать: присваивание не копирует данные, а лишь создаёт новую ссылку.
Отсюда рождаются большинство «неожиданных» багов у новичков

👩‍💻 Замыкания (closures) — функции, которые помнят контекст

В Python функция может «запомнить» значения из внешней области, даже если она уже не существует.

Это и есть замыкание — ключевой инструмент для инкапсуляции логики и данных без классов

➡️ Пример:

def make_multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply

double = make_multiplier(2)
print(double(5))  # 10

multiply помнит значение factor, даже после завершения make_multiplier. То есть double — это функция, замкнувшая внутри себя factor = 2.

📌 Замыкания лежат в основе декораторов, фабрик функций и ленивых вычислений.
Понимание этой концепции — шаг от простого Python к "питонистому" коду

👩‍💻 Как Python ищет переменные (LEGB Rule)

Когда ты обращаешься к переменной, Python ищет её не хаотично, а строго по цепочке LEGB:
Local → Enclosing → Global → Built-in

➡️ Пример:

x = "глобальная"

def outer():
    x = "замыкание"
    def inner():
        x = "локальная"
        print(x)
    inner()

outer()

локальная

Если убрать x = "локальная", Python возьмёт x из ближайшей внешней области — "замыкание".
Если и там нет — из глобальной.

📌 Понимание LEGB помогает избегать неожиданных конфликтов имён и багов при работе с функциями и замыканиями

❓ Зачем используется метод querySelectorAll() в JavaScript и когда его применять?

Метод querySelectorAll() возвращает список всех элементов, соответствующих указанному CSS-селектору. Это удобно, когда нужно сразу получить несколько элементов для обработки или изменений.

✅Пример:

<ul>
  <li class="item">Apple</li>
  <li class="item">Banana</li>
  <li class="item">Orange</li>
</ul>

<script>
  const items = document.querySelectorAll(".item");
  items.forEach(el => el.style.color = "blue");
</script>

📌В этом примере querySelectorAll() выбирает все элементы с классом item и меняет их цвет

querySelectorAll() удобно использовать при работе со списками, карточками, формами и динамическими интерфейсами. Он поддерживает любые CSS-селекторы и позволяет легко применять массовые изменения к группе элементов

👩‍💻 Как Python хранит функции: всё — объекты

В Python функции — это не особый синтаксис, а объекты первого класса.

Их можно присваивать переменным, передавать в другие функции и возвращать как значения

➡️ Пример:

def greet(name):
    return f"Привет, {name}!"

say_hello = greet        # присвоили функцию переменной
print(say_hello("Анна")) # Привет, Анна!

def run(func, arg):
    print(func(arg))

run(greet, "Борис")      # можно передавать функцию как аргумент

📌 Понимание, что функции — такие же объекты, как строки или списки,
открывает путь к лямбдам, декораторам и функциональному стилю в Python

👩‍💻 Передача изменяемых объектов в функции

В Python аргументы передаются по ссылке на объект, а не по значению.

Если функция изменяет мутабельный объект (список, словарь), изменения сохраняются снаружи

➡️ Пример:

def add_item(items):
    items.append("новый элемент")

data = ["a", "b"]
add_item(data)

print(data)  # ['a', 'b', 'новый элемент']

📌 Функция не вернула новый список — она изменила существующий. Чтобы избежать этого, передавай копию (items[:] или items.copy()).

👩‍💻 Замыкания в Python — функция внутри функции

Замыкание (closure) — это функция, которая "запоминает" значения из внешней области видимости, даже если эта область уже недоступна.

Это один из способов создавать функции с состоянием, не используя классы

➡️ Пример:

def counter():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner

c = counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

📌 inner() помнит переменную count между вызовами, потому что она «замкнута» из внешней функции

👩‍💻 Декораторы с аргументами — динамическое управление поведением функции

Декораторы в Python могут принимать параметры, что делает их особенно мощными.

Это позволяет менять поведение функций в зависимости от внешних условий, не переписывая код

➡️ Пример:

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet():
    print("Привет!")

greet()
# Привет!
# Привет!
# Привет!

📌 Здесь repeat(3) создаёт декоратор, который повторяет выполнение функции 3 раза

👩‍💻 Замыкания в Python — функции с памятью

Замыкание (closure) — это функция, которая «запоминает» значения переменных из области видимости, где она была создана, даже если эта область уже недоступна.

Это мощный инструмент для инкапсуляции состояния без классов

➡️ Пример:

def counter(start=0):
    count = start
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

click = counter(10)
print(click())  # 11
print(click())  # 12

📌 Функция increment хранит доступ к переменной count, даже после выхода из counter