Классы

9.1. Несколько слов об именах и объектах

Объекты обладают индивидуальностью, и несколько имен (в разных областях видимости) могут быть связаны с одним и тем же объектом. В других языках это называется псевдонимами. При первом знакомстве с Python этому обычно не придают значения, и об этом можно не беспокоиться при работе с неизменяемыми базовыми типами (числами, строками, кортежами). Однако псевдонимы могут неожиданно повлиять на семантику кода Python, работающего с изменяемыми объектами, такими как списки, словари и большинство других типов. Обычно это идет программе на пользу, поскольку псевдонимы в некоторых отношениях ведут себя как указатели. Например, передача объекта обходится дешево, поскольку реализация передает только указатель; а если функция изменяет объект, переданный в качестве аргумента, вызывающий код увидит это изменение — благодаря этому не нужны два разных механизма передачи аргументов, как в Pascal.

9.2. Области видимости и пространства имен Python

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

Начнем с нескольких определений.

Пространство имен — это соответствие между именами и объектами. В настоящее время большинство пространств имен реализовано в виде словарей Python, но обычно это никак не заметно (кроме влияния на производительность), и в будущем реализация может измениться. Примеры пространств имен: набор встроенных имен (содержащий такие функции, как abs(), и имена встроенных исключений); глобальные имена в модуле; локальные имена при вызове функции. В некотором смысле набор атрибутов объекта также образует пространство имен. Важно знать, что между именами в разных пространствах имен нет абсолютно никакой связи; например, два разных модуля могут определить функцию maximize, и это не вызовет путаницы — пользователи модулей должны указывать перед ней имя модуля.

Кстати, словом атрибут я называю любое имя, стоящее после точки: например, в выражении z.real, real — это атрибут объекта z. Строго говоря, обращения к именам в модулях являются обращениями к атрибутам: в выражении modname.funcname, modname — это объект модуля, а funcname — его атрибут. В данном случае атрибуты модуля напрямую соответствуют глобальным именам, определенным в модуле: они используют одно и то же пространство имен! [1]

Атрибуты могут быть доступны только для чтения или для записи. Во втором случае атрибутам можно присваивать значения. Атрибуты модулей доступны для записи: можно написать modname.the_answer = 42. Атрибуты, доступные для записи, можно также удалять с помощью инструкции del. Например, del modname.the_answer удалит атрибут the_answer у объекта, заданного именем modname.

Пространства имен создаются в разные моменты и имеют разное время жизни. Пространство имен, содержащее встроенные имена, создается при запуске интерпретатора Python и никогда не удаляется. Глобальное пространство имен модуля создается при чтении определения модуля; обычно пространства имен модулей существуют до завершения работы интерпретатора. Инструкции, выполняемые при запуске интерпретатора верхнего уровня, будь то из файла сценария или в интерактивном режиме, считаются частью модуля с именем __main__, поэтому у них есть собственное глобальное пространство имен. (Встроенные имена тоже находятся в модуле; он называется builtins.)

Локальное пространство имен функции создается при вызове функции и удаляется, когда функция возвращает значение или вызывает исключение, не обработанное внутри нее. (На самом деле правильнее сказать, что оно забывается.) Разумеется, при каждом рекурсивном вызове создается отдельное локальное пространство имен.

Область видимости — это текстовая область программы Python, в которой пространство имен доступно напрямую. «Доступно напрямую» означает, что при обращении к имени без уточнений выполняется поиск этого имени в пространстве имен.

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

• самая внутренняя область видимости, в которой поиск выполняется первым делом, содержит локальные имена
• области видимости охватывающих функций, поиск в которых начинается с ближайшей внешней области видимости, содержат нелокальные, но также и неглобальные имена
• предпоследняя область видимости содержит глобальные имена текущего модуля
• самая внешняя область видимости (в ней поиск выполняется последним делом) — это пространство имен со встроенными именами

Если имя объявлено глобальным, все обращения и присваивания выполняются непосредственно в предпоследней области видимости, содержащей глобальные имена модуля. Чтобы повторно связать переменные, найденные вне самой внутренней области видимости, можно использовать инструкцию nonlocal; если переменная не объявлена нелокальной, она доступна только для чтения (попытка записать в такую переменную просто создаст новую локальную переменную во внутренней области видимости, не затрагивая внешнюю переменную с тем же именем).

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

Важно понимать, что области видимости определяются текстом программы: глобальная область видимости функции, определенной в модуле, — это пространство имен этого модуля, независимо от того, откуда и под каким псевдонимом вызывается функция. С другой стороны, фактический поиск имен выполняется динамически, во время выполнения, однако определение языка движется в сторону статического разрешения имен на этапе «компиляции», поэтому не полагайтесь на динамическое разрешение имен! (На самом деле локальные переменные уже определяются статически.)

Особенность Python заключается в том, что — если не действует инструкция global или nonlocal — присваивания именам всегда выполняются во внутренней области видимости. При присваивании данные не копируются — имена просто связываются с объектами. То же верно для удаления: инструкция del x удаляет привязку x из пространства имен, на которое ссылается локальная область видимости. Вообще, все операции, вводящие новые имена, используют локальную область видимости: в частности, инструкции import и определения функций связывают имя модуля или функции в локальной области видимости.

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

def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

9.3. Первое знакомство с классами

Классы вводят немного нового синтаксиса, три новых типа объектов и несколько новых правил.

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

x = MyClass()

def __init__(self):
    self.data = []

x = MyClass()

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

x.counter = 1
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter)
del x.counter

x.f()

xf = x.f
while True:
    print(xf())

class Dog:

    kind = 'canine'         # class variable shared by all instances

    def __init__(self, name):
        self.name = name    # instance variable unique to each instance

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # shared by all dogs
'canine'
>>> e.kind                  # shared by all dogs
'canine'
>>> d.name                  # unique to d
'Fido'
>>> e.name                  # unique to e
'Buddy'

class Dog:

    tricks = []             # mistaken use of a class variable

    def __init__(self, name):
        self.name = name

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks                # unexpectedly shared by all dogs
['roll over', 'play dead']

class Dog:

    def __init__(self, name):
        self.name = name
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']

9.4. Разные замечания

Если одно и то же имя атрибута встречается и в экземпляре, и в классе, при поиске атрибута приоритет отдается экземпляру:

>>> class Warehouse:
...    purpose = 'storage'
...    region = 'west'
...
>>> w1 = Warehouse()
>>> print(w1.purpose, w1.region)
storage west
>>> w2 = Warehouse()
>>> w2.region = 'east'
>>> print(w2.purpose, w2.region)
storage east

К атрибутам данных могут обращаться как методы, так и обычные пользователи («клиенты») объекта. Другими словами, классы нельзя использовать для реализации чистых абстрактных типов данных. В действительности в Python ничего не позволяет обеспечить сокрытие данных — все основано на соглашениях. (С другой стороны, реализация Python на языке C может полностью скрыть детали реализации и при необходимости контролировать доступ к объекту; это могут использовать расширения Python, написанные на C.)

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

Для обращения к атрибутам данных (или другим методам!) изнутри методов сокращенного синтаксиса нет. На мой взгляд, это на самом деле повышает читаемость методов: при просмотре метода невозможно перепутать локальные переменные и переменные экземпляра.

Часто первый аргумент метода называют self. Это всего лишь соглашение: имя self не имеет для Python абсолютно никакого особого значения. Однако учтите, что несоблюдение этого соглашения может затруднить чтение вашего кода другим программистам на Python; кроме того, вполне возможно, что появится программа просмотра классов, полагающаяся на такое соглашение.

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

# Function defined outside the class
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1

    def g(self):
        return 'hello world'

    h = g

Теперь f, g и h — это атрибуты класса C, ссылающиеся на объекты функций, а значит, все они являются методами экземпляров C; h полностью эквивалентен g. Обратите внимание, что такая практика обычно только сбивает читателя программы с толку.

Методы могут вызывать другие методы, обращаясь к атрибутам-методам аргумента self:

class Bag:
    def __init__(self):
        self.data = []

    def add(self, x):
        self.data.append(x)

    def addtwice(self, x):
        self.add(x)
        self.add(x)

Методы могут обращаться к глобальным именам так же, как обычные функции. Глобальная область видимости, связанная с методом, — это модуль, в котором он определен. (Класс никогда не используется в качестве глобальной области видимости.) Хотя причины использовать глобальные данные в методе встречаются редко, для глобальной области видимости есть много других законных применений: например, методы могут использовать функции и модули, импортированные в глобальную область видимости, а также определенные в ней функции и классы. Обычно класс, содержащий метод, сам определен в этой глобальной области видимости, и в следующем разделе мы рассмотрим несколько веских причин, по которым методу может понадобиться обращаться к собственному классу.

Каждое значение является объектом и, следовательно, имеет класс (также называемый типом). Он хранится в object.__class__.

9.5. Наследование

Разумеется, языковой механизм не заслуживал бы названия «класс», если бы не поддерживал наследование. Синтаксис определения производного класса выглядит так:

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

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

class DerivedClassName(modname.BaseClassName):

Определение производного класса выполняется так же, как определение базового класса. При создании объекта класса запоминается базовый класс. Это используется при поиске атрибутов: если запрошенный атрибут не найден в классе, поиск продолжается в базовом классе. Если сам базовый класс является производным от другого класса, это правило применяется рекурсивно.

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

Производные классы могут переопределять методы своих базовых классов. Поскольку при вызове других методов того же объекта методы не обладают особыми привилегиями, метод базового класса, вызывающий другой метод, определенный в том же базовом классе, может в итоге вызвать переопределяющий его метод производного класса. (Для программистов на C++: в Python все методы фактически являются virtual.)

Переопределяющий метод производного класса может захотеть не просто заменить одноименный метод базового класса, а расширить его поведение. Есть простой способ напрямую вызвать метод базового класса: просто вызовите BaseClassName.methodname(self, arguments). Иногда это бывает полезно и клиентам. (Обратите внимание, что это работает, только если базовый класс доступен как BaseClassName в глобальной области видимости.)

В Python есть две встроенные функции для работы с наследованием:

• Используйте isinstance(), чтобы проверить тип экземпляра: isinstance(obj, int) будет иметь значение True, только если obj.__class__ — это int или класс, производный от int.
• Используйте issubclass(), чтобы проверить наследование классов: issubclass(bool, int) имеет значение True, поскольку bool является подклассом int. Однако issubclass(float, int) имеет значение False, поскольку float не является подклассом int.

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

9.6. Приватные переменные

В Python не существует «приватных» переменных экземпляра, доступ к которым возможен только изнутри объекта. Однако в большинстве программ на Python принято считать, что имя с подчёркиванием в начале (например, _spam) обозначает непубличную часть API (будь то функция, метод или элемент данных). Такое имя следует считать деталью реализации, которая может измениться без предупреждения.

Поскольку у закрытых членов класса есть практическое применение (а именно — предотвращение конфликтов имён с именами, определёнными в подклассах), для такого механизма, называемого искажением имён, предусмотрена ограниченная поддержка. Любой идентификатор вида __spam (не менее двух подчёркиваний в начале и не более одного в конце) текстуально заменяется на _classname__spam, где classname — это имя текущего класса без начальных подчёркиваний. Такое искажение выполняется независимо от синтаксической позиции идентификатора, если он встречается в определении класса.

Искажение имён полезно, если требуется разрешить подклассам переопределять методы, не нарушая вызовы методов внутри класса. Например:

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)

    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)

    __update = update   # private copy of original update() method

class MappingSubclass(Mapping):

    def update(self, keys, values):
        # provides new signature for update()
        # but does not break __init__()
        for item in zip(keys, values):
            self.items_list.append(item)

Приведённый выше пример работал бы, даже если бы MappingSubclass ввёл идентификатор __update, поскольку в классе Mapping он заменяется на _Mapping__update, а в классе MappingSubclass — на _MappingSubclass__update.

Обратите внимание: правила искажения предназначены главным образом для предотвращения случайных конфликтов; получить доступ к переменной, считающейся приватной, или изменить её по-прежнему возможно. Это может быть полезно в особых случаях, например при отладке.

Обратите внимание: код, переданный в exec() или eval(), не считает имя класса вызывающего кода текущим классом; это похоже на действие оператора global, область действия которого также ограничена кодом, скомпилированным в байт-код совместно. То же ограничение применяется к getattr(), setattr() и delattr(), а также при прямом обращении к __dict__.

9.7. Разное

Иногда бывает полезен тип данных, похожий на паскалевскую «запись» или структуру C, объединяющий несколько именованных элементов данных. Идиоматичный способ сделать это — использовать dataclasses:

from dataclasses import dataclass

@dataclass
class Employee:
    name: str
    dept: str
    salary: int

>>> john = Employee('john', 'computer lab', 1000)
>>> john.dept
'computer lab'
>>> john.salary
1000

Коду на Python, ожидающему определённый абстрактный тип данных, часто можно передать вместо него класс, имитирующий методы этого типа. Например, если у вас есть функция, форматирующая данные из файлового объекта, можно определить класс с методами read() и readline(), которые получают данные из строкового буфера, и передать этот класс в качестве аргумента.

У объектов методов экземпляра тоже есть атрибуты: m.__self__ — это объект экземпляра, которому принадлежит метод m(), а m.__func__ — это соответствующий методу объект функции.

9.8. Итераторы

Вы, вероятно, уже заметили, что большинство контейнерных объектов можно перебирать с помощью оператора for:

for element in [1, 2, 3]:
    print(element)
for element in (1, 2, 3):
    print(element)
for key in {'one':1, 'two':2}:
    print(key)
for char in "123":
    print(char)
for line in open("myfile.txt"):
    print(line, end='')

Такой способ доступа понятен, краток и удобен. Использование итераторов пронизывает и объединяет Python. За кулисами оператор for вызывает для объекта-контейнера функцию iter(). Эта функция возвращает объект-итератор, который определяет метод __next__() для последовательного доступа к элементам контейнера. Когда элементы заканчиваются, __next__() вызывает исключение StopIteration, сообщая циклу for о необходимости завершиться. Вызвать метод __next__() можно с помощью встроенной функции next(); этот пример показывает, как всё работает:

>>> s = 'abc'
>>> it = iter(s)
>>> it
<str_iterator object at 0x10c90e650>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    next(it)
StopIteration

Теперь, когда вам известен принцип работы протокола итератора, добавить поведение итератора в свои классы несложно. Определите метод __iter__(), который возвращает объект с методом __next__(). Если класс определяет __next__(), то __iter__() может просто возвращать self:

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

>>> rev = Reverse('spam')
>>> iter(rev)
<__main__.Reverse object at 0x00A1DB50>
>>> for char in rev:
...     print(char)
...
m
a
p
s

9.9. Генераторы

Генераторы — простой и мощный инструмент для создания итераторов. Они записываются как обычные функции, но используют оператор yield, когда нужно вернуть данные. Каждый раз при вызове для генератора функции next() он продолжает работу с того места, на котором остановился (сохраняя все значения данных и информацию о последнем выполненном операторе). Пример показывает, что создавать генераторы очень просто:

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

>>> for char in reverse('golf'):
...     print(char)
...
f
l
o
g

Всё, что можно сделать с помощью генераторов, можно также реализовать с помощью итераторов на основе классов, описанных в предыдущем разделе. Генераторы настолько компактны благодаря тому, что методы __iter__() и __next__() создаются автоматически.

Ещё одна важная особенность состоит в том, что локальные переменные и состояние выполнения автоматически сохраняются между вызовами. Благодаря этому функцию проще написать, и она гораздо понятнее, чем вариант с переменными экземпляра, например self.index и self.data.

Помимо автоматического создания методов и сохранения состояния программы, при завершении генераторы автоматически вызывают исключение StopIteration. В совокупности эти возможности позволяют создавать итераторы не сложнее, чем обычные функции.

9.10. Генераторные выражения

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

Примеры:

>>> sum(i*i for i in range(10))                 # sum of squares
285

>>> xvec = [10, 20, 30]
>>> yvec = [7, 5, 3]
>>> sum(x*y for x,y in zip(xvec, yvec))         # dot product
260

>>> unique_words = set(word for line in page  for word in line.split())

>>> valedictorian = max((student.gpa, student.name) for student in graduates)

>>> data = 'golf'
>>> list(data[i] for i in range(len(data)-1, -1, -1))
['f', 'l', 'o', 'g']

Сноски