🧠 Python-задача с собеседования: найди ошибку

Код должен посчитать количество чисел больше среднего значения в списке.

def count_above_avg(nums, avg=sum(nums)/len(nums)):
    count = 0
    for n in nums:
        if n > avg:
            count += 1
    return count

data1 = [1, 2, 3, 4, 5]
data2 = [10, 20, 30]

print(count_above_avg(data1))
print(count_above_avg(data2))

Проблема в этой строке:

```python
def count_above_avg(nums, avg=sum(nums)/len(nums)):
```
Здесь используется значение по умолчанию, которое вычисляется один раз — в момент определения функции, а не при каждом её вызове.

Что происходит по шагам:

Когда Python читает определение функции, он сразу считает:

sum(nums)/len(nums)
Но nums в этот момент - это первый переданный список, то есть data1.

Значение avg фиксируется и больше не меняется.

При вызове:

• count_above_avg(data2)
• среднее значение не пересчитывается, используется старое — от data1.

Поэтому логика ломается, функция работает с неверным средним.

📌 Это известная ловушка Python
Значения аргументов по умолчанию вычисляются один раз.
Это та же причина, почему списки и словари в дефолтных параметрах часто приводят к багам.

🛠 Правильное решение
Нужно вычислять среднее внутри функции, а не в параметрах:

```python
def count_above_avg(nums, avg=None):
if avg is None:
avg = sum(nums) / len(nums)
return sum(1 for n in nums if n > avg)
```

Теперь среднее будет считаться заново при каждом вызове.

💡 Главное правило
Никогда не используй вычисляемые или изменяемые объекты как значения по умолчанию:

❌ def f(x, lst=[])
❌ def f(x, avg=sum(x)/len(x))

✅ Используй None и считай внутри функции.

⚡️ Экономичный способ развернуть DeepSeek локально запускай модель через Ollama.

Так ты получаешь мощную LLM на своём ПК без облака и без огромных требований к железу.

Что важно:

- выбирай DeepSeek Distill 7B/8B или 14B
- формат GGUF + квантизация Q4 (лучший баланс)
- поднимаешь как локальный API и дергаешь из Python, бота или агента

Плюс:

- приватность - всё работает локально
- дешево - не нужен сервер
- можно быстро менять модель, не трогая код

# 1) Установи Ollama (macOS/Linux/Windows)
# https://ollama.com

# 2) Запусти экономичную DeepSeek модель
ollama pull deepseek-r1:8b
ollama run deepseek-r1:8b

# 3) Проверка: запрос к локальному API
curl http://localhost:11434/api/generate \
  -d '{"model":"deepseek-r1:8b","prompt":"Explain transformers simply","stream":false}'

# 4) Использование из Python
python - << 'PY'
import requests

r = requests.post(
    "http://localhost:11434/api/generate",
    json={
        "model": "deepseek-r1:8b",
        "prompt": "Сделай краткий план изучения SQL за 7 дней",
        "stream": False
    },
    timeout=120
)

print(r.json()["response"])
PY

https://www.youtube.com/shorts/zjn2pXrGbXI

🧊 pyPFC - Python-библиотека для Phase Field Crystal (PFC) симуляций

Если ты занимаешься моделированием материалов, кристаллов или фазовых переходов - сохрани.
pyPFC позволяет запускать PFC-симуляции быстро и удобно прямо на Python.

Что такое Phase Field Crystal (PFC)?
PFC (Phase Field Crystal) - это метод моделирования, который описывает материал как непрерывное поле плотности.

Проще:
- вместо того чтобы симулировать каждый атом отдельно (как в molecular dynamics)
- PFC моделирует “узор кристаллической решётки” как волну/поле

За счёт этого PFC может моделировать процессы на более длинных временных масштабах, чем классические атомарные симуляции.

PFC используют, чтобы изучать:
- рост кристаллов и формирование структуры
- дефекты решётки (дислокации)
- зернистость и границы зёрен
- фазовые переходы и самоорганизацию
- поведение материалов при охлаждении/нагреве

Что даёт pyPFC:
⚡ ускорение на GPU через PyTorch (можно гонять и на CPU, и на RTX)
🧪 готовые 3D-симуляции, примеры, эксперименты
🧩 удобно для исследований и обучения
📦 open-source проект + нормальная инженерная структура

GitHub:
https://github.com/HHallb/pyPFC

Используй `pdb` вместо print для надежной отладки!

Использование оператора `print` для отладки может привести к недоразумениям и пропущенным ошибкам, поскольку он не позволяет видеть контекст выполнения программы. Вместо этого используйте встроенные инструменты для отладки, такие как `pdb`, которые дают возможность устанавливать точки остановки, отслеживать выполнение и исследовать состояние переменных в реальном времени.

Подписывайся, больше фишек каждый день !

import pdb
def calculate_factorial(n):
    if n < 0:
        raise ValueError("Negative values are not allowed")
    elif n == 0:
        return 1
    else:
        return n * calculate_factorial(n - 1)
def main():
    num = 5
    pdb.set_trace()  # Запускаем отладчик здесь
    result = calculate_factorial(num)
    print(f"Factorial of {num} is {result}")
if __name__ == "__main__":
    main()

  t.me/ai_machinelearning_big_data - наш телеграм канал с уроками

🧩 Минималистичный код для Claude

Nanocode — это компактная альтернатива Claude Code, реализованная в одном файле на Python без зависимостей. Он включает полный агентный цикл с использованием инструментов для работы с файлами и ведения истории беседы.

🚀Основные моменты:
- Полный агентный цикл с использованием инструментов
- Инструменты: read, write, edit, glob, grep, bash
- Ведение истории беседы
- Цветной вывод в терминале

📌 GitHub: https://github.com/1rgs/nanocode

#python

🔥 КАК РАБОТАЕТ ВНИМАНИЕ (ATTENTION) В ТРАНСФОРМЕРАХ

Механизм внимания - это способ для модели “смотреть” на разные слова в тексте и решать, какие из них сейчас важнее.

Представь фразу: “Я положил ключи на стол, потому что он был рядом”.
Слово “он” должно ссылаться на “стол”, а не на “ключи”.
Внимание делает ровно это - для каждого слова вычисляет, на какие другие слова нужно опираться сильнее.

Как это работает в одном абзаце:

Для каждого токена модель строит три вектора - Query (что я ищу), Key (что я из себя представляю), Value (какую информацию несу).

Считается “похожесть” Query к каждому Key - это оценки важности.

Оценки нормализуются (softmax), чтобы получились веса от 0 до 1.

Итоговое представление токена - это взвешенная сумма Value по всем токенам.
То есть модель смешивает информацию из контекста, но делает это умно - больше веса тем словам, которые сейчас важны.

Почему это суперсила:
вместо того чтобы читать текст строго слева направо, модель может связывать дальние куски, находить нужные факты и строить смысловые зависимости. Именно поэтому трансформеры так хорошо работают с языком, кодом и длинным контекстом.

import numpy as np

def softmax(x: np.ndarray) -> np.ndarray:
    x = x - np.max(x)          # стабилизация
    e = np.exp(x)
    return e / np.sum(e)

# Допустим, у нас 3 токена в контексте.
# Для простоты возьмём маленькую размерность векторов (d=2).
# Query - "что я ищу"
# Key   - "что я такое"
# Value - "какую инфу несу"

Q = np.array([1.0, 0.5])  # Query для текущего токена (например, слово "он")

K = np.array([
    [1.0, 0.0],  # Key токена 1 (например, "ключи")
    [0.9, 0.1],  # Key токена 2 (например, "стол")
    [0.0, 1.0],  # Key токена 3 (например, "рядом")
])

V = np.array([
    [10.0, 0.0],  # Value токена 1
    [0.0, 10.0],  # Value токена 2
    [5.0, 5.0],   # Value токена 3
])

# 1) Считаем "похожесть" Q на каждый K через скалярное произведение
scores = K @ Q  # shape: (3,)
print("scores:", scores)

# 2) Нормализуем оценки -> получаем веса внимания
weights = softmax(scores)
print("attention weights:", weights)

# 3) Итоговый вектор = взвешенная сумма Value
output = weights @ V  # shape: (2,)
print("output (context mixed):", output)

# Интерпретация:
# Если вес токена 2 ("стол") самый большой, значит модель "смотрит" на него сильнее всего.

🐍 Самая крутая фича Python 3.14 - `sys.remote_exec()` (объясняю по-человечески)

Идея простая:
✅ у тебя уже запущено Python-приложение (например FastAPI в Docker/K8s)
✅ оно уже дошло до нужного состояния (в памяти есть переменные, сессии, кеши)
❌ но тебе нужно посмотреть “что внутри” или поставить дебаггер

Раньше ты делал так:
- добавлял debugpy в код
- перезапускал приложение
- заново воспроизводил баг

Python 3.14 даёт новый чит-код:

sys.remote_exec() позволяет выполнить кусок Python-кода ВНУТРИ уже работающего Python-процесса.
То есть буквально “вколоть” скрипт в живой процесс.

Это как:
🔹 зайти внутрь процесса
🔹 выполнить print(), импорт, запись переменных
🔹 или даже подключить дебаггер
без рестарта вообще.


Пример: что можно сделать через sys.remote_exec()

Допустим у нас есть работающий процесс Python.

1) Мы хотим “добавить” туда код:
- вывести PID
- посмотреть глобальные переменные
- записать лог
- даже поменять значение переменной

# Этот код выполняется СНАРУЖИ и запускает инжект внутрь процесса
import sys

target_pid = 12345  # PID запущенного Python процесса

payload = r"""
import os
import time

print("✅ Injected into running process!")
print("PID:", os.getpid())
print("Time:", time.time())

# Пример: читаем что есть в глобальном пространстве
g = globals()
print("Globals keys sample:", list(g.keys())[:10])

# Пример: создаём переменную прямо в процессе
INJECTED_FLAG = True
"""

# Новое API Python 3.14
sys.remote_exec(target_pid, payload)

Пример 2: инжектим debugpy (дебаг без рестарта)

Самая хайповая штука - можно подключить debugpy в уже живое приложение.
То есть приложение уже крутится, у него есть состояние, и ты просто включаешь “прослушку” дебаггера на порту.

import sys

target_pid = 12345  # PID работающего uvicorn / fastapi процесса

payload = r"""
import debugpy

HOST = "0.0.0.0"
PORT = 5679

debugpy.listen((HOST, PORT))
print(f"🐞 debugpy is listening on {HOST}:{PORT}")

# если хочешь остановить выполнение и ждать пока подключишь IDE:
# debugpy.wait_for_client()
# print("✅ debugger attached!")
"""

sys.remote_exec(target_pid, payload)

Дальше:
- ты делаешь port-forward (если Docker/K8s)
- подключаешь VS Code / PyCharm / nvim к localhost:5679
- ставишь breakpoints и дебажишь как обычно


Что важно

1) Это не “удалённое выполнение” как ssh.
Это прям “внутри процесса” - доступ к памяти, переменным, импортам.

2) Это опасно для продакшена.
Требует прав уровня SYS_PTRACE (можно читать/менять процессы) - поэтому только для локалки/стендов.

3) Это может стать стандартом для отладки контейнеров:
- баг воспроизводится только в k8s
- рестарт = баг пропал
- а тут просто подключился и посмотрел

https://www.youtube.com/watch?v=bYPFktmui4c

🐳 Как запустить DeepSeek у себя на ПК через Python

Главная ошибка новичков - сразу ставить огромные модели.
Начни с компактной версии, проверь, что всё запускается, и только потом увеличивай размер.

Алгоритм простой:
1) ставим зависимости
2) качаем лёгкую модель DeepSeek
3) проверяем, что она отвечает
4) при необходимости включаем GPU или берём квантизованную версию

Так ты избежишь вылетов, перегрузки памяти и быстрее получишь рабочий результат.

установить зависимости
pip install transformers accelerate torch sentencepiece

# пример запуска DeepSeek из Python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "deepseek-ai/deepseek-coder-6.7b-base"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"   # если есть GPU — модель сама её использует
)

prompt = "Напиши на Python функцию, которая проверяет, простое ли число."

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=160,
    temperature=0.4
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))