Шаринган разработчика: увидь, где код жрёт время, и бей туда

Оптимизация на языке Итачи. Не улучшай всё подряд, сначала увидь настоящий bottleneck. Включаешь профилировщик cProfile, собираешь статистику, сортируешь по cumtime и бьёшь в самую дорогую функцию. build_report на 78% времени это не догадка, а факт из профиля. Меньше слепых правок, больше точных ударов.

https://www.youtube.com/shorts/11O1Sadtcwc

Что выведет этот код?

funcs = []

for i in range(3):
    funcs.append(lambda: i)

print([f() for f in funcs])

Многие думают:

[0, 1, 2]

Но Python выведет:

[2, 2, 2]

Почему?

`lambda` не запоминает значение `i` в момент создания.

Она запоминает саму переменную.

Когда цикл закончился, `i` уже равно `2`.

Поэтому все функции смотрят на одно и то же последнее значение.

Правильный фикс:

```python
funcs = []

for i in range(3):
funcs.append(lambda i=i: i)

print([f() for f in funcs])
```

Теперь будет:

```python
[0, 1, 2]
```

Хитрость простая:
если создаёшь функцию в цикле — фиксируй значение через аргумент по умолчанию.

Что выведет код?

t = ([],)

try:
    t[0] += [1]
except TypeError as e:
    print("Ошибка:", type(e).__name__)

print(t)

Многие думают:

Ошибка: TypeError
([],)

Но Python выведет:

Ошибка: TypeError
([1],)

Почему?

`t` — tuple, его нельзя менять.

Но внутри tuple лежит список, а список менять можно.

Оператор `+=` сначала мутирует список:

```python
[] -> [1]
```

А потом Python пытается записать результат обратно в tuple:

```python
t[0] = ...
```

И вот тут падает `TypeError`.

Итог странный: ошибка была, но данные уже изменились.

Главный урок:

immutable-контейнер не делает вложенные объекты immutable.

Если внутри tuple лежит list, этот list всё ещё можно изменить.

В regex 1.13 появился макрос regex!.

Важно: это не compile-time regex.

Он не компилирует регулярку на этапе сборки.

Смысл другой: макрос закрывает частый паттерн, когда вы используете что-то вроде std::sync::LazyLock, чтобы регулярное выражение компилировалось примерно один раз, а не при каждом вызове.

То есть вместо ручной обёртки вокруг lazy-инициализации теперь есть более удобный встроенный способ.

PR: github.com/rust-lang/regex/pull/1371

OvisOCR2 вышел на ModelScope.

Это компактная OCR-модель на 0.8B параметров для page-level document parsing: на вход подаётся изображение страницы, на выходе получается структурированный Markdown в нормальном порядке чтения.

Формулы модель отдаёт в LaTeX, таблицы в HTML, визуальные области помечает image tags с bbox-координатами.

По заявленным результатам OvisOCR2 набрала 96.58 overall на OmniDocBench v1.6 и стала первой end-to-end моделью, которая заняла первое место в лидерборде, где раньше доминировали pipeline-системы.

На PureDocBench тоже сильный результат: 75.06 Avg3. Это важнее, чем просто победа на одном бенчмарке, потому что документный парсинг давно страдает от переобучения под популярные наборы.

Модель сделана на базе Qwen3.5-0.8B и дообучалась через SFT, RL и OPD. Для деплоя есть поддержка vLLM, лицензия Apache 2.0.

https://modelscope.ai/models/ATH-MaaS/OvisOCR2

В Python есть словарь, который умеет менять порядок элементов без пересоздания - OrderedDict из collections.

Например, move_to_end() перемещает ключ в конец:

from collections import OrderedDict

data = OrderedDict([
("python", 1),
("django", 2),
("fastapi", 3),
])

data.move_to_end("python")

print(data)
# django, fastapi, python

А с last=False ключ можно отправить в начало:

data.move_to_end("fastapi", last=False)

Обычные dict тоже сохраняют порядок вставки, но OrderedDict полезен, когда порядок нужно активно менять: для LRU-кэшей, очередей, приоритетов и истории действий.

🔥 За одну неделю вышло сразу 6 интересных open-weight моделей

Пока все ждут веса Kimi K3 и Ling 3.0, Sebastian Raschka обновил свою LLM Architecture Gallery свежими релизами. И там есть несколько необычных решений.

1. Nanbeige 4.2 3B
Берёт один стек из 22 Transformer-блоков и прогоняет его дважды. Получается эффективная глубина 44 блока без удвоения весов: больше compute, но почти тот же parameter footprint.

2. Laguna S 2.1
118B MoE, всего 8B активных параметров и контекст 1M токенов. Poolside позиционирует её для долгих coding-agent задач, причём модель помещается на одном DGX Spark.

3. Motif 3 Beta
314B-A13B MoE с новой Grouped Differential Latent Attention: latent-compression внимания дополняется группировкой heads и механизмом подавления «шума».

4. Solar Open 2
250B-A15B от Upstage. Архитектура чередует 3 linear-attention слоя и 1 GQA, что помогает довести контекст до 1M токенов.

5. Antares 1B
Маленькая security-модель Cisco на базе Granite 4.0. Её дообучили через SFT + GRPO для поиска уязвимых участков кода через терминал. Хороший пример того, насколько далеко можно увести специализированную модель всего на 1B параметров.

6. BTL-3
Всего лишь rank-32 LoRA поверх Qwen3.6-27B, заточенная под coding agents и structured tool calling. Авторы заявляют 88,5% на BFCL v4 AST и 95,12% HumanEval pass@1.

Open-weight экосистема сейчас интересна именно разнообразием архитектур: looped transformers, sparse MoE, linear attention, специализированные SLM и обычные LoRA-адаптеры развиваются одновременно.

Все схемы и сравнения:
https://sebastianraschka.com/llm-architecture-gallery/

Один из лучших курсов со Stepik - Rust для тех, кто уже пишет прод 🦀

Когда начинаешь думать не только «работает ли код», но и что происходит с памятью, аллокациями, потоками и ошибками под нагрузкой - Rust становится особенно интересным.

На курсе разберёшь язык через реальные механики:

ownership, borrowing, lifetimes, traits, generics, error handling, модули, тесты и сетевое программирование.

После каждого блока - код и задача с автопроверкой.

Подойдёт разработчикам на Go, C++, Java, Python, JavaScript и других языках.

⚡ Старт сразу
💻 Упор на практику

Освой Rust так, чтобы после курса открыть новый проект и реально понимать, что пишешь и почему это работает: https://stepik.org/a/294885/

«Сэр… всё кончено. Китайцы выложили веса Kimi K3 в открытый доступ»

Moonshot AI опубликовала Kimi K3 на Hugging Face — мультимодальную MoE-модель с 2,8 трлн параметров, из которых на токен активируются около 104 млрд.

Что внутри:

контекст до 1 млн токенов;
работа с текстом и изображениями;
длительные агентные задачи и вызов инструментов;
программирование, исследование репозиториев и работа с терминалом;
нативная квантизация MXFP4.

На Terminal-Bench 2.1 авторы заявляют 88,3 балла, а на FrontierSWE — 81,2. Результаты получены в собственном агентном окружении Kimi Code, поэтому сравнивать их нужно с учётом harness.

Веса доступны по лицензии Kimi K3 License. Это уже не экспериментальная модель «для посмотреть», а открытый 3T-класс, который можно разворачивать через vLLM или SGLang.

One Day Offer: заходи в команду, которая двигает финансы на терабайтах данных! 🔥

На связи блок «Финансы» в Сбере! Мы строим системы, которые автоматизируют казначейство, риск‑менеджмент, отчётность — и добавляем AI для точных прогнозов.

На One Day Offer мы хотим найти коллег сразу в 3 продуктовые команды. Базовый стек и уровень задач одинаковы — выбирай направление по душе:

✔️ BigData: Spark (batch+streaming), сложные SQL‑оптимизации, DWH/Data Lake.
✔️ Микросервисы: Python (FastAPI/Django), API, интеграции с системами.

От тебя ждём: Python от 5 лет, экспертный SQL, PySpark, SOLID/asyncio, HDFS/Kafka.

👉 Регистрируйся по ссылке. Встречаемся 8 августа!

🐍 Python-совет: как объединить списки разной длины

Обычный zip() прекращает работу, когда заканчивается самый короткий список:

x = [1, 2, 3, 4, 5]
y = ["a", "b", "c"]

print(list(zip(x, y)))
# [(1, "a"), (2, "b"), (3, "c")]

Чтобы сохранить все элементы, используйте zip_longest()

from itertools import zip_longest

print(list(zip_longest(x, y)))
# [(1, "a"), (2, "b"), (3, "c"), (4, None), (5, None)]

Для пустых позиций можно указать своё значение:

result = zip_longest(
x,
y,
fillvalue="нет значения",
)```

Полезно при объединении таблиц, колонок и данных из источников разной длины.

#Python #Programming #DataProcessing

One Day Offer для Python-разработчиков!💚

15 августа открываем двери в команду Agent Execution Framework ⚡️

Коллеги создают платформу для GenAI‑агентов в банке — делают так, чтобы ИИ реально работал в серьёзных финпроцессах: с безопасностью, нагрузкой и пользой.

Чем предстоит заниматься:

✔️ развивать backend на Python
✔️ подключать LLM, инструменты, базы знаний и RAG
✔️ строить пайплайны оценки качества агентов
✔️ участвовать в архитектуре и ревью кода

Встречаемся 15 августа онлайн.

Регистрируйся по ссылке

🐍 Python-совет: когда `deque` лучше обычного списка

collections.deque — двусторонняя очередь, оптимизированная для быстрых операций с обоих концов.

from collections import deque

queue = deque(["a", "b", "c"])

queue.append("d")       # добавить справа
queue.appendleft("z")   # добавить слева

queue.pop()             # удалить справа
queue.popleft()         # удалить слева

У deque добавление и удаление с краёв выполняются за O(1). У списка операция pop(0) требует сдвига остальных элементов и работает за O(n).

Ещё одна полезная возможность — циклический сдвиг:

queue.rotate(1)   # сдвиг вправо
queue.rotate(-1)  # сдвиг влево

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

Python-сервис не должен падать вслед за чужим API

Interlock - современная реализация circuit breaker для Python. Она временно блокирует обращения к нестабильному сервису, а затем аккуратно проверяет, восстановился ли он. Синхронный и асинхронный код поддерживаются одним классом.

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

Для сложных сценариев есть resilience

pipeline = (
Pipeline.builder()
.fallback(lambda exc: [])
.retry(attempts=4)
.circuit_breaker(breaker)
.bulkhead(8)
.timeout(2.0)
.build()
)

Порядок стратегий задаётся явно: timeout, bulkhead, circuit breaker, повторные попытки и запасной ответ.

Также доступны интеграции с FastAPI, Litestar, HTTPX, aiohttp, Requests, Redis и OpenTelemetry. Состояние breaker можно синхронизировать между несколькими процессами, а при недоступности Redis библиотека временно возвращается к локальному состоянию.

Ядро не требует внешних зависимостей, декораторы сохраняют типы и сигнатуры функций, лицензия — MIT.

Проект молодой, поэтому проверенные годами pybreaker и circuitbreaker по-прежнему могут быть безопаснее для консервативного продакшена. Но для rate-based окон, контроля медленных запросов и составных политик отказоустойчивости Interlock выглядит интересно.

https://github.com/bagowix/interlock