Классы

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, в которой доступно определенное пространство имен. Здесь «доступно» означает, что неквалифицированная ссылка на имя пытается найти это имя в пространстве имен.

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

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

Если имя объявлено глобальным, все ссылки на него и присваивания ему обращаются непосредственно к предпоследней области видимости, содержащей глобальные имена модуля. Чтобы изменить привязку переменных, найденных вне самой внутренней области видимости, можно использовать инструкцию 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. Разное

Иногда бывает полезен тип данных, похожий на «запись» в Pascal или «структуру» в 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']

Сноски