Основные понятия объектно-ориентированного программирования на python.

машинное обучение глубокое обучение компьютерное зрение NLP

Автор|ХИМАНШИ СИНГХ Компилировать|ВКонтакте Источник | Аналитика Видья

вводить

Изучая объектно-ориентированное программирование, я решил углубиться в его историю и нашел его увлекательным. Термин «объектно-ориентированное программирование» (ООП) был придуман Аланом Кеем в 1966 году, когда он учился в аспирантуре.

Язык Simula — первый язык программирования с характеристиками объектно-ориентированного программирования. Он был разработан в 1967 году для создания программ моделирования, в которых самая важная информация называется объектами.

Хотя OOPS существует на рынке с начала 1960-х годов, в 1990-х OOPS начал расти благодаря C++.

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

Итак, в этой статье я объясню основные концепции объектно-ориентированного программирования на Python.

содержание

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

  2. Объектно-ориентированное программирование (ООП) и процедурное программирование (POP)

  3. Основные концепции ООП

    1. Что такое класс?
    2. Объекты и создание объектов
    3. метод класса
    4. Наследование в классах Python
    5. упаковка
    6. полиморфизм
    7. абстракция данных

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

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

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

Другой пример - если рассматривать собаку как объект, то ее свойства - цвет, порода, имя, вес и т.д., а ее поведение/функция - ходить, лаять, играть и т.д.

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

Объектно-ориентированное программирование (ООП) и процедурное программирование (POP)

Основное различие между ООП и процедурным программированием заключается в том, что

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

  • А ООП-программы состоят из объектов. Объектно-ориентированный подход делит программу на объекты. Эти объекты представляют собой сущности, которые связывают вместе свойства и поведение объектов реального мира.

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

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

  • Такие языки программирования, как C, Pascal и Basic, используют процедурный подход, тогда как java, Python, JavaScript, PHP, Scala и C++ являются основными языками, обеспечивающими объектно-ориентированный подход.

Основные концепции ООП

В этом разделе мы углубимся в основные концепции ООП. Мы обсудим следующие темы

  1. своего рода

  2. объект

  3. метод

  4. наследовать

  5. упаковка

  6. полиморфизм

  7. абстракция данных

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

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

Давайте посмотрим, как определить следующий класс

class class_name:
    class body

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

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

class Car:
    pass

это все!

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

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

2. Объекты и создание объектов

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

Создание экземпляра — это создание экземпляра класса. Давайте создадим объект определенного выше класса —

obj1 = Car()

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

попробуйте распечатать этот объект

print(obj1)

Поскольку наш класс пуст, он возвращает адрес, по которому хранится объект, то есть 0x7fc5e677b6d8.

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

конструктор класса

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

Автомобиль может иметь различные атрибуты, такие как имя, цвет, модель, марка, мощность двигателя, вес, цена и т. д. Мы выделим лишь некоторые из них для простоты понимания.

class Car:
    def __init__(self, name, color):
        self.name = name
        self.color = color

Следовательно, свойства автомобиля или любого другого объекта должны быть в методе, который мы вызываем **__init__()**. Этот метод также известен как метод конструктора. Метод конструктора вызывается всякий раз, когда создается объект класса.

Теперь давайте обсудим параметры метода **__init__()**. Итак, первый параметр этого метода должен быть self. Потом остальные параметры

Два оператора в методе конструктора:

  1. self.name = name
  2. self.color = color:

Это создаст новые свойства, имя и цвет, а затем присвоит им значение параметра. Ключевое слово «я» представляет экземпляр класса. Используя ключевое слово «я», мы можем получить доступ к свойствам и методам класса. Это полезно в определениях методов и инициализации переменных. «self» используется явно каждый раз, когда определяется метод.

Примечание. Вы также можете создавать свойства вне этого метода. Но эти свойства являются общими для всего класса и должны иметь значение.

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

class Car:
    car_type = "Sedan"                 #类属性
    def __init__(self, name, color):
        self.name = name               #实例属性
        self.color = color             #实例属性

Здесь атрибуты экземпляра относятся к атрибутам в методе конструктора, в данном случае self.name и self.color. Атрибуты класса — это атрибуты вне метода конструктора, в данном случае car_type.

3. Методы класса

На данный момент мы добавили свойства автомобиля. Теперь пришло время добавить немного поведения. Методы — это функции, которые мы используем для описания поведения объектов. Они также определены в классе. Пожалуйста, смотрите код ниже

class Car:   
    car_type = "Sedan" 

    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage 

    def description(self):                 
        return f"The {self.name} car gives the mileage of {self.mileage}km/l"

    def max_speed(self, speed):
        return f"The {self.name} runs at the maximum speed of {speed}km/hr"

Методы, определенные в классе (а не методы конструктора), называются методами экземпляра. Кроме того, здесь есть два метода экземпляра: description() и max_speed().

  • description() — этот метод возвращает строку, содержащую описание автомобиля, например название и пробег. Этот метод не имеет дополнительных параметров. Этот метод использует свойства экземпляра.
  • max_speed() — этот метод имеет дополнительный параметр и возвращает строку, показывающую название транспортного средства и его скорость.

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

obj2 = Car("Honda City",24.1)
print(obj2.description())
print(obj2.max_speed(150))

Что мы делаем, так это создаем объект класса car и передаем необходимые параметры. Чтобы использовать object_name.method_name().

Метод description() не имеет дополнительных параметров, поэтому при его вызове никакие параметры не передаются.

У метода max_speed() есть дополнительный параметр, поэтому при его вызове мы передаем аргумент.

Примечание: три важных момента, о которых следует помнить

  1. Может быть создано любое количество объектов класса.

  2. Ошибка возникает, если метод требует n аргументов, а вы не передаете одинаковое количество аргументов.

  3. Порядок аргументов важен.

Давайте посмотрим один за другим

  1. Создание нескольких объектов класса
class Car:
    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage 

    def max_speed(self, speed):
        return f"The {self.name} runs at the maximum speed of {speed}km/hr"

Honda = Car("Honda City",21.4)
print(Honda.max_speed(150))

Skoda = Car("Skoda Octavia",13)
print(Skoda.max_speed(210))

  1. неправильное количество параметров
class Car:

    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage

Honda = Car("Honda City")
print(Honda)

Мы получили эту ошибку, потому что не указали второй параметр.

  1. порядок параметров
class Car:

    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage 

    def description(self):                
        return f"The {self.name} car gives the mileage of {self.mileage}km/l"

Honda = Car(24.1,"Honda City")
print(Honda.description())

смущенный! Потому что мы изменили порядок аргументов.

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

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

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

Интересно, что в дополнение к унаследованным свойствам и методам подклассы могут иметь свои собственные свойства и методы.

Как наследовать родительский класс? Используйте следующий синтаксис:

class parent_class:
body of parent class

class child_class( parent_class):
body of child class

Посмотрим на реализацию

class Car:          #父类

    def __init__(self, name, mileage):
        self.name = name 
        self.mileage = mileage 

    def description(self):                
        return f"The {self.name} car gives the mileage of {self.mileage}km/l"

class BMW(Car):     #子类
    pass

class Audi(Car):     #子类
    def audi_desc(self):
        return "This is the description method of class Audi."

obj1 = BMW("BMW 7-series",39.53)
print(obj1.description())

obj2 = Audi("Audi A8 L",14)
print(obj2.description())
print(obj2.audi_desc())

Мы создали два подкласса, а именно «BMW» и «Audi», которые наследуют методы и свойства родительского класса «Car». Мы не предоставляем дополнительные возможности и функции в классе BMW. И дополнительный метод внутри Audi.

Обратите внимание, как объекты подкласса получают доступ к методу экземпляра description() суперкласса с помощью obj1.description() и obj2.description(). Кроме того, доступ к отдельным методам класса Audi можно получить с помощью obj2.Audi_desc().

5. Упаковка

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

Вы можете объявить защищенный метод или свойство, поставив перед именем метода или свойства знак подчеркивания (_). Например, self._name или def _method(); в обеих строках указано, что атрибуты и методы защищены и не должны использоваться вне доступа класса и подкласса, но вместо этого могут быть доступны методами и объектами класса.

Python просто использует '_' как соглашение о кодировании, чтобы сообщить вам, что эти атрибуты/методы должны использоваться в рамках класса. Вы по-прежнему можете обращаться к переменным и методам, определенным как защищенные, как обычно.

Теперь, чтобы фактически предотвратить доступ к свойствам/методам из-за пределов области действия класса, можно использовать «закрытые члены». Чтобы объявить свойство/метод закрытым членом, используйте двойное подчеркивание ( __ ) в префиксе. Например — self.__name или def __method(), в обеих строках указано, что свойства и методы являются приватными и не могут быть доступны извне класса.

class car:

    def __init__(self, name, mileage):
        self._name = name                #受保护属性
        self.mileage = mileage 

    def description(self):                
        return f"The {self._name} car gives the mileage of {self.mileage}km/l"

obj = car("BMW 7-series",39.53)

#通过类方法访问受保护变量
print(obj.description())

#直接从外部访问受保护变量
print(obj._name)
print(obj.mileage)

Обратите внимание, как мы можем получить доступ к защищенной переменной без каких-либо ошибок. Очевидно, что доступ к переменным по-прежнему открыт. Посмотрим, как работает инкапсуляция.

class Car:

    def __init__(self, name, mileage):
        self.__name = name              #私有变量
        self.mileage = mileage 

    def description(self):                
        return f"The {self.__name} car gives the mileage of {self.mileage}km/l"

obj = Car("BMW 7-series",39.53)

#通过类方法访问私有变量
print(obj.description())

#直接从外部访问私有变量
print(obj.mileage)
print(obj.__name)

Когда мы попытались получить доступ к приватной переменной с помощью метода description(), мы не обнаружили никаких ошибок. Но когда мы пытаемся получить доступ к приватной переменной непосредственно вне класса, Python выдает ошибку: объект car не имеет атрибута ''__name'.

Вы по-прежнему можете получить доступ к свойству напрямую, используя его оформленное имя.Name mangling(изменение имени) — это механизм доступа к членам класса извне. Интерпретатор Python заменяет любой идентификатор с «__var» на «_ClassName__var». Используя это, вы можете получить доступ к членам класса извне.

class Car:

    def __init__(self, name, mileage):
        self.__name = name              #私有变量     
        self.mileage = mileage 

    def description(self):                
        return f"The {self.__name} car gives the mileage of {self.mileage}km/l"

obj = Car("BMW 7-series",39.53)

#通过类方法访问私有变量
print(obj.description())

#直接从外部访问私有变量
print(obj.mileage)
print(obj._car__name)      #名称修饰

Обратите внимание, что это правило предназначено для обработки определенных ситуаций, например, в отладчике. Но это не рекомендуется для обычного программирования

6. Полиморфизм

Полиморфизм — греческое слово. Если мы разберем термин «полиморфизм», мы получим формы «поли» (множественный) и «морф» (преобразование). Таким образом, полиморфизм означает, что существует несколько форм. В ООП это относится к функции с тем же именем, но с другой функциональностью.

class Audi:
  def description(self):
    print("This the description function of class AUDI.")

class BMW:
  def description(self):
    print("This the description function of class BMW.")

audi = Audi()
bmw = BMW()
for car in (audi,bmw):
 car.description()

При вызове функции с объектом audi будет вызываться функция класса audi, при вызове функции с объектом bmw будет вызываться функция класса bmw.

7. Абстракция данных

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

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

from abc import ABC

class abs_class(ABC):
    Body of the class

Важно отметить, что объекты-экземпляры нельзя создавать для абстрактных классов. Например-

from abc import ABC, abstractmethod

class Car(ABC):
    def __init__(self,name):
        self.name = name 

 @abstractmethod
    def price(self,x):
        pass

obj = Car("Honda City")

Теперь вопрос в том, как именно мы используем эту абстракцию. Ответ заключается в использовании наследования.

from abc import ABC, abstractmethod

class Car(ABC):
    def __init__(self,name):
        self.name = name

    def description(self):
        print("This the description function of class car.")

    @abstractmethod
    def price(self,x):
        pass
class new(Car):
    def price(self,x):
        print(f"The {self.name}'s price is {x} lakhs.")

obj = new("Honda City")

obj.description()
obj.price(25)

Автомобиль — это абстрактный класс, унаследованный от класса ABC модуля ABC. Обратите внимание, что у меня есть абстрактный метод (price()) и конкретный метод (description()) в абстрактном классе. Это связано с тем, что абстрактный класс может содержать оба типа функций, тогда как обычный класс не может. Другой класс, наследуемый от этого абстрактного класса, является новым. Метод price() нового заключается в том, что мы переопределяем метод цены абстрактного класса Car.

Определение метода цены в классе new() вступает в силу после того, как пользователь создает объект из класса new() и вызывает метод price(). Эти определения скрыты от пользователя. Абстрактные методы просто предоставляют объявление. Необходимо дать определение подкласса.

Однако, когда метод description() вызывается для объекта класса new() (т.е. obj), будет вызываться метод description() класса Car, поскольку он не является абстрактным методом.

конец

В заключение, в этой статье я представил основные понятия объектно-ориентированного программирования на Python. Теперь вы знаете ООП и основные понятия.

Оригинальная ссылка:Woohoo.Со слов аналитиков vi.com/blog/2020/0…

Добро пожаловать на сайт блога Panchuang AI:panchuang.net/

sklearn машинное обучение китайские официальные документы:sklearn123.com/

Добро пожаловать на станцию ​​сводки ресурсов блога Panchuang:docs.panchuang.net/

Категории