У тех, кто часто работает в терминале, есть привычка вызова особо часто используемых команд. например cd, ls, mc...
Вместо команды exit можно использовать Ctrl+D, и это удобно.

И так уж вышло, что эта привычка невольно у меня включается и при работе в REPL. Для быстрого выхода я жму Ctrl+D, и это работает, но только в Linux. В Windows это совсем не работает, так как там надо нажимать Ctrl+Z. И был бы Windows не такой mustdie если бы этого хватило, но требуется еще нажать Enter (если знаете быстрый выход из REPL на винде, то подсказывайте, я не WinUser). Иногда мне быстрей и привычней вбить exit и нажать Enter, как в bash, но и тут подстава - еще нужны скобки вызова🤬.

В общем, настолько высосанную из пальца проблему надо еще поискать 😆, но я нашел для неё решение!

q = type('q', (object,), {'__repr__': lambda *args: exit()})()

Этот код вставляется в стартап скрипт REPL и создаёт новый объект q. Теперь для выхода из REPL достаточно написать символ q и нажать Enter. Работает одинаково на Linux и Windows.

Как это работает?
▫️ динамически создаётся новый тип объекта с помощью конструкции type(NAME, (BASETYPES,), {ATTRS,})
▫️ в атрибутах создаётся оверрайд метода __repr__, который отвечает за распечатку объекта в REPL
▫️ в этом методе вызывается команда exit()

То есть команда выхода срабатывает как только вы пытаетесь распечатать этот объект в консоли. Именно отображение его репрезентации как объекта а не через не print(), который использует метод __str__.

Аналогично работающий код выглядит так:

class Q:
def __repr__(self):
exit()
q = Q()

Из минусов можно выделить следующее:
▫️ имя q занято, но никто не мешает сделать что-то более уникальное
▫️ Нужно как-то добавлять это в стартап. Тут нам поможет startup script

Аналогичным способом можно сделать и другие действия, но стоит помнить что это нестандартное поведение в Python, в прод не оставляйте!
Пару раз я вставлял аналогичные объекты в интерактивную консоль для дебага, они там выполняли роль шорткатов для каких-то наборов действий

PS. Не очень-то это похоже на трик или лайфхак. Это скорей демонстрация гибкости языка в решении надуманных нестандартных проблем.

#tricks

SQLAlchemy - это один из самых популярных ORM для работы с базами данных из Python.

- поддерживат все популярные базы данных
- не привязана к какому-либо фреймворку (как, например, Django ORM)
- поддерживает асинхрон
- позволяет удобно (питонично) делать довольно сложные SQL запросы

15 июля вышла первая версия из ветки 2.0 и это хорошйи повод изучить эту библиотеку если еще не начали.

Подобрал вам ресурсы для изучения:

- Вебинар и урок про новую SQLAlchemy2.0 от Mike Bayer (автор sqlalchemy и alembic ) с онлайн конференции pythonwebconf:

https://www.youtube.com/watch?v=Uym2DHnUEno

- Для тех кто на английском не очень, есть онлайн книга на руссом от https://xn--r1a.website/massonnn_yt.
А так же видео версия:

https://www.youtube.com/watch?v=leeC0fpAY-E&list=PLN0sMOjX-lm5Pz5EeX1rb3yilzMNT6qLM

Лично я использую алхимию в связке с FastAPI и пока всё устраивает

#tricks #libs

Как проверить является ли директория пустой?

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

if os.listdir(path):
    ...

Тоже самое с pathlib



p = Path(path)
if list(p.iterdir()):
    ...

В первом случае функция os.listdir возвращает полный список файлов. Нам остаётся проверить есть ли там что-либо.
Во втором случае мы получаем генератор, который под капотом использует тот же listdir.

Теперь представим что в директории 10к файлов

for i in range(10000):
    Path(f'/tmp/test/test{i}.txt').touch()

Не сказать, что при наличии SSD это проблема, но когда таких операций много, мы начинаем терять время, особенно с pathlib.

import timeit
test_path = '/tmp/test'
count = 1000

>>> timeit.timeit('list(os.listdir(p))', setup=f'import os;p="{test_path}"', number=count)
2.281363710993901
>>> timeit.timeit('list(p.iterdir())', setup=f'from pathlib import Path;p=Path("{test_path}")', number=count)
5.6957218300012755

То есть мы получаем список всех 10к файлов просто чтобы узнать что там есть файлы. Хотя нам надо узнать есть ли по указанному пути хотя бы один файл.
Для того чтобы ускорить проверку лучше воспользоваться функцией os.scandir(). Она работает на много быстрей и возвращает итератор с объектами os.DirEntry.
Чтобы узнать есть ли в директории хоть один файл достаточно использовать функцию next()



next(os.scandir(path))

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

if next(os.scandir(path), None):
    ...

Либо используем функцию any(), так как она завершится сразу после нахождения первого файла или если итератор пуст.

if any(os.scandir(path)):
    ...

Сравним скорость

>>> timeit.timeit('next(os.scandir(p), None)', setup=f'import os;p="{test_path}"', number=count)
0.2183076049986994
>>> timeit.timeit('any(os.scandir(p))', setup=f'import os;p="{test_path}"', number=count)
0.21016486900043674

#tricks

Функция dir() - удобна для получения списка атрибутов у любого объекта.

Ранее я писал про функцию __dir__() в модуле (не путайте её с переменной __all__(), которая указывает список объектов для импорта если встречается конструкция from module import *).

Скорее всего вы уже знаете как использовать функцию dir(). Любой объект может реализовать метод __dir__() чтобы указать список имеющийхся и динамических атрибутов. И функция dir() поможет получить список этих атрибутов.

>>> dir(str)
['__add__', '__class__', '__contains__', ...]

У этой функции есть еще один способ применения. Её можно вызвать без аргумента, и в таком случае она вернёт список имён в текущем неймспейсе.

>>> dir()
['__builtins__', '__doc__', '__file__', ...]

>>> def test():
>>>    x = 1
>>>    print(dir())
>>> test()
['x']

#basic #tricks

Что позволяет делать f-strings в 3.12.

▫️можно использовать одинаковые кавычки во всём выражении
▫️можно добавлять переносы для многострочного выражения
▫️можно использовать символ новой строки (эта проблема неактуальна)

>>> print(f"{"\n".join(
>>>     ["1","2","3", 
>>>     f"{
>>>         f"{2+2}"
>>>         *(2+2)
>>>      }"
>>>     ]
>>> )}")
1
2
3
4444


#tricks #libs

Варианты распаковки контейнеров по отдельным переменным

Обычная распаковка по точному количеству

data = [1, 2, 3, 4, 5]
v1, v2, v3, v4, v5 = data

Распаковка с неизвестным количество но не меньше чем N

v1, *_ = data
v1, *_, v4, v5 = data

Если точно знаете позицию нужного объекта в списке, включая вложенные списки, то достать его можно двумя способами
Через индекс:

data = [[1]]
v1 = data[0][0]

Через распаковку со скобками:

data = [[1]]
(v1, ), = data

data = [[[1]]]
((v1,), ), = data

Еще примеры распаковки вложенных объектов

data = [[1, 2], [3, 4], [5, 6]]
(v1, v2), (v3, v4), (v5, v6) = data
(v1, v2), *_, (v5, *_) = data

#tricks

Когда пишешь асинхронный код нужно учитывать особенности такого подхода. Всегда требуется держать в уме, когда возвращается корутина а когда реальный результат. Между этими двумя сущностями должен быть вызов через await.
Вот пример синхронного запроса в базу данных с помощь sqlalchemy. Query пишу инлайном для компактности.

entities = session.execute(select(EntityModel)).scalars().all()

Всё ясно и линейно. А вот он же асинхронный.

result = await session.execute(select(EntityModel))
entities = result.scalars().all()

Это значит что session.execute возвращает корутину, или awaitable объект. Сначала его нужно выполнить через await, тогда получишь объект с которым можно дальше работать.
Не хочу сказать что это мастхэв практика, но простые асинхронные запросы тоже можно сократить до одной строки. Просто использовать скобки.

entities = ( await session.execute(select(EntityModel)) ).scalars().all()

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

#tricks

Функция subprocess.check_output() удобна, когда нужно просто получить аутпут процесса.

info = subprocess.check_output(cmd, text=True)

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

CalledProcessError: Command '[...]' returned non-zero exit status 1.

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

За генерацию исключения отвечает аргумент check, который по умолчанию равен False но именно в check_output он равен True и не может быть переопределён при вызове.

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

Классы TimeoutExpired и CalledProcessError имеют ряд атрибутов, которые хранят всю нужну инфу. Например, вызванная команда (cmd), код выхода (returncode) и то что мы ищем - аутпут процесса (output)

Итого, базовая фукнция для захвата аутпута для любого кода выхода будет выглядеть как-то так:

def get_proc_output(cmd):
    try:
        return subprocess.check_output(cmd, text=True)
    except subprocess.CalledProcessError as e:
        return e.output

#tricks

Нередко требуется удалять дубликаты инстансов класса. Для этого обычно используется либо циклы со сравнением некоторых атрибутов, либо тип данных set().

При добавлении элемента в set происходит сравнение этого объекта по хешу. Если хеш совпадает с хешем уже существующего объекта, то происходит сравнение объектов на равенство. Если объекты равны, то новый объект не добавляется.

class A:
    def __init__(self, pk: int):
        self.pk = pk
    def __repr__(self):
        return f"{self.__class__.__name__}(pk={self.pk})"

set([A(pk=1), A(pk=2), A(pk=2)])
>>> {A(pk=1), A(pk=2), A(pk=2)}

Далее для краткости метод `__repr__()` я буду пропускать

По умолчанию в расчёте хеша, помимо прочего, используется адрес в памяти, который можно получить с помощью функции id(), поэтому все объекты считаются разными. Чтобы изменить способ сравнения объектов нам требуется переопределить метод __eq__()

class A:
    def __init__(self, pk: int):
        self.pk = pk
    def __eq__(self, other):
        return self.pk == other.pk

set([A(pk=1), A(pk=2), A(pk=2)])
>>> TypeError: unhashable type: 'A'

Теперь в дело вступает логика, описаная в документации.
Если вы переопределили __eq__() то следует переопределить и __hash__().

class A:
    def __init__(self, pk: int):
        self.pk = pk
    def __eq__(self, other):
        return self.pk == other.pk
    def __hash__(self):
        return hash(self.pk)

set([A(pk=1), A(pk=2), A(pk=2)])
>>> {A(pk=1), A(pk=2)}

Отлично, теперь всё работает.
Этот же принцип действует и при наследовании. Допустим, вы создали дочерний класс

class B(A):
    pass

set([B(pk=1), B(pk=2), B(pk=2)])
>>> {B(pk=1), B(pk=2)}

Теперь следует учитывать вот такое поведение

hash(A(1)) == hash(B(1))
>>> True
set([A(1), B(1)])
>>> {A(pk=1)}

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

class A:
    ...
    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.pk == other.pk
    
    def __hash__(self):
        return hash((self.pk, self.__class__))
    ...

Но если вдруг решите как-то изменить способ сравнения в классе В...

class B(A):
    def __eq__(self, other):
        return abs(self.pk) == abs(other.pk)

set([B(pk=1), B(pk=2), B(pk=2)])
>>> TypeError: unhashable type: 'B'

Снова получите ошибку. Та же логика - при переопределении метода __eq__() в новом классе метод __hash__() автоматически становится None и его тоже требуется переопределить.

#tricks

Три способа создать декоратор для метода класса.

▫️Способ 1. Обычная функция.

Единственное отличие от простого декоратора функции в том, что нужно учитывать аргумент self.
Если же он не нужен то просто пробрасываем его через *args

def decorator_func(func):
    def wrapped(*args, **kwargs):
        print('decorator_func')
        return func(*args, **kwargs)
    return wrapped

class MyClass:
    @decorator_func
    def method(self):
        print('call method')

MyClass().method()
# decorator_func
# call method

▫️Способ 2. Методы класса.

Но что, если декоратор жестко привязан к классу и используется только в нём. И стоит задача закрепить декоратор именно за этим классом и расположить внутри него.
В таком случае можно сделать staticmethod. Это будет выглядеть страшно, но работать будет (тестировано на 3.11)
Очевидно, что декоратор должен быть объявлен раньше метода.

class MyClass:
    @staticmethod
    def decorator(func):
        def wrapper(*args, **kwargs):
            print('decorator from staticmethod')
            return func(*args, **kwargs)
        return wrapper

    @decorator.__func__
    def method(self):
        print('method called')

MyClass().method()
# decorator from staticmethod
# method called

Тоже самое будет и с classmethod, но еще хуже.

class MyClass:
    @classmethod
    def decorator(func):
        def wrapper(self, *args, **kwargs):
            print('decorator from classmethod')
            return func(self, *args, **kwargs)
        return wrapper

    @decorator.__func__
    def method(self):
        print('method called')

MyClass().method()
# decorator from classmethod
# method called

Где-то потерялся аргумент cls. Скорее всего это можно решить но лучше не надо. Оба варианта выглядят страшненько 🫣

▫️Способ 3. Вложенный класс и staticmethod

class MyClass:
    class deco:
        @staticmethod
        def my_decorator(func):
            def wrapper(*args, **kwargs):
                print('decorator from subclass')
                return func(*args, **kwargs)
            return wrapper
    
    @deco.my_decorator
    def method(self):
        print('method called')

MyClass().method()
# decorator from subclass
# method called

Получаем чтото вроде микса способов 1 и 2: функция вложена в отдельный класс.

Лучшей практикой является способ 1 - обычные функции.

Всего пару раз за практику я использовал 3й способ, когда декоратор был намертво привязан к классу и нигде больше не мог использоваться (например, отправлял вызов метода на воркера в другой процесс, не спрашивайте почему так, просто так было нужно 🤪)

Способ 2 не советую. Это, скорей, разминка для ума чем практический пример.

PS
- wraps пропустил для краткости
- в коментах дополнительная инфа

#tricks