Python вопросы с собеседований

⚠️ ИИ вызывает новый дефицит памяти Дата-центры для AI потребляют столько памяти, что её начинает не хватать остальной электронике. Что происходит на рынке: - Контрактные цены на DRAM выросли на 75% всего за месяц - Поставщики пересматривают цены ежедневно - Основные объёмы памяти уходят в AI-серверы Главная причина - переход на HBM (High Bandwidth Memory). HBM - это многослойная память (8–12 слоёв DRAM), которая работает рядом с ускорителями Nvidia и AMD и обеспечивает экстремальную пропускную способность. Масштаб потребления: - Один ускоритель Nvidia Blackwell — до 192 GB HBM - Система NVL72 - 13.4 TB памяти Прогнозы: - Спрос на HBM вырастет на 70% в 2026 году - Уже сейчас HBM занимает 23% производства DRAM (против 19% в 2025) Что это значит для рынка: Обычной памяти становится меньше для: - смартфонов - ПК - автомобилей - игровых консолей Выигрывают производители: Samsung, SK Hynix, Micron - рост маржи. Проигрывают продуктовые команды и компании, которые не могут заранее выкупить поставки. Главный вывод: ИИ начинает влиять не только на софт и модели. Он уже перераспределяет физические ресурсы всей индустрии электроники.

🖥 Шпаргалка по регулярным выражениям в Python Сохрани себе полезную шпаргалку по регулярным выражениям в Python. Эти выражения позволяют эффективно находить и обрабатывать текстовые данные. Важно знать базовые функции и методы, чтобы упростить свою работу с текстом.

import re
# Пример текста

text = "Контакт: example@example.com, телефон: +7-123-456-7890"

# Регулярные выражения для извлечения email и телефона
email_pattern = r'\b[\w.-]+?@\w+?\.\w{2,4}\b'
phone_pattern = r'\+?\d{1,2}[- ]?\d{3}[- ]?\d{3}[- ]?\d{4}'

# Найти все совпадения
emails = re.findall(email_pattern, text)
phones = re.findall(phone_pattern, text)

# Результат
print("Найденные email:", emails)
print("Найденные телефоны:", phones)

🖥 Новый курс на Stepik - PostgreSQL для разработчиков: от основ к созданию API Здесь на пальцах объясняют не только как писать SQL-запросы, а строить настоящие backend-сервисы с базой данных как у профи. В этом курсе ты шаг за шагом создашь REST API на FastAPI + PostgreSQL: от установки среды и первых таблиц - до масштабируемого приложения с безопасностью и CRUD-операциями. 🔹 На практике разберете: • SQL-запросы, фильтры, агрегаты и подзапросы • Связи между таблицами и нормализацию БД • Взаимодействие Python и PostgreSQL • Реализацию REST API и подключение базы • Оптимизацию и разбор реальных задач с собеседований ⚡ После курса у вас будет свой работающий API-проект и реальные навыки работы с PostgreSQL в продакшене. 🎁 Торопись пока действует скидка в честь нвого года! 🚀 Прокачаю свои знания: https://stepik.org/course/255542/

Идеальный старт для проекта Django: конфигурация окружения. Сохрани себе идеальный шаблон virtual environment и основных настроек для каждого нового проекта Django. Это упростит процесс настройки окружения и позволит избежать распространенных ошибок.

# Создание виртуального окружения
python3 -m venv venv

# Активация виртуального окружения
source venv/bin/activate

# Установка основных зависимостей
pip install django djangorestframework psycopg2

# Создание файла requirements.txt
pip freeze > requirements.txt

# Инициализация нового проекта Django
django-admin startproject myproject
# Переход в директорию проекта
cd myproject

# Запуск сервера для проверки
python manage.py runserver

🐳 Как запустить 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))

⚡️ Cowork стал доступен на Windows. Пользователи Windows теперь могут использовать все возможности Cowork: прямой доступ к файлам, выполнение многошаговых задач, поддержку плагинов и всех коннекторов MCP. Ранее этот функционал был эксклюзивом для яблочной платформы. Попутно Anthropic представила гибкую систему инструкций. Вы можете задать глобальные предпочтения: тон, формат ответов или описание своей роли, они будут применяться ко всем чатам. Также появились инструкции уровня папок: они активируются автоматически, когда вы работаете в конкретной директории. Обновлять эти настройки можно прямо в ходе диалога, не копаясь в меню. Инструмент все еще в стадии research preview и открыт для всех пользователей платных тарифов. Для доступа достаточно скачать свежую версию клиента с сайта. @ai_machinelearning_big_data #news #ai #ml

🖥 Python: пакет packaging стал ощутимо быстрее — и это реально заметно в больших проектах Свежий апдейт библиотеки packaging (библиотека, которую используют pip и многие инструменты для сравнения версий и работы с зависимостями) принёс заметное ускорение ключевых операций. Это важно, потому что такие функции вызываются тысячи раз при установке зависимостей, разрешении версий и т.д. Главное, что ускорили: • Быстрее парсинг и сравнение версий (`Version` и `SpecifierSet`). • Некоторые операции (сравнения, фильтрации, хэши) стали в несколько раз быстрее. • Оптимизации направлены на самые “узкие места”, которые чаще всего тормозят pip и другие инструменты. Почему это важно для тебя: • pip будет работать быстрее при установке больших стеков зависимостей. • Инструменты сборки и CI/CD быстрее считают совместимость версий. • Оптимизация сделана без потери корректности и без усложнения API. В целом это пример, как базовая утилита в экосистеме Python может ускориться не из-за нового синтаксиса, а за счёт глубокого профилирования и целевых улучшений. Подробнее о скорости и измерениях — в исходном разборе изменений. https://iscinumpy.dev/post/packaging-faster/

🖥 АВТОКЛИКЕР НА PYTHON ЗА 30 СЕКУНД. Автокликер — одна из самых полезных мини-автоматизаций на Python. Он помогает убрать рутину: клики в интерфейсах, тестирование кнопок, автоматическое выполнение повторяющихся действий в браузере или приложениях. Главная идея — управлять мышью программно. Библиотека pyautogui позволяет: • кликать в нужной точке экрана • двигать курсор • задавать интервалы между действиями • быстро остановить скрипт при необходимости Такой подход часто используют для: • UI-тестирования • автоматизации веб-задач • игр и симуляторов • массовых операций в админках Важно: всегда добавляйте задержку перед запуском, чтобы успеть переключиться в нужное окно. И используйте паузы между кликами, чтобы не перегружать систему.

Установка:
pip install pyautogui

import pyautogui
import time

# Безопасность: переместите мышь в верхний левый угол, чтобы аварийно остановить
pyautogui.FAILSAFE = True

# Пауза перед стартом (5 секунд, чтобы открыть нужное окно)
print("Старт через 5 секунд...")
time.sleep(5)

# Координаты для клика (узнать можно через pyautogui.position())
x, y = 800, 500

# Количество кликов
clicks = 100

# Интервал между кликами (в секундах)
interval = 0.5

for i in range(clicks):
    pyautogui.click(x, y)
    print(f"Клик {i+1}")
    time.sleep(interval)

print("Готово!")

⚡️Max

🐍 Самая крутая фича 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

🔥 Полезная подборка каналов только код, практика и самые передовые инструменты, которые используют разработчики прямо сейчас.👇 🖥 ИИ: t.me/ai_machinelearning_big_data 🖥 Python: t.me/pythonl 🖥 Linux: t.me/linuxacademiya 🖥 C++ t.me/cpluspluc 🖥 Docker: t.me/DevopsDocker 🖥 Хакинг: t.me/linuxkalii 🖥 Devops: t.me/DevOPSitsec 👣 Golang: t.me/Golang_google 🖥 Аналитика: t.me/data_analysis_ml 🖥 Javascript: t.me/javascriptv 🖥 C#: t.me/csharp_ci 🖥 Java: t.me/javatg 🖥 Базы данных: t.me/sqlhub 👣 Rust: t.me/rust_code 🤖 Технологии: t.me/vistehno 💰 Экономика и инвестиции в ИИ t.me/financeStable 💼 Актуальные вакансии: t.me/addlist/_zyy_jQ_QUsyM2Vi 🖥 Chatgpt бот в тг: t.me/Chatgpturbobot 📚 Бесплатные ит-книги: https://t.me/addlist/HwywK4fErd8wYzQy 🖥Подборка по Golang: https://t.me/addlist/MUtJEeJSxeY2YTFi ⚡️ Лучшие ИИ ресурсы: https://t.me/addlist/2Ls-snqEeytkMDgy Самое лучшее в этом: ты учишься даже тогда, когда “нет времени, просто потому что читаешь правильную ленту.

🔥 КАК РАБОТАЕТ ВНИМАНИЕ (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 ("стол") самый большой, значит модель "смотрит" на него сильнее всего.

Рынок ИТ в 2026 сталжестче Работодатели ищут инженеров, которые умеют автоматизировать процессы, а не обслуживать их. Ваш ответ на вызов рынка — курс «Python для инженеров». Научитесь писать скрипты, чтобы: 🟢Ликвидировать ежедневную рутину 🟢Сосредоточиться на архитектуре и сложных задачах 🟢Стать специалистом, который экономит время и деньги компании 💡Инвестируйте в ключевое конкурентное преимущество 👉 CМОТРЕТЬ ПРОГРАММУ

🧩 Минималистичный код для Claude Nanocode — это компактная альтернатива Claude Code, реализованная в одном файле на Python без зависимостей. Он включает полный агентный цикл с использованием инструментов для работы с файлами и ведения истории беседы. 🚀Основные моменты: - Полный агентный цикл с использованием инструментов - Инструменты: read, write, edit, glob, grep, bash - Ведение истории беседы - Цветной вывод в терминале 📌 GitHub: https://github.com/1rgs/nanocode #python

Используй `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 - наш телеграм канал с уроками

🖥 Лучшие практики написания кода на Python (2026) При разработке на Python следует руководствоваться философией The Zen of Python (PEP 20) – набором принципов, подчеркивающих важность простоты и ясности кода. Например, “Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex.” («Красивое лучше, чем некрасивое. Явное лучше неявного. Простое лучше сложного.»). Один из ключевых афоризмов Zen of Python гласит: “Readability counts.” («Читаемость кода имеет значение»), и действительно, код читается гораздо чаще, чем пишется. Поэтому чистый код – это код, который легко читать и поддерживать. Мы собрали современные рекомендации по стилю кода в этой статье: https://uproger.com/luchshie-praktiki-napisaniya-koda-na-python-2026-2/

🧊 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

⚡️ Экономичный способ развернуть 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

🧠 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 и считай внутри функции.

🌟 PaddleOCR-VL-1.5: компактная модель для сложного парсинга. PaddlePaddle обновили свою линейку PaddleOCR-VL, выпустив PaddleOCR-VL-1.5 - компактную VLM на 0.9 млрд. параметров на базе ERNIE-4.5-0.3B-Paddle. Несмотря на скромный размер, в задачах разбора документов она показывает SOTA-результаты. На тесте OmniDocBench v1.5 модель выбила 94.5% точности, обойдя не только прошлую версию, но и более тяжелых конкурентов. Фишка обновления - упор на полевые условия. Модель специально учили работать с плохими исходниками: кривыми сканами, бликами от мониторов и мятыми страницами. Попутно сделали бенчмарк Real5-OmniDocBench, который гоняет модели по 5 сценариям: сканирование, перекосы, деформация листа, фото с экрана и плохое освещение. 🟡В 1.5 добавили: 🟢Text spotting: находит и распознает текст одновременно (печатный русский - неплохо, рукописный - почти никак) 🟢Seal recognition: распознает печати (русские - не очень, китайские - на ура). 🟢Cross-page table merging: умеет склеивать таблицы, которые разорваны между страницами. 🟢Работа с заголовками: не теряет структуру параграфа при переходе на новый лист. 🟢Новые языки: добавили поддержку тибетского и бенгальского, подтянули распознавание редких символов и древних текстов. 🟡Деплой - на любой вкус Модель работает с transformers, дружит с Flash Attention 2 и, само собой, поддерживается PaddlePaddle 3.2.1. Если нужно быстро поднять сервис - есть готовый Docker-образ. 🟡Пара важных моментов по использованию

Если нужен полноценный постраничный парсинг всего документа, лучше использовать официальный пакет PaddleOCR. Реализация через transformers пока ограничена только распознаванием отдельных элементов и споттингом.

В пайплайн встроили логику препроцессинга. Если картинка меньше 1500 пикселей, она автоматом апскейлится фильтром Lanczos. При этом есть потолок в 1.6 млн. пикселей для споттинга, это чтобы не перегружать память GPU и сохранить читаемость мелкого шрифта.

📌Лицензирование: Apache 2.0 License. 🟡Модель 🟡Arxiv 🟡Demo 🟡DeepWiki 🖥Github @ai_machinelearning_big_data #AI #ML #VL #OCR #PaddleOCR

✔️ Сравнение производительности Python и ручного подхода Когда нужно сравнить скорость выполнения задачи с использованием Python и ручного подхода, полезно измерять время выполнения обеих стратегий. Ниже приведен пример, как можно сравнить время выполнения функции, которая суммирует числа от 1 до n с помощью Python и с использованием ручного метода.

import time
# Ручной подход
def manual_sum(n):
    total = 0
    for i in range(1, n + 1):
        total += i
    return total
# Питон-метод
def python_sum(n):
    return sum(range(1, n + 1))
# Сравнение производительности
n = 1000000
start_time = time.time()
manual_result = manual_sum(n)
manual_time = time.time() - start_time
start_time = time.time()