В Python оператор квадратных скобок [] можно переопределить, реализовав магический метод __getitem__. Это позволяет, например, создать объект, который виртуально содержит бесконечное количество повторяющихся элементов:

class Cycle:
    def __init__(self, lst):
        self._lst = lst

    def __getitem__(self, index):
        return self._lst[index % len(self._lst)]

print(Cycle(['a', 'b', 'c'])[100])  # 'b'

Необычность оператора [] в Python в том, что он поддерживает особый синтаксис. Его можно использовать не только так: [2], но и так: [2:10], [2:10:2], [2::2] или даже [:]. Смысл такой записи — [start:stop:step], но в ваших собственных объектах вы можете использовать этот синтаксис как угодно.

Что же передаётся в __getitem__ в таких случаях? Объекты slice созданы специально для этого.

Пример:

class Inspector:
    def __getitem__(self, index):
        print(index)

Inspector()[1]
# 1

Inspector()[1:2]
# slice(1, 2, None)

Inspector()[1:2:3]
# slice(1, 2, 3)

Inspector()[:]
# slice(None, None, None)

Inspector()[:, 0, :]
# (slice(None, None, None), 0, slice(None, None, None))

Объект slice сам по себе ничего не делает — он просто хранит атрибуты start, stop и step:

s = slice(1, 2, 3)
print(s.start)  # 1
print(s.stop)   # 2
print(s.step)   # 3

📲 Мы в MAX

👉@BookPython

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

Правильный способ сделать это — использовать конструкцию try с except Exception, а не голый except:

try:
    foreign()
except Exception:
    logging.warn('fail', exc_info=True)

Голый except эквивалентен except BaseException. А разница между BaseException и Exception в том, что BaseException включает исключения, которые, как правило, ловить не следует, например, KeyboardInterrupt.

📲 Мы в MAX

👉@BookPython

В Python имя переменной может состоять из одного символа подчёркивания: _. Хотя такие имена обычно недостаточно описательны и их не стоит использовать, существует по крайней мере три случая, когда _ имеет общепринятое значение.

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

>>> 2 + 2  
4  
>>> _  
4

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

В-третьих, _ используется, когда необходимо придумать имя для значения, которое не представляет интереса:

>>> log_entry = '10:50:24 14234 GET /api/v1/test'  
>>> time, _, method, location = log_entry.split()

📲 Мы в MAX

👉@BookPython

Есть три ситуации, в которых только что созданную переменную нельзя аннотировать типом: распаковка кортежей, циклы for и инструкции with.

Все эти примеры некорректны:

name: str, age: int = student

for x: int in numbers: 
    ...

with connection() as conn: Connection:
    ...

Правильный способ указать тип таких переменных — объявить их заранее, без инициализации:

conn: Connection
with connection() as conn:
    ...

📲 Мы в MAX

👉@BookPython

В Python сортировка по умолчанию является стабильной, то есть сохраняет порядок равных элементов:

a = [2, -1, 0, 1, -2]
sorted(a, key=lambda x: x**2)
# [0, -1, 1, 2, -2]

Функции max и min тоже стараются быть согласованными с поведением sorted.
max работает аналогично sorted(a, reverse=True)[0], а min — как sorted(a)[0].
Это означает, что обе функции возвращают самый левый возможный результат:

max([2, -2], key=lambda x: x**2)
# 2

max([-2, 2], key=lambda x: x**2)
# -2

min([2, -2], key=lambda x: x**2)
# 2

min([-2, 2], key=lambda x: x**2)
# -2

📲 Мы в MAX

👉@BookPython

Модуль collections предоставляет класс ChainMap, который позволяет использовать несколько отображений (словарей) как одно объединённое:

from collections import ChainMap

d = ChainMap(dict(a=1), dict(a=2, b=2))
d['a']  # 1
d['b']  # 2
d['c']  # ...
# KeyError: 'c'

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

d = ChainMap(dict(a=1), dict(a=2, b=2))
d['c'] = 3
d
# ChainMap({'a': 1, 'c': 3}, {'a': 2, 'b': 2})

📲 Мы в MAX

👉@BookPython

Некоторым генераторам нужно возвращать все элементы другого генератора:

>>> def enclose(gen, before='{', after='}'):
...     yield before
...     for x in gen:
...         yield x
...     yield after
...
>>> list(enclose(range(5)))
['{', 0, 1, 2, 3, 4, '}']

Однако предпочтительнее использовать yield from:

>>> def enclose(gen, before='{', after='}'):
...     yield before
...     yield from gen
...     yield after

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

📲 Мы в MAX

👉@BookPython

Python позволяет работать с путями файловой системы через модуль os.path. Модуль содержит множество функций, которые обрабатывают строки как пути и выполняют полезные операции, такие как объединение путей и прочее:

>>> import os.path
>>> os.path.join('/usr', 'local')
'/usr/local'
>>> os.path.dirname('/var/log')
'/var'

Однако, начиная с Python 3.4, доступен новый модуль pathlib, предлагающий объектно-ориентированный подход:

>>> from pathlib import Path
>>> Path('/usr') / Path('local')
PosixPath('/usr/local')
>>> Path('/usr') / 'local'
PosixPath('/usr/local')
>>> Path('/var/log').parent
PosixPath('/var')
>>> Path('/var/log').parent.name
'var'

📲 Мы в MAX

👉@BookPython

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

class A: pass
a = A()
a.x = 1
a.__dict__
# {'x': 1}

При прямом доступе к этому словарю можно даже создать атрибуты, которые не являются допустимыми идентификаторами Python (то есть получить их через стандартный синтаксис obj.attr не получится):

a.__dict__[' '] = ' '
getattr(a, ' ')
# ' '

Можно также попросить Python хранить атрибуты непосредственно в памяти (как у простых структур C) с помощью slots. Это экономит память и немного ускоряет доступ к атрибутам, так как не происходит поиска в словаре.

class Point:
    __slots__ = ['x', 'y']

Есть несколько моментов, которые нужно помнить при использовании slots. Во-первых, нельзя задавать атрибуты, не указанные в slots. Во-вторых, если класс наследуется от класса с slots, его slots не перекрывают родительские, а добавляются к ним:

class Parent: __slots__ = ['x']
class Child(Parent): __slots__ = ['y']
c = Child()
c.x = 1
c.y = 2

В-третьих, нельзя наследоваться сразу от двух разных классов с непустыми slots, даже если они совпадают.

Помни, что slots предназначены для оптимизации, а не для ограничения набора атрибутов.

📲 Мы в MAX

👉@BookPython

Если вы хотите перехватить и IndexError, и KeyError, вы можете и должны использовать LookupError — их общего предка. Это оказывается полезным при работе со сложными вложенными данными:

try:
    db_host = config['databases'][0]['hosts'][0]
except LookupError:
    db_host = 'localhost'

📲 Мы в MAX

👉@BookPython

Каждый класс Python имеет два «магических» атрибута, которые можно использовать для получения информации о его базовых классах.

Первый — __bases__; он возвращает непосредственных родителей класса:

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass


print(D.__bases__)
# (<class '__main__.B'>, <class '__main__.C'>)

Второй —```python

class B``` он возвращает кортеж со всеми классами, которые задействованы при разрешении методов (отсюда и название), то есть родителей, их родителей и так далее:

print(D.__mro__)
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

📲 Мы в MAX

👉@BookPython

В Python операторы += и + являются разными. За их поведение отвечают методы __iadd__ и __add__ соответственно.

class A:
    def __init__(self, x):
        self.x = x

    def __iadd__(self, another):
        self.x += another.x
        return self

    def __add__(self, another):
        return type(self)(self.x + another.x)

Если __iadd__ не определён, выражение a += b сводится к простому a = a + b.

Обычно разница между += и + в том, что первый изменяет объект, а второй создаёт новый:

>>> a = [1, 2, 3]
>>> b = a
>>> a += [4]
>>> a
[1, 2, 3, 4]
>>> b
[1, 2, 3, 4]
>>> a = a + [5]
>>> a
[1, 2, 3, 4, 5]
>>> b
[1, 2, 3, 4]

📲 Мы в MAX

👉@BookPython

В Python блок else может располагаться не только после if, но и после for и while. Код внутри else выполняется, если цикл не был прерван оператором break.

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

>>> first_odd = None
>>> for x in [2, 3, 4, 5]:
...     if x % 2 == 1:
...         first_odd = x
...         break
... else:
...     raise ValueError('В списке нет нечетных элементов')
...
>>> first_odd
3

>>> for x in [2, 4, 6]:
...     if x % 2 == 1:
...         first_odd = x
...         break
... else:
...     raise ValueError('В списке нет нечетных элементов')
...
...
ValueError: В списке нет нечетных элементов

📲 Мы в MAX

👉@BookPython

Начиная с Python 3.0, при возникновении нового исключения внутри блока except перехваченное исключение автоматически сохраняется в атрибуте __context__ создаваемого исключения. В результате при выводе будут показаны оба исключения:

try:
    1 / 0
except ZeroDivisionError:
    raise ValueError('Zero!')

(most recent call last):
  File "test.py", line 2, in <module>
    1 / 0
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "test.py", line 4, in <module>
    raise ValueError('Zero!')
ValueError: Zero!

Кроме того, вы можете явно указать причинное исключение, использовав конструкцию raise … from. Тогда в атрибут __cause__ нового исключения будет помещено исходное:

division_error = None

try:
    1 / 0
except ZeroDivisionError as e:
    division_error = e

raise ValueError('Zero!') from division_error

(most recent call last):
  File "test.py", line 4, in <module>
    1 / 0
ZeroDivisionError: division by zero

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "test.py", line 8, in <module>
    raise ValueError('Zero!') from division_error
ValueError: Zero!

📲 Мы в MAX

👉@BookPython

>>> bool(datetime(2018, 1, 1).time())
False
>>> bool(datetime(2018, 1, 1, 13, 12, 11).time())
True

До Python 3.5 объекты datetime.time() считались ложными, если они представляли полночь по UTC. Это могло приводить к трудноуловимым ошибкам. В следующих примерах if not может выполниться не потому, что created_time равен None, а потому, что время — полночь.

def create(created_time=None) -> None:
    if not created_time:
        created_time = datetime.now().time()

Можно исправить это, явно проверяя на None:

def create(created_time=None) -> None:
    if created_time is None:
        created_time = datetime.now().time()

📲 Мы в MAX

👉@BookPython

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

Для асинхронного выполнения кода в потоке следует использовать метод loop.run_in_executor.

Сторонний модуль aiofiles делает всё это за тебя, предоставляя простой и удобный интерфейс:

async with aiofiles.open('filename', mode='r') as f:
    contents = await f.read()

📲 Мы в MAX

👉@BookPython

Иногда нужно создать функцию на основе более универсальной.

Например, у функции int() есть параметр base, который мы хотим зафиксировать, чтобы получить новую функцию base2:

>>> int("10")
10
>>> int("10", 2)
2
>>> def base2(x):
...     return int(x, 2)
...
>>> base2("10")
2

functools.partial позволяет сделать то же самое, но точнее и семантически понятнее:

base2 = partial(int, base=2)

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

>>> map(partial(int, base=2), ["1", "10", "100"])
[1, 2, 4]

Без partial пришлось бы делать так:

>>> map(lambda x: int(x, base=2), ["1", "10", "100"])
[1, 2, 4]

📲 Мы в MAX

👉@BookPython

Существует две встроенные функции, которые позволяют анализировать итерируемые объекты без необходимости писать тривиальные и избыточные циклы for. Это all и any.

any возвращает True, если хотя бы одно значение истинно; all возвращает True, только если все значения истинны. Для пустого итерируемого объекта all возвращает True, а any — False.

Обе функции особенно полезны в сочетании со списковыми включениями (list comprehensions):

package_broken = any(
    part.is_broken() for part in package.get_parts()
)
package_ok = all(
    part.ok() for part in package.get_parts()
)

Функции any и all зачастую взаимозаменяемы благодаря законам де Моргана. Используй ту, с которой код будет понятнее.

📲 Мы в MAX

👉@BookPython