Йо, пацаны, сегодня про важное! 😎🐍

Знаете, что такое GIL? Это такой "Главный Интерпретаторский Замок", который держит ваш Питон в узде, пока он шпарит код в одном потоке. Но вот что интересно — в новом Питоне 3.13 чуваки из Python решили, что можно и без этого замка жить. Казалось бы, свобода для всех потоков, но тут есть засада!

🔥 Если ты компилишь Python без GIL и запускаешь один поток — привет, тормоза! Почему? Ну, потому что система теперь тратит время на то, чтобы сделать всё безопасным для многопоточности. В итоге твой код тормозит примерно на 40% сильнее, чем в обычной версии с GIL! Да, это как если бы ты снял шлем на гонках и надеялся, что ветер сам разрулит — но нет, тормоза будут!

💡 Когда это важно? Если у тебя обычный код, который не гоняет сотни потоков, то без GIL ты тупо теряешь скорость, как будто тачку на ручник поставил. Free-threaded Питон — штука крутая для тех, кто шарит в многопоточности, но если у тебя один поток, держись подальше, пока не прикрутят норм оптимизации.

🥶 Но есть надежда! Говорят, что в Python 3.14 сделают так, что без GIL код будет тормозить всего на 10%, а это уже не так обидно. Но это потом, а пока — не гоняй, где не надо!

Вывод для пацанов: если твой код одинокий волк (однопоточный), то GIL тебе друг. А если ты хочешь жить на грани и жмешь на газ в многопоточке — пробуй без GIL, но будь готов к тормозам в версии 3.13. 🚗💨

Понравилось? Лайк и подписка, вы ж знаете, куда нажать! 💪

🔥 Продолжаем базарить про Python 3.13! 🔥

В прошлом посте мы уже говорили про те самые 40% потери производительности в однопоточных программах без GIL. Но не всё так плохо, пацаны. Давайте разберём, что ещё нас ждёт в Python 3.13, и как это вообще использовать.

Дата релиза и что это значит для тебя 📅

Python 3.13 выходит уже 7 октября 2024 года! Это значит, что скоро можно будет официально юзать версии без GIL. Это не просто мелкая обнова, это настоящая революция для тех, кто хочет выжимать из многопоточности максимум. Твой код будет реально параллельно работать на всех ядрах процессора, как настоящий чемпион.

Как запустить Free-threading? 🛠

1. Windows и macOS: качай обнову с официального сайта и просто выбирай установку без GIL.
2. Линукс или самосборщики: компилируешь с флагом --disable-gil, и готово!

Как чекнуть, отключён ли GIL? 🔍

Чтобы убедиться, что ты реально отключил GIL, запускай:

python -VV

Если увидишь надпись "experimental free-threading build", значит, ты сделал всё по красоте.

Можно ещё проверить в рантайме через функцию

sys._is_gil_enabled()

Что по безопасности в многопоточке? ⚠️

Когда работаешь без GIL, стоит быть осторожным:

- Итераторы: не дели один и тот же итератор на все потоки — это может привести к проблемам.
- Frame объекты: не трогай их в других потоках, это может крашнуть программу.


Иммортализация объектов — это чё? 🛡

Теперь некоторые объекты в free-threading режиме становятся бессмертными. Это значит, что они больше не будут удаляться из памяти. Это касается функций, модулей, методов и строк. Учти, если таких объектов будет много, твоя оперативка быстро забьётся. Иными словами - утечка памяти. Но в 3.14 это тоже обещали забороть.

Что по C-расширениям? 🔧

Если твои проекты зависят от C-расширений, знай, что не все из них поддерживают работу без GIL. Если вдруг что, GIL включится автоматически, и ты увидишь предупреждение.
Это касается например таких важных либ, как lxml, на базе которой например сделаны самые быстрые части BeautifulSoup и много чего еще.
Потому твой какой нибудь парсер скорее всего нормально в free-trading 3.13 не заработает, братан.
Но со временем чуваки доработают и этот момент, причем есть шанс что в промежуточных версиях до 3.14 (ноэтонеточно)

Итог: как выжать максимум из Python 3.13? 💪

1. Готовься к многопоточности: вырубай GIL, если твой проект реально нуждается в многопоточности, и кайфуй от полной загрузки всех ядер процессора.
2. Однопоточный код? Подожди 3.14: если твой проект однопоточный, лучше дождись версии Python 3.14, где ребята обещают снизить потери производительности до 10%.
3. Иммортализация объектов: если у тебя много модулей и строк — будь готов к увеличению потребления памяти.

Python 3.13 уже 7 октября 2024! Но использовать его нужно если ты чётко осознаешь последствия!

"Братишки, вот как `builtins` решает ваши проблемы с `input()`"

Чё, пацаны, когда юзаешь питончик, всё круто, пока не надо бахнуть input(). И тут твой скрипт тормозит на месте и ждёт, пока ты что-то влупишь с клавы, да? Не порядок. Но тут я покажу, как сделать, чтобы input() играл по твоим правилам и вообще не парил мозг. Всё это на базе builtins — самого матерого пацана в питонячей тусовке.

Кто такой builtins?

builtins — это как главный босс в Python. Он отвечает за всю стандартную движуху, типа print(), len(), input() и т.д. Его всегда можно вызвать по фасту, даже если ты не подключал его напрямую. Но вот фишка — ты можешь подкрутить его и заставить выполнять твои команды.

Короче, как мы будем хакать input()?

Чё мы сделаем: бахнем декоратор и вставим туда замутку с подменой input(). Смотри:

1. Декорим твою функцию так, чтобы вместо обычного input() скрипт сам подставлял то, что тебе надо.
2. Это всё будет кататься через глобальный объект __builtins__, где input() живёт по дефолту.
3. Мы временно заменим его своим и обратно всё откатим после, чтобы никто и не догадался, что мы мутим.

Пример кода

def auto_input(mock_values):
    def decorator(func):
        def wrapper(*args, **kwargs):
            # Сохраняем реальный `input`
            original_input = __builtins__.input  
            # Врубаем наши данные вместо реального инпута
            values = iter(mock_values)
            __builtins__.input = lambda _: next(values)
            # Вызов твоей функции
            result = func(*args, **kwargs)
            # Возвращаем всё как было
            __builtins__.input = original_input
            return result
        return wrapper
    return decorator

Как это юзать?

Теперь ты можешь кидать это куда угодно. Надо автоматом влепить значения в input() — не вопрос:

@auto_input(["значение1", "значение2"])
def my_function():
    first = input("Введите первое значение: ")
    second = input("Введите второе значение: ")
    print(f"Введено: {first}, {second}")

my_function()

Чё будет:
Скрипт больше не будет сидеть в ожидании, когда ты там что-то вкатишь. Он сам себе всё подставит, как ты задал в декораторе. Нормально, да?

Зачем это нужно?

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

Важный момент

После того как поработали с подменой, мы всегда возвращаем старый добрый input(), иначе можно устроить хаос, и другие функции начнут путаться, как оно вообще работает.

Резюмирую:

builtins — это тот парень, которого ты можешь взломать и заставить делать работу по твоему. Главное — делать это по уму, чтобы никто не палил тему. Подменяй input(), рули своим кодом и не давай ему тебя держать в заложниках!

Так что, пацаны, юзайте правильно — и будет вам Python с кайфом.

#декоратор #хак

👋 *Эй, пацаны и девчата!* Сегодня покажу, как кодить на Python так, чтобы выглядело "чётко" и стильно, как белые кроссы. Берём фишки, чтобы ваш код был не просто норм, а 🔝!

1. Списочные включения 🔥

❌ Не канает:

squares = []
for x in range(10):
    squares.append(x ** 2)

✅ Как надо:

squares = [x ** 2 for x in range(10)]

🎤 *Коммент*: Одной строкой создаем список. Чисто — чики-брики, 👌 и сразу порядок.

2. Генераторы 🚀

❌ Как не стоит:

large_list = [x * x for x in range(1000000)]

✅ Как надо:

large_generator = (x * x for x in range(1000000))

🎤 *Коммент*: Вместо создания огромного списка берём генератор. Память не жрёт, 💾 особенно если данных много.

3. Распаковка кортежей 💼

❌ Плохо:

point = (10, 20)
x = point[0]
y = point[1]

✅ Как надо:

x, y = point

🎤 *Коммент*: Одной строкой раскидываем значения по переменным, как надо, а не как в лавке с вещами.

4. enumerate() — не парься с индексом 👀

❌ Сложный путь:

i = 0
for item in items:
    print(i, item)
    i += 1

✅ Как надо:

for i, item in enumerate(items):
    print(i, item)

🎤 *Коммент*: enumerate() даёт и элемент, и индекс. Экономит строки и 🌐 понятно.

5. Менеджер контекста with 📂

❌ Старый способ:

file = open('data.txt', 'r')
try:
    data = file.read()
finally:
    file.close()

✅ Как надо:

with open('data.txt', 'r') as file:
    data = file.read()

🎤 *Коммент*: with сам закроет файл, как завершил. 👋 Экономия времени.

6. Методы словаря get() и setdefault() 🔑

❌ Долго:

if key in my_dict:
    value = my_dict[key]
else:
    value = default_value

✅ Быстрее:

value = my_dict.get(key, default_value)

🎤 *Коммент*: Одной строкой получаем значение. 🤏 Легче понять и экономим символы.

7. Обмен значениями через множественное присваивание 🤝

❌ Лишние шаги:

temp = a
a = b
b = temp

✅ Как профи:

a, b = b, a

🎤 *Коммент*: Обмениваем значения без временных переменных, как в обменнике.

8. any() и all() — проверка сразу всех 🕵️‍♂️

❌ Не оптимально:

def has_negative(nums):
    for num in nums:
        if num < 0:
            return True
    return False

✅ Лучше так:

def has_negative(nums):
    return any(num < 0 for num in nums)

🎤 *Коммент*: any() проверяет сразу всё. Экономия строк и 💪 эффективность.

9. f-строки 🎫

❌ Устарело:

name = 'Alice'
age = 30
message = 'Name: %s, Age: %d' % (name, age)

✅ Современный подход:

name = 'Alice'
age = 30
message = f'Name: {name}, Age: {age}'

🎤 *Коммент*: f-строки дают возможность вставлять значения прямо в текст. 💬 Быстрее и читаемо.

10. PEP 8 🧑‍🏫

❌ Как не надо:

def calculateSum(a,b):
    return(a+b)

✅ Правильно:

def calculate_sum(a, b):
    return a + b

🎤 *Коммент*: PEP 8 — это стиль, 👔 порядок и уважение. Если хочешь кодить как профи, придерживайся норм.

Доп. Практики 🛠

- Избегаем изменяемых объектов по умолчанию:
❌ Потенциальная проблема:

  def append_to_list(value, my_list=[]):
      my_list.append(value)
      return my_list
  

✅ Надёжно:

  def append_to_list(value, my_list=None):
      if my_list is None:
          my_list = []
      my_list.append(value)
      return my_list
  

🎤 *Коммент*: Изменяемые значения как дефолты могут привести к багам. 🛑 Лучше использовать None.

- Обработка ошибок через исключения:
❌ Не оптимально:

  def divide(a, b):
      if b == 0:
          return None
      else:
          return a / b
  

✅ Используем try-except:

  def divide(a, b):
      try:
          return a / b
      except ZeroDivisionError:
          print("Деление на ноль!")
  

🎤 *Коммент*: Исключения — это 👌 чистый способ ловить ошибки.


⚡️ *Вот такие дела, ребята! Применяйте эти фишки и пишите не просто рабочий код, а настоящий Python с душой!*

Эй, народ, послушайте сюда! Сейчас я вам расскажу про такую фишку, как memoryview, и почему без него иногда ну вообще никуда.

Что за `memoryview` и зачем он нужен?

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

memoryview — это как прямой доступ к памяти. Он позволяет смотреть на данные без копирования, работать с ними быстро и эффективно. Это как если бы вы получили мастер-ключ от всех данных и могли бы делать с ними всё, что душе угодно.

Реальный пример: Быстрая обработка сетевых данных

Допустим, вы пилите свой сервер для онлайн-игры или чата. Данные летят пачками, и вам нужно их обрабатывать на лету. Если каждый раз копировать данные, ваш сервер начнёт тупить и лагать. А это никому не нужно, верно?

Вот как `memoryview` спасает ситуацию:

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

import socket

# Создаём сокет и принимаем данные
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('example.com', 80))
sock.sendall(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')

data = sock.recv(4096)
mv = memoryview(data)

# Предположим, первые 4 байта — это длина следующего сообщения
msg_length = int.from_bytes(mv[:4], 'big')

# Достаём само сообщение
message = mv[4:4+msg_length]

# Обрабатываем сообщение без копирования
process_message(message)

Почему это круто?

- Скорость: Нет лишних копирований данных. Вы работаете напрямую с буфером.
- Экономия памяти: При больших объёмах данных это критично.
- Гибкость: Можно легко работать с различными протоколами и форматами данных.

Ещё один пример: Изменение частей данных в массиве

Допустим, вы работаете с изображением или звуком, и вам нужно быстро менять части данных. С memoryview это делается на раз-два.

# Имеем изменяемый массив байтов, например, изображение
buffer = bytearray(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09')

# Создаём memoryview
mv = memoryview(buffer)

# Меняем часть данных напрямую
mv[2:5] = b'\xFF\xFF\xFF'

print(buffer)  # Выведет: bytearray(b'\x00\x01\xff\xff\xff\x05\x06\x07\x08\x09')

Где без `memoryview` никуда?

- Работа с бинарными протоколами: Сетевые приложения, где нужно быстро парсить и формировать пакеты данных.
- Графика и мультимедиа: Обработка изображений, видео или аудио в реальном времени.
- Интеграция с низкоуровневыми библиотеками: Когда нужно передавать данные в C-расширения или использовать буферные интерфейсы.

Например, интеграция с NumPy

Если вы работаете с массивами NumPy и хотите передать данные в библиотеку, которая использует буферный интерфейс, memoryview позволяет сделать это без копирования.

import numpy as np

# Создаём массив NumPy
arr = np.arange(10, dtype='int32')

# Создаём memoryview
mv = memoryview(arr)

# Передаём mv в функцию, ожидающую буферный интерфейс
some_function_that_uses_buffer(mv)

Заключение

memoryview — это мощный инструмент для тех, кто хочет выжать максимум из Python. Он позволяет работать с данными на низком уровне, экономить память и ускорять выполнение кода. Так что, если вы стремитесь к топовой производительности и хотите, чтобы ваш код был быстрым, как пуля, берите на вооружение memoryview и творите чудеса!

🔥 UV: Менеджер пакетов для Python для настоящих пацанов 🔥

Йо, братва! Если вы до сих пор юзаете старые инструменты типа pip и pipenv, пора перейти на новый движ — UV. Это не просто менеджер пакетов, а целый универальный инструмент, который всё решает: ставит зависимости, создает виртуалки, даже нужную версию Python подкачивает. Всё это на Rust, так что скорость — как ракета 🚀.

---

💥 Чё такое UV?

Представьте, что у вас один инструмент, который заменяет сразу кучу утилит:
• _pip_
• _pip-tools_
• _virtualenv_
• _pyenv_
• _pipx_
и даже Git-фишки!
С UV вам не надо мутиться с кучей команд — одна команда, и все работает, как часы ⏱️.

---

⚡️ Основные фишки UV:

- Скорость — молния ⚡️
Благодаря Rust, установка пакетов и разрешение зависимостей происходит в 10–100 раз быстрее, чем у старых добрых инструментов. Кэш включен — и скорость супер!

- Все в одном 🎯
UV ставит зависимости, создает виртуалки и даже управляет версиями Python. Забудьте про разрозненные утилиты!

- Простота использования 🤙
Команды похожи на привычные:

  uv pip install flask
  uv pip compile -o requirements.txt
  uv pip sync requirements.txt
  

Для виртуалок и Python:

  uv venv --python 3.11.9
  uv python install 3.12
  

- Git-интеграция 🔥
Хочешь брать зависимости прямо из Git-реп? UV тащит их, кэширует и обновляет без заморочек. Если нужны самые свежие фичи, — это твой выбор!

---

🛠 Как юзать UV на практике:

*Инициализация проекта*

uv init my_project
cd my_project

Структура проекта готова, появляется pyproject.toml и .python-version. Всё по понятиям!

*Добавление зависимостей*

uv add "fastapi>=0.70"

Зависимости пишутся в конфиг, lockfile генерится — у вас всегда один и тот же билд на всех машинах.

*Создание виртуального окружения*

uv python install 3.11.9
uv venv --python 3.11.9

Нужную версию Python ставит UV и создает виртуалку без лишних заморочек.

*Запуск утилит и скриптов*
Для утилит, типа Ruff:

uvx ruff check .

А если есть скрипт с инлайн-зависимостями, добавляешь так:

uv add --script my_script.py "requests" "rich"
uv run my_script.py

Запускается скрипт в изолированном окружении — все как надо.

---

🚀 Git-движуха в UV

Слушай, UV не только пакеты ставит — он умеет тащить зависимости прямо из Git! Если тебе нужна свежая версия библиотеки из репы, указывай её, а UV все схватит, закэширует и подтянет обновления. Это реально спасает, когда работаешь с экспериментальными фичами или хочешь всегда быть на гребне волны 🌊.

---

🤘 Итог

UV — это настоящий хайп в мире Python. Он объединяет все, что нужно для быстрой и удобной разработки, и уже стал стандартом для настоящих пацанов, которые ценят свое время и не любят морочиться с настройками. Если хочешь работать быстро, четко и без лишних заморочек — переходи на UV, бро. Это будущее Python, и оно уже наступило!

Если есть вопросы или нужна помощь — пиши, всегда на связи! ✌️😎

PEP 750: t-строки в 3.14

В питон добавили еще один способ форматировать строки. Теперь – со специальным АПИ для внешних интеграций.

- PEP: https://peps.python.org/pep-0750
- Реализация: https://github.com/python/cpython/pull/132662

Основная причина: использовать f строки удобно, но нет никакого АПИ для перехвата момента "вставки" или интерполяции значений. Например, при форматировании html или sql – требуется специальным образом делать escape для значений. И раньше код вида f"<div>{template}</div>" представлял собой дыру в безопасности и потенциальное место для XSS.

string.templatelib.Template

Новый префикс t не будет создавать объект str, он будет создавать объект класса string.templatelib.Template:

>>> user = 'sobolevn'
>>> template = t"Hi, {user}"
>>> template
Template(strings=('Hi, ', ''), interpolations=(Interpolation('sobolevn', 'user', None, ''),))

>>> from string.templatelib import Template
>>> isinstance(template, Template)
True

Обратите внимание, что при создании template – у нас не произошло форматирование сразу. Мы создали объект, у которого есть свойства strings и interpolations, из которых можно собрать финальную отформатированную строку.

Давайте посмотрим на примере. Допустим, мы хотим формировать URL из наших данных:

>>> domain = 'example.com'
>>> query = 'python string formatting is too complex'
>>> template = t'https://{domain}?q={query}'

И сам код логики форматирования, где мы будем вставлять значения разным способом. Если у нас шаблон query, то мы будем использовать quote_plus для его форматирования. Остальные значения – будем вставлять как есть:

>>> from string.templatelib import Template, Interpolation
>>> from urllib.parse import quote_plus

>>> def format_url(template: Template) -> str:
...     parts = []
...     for part in template:
...         match part:
...             case str() as s:  # regular string
...                 parts.append(s)
...             case Interpolation(value, expression='query'):
...                 parts.append(quote_plus(value))
...             case Interpolation(value):
...                 parts.append(value)
...     return ''.join(parts)

И вот результат:

>>> format_url(template)
'https://example.com?q=python+string+formatting+is+too+complex'

Только теперь наш Template был отформатирован. Нами. Ручками.
У нас есть полный контроль за процессом форматирования. Вот в чем суть данного ПЕПа.

Фичи одной строкой

- Работает = как обычно в f строках: t'{user=}'
- Есть привычные определители формата: !r, !s, .2f, тд
- t строки можно конкатенировать: t'Hello' + t' , world!' и t'Hello, ' + 'world'
- Поддерживается режим raw строк: rt"Hi \n!"

Как устроено внутри?

Интересные места имплементации:
- Изменения лексера
- Изменения грамматики языка
- Новое CAPI _PyTemplate
- Новые классы Template и Interpolation написанные на C
- Новый байткод BUILD_INTERPOLATION и BUILD_TEMPLATE

>>> import dis
>>> user = 'sobolevn'
>>> dis.dis('t"Hi, {user}"')
  0           RESUME                   0

  1           LOAD_CONST               2 (('Hi, ', ''))
              LOAD_NAME                0 (user)
              LOAD_CONST               1 ('user')
              BUILD_INTERPOLATION      2
              BUILD_TUPLE              1
              BUILD_TEMPLATE
              RETURN_VALUE

Обсуждение: как вам еще один способ форматирования строк?

| Поддержать | YouTube | GitHub | Чат |