Создание класса в python: как работать с классами, разбор на примерах

Классы в Python — Python самоучитель

Объектно-ориентированное программирование считается одним из самых эффективных методов создания программ. В объектно-ориентированном программирование создаются классы, описывающие реальные предметы и ситуации, а затем создаете объекты на основе этих описаний. Созданием объекта на основе класса называется созданием экземпляра. 

Содержание страницы:
1. Создание класса
1.1. Метод __init__()
1.2. Создание экземпляра класса
1.3. Обращение к атрибутам класса
1.4. Вызов методов класса
2. Работа с классами
2.1. Прямое изменение значения атрибута
2.2. Изменение значения атрибута с использованием метода
2. 3. Изменение значения атрибута с приращением
3. Наследование класса
3.1. Переопределение методов класса-родителя

1. Создание класса в Python

Классы в Python могут моделировать практически все что угодно. Создадим простой класс, который будет описывать конкретный автомобиль:

class Car():
    «»»Описание автомобиля»»»
    def __init__(self, brand, model):
        «»»Инициализирует атрибуты brand и model»»»
        self.brand = brand
        self.model = model

    def sold(self):
        «»»Автомобиль продан»»»
        print(f»Автомобиль {self.brand} {self.model} продан «)

    def discount(self):
        «»»Скидка на автомобиль»»»
        print(f»На автомобиль {self.brand} {self.model} скидка 5%»)

Разберем код по порядку. В начале определяется класс с именем Car (class Car). По общепринятым соглашение название класса начинается с символа верхнего регистра. Круглые скобки в определение класса пусты, так как класс создается с нуля. Далее идет строка документации с кратким описанием. («»»Описание автомобиля»»»). 

1.1. Метод __init__()

Функция, являющаяся частью класса, называется методом. Все свойства функций так же относятся и к методам, единственное отличие это способ вызова метода. Метод __init__() — специальный метод, который автоматически выполняется при создание нового экземпляра. Имя метода начинается и заканчивается двумя символами подчеркивания. Метод __init__() определяется с тремя параметрами: self, brand, model. Параметр self обязателен в определение метода и должен стоять перед всеми остальными параметрами. При создании экземпляра на основе класса Car, необходимо передать только два последних аргумента brand и model.

Каждая из двух переменных self.brand = brand и self.model = model снабжена префиксом self и к ним можно обращаться вызовом self.brand и self.model. Значения берутся из параметров brand и model. Переменные, к которым вы обращаетесь через экземпляры, также называются атрибутами. 

В классе Car также есть два метода: sold() и discount(). Этим методам не нужна дополнительная информация и они определяются с единственным параметром self. Экземпляры, которые будут созданы на базе этого класса смогут вызывать данные методы, которые просто выводят информацию. 

1.2. Создание экземпляра класса 

С помощью класса Car мы можем создавать экземпляры для конкретного автомобиля. Каждый экземпляр описывает конкретный автомобиль и его параметры. 

car_1 = Car(‘Bmw’, ‘X5’)

Создадим переменную car_1 и присвоим ей класс с параметрами автомобиля которые нужно обязательно передать (brand, model).  При выполнение данного кода Python вызывает метод __init__ , создавая экземпляр, описывающий конкретный автомобиль и присваивает атрибутам brand и model  переданные значения. Этот экземпляр сохраняется в переменной car_1. 

1.3. Обращение к атрибутам класса

К атрибутам экземпляра класса мы можем обращаться через запись:

print(f»{car_1.brand}»)

В записи используется имя экземпляра класса и после точки имя атрибута (car_1.brand) или (car_1.model). В итоге на экран выведется следующая информация:

Bmw
X5

1.4. Вызов методов класса

После создания экземпляра на основе класса Car можете вызывать любые методы, написанные в классе. Чтобы вызвать метод, укажите экземпляр (car_1) и вызываемый метод после точки:

car_1.sold()
car_1.discount()

При вызове данных методов, Python выполнит код, написанный в этом методе.

Автомобиль Bmw X5 продан 
На автомобиль Bmw X5 скидка 5%

2.

class Car():
    «»»Описание автомобиля»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты»»»
        self.brand = brand
        self.model = model
        self.years = years
        self.mileage = 0

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self.brand} {self.model} {self.years}»
        return name.title()

    def read_mileage(self):
        «»»Пробег автомобиля»»»
        print(f»Пробег автомобиля {self.mileage} км.»)

В описание автомобиля есть три атрибута(параметра) это brand, model, years. Также мы создали новый атрибут mileage (пробег) и присвоили ему начальное значение 0. Так как пробег у всех автомобилей разный, в последующем мы сможем изменять этот атрибут. Метод get_full_name будет возвращать полное описание автомобиля. Метод read_mileage будет выводить пробег автомобиля. 

Создадим экземпляр с классом Car и запустим методы:

car_2 = Car(‘audi’, ‘a4’, 2019)
print(car_2.get_full_name())
car_2.read_mileage()

В результате в начале Python вызывает метот __init__() для создания нового экземпляра. Сохраняет название, модель, год выпуска и создает новый атрибут с пробегом равным 0. В итоге мы получим такой результат:

Автомобиль Audi A4 2019
Пробег автомобиля 0 км.

2.1. Прямое изменение значения атрибута

Для изменения значения атрибута можно обратиться к нему напрямую и присвоить ему новое значение. Изменим пробег автомобиля car_2:

car_2 = Car(‘audi’, ‘a4’, 2019)
print(car_2.

Мы обратились к нашему экземпляру car_2 и связанным с ним атрибутом пробега(mileage) и присвоили новое значение 38. Затем вызвали метод read_mileage() для проверки. В результате мы получим следующие данные. 

Автомобиль Audi A4 2019
Пробег автомобиля 38 км.

2.2. Изменение значения атрибута с использованием метода 

В Python удобнее писать методы, которые будут изменять атрибуты за вас. Для этого вы просто передаете новое значение методу, который обновит значения. Добавим в наш класс Car метод update_mileage() который будет изменять показания пробега. 

class Car():
    «»»Описание автомобиля»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты»»»
        self.brand = brand
        self.model = model
        self. years = years
        self.mileage = 0

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self.brand} {self.model} {self.years}»
        return name.title()

    def read_mileage(self):
        «»»Пробег автомобиля»»»

    def update_mileage(self, new_mileage):
        «»»Устанавливает новое значение пробега»»»
        self.mileage = new_mileage

car_2 = Car(‘audi’, ‘a4’, 2019)
print(car_2.get_full_name())

car_2.read_mileage()
car_2.update_mileage(17100)
car_2.read_mileage()

Вначале выведем текущие показания пробега ( car_2.read_mileage() ). Затем вызовем метод update_mileage() и передадим ему новое значение пробега ( car_2.update_mileage(17100) ). Этот метод устанавливает пробег 17100. Выведем текущие показания ( car_2.read_mileage() ) и у нас получается:

Автомобиль Audi A4 2019
Пробег автомобиля 0 км.
Пробег автомобиля 17100 км.

2.3. Изменение значения атрибута с приращением

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

def add_mileage(self, km):
        «»»Добавляет пробег»»»
        self.mileage += km

Новый метод add_mileage() получает пробег в км и добавлет его к self.mileage

car_2.add_mileage(14687)
car_2.read_mileage()

Пробег автомобиля 31787 км.

В итоге после вызова метода add_mileage() пробег автомобиля в экземпляре car_2 увеличится на 14687 км и станет равным 31787 км. Данный метод мы можем вызывать каждый раз при изменении пробега и передавать новые значение, на которое будет увеличивать основной пробег.

3. Наследование класса в Python

Создавая новые классы не обязательно их создавать с нуля. Новый класс может наследовать свои атрибуты (переменные) и методы (функции принадлежащие классам) от ранее определенного исходного

class Car():
    «»»Описание автомобиля»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты brand и model»»»
        self.brand = brand
        self.model = model
        self.years = years
        self.mileage = 0

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self.brand} {self.model} {self.years}»

    def read_mileage(self):
        «»»Пробег автомобиля»»»
        print(f»Пробег автомобиля {self. mileage} км.»)

    def update_mileage(self, new_mileage):
        «»»Устанавливает новое значение пробега»»»
        self.mileage = new_mileage
    
    def add_mileage(self, km):
        «»»Добавляет пробег»»»
        self.mileage += km

class ElectricCar(Car):
    «»»Описывает электромобиль»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты класса родителя»»»
        super().__init__(brand, model, years)
        # атрибут класса-потомка
        self.battery_size = 100

    def battery_power(self):
        «»»Выводит мощность аккумулятора авто»»»
        print(f»Мощность аккумулятора {self.battery_size} кВт⋅ч»)

Мы создали класс ElectriCar на базе класса Car. Имя класса-родителя в этом случае ставится в круглые скобки( class ElectricCar(Car) ). Метод __init__  в классе потомка (подклассе) инициализирует атрибуты класса-родителя и создает экземпляр класса Car. Функция super() .- специальная функция, которая приказывает Python вызвать метод __init__() родительского класса Car, в результате чего экземпляр ElectricCar получает доступ ко всем атрибутам класса-родителя. Имя super как раз и происходит из-за того, что класс-родителя называют суперклассом, а класс-потомок — подклассом.          

Далее мы добавили новый атрибут self.battery_size и присвоили исходное значение 100. Этот атрибут будет присутствовать во всех экземплярах класса ElectriCar. Добавим новый метод battery_power(), который будет выводить информацию о мощности аккумулятора.         

Создадим экземпляр класса ElectriCar и сохраним его в переменную tesla_1

tesla_1 = ElectricCar(‘tesla’, ‘model x’, 2021)
print(tesla_1.get_full_name())
tesla_1.battery_power()

При вызове двух методов мы получим:

Автомобиль Tesla Model X 2021
Мощность аккумулятора 100 кВт⋅ч

В новый класс ElectriCar мы можем добавлять любое количество атрибутов и методов связанных и не связанных с классом-родителем Car.     

3.1. Переопределение методов класса-родителя

Методы, которые используются в родительском классе можно переопределить в классе-потомке (подклассе). Для этого в классе-потомке определяется метод с тем же именем, что и у класса-родителя. Python игнорирует метод родителя и переходит на метод, написанный в классе-потомке (подклассе). Переопределим метод def get_full_name() чтобы сразу выводилась мощность аккумуляторов. 

class ElectricCar(Car):
    «»»Описывает электромобиль»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты класса родителя»»»
        super().__init__(brand, model, years)
        # атрибут класса-потомка
        self.battery_size = 100

    def battery_power(self):
        «»»Выводит мощность аккумулятора авто»»»
        print(f»Мощность аккумулятора {self.battery_size} кВт⋅ч»)

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self. brand} {self.model} {self.years} {self.battery_size}-кВт⋅ч «
        return name.title()
 

В результате при запросе полного названия автомобиля Python проигнорирует метод def get_full_name() в классе-родителя Car и сразу перейдет к методу def get_full_name() написанный в классе ElectricCar.          

tesla_1 = ElectricCar(‘tesla’, ‘model x’, 2021)
print(tesla_1.get_full_name())

Автомобиль Tesla Model X 2021 100-Квт⋅Ч

Далее: Файлы и исключения в Python

Назад: Функции в Python

Создание экземпляра класса в Python.

• Процесс создания экземпляра класса;
• Операции, доступные экземплярам класса.

Процесс создания экземпляра класса.

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

• Создание нового экземпляра целевого класса;
• Инициализация нового экземпляра с соответствующим начальным состоянием.

Для выполнения первого шага в классах Python есть специальный метод .__new__(), который отвечает за создание и возврат нового пустого объекта. Затем другой специальный метод .__init__(), принимает результирующий объект вместе с аргументами конструктора класса.

Метод .__init__() принимает новый объект в качестве первого аргумента self. Затем он устанавливает любой требуемый атрибут экземпляра в допустимое состояние, используя аргументы, переданные ему конструктором класса.

Короче говоря, процесс создания экземпляра Python начинается с запуска создателя экземпляра .__new__() для создания нового пустого объекта. Процесс продолжается инициализатором экземпляра .__init__(), который принимает аргументы конструктора для инициализации вновь созданного объекта.

Чтобы изучить внутреннюю работу процесса создания экземпляров Python, рассмотрите следующий пример класса Point, который (в демонстрационных целях) реализует пользовательскую версию обоих методов, .__new__() и .__init__():

# point.py
class Point:
    def __new__(cls, *args, **kwargs):
        print("1. Создается новый экземпляр Point.")
        return super().__new__(cls)
    def __init__(self, x, y):
        print("2. Инициализируется новый экземпляр Point.")
        self.x = x
        self.y = y
    def __repr__(self) -> str:
        return f"{type(self).__name__}(x={self.x}, y={self.y})"

Описание того, что делает этот код:

• Строка def __new__(cls, *args, **kwargs) определяет метод, который принимает класс в качестве первого аргумента. Обратите внимание, что использование cls в качестве имени этого аргумента является строгим соглашением в Python, точно так же, как использование self для имени текущего экземпляра. Метод также принимает *args и **kwargs, что позволяет передавать неопределенное количество аргументов инициализации базовому экземпляру.
• Строка return super().__new__(cls) создает и возвращает новый экземпляр Point, вызывая метод родительского класса .__new__() с cls в качестве аргумента. Этот экземпляр будет первым аргументом для .__init__(). В этом примере объект является родительским классом, и вызов super() дает доступ к нему.
• Строка def __init__(self, x, y) определяет метод конструктора, который отвечает за этап инициализации. Этот метод принимает первый аргумент с именем self, который содержит ссылку на текущий экземпляр и два дополнительных аргумента, x и y.
• Внутри метода конструктора .__init__() инициализируются начальные значения атрибутов экземпляра Point.x и Point.y соответственно. Для этого он использует входные аргументы x и y.

Сохраним код, представленный выше в файл с именем point.py и запустим интерпретатор Python:

>>> from point import Point
>>> point = Point(21, 42)
# 1. Создается новый экземпляр Point.
# 2. Инициализируется новый экземпляр Point.
>>> point
# Point(x=21, y=42)

Операции, доступные экземплярам класса.

Единственные операции, понятные объектам-экземплярам класса, являются ссылки на атрибуты класса. Существует два вида допустимых имен атрибутов класса, это атрибуты данных и методы класса.

Атрибуты данных соответствуют «переменным экземпляра» в языке Smalltalk или «членам данных» в языке C++. Атрибуты данных класса в Python можно не объявлять, как например это делается с локальным переменным, они появляться динамически, когда им впервые присваивается значение. При этом, динамически созданные атрибуты хранятся в специальном словаре объекта-экземпляра x. __dict__. Например, если x это экземпляр MyClass, то следующий фрагмент кода напечатает значение 16.

Создайте файл test.py с определением класса MyClass и запустите его в интерактивном режиме командой: python3 -i test.py.

# файл `test.py`
class MyClass:
    """Простой пример класса"""
    i = 12345
    def f(self):
        return 'hello world'
# запускаем: $ python3 -i test.py 
>>> x = MyClass()
# обратите внимание, что атрибут 
# `counter` в классе не определен
>>> x.counter = 1
# динамически созданные атрибуты экземпляра класса 
# хранятся в специальных словарях этих экземпляров
>>> x.__dict__
# {'counter': 1}
>>> while x.counter < 10:
...     x.counter = x.counter * 2
... 
>>> x.counter
# 16
# удаляем динамически созданный атрибут
>>> del x.counter
# смотрим специальный словарь экземпляра
>>> x.__dict__
# {}
# пытаемся получить значение
x. counter
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# AttributeError: 'MyClass' object has no attribute 'counter'

Другой вид ссылки на атрибут объекта-экземпляра — это метод. Метод — это функция, которая принадлежит объекту класса. В языке Python термин «метод«, для экземпляров классов, не уникален: другие типы объектов также могут иметь свои методы. Например, объекты списка list() имеют методы list.append, list.insert, list.remove, list.sort и т. д. Дальше будем использовать термин «метод» исключительно для обозначения «методов объектов экземпляра класса«, если явно не указано иное.

Допустимые имена методов объекта экземпляра класса зависят от его класса. По определению, все атрибуты класса, являющиеся объектами функций, определяют соответствующие методы его экземпляров. Таким образом, в нашем примере x.f это допустимая ссылка на связанный метод, так как MyClass. f это функция. Тогда как x.i это НЕ метод, а ссылка на атрибут класса MyClass.i. При этом выражение x.f это объект связанного метода, т.е. не то же самое, что MyClass.f. Так как MyClass.f — это объект функции.

Смотрим пример, который это показывает:

>>> MyClass.f
# <function MyClass.f at 0x7f3c1c409400>
>>> x.f
# <bound method MyClass.f of <__main__.MyClass object at 0x7f3c1fd67710>>
>>> MyClass.i
# 12345
>>> x.i
# 12345

Как создать класс в Python

В этой статье мы научимся создавать класс в Python. Мы рассмотрим методологию, синтаксис, ключевые слова, связанные термины с некоторыми простыми подходами, а также некоторые пользовательские коды, чтобы лучше понять тему класса. Давайте сначала кратко рассмотрим, что такое класс, его типы, а также то, как он используется и определяется в языке Python.

Что такое класс?

Python — популярный язык сценариев. Он также поддерживает концепции парадигмы объектно-ориентированного программирования. Объектно-ориентированное программирование на Python включает создание объектов до Класс , Наследование , Полиморфизм, и Инкапсуляция . Класс похож на план, который объединяет различные типы элементов под одной крышей. Python может иметь несколько классов в одном скрипте Python. Каждый класс содержит свои собственные атрибуты, экземпляры и методы для поддержания состояния класса. Классы Python имеют возможность защищать данные от внешних угроз. Доступ к классам осуществляется из объекта с именем объектов . Он имеет методы, называемые функций-членов для изменения состояния класса. Предположим, что ваш класс представляет собой дом, который содержит детали дома, такие как комната, кухня, двери и т. д. Точно так же класс имеет различные атрибуты, называемые элементами данных , которые рассказывают нам о классе.

Класс Реальный пример

Давайте разберемся на реальном примере, чтобы понять важность объектно-ориентированного класса. Предположим, что в одном классе 50 учеников, и учитель хочет хранить, управлять и поддерживать оценки по каждому предмету, выставленные 50 учениками. Чтобы поддерживать эти большие данные, вводятся классы, поскольку они объединяют данные вместе и обеспечивают организацию данных. Класс создает объекты для своего функционирования. Класс будет определять свойства, связанные со студентами, такие как имя, номер списка, оценки и т. д. под одной крышей, а затем получать доступ к информации с помощью созданных объектов.

Теперь давайте посмотрим, как создаются классы, какие важные моменты нужно иметь в виду перед созданием класса, а затем, какую функциональность нам предоставляет другой класс.

Создание класса в Python

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

Важные моменты

1. Классы создаются с использованием класса 9ключевое слово 0008.
2. После имени класса используется двоеточие (:) .
3. Класс состоит из атрибутов (данных) и методов (функций).
4. Атрибуты, применимые ко всему классу, определяются первыми и называются атрибутами класса .
5. Доступ к атрибутам можно получить с помощью оператора точка (.) через объекты.

Давайте разберемся с концепцией класса «Собака» , используя простой код.

Пример: создание Python класса

 #class определяется с помощью ключевого слова class
класс Собака:
  
  #данные-члены класса
  цвет = "черный" #атрибут 1
  имя = "Поло" #атрибут 2
   
  #конструктор класса
  защита __init__(сам):
         проходить
  
  #пользовательская функция класса
  Функция определения():
      проходить
   
 


Берем класс и называем его "Собака". Мы определили два атрибута или два экземпляра класса Dog, которые хранят цветов, и имен. Это самый простой шаблон класса. Далее мы определили конструктор, который использует __init__ для его объявления. После этого пользователь может создавать свои собственные функции, называемые функциями-членами класса, и выполнять различные операции над атрибутами, определенными внутри класса. Мы оставили эти две функции пустыми и узнаем о них больше в другой статье.

Как видно из приведенного выше примера, все различные атрибуты или свойства собаки объединены в один пакет. Эти атрибуты подобны переменным класса, которые являются локальными для его класса. Когда класс определен, новый 9Пространство имен 0007 создается и используется как локальная область, таким образом, все присваивания локальным переменным (здесь атрибуты) переходят в это новое пространство имен, а затем получают доступ к ним с помощью объекта. Мы узнаем больше об объектах класса в следующей статье.

Заключение

В этой статье мы научились создавать класс в Python, используя ключевое слово class . Мы использовали класс Dog, чтобы лучше понять тему. Мы узнали об объектно-ориентированном программировании с его важностью. Мы узнали, как классы используются в нашей повседневной жизни.

Классы и объекты в Python

"Здравствуйте, меня зовут Аян"