Чтобы объект можно было использовать в качестве ключа словаря, он должен быть хешируемым. Хешируемые объекты поддерживают метод __hash__, который возвращает целое число. Для получения хеша значения используется встроенная функция hash.

Встроенные типы, которые являются неизменяемыми, по умолчанию хешируемы. Все пользовательские объекты тоже хешируемы, но есть нюанс. Если вы определяете метод __eq__ для своего типа, то вы также должны определить __hash__ таким образом, чтобы hash(a) == hash(b) для всех a и b, которые считаются равными. Нарушение этого правила может привести к некорректной работе словаря:

class A:
    def __init__(self, x):
        self.x = x
        
    def __hash__(self):
        return random.randrange(10000)
    
    def __eq__(self, other):
        return self.x == other.x

d = {}
d[A(2)] = 2
d.get(A(2), 0)
# Вывод: 0

Обратите внимание: как только вы определяете __eq__ в классе, реализация __hash__ по умолчанию удаляется, так как она больше не подходит (по умолчанию все значения считаются неравными).

👉@BookPython

Python поддерживает цепочные присваивания со следующим синтаксисом:

a = b = c = 42

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

a = (b = (c = 42))

В Python всё не так. Операция присваивания не возвращает результат — это оператор, а не выражение. Вместо этого происходит несколько присваиваний слева направо:

  2           0 LOAD_CONST       1 (42)
              2 DUP_TOP
              4 STORE_FAST       0 (a)
              6 DUP_TOP
              8 STORE_FAST       1 (b)
             10 STORE_FAST       2 (c)

👉@BookPython

Как отлаживать Python-код, не выходя из редактора — с помощью встроенного модуля pdb.

🔍 Быстрая отладка с pdb

Часто, когда код не работает как надо, мы начинаем закидывать print()-ами. Но это неудобно, медленно и мусорит код. Вместо этого вставь в нужное место строчку:

import pdb; pdb.set_trace()

Когда выполнение дойдет до этой строки, ты попадешь в интерактивную консоль отладчика прямо в терминале. Дальше можно:

- n (next) — перейти к следующей строке;
- s (step) — зайти внутрь функции;
- c (continue) — продолжить выполнение;
- l (list) — показать текущий контекст;
- p var — вывести значение переменной var.

💡 Пример

def calc(a, b):
    import pdb; pdb.set_trace()
    result = a + b
    return result

calc(2, 3)

На строке с pdb.set_trace() ты остановишься и сможешь изучить, что происходит внутри.

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

- Понять, почему что-то идет не так.
- Посмотреть, какие значения у переменных прямо в момент ошибки.
- Быстро отладить без запуска IDE — удобно в Docker, SSH или при работе с cron.

Попробуй — один раз освоишь, и уже не захочешь возвращаться к print().


👉@BookPython

Некоторые модули Python скомпилированы непосредственно в интерпретатор. Они называются встроенными модулями и не должны путаться со стандартной библиотекой. Полный список таких модулей можно получить с помощью sys.builtin_module_names. Среди них можно отметить sys, gc, time и другие.

Обычно не имеет значения, является ли модуль встроенным, однако стоит учитывать, что import всегда сначала ищет модуль среди встроенных. То есть встроенный модуль sys будет загружен, даже если у вас в каталоге есть файл sys.py. С другой стороны, если у вас, например, есть datetime.py в текущей директории, он действительно может быть загружен вместо стандартного модуля datetime.


👉@BookPython

Сегодня покажу вам удобный способ следить за производительностью Python-кода прямо в терминале — с помощью py-spy.

🔍 Что такое py-spy?

py-spy — это sampling-профайлер для Python, который не требует модификации кода и может подключаться к уже работающим процессам. Он написан на Rust, работает очень быстро и почти не влияет на производительность.



🛠 Установка:

pip install py-spy

Или, если хочется поставить бинарник напрямую:

curl -sSL https://install.python-poetry.org | python3 -

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

1. Снять снимок с работающего процесса:

py-spy top --pid 12345

Альтернатива htop, но показывает, какие функции Python жрут CPU.

2. Записать flamegraph:

py-spy record -o profile.svg --pid 12345

Откроется красивая SVG-шечка, где видно, куда утекает время выполнения.

3. Запустить скрипт с профилированием:

py-spy top -- python my_script.py

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

- Падает производительность? Посмотри, какие функции грузят процессор.
- Программа зависла? Снимок покажет, где именно.
- Хотите оптимизировать горячие участки? Flamegraph быстро выведет подозреваемых.


🔥 Совет от меня: py-spy умеет работать с контейнерами и виртуальными окружениями, просто указывайте --pid правильного процесса. Идеален для DevOps'а и продакшн-серверов.

👉@BookPython

В Python вы можете легко изменять все стандартные переменные, доступные в глобальном пространстве имён:

>>> print = 42
>>> print(42)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

Это может быть полезно, если ваш модуль определяет какие-то функции с теми же именами, что и встроенные. Такое также случается при метапрограммировании, когда вы принимаете произвольную строку в качестве идентификатора.

Тем не менее, даже если вы затеняете (shadow) некоторые встроенные имена, вам всё ещё может понадобиться доступ к оригинальным объектам, на которые они изначально ссылались. Для этого существует модуль builtins:

>>> import builtins
>>> print = 42
>>> builtins.print(1)
1

Также переменная __builtins__ доступна в большинстве модулей. Однако здесь есть нюанс. Во-первых, это деталь реализации CPython, и обычно её вообще не стоит использовать. Во-вторых, __builtins__ может ссылаться либо на builtins, либо на builtins.__dict__, в зависимости от того, как именно был загружен текущий модуль.

👉@BookPython

Подборка Telegram каналов для программистов

https://t.me/bash_srv Bash Советы
https://t.me/win_sysadmin Системный Администратор Windows
https://t.me/lifeproger Жизнь программиста. Авторский канал.
https://t.me/devopslib Библиотека девопса | DevOps, SRE, Sysadmin
https://t.me/rabota1C_rus Вакансии для программистов 1С

Системное администрирование 📌
https://t.me/sysadmin_girl Девочка Сисадмин
https://t.me/srv_admin_linux Админские угодья
https://t.me/linux_srv Типичный Сисадмин

https://t.me/linux_odmin Linux: Системный администратор
https://t.me/devops_star DevOps Star (Звезда Девопса)
https://t.me/i_linux Системный администратор
https://t.me/linuxchmod Linux
https://t.me/sys_adminos Системный Администратор
https://t.me/tipsysdmin Типичный Сисадмин (фото железа, было/стало)
https://t.me/sysadminof Книги для админов, полезные материалы
https://t.me/i_odmin Все для системного администратора
https://t.me/i_odmin_book Библиотека Системного Администратора
https://t.me/i_odmin_chat Чат системных администраторов
https://t.me/i_DevOps DevOps: Пишем о Docker, Kubernetes и др.
https://t.me/sysadminoff Новости Линукс Linux

1C разработка 📌
https://t.me/odin1C_rus Cтатьи, курсы, советы, шаблоны кода 1С
https://t.me/DevLab1C 1С:Предприятие 8

Программирование C++📌
https://t.me/cpp_lib Библиотека C/C++ разработчика
https://t.me/cpp_knigi Книги для программистов C/C++
https://t.me/cpp_geek Учим C/C++ на примерах

Программирование Python 📌
https://t.me/pythonofff Python академия. Учи Python быстро и легко🐍
https://t.me/BookPython Библиотека Python разработчика
https://t.me/python_real Python подборки на русском и английском
https://t.me/python_360 Книги по Python Rus

Java разработка 📌
https://t.me/BookJava Библиотека Java разработчика
https://t.me/java_360 Книги по Java Rus
https://t.me/java_geek Учим Java на примерах

GitHub Сообщество 📌
https://t.me/Githublib Интересное из GitHub

Базы данных (Data Base) 📌
https://t.me/database_info Все про базы данных

Мобильная разработка: iOS, Android 📌
https://t.me/developer_mobila Мобильная разработка
https://t.me/kotlin_lib Подборки полезного материала по Kotlin

Фронтенд разработка 📌
https://t.me/frontend_1 Подборки для frontend разработчиков
https://t.me/frontend_sovet Frontend советы, примеры и практика!
https://t.me/React_lib Подборки по React js и все что с ним связано

Разработка игр 📌
https://t.me/game_devv Все о разработке игр

Библиотеки 📌
https://t.me/book_for_dev Книги для программистов Rus
https://t.me/programmist_of Книги по программированию
https://t.me/proglb Библиотека программиста
https://t.me/bfbook Книги для программистов
https://t.me/books_reserv Книги для программистов

БигДата, машинное обучение 📌
https://t.me/bigdata_1 Data Science, Big Data, Machine Learning, Deep Learning

Программирование 📌
https://t.me/bookflow Лекции, видеоуроки, доклады с IT конференций
https://t.me/coddy_academy Полезные советы по программированию
https://t.me/rust_lib Полезный контент по программированию на Rust
https://t.me/golang_lib Библиотека Go (Golang) разработчика
https://t.me/itmozg Программисты, дизайнеры, новости из мира IT
https://t.me/php_lib Библиотека PHP программиста 👨🏼‍💻👩‍💻
https://t.me/nodejs_lib Подборки по Node js и все что с ним связано
https://t.me/ruby_lib Библиотека Ruby программиста

QA, тестирование 📌
https://t.me/testlab_qa Библиотека тестировщика

Шутки программистов 📌
https://t.me/itumor Шутки программистов

Защита, взлом, безопасность 📌
https://t.me/thehaking Канал о кибербезопасности
https://t.me/xakep_2 Хакер Free

Книги, статьи для дизайнеров 📌
https://t.me/ux_web Статьи, книги для дизайнеров

Математика 📌
https://t.me/Pomatematike Канал по математике
https://t.me/phis_mat Обучающие видео, книги по Физике и Математике

Excel лайфхак📌
https://t.me/Excel_lifehack

https://t.me/tikon_1 Новости высоких технологий, науки и техники💡
https://t.me/mir_teh Мир технологий (Technology World)

Вакансии 📌
https://t.me/sysadmin_rabota Системный Администратор
https://t.me/progjob Вакансии в IT

Обработка исключений в асинхронных программах может быть непростой задачей.

В asyncio, если корутина выбрасывает исключение, оно передаётся в тот код, который ожидает соответствующий future. Если await вызывается в нескольких местах, то каждое из них получит это исключение (так как оно сохраняется внутри объекта исключения). Следующий код напечатает сообщение об ошибке пять раз:

import asyncio

async def error():
    await asyncio.sleep(1)
    raise ValueError()

async def waiter(task):
    try:
        await task
    except ValueError:
        print('error')
    else:
        print('OK')

async def main():
    task = asyncio.get_event_loop().create_task(error())

    for _ in range(5):
        asyncio.get_event_loop().create_task(waiter(task))

    await asyncio.sleep(2)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

Если исключение выброшено, но задача (task) ни разу не была ожидаема (awaited), исключение будет потеряно. В таком случае при уничтожении задачи вы получите предупреждение: “Task exception was never retrieved”.

Когда вы используете await asyncio.gather(tasks) и одна из задач выбрасывает исключение, оно передаётся наружу. Однако если несколько задач выбросят исключения, вы получите только первое, остальные будут проигнорированы:

import asyncio

async def error(i):
    await asyncio.sleep(1)
    raise ValueError(i)

async def main():
    try:
        await asyncio.gather(
            error(1),
            error(2),
            error(3),
        )
    except ValueError as e:
        print(e)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

Вы можете использовать gather с параметром return_exceptions=True, чтобы получать исключения как обычные значения. Следующий код напечатает: [42, ValueError(2,), ValueError(3,)]

import asyncio

async def error(i):
    await asyncio.sleep(1)
    if i > 1:
        raise ValueError(i)
    return 42

async def main():
    results = await asyncio.gather(
        error(1),
        error(2),
        error(3),
        return_exceptions=True,
    )

    print(results)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

👉@BookPython

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

Библиотека NumPy поддерживает Ellipsis в качестве аргумента __getitem__, например: x[...] возвращает все элементы массива x.

PEP 484 придаёт Ellipsis дополнительное значение: Callable[..., type] — это способ определить тип вызываемых объектов без указания типов аргументов.

Наконец, ... можно использовать, чтобы обозначить, что функция ещё не реализована. Это абсолютно валидный код на Python:

def x():
    ...

👉@BookPython

Когда вы пишете obj.x = y, нельзя быть уверенным, что атрибут x объекта obj действительно станет равным y. Протокол дескрипторов в Python позволяет определить, как будет обрабатываться присваивание атрибутов.

class Descriptor:
    def __set__(self, obj, value):
        obj.test = value

class A:
    x = Descriptor()

В этом примере x напрямую никогда не присваивается значение — вместо этого устанавливается атрибут test:

>>> a = A()
>>> a.x = 42
>>> a.test
42
>>> a.x
<__main__.Descriptor at 0x7ff7baef51d0>

Если всё же нужно напрямую изменить значение x, например, в тестах или при использовании метапрограммирования, придётся обращаться напрямую к __dict__:

>>> a.__dict__['x'] = 42
>>> a.x
42

👉@BookPython

itertools.tee() создаёт несколько итераторов из одного. Это может быть полезно, если несколько потребителей должны читать один и тот же поток данных.

In : a, b, c = tee(iter(input, ''), 3)

In : next(a), next(c)
FIRST
Out: ('FIRST', 'FIRST')

In : next(a), next(b)
SECOND
Out: ('SECOND', 'FIRST')

In : next(a), next(b), next(c)
THIRD
Out: ('THIRD', 'SECOND', 'SECOND')

Данные, которые ещё не были использованы всеми итераторами, сохраняются в памяти. Если какие-то из созданных итераторов ещё не начали чтение к моменту, когда другие уже завершили, это означает, что все сгенерированные элементы будут сохранены в памяти для последующего использования. В таком случае проще и эффективнее использовать list(iter(input, '')) вместо tee.


👉@BookPython

Чтобы сохранить любую информацию в памяти или на устройстве хранения, её необходимо представить в виде байтов. Python, как правило, предоставляет уровень абстракции, при котором вы оперируете непосредственно данными, а не их байтовым представлением.

Тем не менее, когда вы, скажем, записываете строку в файл, вы работаете с физической структурой данных. Чтобы поместить символы в файл, их нужно преобразовать в байты — это называется кодированием. Когда вы получаете байты из файла, скорее всего, вы захотите превратить их в осмысленные символы — это называется декодированием.

Существует сотни методов кодирования. Самый популярный — вероятно, Unicode, но он сам по себе не может преобразовывать данные в байты. В смысле байтового представления Unicode вообще не является кодировкой. Unicode определяет соответствие между символами и их числовыми кодами. Например, 🐍 имеет код 128013.

Но чтобы записать числа в файл, нужна настоящая кодировка. Unicode обычно используется вместе с utf-8, которая (в большинстве случаев) является стандартной в Python. При чтении из файла Python автоматически декодирует utf-8. Вы можете выбрать любую другую кодировку с помощью параметра encoding= функции open, либо читать «сырые» байты, добавив b к режиму открытия файла.

👉@BookPython

Если вы создаёте новые объекты внутри метода __init__, возможно, будет лучше передавать их как аргументы и использовать фабричный метод. Это позволяет разделить бизнес-логику и технические детали создания объектов.

В этом примере __init__ принимает host и port для создания подключения к базе данных:

class Query:
    def __init__(self, host, port):
        self._connection = Connection(host, port)

Возможный рефакторинг:

class Query:
    def __init__(self, connection):
        self._connection = connection
        
    @classmethod
    def create(cls, host, port):
        return cls(Connection(host, port))

Такой подход имеет как минимум следующие преимущества:

• Упрощает внедрение зависимостей. В тестах можно использовать Query(FakeConnection()).
• Класс может иметь столько фабричных методов, сколько нужно; подключение может создаваться не только по host и port, но и путём клонирования другого подключения, чтения конфигурационного файла или объекта, использования значения по умолчанию и т.д.
• Такие фабричные методы можно сделать асинхронными; это невозможно для __init__.


👉@BookPython

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

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

import functools

def log_calls(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"[CALL] {func.__name__} args={args} kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"[RETURN] {func.__name__} -> {result}")
        return result
    return wrapper

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

@log_calls
def multiply(a, b):
    return a * b

multiply(3, 5)

📌 Вывод:

[CALL] multiply args=(3, 5) kwargs={}
[RETURN] multiply -> 15

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

Кстати, с небольшими изменениями можно направить вывод не в print(), а в logging, или даже сохранять в файл — по вкусу.

Пользуетесь такими декораторами? Или у вас свой лайфхак?


👉@BookPython

Одна и та же строка может быть представлена по-разному в Unicode, и стандарт это учитывает. Он определяет два типа эквивалентности: последовательности могут быть канонически эквивалентными или совместимыми.

Канонически эквивалентные последовательности выглядят одинаково, но содержат разные кодовые точки. Например, символ ö может быть представлен как LATIN SMALL LETTER O WITH DIAERESIS (U+00F6) или как комбинация из o и диакритического знака: LATIN SMALL LETTER O (U+006F) + COMBINING DIAERESIS (U+0308).

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

Для каждого из этих типов эквивалентности можно нормализовать строку в Unicode, сжимая или расширяя последовательности. В Python для этого используется модуль unicodedata:

import unicodedata

modes = [
    # Сжать канонически эквивалентные
    'NFC',
    # Расширить канонически эквивалентные
    'NFD',
    # Сжать совместимые
    'NFKC',
    # Расширить совместимые
    'NFKD',
]

s = 'ff + ö'

for mode in modes:
    norm = unicodedata.normalize(mode, s)
    print('\t'.join([
        mode,
        norm,
        str(len(norm.encode('utf8'))),
    ]))

Результат:

NFC     ff + ö   8
NFD     ff + ö   9
NFKC    ff + ö  7
NFKD    ff + ö  8

👉@BookPython

Обычно вы взаимодействуете с генератором, запрашивая данные с помощью next(gen). В Python 3 вы также можете отправлять значения обратно в генератор с помощью g.send(x). Но существует техника, которой вы, вероятно, не пользуетесь каждый день, а возможно, и вовсе не знаете: выбрасывание исключений внутри генератора.

С помощью gen.throw(e) можно выбросить исключение в той точке, где генератор gen приостановлен — то есть на инструкции yield. Если генератор обрабатывает это исключение, gen.throw(e) возвращает следующее значение, полученное через yield (или выбрасывает StopIteration, если генератор завершён). Если генератор не перехватывает исключение, оно пробрасывается обратно к вызывающему коду.

def gen():
    try:
        yield 1
    except ValueError:
        yield 2

g = gen()

next(g)
# Out: 1

g.throw(ValueError)
# Out: 2

g.throw(RuntimeError('TEST'))
# RuntimeError: TEST

Эта техника позволяет более точно управлять поведением генератора — не только передавать данные внутрь, но и, например, сообщать о проблемах со значениями, полученными через yield. Однако такие случаи бывают редко, и встретить g.throw в дикой природе почти невозможно.

Тем не менее, декоратор @contextmanager из модуля contextlib использует именно такую технику, позволяя коду внутри контекста перехватывать исключения.

from contextlib import contextmanager

@contextmanager
def atomic():
    print('BEGIN')

    try:
        yield
    except Exception:
        print('ROLLBACK')
    else:
        print('COMMIT')

with atomic():
    print('ERROR')
    raise RuntimeError()

BEGIN  
ERROR  
ROLLBACK

👉@BookPython

Стандартный механизм расширения путей в оболочке называется globbing. Шаблоны, которые вы используете для сопоставления путей, называются globs.

$ echo /li*
/lib /lib64

Python поддерживает globbing с помощью модуля glob. Однако есть важное замечание: оболочка возвращает сам шаблон, если файлы не найдены, а Python — нет:

$ echo /zz**
/zz**
$ python -c 'from glob import glob; print(glob("/zz**"))'
[]

👉@BookPython

Функция super() позволяет обращаться к родительскому (базовому) классу. Это может быть очень полезно в случаях, когда производный класс хочет добавить что-то к реализации метода, а не полностью переопределять его:

class BaseTestCase(TestCase):
    def setUp(self):
        self._db = create_db()

class UserTestCase(BaseTestCase):
    def setUp(self):
        super().setUp()
        self._user = create_user()

Имя функции super не означает "отличный" или "очень хороший". В данном контексте слово super означает "выше" (как, например, в слове superintendent — заведующий). Несмотря на это, super() не всегда ссылается на базовый класс — он может вернуть и "соседний" класс. Более точным названием была бы, возможно, функция next(), так как возвращается следующий класс согласно цепочке разрешения методов (MRO — Method Resolution Order).

Пример:

class Top:
    def foo(self):
        return 'top'

class Left(Top):
    def foo(self):
        return super().foo()

class Right(Top):
    def foo(self):
        return 'right'

class Bottom(Left, Right):
    pass

# выводит 'right'
print(Bottom().foo())

Обрати внимание: результат работы super() может отличаться в зависимости от MRO вызвавшего объекта.

>>> Bottom().foo()
'right'
>>> Left().foo()
'top'

👉@BookPython

Функция map вызывает другую функцию для каждого элемента итерируемого объекта. Это значит, что функция должна принимать одно значение в качестве аргумента:

In : list(map(lambda x: x ** 2, [1, 2, 3]))
Out: [1, 4, 9]

Однако если каждый элемент итерируемого объекта — это кортеж, было бы удобно передавать каждый элемент кортежа как отдельный аргумент. В Python 2 это было возможно благодаря распаковке параметров кортежа (обратите внимание на скобки):

>>> map(lambda (a, b): a + b, [(1, 2), (3, 4)])
[3, 7]

В Python 3 эта возможность исчезла, но есть другое решение — itertools.starmap. Она распаковывает кортежи за вас, будто функция вызывается со звёздочкой: f(*arg) (отсюда и название функции):

from itertools import starmap

In [3]: list(starmap(lambda a, b: a + b, [(1, 2), (3, 4)]))
Out[3]: [3, 7]

👉@BookPython