Python: простые вещи, которые улучшают код

Если писать так:

if type(x) == str:
    print("Это строка")

это может работать, но ломается на наследниках str.

Правильнее использовать isinstance(). Он учитывает наследование и лучше согласуется с полиморфизмом.

if isinstance(x, str):
    print("Это строка")

Такой вариант сработает и для str, и для его подклассов.

Итог: type(x) == str годится только для простых случаев, но хрупкий. isinstance(x, str) — более устойчивый и корректный вариант почти всегда.

👉 @PythonPortal

Наконец-то кто-то пропатчил Chromium на уровне исходников!

Не JS-инъекции, не твики флагов, а полноценная модификация отпечатков прямо в C++ исходниках с последующей сборкой бинарника.

Результат?

Cloudflare Turnstile: всё пройдено
reCAPTCHA v3: score 0.9 (уровень человека)
FingerprintJS / BrowserScan: всё зелёное
Пройдено 30/30 детект-сайтов

Drop-in замена для Playwright / Puppeteer — меняете импорт в 3 строки кода и получаете моментальный unban!

pip install cloakbrowser
или
npm install cloakbrowser

Больше никакого страха перед anti-bot защитой, братья!

👉 @PythonPortal

все записи теперь братья близнецы

👉 @PythonPortal

Напоминание: в Python 3.14 завезли несколько действительно сильных обновлений 🐍

Если ещё не обновлялись, вот что появилось:

- Free-threaded Python теперь официально поддерживается — без GIL;
- deferred evaluation аннотаций — forward references теперь работают нормально из коробки;
- template string literals (t-strings) для более безопасной обработки строк;
- встроенный модуль сжатия Zstandard;
- подсветка синтаксиса прямо в REPL;
- multiple interpreters в стандартной библиотеке.

Кроме этого, tail-call interpreter даёт прирост производительности без изменений в коде:

- примерно 3–5% на Linux;
- около 7–8% на ARM Mac.

👉 @PythonPortal

Это, вероятно, самый честный разбор production-архитектуры AI-систем, который сейчас есть в интернете.

9-слойная AI production architecture:

services/ — RAG-пайплайн, семантический кеш, память, query rewriter, роутер. Не один файл. Пять.

agents/ — document grader, decomposer, adaptive router. Самокоррекция заложена в архитектуру.

prompts/ — версионируемые, типизированные, зарегистрированные. Никакого хардкода.

security/ — input, content и output-фильтрация. Три уровня защиты, а не один.

evaluation/ — golden dataset, офлайн-eval, онлайн-мониторинг. Большинство этот слой полностью пропускает и деплоит вслепую.

observability/ — трассировка по каждому этапу, привязка фидбека к трейсам, стоимость каждого запроса.

.claude/ — контекст агента, чтобы AI-кодинг-ассистент понимал кодовую базу до того, как начнёт менять файлы.

👉 @PythonPortal

😢😢😢

👉 @PythonPortal

Промпты для Claude, которые помогают оптимизировать GitHub-профиль.

👉 @PythonPortal

⚠️ Небольшой Python-трюк: как кастомизировать поведение списка

Класс UserList из модуля collections в Python используется для создания пользовательских объектов, работающих как список, но с кастомным поведением. Он выступает базовым классом, от которого можно наследоваться, если нужно реализовать собственные структуры данных со специализированными методами и логикой.

Допустим, вы хотите создать список с кастомным методом append(), разрешив добавлять только чётные числа. Код ниже показывает, как это можно реализовать через UserList.

В этом примере метод append() переопределён так, чтобы разрешать добавление только чётных чисел. Если передать нечётное число, выводится сообщение о том, что нечётные значения запрещены. Метод sort() также переопределён и всегда сортирует список в обратном порядке.

Когда экземпляр obj вызывается с аргументом 3, который является нечётным числом, выводится сообщение "Non-even numbers not allowed", а сам список остаётся без изменений.

👉 @PythonPortal

🤭🤭🤭

👉 @PythonPortal

DeepSeek выпустили фундаментальную переработку архитектуры трансформера.

Она решает проблему «кризиса идентичности», которая ломает очень большие модели ИИ.

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

Без них глубокие сети начинают терять информацию по пути и становятся плохо обучаемыми.

Но есть проблема: при росте глубины и размера моделей такие простые «пропуски» перестают работать.

Информация размывается. Градиенты нестабильны. Математика начинает ломаться.

DeepSeek (включая исследователей, среди которых Вэньфэн Лян) опубликовали работу с введением mHC: манивольд-ограниченные гипер-связи.

Это полная переработка того, как данные проходят внутри модели.

Вместо одного «обходного пути» они расширили его до нескольких параллельных потоков. Эти связи называют гипер-связями.

Но на этом не остановились.

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

Ключевой шаг DeepSeek — принудить эти связи жить на заданном математическом многообразии.

Проецируя связи на многогранник Бёркгофа с помощью алгоритма Синхорна–Кноппа, они заставили модель оставаться устойчивой.

Сохраняется богатство маршрутов передачи данных, но сигнал не теряется и не «взрывается».

Результаты:

Стабильность: удалось обучить модель на 27 млрд параметров, которую раньше нельзя было стабилизировать с обычными гипер-связями.

Производительность: значительное улучшение на бенчмарках кодирования, математики и рассуждений (BBH и DROP).

Эффективность: несмотря на усложнение, кастомное ядро добавляет примерно 6,7% накладных расходов на обучение.

Последние годы индустрия пыталась делать модели умнее через увеличение масштаба.

DeepSeek показали, что реальный прирост даёт исправление «инфраструктуры» внутри модели.

Будущее масштабирования — не только в увеличении числа слоёв.

Оно в более качественных связях между ними.

👉 @PythonPortal

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

А потом приходит осознание, что почти вся инфраструктура систем под капотом опирается на ту же самую идею.

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

И этот уровень абстракции встречается буквально везде.

Например, в базах данных оптимизаторы запросов по стоимости — это по сути огромные движки динамического программирования.

SQL-запрос с большим количеством JOIN между таблицами создаёт колоссальное комбинаторное пространство вариантов выполнения.
Оптимизатору нужно выбрать порядок JOIN, пути доступа, индексы, hash join / merge join / nested loop, predicate pushdown, partition pruning, стратегию параллелизма.

Наивный перебор растёт факториально.

Поэтому оптимизаторы используют динамическое программирование для вычисления:
«какой самый дешёвый способ выполнить подмножество S отношений?»

Классическая оптимизация в стиле Selinger хранит самый дешёвый план для каждого подмножества и постепенно строит более крупные планы из меньших оптимальных под-планов.

Что-то вроде:

DP[S] = минимальная стоимость плана для JOIN отношений из подмножества S

Дальше переходы выглядят так:
комбинируем оптимальные левый/правый под-планы + оцениваем cardinality + считаем стоимость IO / CPU / сети.

Вся магия в том, что система перестаёт повторно вычислять эквивалентные состояния, но при этом всё ещё приближается к глобальному оптимуму.

И это далеко не только про базы данных.

Динамическое программирование тихо лежит в основе:
алгоритмов кратчайших путей, декодирования Витерби, выравнивания последовательностей в биоинформатике, оптимизаций компилятора, edit distance, эвристик TCP congestion control, политик кэширования, планировщиков ресурсов, tiling для GPU-ядра, register allocation, вероятностного вывода, value iteration в reinforcement learning.

Даже современное мышление в распределённых системах часто напоминает динамическое программирование:
минимизация задержек и стоимости через ограниченные переходы состояний.

Больше всего мне нравится, как DP меняет само мышление.

Ты перестаёшь брутфорсить задачу и начинаешь задавать другие вопросы:

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

Тот самый дофаминовый момент, когда решение оптимизируется с O(nlogn) до O(n) или с O(n²) до O(n), — именно ради этого хочется писать алгоритмы каждый день.

И этот майндсет полезен далеко за пределами алгоритмических собеседований.

Одна из самых элегантных идей в CS:
превращать невозможные пространства поиска в вычислимо решаемые задачи через сжатие состояния и переиспользование оптимальных результатов.

👉 @PythonPortal

👉 @PythonPortal

Кто-то сделал бесплатный PDF-редактор, который делает всё то же, что и Adobe, но занимает всего 20 МБ.

RevPDF работает полностью локально на устройстве. Позволяет редактировать текст и изображения, подписывать документы, редактировать конфиденциальные данные, сжимать файлы, конвертировать в Word — без интернета, без аккаунта и без подписки.

Полностью бесплатно. Полностью офлайн.

👉 @PythonPortal

7 обязательных сложностей алгоритмов (Big-O) для собеседований:

1. 𝐎(1) — 𝐤𝐨𝐧𝐬𝐭𝐚𝐧𝐭𝐧𝐚𝐲𝐚 𝐬𝐥𝐨𝐳𝐡𝐧𝐨𝐬𝐭𝐢

- Время выполнения не зависит от размера входных данных.
- Пример: доступ к элементу массива по индексу.

2. 𝐎(𝐥𝐨𝐠 𝐧) — 𝐥𝐨𝐠𝐚𝐫𝐢𝐟𝐦𝐢𝐜𝐡𝐞𝐬𝐤𝐚𝐲𝐚 𝐬𝐥𝐨𝐳𝐡𝐧𝐨𝐬𝐭𝐢

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

3. 𝐎(𝐧) — 𝐥𝐢𝐧𝐞𝐲𝐧𝐚𝐲𝐚 𝐬𝐥𝐨𝐳𝐡𝐧𝐨𝐬𝐭𝐢

- Время растёт линейно относительно размера входных данных.
- Пример: поиск элемента в массиве перебором.

4. 𝐎(𝐧 𝐥𝐨𝐠 𝐧) — 𝐥𝐢𝐧𝐞𝐲𝐧𝐨-𝐥𝐨𝐠𝐚𝐫𝐢𝐟𝐦𝐢𝐜𝐡𝐞𝐬𝐤𝐚𝐲𝐚 𝐬𝐥𝐨𝐳𝐡𝐧𝐨𝐬𝐭𝐢

- Время растёт чуть быстрее линейного. Обычно включает логарифмическое число операций на каждый элемент.
- Пример: сортировка quick sort или merge sort.

5. 𝐎(𝐧^2) — 𝐤𝐯𝐚𝐝𝐫𝐚𝐭𝐢𝐜𝐡𝐞𝐬𝐤𝐚𝐲𝐚 𝐬𝐥𝐨𝐳𝐡𝐧𝐨𝐬𝐭𝐢

- Время растёт пропорционально квадрату входа.
-Пример: bubble sort, где происходит сравнение и возможный swap каждой пары элементов.

6. 𝐎(2^𝐧) — 𝐞𝐤𝐬𝐩𝐨𝐧𝐞𝐧𝐭𝐬𝐢𝐚𝐥𝐧𝐚𝐲𝐚 𝐬𝐥𝐨𝐳𝐡𝐧𝐨𝐬𝐭𝐢

- Время удваивается с каждым новым элементом входа. Такие алгоритмы быстро становятся непригодными для больших данных.
- Пример: генерация всех подмножеств множества.

7. 𝐎(𝐧!) — 𝐟𝐚𝐤𝐭𝐨𝐫𝐢𝐚𝐥𝐧𝐚𝐲𝐚 𝐬𝐥𝐨𝐳𝐡𝐧𝐨𝐬𝐭𝐢

- Время пропорционально факториалу размера входа.
- Пример: генерация всех перестановок множества.

👉 @PythonPortal

Лёгковесный автономный AI-агент на Python с поддержкой нескольких моделей и множества инструментов, может заменить Claude Code и работает локально: https://github.com/KevRojo/Dulus

Автономный AI-агент, написанный на 12 000 строк Python-кода, с поддержкой 11 провайдеров моделей, между которыми можно переключаться по необходимости, и 27 встроенными инструментами. Поддерживает протокол MCP, горячую загрузку плагинов, параллельную работу саб-агентов, офлайн-голосовой ввод/вывод и интеграцию с Telegram (Telegram-bridge).

👉 @PythonPortal

Пишешь объектно-ориентированный Python? Не путай два базовых типа отношений:

1/ has-a («композиция»). Один объект содержит другой. У Person есть (has-a) name. У Car есть (has-a) color.

2/ is-a («наследование»). Один класс является разновидностью уже существующего. Employee — это (is-a) Person. Car — это (is-a) Vehicle.

👉 @PythonPortal

Компании, которые увольняют программистов и направляют деньги на ИИ выглядят примерно так

👉 @PythonPortal

Тернарный оператор в Python — удобная штука, но им легко злоупотребить:

'A' if s>=90 else 'B' if s>=80 else 'C' if s>=70 else 'F'

То, что это можно написать, ещё не значит, что так стоит писать.
Если условий 3 и больше — лучше использовать if-elif-else.

А тернарный оператор стоит оставить для:
comprehensions (генераторов списков / коллекций), lambda-выражений, return в одну строку.

👉 @PythonPortal

Регулярные выражения в python

Регулярные выражения (regex) в Python используются для поиска, соответствия и манипулирования строками на основе шаблонов. В Python регулярные выражения реализованы в модуле re

Основные функции модуля re:

🔸re.match(): Проверяет, соответствует ли начало строки заданному шаблону.
🔸re.search(): Ищет шаблон в строке и возвращает первый найденный совпадающий объект.
🔸re.findall(): Находит все совпадения шаблона в строке и возвращает их в виде списка.
🔸re.finditer(): Находит все совпадения шаблона и возвращает их в виде итератора.
🔸re.sub(): Заменяет все совпадения шаблона на заданную строку.
🔸re.split(): Разделяет строку по заданному шаблону.

Примеры использования:

import re

# Пример строки
text = "The rain in Spain falls mainly in the plain."

# 1. re.match()
match = re.match(r'The', text)
if match:
    print("Match found:", match.group())
else:
    print("No match found")

# 2. re.search()
search = re.search(r'rain', text)
if search:
    print("Search found:", search.group())
else:
    print("No search found")

# 3. re.findall()
findall = re.findall(r'in', text)
print("Findall results:", findall)

# 4. re.finditer()
finditer = re.finditer(r'in', text)
for match in finditer:
    print("Finditer match:", match.group(), "at position", match.start())

# 5. re.sub()
substitute = re.sub(r'rain', 'snow', text)
print("Substitute result:", substitute)

# 6. re.split()
split = re.split(r'\s', text)
print("Split result:", split)

Объяснение примера:

> re.match(r'The', text): Проверяет, начинается ли строка text с "The".
> re.search(r'rain', text): Ищет первое вхождение "rain" в строке text.
> re.findall(r'in', text): Находит все вхождения "in" в строке text.
> re.finditer(r'in', text): Возвращает итератор, который перебирает все вхождения "in" в строке text.
> re.sub(r'rain', 'snow', text): Заменяет все вхождения "rain" на "snow" в строке text.
> re.split(r'\s', text): Разделяет строку text по пробелам (символы пробела).

Дополнительные примеры шаблонов:

\d: Любая цифра.
\D: Любой символ, кроме цифры.
\w: Любая буква, цифра или символ подчеркивания.
\W: Любой символ, кроме буквы, цифры или символа подчеркивания.
\s: Любой пробельный символ.
\S: Любой непробельный символ.
.: Любой символ, кроме новой строки.
^: Начало строки.
$: Конец строки.
*: 0 или более повторений.
+: 1 или более повторений.
?: 0 или 1 повторение.
{n}: Ровно n повторений.
{n,}: n или более повторений.
{n,m}: От n до m повторений.

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

👉 @PythonPortal