Как сделать класс приватным python
Классы предоставляют средство объединения данных и функциональных возможностей. Созданный новый класс создаёт новый тип объекта, допускающий новые экземпляры этого типа, которые требуется создать. К каждому экземпляру класса могут прикрепляться атрибуты для поддержания его состояния. Сущности класса также могут содержать методы (определяемые этим классом) для изменения его состояния.
По сравнению с другими языками программирования механизм классов Python’а добавляет классы с минимумом нового синтаксиса и семантики. Это смесь классовых механизмов, заимствованных из C++ и Modula-3. Классы Python предоставляют все стандартные возможности объектно-ориентированного программирования: механизм наследования классов поддерживает несколько предков для класса, производный класс может переопределять любые методы своего предка или предков, а любой его метод может вызвать метод предка с таким же именем. Объекты могут содержать произвольное количество и типов данных. Также как и модули, классы участвуют в динамической природе Python: они создаются во время выполнения, и могут изменены в дальнейшем после создания.
В терминологии C++, члены класса (включая данные-члены), обычно, открыты (public) (исключая Приватные переменные , описанные ниже), и все функции членов: виртуальны. Как в Modula-3, нет краткой ссылки на члены объекта из его методов: функция-метод определяется с явным первым аргументом, описывающим объект, который неявно передаётся при вызове. Как в Smalltalk, классы сами по себе являются объектами. Таким образом обеспечивается семантика для импортирования и переименования. В отличие от C++ и Modula-3 встроенные типы могут использоваться в качестве предков для расширения возможностей пользователем. Кроме того, как в C++, но не как в Modula-3, большинство встроенных операторов со специальным синтаксисом (арифметические операторы, индексирование и т. д.) могут переопределяться для экземпляров классов.
9.1. Пара слов о терминологии¶
Объекты обладают индивидуальностью, и с одним объектом может быть связано несколько имён (в нескольких областях видимости). Такая практика в других языках известна как псевдонимы имён (aliasing). На первый взгляд, псевдонимы малозаметны в Python, и их можно без последствий игнорировать при работе с основными неизменяемыми типами (числами, строками, кортежами). Тем не менее, псевдонимы имён влияет на семантику программного кода Python, работающего с изменяемыми объектами: списками, словарями и большинством типов. Обычно такая практика считается полезной, поскольку псевдонимы работают подобно указателям в некотором смысле. Например, передача объекта — дешевая операция, поскольку в реализации передаётся только указатель. Если функция изменяет переданный в качестве аргумента объект, это будет заметно и в месте вызова. За счёт этого пропадает необходимость в двух различных механизмах передачи аргументов как в Паскале.
9.2. Области видимости и пространства имён в Python¶
Прежде чем заняться классами необходимо получить представление о правилах областей видимости в Python. Определения классов проделывают над пространствами имён некоторые ловкие трюки. Чтобы полностью понимать происходящее, нужно знать о принципах работы областей видимости и пространств имён. Эти знания не помешают любому профессиональному программисту на Python.
Давайте начнём с нескольких определений.
Пространство имён (namespace) — это сопоставление между именами и объектами. Большинство пространств имён в настоящее время реализовано в виде Python словарей, но это обычно не заметно и может измениться в будущем. Примеры пространства имён: набор встроенных имён (содержащих такие функции, как abs() , встроенные имена исключений); глобальные имена в модуле; локальные имена в вызове функции. В некотором смысле набор атрибутов объекта также формирует пространство имён. Важная вещь, которую необходимо знать о пространствах имён — это то, что нет абсолютно никакой связи между именами в разных пространствах имён: например, два разных модуля могут без проблем определять функцию maximize , т. к. пользователи модулей будут использовать имена модулей в качестве префиксов.
Кстати, я использую слово атрибут (attribute) для любого имени, следующего за точкой, например, в выражении z.real real является атрибутом объекта z . Строго говоря, ссылки на имена в модулях являются ссылками на атрибуты: в modname.funcname выражения modname является модулем и funcname является его атрибутом. В таком случае обнаруживается прямая связь между атрибутами модуля и глобальными именами, определёнными в модуле: они разделяют между собой одно и тоже пространство имён! [1]
Атрибуты доступны только для чтения или записи. В последнем случае допускается присваивание атрибуту значения. Атрибуты модуля доступны для записи: можно записать modname.the_answer = 42 . Доступные для записи атрибуты также можно удалить с помощью оператора del . Например, del modname.the_answer удалит атрибут, the_answer из объекта с именем modname .
Хотя области определяются статически, они используются динамически. В любой момент выполнения существует 3 или 4 вложенные области, пространства имён которых доступны непосредственно:
- самая внутренняя область видимости (по ней поиск осуществляется в первую очередь) содержит локальные имена;
- области видимости всех функций, начиная найденных с ближайшей области видимости, содержит нелокальные, но и неглобальные имена;
- предпоследняя область видимости, по ней проходит следующий поиск и она содержит глобальные имена текущего модуля;
- самая внешняя область видимости (заключительный поиск) — это пространство имён, содержащее встроенные имена.
Если имя объявлено как global, то все ссылки и присвоения приходят прямо к среднему уровню, содержащему глобальные имена модуля. Чтобы вернуть привязку для переменных, найденных вне внутреннего уровня видимости, может использоваться оператор nonlocal ; без объявления nonlocal такие переменные — только для чтения (попытка записать в такую переменную просто создаст новую локальную переменную в самой внутренней области, оставляя идентично названную внешнюю переменную неизменной).
Обычно локальная область видимости ссылается на локальные имена текущей (буквально) функции. Вне функций локальная область видимости ссылается на то же пространство имён, что и глобальная область видимости: пространство имён модуля. Определения классов помещают в локальную область видимости ещё одно пространство имён.
Важно осознавать, что области видимости ограничиваются на текстовом уровне: глобальная область видимости функции, определённая в модуле, является пространством имён этого модуля, независимо от того, откуда или по какому псевдониму была эта функция вызвана. С другой стороны, фактический поиск имён осуществляется динамически, во время выполнения. Как бы то ни было, язык развивается в сторону статического разрешения имён (во время компиляции), так что не стоит полагаться на динамическое разрешение имён! (Фактически, локальные переменные уже определены статично.)
Особая хитрость в Python состоит в том, что при условии, что в данной области не включены операторы global или nonlocal — присваивания именам всегда уходят в самую внутреннюю область видимости. Присваивания не копируют данных, а лишь связывают имена с объектами. То же самое верно и для удалений: оператор del x удаляет привязку x из пространства имён, на которое ссылается локальная область видимости. Фактически, все операции, которые вводят новые имена используют локальную область видимости: в частности операторы import и определения функций связывают имя модуля или функции в локальной области видимости.
Оператор global можно использовать для того, чтобы объявить определённые переменные как привязанные к глобальной области видимости и указывает, что их переназначения должны происходить в ней; оператор nonlocal помечает переменные как привязанные к окружающей их области видимости и указывает, что их переназначения должны происходить в ней.
9.2.1. Пример области видимости и пространств имён¶
Приведём пример, показывающий, каким образом можно ссылаться на разные области видимости и пространства имён, и как global и nonlocal влияют на привязку переменной:
Выходные данные кода примера:
Обратите внимание, что локальное присваивание (работающее по умолчанию) не изменило scope_test связывание spam. Присвоение nonlocal изменило scope_test связывание spam, и global присваивание заменило привязку на связывание на уровне модуля.
Можно увидеть, что до глобального присваивания у переменной spam не было предшествующих связываний до global -присваивания.
9.3. Первый взгляд на классы¶
Классы вводят немного нового синтаксиса, три новых типа объектов и некоторое количество новой семантики.
9.3.1. Синтаксис определения класса¶
Простейшая форма определения класса выглядит так:
Определения классов, как и определения функций (операторы def ), должны определяться до того, как они окажут какое-либо воздействие. (Вы можете, предположим, поместить определение класса в ветку оператора if или внутрь функции.)
На практике, внутри определения класса обычно помещаются определения функций, но позволено использовать и другие операторы, — и иногда с пользой — как мы увидим позже. Определения функций внутри класса имеют особенную форму списка аргументов, в связи с соглашениями по вызову методов — опять же, это будет рассмотрено далее.
При вводе определения класса создаётся новое пространство имён, которое и используется в качестве локальной области видимости. Таким образом, все присваивания локальным переменным происходят в этом новом пространстве имён. В частности, определения функций связывают здесь имя новой функции.
Когда определение класса пройдено (до конца), объект класса создан. По существу, это обёртка вокруг содержимого пространства имён, созданного во время определения класса; подробнее объекты классов мы изучим в следующем разделе. Оригинальная локальная область видимости (та, которая действовала в последний момент перед вводом определения класса) восстанавливается, а объект-класс тут же связывается в ней с именем класса, указанном в заголовке определения класса (в примере — ClassName ).
9.3.2. Объекты класса¶
Объекты класса поддерживают два вида операций: ссылки на атрибуты и экземпляр.
Ссылки на атрибуты используют стандартный синтаксис, использующих для всех ссылок на атрибуты в Python: obj.name . Допустимыми именами атрибутов являются все имена, которые были в пространстве имён класса при создании объекта класса. Так что, если определение класса выглядело следующим образом:
Тогда MyClass.i и MyClass.f являются допустимыми ссылками на атрибуты, возвращая целое число и объект функции соответственно. Атрибутам класса также можно изменить значения MyClass.i путём присвоения. __doc__ также является допустимым атрибутом, возвращающим докстринг, принадлежащей классу MyClass.
Создание экземпляра класса использует синтаксис вызова функции. Просто представьте, что объект-класс — это непараметризированная функция, которая возвращает новый экземпляр класса. Например (предполагая класс, приведённый выше):
создаёт новый экземпляр класса и присваивает этот объект локальной переменной x .
Операция создания экземпляра (instantiation) создаёт объект данного класса. Большая часть классов предпочитает создавать экземпляры, имеющие определённое начальное состояние. Поэтому класс может определить специальный метод с именем __init__() , например:
Когда класс определяет метод __init__() , при создании экземпляра класса автоматически вызывается __init__() . В этом примере новый инициализированный экземпляр может быть получен путём:
Конечно, метод __init__() может содержать аргументы для большей гибкости. В этом случае аргументы, данные оператору создания экземпляра класса передаются __init__() . Например:
9.3.3. Объекты экземпляра¶
Теперь, что же мы можем делать с объектами-экземплярами? Единственные операции, доступные объектам-экземплярам — это ссылки на атрибуты. Есть два типа корректных имён атрибутов — это атрибуты-данные и методы.
Допустимые имена методов объекта экземпляра зависят от его класса. По определению, все атрибуты класса, являющиеся объектами функции, определяют соответствующие методы его экземпляра. Таким образом, в нашем примере x.f является допустимым методом , т. к. MyClass.f является функцией, но x.i нет, т. к. MyClass.i нет. Но x.f не то же самое, что MyClass.f — является методом объекта, а не объектом функции.
9.3.4. Объекты-методы¶
Обычно метод вызывается сразу после его привязки:
В MyClass примере будет возвращено строковое 'hello world' . Однако вызывать метод сразу не нужно: x.f — это объект-метод и может быть сохранён и вызван позднее. Например:
Будет продолжать печатать hello world до конца времени.
Что именно происходит при вызове метода? Возможно, вы заметили, что x.f() выше вызывался без аргумента , несмотря на то, что определение функции f() был указан аргумент. Что же случилось с аргументом? Несомненно, Python порождает исключение когда функция, требующая присутствия аргумента, вызвана без него — даже, если он на самом деле не используется…
Теперь вы, возможно, догадались: отличительная особенность методов состоит в том, что в качестве первого аргумента функции передаётся объект. В нашем примере вызов x.f() в точности эквивалентен MyClass.f(x) . В общем случае, вызов метода со списком из n аргументов эквивалентен вызову соответствующей функции со списком аргументов, созданным за счёт вставки объекта, вызвавшего метод, перед первым аргументом.
Если вы всё ещё не поняли, как работают методы, взгляд на реализацию возможно прояснит происходящее. Когда атрибут экземпляра ссылается на что-либо, не являющееся атрибутом-данными, производится поиск по классу. Если имя указывает корректный атрибут класса, являющийся объектом-функцией, создаётся метод: через упаковку (указателя на) объекта-экземпляра и найденного объекта-функции в абстрактный объект, получается объект-метод. Когда объект-метод вызывается со списком аргументов, он снова распаковывается и новый список аргументов конструируется из объекта-экземпляра и оригинального списка аргументов, и затем уже с новым списком аргументов вызывается объект-функция.
9.3.5. Переменные класса и экземпляра¶
Вообще говоря, переменные экземпляров используются исключительно для своего экземпляра, переменные класса — для атрибутов и методов, разделяемых всеми экземплярами класса:
Как обсуждалось в Пара слов о терминологии , общие данные могут вызывать удивительные эффекты с участием изменчивых объектов, таких как списки и словари. Например, список tricks в следующем коде не следует использовать как переменную класса, т. к. только один список будет общим для всех Dog экземпляров:
Для правильной конструкции класса следует использовать переменную экземпляра:
Прежде, чем говорить о классах – было бы хорошо понимать основы пространства имён в Python и основы жизненного цикла данных в нём.
Имена
Для начала – поговорим об именах.
Имя – это просто идентификатор, который указывает на какой-то объект в памяти.
Т.е., создавая объект в памяти – вы можете создать указатель, после чего обратиться к нему либо по имени – либо напрямую:
Имена могут указывать и на функции, которые так же являются объектами (как и всё в Python):
Пространства имён
Теперь рассмотрим понятие пространства имён (или namespace).
Грубо говоря, пространство имён – это не более чем коллекция нескольких имён (или “указателей” на объекты). Таких коллекций одновременно может существовать несколько, и каждая из них будет независима друг от друга. По сути – когда вы запускаете интерпретатор, и создаёте в нём функцию – вы уже используете как минимум два таких пространства, область видимости встроенных имён, которая создаётся при запуске интерпретатора. Именно поэтому нам сразу же доступны для использования встроенные переменные типа True или False и встроенные функции, таки как id() , print() и т.д. В глобальной области видимости – вы можете создавать свои объекты, такие как функции. А внутри функций – будет располагаться локальная область видимости самой функции.
Пространство имён хорошо проиллюстрировано на этой картинке:
Именно благодаря тому, что имеется несколько изолированных областей видимости – вы можете использовать одни и те же имена в различных пространствах имён. Например:
Области видимости
Области видимости Python – ещё одно необходимое условие для понимая работы классов и принципов ООП.
Область видимости – это часть кода, из которой доступ к пространству имён может быть получен без каких-либо префиксов. В каждый момент времени у вас есть как минимум три вложенных области видимости:
- область видимости текущей функции, которая содержит её локальные переменные;
- область видимости модуля, который содержит глобальные имена (такие как имена функций в нём);
- внешняя область видимости с встроенными именами.
Когда происходит обращение к переменной внутри функции – сначала выполняется её поиск в локальной области видимости внутри функции, затем – в области видимости модуля, и последним – во встроенной области видимости.
Возвращаясь к классам – они представляют собой такое же изолированное пространство имён и свою область видимости, как и функции или глобальная область видимости. Вы можете представлять себе класс как отдельную область видимости со своим пространством имён, которая содержит свой набор вложенных пространств имён (функции, или методы – мы рассмотрим понятие методы позже).
Лучше всего об этом рассказано в книге Марк Лутц – “Изучаем Python”, глава 16.
Создание класса
Если функция создаётся с помощью ключевого слова def – то класс создаётся с помощью ключевого слова class .
Вот пример простейшего класса:
- class – указание на то, что далее последует объявление класса;
- ThisIsClass – имя класса;
- pass – оператор в классе.
Следует запомнить, что объект (или инстанс – instance) класса, и экземпляр класса – это две разные сущности.
Объект класса создаётся во время его объявления (грубо говоря – когда интерпретатор встречает слово class в коде).
Экземпляр класса – отдельный, новый объект класса, который создаётся во время присваивания класса какой-то переменной и вызова с оператором () .
После создания экземпляра класса – вы можете работать с ним, как с обычной переменной или функцией.
Атрибуты классов
Каждый класс может содержать свой набор атрибутов (переменных, определённых в классе).
Для получения доступа к атрибутам класса – используйте точку в качестве разделителя:
Главная идея в использовании классов, и вообще ООП – это многократное использование одного и того же кода.
Класс в ООП – является как бы конструктором, из которого вы можете далее создавать множество экземпляров:
Каждый из этих экземпляров имеет свою область видимости и собственное пространство имён.
По умолчанию – все атрибуты класса доступны “снаружи”, т.е. – из других областей видимости.
Что бы создать т.н. “приватный” атрибут – используйте символ одинарного или двойного подчёркивания:
Мы рассмотрим “приватные” аргументы и методы далее, в Инкапсуляции.
Методы классов
Каждый класс может содержать несколько методов класса.
По сути – метод, это обычная функция, например:
Методы могут принимать любые другие аргументы:
Тут мы встречаемся со специальным аргументом метода – self .
Его имя – необязательно, но общепринято использовать именно такое имя. Оно так же требуется для получения доступа к атрибутам класса.
self указывает на экземпляр класса, из которого вызывается метод или атрибут:
Кроме того, self потребуется для доступа к атрибутам класса:
Свойства классов
Наследование (inheriting) классов
До сих пор вы создавали класс так:
Однако, классы в Python поддерживают механизм наследования, когда дочерний класс наследует атрибуты и методы из родительского класса.
Для того, что бы указать, что у класса есть родительских класс – он указывается в скобках:
В этом примере InheritingClass наследует значение атрибута parentclassattribute из родительского – ParentClass класса.
Тоже касается и методов классов:
Дочерний класс InheritingClass использует метод paerntmethod родительского класса.
Кроме того, дочерний класс может переопределить метод (или атрибут) родительского класса:
Дочерний класс InheritingClass перезаписывает данные родительского атрибута classattribute своим значением, и переопределяет поведение родительского метода method() .
Допустимо также множественное наследование:
Инкапсуляция
Мы уже кратко касались этой темы выше. Инкапсуляция – это скрытие каких-то данных – атрибутов или методов – от внешней области видимости.
Например – публичный атрибут:
И – скрытый, “инкапсулированный”, атрибут:
Пример с обычным публичным методом класса:
При этом – эти атрибуты и методы будут доступны для использования внутри самого класса:
Однако, следует учитывать, что полностью приватным метод или атрибут в Python сделать нельзя:
Полиморфизм
Полиморфизм – возможность использовать одно и то же имя метода к разным объектам разных классов.
Специальные методы классов
Специальных методов классов в Python очень много, поэтому – рассмотрим только два основных.
Наиболее часто встречающийся – __init__ .
Он является “конструктором класса“, и вызывается каждый раз при создании экземпляра класса.
С его помощью удобно создавать аргументы, которые в дальнейшем будут использоваться другими методами класса:
При работе с языком объектно-ориентированного программирования, таким как Python, инкапсуляция в Python является одной из 4 важных концепций, которые необходимо понять. Остальные три — это наследование, полиморфизм и абстракция.
Что такое инкапсуляция в Python?
При работе с классами и работе с конфиденциальными данными предоставление глобального доступа ко всем переменным, используемым в программе, не является лучшим решением. Инкапсуляция в Python дает нам возможность получить доступ к необходимым переменным, не предоставляя программе полноценный доступ к любой из этих переменных.
Обновление, изменение или удаление данных из переменных можно выполнить с помощью методов, определенных специально для этой цели. Преимущество использования этого подхода к программированию — улучшенный контроль над входными данными и повышенная безопасность.
Концепция инкапсуляции одинакова для всех объектно-ориентированных языков программирования. Разница видна, когда концепции применяются к конкретным языкам.
По сравнению с такими языками, как Java, которые предлагают модификаторы доступа (общедоступные или частные) для переменных и методов, Python предоставляет доступ ко всем переменным и методам.
Приведенный ниже код показывает, как легко получить доступ к переменным.
Поскольку у нас нет модификаторов доступа в Python, мы будем использовать несколько различных методов для управления доступом к переменным в программе.
Методы контроля доступа
Python предлагает несколько методов для ограничения доступа к переменным и методам в программе. Давайте подробно рассмотрим методы.
Использование одиночного подчеркивания
Распространенное соглашение программирования Python для идентификации частной переменной — это префикс с подчеркиванием. Теперь это не имеет никакого значения для компилятора. Переменная по-прежнему доступна в обычном режиме. Но поскольку это соглашение, принятое программистами, оно сообщает другим программистам, что переменные или методы должны использоваться только в рамках класса.
Понятно, что доступ к переменным не изменился. Но можем ли мы сделать что-нибудь, чтобы это действительно было приватным? Посмотрим дальше.
Использование двойного подчеркивания
Если вы хотите сделать члены класса, то есть методы и переменные, частными, вам следует поставить перед ними двойное подчеркивание. Но Python предлагает некоторую поддержку модификатора private. Этот механизм называется изменением имени. При этом по-прежнему можно получить доступ к членам класса извне.
Имя Mangling
В Python любой идентификатор с __Var переписывается интерпретатором python как _Classname__Var, а имя класса остается как текущее имя класса. Этот механизм изменения имен называется изменением имен.
В приведенном ниже примере в Class person переменная age изменена, и ей предшествуют двойные символы подчеркивания в начале.
Вы можете заметить, что к переменным по-прежнему можно обращаться с помощью методов, которые являются частью класса. Но вы не можете получить доступ напрямую извне, поскольку это частная переменная.
Использование методов Getter и Setter
Если вы хотите получить доступ и изменить частные переменные, следует использовать методы доступа getter и setter, поскольку они являются частью Class.
Преимущества
Инкапсуляция не только обеспечивает лучший поток данных, но и защищает данные от внешних источников. Концепция инкапсуляции делает код самодостаточным.
Это очень полезно на уровне реализации, вы должны скрыть данные в блоке, чтобы упростить инкапсуляцию, а также защитить данные.
Зачем нужна инкапсуляция?
Следующие причины показывают, почему разработчики находят инкапсуляцию удобной и почему объектно-ориентированная концепция превосходит многие языки программирования.
- Инкапсуляция помогает в достижении четко определенного взаимодействия в каждом приложении.
- Объектно-ориентированная концепция фокусируется на возможности повторного использования кода в Python.
- Приложения можно безопасно обслуживать.
- Это обеспечивает гибкость кода за счет правильной организации.
- Способствует плавному взаимодействию с пользователями без каких-либо внутренних сложностей.
- Это улучшает читаемость кода. Любые изменения в одной части кода не помешают другой.
- Инкапсуляция обеспечивает защиту данных и предотвращает случайный доступ к данным. Доступ к защищенным данным можно получить с помощью описанных выше методов.
Инкапсуляция в Python заключается в том, что данные скрыты за пределами определения объекта. Это позволяет разработчикам создавать удобный интерфейс. Это также помогает защитить данные от взломов, так как код надежно защищен и недоступен для внешних источников.
Объектно-ориентированное программирование (ООП) — это парадигма программирования, где различные компоненты компьютерной программы моделируются на основе реальных объектов. Объект — это что-либо, у чего есть какие-либо характеристики и то, что может выполнить какую-либо функцию.
Содержание
Представьте сценарий, где вам нужно разработать болид Формулы-1 используя подход объектно-ориентированного программирования. Первое, что вам нужно сделать — это определить реальные объекты в настоящей гонке Формула-1. Какие аспекты в Формуле-1 обладают определенными характеристиками и могут выполнять ту или иную функцию?
Есть вопросы по Python?
На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!
Telegram Чат & Канал
Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!
Паблик VK
Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!
- мощность двигателя;
- марка;
- модель;
- производитель, и т. д.
Соответственно, болид можно запустить, остановить, ускорить, и так далее. Гонщик может быть еще одним объектом в Формуле-1. Гонщик имеет национальность, возраст, пол, и так далее, кроме этого, он обладает таким функционалом, как управление болидом, рулевое управление, переключение передач.
Как и в этом примере, в объектно-ориентированном программировании мы создадим объекты, которые будут соответствовать реальным аспектам.
В этой статье мы разберем подробную инструкцию объектно-ориентированного программирования в Python, но перед этим, рассмотрим некоторые преимущества и недостатки объектно-ориентированного программирования.
Преимущества и недостатки ООП Python
Рассмотрим несколько основных преимуществ объектно-ориентированного программирования:
Хотя объектно-ориентированное программирование обладает рядом преимуществ, оно также содержит определенные недостатки, некоторые из них находятся в списке ниже:
- Для создания объектов необходимо иметь подробное представление о разрабатываемом программном обеспечении;
- Не каждый аспект программного обеспечения является лучшим решением для реализации в качестве объекта. Для новичков может быть тяжело прочертить линию в золотой середине;
- С тем, как вы вносите все новые и новые классы в код, размер и сложность программы растет в геометрической прогрессии;
В следующем разделе мы рассмотрим ряд самых важных концепций объектно-ориентированного программирования.
Как и следует из названия, объектно-ориентированное программирование — это речь об объектах. Однако, перед тем как создать объект, нам нужно определить его класс.
Класс
Класс в объектно-ориентированном программировании выступает в роли чертежа для объекта. Класс можно рассматривать как карту дома. Вы можете понять, как выглядит дом, просто взглянув на его карту.
Cам по себе класс не представляет ничего. К примеру, нельзя сказать что карта является домом, она только объясняет как настоящий дом должен выглядеть.
Отношение между классом и объектом можно представить более наглядно, взглянув на отношение между машиной и Audi. Да, Audi – это машина. Однако, нет такой вещи, как просто машина. Машина — это абстрактная концепция, которую также реализуют в Toyota, Honda, Ferrari, и других компаниях.
Ключевое слово class используется для создания класса в Python. Название класса следует за ключом class , за которым следует двоеточие. Тело класса начинается с новой строки, с отступом на одну вкладку влево.
Давайте рассмотрим, как мы можем создать самый простой класс в Python. Взглянем на следующий код:
Читайте также: