classes.md
1> **Источник:** https://python-all.ru/3.12/tutorial/classes.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 9. Классы89Классы предоставляют способ объединения данных и функциональности. Создание нового класса создаёт новый *тип* объекта, позволяя создавать новые *экземпляры* этого типа. Каждый экземпляр класса может иметь атрибуты для поддержания своего состояния. Экземпляры класса также могут иметь методы (определяемые его классом) для изменения этого состояния.1011По сравнению с другими языками программирования, механизм классов Python добавляет классы с минимумом нового синтаксиса и семантики. Это смесь механизмов классов, применяемых в C++ и Modula-3. Классы Python предоставляют все стандартные возможности объектно-ориентированного программирования: механизм наследования классов допускает множественные базовые классы, производный класс может переопределять любые методы своего базового класса или классов, и метод может вызывать метод базового класса с тем же именем. Объекты могут содержать произвольное количество и виды данных. Как и модули, классы обладают динамической природой Python: они создаются во время выполнения и могут быть изменены после создания.1213В терминологии C++ обычно члены класса (включая члены-данные) являются *открытыми* (за исключением случаев, рассмотренных ниже в разделе [Приватные переменные](https://python-all.ru/3.12/tutorial/classes.html#tut-private)), а все функции-члены являются *виртуальными*. Как и в Modula-3, нет сокращений для обращения к членам объекта из его методов: функция-метод объявляется с явным первым аргументом, представляющим объект, который неявно передаётся при вызове. Как и в Smalltalk, сами классы являются объектами. Это даёт семантику для импорта и переименования. В отличие от C++ и Modula-3, встроенные типы могут использоваться в качестве базовых классов для расширения пользователем. Также, как и в C++, большинство встроенных операторов со специальным синтаксисом (арифметические операторы, индексирование и т.д.) могут быть переопределены для экземпляров классов.1415(Из-за отсутствия общепринятой терминологии для описания классов, я буду иногда использовать термины Smalltalk и C++. Я бы использовал термины Modula-3, поскольку его объектно-ориентированная семантика ближе к Python, чем к C++, но, полагаю, немногие читатели слышали о нём.)1617## 9.1. Несколько слов об именах и объектах1819Объекты обладают индивидуальностью, и несколько имён (в разных областях видимости) могут быть связаны с одним и тем же объектом. В других языках это называется псевдонимизацией (aliasing). При первом знакомстве с Python на это обычно не обращают внимания, и это можно безопасно игнорировать при работе с неизменяемыми базовыми типами (числа, строки, кортежи). Однако псевдонимизация может неожиданно повлиять на семантику кода Python, использующего изменяемые объекты, такие как списки, словари и большинство других типов. Обычно это используется на пользу программе, поскольку псевдонимы в некоторых отношениях ведут себя как указатели. Например, передача объекта – дешёвая операция, так как реализация передаёт только указатель; и если функция изменяет объект, переданный как аргумент, вызывающий увидит изменения – это устраняет необходимость в двух разных механизмах передачи аргументов, как в Pascal.2021## 9.2. Области видимости и пространства имён Python2223Прежде чем ввести классы, я должен рассказать кое-что о правилах областей видимости в Python. Определения классов используют некоторые хитрости с пространствами имён, и нужно знать, как работают области видимости и пространства имён, чтобы полностью понимать происходящее. Кстати, знание этого предмета полезно любому продвинутому программисту на Python.2425Начнём с некоторых определений.2627*Пространство имён* – это отображение имён на объекты. Большинство пространств имён в настоящее время реализованы как словари Python, но это обычно никак не заметно (кроме производительности) и может измениться в будущем. Примеры пространств имён: множество встроенных имён (содержащее такие функции, как [`abs()`](https://python-all.ru/3.12/library/functions.html#abs), и имена встроенных исключений); глобальные имена в модуле; локальные имена в вызове функции. В некотором смысле набор атрибутов объекта также образует пространство имён. Важно знать, что между именами в разных пространствах имён нет абсолютно никакой связи; например, два разных модуля могут оба определять функцию `maximize` без путаницы – пользователи модулей должны указывать перед ней имя модуля.2829Кстати, я использую слово *атрибут* для любого имени, следующего за точкой – например, в выражении `z.real`, `real` является атрибутом объекта `z`. Строго говоря, ссылки на имена в модулях являются ссылками на атрибуты: в выражении `modname.funcname`, `modname` – это объект модуля, а `funcname` – его атрибут. В этом случае существует прямое соответствие между атрибутами модуля и глобальными именами, определёнными в модуле: они используют одно и то же пространство имён! [\[1\]](https://python-all.ru/3.12/tutorial/classes.html#id2)3031Атрибуты могут быть доступны только для чтения или для записи. В последнем случае возможно присваивание атрибутам. Атрибуты модуля доступны для записи: можно написать `modname.the_answer = 42`. Атрибуты, доступные для записи, также можно удалить с помощью оператора [`del`](https://python-all.ru/3.12/reference/simple_stmts.html#del). Например, `del modname.the_answer` удалит атрибут `the_answer` из объекта, обозначенного именем `modname`.3233Пространства имён создаются в разные моменты и имеют разное время жизни. Пространство имён, содержащее встроенные имена, создаётся при запуске интерпретатора Python и никогда не удаляется. Глобальное пространство имён для модуля создаётся при чтении определения модуля; обычно пространства имён модулей существуют до завершения интерпретатора. Операторы, выполняемые при верхнеуровневом вызове интерпретатора (из скрипта или в интерактивном режиме), считаются частью модуля с именем [`__main__`](https://python-all.ru/3.12/library/__main__.html#module-__main__), поэтому у них есть собственное глобальное пространство имён. (На самом деле встроенные имена также живут в модуле; он называется [`builtins`](https://python-all.ru/3.12/library/builtins.html#module-builtins).)3435Локальное пространство имён для функции создаётся при её вызове и удаляется, когда функция завершается или возбуждает исключение, не обработанное внутри функции. (На самом деле, «забывание» было бы лучшим способом описать происходящее.) Конечно, рекурсивные вызовы имеют собственные локальные пространства имён.3637*Область видимости* – это текстовая область программы на Python, в которой пространство имён доступно напрямую. «Напрямую доступно» означает, что неквалифицированная ссылка на имя пытается найти это имя в пространстве имён.3839Хотя области видимости определяются статически, они используются динамически. В любой момент выполнения существует 3 или 4 вложенные области видимости, чьи пространства имён доступны напрямую:4041- самая внутренняя область, которая просматривается первой, содержит локальные имена42- области видимости всех объемлющих функций, которые просматриваются начиная с ближайшей объемлющей области, содержат нелокальные, но также и неглобальные имена43- предпоследняя область содержит глобальные имена текущего модуля44- самая внешняя область (просматривается последней) – это пространство имён, содержащее встроенные имена4546Если имя объявлено глобальным, все ссылки и присваивания идут непосредственно в предпоследнюю область, содержащую глобальные имена модуля. Для повторного связывания переменных, найденных за пределами самой внутренней области, можно использовать оператор [`nonlocal`](https://python-all.ru/3.12/reference/simple_stmts.html#nonlocal); если не объявлено nonlocal, эти переменные доступны только для чтения (попытка записи в такую переменную просто создаст *новую* локальную переменную в самой внутренней области, оставив внешнюю переменную с тем же именем неизменённой).4748Обычно локальная область видимости ссылается на локальные имена (текстуально) текущей функции. Вне функций локальная область видимости ссылается на то же пространство имён, что и глобальная: пространство имён модуля. Определения классов помещают ещё одно пространство имён в локальную область.4950Важно понимать, что области видимости определяются текстуально: глобальная область функции, определённой в модуле, – это пространство имён этого модуля, независимо от того, откуда и под каким псевдонимом функция вызывается. С другой стороны, фактический поиск имён выполняется динамически, во время выполнения – однако определение языка развивается в сторону статического разрешения имён, во время «компиляции», так что не полагайтесь на динамическое разрешение имён! (На самом деле, локальные переменные уже определяются статически.)5152Особая особенность Python заключается в том, что – если не действуют операторы [`global`](https://python-all.ru/3.12/reference/simple_stmts.html#global) или [`nonlocal`](https://python-all.ru/3.12/reference/simple_stmts.html#nonlocal) – присваивания именам всегда попадают в самую внутреннюю область видимости. Присваивания не копируют данные – они просто связывают имена с объектами. То же верно для удалений: оператор `del x` удаляет привязку `x` из пространства имён, на которое ссылается локальная область. Фактически, все операции, вводящие новые имена, используют локальную область: в частности, операторы [`import`](https://python-all.ru/3.12/reference/simple_stmts.html#import) и определения функций связывают имя модуля или функции в локальной области.5354Оператор [`global`](https://python-all.ru/3.12/reference/simple_stmts.html#global) используется для указания, что определённые переменные живут в глобальной области и должны быть перепривязаны там; оператор [`nonlocal`](https://python-all.ru/3.12/reference/simple_stmts.html#nonlocal) указывает, что определённые переменные живут в объемлющей области и должны быть перепривязаны там.5556### 9.2.1. Пример областей видимости и пространств имён5758Это пример, демонстрирующий, как обращаться к различным областям видимости и пространствам имён, и как [`global`](https://python-all.ru/3.12/reference/simple_stmts.html#global) и [`nonlocal`](https://python-all.ru/3.12/reference/simple_stmts.html#nonlocal) влияют на связывание переменных:5960```python61def scope_test():62 def do_local():63 spam = "local spam"6465 def do_nonlocal():66 nonlocal spam67 spam = "nonlocal spam"6869 def do_global():70 global spam71 spam = "global spam"7273 spam = "test spam"74 do_local()75 print("After local assignment:", spam)76 do_nonlocal()77 print("After nonlocal assignment:", spam)78 do_global()79 print("After global assignment:", spam)8081scope_test()82print("In global scope:", spam)83```8485Вывод примера кода:8687```text88After local assignment: test spam89After nonlocal assignment: nonlocal spam90After global assignment: nonlocal spam91In global scope: global spam92```9394Обратите внимание, что присваивание *локальной* переменной (по умолчанию) не изменило привязку *spam* в *scope\_test*. Присваивание [`nonlocal`](https://python-all.ru/3.12/reference/simple_stmts.html#nonlocal) изменило привязку *spam* в *scope\_test*, а присваивание [`global`](https://python-all.ru/3.12/reference/simple_stmts.html#global) изменило привязку на уровне модуля.9596Также видно, что не было предыдущей привязки для *spam* до присваивания [`global`](https://python-all.ru/3.12/reference/simple_stmts.html#global).9798## 9.3. Первое знакомство с классами99100Классы вводят немного нового синтаксиса, три новых типа объектов и некоторую новую семантику.101102### 9.3.1. Синтаксис определения класса103104Простейшая форма определения класса выглядит так:105106```python107class ClassName:108 <statement-1>109 .110 .111 .112 <statement-N>113```114115Определения классов, как и определения функций (операторы [`def`](https://python-all.ru/3.12/reference/compound_stmts.html#def)), должны быть выполнены, чтобы возыметь действие. (Теоретически можно разместить определение класса в ветке оператора [`if`](https://python-all.ru/3.12/reference/compound_stmts.html#if) или внутри функции.)116117На практике операторы внутри определения класса обычно являются определениями функций, но допускаются и другие операторы, и иногда они полезны – мы вернёмся к этому позже. Определения функций внутри класса обычно имеют особую форму списка аргументов, продиктованную соглашениями о вызове методов – и это тоже объясняется позже.118119При входе в определение класса создаётся новое пространство имён, которое используется как локальная область видимости – таким образом, все присваивания локальным переменным попадают в это новое пространство имён. В частности, определения функций связывают имя новой функции здесь.120121Когда определение класса завершается нормально (через конец), создаётся *объект класса*. Это по сути обёртка вокруг содержимого пространства имён, созданного определением класса; мы узнаем больше об объектах класса в следующем разделе. Исходная локальная область видимости (действовавшая непосредственно перед входом в определение класса) восстанавливается, и объект класса связывается здесь с именем класса, указанным в заголовке определения класса (`ClassName` в примере).122123### 9.3.2. Объекты классов124125Объекты классов поддерживают два вида операций: обращение к атрибутам и создание экземпляров.126127*Обращение к атрибутам* использует стандартный синтаксис, принятый для всех обращений к атрибутам в Python: `obj.name`. Допустимыми именами атрибутов являются все имена, которые находились в пространстве имён класса на момент создания объекта класса. Итак, если определение класса выглядело так:128129```python130class MyClass:131 """Простой пример класса"""132 i = 12345133134 def f(self):135 return 'hello world'136```137138тогда `MyClass.i` и `MyClass.f` являются допустимыми обращениями к атрибутам, возвращающими целое число и объект функции соответственно. Атрибутам класса также можно присваивать, так что вы можете изменить значение `MyClass.i` присваиванием. [`__doc__`](https://python-all.ru/3.12/reference/datamodel.html#type.__doc__) также является допустимым атрибутом, возвращающим строку документации, принадлежащую классу: `"A simple example class"`.139140*Создание экземпляра* класса использует синтаксис вызова функции. Просто представьте, что объект класса – это функция без параметров, возвращающая новый экземпляр класса. Например (предполагая приведённый выше класс):141142```python143x = MyClass()144```145146создаёт новый *экземпляр* класса и присваивает этот объект локальной переменной `x`.147148Операция создания экземпляра («вызов» объекта класса) создаёт пустой объект. Многие классы предпочитают создавать объекты с экземплярами, настроенными на определённое начальное состояние. Поэтому класс может определить специальный метод с именем [`__init__()`](https://python-all.ru/3.12/reference/datamodel.html#object.__init__), например так:149150```python151def __init__(self):152 self.data = []153```154155Когда класс определяет метод [`__init__()`](https://python-all.ru/3.12/reference/datamodel.html#object.__init__), создание экземпляра класса автоматически вызывает `__init__()` для только что созданного экземпляра класса. Таким образом, в этом примере новый инициализированный экземпляр можно получить так:156157```python158x = MyClass()159```160161Конечно, метод [`__init__()`](https://python-all.ru/3.12/reference/datamodel.html#object.__init__) может иметь аргументы для большей гибкости. В этом случае аргументы, переданные оператору создания экземпляра класса, передаются `__init__()`. Например,162163```python164>>> class Complex:165... def __init__(self, realpart, imagpart):166... self.r = realpart167... self.i = imagpart168...169>>> x = Complex(3.0, -4.5)170>>> x.r, x.i171(3.0, -4.5)172```173174### 9.3.3. Объекты экземпляров175176Что можно делать с объектами экземпляров? Единственные операции, которые понимают объекты экземпляров, – это обращение к атрибутам. Существует два вида допустимых имён атрибутов: атрибуты-данные и методы.177178*Атрибуты данных* соответствуют «переменным экземпляра» в Smalltalk и «членам данных» в C++. Атрибуты данных не нужно объявлять; как и локальные переменные, они возникают при первом присваивании. Например, если `x` является экземпляром `MyClass`, созданным выше, следующий фрагмент кода выведет значение `16`, не оставив следа:179180```python181x.counter = 1182while x.counter < 10:183 x.counter = x.counter * 2184print(x.counter)185del x.counter186```187188Другой вид обращения к атрибуту экземпляра – это *метод*. Метод – это функция, которая «принадлежит» объекту.189190Допустимые имена методов объекта экземпляра зависят от его класса. По определению, все атрибуты класса, являющиеся объектами-функциями, определяют соответствующие методы его экземпляров. Так, в нашем примере `x.f` является допустимой ссылкой на метод, так как `MyClass.f` – функция, а `x.i` – нет, поскольку `MyClass.i` функцией не является. Но `x.f` – это не то же самое, что `MyClass.f`; это *объект метода*, а не объект функции.191192### 9.3.4. Объекты методов193194Обычно метод вызывается сразу после его связывания:195196```python197x.f()198```199200В примере `MyClass` это вернёт строку `'hello world'`. Однако необязательно вызывать метод сразу: `x.f` – это объект-метод, который можно сохранить и вызвать позже. Например:201202```python203xf = x.f204while True:205 print(xf())206```207208будет продолжать печатать `hello world` до бесконечности.209210Что именно происходит при вызове метода? Возможно, вы заметили, что `x.f()` был вызван без аргумента выше, хотя определение функции для `f()` указывало аргумент. Что случилось с аргументом? Разумеется, Python возбуждает исключение, когда функция, требующая аргумент, вызывается без него – даже если этот аргумент фактически не используется…211212На самом деле вы, возможно, догадались: особенность методов в том, что объект экземпляра передаётся как первый аргумент функции. В нашем примере вызов `x.f()` полностью эквивалентен `MyClass.f(x)`. В общем случае вызов метода со списком из *n* аргументов эквивалентен вызову соответствующей функции со списком аргументов, созданным путём вставки объекта экземпляра метода перед первым аргументом.213214В общем случае методы работают следующим образом. При обращении к не-данному атрибуту экземпляра выполняется поиск в классе экземпляра. Если имя обозначает допустимый атрибут класса, являющийся объектом-функцией, ссылки на объект экземпляра и объект функции упаковываются в объект метода. Когда объект метода вызывается со списком аргументов, из объекта экземпляра и списка аргументов строится новый список аргументов, и с ним вызывается объект функции.215216### 9.3.5. Переменные класса и экземпляра217218Вообще говоря, переменные экземпляра предназначены для данных, уникальных для каждого экземпляра, а переменные класса – для атрибутов и методов, общих для всех экземпляров класса:219220```python221class Dog:222223 kind = 'canine' # переменная класса, общая для всех экземпляров224225 def __init__(self, name):226 self.name = name # переменная экземпляра, уникальная для каждого экземпляра227228>>> d = Dog('Fido')229>>> e = Dog('Buddy')230>>> d.kind # общая для всех собак231'canine'232>>> e.kind # общая для всех собак233'canine'234>>> d.name # уникально для d235'Fido'236>>> e.name # уникально для e237'Buddy'238```239240Как обсуждалось в [Замечание об именах и объектах](https://python-all.ru/3.12/tutorial/classes.html#tut-object), совместно используемые данные могут иметь неожиданные последствия при работе с [изменяемыми](https://python-all.ru/3.12/glossary.html#term-mutable) объектами, такими как списки и словари. Например, список *tricks* в следующем коде не следует использовать как переменную класса, поскольку этот единственный список будет общим для всех *Dog* экземпляров:241242```python243class Dog:244245 tricks = [] # ошибочное использование переменной класса246247 def __init__(self, name):248 self.name = name249250 def add_trick(self, trick):251 self.tricks.append(trick)252253>>> d = Dog('Fido')254>>> e = Dog('Buddy')255>>> d.add_trick('roll over')256>>> e.add_trick('play dead')257>>> d.tricks # неожиданно общая для всех собак258['roll over', 'play dead']259```260261Правильное проектирование класса подразумевает использование переменной экземпляра:262263```python264class Dog:265266 def __init__(self, name):267 self.name = name268 self.tricks = [] # создаёт новый пустой список для каждой собаки269270 def add_trick(self, trick):271 self.tricks.append(trick)272273>>> d = Dog('Fido')274>>> e = Dog('Buddy')275>>> d.add_trick('roll over')276>>> e.add_trick('play dead')277>>> d.tricks278['roll over']279>>> e.tricks280['play dead']281```282283## 9.4. Разные замечания284285Если одно и то же имя атрибута встречается и в экземпляре, и в классе, то при поиске атрибута приоритет отдаётся экземпляру:286287```python288>>> class Warehouse:289... purpose = 'storage'290... region = 'west'291...292>>> w1 = Warehouse()293>>> print(w1.purpose, w1.region)294storage west295>>> w2 = Warehouse()296>>> w2.region = 'east'297>>> print(w2.purpose, w2.region)298storage east299```300301Атрибуты данных могут использоваться как методами, так и обычными пользователями («клиентами») объекта. Иными словами, классы не пригодны для реализации чистых абстрактных типов данных. На самом деле в Python нет возможности принудительно скрыть данные – всё строится на соглашениях. (С другой стороны, реализация Python, написанная на C, может полностью скрыть детали реализации и контролировать доступ к объекту, если это необходимо; эта возможность может использоваться расширениями Python, написанными на C.)302303Клиенты должны осторожно обращаться с атрибутами данных – они могут нарушить инварианты, поддерживаемые методами, если будут записывать свои значения в эти атрибуты. Обратите внимание, что клиенты могут добавлять собственные атрибуты данных к объекту экземпляра, не влияя на корректность методов, при условии отсутствия конфликтов имён – и снова соглашение об именах может избавить от многих проблем.304305Не существует краткой формы для обращения к атрибутам данных (или другим методам!) из методов. Я нахожу, что это на самом деле повышает читаемость методов: при беглом просмотре метода невозможно перепутать локальные переменные и переменные экземпляра.306307Часто первый аргумент метода называется `self`. Это не более чем соглашение: имя `self` не имеет для Python абсолютно никакого особого значения. Однако имейте в виду, что, не следуя этому соглашению, вы делаете свой код менее читаемым для других программистов Python; также возможно, что будет написана программа *обозреватель классов*, которая полагается на такое соглашение.308309Любой объект функции, являющийся атрибутом класса, определяет метод для экземпляров этого класса. Совершенно необязательно, чтобы определение функции было текстуально вложено в определение класса: можно также присвоить объект функции локальной переменной в классе. Пример:310311```python312# Функция, определённая вне класса313def f1(self, x, y):314 return min(x, x+y)315316class C:317 f = f1318319 def g(self):320 return 'hello world'321322 h = g323```324325Теперь `f`, `g` и `h` – все атрибуты класса `C`, которые ссылаются на объекты функций, и, следовательно, все они являются методами экземпляров `C` – `h` полностью эквивалентен `g`. Обратите внимание, что такая практика обычно только запутывает читателя программы.326327Методы могут вызывать другие методы, используя атрибуты метода аргумента `self`:328329```python330class Bag:331 def __init__(self):332 self.data = []333334 def add(self, x):335 self.data.append(x)336337 def addtwice(self, x):338 self.add(x)339 self.add(x)340```341342Методы могут ссылаться на глобальные имена так же, как обычные функции. Глобальная область видимости, связанная с методом, – это модуль, содержащий его определение. (Класс никогда не используется в качестве глобальной области видимости.) Хотя редко встречаются веские причины для использования глобальных данных в методе, существуют многие законные применения глобальной области видимости: например, функции и модули, импортированные в глобальную область видимости, могут использоваться методами, а также функции и классы, определённые в ней. Обычно класс, содержащий метод, сам определён в этой глобальной области видимости, и в следующем разделе мы найдём несколько хороших причин, по которым методу может понадобиться ссылаться на собственный класс.343344Каждое значение является объектом и поэтому имеет *класс* (также называемый его *типом*). Он хранится как `object.__class__`.345346## 9.5. Наследование347348Разумеется, языковая возможность не заслуживала бы названия «класс», если бы не поддерживала наследование. Синтаксис определения производного класса выглядит так:349350```python351class DerivedClassName(BaseClassName):352 <statement-1>353 .354 .355 .356 <statement-N>357```358359Имя `BaseClassName` должно быть определено в пространстве имён, доступном из области видимости, содержащей определение производного класса. Вместо имени базового класса допускаются также любые другие выражения. Это может быть полезно, например, когда базовый класс определён в другом модуле:360361```python362class DerivedClassName(modname.BaseClassName):363```364365Выполнение определения производного класса происходит так же, как и для базового класса. При создании объекта класса базовый класс запоминается. Это используется для разрешения ссылок на атрибуты: если запрашиваемый атрибут не найден в классе, поиск продолжается в базовом классе. Это правило применяется рекурсивно, если сам базовый класс является производным от какого-либо другого класса.366367В создании экземпляров производных классов нет ничего особенного: `DerivedClassName()` создаёт новый экземпляр класса. Ссылки на методы разрешаются следующим образом: выполняется поиск соответствующего атрибута класса, при необходимости спускаясь по цепочке базовых классов; ссылка на метод считается действительной, если результатом поиска является объект функции.368369Производные классы могут переопределять методы своих базовых классов. Поскольку методы не имеют особых привилегий при вызове других методов того же объекта, метод базового класса, который вызывает другой метод, определённый в том же базовом классе, может в итоге вызвать метод производного класса, переопределяющий его. (Для программистов на C++: все методы в Python по сути являются `virtual`.)370371Переопределяющий метод в производном классе может на самом деле захотеть расширить, а не просто заменить метод базового класса с тем же именем. Есть простой способ напрямую вызвать метод базового класса: просто вызовите `BaseClassName.methodname(self, arguments)`. Это иногда полезно и для клиентов. (Обратите внимание, что это работает только в том случае, если базовый класс доступен как `BaseClassName` в глобальной области видимости.)372373В Python есть две встроенные функции, работающие с наследованием:374375- Используйте [`isinstance()`](https://python-all.ru/3.12/library/functions.html#isinstance) для проверки типа экземпляра: `isinstance(obj, int)` будет `True` только если `obj.__class__` является [`int`](https://python-all.ru/3.12/library/functions.html#int) или какого-либо класса, производного от [`int`](https://python-all.ru/3.12/library/functions.html#int).376- Используйте [`issubclass()`](https://python-all.ru/3.12/library/functions.html#issubclass) для проверки наследования классов: `issubclass(bool, int)` является `True`, поскольку [`bool`](https://python-all.ru/3.12/library/functions.html#bool) является подклассом [`int`](https://python-all.ru/3.12/library/functions.html#int). Однако `issubclass(float, int)` является `False`, поскольку [`float`](https://python-all.ru/3.12/library/functions.html#float) не является подклассом [`int`](https://python-all.ru/3.12/library/functions.html#int).377378### 9.5.1. Множественное наследование379380Python также поддерживает форму множественного наследования. Определение класса с несколькими базовыми классами выглядит так:381382```python383class DerivedClassName(Base1, Base2, Base3):384 <statement-1>385 .386 .387 .388 <statement-N>389```390391В большинстве простых случаев можно представлять поиск атрибутов, наследуемых от родительского класса, как поиск в глубину слева направо без повторного поиска в одном и том же классе при пересечении иерархии. Таким образом, если атрибут не найден в `DerivedClassName`, он ищется в `Base1`, затем (рекурсивно) в базовых классах `Base1`, и если не найден там, то в `Base2`, и так далее.392393На самом деле всё немного сложнее: порядок разрешения методов (MRO) динамически изменяется для поддержки кооперативных вызовов [`super()`](https://python-all.ru/3.12/library/functions.html#super). Этот подход известен в некоторых других языках с множественным наследованием как call-next-method и является более мощным, чем вызов super в языках с одиночным наследованием.394395Динамическое упорядочивание необходимо, потому что все случаи множественного наследования содержат одно или несколько ромбовидных отношений (когда по крайней мере один из родительских классов может быть достигнут несколькими путями от самого нижнего класса). Например, все классы наследуют от [`object`](https://python-all.ru/3.12/library/functions.html#object), поэтому любой случай множественного наследования предоставляет более одного пути к [`object`](https://python-all.ru/3.12/library/functions.html#object). Чтобы базовые классы не обрабатывались более одного раза, динамический алгоритм линеаризует порядок поиска, сохраняя указанный в каждом классе порядок слева направо, вызывая каждый родительский класс только один раз, и является монотонным (то есть класс может быть унаследован без влияния на порядок приоритета его родителей). В совокупности эти свойства позволяют проектировать надёжные и расширяемые классы с множественным наследованием. За подробностями обратитесь к [The Python 2.3 Method Resolution Order](https://python-all.ru/3.12/howto/mro.html#python-2-3-mro).396397## 9.6. Приватные переменные398399«Приватных» переменных экземпляра, к которым нельзя обратиться иначе как изнутри объекта, в Python не существует. Однако существует соглашение, которому следует большая часть кода Python: имя с префиксом подчёркивания (например, `_spam`) следует рассматривать как непубличную часть API (будь то функция, метод или элемент данных). Его следует считать деталью реализации, которая может измениться без уведомления.400401Поскольку существует обоснованный вариант использования для закрытых членов класса (а именно, чтобы избежать коллизий имён с именами, определёнными в подклассах), для такого механизма предусмотрена ограниченная поддержка, называемая *искажением имён*. Любой идентификатор вида `__spam` (как минимум два начальных символа подчёркивания, не более одного конечного) текстуально заменяется на `_classname__spam`, где `classname` – это имя текущего класса с удалёнными начальными символами подчёркивания. Это искажение выполняется независимо от синтаксической позиции идентификатора, если он встречается в определении класса.402403> **См. также**404>405> См. [спецификации искажения приватных имён](https://python-all.ru/3.12/reference/expressions.html#private-name-mangling) с подробностями и особыми случаями.406407Искажение имён полезно для того, чтобы подклассы могли переопределять методы, не нарушая внутриклассовых вызовов методов. Например:408409```python410class Mapping:411 def __init__(self, iterable):412 self.items_list = []413 self.__update(iterable)414415 def update(self, iterable):416 for item in iterable:417 self.items_list.append(item)418419 __update = update # приватная копия исходного метода update()420421class MappingSubclass(Mapping):422423 def update(self, keys, values):424 # предоставляет новую сигнатуру для update()425 # но не нарушает __init__()426 for item in zip(keys, values):427 self.items_list.append(item)428```429430Приведённый выше пример будет работать, даже если `MappingSubclass` введёт идентификатор `__update`, поскольку он заменяется на `_Mapping__update` в классе `Mapping` и на `_MappingSubclass__update` в классе `MappingSubclass` соответственно.431432Обратите внимание, что правила искажения в основном предназначены для предотвращения случайностей; по-прежнему можно получить доступ к переменной, считающейся закрытой, или изменить её. Это может быть даже полезно в особых обстоятельствах, например, в отладчике.433434Обратите внимание, что код, переданный в `exec()` или `eval()`, не считает имя класса вызывающего класса текущим классом; это похоже на эффект оператора `global`, действие которого также ограничено кодом, скомпилированным вместе. То же ограничение применяется к `getattr()`, `setattr()` и `delattr()`, а также при прямом обращении к `__dict__`.435436## 9.7. Разное437438Иногда полезно иметь тип данных, похожий на запись (record) в Pascal или структуру (struct) в C, объединяющий несколько именованных элементов данных. Идиоматический подход – использовать для этого [`dataclasses`](https://python-all.ru/3.12/library/dataclasses.html#module-dataclasses):439440```python441from dataclasses import dataclass442443@dataclass444class Employee:445 name: str446 dept: str447 salary: int448```449450```python451>>> john = Employee('john', 'computer lab', 1000)452>>> john.dept453'computer lab'454>>> john.salary4551000456```457458Фрагмент кода Python, ожидающий определённый абстрактный тип данных, часто может получить вместо него класс, эмулирующий методы этого типа данных. Например, если есть функция, форматирующая данные из файлового объекта, можно определить класс с методами [`read()`](https://python-all.ru/3.12/library/io.html#io.TextIOBase.read) и [`readline()`](https://python-all.ru/3.12/library/io.html#io.TextIOBase.readline), которые получают данные из строкового буфера, и передать его как аргумент.459460У [объектов методов экземпляра](https://python-all.ru/3.12/reference/datamodel.html#instance-methods) тоже есть атрибуты: [`m.__self__`](https://python-all.ru/3.12/reference/datamodel.html#method.__self__) – это объект экземпляра с методом `m()`, а [`m.__func__`](https://python-all.ru/3.12/reference/datamodel.html#method.__func__) – это [объект функции](https://python-all.ru/3.12/reference/datamodel.html#user-defined-funcs), соответствующий методу.461462## 9.8. Итераторы463464К настоящему моменту вы, вероятно, заметили, что большинство объектов-контейнеров можно перебирать с помощью оператора [`for`](https://python-all.ru/3.12/reference/compound_stmts.html#for):465466```python467for element in [1, 2, 3]:468 print(element)469for element in (1, 2, 3):470 print(element)471for key in {'one':1, 'two':2}:472 print(key)473for char in "123":474 print(char)475for line in open("myfile.txt"):476 print(line, end='')477```478479Такой стиль доступа ясен, краток и удобен. Использование итераторов пронизывает Python и объединяет его. За кулисами оператор [`for`](https://python-all.ru/3.12/reference/compound_stmts.html#for) вызывает [`iter()`](https://python-all.ru/3.12/library/functions.html#iter) у объекта-контейнера. Функция возвращает объект-итератор, который определяет метод [`__next__()`](https://python-all.ru/3.12/library/stdtypes.html#iterator.__next__), обращающийся к элементам контейнера по одному. Когда элементов больше нет, [`__next__()`](https://python-all.ru/3.12/library/stdtypes.html#iterator.__next__) возбуждает исключение [`StopIteration`](https://python-all.ru/3.12/library/exceptions.html#StopIteration), которое говорит циклу `for` завершиться. Вызвать метод [`__next__()`](https://python-all.ru/3.12/library/stdtypes.html#iterator.__next__) можно с помощью встроенной функции [`next()`](https://python-all.ru/3.12/library/functions.html#next); этот пример показывает, как всё это работает:480481```python482>>> s = 'abc'483>>> it = iter(s)484>>> it485<str_iterator object at 0x10c90e650>486>>> next(it)487'a'488>>> next(it)489'b'490>>> next(it)491'c'492>>> next(it)493Traceback (most recent call last):494 File "<stdin>", line 1, in <module>495 next(it)496StopIteration497```498499Увидев механику протокола итератора, легко добавить поведение итератора в свои классы. Определите метод [`__iter__()`](https://python-all.ru/3.12/library/stdtypes.html#container.__iter__), который возвращает объект с методом [`__next__()`](https://python-all.ru/3.12/library/stdtypes.html#iterator.__next__). Если класс определяет `__next__()`, то `__iter__()` может просто вернуть `self`:500501```python502class Reverse:503 """Итератор для перебора последовательности в обратном порядке."""504 def __init__(self, data):505 self.data = data506 self.index = len(data)507508 def __iter__(self):509 return self510511 def __next__(self):512 if self.index == 0:513 raise StopIteration514 self.index = self.index - 1515 return self.data[self.index]516```517518```python519>>> rev = Reverse('spam')520>>> iter(rev)521<__main__.Reverse object at 0x00A1DB50>522>>> for char in rev:523... print(char)524...525m526a527p528s529```530531## 9.9. Генераторы532533[Генераторы](https://python-all.ru/3.12/glossary.html#term-generator) – это простой и мощный инструмент для создания итераторов. Они пишутся как обычные функции, но используют оператор [`yield`](https://python-all.ru/3.12/reference/simple_stmts.html#yield) всякий раз, когда нужно вернуть данные. Каждый раз при вызове [`next()`](https://python-all.ru/3.12/library/functions.html#next) генератор возобновляет работу с того места, где остановился (он запоминает все значения данных и то, какой оператор был выполнен последним). Пример показывает, что создавать генераторы может быть тривиально просто:534535```python536def reverse(data):537 for index in range(len(data)-1, -1, -1):538 yield data[index]539```540541```python542>>> for char in reverse('golf'):543... print(char)544...545f546l547o548g549```550551Всё, что можно сделать с генераторами, можно сделать и с итераторами на основе классов, как описано в предыдущем разделе. Что делает генераторы такими компактными – это то, что методы [`__iter__()`](https://python-all.ru/3.12/library/stdtypes.html#iterator.__iter__) и [`__next__()`](https://python-all.ru/3.12/reference/expressions.html#generator.__next__) создаются автоматически.552553Ещё одна ключевая особенность: локальные переменные и состояние выполнения автоматически сохраняются между вызовами. Это делает функцию проще для написания и гораздо понятнее, чем подход с использованием переменных экземпляра, таких как `self.index` и `self.data`.554555В дополнение к автоматическому созданию методов и сохранению состояния программы, при завершении генераторы автоматически возбуждают [`StopIteration`](https://python-all.ru/3.12/library/exceptions.html#StopIteration). В совокупности эти возможности позволяют легко создавать итераторы, не прилагая больше усилий, чем при написании обычной функции.556557## 9.10. Генераторные выражения558559Некоторые простые генераторы можно кратко записать в виде выражений, используя синтаксис, похожий на списочные включения, но с круглыми скобками вместо квадратных. Эти выражения предназначены для ситуаций, когда генератор сразу используется обрамляющей функцией. Генераторные выражения более компактны, но менее универсальны, чем полные определения генераторов, и, как правило, более дружественны к памяти, чем эквивалентные списочные включения.560561Примеры:562563```python564>>> sum(i*i for i in range(10)) # сумма квадратов565285566567>>> xvec = [10, 20, 30]568>>> yvec = [7, 5, 3]569>>> sum(x*y for x,y in zip(xvec, yvec)) # скалярное произведение570260571572>>> unique_words = set(word for line in page for word in line.split())573574>>> valedictorian = max((student.gpa, student.name) for student in graduates)575576>>> data = 'golf'577>>> list(data[i] for i in range(len(data)-1, -1, -1))578['f', 'l', 'o', 'g']579```580581Сноски582583\[[1](https://python-all.ru/3.12/tutorial/classes.html#id1)\]584585За исключением одного. Объекты модулей имеют секретный атрибут только для чтения [`__dict__`](https://python-all.ru/3.12/reference/datamodel.html#object.__dict__), который возвращает словарь, используемый для реализации пространства имён модуля; имя `__dict__` является атрибутом, но не глобальным именем. Очевидно, что использование этого нарушает абстракцию реализации пространства имён, и должно быть ограничено такими вещами, как посмертные отладчики.586