Programação orientada a objetos em Python

Muitos recursos existem na programação orientada a objetos (OOP) para desenvolver qualquer aplicativo simples e complexo. É usado para organizar o código com base no objeto que contém atributos e comportamentos, e cada objeto é uma instância de uma classe específica. Os programas OOP são mais eficientes que a programação funcional e fáceis de entender. Essa abordagem de programação é mais adequada para o desenvolvimento de projetos grandes e complexos que são divididos em grupos. O Python é uma linguagem de programação muito popular para apoiar a programação funcional e orientada a objetos. Três principais características do OOP são herança, encapsulamento e polimorfismo. Como escrever um programa orientado a objetos em Python a partir do básico e os usos de três recursos OOP principais usando o script python descrito neste tutorial.

Conteúdo:

Aprender a programação orientada a objetos em Python do básico foi explicada aqui discutindo os seguintes tópicos com exemplos.

1. Classe e objeto
2. Construtor
3. Herança
4. Encapsulamento
5. Polimorfismo
6. Getter e setter
7. Operador de sobrecarga e função

Classe e objeto:

Em programação orientada a objetos, aula é usado para declarar a estrutura de dados definida pelo usuário que contém o conjunto de atributos. Os atributos podem ser as variáveis ​​de classe, variáveis ​​de instância e métodos. As variáveis ​​acessíveis por todas as instâncias da classe são chamadas de variáveis ​​de classe. As funções declaradas dentro da classe são chamadas de métodos. As variáveis ​​definidas dentro de qualquer método de classe e acessíveis pela instância atual da classe são chamadas de variáveis ​​de instância. Uma aula é declarada em Python, definindo a palavra -chave de classe seguida por um nome de classe e cólon (:). A sintaxe da classe é definida abaixo.

Sintaxe da classe:

Classe ClassName:
Variáveis;
Métodos;

Uma instância ou cópia de uma classe é chamada de objeto usado para acessar as variáveis ​​de classe e os métodos de classe. Uma aula é inútil sem declarar um objeto porque o aula contém a descrição do objeto que não aloca nenhuma memória. O objeto é declarado mencionando o nome da classe com os primeiros suportes iniciais e finais. Se o aula contém qualquer método construtor com os parâmetros, então você deve definir o valor dos parâmetros no momento de objeto declaração. A sintaxe do objeto é dada abaixo.

Sintaxe do objeto:

Object_name = classe_name ()

ou

Object_name = classe_name (value1, value2,…)

A declaração de uma classe simples e a declaração de objeto dessa classe mostraram no script a seguir. Uma aula chamada 'Livro'foi declarado aqui que contém três variáveis ​​de classe (Book_name, Author_Name e Price) e um método chamado book_discount_price (). O método calculará o preço do livro após um desconto de 5% e imprimirá os detalhes do livro com o preço original e o desconto. A variável de objeto nomeada ObjBook foi definida no script para criar a instância da classe e chamar o método da classe.

ClassandObject.py

# Defina a classe
livro escolar:
# Defina e inicialize variáveis ​​de classe
book_name = "Aprenda Python da maneira mais difícil"
autor_name = "Zed Shaw"
Preço = 22
# Defina o método da classe para exibir detalhes do livro com preço de desconto
def book_discount_price (self):
# Calcule o preço do desconto após 5% de desconto
d_price = self.Preço - Self.Preço * 0.05
# Detalhes do livro de impressão
Print ("Nome do livro: \ name nauthor: \ noriginal Preço: $ \ ndiscount Preço: $ \ n"
.formato (self.book_name, self.autor_name, self.preço, d_price))
# Crie um objeto da classe
objBook = livro ()
Print ("Reserve informações após desconto:")
# Ligue para o método da classe
ObjBook.book_discount_price ()

Saída:

A saída a seguir aparecerá após a execução do script acima.

Construtor:

O construtor é um método de uma classe chamada automaticamente na declaração de objeto da época. É usado principalmente para inicializar o objeto de uma variável. def A palavra -chave é usada para declarar qualquer método em uma declaração de classe Python, e o nome do método do construtor é __iniciar__() em Python. Dois tipos de construtores podem ser declarados em Python. Estes são o construtor sem parâmetros e o construtor parametrizado. Os usos de ambos os construtores mostraram nesta parte deste tutorial.

A. construtor sem parâmetro

O construtor que contém apenas um argumento chamado auto é chamado de construtor sem parâmetro ou padrão. Nenhum parâmetro é necessário para passar no momento da declaração de objeto de uma classe que contém o construtor sem parâmetros. A maneira de declarar um construtor sem parâmetros foi mostrado no script a seguir. Aqui o Cliente classe contém o construtor sem parâmetros que inicializará as quatro variáveis ​​de classe quando qualquer objeto de classe será criado. Em seguida, um objeto da classe nomeado objcustomer foi declarado para acessar as variáveis ​​da classe.

default_constructor.py

# Defina aula de cliente
Cliente de aula:
# Declarar construtor sem parâmetro
def __init __ (self):
# Inicialize variáveis ​​de classe
auto.Id = 'd-67455'
auto.nome = 'sakib hasan'
auto.Account_type = 'Salvando'
auto.Balance = 5000000
# Crie objeto da classe do cliente
objcustomer = cliente ()
Print ("Informações básicas do cliente: \ n")
# Imprima os valores das propriedades do objeto
print ("Id: \ nName: \ naccount Type: \ nBalance: "
.formato (Objcustomer.Id, objcustomer.Nome, Objcustomer.Account_type, objcustomer.equilíbrio))

Saída:

A saída a seguir aparecerá após a execução do script acima.

B. Construtor parametrizado

O construtor que contém um ou mais argumentos com o 'auto'O argumento é chamado de construtor parametrizado. Você precisa passar os valores dos parâmetros no momento da criação de objetos da classe. A maneira de declarar o construtor parametrizado foi mostrado no script a seguir. Aqui o Cliente A classe é declarada com um construtor parametrizado e dois métodos. O método chamado balance_after_deposit () é definido para adicionar o valor do depósito com o saldo. O método chamado balance_after_withdraw () é definido para deduzir o valor da retirada do saldo. Em seguida, a variável de objeto é definida para exibir os detalhes básicos do cliente, o saldo após o depósito e o saldo após a retirada.

Parametized_Constructor.py

# Defina aula de cliente
Cliente de aula:
# Declarar construtor com parâmetro
def __init __ (self, cust_id, cust_name, cust_balance):
# Inicialize variáveis
auto.Id = cust_id
auto.nome = cust_name
auto.Balance = cust_balance
# Adicione o valor com o saldo
Def Balance_after_deposit (self, deposit_amount):
auto.balança += deposit_amount
# Imprima o saldo atual
Print ("Depósito Ammount: \ Ncurrent Balance: \ n".formato (deposit_amount, self.equilíbrio))
# Subtraia o valor do saldo
Def Balance_after_withdraw (self, retirt_amount):
auto.Balance -= retirada_amount
# Imprima o saldo atual
Print ("Retire o Balanço: \ Ncurrent Balance: \ n".formato (retirada_amount, self.equilíbrio))
# Crie objeto da classe do cliente
objcustomer = cliente ('M-231234', 'Mir Sabbir', 200000)
# Imprima as informações básicas do cliente
Print ("Detalhes do cliente: \ nid: \ nName: \ NOPENING BALANCE: \ n"
.formato (Objcustomer.Id, objcustomer.Nome, Objcustomer.equilíbrio))
# Adicione o valor do depósito
objcustomer.balance_after_deposit (30000)
# Subtraia o valor da retirada
objcustomer.balance_after_withdraw (10000)

Saída:

A saída a seguir aparecerá após a execução do script acima. Aqui, o saldo de abertura é 200000. O saldo se torna 220000 depois de adicionar 30000 e deduzir 10000.

Herança:

Uma das características básicas da programação orientada a objetos é a herança. A maneira de criar uma nova classe a partir de uma classe existente é chamada de herança. A classe existente é chamada de classe pai ou classe base, e a nova classe herdada é chamada de Classe Child ou Derivada. A classe infantil conterá as características da classe base após a herança. Como a herança pode ser aplicada na classe Python mostrou no exemplo a seguir. No roteiro, o 'Estudante'é a classe pai e o'StudentDetails'É a classe infantil. Ambas as classes têm os construtores parametrizados. A classe pai tem um método chamado Exibir básico () Para imprimir as variáveis ​​de ID, nome e e -mail da classe pai. A classe infantil tem um método chamado displayInfo () Para imprimir os valores do lote e variáveis ​​semestre da classe infantil. O construtor da classe pai é chamado de construtor de classe infantil. Após a declaração de classe, o objeto da classe pai foi declarado com valores de três parâmetros para inicializar as variáveis ​​de classe da classe pai, e o método da classe pai foi chamado para exibir esses valores. Em seguida, o objeto de classe infantil foi declarado com valores de três parâmetros para inicializar as variáveis ​​de classe da classe infantil, e o método da classe infantil foi chamado para exibir esses valores.

herança.py

# Defina a classe pai
Aluno da aula:
# Defina o construtor da classe pai
def __init __ (self, id, nome, e -mail):
# Inicialize as variáveis ​​da classe pai
auto.Id = id
auto.nome = nome
auto.email = email
# Defina o método da classe pai
def DisplayBasic (self):
# Imprima os valores das variáveis ​​da classe pai
print ("id: \ nName: \ nemail: ".formato (self.Id, eu.nome, eu.e-mail))
# Defina a classe infantil
Classe StudentDetails (aluno):
# Definir construtor de classe infantil
def __init __ (self, id, nome, e -mail, departamento, lote, SEM, cgpA):
# Ligue para o construtor da classe pai
Estudante.__init __ (self, id, nome, e -mail)
# Inicialize as variáveis ​​da classe infantil
auto.Departamento = Departamento
auto.lote = lote
auto.Semestre = SEM
auto.CGPA = CGPA
# Defina o método da classe infantil
def DisplayInfo (self):
Estudante.DisplayBasic (self)
# Imprima os valores das variáveis ​​da classe infantil
print ("Departamento: \ nbatch: \ nsemerter: "
.formato (self.departamento, eu.lote, eu.semestre))
# Crie o objeto da classe pai
objstudent = aluno ('674534', 'rakib hasan', '[email protected] ')
Print ("Informações básicas do aluno: \ n")
# Ligue para o método da classe pai
objstudent.DisplayBasic ()
# Crie o objeto da classe infantil
objStudentDetails = StudentDetails ('783412', 'Zannatul Ferdous', '[email protected] ',' cse ', 48, 10, 3.89)
Print ("Informações detalhadas do \ \ \ nstudent: \ n")
# Ligue para o método da classe infantil
objstudentDetails.displayInfo ()
# Imprima um valor de propriedade da classe infantil
print ("CGPA: ".formato (objstudentDetails.cGPA))

Saída:

A saída a seguir aparecerá após a execução do script acima.

Encapsulamento:

Outra característica básica da programação orientada a objetos é o encapsulamento. A maneira de ocultar as variáveis ​​e métodos específicos de uma classe é chamada de encapsulamento. É usado para definir a restrição para acessar os dados específicos. O principal objetivo desse recurso é fornecer segurança de dados pela ocultação de dados. O encapsulamento pode ser implementado em Python, declarando os membros de dados privados ou protegidos da classe. Como o encapsulamento pode ser implementado no Python mostrou no exemplo a seguir. No script, o Adicionar A classe criou herdando o Número aula. Um membro privado chamado '__resultado'declarou na classe infantil armazenar a soma de dois números, e essa variável é acessível apenas dentro da classe infantil. O construtor da classe pai inicializará duas variáveis ​​de classe com os números. De acordo com o script, o construtor da classe criança chamará o construtor da classe pai, calculará a soma das variáveis ​​de classe e imprimirá o resultado da adição. Após a declaração de classe, o objeto da classe infantil foi declarado. Em seguida, o membro privado da classe infantil usou na função de impressão que gerará um erro.

encalsulação.py

# Defina a classe pai
número da classe:
def __init __ (self):
# Inicialize os membros públicos da classe dos pais
auto.n1 = 10
auto.n2 = 30
# Defina a classe infantil
classe add (número):
def __init __ (self):
# Ligue para o construtor pai
Número.__nele mesmo)
"
Armazene o resultado da adição em um membro privado
da classe infantil
"
auto.__Result = self.N1 + self.n2
# Imprima o resultado da adição
print ("O resultado da adição = \ n".formato (self.__resultado))
# Crie o objeto da classe infantil
objadd = add ()
# Imprima a propriedade privada da classe infantil
Imprimir (objadd.__resultado)

Saída:

A saída a seguir aparecerá após a execução do script acima. Quando o objeto foi definido, o método do construtor foi chamado e a soma de 10 e 30 imprimiu. A mensagem de erro apareceu para tentar acessar o membro privado de fora da classe.

Polimorfismo:

Outra característica básica da programação orientada a objetos é o polimorfismo. O significado de poli é 'muitos' e morfismo é 'formas'. A maneira de declarar a mesma função várias vezes para fins diferentes é chamada de polimorfismo. A codificação se torna mais fácil para usar esse recurso do OOP. Esse recurso pode ser implementado usando o script python, como polimorfismo em diferentes classes, polimorfismo em classes herdadas, etc. Como o polimorfismo pode ser implementado em diferentes classes usando o script python mostrado no exemplo a seguir. No roteiro, duas classes não relacionadas denominadas retângulo e círculo foram declaradas. Ambas as classes têm o construtor parametrizado e um método nomeado área(). Aqui, ambas as classes contêm o mesmo método, mas o objetivo do método é diferente. Na classe retangular, o construtor inicializará duas variáveis ​​nomeadas altura e largura, e a área() o método calculará a área do retângulo. Na classe Circle, o construtor inicializará uma variável nomeada raio, e a área() o método calculará a área do círculo. Depois de declarar a classe, dois valores numéricos serão retirados do usuário para passar os valores de altura e largura para o construtor do Retângulo classe no momento da declaração de objetos. Em seguida, o área() Método do Retângulo A classe será chamada para imprimir a área do retângulo com base nos valores de entrada. Depois disso, um valor numérico será retirado do usuário para passar o valor do raio para o construtor do Círculo aula no momento da criação de objetos. , o área() Método do Círculo A classe será chamada para imprimir a área do círculo com base no valor de entrada.

polimorfismo.py

# Defina a classe retângulo
Retângulo de classe:
# Defina o construtor
def __init __ (eu, altura, largura):
# Inicialize as variáveis ​​de classe
auto.altura = altura
auto.largura = largura
# Defina o método para calcular a área do retângulo
Área Def (self):
área = self.altura * eu.largura
print ("A área do retângulo é \ n".formato (área))
# Defina a classe Circle
Círculo de Classe:
# Defina o construtor
def __init __ (eu, raio):
# Inicialize a variável de classe
auto.raio = raio
# Defina o método para calcular a área do círculo
Área Def (self):
área = 3.14 * eu.raio * eu.raio
print ("A área do círculo é \ n".formato (área))
# Pegue os valores de altura e largura do usuário
altura = int (entrada ("Digite a altura do retângulo:")))
largura = int (entrada ("Digite a largura do retângulo:")))
# Crie o objeto da classe Retângulo
objrectangle = retângulo (altura, largura)
# Call Area () Método para imprimir a área do retângulo
objrectangle.área()
# Pegue o valor do raio do usuário
raio = int (entrada ("Digite o raio do retângulo:")))
# Crie o objeto da classe Circle
objcircle = círculo (raio)
# Call Area () Método para imprimir a área do círculo
OB000000000000000000000000000000000000000000000000000000000000000000000000000000JC CIRCLE.área()

Saída:

A saída a seguir aparecerá após a execução do script acima. De acordo com a produção, 5 tomou como valor de altura e 2 tomou como valor de largura. Para esses valores, a área do retan0gle é 10 (5 × 2) que foi impressa. Em seguida, 2 tomou como valor de raio e a área do círculo é 12.56 (3.14x2x2) que foi impresso.

Getter e setter:

O método usado para ler o valor da propriedade é chamado getter, e o método usado para definir o valor da propriedade é chamado de setter. Na programação orientada a objetos, o getter é usado para acessar os atributos privados da classe, e o setter é usado para definir os valores dos atributos privados da classe. Os principais propósitos desse recurso são garantir o encapsulamento de dados e a validação de dados. O getter e o setter podem ser implementados usando a função normal ou @property decorador. Ambas as maneiras de implementar o setter e getter foram mostradas nesta parte do tutorial.

Setter e getter usando a função normal:

O script a seguir mostra como a função normal pode ser usada para implantar métodos de getter e setter. No script, o Pessoa A classe contém os métodos personalizados de getter e setter para ler os valores das variáveis ​​de classe privada e definir o valor da variável de email que é um membro privado. O valor vazio passou para a variável de email no momento da criação de objetos, e o método do setter personalizado foi usado para definir o valor do email. O método Getter personalizado retornará todos os valores da variável de classe como uma lista.

Custom_Setter_getter.py

# Defina a classe
Pessoa de classe:
def __init __ (self, nome, email, telefone):
# Defina as variáveis ​​de membro privado
auto.__name = nome
auto.__Email = email
auto.__phone = telefone
# Definir getter personalizado
def get_person_data (self):
print ("O método Getter personalizado é chamado")
retornar [self.__nome, eu.__Email, eu.__telefone]
# Definir setter personalizado
def set_person_data (self, email):
print ("O método de setter personalizado é chamado")
auto.__Email = email
# Crie objeto da classe
objperson = pessoa ('rifat bin hasan', ", '01855435626')
# Defina o valor de email usando o Setter Custom
Objperson.set_person_data ('[email protected] ')
# Leia todos os valores dos membros de dados usando getter personalizado
pessoa = objperson.get_person_data ()
# Imprima os valores de retorno
print ("Nome: \ nemail: \ nphone: ".formato (pessoa [0], pessoa [1], pessoa [2])))

Saída:

A saída a seguir aparecerá após a execução do script acima.

Setter e getter usando @property Decorator:

O script a seguir mostra como o Decorador @Property pode ser usado para implantar métodos de getter e setter. No script, o getter e o setter declararam usando o @property decorador para definir o valor do nome da variável, um membro da classe privada. Depois de declarar a classe, o objeto da classe foi definido e o valor da variável de nome foi atribuído e recuperado usando o setter e o getter.

decorator_setter_getter.py

# Defina a classe
Pessoa de classe:
def __init __ (self, name = "):
# Defina as variáveis ​​de membro privado
auto.__name = nome
# Definir getter personalizado
@propriedade
Nome definido (self):
print ("O método getter é chamado")
retornar a si mesmo.__nome
# Definir setter personalizado
@nome.normatizador
nome def (self, nome):
print ("O método do setter é chamado")
auto.__name = nome
# Crie objeto da classe
objperson = pessoa ()
# Defina o valor de email usando o Setter Custom
Objperson.Nome = 'Zanifer Ali'
print ("O nome da pessoa é \ n".formato (objperson.nome))

Saída:

A saída a seguir aparecerá após a execução do script acima.

Operador de sobrecarga e função:

Quando qualquer função ou operador é usado para um propósito diferente com base no parâmetro de função ou nos operandos em vez do uso normal da função ou operador, ela é chamada de sobrecarga. O recurso de reutilização pode ser implementado na programação orientada a objetos usando a sobrecarga do operador e a sobrecarga de funções. É uma característica útil do OOP, mas o uso excessivo desse recurso cria dificuldade em gerenciar o código. O simples uso da sobrecarga do operador e sobrecarga de funções na classe Python foi mostrado neste tutorial.

Sobrecarga do operador:

O operador é usado em dois operandos. O objetivo de cada operador é diferente. Por exemplo, existem muitos usos do operador '+', como pode ser usado para adição, combinando duas cordas, etc. Mas quando o operador '+' é usado para um propósito diferente, é chamado de sobrecarga do operador. As funções especiais são usadas para diferentes tipos de sobrecarga do operador. A função especial é declarada usando '__' no início e no final do nome da função. Muitas funções especiais de diferentes tipos de operadores existem no Python para sobrecarga do operador. O operador pode ser matemático, comparação operador, operador de atribuição, etc. O uso da função especial do operador matemático foi demonstrado nesta parte deste tutorial para entender o conceito de sobrecarga do operador no Python.

Operador Matemático:

Os operadores usados ​​para operações aritméticas são chamadas de operador matemático. Esses operadores podem ser usados ​​para um propósito especial usando uma função especial. Algumas funções especiais do operador matemático são mencionadas abaixo.

Nome do operador	Símbolo	Função especial
Adição	+	__Add __ (eu, outro)
Subtração	-	__sub __ (eu, outro)
Multiplicação	*	__mul __ (eu, outro)
Divisão	/	__TrueDiv __ (eu, outro)
Módulo	%	__mod __ (eu, outro)
Poder	**	__pow __ (eu, outro)

Usando a função especial do operador de energia (**):

__Pancada__() A função especial é usada para sobrecarregar o operador de energia. O principal objetivo do operador de energia é calcular o valor de potência de um número específico. Mas se precisarmos calcular os valores de energia usando valores de ponto, então o operador de energia geral não funcionará. Suponha que haja dois pontos (3, 2) e (2, 4). Precisamos da soma de 32 e 24. Nesse caso, temos que usar a função especial do operador de energia. A função __pow __ () pode calcular a soma dos poderes com base nos valores de ponto mostrados no script a seguir. A classe SUMOFPOWER Contém um construtor parametrizado para inicializar duas variáveis ​​de classe, __Pancada__() função para calcular a soma de dois poderes com base em valores pontuais e __str __ () função para imprimir o objeto da classe. Em seguida, dois objetos da classe foram declarados. O operador de energia usou duas variáveis ​​de objeto na impressão () função para chamar o __Pancada__() função para concluir a operação.

operator_overloading.py

# Defina a classe
Classe sumofpowers:
# Defina o construtor de classe
def __init __ (self, n1, n2):
auto.a = n1
auto.b = n2
# Sobrecarregando o operador de energia
def __pow __ (eu, outro):
a = self.a ** outro.a
b = self.irmão.b
auto.resultado = a + b
Retornar Sumofpowers (A, B)
# Função de string para imprimir objeto da classe
def __str __ (self):
Retornar Str (self.a)+'+'+str (self.b)
# Crie o primeiro objeto
Pow1 = Sumofpowers (3, 2)
# Crie o segundo objeto
POW2 = SUMOFPOWERS (2, 4)
# Calcule os poderes e imprima a soma dos poderes
print ("A soma de Powers =", Pow1 ** Pow2, "=", Pow1.resultado)

Saída:

A saída a seguir aparecerá após a execução do script acima. 32 é 9 e 24 é 16. A soma de 9 e 16 é 25 que está sendo exibida na saída.

Sobrecarga da função:

Às vezes, precisamos escrever vários métodos que são bastante semelhantes, mas diferem em algumas partes apenas. Nesse caso, um único método pode ser definido para realizar as mesmas tarefas usando a sobrecarga de função. A complexidade do código pode ser removida e o código fica mais claro usando a sobrecarga de funções. A saída da função depende do argumento passado para a função. Como a sobrecarga de função pode ser implementada no Python mostrou no script a seguir. O principal objetivo do script é executar quatro tipos de operações aritméticas com o valor padrão ou os valores aprovados no momento da criação de objetos. O método chamado calcular () tem sido usado aqui para fazer as operações aritméticas. O método foi chamado quatro vezes no script para realizar quatro tipos de tarefas. Quando o método chama sem nenhum argumento, ele exibirá apenas uma mensagem. Quando o método chama com '+' como valor de argumento, ele calcula os valores padrão. Quando o método chama com '-' e um valor numérico como valores de argumento, subtrairá o segundo valor padrão do valor do argumento. Quando o método chama com '*' e dois valores numéricos como valores de argumento, ele calculará dois valores de argumento.

function_overloading.py

# Defina a classe
Aritmética de classe:
# Defina a variável de classe
resultado = 0
# Defina o método de classe
def Calcule (self, operator = "", número 1 = 25, número2 = 35):
# Calcule o somatório
Se operador == "+":
auto.resultado = número 1 + número2
print ('O resultado da adição é '.formato (self.resultado))
# Calcule a subtração
operador elif == "-":
auto.resultado = número1 - número2
print ('O resultado da subtração é '.formato (self.resultado))
# Calcule a multiplicação
operador elif == "*":
auto.resultado = número 1 * número2
print ('O resultado da multiplicação é '.formato (self.resultado))
# Calcule a divisão
operador elif == "/":
auto.resultado = número1 / número2
print ('O resultado da divisão é '.formato (self.resultado))
outro:
Print ("Nenhum operador é dado")
# Crie o objeto da classe
objaritmético = aritmético ()
# Ligue para o método sem argumento
Objaritmético.calcular()
# Ligue para o método com um argumento
Objaritmético.Calcule ('+')
# Ligue para o método com dois argumentos
Objaritmético.Calcule ('-', 50)
# Ligue para o método com três argumentos
Objaritmético.Calcule ('*', 2, 3)

Saída:

A saída a seguir aparecerá após a execução do script acima. 'Nenhum operador é dado'A mensagem impressa para chamar o método sem nenhum argumento. A soma de 25 e 35 foi impressa para chamar o método com um argumento. O valor da subtração de 50-35 foi impresso para chamar o método com dois valores de argumento. O valor de multiplicação de 3 e 2 imprimiu para chamar o método com três valores de argumento. Dessa forma, a sobrecarga de funções foi implementada no script para usar a mesma função várias vezes.

Conclusão:

A programação básica orientada a objetos em Python foi explicada neste tutorial usando exemplos de python muito simples. As características mais comuns do OOP são discutidas aqui para ajudar os leitores a conhecer o caminho do OOP em Python e capazes de escrever o programa Python usando classe e objeto.