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

Python Программирование и разработка

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

Класс и объект

В объектно-ориентированном программировании класс используется для объявления пользовательской структуры данных, содержащей набор атрибутов. Атрибуты могут быть переменными класса, переменными экземпляра и методами. Переменные, доступные для всех экземпляров класса, называются переменными класса. Функции, объявленные внутри класса, называются методами. Переменные, определенные внутри любого метода класса и доступные текущему экземпляру класса, называются переменными экземпляра. Класс объявляется в Python путем определения ключевого слова class, за которым следует имя класса и двоеточие (:). Синтаксис класса определен ниже.

Синтаксис класса

class className:
Variables;
Methods;

Экземпляр или копия класса называется объектом, используемым для доступа к переменным класса и методам класса. Класс бесполезен без объявления объекта, потому что класс содержит только описание объекта, которое не выделяет никакой памяти. Объект объявляется упоминая имя класса с началом и концом первой скобки. Если класс содержит какой-либо метод конструктора с параметрами, тогда вы должны определить значение параметров во время объявления объекта. Синтаксис объекта приведен ниже.

Синтаксис объекта

Object_Name = Class_Name()

или же

Object_Name = Class_Name(value1, value2, …)

Объявление простого класса и объявление объекта этого класса показано в следующем скрипте. Здесь объявлен класс с именем Book, который содержит три переменные класса (book_name, author_name и price) и метод с именем book_discount_price (). Метод рассчитает стоимость книги после 5% скидки и распечатает детали книги с оригиналом и ценой со скидкой. Переменная объекта с именем objBook была определена в сценарии для создания экземпляра класса и вызова метода класса.

ClassAndObject.py

# Define the class
class Book:
# Define and initialize class variables
book_name = «Learn Python the Hard Way»
author_name = «Zed Shaw»
price = 22

# Define class method to display book details with discount price
def book_discount_price(self):
# Calculate the discount price after 5% discount
d_price = self.price — self.price * 0.05
# Print book details
print(«Book Name : {} \nAuthor Name : {}\nOriginal Price: ${}\nDiscount Price: ${}\n«
.format(self.book_name, self.author_name, self.price, d_price))

# Create an object of the class
objBook = Book()
print(«Book information after discount:»)
# Call the class method
objBook.book_discount_price()

Выход:

Следующий вывод появится после выполнения вышеуказанного сценария.

Конструктор

Конструктор — это метод класса, который вызывается автоматически при объявлении объекта этого класса. В основном он используется для инициализации объекта переменной. Ключевое слово def используется для объявления любого метода в объявлении класса Python, а имя метода конструктора — __init __ () в Python. В Python можно объявить два типа конструкторов. Это конструктор без параметров и конструктор с параметрами. Использование обоих конструкторов показано в этой части этого руководства.

А. конструктор без параметров

Конструктор, содержащий только один аргумент с именем self, называется конструктором без параметров или конструктором по умолчанию. Во время объявления объекта класса, который содержит конструктор без параметров, не требуется передавать никаких параметров. Способ объявления конструктора без параметров показан в следующем скрипте. Здесь класс Customer содержит конструктор без параметров, который инициализирует четыре переменные класса при создании любого объекта класса. Затем был объявлен объект класса objCustomer для доступа к переменным класса.

default_constructor.py

# Define Customer class
class Customer:
# Declare Constructor without parameter
def __init__(self):
# Initialize class variables
self.ID = ‘D-67455’
self.name = ‘Sakib Hasan’
self.account_type = ‘Saving’
self.balance = 5000000

# Create object of the Customer class
objCustomer = Customer()
print(«Customer’s Basic Information:\n«)
# Print the the values of the object properties
print(«ID: {}\nName: {}\nAccount Type: {}\nBalance: {}»
.format(objCustomer.ID, objCustomer.name, objCustomer.account_type, objCustomer.balance))

Выход:

Следующий вывод появится после выполнения вышеуказанного сценария.

Б. Параметризованный конструктор

Конструктор, содержащий один или несколько аргументов с аргументом self, называется параметризованным конструктором. Вы должны передать значения параметров во время создания объекта класса. Способ объявления параметризованного конструктора показан в следующем скрипте. Здесь класс Customer объявлен с параметризованным конструктором и двумя методами. Метод с именем balance_after_deposit () определен для добавления суммы депозита к балансу. Метод с именем balance_after_withdraw () определен для вычета суммы снятия с баланса. Затем определяется объектная переменная для отображения основных сведений о клиенте, баланса после депозита и баланса после снятия средств.

parameterized_constructor.py

# Define Customer class
class Customer:
# Declare Constructor with parameter
def __init__(self, cust_id, cust_name, cust_balance):
# Initialize variables
self.ID = cust_id
self.name = cust_name
self.balance = cust_balance

# Add amount with the balance
def balance_after_deposit(self, deposit_amount):
self.balance += deposit_amount
# Print the current balance
print(«Deposit Ammount: {}\nCurrent Balance: {}\n«.format(deposit_amount, self.balance))

# Subtract amount from the balance
def balance_after_withdraw(self, withdraw_amount):
self.balance —= withdraw_amount
# Print the current balance
print(«Withdraw Ammount: {}\nCurrent Balance: {}\n«.format(withdraw_amount, self.balance))

# Create object of the customer class
objCustomer = Customer(‘M-231234’, ‘Mir Sabbir’, 200000)

# Print the customer’s basic information
print(«Customer Details:\nID: {}\nName: {}\nOpening Balance: {}\n«
.format(objCustomer.ID, objCustomer.name, objCustomer.balance))

# Add the deposit amount
objCustomer.balance_after_deposit(30000)

# Subtract the withdrawal amount
objCustomer.balance_after_withdraw(10000)

Выход:

Следующий вывод появится после выполнения вышеуказанного сценария. Здесь начальное сальдо составляет 200000. Сальдо становится 220000 после добавления 30000 и вычитания 10000.

Наследование

Одна из основных функций объектно-ориентированного программирования — это наследование. Способ создания нового класса из существующего называется наследованием. Существующий класс называется родительским или базовым классом, а унаследованный новый класс называется дочерним или производным классом. Дочерний класс будет содержать функции базового класса после наследования. Как наследование может быть применено в классе Python, показано в следующем примере. В сценарии Student — это родительский класс, а StudentDetails — дочерний класс. Оба класса имеют параметризованные конструкторы. В родительском классе есть метод display basic () для печати идентификатора, имени и переменных электронной почты родительского класса. У дочернего класса есть метод с именем displayInfo ()для печати значений пакетных и семестровых переменных дочернего класса.

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

inheritance.py

# Define the parent class
class Student:

# Define the parent class constructor
def __init__(self, ID, name, email):
# Initialize the parent class variables
self.ID = ID
self.name = name
self.email = email

# Define the parent class method
def displayBasic(self):
# Print the values of the parent class variables
print(«ID: {}\nName: {}\nEmail: {}».format(self.ID, self.name, self.email))

# Define the child class
class StudentDetails(Student):

# Define child class constructor
def __init__(self, ID, name, email, dept, batch, sem, cgpa):
# Call the parent class constructor
Student.__init__(self, ID, name, email)
# Initialize the child class variables
self.department = dept
self.batch = batch
self.semester = sem
self.cgpa = cgpa

# Define the child class method
def displayInfo(self):
Student.displayBasic(self)
# Print the values of the child class variables
print(«Department: {}\nBatch: {}\nSemerter: {}»
.format(self.department, self.batch, self.semester))

# Create the object of the parent class
objStudent = Student(‘674534’, ‘Rakib Hasan’, ‘rakib@gmail.com’)
print(«Student’s Basic Information:\n«)
# Call the method of the parent class
objStudent.displayBasic()

# Create the object of the child class
objStudentDetails = StudentDetails(‘783412’, ‘Zannatul Ferdous’, ‘zannat@gmail.com’, ‘CSE’, 48, 10, 3.89)
print(«\nStudent’s Detail Information:\n«)
# Call the method of the child class
objStudentDetails.displayInfo()
# Print a property value of the child class
print(«CGPA: {}».format(objStudentDetails.cgpa))

Выход:

Читайте также:  Sublime или Brackets: сравнение

Следующий вывод появится после выполнения вышеуказанного сценария.

Инкапсуляция

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

encalsulation.py

# Define the parent class
class Number:
def __init__(self):
# Initialize the public members of parent class
self.n1 = 10
self.n2 = 30

# Define the child class
class Add(Number):
def __init__(self):
# Call the parent constructor
Number.__init__(self)
»’
Store the result of the addition in a private member
of the child class
»’

self.__result = self.n1 + self.n2
# Print the result of the addition
print(«The result of the addition = {}\n«.format(self.__result))

# Create the object of the child class
objAdd = Add()
# Print the private property of the child class
print(objAdd.__result)

Выход:

Следующий вывод появится после выполнения вышеуказанного сценария. Когда объект был определен, был вызван метод конструктора, и была напечатана сумма 10 и 30. Сообщение об ошибке появилось при попытке доступа к закрытому члену извне класса.

Полиморфизм

Еще одна основная особенность объектно-ориентированного программирования — полиморфизм. Значение поли является «много», и морфизм является «формы». Способ объявления одной и той же функции несколько раз для разных целей называется полиморфизмом. Кодирование становится проще для использования этой функции ООП. Эта функция может быть реализована с использованием сценария Python, например полиморфизм в разных классах, полиморфизм в унаследованных классах и т. Д. Как полиморфизм может быть реализован в разных классах с помощью сценария Python, показано в следующем примере. В сценарии объявлены два несвязанных класса с именами Rectangle и Circle.

Оба класса имеют параметризованный конструктор и метод с именем area ().Здесь оба класса содержат один и тот же метод, но назначение метода разное. В прямоугольном классе конструктор инициализирует две переменные с именами height и width, а метод area () вычисляет площадь прямоугольника. В классе окружности конструктор инициализирует одну переменную с именем radius, а метод area () вычислит площадь круга. После объявления класса у пользователя будут взяты два числовых значения для передачи значений высоты и ширины конструктору класса Rectangle во время объявления объекта. Затем метод area () объекта Rectangleбудет вызван класс для печати прямоугольной области на основе входных значений. После этого у пользователя будет взято одно числовое значение для передачи значения радиуса конструктору класса Circle во время создания объекта., То площадь () метод Circle класса будет называться, чтобы напечатать площадь круга на основе значения входного сигнала.

polymorphism.py

# Define the Rectangle class
class Rectangle:
# Define the constructor
def __init__(self, height, width):
# Initialize the class variables
self.height = height
self.width = width

# Define the method to calculate rectangle area
def area(self):
area = self.height * self.width
print(«The area of the rectangle is {}\n«.format(area))

# Define the Circle class
class Circle:
# Define the constructor
def __init__(self, radius):
# Initialize the class variable
self.radius = radius

# Define the method to calculate circle area
def area(self):
area = 3.14 * self.radius * self.radius
print(«The area of the circle is {}\n«.format(area))

# Take the height and width values from the user
height = int(input(«Enter the height of the rectangle: «))
width = int(input(«Enter the width of the rectangle: «))

# Create the object of the Rectangle class
objRectangle = Rectangle(height, width)
# Call area() method to print the rectangle area
objRectangle.area()

# Take the radius value from the user
radius = int(input(«Enter the radius of the rectangle: «))
# Create the object of the Circle class
objCircle = Circle(radius)
# Call area() method to print the circle area
ob0000000000000000000000000000000000000000000000000000000000000000jCircle.area()

Выход:

Следующий вывод появится после выполнения вышеуказанного сценария. Согласно выходным данным, 5 было принято за значение высоты, а 2 — за значение ширины. Для этих значений площадь распечатанного прямоугольника составляет 10 (5 × 2). Затем, 2 было принято в качестве значения радиуса, а площадь круга 12,56 (3,14×2×2), которая была напечатана.

Получатель и сеттер

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

Сеттер и геттер с использованием обычной функции

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

custom_setter_getter.py

# Define the class
class Person:
def __init__(self, name, email, phone):
# Define the private member variables
self.__name = name
self.__email = email
self.__phone = phone

# Define custom getter
def get_person_data(self):
print(«The custom getter method is called»)
return [self.__name, self.__email, self.__phone]

# Define custom setter
def set_person_data(self, email):
print(«The custom setter method is called»)
self.__email = email

# Create object of the class
objPerson = Person(‘Rifat Bin Hasan’, », ‘01855435626’)
# Set the email value using custom setter
objPerson.set_person_data(‘rifat@gmail.com’)
# Read all data member values using custom getter
person = objPerson.get_person_data()
# Print the return values
print(«Name: {}\nEmail: {}\nPhone: {}».format(person[], person[1], person[2]))

Выход:

Читайте также:  Как перевернуть вектор в C++?

Следующий вывод появится после выполнения вышеуказанного сценария.

Сеттер и геттер с использованием декоратора @property:

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

decorator_setter_getter.py

# Define the class
class Person:
def __init__(self, name=»):
# Define the private member variables
self.__name = name

# Define custom getter
@property
def name(self):
print(«The getter method is called»)
return self.__name

# Define custom setter
@name.setter
def name(self, name):
print(«The setter method is called»)
self.__name = name

# Create object of the class
objPerson = Person()
# Set the email value using custom setter
objPerson.name = ‘Zanifer Ali’

print(«The name of the person is {}\n«.format(objPerson.name))

Выход:

Следующий вывод появится после выполнения вышеуказанного сценария.

Оператор и функция перегрузки

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

Перегрузка оператора

Оператор используется с двумя операндами. Назначение каждого оператора разное. Например, существует множество применений оператора «+„, например, его можно использовать для сложения, объединения двух строк и т. Д. Но когда оператор “+» используется для другой цели, это называется перегрузкой оператора. Специальные функции используются для различных типов перегрузки операторов. Специальная функция объявляется с использованием ’__’ в начале и в конце имени функции. В Python существует множество специальных функций различных типов операторов для перегрузки операторов. Оператор может быть математическим, сравнение оператор, оператор присваиванияи т. д. Использование специальной функции математического оператора было показано в этой части этого руководства, чтобы понять концепцию перегрузки оператора в Python.

Математический оператор

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

Имя оператора Символ Специальная функция
Добавление + __add __ (я, другое)
Вычитание __sub __ (я, другой)
Умножение * __mul __ (я, другой)
Разделение / __truediv __ (я, другой)
Модуль % __mod __ (сам, другое)
Мощность ** __pow __ (я, другой)

Используя специальную функцию оператора мощности (**):

Специальная функция __pow __ () используется для перегрузки оператора мощности. Основная цель оператора мощности — вычислить значение мощности определенного числа. Но если нам потребуется вычислить значения мощности с использованием точечных значений, тогда общий оператор мощности не будет работать. Предположим, есть две точки (3, 2) и (2, 4). Нам нужна сумма 32 и 24. В этом случае мы должны использовать специальную функцию оператора мощности. Функция __pow __ () может вычислять сумму сил на основе значений точек, показанных в следующем скрипте. Класс SumOfPower содержит параметризованный конструктор для инициализации двух переменных класса, функцию __pow __ () для вычисления суммы двух степеней на основе значений точек и __str __ ()функция для печати объекта класса. Затем были объявлены два объекта класса. Оператор мощности использовал две объектные переменные в функции print () для вызова функции __pow __ () для завершения операции.

operator_overloading.py

# Define the class
class SumOfPowers:
# Define the class constructor
def __init__(self, n1, n2):
self.a = n1
self.b = n2

# Overloading the power operator
def __pow__(self, other):
= self.a ** other.a
= self.b ** other.b
self.result = a + b
return SumOfPowers(a, b)

# string function to print object of the class
def __str__(self):
return str(self.a)+‘ + ‘+str(self.b)

# Create the first object
pow1 = SumOfPowers(3, 2)
# Create the second object
pow2 = SumOfPowers(2, 4)
# Calculate the powers and print the sum of powers
print(«The sum of powers = «, pow1**pow2, «=», pow1.result)

Выход:

Следующий вывод появится после выполнения вышеуказанного сценария. 32 равно 9, а 24 равно 16. Сумма 9 и 16 равна 25, что отображается в выходных данных.

Перегрузка функций

Иногда нам нужно написать несколько методов, которые очень похожи, но отличаются только некоторыми частями. В этом случае можно определить один метод для выполнения тех же задач с использованием перегрузки функций. Сложность кода может быть устранена, и код становится более понятным, если использовать перегрузку функций. Вывод функции зависит от аргумента, переданного функции. Как можно реализовать перегрузку функций в Python, показано в следующем скрипте. Основная цель скрипта — выполнить четыре типа арифметических операций со значением по умолчанию или значениями, переданными во время создания объекта. Метод с именем calculate ()здесь используется для арифметических операций.

Этот метод вызывается в сценарии четыре раза для выполнения четырех типов задач. Когда метод вызывается без аргументов, он отображает только сообщение. Когда метод вызывается со знаком «+» в качестве значения аргумента, он вычисляет значения по умолчанию. Метод вызывает с ’-’ и числовым значением в качестве значений аргумента, он вычитает второе значение по умолчанию из значения аргумента. А также когда метод вызывает с ’*’ и двумя числовыми значениями в качестве значений аргументов, он вычисляет два значения аргумента.

function_overloading.py

# Define the class
class Arithmetic:
# Define the class variable
result = 

# Define the class method
def calculate(self, operator=«», number1=25, number2=35):
# Calculate the summation
if operator == «+»:
self.result = number1 + number2
print(‘The result of the addition is {}’.format(self.result))
# Calculate the subtraction
elif operator == «-«:
self.result = number1 — number2
print(‘The result of the subtraction is {}’.format(self.result))
# Calculate the multiplication
elif operator == «*»:
self.result = number1 * number2
print(‘The result of the multiplication is {}’.format(self.result))
# Calculate the division
elif operator == «/»:
self.result = number1 / number2
print(‘The result of the division is {}’.format(self.result))
else:
print(«No operator is given»)

# Create the object of the class
objArithmetic = Arithmetic()

# Call the method without argument
objArithmetic.calculate()
# Call the method with one argument
objArithmetic.calculate(‘+’)
# Call the method with two arguments
objArithmetic.calculate(‘-‘, 50)
# Call the method with three arguments
objArithmetic.calculate(‘*’, 2, 3)

Выход:

Следующий вывод появится после выполнения вышеуказанного сценария. Сообщение » Оператор не задан » было напечатано для вызова метода без аргументов. Сумма 25 и 35 была напечатана для вызова метода с одним аргументом. Значение вычитания 50-35 было напечатано для вызова метода с двумя значениями аргументов. Значение умножения 3 и 2 напечатано для вызова метода с тремя значениями аргументов. Таким образом, в скрипте реализована перегрузка функций, позволяющая использовать одну и ту же функцию несколько раз.

Заключение

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

Оцените статью
bestprogrammer.ru
Добавить комментарий