🚀 Фишка на Python: Скачивание нескольких файлов параллельно с помощью ThreadPoolExecutor

Этот скрипт использует urllib.request + concurrent.futures, чтобы загружать файлы одновременно и значительно ускорить процесс.

import os
import urllib.request

from concurrent.futures import ThreadPoolExecutor, as_completed

def downloader(url):
    """Скачивает указанный URL и сохраняет его на диск"""
    req = urllib.request.urlopen(url)
    filename = os.path.basename(url)
    ext = os.path.splitext(url)[1]
    if not ext:
        raise RuntimeError('URL не содержит расширения')

    with open(filename, 'wb') as file_handle:
        while True:
            chunk = req.read(1024)
            if not chunk:
                break
            file_handle.write(chunk)

    return f'Загрузка завершена: {filename}'

def main(urls):
    """Создаёт пул потоков и скачивает указанные файлы"""
    with ThreadPoolExecutor(max_workers=5) as executor:
        futures = [executor.submit(downloader, url) for url in urls]
        for future in as_completed(futures):
            print(future.result())

if __name__ == '__main__':
    urls = [
        "http://www.irs.gov/pub/irs-pdf/f1040.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040a.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040ez.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040es.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040sb.pdf"
    ]
    main(urls)

Читать полностью…

Docker и Kubernetes: основы разработки под облачную инфраструктуру

Курс для тех, кто хочет держать свой стэк и знания актуальными и глубоко разбираться, как устроены Docker, Kubernetes, и современная облачная инфраструктура в целом.

🌐 Чему вы научитесь:

🤩 Создавать облачную инфраструктуру «с нуля» управление и конфигурация серверов с Terraform, Ansible, cloud‑init
🤩 Уверенно работать с Docker: Dockerfile, слои, кэш, многоступенчатые сборки, реестры, безопасность, air‑gapped
🤩 Проектировать многоконтейнерные приложения: паттерны Sidecar, Ambassador, Adapter, проверки (liveness/readiness), DaemonSet и поды
🤩 Настраивать сеть и балансировку в Kubernetes
ClusterIP, Services, Ingress, MetalLB, TLS/SNI, сервис‑меши (Istio)
🤩 Организовывать хранение данных: PersistentVolumes / PVC, StorageClasses, резервное копирование. Упаковка в Helm и поддержка через Operator

🥸 Кто мы: R&D-центр Devhands. Автор курса — Николай Ихалайнен, эксперт по СУБД и бекенду (ex-Percona), со-основатель MyDB, энтузиаст открытого ПО.

🗓 Старт курса: 17 сентября, 6 недель обучения.
Изучить программу и записаться можно здесь.

Ждем вас!

Реклама. ИП Рыбак А.А. ИНН 771407709607 Erid: 2VtzqxNnFKA

Читать полностью…

🍭 Задача на Python: Анализ работы декораторов и замыканий
Уровень: middle

Код:

def counter(func):
    count = 0
    
    def wrapper(*args, **kwargs):
        nonlocal count
        count += 1
        print(f"Функция {func.__name__} вызвана {count} раз")
        return func(*args, **kwargs)
    
    return wrapper

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

print(greet("Анна"))
print(greet("Пётр"))

Вопрос: Что выведет данный код?

Правильный ответ:
Функция greet вызвана 1 раз
Привет, Анна!
Функция greet вызвана 2 раз
Привет, Пётр!

Пояснение:
1. Декоратор counter создает замыкание — внутреннюю функцию wrapper, которая имеет доступ к переменной count.
2. При каждом вызове декорированной функции greet:
— Увеличивается счетчик count
— Выводится сообщение с текущим значением счетчика
— Вызывается оригинальная функция greet с переданными аргументами
3. Переменная count сохраняет свое состояние между вызовами благодаря механизму замыканий.
4. nonlocal позволяет изменять переменную из внешней области видимости

@python_job_interview

Читать полностью…

🔥 Самые сложные вопросы для интервью в Google — как готовиться и что отвечать

🔤 Что чаще спрашивают
- Алгоритмы и структуры данных
- «Найдите k-й элемент в отсортированных массивах без слияния»
- «Минимальное окно подстроки с набором символов»
- «Пути с минимальной стоимостью в графе с ловушками/порталами»
- Системный дизайн (Senior+)
- «Спроектируйте сокращатель ссылок с 10 млрд кликов/день»
- «Реал-тайм чат с end-to-end доставкой и поиском по истории»
- «Видео-платформа: загрузка, хранение, CDN, рекомендации»
- Конкурентность и распределённые системы
- «Счётчик с глобальной монотонностью на шардированном кластере»
- «Идемпотентная очередь задач при ретраях и дедупликации»
- Поведенческие (бар-рейзер)
- «Расскажите про провал и чему вы научились»
- «Как вы влияли без формальных полномочий»

📌 Как решать задачи с кодом (шаблон)
1) Уточните ограничения и формат ввода/вывода.
2) Проговорите наивное решение → оценка O(...) по времени/памяти.
3) Предложите улучшение (двойной указатель, heap, prefix, DP, BFS/DFS, binary search on answer).
4) Кодируйте чисто: небольшие функции, проверки краёв, именование.
5) Прогоны тестов: пустой ввод, дубликаты, большие размеры, Unicode и т. п.
6) Завершите: сложность, варианты оптимизации, trade-offs.

🛠 **Системный дизайн — скелет ответа**
- Требования: функциональные/нефункциональные (RPS, латентность, доступность).
- API/схемы данных → оценка объёмов (QPS, storage, рост).
- Высокоуровневая архитектура: клиент, API-шлюз, сервисы, БД, кэш, очередь, CDN.
- Горячие пути: чтение/запись, кэширование, индексирование, консистентность.
- Масштабирование: шардинг, репликация, партиционирование, backpressure.
- Надёжность: ретраи, идемпотентность, дедупликация, алерты, SLO/SLI.
- Трейд-оффы и поэтапный rollout.

☠️ Типичные ловушки
- Пишете код сразу, не уточнив ограничения.
- Нет тестов на крайние случаи.
- Перескакиваете в микро-детали дизайна, не зафиксировав требования.
- Не называете trade-offs и метрики успеха.

🔖 Мини-шпаргалка по инструментам
- Два указателя — подстроки/окна/парные суммы.
- Heap/priority queue — k-наилучших элементов/поток слияния.
- Prefix/Suffix/Hash — подсчёты и проверки за O(1) на запрос.
- DP — оптимизация по состояниям (категории: линейная, на подмасках, по интервалам).
- Graph — BFS (минимум шагов), Dijkstra/0-1 BFS (взвешенные), Topo sort (DAG).
- «Binary search по ответу» — задачи вида «можно/нельзя при X».

⚡️ Как готовиться эффективно (4 шага)
1) Разделите тренировки: 60% кодинг, 25% дизайн, 15% поведенческие.
2) Решайте задачники по темам и фиксируйте паттерн решения (а не только код).
3) Мок-интервью: таймер 30–45 минут, проговаривайте мысли вслух.
4) Соберите портфель историй по STAR: конфликт, лидерство, фейл, влияние на метрики.

Удачи на интервью!

👉 Полное видео

Читать полностью…

🖥 Microsoft вопрос с собеседования по SQL

Задача: найти топ-2 Power Users в Microsoft Teams — пользователей, которые отправили больше всего сообщений в августе 2022. Вывести их sender_id и количество сообщений.

Подход:
1) Отфильтровать сообщения по интервалу августа — в T-SQL удобно задавать полуинтервалом [2022-08-01, 2022-09-01), без функций над датой (чтобы не ломать индексы).
2) Посчитать сообщения по sender_id.
3) Отсортировать по убыванию и взять TOP 2.
Если хотите корректно обрабатывать «ничьи» — используйте DENSE_RANK().

Быстрое решение (T-SQL):

SELECT TOP (2)
       sender_id,
       COUNT(*) AS message_count
FROM   messages
WHERE  sent_date >= '2022-08-01'
  AND  sent_date <  '2022-09-01'
GROUP BY sender_id
ORDER BY COUNT(*) DESC, sender_id;

Вариант с учетом ничьих (tie-safe):

WITH monthly AS (
  SELECT sender_id, COUNT(*) AS message_count
  FROM   messages
  WHERE  sent_date >= '2022-08-01'
    AND  sent_date <  '2022-09-01'
  GROUP BY sender_id
),
ranked AS (
  SELECT sender_id, message_count,
         DENSE_RANK() OVER (ORDER BY message_count DESC) AS rnk
  FROM   monthly
)
SELECT sender_id, message_count
FROM   ranked
WHERE  rnk <= 2
ORDER BY message_count DESC, sender_id;

Почему так:

- Фильтр по диапазону дат без функций сохраняет «sargable» запрос (используются индексы по sent_date).
- GROUP BY + COUNT(*) дают нужную метрику.
- DENSE_RANK() аккуратно захватывает все «совместные» вторые места.

Читать полностью…

📌Python на взлете, а Python Software Foundation в минусе на 1.5 млн. долларов: разбираем свежий опрос.

Python Software Foundation (PSF) совместно с JetBrains опубликовала результаты восьмого, самого крупного в истории опроса разработчиков - в нём приняли участие более 30 000 человек.

Данные, собранные в конце 2024 года, показывают, что 72% респондентов используют Python в рабочих целях и это подтверждает доминирующую роль языка в индустрии. И популярность Python продолжает расти: согласно другому исследованию, от Stack Overflow, использование языка увеличилось на 7%.

🟡Приток свежей крови в экосистему.

Половина опрошенных имеют менее 2 лет профессионального опыта в программировании, а 39% начали использовать Python в течение последних 2 лет. Это говорит о том, что язык активно привлекает новичков и остается ключевой точкой входа в разработку.

🟡Парадокс версий.

Только 15% разработчиков используют последнюю на момент опроса версию, 3.13. В PSF утверждают, что массовый переход на нее мог бы сэкономить миллионы долларов на облачных вычислениях за счет повышения эффективности.

Однако сами разработчики не торопятся: 53% заявляют, что текущая версия полностью удовлетворяет их потребности, 27% ссылаются на проблемы с совместимостью, а 25% - на нехватку времени.

При этом нельзя сказать, что сообщество инертно. Самая популярная версия - 3.12 (35%), выпущенная в конце 2023 года, за ней следует 3.11 (21%), что говорит о довольно быстрой адаптации к не самым последним, но свежим релизам.

🟡Сферы применения.

Анализ данных (48%) и веб-разработка (46%) идут практически вровень. Но если к анализу прибавить ML (41%) и инжиниринг данных (31%), то доминирование Data Science становится очевидным.

В мире веб-фреймворков происходит смена караула: FastAPI (38%) резко вырвался вперед, обогнав ветеранов: Django (35%) и Flask (34%). Год назад у FastAPI было всего 29%.

Ещё один стремительный взлёт — у написанного на Rust менеджера пакетов uv, который позиционируется как замена pip. Заявляя о кратном превосходстве в скорости, он уже отхватил 11% пользователей.

А вот в лагере IDE плохие новости для спонсора опроса, JetBrains: Visual Studio Code укрепил свое лидерство, набрав 48% (против 41% в прошлом году), а доля PyCharm снизилась до 25% (с 31%).

🟡Финансовые проблемы Python Software Foundation.

Ранее в этом месяце PSF объявила о приостановке своей грантовой программы из-за нехватки средств.

Годовой отчет за 2024 год показал чистый убыток в размере 1 462 000 долларов, что значительно больше, чем в 2023 году, там убыток был 225 000 долларов.

Фонд, который поддерживает репозиторий PyPI, дистрибуцию самого Python и нанимает разработчиков для CPython, оказался в сложной ситуации и явно нуждается в большей поддержке и ресурсах от корпораций, которые строят свой бизнес и получают доход на Python.


@ai_machinelearning_big_data

#news #ai #ml

Читать полностью…

🖥 Полный проект с нуля: клон голоса на Python

🔊 Клонирование голоса на Python с нуля: пошаговый разбор, рабочий код, проверка сходства и защита с водяными знаками.

Полное руководство для разработчиков по созданию собственного проекта voice cloning.

📌 Читать

@python_job_interview

Читать полностью…

👾 Задача из собеседования по Python
Уровень: middle-senior

Условие:
Реализуйте потокобезопасный кэш с TTL и политикой вытеснения LRU. Кэш должен:
1️⃣ Автоматически удалять записи по истечении TTL.
2️⃣ При достижении максимального размера вытеснять реже всего используемые элементы.
3️⃣ Гарантировать корректную работу в многопоточной среде.
4️⃣ Поддерживать методы: get(key), set(key, value, ttl), delete(key), clear().
5️⃣ Опционально: реализовать ленивое удаление просроченных записей.

Решение:

import time
import threading
from collections import OrderedDict

class TTLLRUCache:
    def __init__(self, maxsize=1024):
        self.maxsize = maxsize
        self._cache = OrderedDict()
        self._lock = threading.RLock()
        self._expiry_times = {}

    def get(self, key):
        with self._lock:
            if key not in self._cache:
                return None
            
            # Ленивое удаление просроченного ключа
            if self._is_expired(key):
                self._delete(key)
                return None
            
            # Обновляем порядок использования (LRU)
            self._cache.move_to_end(key)
            return self._cache[key]

    def set(self, key, value, ttl=None):
        with self._lock:
            # Вытеснение старых записей при достижении лимита
            if len(self._cache) >= self.maxsize:
                self._evict()
            
            self._cache[key] = value
            self._cache.move_to_end(key)
            self._expiry_times[key] = time.time() + ttl if ttl else None

    def delete(self, key):
        with self._lock:
            self._delete(key)

    def _delete(self, key):
        self._cache.pop(key, None)
        self._expiry_times.pop(key, None)

    def clear(self):
        with self._lock:
            self._cache.clear()
            self._expiry_times.clear()

    def _is_expired(self, key):
        expiry = self._expiry_times.get(key)
        return expiry is not None and expiry < time.time()

    def _evict(self):
        # Сначала удаляем просроченные ключи
        expired_keys = [k for k in self._cache if self._is_expired(k)]
        for k in expired_keys:
            self._delete(k)
        
        # Если после этого кэш всё ещё полон, применяем LRU
        if len(self._cache) >= self.maxsize:
            self._cache.popitem(last=False)

    def __contains__(self, key):
        with self._lock:
            if key not in self._cache:
                return False
            if self._is_expired(key):
                self._delete(key)
                return False
            return True

Пояснение:

1. Потокобезопасность:
Используется threading.RLock для всех операций, изменяющих состояние кэша. Это позволяет рекурсивные блокировки из одного потока.

2. TTL:
Время истечения хранится в отдельном словаре _expiry_times. При обращении к ключу проверяется его актуальность.

3. LRU-политика:
OrderedDict автоматически поддерживает порядок использования элементов. Метод move_to_end() обновляет позицию при каждом обращении, а popitem(last=False) удаляет самый старый элемент.

4. Гибкое удаление:
— Ленивое (при обращении к ключу)
— Активное (при добавлении новых элементов через _evict())

5. Оптимизация:
— Сначала удаляются просроченные ключи, и только потом применяется LRU.
— Сложность операций: O(1) для get/set (в среднем случае).

@python_job_interview

Читать полностью…

⚡ Python-трюк: быстрая группировка данных

Хотите сгруппировать элементы по ключу без лишних циклов?
Используйте itertools.groupby — но не забудьте предварительно отсортировать данные по этому ключу, иначе группы будут неправильными.

from itertools import groupby
from operator import itemgetter

data = [
    {"user": "alice", "score": 8},
    {"user": "bob",   "score": 5},
    {"user": "alice", "score": 7},
    {"user": "bob",   "score": 9},
]

# Сортируем по ключу
data.sort(key=itemgetter("user"))

# Группируем и считаем средний балл
for user, items in groupby(data, key=itemgetter("user")):
    scores = [i["score"] for i in items]
    print(user, "avg score:", sum(scores) / len(scores))

#Python #itertools #groupby #lifehack

Читать полностью…

🐍 Полезный совет по Python: используйте with open() вместо ручного закрытия файлов

Начинающие часто пишут так:

f = open("data.txt", "r")
data = f.read()
f.close()

Код рабочий, но если внутри произойдёт ошибка — файл может не закрыться. Это приведёт к утечкам ресурсов.

🚀 Правильный способ — использовать контекстный менеджер with open()

with open("data.txt", "r") as f:
    data = f.read()

💡 Преимущества:

Файл закрывается автоматически, даже если произойдёт ошибка

Код становится короче и чище

Работает одинаково для чтения, записи и бинарных файлов

📊 Пример записи:

with open("output.txt", "w") as f:
    f.write("Hello, Python!")

После выхода из блока with файл гарантированно закрыт, ничего вручную делать не нужно.

📌 Итог
Используйте with open() всегда, когда работаете с файлами. Это безопаснее, чище и надёжнее, чем open() + close().

Читать полностью…

🖥 Полезный трюк: Полезный трюк: временно фиксируйте генераторы случайных чисел в блоке кода и автоматически возвращайте их состояние.

Это даёт воспроизводимость экспериментов без глобальных побочек. С

from contextlib import contextmanager

@contextmanager
def temp_seed(seed: int):
    # Сохраняем состояния
    py_state = random.getstate()
    try:
        import numpy as np
        np_state = np.random.get_state()
    except Exception:
        np = None
        np_state = None
    try:
        import torch
        torch_state = torch.random.get_rng_state()
        torch_cuda_state = torch.cuda.get_rng_state_all() if torch.cuda.is_available() else None
    except Exception:
        torch = None
        torch_state = torch_cuda_state = None

    # Устанавливаем семена
    random.seed(seed)
    if np: np.random.seed(seed)
    if torch:
        torch.manual_seed(seed)
        if torch.cuda.is_available():
            torch.cuda.manual_seed_all(seed)
    try:
        yield
    finally:
        # Восстанавливаем состояния
        random.setstate(py_state)
        if np_state is not None: np.random.set_state(np_state)
        if torch_state is not None: torch.random.set_rng_state(torch_state)
        if torch_cuda_state is not None and torch.cuda.is_available():
            torch.cuda.set_rng_state_all(torch_cuda_state)

# Пример использования
if __name__ == "__main__":
    import numpy as np

    with temp_seed(123):
        print("Блок A:", random.random(), np.random.randint(0, 10))
    with temp_seed(123):
        print("Блок B:", random.random(), np.random.randint(0, 10))  # те же значения
    print("Вне блока:", random.random())  # обычный глобальный поток случайности

Читать полностью…

🔍 Открытое собеседование на Python-бекендера с разработчиком из Avito и Яндекс в четверг

14 августа (уже в четверг!) в 19:00 по мск приходи онлайн на открытое собеседование, чтобы посмотреть на настоящее интервью на Middle Python-разработчика.

Как это будет:
📂 Савва Демиденко, ТехЛид с опытом в Яндексе и Авито, будет задавать реальные вопросы и задачи разработчику-добровольцу
📂 Савва будет комментировать каждый ответ респондента, чтобы дать понять чего от вас ожидает собеседующий на интервью
📂 В конце можно будет задать любой вопрос Савве

Это бесплатно. Эфир проходит в рамках менторской программы от ШОРТКАТ для Python-разработчиков, которые хотят повысить свой грейд, ЗП и прокачать скиллы.

Переходи в нашего бота, чтобы получить ссылку на эфир → @shortcut_py_bot

Реклама.
О рекламодателе.

Читать полностью…

📌Новый прорыв в алгоритмах: найден способ считать кратчайшие пути быстрее Дейкстры

Метод преодоления "барьера сортировки" для задач кратчайшего пути в ориентированных графах.

Группа исследователей из университетов Синьхуа, Стенфорда и Института Макса Планика представили детерминированный алгоритм для решения задачи SSSP в ориентированных графах с неотрицательными вещественными весами, который работает за время, пропорциональное числу ребер, умноженному на логарифмический множитель, который растет медленнее, чем обычный логарифм.

Проблема поиска кратчайшего пути от одной вершины до всех остальных (SSSP) — одна из фундаментальных в теории графов, и её история тянется с 50-х годов прошлого века. Классический алгоритм Дейкстры, в связке с продвинутыми структурами данных, решает эту задачу за время, которое примерно пропорционально сумме числа рёбер и произведения числа вершин на логарифм от их же числа.

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

🟡Основная идея работы - гибрид из алгоритма Дейкстры и алгоритма Беллмана-Форда.

Алгоритм Дейкстры на каждом шаге выбирает из "границы" - множества еще не обработанных вершин ту, что находится ближе всего к источнику. Это и создает узкое место, так как размер границы может достигать величины, сопоставимой с общим числом вершин в графе, и на каждом шаге требуется находить минимум.

Алгоритм Беллмана-Форда, в свою очередь, не требует сортировки, но его сложность пропорциональна числу ребер, умноженному на количество шагов, что слишком долго.

🟡Новый подход использует рекурсию.

Вместо того чтобы поддерживать полную отсортированную границу, алгоритм фокусируется на ее сокращении. А если граница слишком велика, то запускается несколько шагов алгоритма Беллмана-Форда из ее вершин.

Это позволяет найти точное расстояние до некоторой части вершин, чьи кратчайшие пути коротки. Длинные же пути должны проходить через одну из "опорных" вершин, которых оказывается значительно меньше, чем вершин в исходной границе. Таким образом, сложная работа концентрируется только на этом небольшом наборе опорных точек.

🟡Принцип "разделяй и властвуй".

Он рекурсивно разбивает задачу на несколько уровней. На каждом уровне применяется вышеописанная техника сокращения границы, что позволяет значительно уменьшить объем работы на каждую вершину, поскольку логарифмический множитель эффективно делится на другой, более медленно растущий логарифмический член.

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

✔️ Зачем это нужно
— Быстрее решаются задачи в навигации, графах дорог, сетях и планировании.
— Доказано, что Дейкстра — не предел, и можно ещё ускорять поиск кратчайших путей.


🟡Arxiv


@ai_machinelearning_big_data

#AI #ML #Sorting #Graphs #Algorithm

Читать полностью…

120 ключевых вопросов по SQL за 2025 год

Статья содержит 120 ключевых вопросов по SQL для собеседований, разделённых по темам и уровням сложности, с краткими пояснениями.

Основываясь на актуальных требованиях 2025 года, вопросы охватывают базу данных, оптимизацию, практические задачи и нюансы СУБД (MySQL, PostgreSQL, SQL Server).

🔜 Подробности

Читать полностью…

🔑 Сложная задача для собеседования по Python

Условие:
Рассмотрим следующий фрагмент кода с использованием asyncio и декораторов:

import asyncio

def cache(func):
    cache = {}
    
    async def wrapper(*args):
        if args not in cache:
            cache[args] = await func(*args)
        return cache[args]
    
    return wrapper

@cache
async def expensive_operation(x):
    await asyncio.sleep(1)
    return x * 2

async def main():
    tasks = [expensive_operation(i) for i in range(3)]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

Вопрос:
Что будет выведено в консоль и почему?

Варианты ответов:
1) [0, 2, 4] — вывод корректный, кеширование работает
2) RuntimeError — возникает из-за неправильного использования await в декораторе
3) [0, 0, 0] — возникает ошибка кеширования
4) [2, 2, 2] — декоратор мешает асинхронности

Правильный ответ: 3)

Пояснение:
1️⃣ Проблема в декораторе: обычный def-декоратор не совместим с асинхронными функциями. При вызове await func(args) внутри wrapper, декоратор не дожидается выполнения корутины, возвращая None.
2️⃣ Почему [0, 0, 0]:
— cache[args] сохраняет не результат, а корутину (<coroutine object...>).
— При повторном обращении к кешу возвращается эта корутина, но await вне декоратора не применяется.
— Фактически, все задачи получают первую сохраненную корутину (для x=0), которая всегда возвращает 0.
3️⃣ Чтобы исправить код нужно использовать functools.wraps и сделать декоратор асинхронным.

Пишите свои варианты решения в комментариях 🔽

@python_job_interview

Читать полностью…

🎯 Разбор задания с подвохом (Python, собес)

Задание
> Сформируйте список функций callbacks, где каждая функция при вызове печатает свой индекс.
> Затем вызовите их по очереди (или из потоков/таймеров) — ожидаемый вывод: 0 1 2.

Наивное решение (почти все так пишут)

callbacks = [lambda: print(i) for i in range(3)]

for f in callbacks:
    f()

Что выведет?
2 2 2 — и это не баг интерпретатора.

В чём подвох

- Замыкание поздно связывает имя i: лямбды не «копируют» значение, а смотрят на переменную i, когда вы их вызываете.
- К моменту вызова цикл уже закончился, i == 2, значит все три лямбды печатают 2.

Правильные варианты

Привязать значение через параметр по умолчанию (часто лучший баланс читаемости)

callbacks = [lambda i=i: print(i) for i in range(3)]
for f in callbacks:
    f()  # 0 1 2

Заводим фабрику функций (прямо подчёркивает намерение)

def make_printer(i):
    def _f():
        print(i)
    return _f

callbacks = [make_printer(i) for i in range(3)]
for f in callbacks:
    f()  # 0 1 2

functools.partial — когда нужно просто «прикрутить аргументы»

from functools import partial

callbacks = [partial(print, i) for i in range(3)]
for f in callbacks:
    f()  # 0 1 2

А если таймеры/потоки?

import threading

for i in range(3):
    # ПЛОХО: замкнёт одно и то же i
    # threading.Timer(1, lambda: print(i)).start()

    # ХОРОШО: привяжем значение сразу
    threading.Timer(1, lambda i=i: print(i)).start()

Мини-чеклист для собеса

- Лямбды/внутренние функции в цикле → проверь, не упираешься ли в late binding.

- Если нужна «заморозка» значения, используй параметр по умолчанию, фабрику или partial.

Не путай с другой классикой: изменяемые значения по умолчанию (например, def f(x, acc=[])), это другая ловушка.

Вывод

В Python замыкания захватывают имена, а не значения.

Привязывай нужное значение в момент создания функции — и подвох исчезнет.

Читать полностью…

👨‍🔧 CoreNN — база данных для работы с векторами и эмбеддингами в масштабе миллиардов, с сублинейным временем отклика на обычных серверах.

📌 Пример: поиск по 1 млрд эмбеддингов комментариев Reddit из индекса 4,8 ТБ на диске занимает всего 15 мс.

🔧 Ключевые особенности:
- Работает на дешёвых SSD/flash-накопителях, а не в дорогой DRAM → в 40–100 раз дешевле.
- Масштабирование: от 1 до 1 млрд векторов в одном индексе.
- Upsert и delete оптимизируют локальный граф, освобождают место и сохраняют скорость — без полной перестройки.
- Поддерживает параллельные запросы и обновления без блокировок.

🔗 https://github.com/wilsonzlin/CoreNN

Читать полностью…

🐍 Python + Ruff: сложность кода под контролем

На скрине — функция validate_product, которая проходит несколько вложенных проверок.
Линтер Ruff с правилом C901 (McCabe Complexity) сигнализирует: сложность функции = 7, что выше лимита 5.

📏 McCabe Complexity измеряет количество ветвлений и условий в функции. Чем выше показатель, тем сложнее код для понимания и поддержки.

⚠️ Почему это важно:
• Снижение читаемости
• Рост вероятности багов
• Трудности при тестировании

💡 Решение:
1. Разбить функцию на несколько маленьких с понятными именами
2. Использовать ранние выходы (`return`) вместо вложенных if
3. Упрощать логику с помощью вспомогательных функций или структур данных

#Python #Ruff #CleanCode #Refactoring #McCabeComplexity

Читать полностью…

💼 Как подготовиться к любому собеседованию: гайд от нового сотрудника OpenAI

Новый инженер OpenAI поделился опытом прохождения интервью в AI-стартапы и крупные компании, включая OpenAI.

1. Заботьтесь о себе — ментально и физически
Интервью — это стресс. Следите за сном, питанием, отдыхом, заручитесь поддержкой друзей и семьи.

2. Помните: цель — ваш успех
Компания и интервьюеры хотят, чтобы вы прошли. Даже если был отказ, пробуйте снова — многие успешно попадали на роль со второй попытки.

3. Получайте удовольствие от процесса
Это шанс познакомиться с интересными людьми, узнать новые технологии и потренироваться в решении задач.

4. Готовьтесь основательно
- 100 часов на задачи (LeetCode и аналоги)
- 100 часов на изучение теории и статей
- Тренируйтесь с друзьями без автодополнений и LLM-подсказок

5. Каждая встреча важна
Даже «неформальный звонок» — это возможность показать мотивацию, характер и профессионализм.

6. Работайте над профилем и сетью
LinkedIn, GitHub с проектами, участие в митапах, open-source, хакатонах — всё это привлечёт внимание рекрутеров.

7. Первые звонки
- С рекрутером: записывайте детали — этапы, состав команды, имя руководителя
- С руководителем: изучите его публикации и проекты, покажите интерес, расскажите, почему хотите работать именно здесь

8. Поведенческие вопросы
Готовьте истории по формату STAR(I) — о том, как решали конфликты, брали на себя лидерство, справлялись с ошибками.

9. Техническая часть
- Решайте задачи быстро и чётко, проговаривая ход мыслей
- Практикуйте кодинг в условиях стресса и без IDE
- Разбирайтесь в алгоритмах, трансформерах, RL-методах
- Умейте объяснить свою текущую работу и её пользу для компании

10. Переговоры
Обсуждайте не только зарплату, но и команду, миссию, культуру. Все договорённости фиксируйте письменно.

11. Принятие решения
Выбирайте место, где вам будет комфортно работать каждый день.

📌 Главное: интервью — это навык, который можно натренировать. Подготовка + уверенность = высокий шанс успеха.

📌 Полный текст

Читать полностью…

🏵️ async-lru — кэширование для асинхронного Python без головной боли

Простой, но мощный порт стандартного lru_cache из functools для asyncio-приложений. Главная фишка — автоматическая обработка конкурентных вызовов: даже если 10 корутин запросят одни и те же данные одновременно, реальный запрос выполнится лишь один раз.

Проект особенно полезен в связке с aiohttp для кэширования HTTP-запросов или результатов работы с базами данных. Поддержка TTL и ручная инвалидация кэша делают библиотеку универсальным инструментом.

🤖 GitHub

@python_job_interview

Читать полностью…

🖥 Молниеносный HTML-парсинг: selectolax быстрее BS4 в разы

Полезный трюк: быстро парсим HTML прямо из строки с помощью selectolax — лёгкой и очень быстрой библиотеки на C, в разы быстрее BeautifulSoup.

Установка:

pip install selectolax

Пример с кодом:

from selectolax.parser import HTMLParser

html = """

<html><body> <h1>Hello</h1> <p class='msg'>World</p> </body></html> """
tree = HTMLParser(html)
print(tree.css_first("h1").text()) # Hello
print(tree.css_first("p.msg").text()) # World

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

Читать полностью…

🆕 Hugging Face представили **AI Sheets** — no-code инструмент для создания и обработки таблиц с помощью ИИ.

- Выглядит как обычная таблица, но вместо формул — тысячи моделей
- Поддержка OpenAI-совместимых и локальных LLM
- Можно добавлять столбцы с промптами, редактировать данные вручную или через лайки
- Запуск онлайн или локально (Docker / pnpm)
- Полностью опенсорс (Apache-2.0), легко встроить в пайплайны
- Подходит для классификации, трансформации данных, синтетики и «vibe-тестов» моделей

⚡️ Попробовать

#AI #NoCode #datasets #HuggingFace #LLM

Читать полностью…

⚡️Лето подходит к концу, но подарки нет!

Разыгрываем iPhone 16 Pro и Apple Watch SE 2 📲⌚️

📄 Условия участия очень просты:

⚡️Подписаться на Telegram каналы:

▪t.me/pythonl

▪ t.me/DevOPSitsec

⚡️Нажать "Участвую!" под этим постом

Итоги подведём уже 15 сентября. Доставка осуществляется по всей территории РФ и РБ🚚

⚡️Удачи ВСЕМ🍀

Читать полностью…

Тот, кто знает, чего хотят на собеседовании, всегда выигрывает у того, кто просто пришел отвечать на вопросы.

Разница между ними в том, что первый видит процесс целиком: он понимает, зачем нужен каждый этап, чего ждет интервьюер, и как в нужный момент показать сильные стороны. А второй просто надеется, что его ответы «понравятся». И, к сожалению, чаще всего это не срабатывает.

21 августа в 18:00 (МСК) karpovꓸcourses проведут вебинар совместно с Павлом Бухтиком — экс-руководителем продуктовой аналитики в Яндексе и FindMyKids, экспертом с восьмилетним опытом в профессии, пять из которых на управленческой позиции.

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

Узнайте четкий план, как действовать на собеседовании: https://clc.to/erid_2W5zFJd2cvC 

Это третий вебинар Data-интенсива: от новичка до оффера, который поможет сориентироваться в сфере Data Science и перейти к первым шагам.

Реклама. ООО "КАРПОВ КУРСЫ". ИНН 7811764627. erid: 2W5zFJd2cvC

Читать полностью…

🔥 НЕОЧЕВИДНЫЙ ТРЮК: ускоряй циклы в Python без лишнего кода с помощью itemgetter

Если ты часто итерируешь по списку словарей и достаёшь одни и те же поля — ты можешь заметно ускорить код, заменив lambda на operator.itemgetter. Это не только делает код чище, но и работает быстрее за счёт оптимизации на уровне C.

Полезно, например, при сортировке, группировке или фильтрации данных.

https://www.youtube.com/shorts/55V7jgTrcBA

Читать полностью…

🐍 Snoop — умный дебаггер для Python, который делает отладку проще print-ов. Проект предлагает альтернативу классическому print() для отладки: просто добавьте декоратор @snoop к функции, и он покажет пошаговое выполнение кода с значениями переменных.

Интегрируется с Jupyter, поддерживает глубину вложенных вызовов (depth=2) и даже умеет взрывать сложные структуры данных (watch_explode). Не требует сложной настройки — достаточно pip install snoop.

🤖 GitHub

@python_job_interview

Читать полностью…

🖥 ЗАДАЧА С СОБЕСЕДОВАНИЯ: что выведет код?

Что выведет следующий код — и почему?

a = 256
b = 256
print(a is b)

x = 257
y = 257
print(x is y)

❓Ожидаешь True в обоих случаях? Не всё так просто.

📌 В Python целые числа от -5 до 256 кешируются.
То есть a и b указывают на один и тот же объект → a is b → True

Но x и y — это уже разные объекты, потому что 257 не кешируется → x is y → False

⚠️ is сравнивает объекты, а не значения.
Если хочешь сравнить значения — используй ==

💡 Вывод: даже базовые типы могут вести себя неожиданно, если сравнивать их через is.

Читать полностью…

🖥 Flet — фреймворк для создания кроссплатформенных приложений на Python

— pip install flet

Flet — фреймворк, предоставляющий Flutter компоненты для разработки кроссплатформенных приложений на Python (разработчики обещают расширять список поддерживаемых языков).

Flet не использует какие-то SDK, не компилирует код Python в код Dart и весь UI отображается с помощью встроенного Web сервера.

🖥 GitHub
🟡 Доки

Читать полностью…

⚡ Agent Lightning — ускоритель обучения для ИИ-агентов от Microsoft

Agent Lightning — это фреймворк для обучения и оптимизации LLM-агентов с помощью Reinforcement Learning без изменения их кода.

🧠 Поддерживает:
• LangChain
• AutoGen
• OpenAI Agents SDK
• и другие фреймворки на Python

🔧 Как он работает:
• Агент не нужно переписывать — он подключается как есть
• Вся его работа разбивается на отдельные шаги (эпизоды), которые можно анализировать
• Специальный алгоритм LightningRL оценивает, какие действия были полезны, а какие — нет
• Система может учитывать не только финальный результат, но и промежуточные сигналы (награды)
• Эти данные автоматически собираются и используются для дообучения агента

🔥 Преимущества:
• Не требует модификации логики агента
• Можно легко подключить к существующим пайплайнам
• Улучшает точность и устойчивость в сложных задачах: от генерации кода до Text-to-SQL

Отличный инструмент для всех, кто хочет сделать своих LLM-агентов.

🟠Проект: https://microsoft.com/en-us/research/project/agent-lightning/
🟠Статья: https://arxiv.org/abs/2508.03680
🟠Github: https://github.com/microsoft/agent-lightning

@ai_machinelearning_big_data


#agent #reinforcementlearning #mlops #llm #Microsoft

Читать полностью…

Как сделать помощника, который помнит контекст?

Голосовые ассистенты и LLM-сервисы — это круто, но... они часто не знают контекста. Или забывают, что вы им сказали полминуты назад.

Что, если помощник действительно помнил бы:

— кто вы
— что вы уже спрашивали
— и какие у вас были кейсы в прошлом?

На вебинаре Яндекса расскажут, как это реализовать через RAG + YDB:

🧠 память с помощью эмбеддингов
🔍 векторный поиск с фильтрацией
⚙️ масштабируемое и быстрое решение на SQL

Подходит как для внутренних ИИ-сервисов, так и для клиентских продуктов.

Читать полностью…