Подборка @pythonetc, август 2019

Новая подборка советов про Python и программирование из моего авторского канала @pythonetc.

← Предыдущие подборки

Если у экземпляра класса нет атрибута с заданным именем, то он пытается обратиться к атрибуту класса с тем же именем.

>>> class A:
... x = 2
...
>>> A.x
2
>>> A().x
2

Экземпляр легко может иметь атрибут, которого нет у класса, или иметь атрибут с другим значением:

>>> class A:
... x = 2
... def __init__(self):
... self.x = 3
... self.y = 4
...
>>> A().x
3
>>> A.x
2
>>> A().y
4
>>> A.y
AttributeError: type object 'A' has no attribute 'y'

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

class ClassOnlyDescriptor: def __init__(self, value): self._value = value self._name = None # see __set_name__ def __get__(self, instance, owner): if instance is not None: raise AttributeError( f' has no attribute {self._name}' ) return self._value def __set_name__(self, owner, name): self._name = name class_only = ClassOnlyDescriptor class A: x = class_only(2) print(A.x) # 2
A().x # raises AttributeError


См. также, как работает Django-декоратор classonlymethod: https://github.com/django/django/blob/b709d701303b3877387020c1558a590713b09853/django/utils/decorators.py#L6

Функциям, объявленным в теле класса, область видимости этого класса недоступна. Это сделано потому, что эта область видимости существует только в ходе создания класса.

>>> class A:
... x = 2
... def f():
... print(x)
... f()
...
[...]
NameError: name 'x' is not defined

Обычно это не является проблемой: методы объявляются внутри класса только для того, чтобы стать методами и быть вызванными позднее:

>>> class A:
... x = 2
... def f(self):
... print(self.x)
...
>>>
>>>
>>> A().f()
2

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

>>> class A:
... x = 2
... y = [x for _ in range(5)]
...
[...]
NameError: name 'x' is not defined

Однако у comprehensions нет доступа к self. Единственный способ обеспечить доступ к

x

заключается в добавлении ещё одной области видимости (ага, дурацкое решение):

>>> class A:
... x = 2
... y = (lambda x=x: [x for _ in range(5)])()
...
>>> A.y
[2, 2, 2, 2, 2]


В Python None эквивалентно None, так что может показаться, что проверять на None можно с помощью ==:

ES_TAILS = ('s', 'x', 'z', 'ch', 'sh') def make_plural(word, exceptions=None): if exceptions == None: # ← ← ← exceptions = {} if word in exceptions: return exceptions[word] elif any(word.endswith(t) for t in ES_TAILS): return word + 'es' elif word.endswith('y'): return word[0:-1] + 'ies' else: return word + 's' exceptions = dict( mouse='mice',
) print(make_plural('python'))
print(make_plural('bash'))
print(make_plural('ruby'))
print(make_plural('mouse', exceptions=exceptions))


Но это будет ошибкой. Да, None равно None, но не только оно. Пользовательские объекты тоже могут быть равны None:

>>> class A:
... def __eq__(self, other):
... return True
...
>>> A() == None
True
>>> A() is None
False

Единственный правильный способ сравнения с None заключается в использовании is None.

Например, такое число можно получить с помощью math.nan. Числа с плавающей запятой в Python могут иметь значения NaN. nan не равно ничему, включая себя:

>>> math.nan == math.nan
False

Кроме того, NaN-объект не уникален, у вас может быть несколько разных NaN-объектов из разных источников:

>>> float('nan')
nan
>>> float('nan') is float('nan')
False

Это означает, что, в целом, вы не можете использовать NaN в качестве ключа словаря:

>>> d = {}
>>> d[float('nan')] = 1
>>> d[float('nan')] = 2
>>> d
{nan: 1, nan: 2}


typing позволяет определять типы для генераторов. Дополнительно можно указать, какой тип генерируется, какой передаётся генератору и какой возвращается с помощью

return

. Например, Generator[int, None, bool] генерирует целые числа, возвращает булевы и не поддерживает g.send().

chain_while проксирует данные от других генераторов до тех пор, пока один из них не вернёт значение, которое является сигналом остановки в соответствии с функцией condition: А вот пример посложнее.

from typing import Generator, Callable, Iterable, TypeVar Y = TypeVar('Y')
S = TypeVar('S')
R = TypeVar('R') def chain_while( iterables: Iterable[Generator[Y, S, R]], condition: Callable[[R], bool],
) -> Generator[Y, S, None]: for it in iterables: result = yield from it if not condition(result): break def r(x: int) -> Generator[int, None, bool]: yield from range(x) return x % 2 == 1 print(list(chain_while( [ r(5), r(4), r(3), ], lambda x: x is True,
)))


Задать аннотации для фабричного метода не так просто, как может показаться. Сразу хочется использовать нечто подобное:

class A: @classmethod def create(cls) -> 'A': return cls()

Но это будет неправильно. Хитрость в том, что create возвращает не A, он возвращает cls, который является A или одним из его потомков. Взгляните на код:

class A: @classmethod def create(cls) -> 'A': return cls() class B(A): @classmethod def create(cls) -> 'B': return super().create()

Результатом проверки mypy является ошибка error: Incompatible return value type (got "A", expected "B"). Повторюсь, проблема в том, что super().create() аннотирован как возвращающий A, хотя в этом случае он возвращает B.

Это можно исправить, если аннотировать cls с помощью TypeVar:

AType = TypeVar('AType')
BType = TypeVar('BType') class A: @classmethod def create(cls: Type[AType]) -> AType: return cls() class B(A): @classmethod def create(cls: Type[BType]) -> BType: return super().create()

Теперь create возвращает экземпляр класса cls. Однако эти аннотации слишком расплывчаты, мы потеряли информацию о том, что cls является подтипом A:

AType = TypeVar('AType') class A: DATA = 42 @classmethod def create(cls: Type[AType]) -> AType: print(cls.DATA) return cls()

Получаем ошибку "Type[AType]" has no attribute "DATA".

Для этого используется TypeVar с аргументом bound. Чтобы её исправить, нужно явно определить AType как подтип A.

AType = TypeVar('AType', bound='A')
BType = TypeVar('BType', bound='B') class A: DATA = 42 @classmethod def create(cls: Type[AType]) -> AType: print(cls.DATA) return cls() class B(A): @classmethod def create(cls: Type[BType]) -> BType: return super().create()