Атрибут shape возвращает кортеж с размерностями структуры данных pandas. Для одномерного объекта Series единственное значение этого кортежа совпадает с размером этого Series. Запятая после 3 — стандартное наглядное представление кортежей Python из одного элемента:

print(diet.shape) # (3, )

В Python 3.6+ можно использовать кириллические имена переменных в f-строках. Это стало возможным благодаря PEP 498, который ввел f-строки в Python 3.6. Однако это bad practice.

f-строки — это нечто большее, чем просто вставка переменных. Существует скрытый синтаксис форматирования, называемый Format Mini-Language, который позволяет вам лучше контрировать форматирование:

memory = 1.5e9  # 1.5 Гб в байтах

# Базовый пример
print(f"Memory: {memory / 1e9:+.2f} GB") # Добавит знак плюса, оставит только два знака после запятой

# Разные форматы чисел
print(f"Memory (scientific): {memory / 1e9:.2e} GB")  # научная нотация
print(f"Memory (percentage): {memory / 1e9:.1%} GB")  # процентный формат
print(f"Memory (binary): {int(memory):b} bytes")  # двоичный формат

В Format Mini-Language есть еще фокусы:

memory = 1.5e9  # 1.5 GB в байтах

# Выравнивание и заполнение
print(f"Memory (right aligned): {memory / 1e9:>10.2f} GB")  # выравнивание по правому краю
print(f"Memory (left aligned): {memory / 1e9:<10.2f} GB")  # выравнивание по левому краю
print(f"Memory (centered): {memory / 1e9:^10.2f} GB")  # центрирование
print(f"Память: {memory / 1e9:010.2f} GB")  # заполнение нулями

# Группировка цифр
print(f"Память: {memory:,.0f} байт(-ов)")  # разделение запятыми

LRUcache (от англ. Least Recently Used cache) — это механизм кэширования, который хранит ограниченное количество результатов вычислений или обращений к данным, и при переполнении освобождает место, удаляя из кэша самый долго неиспользуемый элемент.

Декоратор @cache применяется к функциям и автоматически запоминает результаты их вызовов с конкретными аргументами. Если функция с такими же аргументами вызывается повторно, результат берется из кэша, что значительно ускоряет работу, особенно при дорогих в вычислении функциях.

Интерпретатор «замрет», потому что попадет в состояние бесконечного ожидания (deadlock).

future = Future() # создаем Future-объект в состоянии pending

print(future.result()) # Просим показать result(), БЛОКИРУЯ

future.set_result("Hello from the future!") # Задаем result

result() будет ждать, пока результат не будет установлен, но set_result() никогда не будет вызван, так как выполнение программы остановилось на предыдущей строке.

С такой ситуацией можно справиться, если добавить аргумент-таймаут:

future.result(timeout=1)

Cоздаем объект Future из модуля asyncio (это не то же самое, что concurrent.futures.Future:

future = asyncio.Future()

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

asyncio.create_task(set_after_delay(future))

Она:
- Принимает future как параметр
- Ждет 1 секунду
- Устанавливает результат в future

Ждем, пока future получит результат. Это не блокирует весь интерпретатор, а только текущую корутину:

result = await future

Это еще называют «Неблокирующим ожиданием».