Использование распаковки для исключения лишних элементов

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

>>>record = ('kiriharu', 'me@kiriha.ru', '8-800-555-35-35', '1337-1337')
>>>get_phones(record)
['8-800-555-35-35', '1337-1337']

Второй пример показывает, что распаковку можно использовать даже в середине присваивания. Функция отбросит первый и последний элемент в списке, а остальное запишет в grades:

>>>grades = ('kiriharu', 1, 1, 1, 1, 'A')
>>>get_grades(grades)
[1, 1, 1, 1]

Выражение со звездочкой можно использовать как угодно - можно наоборот отбросить всё то, что попадает в него, а остальное вернуть. Попробуйте сами написать такую функцию :)

Код на GitHub
#std

Несколько методов для эмуляции числовых типов

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

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

>>> v1 = Vector2D(1, 1)
>>> v2 = Vector2D(5, 6)
>>> v1 + v2
Vector(6, 7)
>>> v1 * 3
Vector(3, 3)

GitHub
#std

Возвращайте NotImplemented для неподдерживаемых бинарных операций с вашим типом

В комментариях к предыдущему посту возник вопрос, что если вместо целочисленного scalar к нам придет float или какой-то другой тип?

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

Оказывается, в Python есть следующий механизм: если метод представляющий бинарную операцию (__add__, __mul__ и т.д.) возвращает NotImplemented, то Python попытается произвести отраженную операцию (для x.__mul__(1) вызовет 1.__rmul__(x), например) или другие операции, в зависимости от оператора. Как только все возможные методы вернут NotImplemented он сам возбудит исключение на месте вызова метода в вашем коде, а не в коде класса:

>>> v1 = Vector2D(1, 2)
>>> v1 * 1.1
TypeError: unsupported operand type(s) for *: 'Vector2D' and 'float'

Списки магических методов и рекомендации по их реализации можно найти в разделе Data model

GitHub | Объяснение "на пальцах"
#std

Как работает bool()?

Python может принимать любой объект в булевом контексте. Чтобы определить, является ли выражение истинным или ложным, применяется функция bool(x), которая должна вернуть булево значение (True или False).

По умолчанию, объект попытается вызвать метод __bool__, который должен вернуть булево значение. Если реализованного метода нет, то Python попытается вызвать __len__, который должен вернуть 0 или значение больше ноля - при ноле результатом будет False, соответственно при значении больше ноля - True. Если ни один метод не реализован, то автоматически вернется True.

Резюмируя, получается такая цепочка: __bool__ → __len__ → True
#std

Немного фактов про str() и repr()

- repr() вызывает метод __repr__ объекта, а метод str(), собственно __str__.
- repr() вызывается интерактивной оболочкой, при попытке вывести объект.
- Если метод __str__ в объекте не определен, то вызывается __repr__.

А что вы можете сказать про str() и repr()? Пишите ниже, в комментарии 👇
#std

Когда использовать __str__ или __repr__?

Оба магических метода используются для получения строкового представления объекта. Но как их лучше использовать - можно увидеть на картинке.

Таким образом имеем, что __repr__ должен использоваться для предоставлении информации об объекте разработчику, а __str__ должен быть читаемым и использоваться для представления информации пользователю.
#std

В канале недавно уже был пост про namedtuple, но мне ещё есть что про него рассказать.

Первое, что я хотел бы вам показать - именованный кортеж можно создать с помощью любой структуры данных, которая поддерживает итерирование:

>>> lst = ['Mining', 'Excavating', 'Boiling']
>>> Skills = namedtuple('Skills', lst)
>>> skills = Skills(1, 2, 3)
>>> skills
Skills(Mining=1, Excavating=2, Boiling=3)

Ещё мы можем создать кортеж через метод _make():

>>> skills = Skills._make([1, 2, 3])
Skills(Mining=1, Excavating=2, Boiling=3)

В примере используется список, но никто не мешает вам сделать такое же с кортежем, множеством и даже словарем (но вот только значения которые вы установите для ключа игнорируются).

Именованные кортежи неизменяемые, но мы можем использовать метод _replace(), чтобы изменить данные. Под капотом он использует метод _make для создания нового кортежа, поэтому, по сути, мы просто пересоздадим кортеж:

>>> skills._replace(Mining=100)
Skills(Mining=100, Excavating=2, Boiling=3)

#std

Типизация именованных кортежей.

Один из комментаторов указал, что namedtuple() объявлен устаревшим и в 3.10 его поддержка прекратится. Что же делать? Использовать NamedTuple, если в вашем проекте питон выше версии 3.6.

Именованный кортеж можно создать 2 путями - через наследование NamedTuple (класс Skills) или старым способом (AnotherSkills). Оба способа содержат аннотации типов, повышающие (как минимум) читаемость кода.
Все методы, которые были в namedtuple (_make(), _replace(), _asdict()) работают:

>>> s = Skills(0)
>>> s._asdict()
{'mining': 0, 'excavating': 1}

Теперь мы можем посмотреть на аннотации:

s.__annotations__
{'mining': <class 'int'>, 'excavating': <class 'int'>}

Так же, ничего не мешает добавлять новые методы или оверрайтить существующие. В примере у Skills переопределен метод для str():

>>>str(s)
'Какой качок, уровень копания: 0\nуровень лесорубства: 100'

GitHub
#std

Про применение all()

Стандартная библиотека Python полна полезных вещей, но полезные вещи есть даже среди встроенных функций. Одна из таких встроенных функций - это all().

Функция all() возвращает True, если все элементы истинные (или объект пустой).

К примеру, all() очень удобно использовать с генераторами. Например, мы можем проверить, являются ли все октеты в IP-адресе числами:

>>> all(i.isdigit() for i in '127.0.0.b'.split('.'))
False
>>> all(i.isdigit() for i in '127.0.0.1'.split('.'))
True
#std

Поиск N максимальных или минимальных элементов.

Если вы хотите создать список из N максимальных или минимальных элементов, модуль heapq вам поможет в этом.
У этого модуля есть две функции: nlargest() и nsmallest(), которые, соответственно ищут максимальные и минимальные элементы. Например:

>>> nums = [10, 20, 30, 40, 55, 632, -3, 98321, 82, 0, 8]
>>> heapq.nlargest(4, nums)
[98321, 632, 82, 55]
>>> heapq.nsmallest(4, nums)
[-3, 0, 8, 10]

Обе функции принимают параметр key, который позволяет их использовать с сложными структурами данных. Например:

currency = [
dict(name="Etherium", price=3323),
dict(name="Bitcoin", price=45538),
dict(name="ZCash", price=132),
dict(name="Litecoin", price=184),
dict(name="OmiseGo", price=8.933)
]

>>> heapq.nsmallest(2, currency, key=lambda s: s['price'])
[{'name': 'OmiseGo', 'price': 8.933}, {'name': 'ZCash', 'price': 132}]
>>> heapq.nlargest(2, currency, key=lambda s: s['price'])
[{'name': 'Bitcoin', 'price': 45538}, {'name': 'Etherium', 'price': 3323}]
#std

Определяем наиболее часто встречающиеся элементы в последовательности.

Допустим, у нас есть некоторая последовательность из слов (words), и мы хотим узнать, какие элементы в ней встречаются чаще остальных.

Для этого можно использовать класс Counter из модуля collections в котором есть метод most_common(), который и выдаст список элементов, которые встречаются чаще остальных.

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

>>>counts['test']
2

Кстати, эта задача часто встречается на собеседованиях и просят её реализовать без модуля collections. Как бы вы её решили? Ответы можете писать в комментарии, обсудим.
#std

Ручной проход по списку

Задачка: нужно пройти по списку не используя цикл for.

Решение у этой задачи достаточно простое - можно использовать функцию next() и ловить исключение StopIteration. На скриншоте можно увидеть пример с использованием цикла while.

Здесь мы получаем итератор - это такой объект, который облегчает навигацию по коллекциям. Дальше в цикле вызываем next(), который получает следующий элемент и так до тех пор пока элементы не закончатся - индикатором этого будет вызов исключения StopIteration.
#std

Я заметил, что редко использую функции из itertools, в основном когда нужно произвести какие-то "красивые" шаманства. Теперь будем вспоминать саму библиотеку вместе, естественно с примерами :)
Сам модуль itertools это набор из эффективных и быстрых по памяти инструментов, возвращающие итераторы. Сами по себе итераторы можно комбинировать с такими функциями как map(), list() лямбдами или же использовать их с помощью цикла for.

А сегодня мы начнем c самых простых - c бесконечных итераторов. Всего по документации их три: count(), cycle() и repeat().
Ниже я буду указывать аргументы по умолчанию и возможные передаваемые типы как тайп-хинты. Надеюсь ни у кого не возникнет проблем с пониманием.

#itertools #std

count(start: int | float = 0, step: int | float = 1) -> Iterator[int | float]

Создает итератор, который возвращает равномерно распределенные значения, начиная с числа, указанного в аргументе start. Само значение-шаг указывается в переменной step:

>>> first = count(10, 2)
>>> next(first)
10
>>> next(first)
12
>>> next(first)
14
>>> second = count(0.1, 0.1)
>>> next(second)
0.1
>>> next(second)
0.2
>>> next(second)
0.30000000000000004
>>> next(second)
0.4

Небольшая загадка для вас - почему вместо 0.3 получили такое число? Пишите в комменты :)

#itertools #std

cycle(p: Iterable) -> Iterator

Создает итератор, который возвращает элементы из переданного итератора поштучно и сохраняет их. После того как элементы закончились, он начинает возвращать сохранённые элементы и так до тех пор, пока мы сами не прервем его работу:

>>> first = cycle([1, 2])
>>> next(first)
1
>>> next(first)
2
>>> next(first)
1
>>> next(first)
2

Например, вот так при помощи функций islice и cycle мы можем сгенерировать список из 20 элементов из необходимой нам коллекции:

>>> list(islice(cycle([1, 2, 3, 4]), None, 20))
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

#itertools #std

repeat(object: T, times: Optional[int] = None) -> Iterable[T]

Создает итератор который возвращает объект снова и снова. Можно указать параметр times, который вернет объект заданное количество раз и завершит работу итератора:

>>> first = repeat("hehe", 3)
>>> next(first)
'hehe'
>>> next(first)
'hehe'
>>> next(first)
'hehe'
>>> next(first)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Очень часто repeat используют чтобы по быстрому сгенерировать коллекцию из элементов:

>>> list(repeat(10, 10))
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]

#itertools #std

Создание временных файлов

В процессе написания скрипта может потребоваться создание временных файлов, которые будут удалены автоматически после завершения работы скрипта или обработки файла.
Это может быть полезно по разным причинам - при обработке больших данных (которые не вместятся в буфер) или при проведении сложных операций (например, можно создать временный файл и натравить на него ffmpeg).

Для решения этих проблем в Python есть модуль tempfile. Нас интересует 2 функции - это TemporaryFile и NamedTemporaryFile.

TemporaryFile позволяет создать безымянный временный файл. Вот так можно создать временный текстовой файл, открыть его на запись и чтение (за это отвечает первый аргумент "w+t", подробнее можно прочитать здесь):

from tempfile import TemporaryFile
with TemporaryFile("w+t") as t:
  t.write("Hello, boxwithpython!")
  t.seek(0)
  data = t.read()

NamedTemporaryFile используется для более продвинутых сценариев, так как он создает файл с именем, поэтому мы можем получить путь к нему и использовать его для дальнейших целей:

from tempfile import 

NamedTemporaryFile


with NamedTemporaryFile("w+t") as t:
  t.write("Hello, boxwithpython!")
  print(t.name) # /tmp/tmpljhsktjt

#std

Shielded execution в asyncio

Допустим, есть следующий обработчик, который производит оплату:

async def handler(request):
    await service.pay(request.user)
    return web.Response(text="payed")

Если соединение отвалится то обработчик упадет с ошибкой, так как серверу будет некуда отправлять ответ. Задача должна отмениться, но что если мы хотим, чтобы она выполнилась наверняка?

Поможет нам в этом asycio.shield(). Он защищает задачу от отмены, даже в случае возникновения ошибки. Выглядит это следующим образом:

async def handler(request):
    await asyncio.shield(service.pay(request.user))
    return web.Response(text="payed")

#asyncio #std

Про __slots__

Python, аналогично другим динамическим языкам, таким как JavaScript, предоставляет возможность манипулирования объектами в рантайме, в том числе позволяет добавлять, изменять и удалять атрибуты. Цена этого – понижение скорости доступа к атрибутам и дополнительные расходы памяти.

Такое поведение нужно не всегда. Бывают случаи, когда мы точно знаем, какие атрибуты будут у наших экземпляров классов. Или же мы хотим ограничить добавление новых атрибутов. Именно для этого и существует __slots__.

Слоты задаются через атрибут __slots__ в классе:

class SlotsClass:
    slots = ('foo', 'bar')

>>> obj = SlotsClass()
>>> obj.foo = 5
>>> obj.foo
# 5
>>> obj.another_attribute = 'test'
Traceback (most recent call last):
  File "python", line 5, in <module>
AttributeError: 'SlotsClass' object has no attribute 'another_attribute'

Теперь мы не можем добавлять новые атрибуты к нашим объектам. Скорость доступа к атрибутам повышается на 25-30%, потому что при доступе к ним их больше не надо вычислять.
В свою очередь, память экономится из-за того, что у класса не создается __dict__, который как раз хранил атрибуты.

#std #slots