Python объектно ориентированное программирование: концепции, принципы и примеры реализации

Объектно-ориентированное программирование в Python — it-black.ru

Объектно-ориентированное программирование в Python — it-black.ru Перейти к содержимому

Сегодня я расскажу вам о объектно-ориентированных возможностях в Python. Ведь с самого начала Python проектировался как объектно-ориентированный язык программирования.

Объектно-ориентированное программирование (ООП) — парадигма программирования, в которой основными концепциями являются понятия объектов и классов.

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

Python соответствует принципам объектно-ориентированного программирования. В Python всё является объектами — и строки, и списки, и словари, и всё остальное.

Использование классов дает прежде всего преимущества абстрактного подхода в программировании.

1. Полиморфизм: в разных объектах одна и та же операция может выполнять различные функции. Слово «полиморфизм» имеет греческую природу и означает «имеющий многие формы».

Простым примером полиморфизма может служить функция count(), выполняющая одинаковое действие для различных типов обьектов: ‘abc’.count(‘a’) и [1, 2, ‘a’].count(‘a’). Оператор плюс полиморфичен при сложении чисел и при сложении строк.

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

Атрибуты могут иметь различные состояния в промежутках между вызовами методов класса, вследствие чего сам объект данного класса также получает различные состояния — state.

3. Наследование: можно создавать специализированные классы на основе базовых. Это позволяет избегать написания повторного кода.

4. Композиция: объект может быть составным и включать в себя другие объекты.

Объектно-ориентированный подход в программировании подразумевает следующий алгоритм действий.

1. Описывается проблема с помощью обычного языка с использованием понятий, действий, прилагательных.
2. На основе понятий формулируются классы.
3. На основе действий проектируются методы.
4. Реализуются методы и атрибуты.

Теперь приступим к написанию своих классов и объектов на Python. Попробуем определить собственный класс и объект:

# Пример создания класса и объекта:
class Cat(object):
  """ Виртуальная кошка """
  def talk(self):
    print("Мяу")

Bagira = Cat()
Bagira.talk()
input()

# выведет: Мяу

Первым делом мы объявили класс Cat. Для создания класса используется служебное слово «class». Имя класса начинается с большой буквы.

Наш класс будет создан с опорой на фундаментальный встроенный тип object, проще говоря, мы наследуем наш класс от object.

Строка «»» Виртуальная кошка «»» документирует класс.

Далее мы объявляем метод:

def talk(self):
    print("Мяу")

Метод talk() выводит строку «Мяу». У метода talk() есть параметр self, который мы не используем.

Далее мы создаем объект Bagira класса Cat() и вызываем его метод talk():

Bagira = Cat()
Bagira.talk()

Сначала создается переменная Bagira, затем используется точечная нотация для вызова метода talk(). При вызове метода talk() мы видим строку «Мяу».

Конструкторы

Конструкторы используются для инициализации объекта, например, для загрузки информации из базы данных. Пример:

class Cat(object):
  """ Виртуальная кошка """
  def __init__(self):
    print("Родилась новая кошка!")
  def talk(self):
    print("Мяу")
cat1 = Cat()
cat2 = Cat()
cat1. talk()
cat2.talk()
input()

Конструктор также называется методом инициализации, поэтому имя у него специфическое — __init()__. Имя конструктора нельзя изменять.

В примере мы создаем несколько объектов класса Cat. При создании объектов будет выведено сообщение о рождении новой кошки. Затем вызываем метод talk() каждого объекта.

Атрибуты класса

Атрибуты класса бывают двух видов:

1. атрибуты данных;
2. атрибуты-методы.

Атрибуты класса — это имена переменных вне функций и имена функций. Эти атрибуты наследуются всеми объектами, созданными на основе данного класса.

Атрибуты обеспечивают свойства и поведение объекта. Объекты могут иметь атрибуты, которые создаются в теле метода, если данный метод будет вызван для конкретного объекта. Использование атрибута:

class Cat(object):
  """ Виртуальная кошка """
  def __init__(self, name):
    print("Родилась новая кошка!")
    self. name = name
  def talk(self):
    print(self.name, ": Мяу")
    
cat1 = Cat("Багира")
cat2 = Cat("Василий")
cat1.talk
cat2.talk

input()

В данном примере мы добавили параметр name нашему конструктору. Теперь при создании объекта мы можем назвать наших кошек.

Далее мы выводим (в конструкторе) строку о рождении кошки, а вот следующая за print() строка как раз создает атрибут name и присваивает ему значение параметра name.

Также мы изменили метод talk(). Теперь он выводит имя кошки, то есть значение атрибута self.name. К атрибуту можно обратиться напрямую:

print(cat1.name)

# выведет: Багира

Аргумент self — это ссылка на создаваемый в памяти компьютера объект. Параметр self автоматически становится ссылкой на объект, по отношению к которому вызван метод.

Поэтому через метод self метод получает доступ к вызывающему объекту, к его атрибутам и методам.

Закрытые атрибуты и методы

По умолчанию все атрибуты и методы класса являются открытыми или публичными (public). Публичные методы можно вызывать за пределами класса, а к публичным атрибутам можно обращаться за пределами класса.

Существуют также и закрытые или приватные (private) методы и атрибуты. Приватный метод можно вызывать только внутри класса — в других методах.

К приватным атрибутам невозможно обратиться напрямую. В Python два знака подчеркивания означают, что атрибут будет закрытым. Рассмотрим пример:

def __init__(self, name):
   print("Родилась новая кошка!")
   self.name = name
   Cat.total += 1
   self.__w = 1

Атрибут __w является закрытым. Приватный метод объявляется аналогично:

def __private_method(self):
   print("Закрытый метод")

Если атрибут предназначен для служебного использования и его неправильное изменение может привести к сбою, то лучше его сделать закрытым и изменять только внутри класса — так вы сможете контролировать процесс изменения значения.

Управление доступом к закрытому атрибуту

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

Для создания свойства нужно написать метод, который возвращает значение. Перед таким методом нужно объявить декоратор @property.

Создав свойство, мы приоткрываем закрытый атрибут и делаем его доступным для чтения. Но с помощью свойств можно сделать его доступным не только для чтения, но и для записи.

Видео по уроку:

Программа «Виртуальная кошка»

Для закрепления теоретических знаний в области ООП создадим небольшую программу «Виртуальная кошка». В данной программе можно будет покормить виртуальную кошку, а также поиграть и взвесить. Листинг программы:

class Cat(object):
    """ Виртуальная кошка """
    total = 0
    @staticmethod
    def count():
        print("Всего кошек: ", Cat.total)
    
    def __init__(self):
        print("Родилась новая кошка!")
        self.name = input("Как мы её назовём? ")
        Cat.total += 1
        self.__w = 300
        self.hunger = 1
        
    def __str__(self):
        res = "Объект класса Cat\n name: " + self.name + "\nBec: " + str(self.__w)
        return res
        
    @property
    def weight(self):
        return self.__w
    
    def talk(self):
        print(self.name, ": Мяу")
    
    def eat(self):
        if self.hunger == 5:
            print("Кошка не голодная")
        else:
            self.hunger += 1
            self.  __w += 30
            print("Мур!")

    def play(self):
        self.talk()
        self.__w -= 5
        if self.hunger > 0:
            self.hunger -= 1
        else:
            self.hunger = 1
    
def main():

    bagira = Cat()
    choice = None
    while choice != "0":
        print \
        ("""
        Что будем делать?
            
        0 - Выйти
        1 - Поговорить с кошкой
        2 - Покормить
        3 - Поиграть
        4 - Взвесить
        """)
            
        choice = input(">>: ")
        print()

        # exit
        if choice == "0":
            print("Пока.")
            
        # послушать
        elif choice == "1":
            bagira.talk()
                
        # покормить
        elif choice == "2":
            bagira.eat()
                
        # поиграть
        elif choice == "3":
            bagira. play()
        elif choice == "4":
            print("Вес: ", bagira.weight, " гр. ")
            
        # неправильный ввод
        else:
            print("\nНеправильный ввод!")  
main()            
input()

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

При рождении кошки пользователю дается возможность выбрать имя кошки. Также устанавливается начальный вес в 300 грамм и уровень голода 1, что означает, что кошка голодна.

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

При каждом кормлении вес кошки увеличивается на 30 граммов. При каждой игре с кошкой она теряет 5 грамм веса.

Вывод программы:

Видео по созданию программы:

Facebook

Twitter

• Виктор Черемных
• 31 декабря, 2017
• 2 Comments

Группа в VK

Обнаружили опечатку?

Сообщите нам об этом, выделите текст с ошибкой и нажмите Ctrl+Enter, будем очень признательны!

Свежие статьи

Облако меток

Instagram Vk Youtube Telegram Odnoklassniki

Полезно знать

Рубрики

Авторы

Курс Python.

Объектно-ориентированное программирование в Екатеринбурге Код: ITCloud-P-OOA Python — мощный высокоуровневый язык программирования, идеально подходящий для разработки самостоятельных программ и сценариев. Python используют такие гиганты, как Google, Intel, Cisco и Hewlett-Packard, на нем работают популярные площадки YouTube, «ВКонтакте», DropBox. Python – язык программирования, который будет востребован еще очень долго!

На курсе вы получите базовые навыки объектно-ориентированного программирования, познакомитесь с базовыми элементами языка Python. Получите необходимую подготовку для изучения проектирования пользовательского интерфейса на базе Qt/Python и веб-программирования на базе Python/Django.

Стоимость курса

33 900 руб

Заказать

Вы научитесь:

• Создавать объектно-ориентированные приложения на языке Python 
• Выполнять первичную обработку данных на языке Python 
• Ориентироваться в стандартной библиотеке языка Python

Аудитория:

Инженеры-программисты

Содержание курса

1. Классы и объекты
Введение в Объектною-ориентированное программирование (ООП)
Класс и экземпляр класса.
Данные экземпляра, методы экземпляра и свойства экземпляра
Создание собственного класса
Инкапсуляция
Атрибуты класса
Чтение и изменение атрибута.
Практикум: Разработка собственных классов. Определение нужных методов и свойств классов. Создание нескольких объектов

2.Наследование
Роль наследования в ООП, понятие иерархии наследования
Принцип утиной типизации
Понятие базового класса и производного класса
Функция isinstance и ее применение.
Создание производного класса
Применение экземпляров базового и производного класса.
Практикум: Расширение готовых классов

3.Абстрактные классы и полиморфизм
Полиморфизм. Принцип DRY и WET
Понятие абстракции
Знакомство с абстрактными классами Python
Подмена методов в производном классе.
Полиморфные классы
Контейнерные типы.
Библиотечные модули collections и collections.abc
Применение контейнерных типов
Практикум: Имплементация новых методов

4.Алгоритмы сортировки и поиска в Python
Сложность алгоритмов, O(N) нотация. Типы сортировки.
Основные алгоритмы сортировки и поиска
Этапы разработки алгоритма
Разработка на Python оптимальных алгоритмов поиска
Оптимизация алгоритма
Практикум: Реализация на Python алгоритма решателя Судоку.
Решение 100 сложнейших Судоку

5.Алгоритмы поиска на графах
Введение в теорию графов, основные алгоритмы на графах
Теория графов. Представление графов в Python
Поиск в ширину
Поиск в глубину
Лабораторная работа: Имплементация графа на Python
Практикум: Нахождение кратчайшего пути проезда на примере графа станций московского метрополитена

6. Записи и данных. Работа с данными SQLite
Разработка структуры данных
Сохранение данных.
Список и запись. Записи и таблицы
Чтение и запись Понятие об объектно-реляционном соответствии
Хранение данных пользователей в СУБД Sqlite
Использование СУБД Sqlite для хранения данных графа московского метрополитена
Практикум: Хранение данных пользователей в СУБД Sqlite

7. Хранение данных вне программы
Понятие о структуре данных
Использование структуры для хранения данных
Хранение данных вне Python
Сохранение и восстановление данных.
Библиотечный модуль pickle и shelve
Практикум: Сохранение данных графа и использованием модуля pickle

8. Работа с данными JSON в Python
Знакомство с форматом JSON. Работа с форматом JSON в Python.
Сериализация и десериализация файлов JSON в Python.
Хранение данных вне Python
Сохранение данных в файл JSON
Практикум: Составление графа московского метрополитена на основе файла JSON

Другие курсы данной тематики

• Oracle Application Express Workshop I
• Java SE: Базовый
• Разработка распределенных приложений с использованием EJB 3
• Библиотека ReactJS
• Основы программирования на Python для сетевых инженеров
• Шаблоны проектирования (GoF). Редакция для Java
• Обзорно-практический курс по Java технологиям для базы данных Oracle 10,11 и Weblogic сервера
• Oracle Application Express Workshop II
• Расширенные возможности HTML5
• Программирование на C++

Полиморфизм в Python (с примерами)

В этом уроке мы узнаем о полиморфизме, различных типах полиморфизма и о том, как мы можем реализовать их в Python с помощью примеров.

Что такое полиморфизм?

Буквальное значение полиморфизма — условие появления в различных формах.

Полиморфизм — очень важная концепция в программировании. Это относится к использованию сущности одного типа (метода, оператора или объекта) для представления разных типов в разных сценариях.

Давайте рассмотрим пример:

Пример 1: Полиморфизм в операторе сложения

Мы знаем, что оператор + широко используется в программах Python. Но у него нет одноразового использования.

Для целочисленных типов данных оператор + используется для выполнения арифметической операции сложения.

 число1 = 1
число2 = 2
печать (число1+число2)
 

Следовательно, приведенная выше программа выводит 3 .

---

Аналогично, для строковых типов данных 9Оператор 0015 + используется для выполнения конкатенации.

 стр1 = "Питон"
str2 = "Программирование"
печать (стр1+" "+стр2)
 

В результате вышеуказанная программа выводит Python Programming .

Здесь мы видим, что один оператор + использовался для выполнения различных операций с различными типами данных. Это одно из самых простых проявлений полиморфизма в Python.

---

Полиморфизм функций в Python

В Python есть некоторые функции, совместимые с несколькими типами данных.

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

Пример 2: Полиморфная функция len()

 print(len("Programiz"))
print(len(["Python", "Java", "C"]))
print(len({"Имя": "Джон", "Адрес": "Непал"}))
 

Выход

  9
3
2
  

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

Полиморфизм в функции len() в Python

---

Полиморфизм классов в Python

Полиморфизм — очень важная концепция объектно-ориентированного программирования.

Чтобы узнать больше об ООП в Python, посетите: Python Object-Oriented Programming

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

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

Пример 3: Полиморфизм в методах класса

 class Cat:
    def __init__(я, имя, возраст):
        self.name = имя
        возраст = возраст
    информация о защите (я):
        print(f"Я кошка. Меня зовут {self.name}. Мне {self.age} лет.")
    определение make_sound (я):
        распечатать("Мяу")
класс Собака:
    def __init__(я, имя, возраст):
        self.name = имя
        возраст = возраст
    информация о защите (я):
        print(f"Я собака. Меня зовут {self.name}. Мне {self.age} лет.")
    определение make_sound (я):
        печать("Кора")
cat1 = Кошка ("Китти", 2.5)
dog1 = Собака("Пушистый", 4)
для животного в (cat1, dog1):
    животное.make_sound()
    животное.информация()
    животное.make_sound()
 

Выход

  Мяу
Я кот. Меня зовут Китти. Мне 2,5 года.
мяу
Лаять
Я собака. Меня зовут Флаффи. Мне 4 года.
Лаять
  

Здесь мы создали два класса Cat и Dog . Они имеют схожую структуру и имена методов info() и make_sound() .

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

---

Полиморфизм и наследование

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

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

Рассмотрим пример:

Пример 4. Переопределение метода

 из math import pi
Форма класса:
    def __init__(я, имя):
        self. name = имя
    область защиты (я):
        проходить
    деф факт(я):
        return "Я двумерная форма."
    защита __str__(я):
        вернуть себя.имя
Класс Квадрат (Форма):
    def __init__(я, длина):
        super().__init__("Квадрат")
        собственная длина = длина
    область защиты (я):
        вернуть self.length**2
    деф факт(я):
        return "Каждый угол квадрата равен 90 градусов».
класс Круг (Форма):
    def __init__(я, радиус):
        super().__init__("Круг")
        self.radius = радиус
    область защиты (я):
        вернуть pi*self.radius**2
а = квадрат (4)
б = круг(7)
печать (б)
печать (b.fact())
печать (a.fact())
печать (б. область ())
 

Выход

  Круг
Я двухмерная форма.
У квадратов каждый угол равен 90 градусов.
153.93804002589985
  

Здесь мы видим, что такие методы, как __str__() , которые не были переопределены в дочерних классах, используются из родительского класса.

Из-за полиморфизма интерпретатор Python автоматически распознает, что метод fact() для объекта a (класс Square ) переопределен. Таким образом, он использует тот, который определен в дочернем классе.

С другой стороны, поскольку метод fact() для объекта b не переопределен, он используется из класса Parent Shape .

Полиморфизм в родительских и дочерних классах в Python

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

Объектно-ориентированное программирование на Python: обучение на примерах

В этом руководстве рассказывается об объектно-ориентированном программировании (ООП) на Python с примерами. Это пошаговое руководство, предназначенное для людей, не имеющих опыта программирования. Объектно-ориентированное программирование популярно и доступно на других языках программирования, помимо Python, таких как Java, C++, PHP.

Что такое объектно-ориентированное программирование?

В объектно-ориентированном программировании (ООП) у вас есть возможность представлять в своем коде объекты реального мира, такие как автомобиль, животное, человек, банкомат и т. д. Простыми словами, объект – это то, что обладает некоторыми характеристиками и может выполнять определенные функции. Например, автомобиль является объектом и может выполнять такие функции, как запуск, остановка, движение и торможение. Это функции автомобиля. И характеристики это цвет автомобиля, пробег, максимальная скорость, год выпуска и т.д.

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

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

Используют ли специалисты по данным объектно-ориентированное программирование?

Это один из самых распространенных вопросов, который возникает у ученых, занимающихся данными, перед изучением ООП. Когда дело доходит до манипулирования данными и машинного обучения с использованием Python, обычно рекомендуется изучать библиотеки pandas, numpy, matplotlib, scikit-learn. Эти библиотеки были написаны опытными разработчиками Python для автоматизации или упрощения большинства задач, связанных с наукой о данных. Все эти библиотеки зависят от ООП и его концепций. Например, вы строите регрессионную модель, используя библиотеку scikit-learn. Сначала вы должны объявить свою модель как объект, а затем использовать метод подгонки. Не зная основ ООП, вы не сможете понять, почему вы пишете код таким образом.

В python в основном существует 3 стиля программирования: объектно-ориентированное программирование, функциональное программирование и процедурное программирование. Проще говоря, есть 3 разных способа решения проблемы в Python. Функциональное программирование наиболее популярно среди специалистов по данным, поскольку оно имеет преимущество в производительности. ООП полезен, когда вы работаете с большими кодовыми базами, а ремонтопригодность кода очень важна.

Вывод: Хорошо изучить основы ООП, чтобы понять, что стоит за библиотеками, которые вы используете. Если вы стремитесь стать отличным разработчиком Python и хотите создать библиотеку Python, вам необходимо изучить ООП (обязательно!). В то же время есть много специалистов по данным, которые не знакомы с концепциями ООП и все еще преуспевают в своей работе.

Основы: ООП в Python

В этом разделе мы подробно рассмотрим концепции, связанные с ООП в Python.

Объект и класс

Класс — это архитектура объекта. Это правильное описание атрибутов и методов класса. Например, дизайн автомобиля одного типа — это класс. Вы можете создать множество объектов из класса. Как вы можете сделать много автомобилей одного и того же типа из конструкции автомобиля.

Существует множество реальных примеров классов, описанных ниже —

• Рецепт омлета — это класс. Омлет — это объект.
• Владелец банковского счета — это класс. Атрибутами являются Имя, Фамилия, Дата рождения, Профессия, Адрес и т. д. Методы могут быть «Смена адреса», «Смена профессии», «Смена фамилии» и т. д. «Смена фамилии» обычно применима к женщин, когда они меняют фамилию после замужества
• Собака — это класс. Атрибуты: Порода, Количество ног, Размер, Возраст, Цвет и т. д. Методы могут быть Едят, Спят, Сидят, Лают, Бегают и т. д.

В python мы можем создать класс, используя ключевое слово class . Метод класса может быть определен ключевым словом def . Она похожа на обычную функцию, но определена внутри класса и является функцией класса. Первым параметром в определении метода всегда является self и метод вызывается без параметра self .

Пример 1: Создать класс автомобиля

• класс : автомобиль
• атрибуты : год, мили на галлон и скорость
• методы : ускорение и торможение
• объект : автомобиль1

класс автомобиля:
    
    # атрибуты
        year = 2016 # год выпуска модели автомобиля
        миль на галлон = 20 # пробег
        скорость = 100 # текущая скорость
        
    # методы
        Ускорение по определению (само):
            вернуть автомобиль. скорость + 20
        деф тормоз(сам):
            скорость возврата автомобиля - 50
 

автомобиль1=автомобиль()
car1.ускорить()
120
car1.тормоз()
50
автомобиль1.год
2016
машина1.миль на галлон
20
автомобиль1.скорость
100
 

Для отправки методов нам нужно использовать круглые скобки.

Пример 2: Создание класса компании

В приведенном ниже примере мы создаем класс с именем company. Здесь атрибутами являются название, оборот, выручка и количество сотрудников, работающих в компании. Метод — доход, полученный на одного работника (назовем его производительность для демонстрационных целей).

# Создает класс Company
класс Компания:
    
    # атрибуты
    имя = "Банк XYZ"
    оборот = 5000
    доход = 1000
    количество_сотрудников = 100
    
    # метод
    Производительность по определению (я):
        вернуть Company.revenue/Company.no_of_employees
 

Атрибуты, определенные вне метода, могут быть извлечены без создания объекта.

Название компании
  Выход 
«XYZ Банк»
Компания.оборот
  Выход 
5000
Company.no_of_employees
  Выход 
100
Компания().производительность()
  Выход 
10,0
 

Конструктор

Конструктор — это специальный метод. Вы можете думать о ней как о функции, которая инициализирует или активирует атрибуты или свойства класса для объекта. Используйте ключевое слово __init__ для создания метода для конструктора. В предыдущем разделе мы обсуждали пример автомобиля как объекта. Вы можете думать о конструкторе как о полной последовательности действий, необходимых для того, чтобы фабрика построила объект автомобиля из шаблона проектирования класса. self представляет тот объект, который наследует эти свойства.

Объекты являются экземплярами класса. Слова «экземпляр» и «объект» взаимозаменяемы. Процесс создания объекта класса называется экземпляр .

В следующем примере мы просим пользователя ввести значения. __init__ вызывается всякий раз, когда создается объект класса.

классный человек:
        def __init__(я,имя,фамилия):
            self.first = имя
            self.last = фамилия
мое имя = человек ("Дипаншу", "Бхалла")
распечатать (мое имя.последнее)
 

Мы создали myname объект класса person.

 При создании нового объекта >>> вызывается метод __init__ >>> Поведение внутри метода __init__ выполняется 

Возьмем другой пример. Здесь приведенная ниже программа возвращает выходные данные на основе метода, определенного в классе

.
класс Моя компания:
        
    # методы
    def __init__(я, название компании, доход, размер сотрудников):
        self.name = название компании
        собственный доход = доход
        self.no_of_employees = количество сотрудников
    Производительность по определению (я):
        вернуть self.revenue/self.no_of_employees
Моя компания('Банк XYZ', 1000,100).производительность()
  Выход 
10,0
MyCompany('ABC Bank', 5000,200). productivity()
  Выход 
25,0
 

Альтернативный способ вызова метода класса

Банк = MyCompany('ABC Bank', 5000,200)
MyCompany.productivity(Банк)
 

Переменные

Атрибуты класса также называются переменными. Существует два вида переменных: одна объявляется внутри класса, но вне методов класса, а другая объявляется внутри __init__ .

При использовании метода __int__ доступ к переменным возможен только после создания объекта. Эти переменные называются Переменные экземпляра или локальные переменные. Тот, который определен вне методов, называется переменными класса или глобальными переменными. Вы можете получить доступ к этим переменным в любом месте класса. Посмотрите разницу в примере ниже.

класс Моя компания:
    #Переменная класса
    рост = 0,1
            
    def __init__(я, название компании, доход, размер сотрудников):
        #Переменные экземпляра
        self.name = название компании
        собственный доход = доход
        self. no_of_employees = количество сотрудников
МояКомпания.рост
  0,1 
 

Как получить переменную дохода из класса MyCompany?

Неправильный путь

Моя компания.доход
 

AttributeError: объект типа «Моя компания» не имеет атрибута «доход»

Правильный путь

Банк = МояКомпания('Банк DBA',50000, 1000)
Банк.доход
 

50000

MyCompany.revenue возвращает ошибку, поскольку к ней невозможно получить доступ, поскольку объект не создан.

Методы

В python есть три типа методов: экземпляр, класс и статический.

• Экземпляр принимает self в качестве первого аргумента. Их также называют Object или обычным методом . Это тот же метод, который мы уже изучили в предыдущих разделах.
• Класс принимает cls в качестве первого аргумента. cls относится к классу. Чтобы получить доступ к переменной класса в методе, мы используем метод @classmethod 9. декоратор 0016 и передать класс методу
• Статический ничего не принимает в качестве первого аргумента. Он имеет ограниченное использование, которое объясняется в последней части этой статьи.

Чем отличаются методы экземпляра и класса?

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

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

Здесь мы создаем 3 метода: rateperkm , noofcabs , avgnoofpassengers . Первый — это метод экземпляра, а два других — методы класса.

• рейтперкм возвращает стоимость проезда на такси за км, которая рассчитывается путем деления общей суммы счета на номер. км пройдено кабиной.
• noofcabs возвращает количество работающих кабин. Подумайте об агентстве такси, которое владеет множеством такси и хочет знать, сколько такси занято
.
• avgnoofpassengers возвращает среднее количество пассажиров, путешествующих в автомобиле. Для расчета среднего значения учитываются все работающие кабины и количество пассажиров в каждой кабине.

Кабина класса:
    
    #Инициализировать переменные для первой итерации
    количество кабин = 0
    количество пассажиров = 0
    def __init__(я,водитель,км,места,оплата,пассажиры):
        self.driver = водитель
        автономный пробег = км
        self. places = места
        селф.билл = платить
        Cab.numberofcabs = Cab.numberofcabs + 1
        Cab.numpassengers = Cab.numpassengers + пассажиры
    #Возвращает цену такси за км
    def rateperkm(я):
        возврат self.bill/self.running
        
    #Возвращает количество работающих кабин
    @классметод
    определение noofcabs (cls):
        вернуть cls.numberofcabs
    #Возвращает среднее количество пассажиров в кабине
    @классметод
    определение avgnoofpassengers (cls):
        вернуть целое (cls.numpassengers/cls.numberofcabs)
firstcab = Cab("Рамеш", 80, ['Дели', 'Нойда'], 2200, 3)
secondcab = Cab("Суреш", 60, ['Гургаон', 'Нойда'], 1500, 1)
Thirdcab = Cab("Дэйв", 20, ['Гургаон', 'Нойда'], 680, 2)
firstcab.водитель
  'Рамеш'
 
водитель второго такси
  'Суреш'
 
третий каб.водитель
  'Дэйв'
  

firstcab.rateperkm()
  27,5 
secondcab.rateperkm()
  25,0 
Thirdcab.rateperkm()
  34,0 
 

Кабина.noofcabs()
  3
 
Cab. avgnoofpassengers()
  2
  

Cab.avgnoofpassengers() возвращает 2, что вычисляется как (3 + 1 + 2)/3

Статические методы

Статический метод является наименее популярным среди всех трех методов. В отличие от методов экземпляра и класса, статический метод не принимает в качестве первого параметра специальное ключевое слово (self, cls). Он имеет ограниченное использование, потому что ни вы не можете получить доступ к свойствам экземпляра (объекта) класса, ни вы не можете получить доступ к атрибутам класса. Единственное использование - его можно вызывать без объекта. Это в основном полезно для создания вспомогательных или служебных функций, таких как проверка имени водителя (имя водителя должно быть меньше 32 символов) или сумма счета должна быть больше нуля (не может быть отрицательной или нулевой). См. программу ниже для той же задачи.

Кабина класса:
    
    @статический метод
    деф биллинга (оплата):
        возврат int (оплата)> 0
Cab. billvalidation(0,2)
  Выход 
ЛОЖЬ
 

Наследство

Наследование использует код для класса Children , который уже был написан для класса Parent . Например, некоторые атрибуты класса транспортного средства совпадают с классами автомобилей, автобусов и грузовиков. Имя водителя, количество колес и т. д. одинаковы для всех классов. Транспортное средство родительского класса и Автомобиль, автобус и грузовик детей классов . В ООО это означает, что класс наследует атрибуты и методы поведения от своего родительского класса.

• Создайте родительский класс Vehicle и используйте его атрибуты для дочернего класса Vehicle . В приведенной ниже программе нам не нужно указывать атрибуты класса cab. Он наследуется от транспортного средства.

класс Транспортное средство:
    def __init__(я,водитель,колеса,сиденья):
        self.driver = водитель
        self.noofwheels = колеса
        self. noofseats = места
класс Кабина(Автомобиль):
    проходить
cab_1 = Кабина («Сэнди», 4, 2)
кабина_1.водитель
  Выход 
'Сэнди'
 

Как изменить переменную класса подкласса Транспортное средство

класс Транспортное средство:
    минимальная ставка = 50
    def __init__(я,водитель,колеса,сиденья):
        self.driver = водитель
        self.noofwheels = колеса
        self.noofseats = места
класс Кабина(Автомобиль):
    минимальная ставка = 75
Транспортное средство.минимальная ставка
  50 
Минимальная ставка кабины
  75 
 

Как создать дочерний класс с большим количеством параметров, чем у родительского класса

В этом примере у нас есть два класса Cab и Bus , у которых много схожих атрибутов, но есть несколько уникальных для данного класса. Чтобы решить эту проблему, мы создали родительский класс с именем Vehicle , который содержит общие атрибуты и метод.

класс Транспортное средство:
    минимальная ставка = 50
    def __init__(я,водитель,колеса,сиденья,км,счет):
        self. driver = водитель
        self.noofwheels = колеса
        self.noofseats = места
        автономный пробег = км
        селф.билл = счет
    
    def rateperkm(я):
        возврат self.bill/self.running
класс Кабина(Автомобиль):
    минимальная ставка = 75
    def __init__(я,водитель,колеса,сиденья,км,счет,тип кабины):
        Vehicle.__init__(я,водитель,колеса,сиденья,км,счет)
        self.category = тип такси
Класс Автобус(Автомобиль):
    минимальная ставка = 25
    def __init__(я,водитель,колеса,сиденья,км,счет,цвет):
        Vehicle.__init__(я,водитель,колеса,сиденья,км,счет)
        self.color = цвет
cab_1 = Cab('Prateek', 4, 3, 50, 700, 'Внедорожник')
cab_1.категория
cab_1.rateperkm()
bus_1 = Bus('Дэйв', 4, 10, 50, 400, 'зеленый')
bus_1.цвет
bus_1.rateperkm()
 

Мы можем заменить эту команду Vehicle.__init__(я,водитель,колеса,сиденья,км,счет) на super().__init__(водитель,колеса,сиденья,км,счет) .
super() используется для ссылки на родительские атрибуты и методы.

Полиморфизм

Полиморфизм означает способность принимать различные формы. Это важная концепция, когда вы имеете дело с дочерним и родительским классами. Полиморфизм в python применяется через переопределение метода и перегрузку метода .

Переопределение метода

Переопределение метода позволяет нам иметь метод в дочернем классе с тем же именем, что и в родительском классе, но определение метода дочернего класса отличается от метода родительского класса.

класс Транспортное средство:
    защитное сообщение (я):
        print("Метод родительского класса")
класс Кабина(Автомобиль):
    защитное сообщение (я):
        print("Метод класса дочерней кабины")
Класс Автобус(Автомобиль):
    защитное сообщение (я):
        print("Метод класса дочерней шины")
х = Транспортное средство ()
х.сообщение()
  Метод родительского класса 
у = кабина ()
у.сообщение()
  Метод класса дочерней кабины 
г = автобус ()
z.сообщение()
  Метод класса дочерней шины 
 

Как вы можете видеть вывод, показанный выше, дочерние классы переопределяют метод родительского класса.

Перегрузка метода

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

В приведенном ниже сценарии метод может быть вызван без параметра (игнорируя параметр фразы). Или его можно вызвать с параметром , фразой .

Сообщение класса:
    детали защиты (я, фраза = нет):
    
        если фраза не None:
            print('Мое сообщение - ' + фраза)
        еще:
            print('Добро пожаловать в мир Python')
        
# Объект
х = сообщение ()
    
# Вызов метода без параметров
х.детали()
    
# Вызов метода с параметром
x.details('Жизнь прекрасна')
 

Что такое __str__?

Он используется для создания удобочитаемого представления объекта.

класс Транспортное средство:
    def __init__(я,водитель,колеса,сиденья):
        self. driver = водитель
        self.noofwheels = колеса
        self.noofseats = места
veh_1 = Автомобиль ("Песчаный", 4, 2)
печать (veh_1)
  Выход 
 __main__.Объект транспортного средства по адресу 0x0000019ECCCA05F8
 

класс Транспортное средство:
    def __init__(я,водитель,колеса,сиденья):
        self.driver = водитель
        self.noofwheels = колеса
        self.noofseats = места
    защита __str__(я):
        return "Имя водителя:" + self.driver + ";" + "Количество мест в кабине:" + str(self.noofseats)
veh_1 = Автомобиль ("Песчаный", 4, 2)
печать (veh_1)
  Выход 
Имя водителя: Сэнди;
Количество мест в кабине: 2
 

Инкапсуляция данных

Инкапсуляция данных означает ограничение доступа к методам и переменным. Это может предотвратить случайное (ошибочное) изменение данных.

• Когда мы используем два символа подчеркивания '__' перед именем атрибута, это делает атрибут недоступным за пределами класса. Он становится закрытым атрибутом , что означает, что вы не можете читать и записывать эти атрибуты, кроме как внутри класса. Обычно используется разработчиком модуля.
• Если вы не используете подчеркивание перед атрибутом, это общедоступный атрибут , доступ к которому можно получить внутри или вне класса.

класс Квартира:
    защита __init__(сам):
        self.type = "премиум"
        self.__bhk = "3 BHK"
flat_1 = Квартира()
квартира_1.тип
премия
flat_1.__bhk
AttributeError: объект «Плоский» не имеет атрибута «__bhk»
 

В приведенной выше программе type является общедоступным атрибутом, а bhk — приватным атрибутом, к которому нельзя получить доступ за пределами класса.

Добытчики и сеттеры

Они используются для получения и обновления значения переменной. Сеттер — это метод, который обновляет значение переменной. Getter — это метод, который считывает значение переменной. Давайте узнаем это на примерах.

класс Транспортное средство:
    def __init__(я,имя_водителя,фамилия_водителя):
        self.fdriver = имя_водителя
        self.ldriver = фамилия_водителя
        self. email = self.fdriver + '.' + self.ldriver + '@uber.com'
veh_1 = Автомобиль ("Сэнди", "Стюарт")
veh_1.fдрайвер
  Сэнди 
veh_1.email
  'Сэнди.Стюарт@uber.com'
 
 

Здесь мы обновляем имя водителя, но это не влияет на адрес электронной почты, который представляет собой комбинацию имени и фамилии.

veh_1.fdriver = 'Том'
veh_1.fдрайвер
  'Том' 
veh_1.email
  'Сэнди.Стюарт@uber.com'
  

Имя было изменено с Сэнди на Том, но адрес электронной почты остался прежним. Хорошо, возникает очевидный вопрос «как обновить адрес электронной почты?». С использованием @property декоратор мы можем изменить поведение электронной почты. email(self) — это метод, но он работает как обычное свойство. Этот специальный метод называется Getters and Setters

.
класс Транспортное средство:
    def __init__(я,имя_водителя,фамилия_водителя):
        self.fdriver = имя_водителя
        self.ldriver = фамилия_водителя
        
    @свойство
    адрес электронной почты (я):
        вернуть self. fdriver + '.' + self.ldriver + '@uber.com'
veh_1 = Автомобиль ("Сэнди", "Стюарт")
veh_1.fdriver = 'Том'
veh_1.email
  '[email protected]' 
 

Как автоматически обновить имя и фамилию, изменив адрес электронной почты

класс Транспортное средство:
    def __init__(я,имя_водителя,фамилия_водителя):
        self.fdriver = имя_водителя
        self.ldriver = фамилия_водителя
        
    @свойство
    адрес электронной почты (я):
        вернуть self.fdriver + '.' + self.ldriver + '@uber.com'
    @email.setter
    адрес электронной почты (я, адрес):
        первый = адрес[:address.find('.')]
        последний = адрес[address.find('.')+1:address.find('@')]
        self.fdriver = первый
        self.ldriver = последний
veh_1 = Автомобиль ("Сэнди", "Стюарт")
veh_1.email = '[email protected]'
veh_1.fдрайвер
  'глубокий' 
veh_1.lдрайвер
  'бхалла' 
 

Валидация

В реальном мире геттеры и сеттеры в основном используются для включения логики проверки. В приведенном ниже примере мы создаем класс пожертвований с атрибутом суммы. Сумма должна находиться в диапазоне от 10 до 1 000 000. Если пользователь вводит меньше 10, оно должно быть установлено как 10. Точно так же, если пользователь пытается ввести значение больше 1 миллиона, оно должно быть ограничено только 1 миллионом.

пожертвование класса:
    def __init__(я, количество):
        самостоятельная сумма = сумма
        
    @свойство
    Сумма защиты (я):
        вернуть себя.__сумма
    @amount.setter
    сумма защиты (я, сумма):
        если сумма 1000000:
            сам.__сумма = 1000000
        еще:
            self.__amount = количество
благотворительность = пожертвование (5)
благотворительность.сумма
  10 
 

Как импортировать класс

В этом разделе мы расскажем, как загрузить класс из другого файла или каталога.

1. Сохраните следующий скрипт как Mymodule.py

"""
Класс автомобиля
"""
Кабина класса:
    
    #Инициализировать для первой итерации
    количество кабин = 0
    def __init__(я,водитель,км,оплата):
        self. driver = водитель
        автономный пробег = км
        селф.билл = платить
        Cab.numberofcabs = Cab.numberofcabs + 1
    #Возвращает среднюю цену за км
    def rateperkm(я):
        возврат self.bill/self.running
        
    #Возвращает количество работающих кабин
    @классметод
    определение noofcabs (cls):
        вернуть cls.numberofcabs
если __name__ == "__main__":
    
    #Класс кабины
    firstcab = Cab("Рамеш", 80, 1200)
    Атрибут #driver в классе Cab
    печать (firstcab.driver)
    
    #метод класса
    печать (Cab.noofcabs())
 

2. В приведенном ниже коде укажите каталог, в котором хранится файл Mymodule.py

импорт ОС
os.chdir("C:/Пользователи/DELL/Рабочий стол/")
импортировать мой модуль
 

3. Создайте объект или запустите методы, как обычно. Обязательно добавьте имя модуля в качестве префикса перед использованием класса и метода класса
.

#Класс кабины в Mymodule.py
firstcab = Mymodule.Cab("Рамеш", 80, 1200)
Атрибут #driver в классе кабины
firstcab. водитель
Метод экземпляра #rateperkm в Mymodule2.py
firstcab.rateperkm()
Метод класса #noofcabs в Mymodule2.py
Мой модуль.Cab.noofcabs()
 

Чтобы избежать написания имени модуля для доступа к классу, вы можете использовать «из», который загружает модуль в текущее пространство имен.

из импорта Mymodule *
firstcab = Cab("Сэнди", 80, ['Дели', 'Нойда'], 1200, 3)
 

Что такое __name__ == "__main__"?

Любой код внутри , если __name__ == '__main__': , будет выполняться, когда вы запускаете файл .py напрямую (из терминала).

Если вы импортируете модуль , импортируйте Mymodule , код внутри if __name__ == '__main__': не будет запущен.

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

если __name__ == '__main__':
    print('Первый результат')
еще:
    print('Второй результат')
 

Как изменить каталог в командной строке

Введите cd , затем пробел и имя папки.

No related posts.