👋 *Эй, пацаны и девчата!* Сегодня покажу, как кодить на 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 | Чат |