Programación orientada a objetos en Python

Existen muchas características en la programación orientada a objetos (OOP) para desarrollar cualquier aplicación simple a compleja. Se utiliza para organizar el código basado en el objeto que contiene atributos y comportamientos, y cada objeto es una instancia de una clase en particular. Los programas OOP son más eficientes que la programación funcional y fáciles de entender. Este enfoque de programación es más adecuado para desarrollar proyectos grandes y complejos que se dividan en grupos. Python es un lenguaje de programación muy popular para admitir la programación funcional y orientada a objetos. Tres características principales de OOP son la herencia, la encapsulación y el polimorfismo. Cómo escribir un programa orientado a objetos en Python desde lo básico y los usos de tres características principales de OOP mediante el uso de script de Python han descrito en este tutorial.

Contenido:

Aprender la programación orientada a objetos en Python de lo básico se ha explicado aquí discutiendo los siguientes temas con ejemplos.

1. Clase y objeto
2. Constructor
3. Herencia
4. Encapsulación
5. Polimorfismo
6. Getter y Setter
7. Operador de sobrecarga y función

Clase y objeto:

En programación orientada a objetos, clase se utiliza para declarar la estructura de datos definida por el usuario que contiene el conjunto de atributos. Los atributos pueden ser las variables de clase, variables de instancia y métodos. Las variables a las que se pueden acceder en todas las instancias de la clase se llaman variables de clase. Las funciones que se declaran dentro de la clase se denominan métodos. Las variables definidas dentro de cualquier método de clase y accesibles por la instancia actual de la clase se denominan variables de instancia. Una clase se declara en Python definiendo la palabra clave de clase seguida de un nombre de clase y colon (:). La sintaxis de la clase se define a continuación.

Sintaxis de la clase:

clase className:
Variables;
Métodos;

Una instancia o copia de una clase se llama objeto utilizado para acceder a las variables de clase y los métodos de clase. Una clase es inútil sin declarar un objeto porque el clase contiene la descripción del objeto solo que no asigna ningún recuerdo. El objeto se declara mencionando el nombre de la clase con los primeros soportes iniciales y finales. Si el clase contiene cualquier método de constructor con los parámetros, entonces debe definir el valor de los parámetros en el momento de objeto declaración. La sintaxis del objeto se da a continuación.

Sintaxis del objeto:

Object_name = class_name ()

o

Object_name = class_name (value1, value2, ...)

La declaración de una clase simple y la declaración de objeto de esa clase se ha mostrado en el siguiente script. Una clase llamada 'Libro'ha sido declarado aquí que contiene tres variables de clase (book_name, autor_name y precio) y un método nombrado book_discount_price (). El método calculará el precio del libro después de un descuento del 5% e imprimirá los detalles del libro con el precio original y el descuento. La variable de objeto llamada objbook se ha definido en el script para crear la instancia de la clase y llamar al método de clase.

ClassAndObject.py

# Defina la clase
Libro de clase:
# Definir e inicializar las variables de clase
book_name = "Aprende python de la manera difícil"
autor_name = "Zed Shaw"
Precio = 22
# Definir el método de clase para mostrar los detalles del libro con precio de descuento
Def Book_discount_price (self):
# Calcule el precio de descuento después del 5% de descuento
d_price = self.Precio - Self.precio * 0.05
# Detalles del libro impreso
print ("Nombre del libro: \ nauthor nombre: \ precio noriginal: $ \ ndiscount Price: $ \ n"
.formato (yo mismo.book_name, yo.autor_name, yo.precio, d_price))
# Crear un objeto de la clase
objbook = book ()
Imprimir ("Información de libro después del descuento:")
# Llame al método de clase
objero.book_discount_price ()

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior.

Constructor:

El constructor es un método de una clase llamada automáticamente en la declaración de objeto de tiempo de esa clase. Se usa principalmente para inicializar el objeto de una variable. defensor La palabra clave se utiliza para declarar cualquier método en una declaración de clase de Python, y el nombre del método del constructor es __en eso__() en Python. Se pueden declarar dos tipos de constructores en Python. Estos son el constructor sin parámetros y el constructor parametrizado. Los usos de ambos constructores se han mostrado en esta parte de este tutorial.

A. constructor sin parámetros

El constructor que contiene solo un argumento llamado ser se llama constructor sin parámetro o predeterminado. No se requiere ningún parámetro en el momento de la declaración de objeto de una clase que contenga el constructor sin parámetro. La forma de declarar un constructor sin parámetros se ha mostrado en el siguiente script. Aquí el Cliente La clase contiene el constructor sin parámetros que inicializará las cuatro variables de clase cuando se creará cualquier objeto de clase. A continuación, un objeto de la clase llamado objecustómero ha sido declarado acceder a las variables de la clase.

Constructor predeterminado.py

# Defina la clase de clientes
Cliente de clase:
# Declarar constructor sin parámetro
def __init __ (self):
# Inicializar variables de clase
ser.Id = 'D-67455'
ser.nombre = 'Sakib Hasan'
ser.Account_type = 'Saving'
ser.Balance = 5000000
# Crear objeto de la clase de clientes
objcustomer = customer ()
Imprimir ("Información básica del cliente: \ n")
# Imprima los valores de las propiedades del objeto
print ("id: \ nname: \ naccount type: \ nbalance: "
.formato (objcustomer.Id, objecustomer.Nombre, Objcustomer.Account_type, objcustomer.balance))

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior.

B. Constructor parametrizado

El constructor que contiene uno o más argumentos con el 'ser'El argumento se llama constructor parametrizado. Tienes que pasar los valores de los parámetros en el momento de la creación de objetos de la clase. La forma de declarar constructor parametrizado se ha mostrado en el siguiente script. Aquí el Cliente La clase se declara con un constructor parametrizado y dos métodos. El método nombrado balance_after_deposit () se define para agregar el monto del depósito con el saldo. El método nombrado balance_after_withdraw () se define para deducir el monto del retiro del saldo. A continuación, la variable del objeto se define para mostrar los detalles básicos del cliente, el saldo después del depósito y el saldo después del retiro.

Parameterized_constructor.py

# Defina la clase de clientes
Cliente de clase:
# Declarar constructor con el parámetro
def __init __ (self, cust_id, cust_name, cust_balance):
# Inicializar variables
ser.Id = cust_id
ser.nombre = cust_name
ser.Balance = Cust_balance
# Agregar cantidad con el saldo
def balance_after_deposit (self, deposit_amount):
ser.saldo += deposit_amount
# Imprima el saldo actual
print ("depositar ammount: \ ncurrent saldo: \ n".formato (deposit_amount, yo.balance))
# Resta el monto del saldo
def balance_after_withdraw (self, retraw_amount):
ser.Balance -= Retirar_Amount
# Imprima el saldo actual
print ("retirar ammount: \ ncurrent Balance: \ n".formato (retirado_amount, yo.balance))
# Crear objeto de la clase de clientes
objcustomer = cliente ('M-231234', 'Mir Sabbir', 200000)
# Imprima la información básica del cliente
print ("Detalles del cliente: \ nid: \ nname: \ nopening balance: \ n"
.formato (objcustomer.Id, objecustomer.Nombre, Objcustomer.balance))
# Agregue el monto del depósito
objecustómero.balance_after_deposit (30000)
# Resta el monto del retiro
objecustómero.balance_after_withdraw (10000)

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior. Aquí, el saldo de apertura es 200000. El saldo se convierte en 220000 después de agregar 30000 y deducir 10000.

Herencia:

Una de las características básicas de la programación orientada a objetos es la herencia. La forma de crear una nueva clase a partir de una clase existente se llama herencia. La clase existente se llama clase principal o clase base, y la nueva clase hereditaria se llama niño o clase derivada. La clase infantil contendrá las características de la clase base después de la herencia. Cómo se puede aplicar la herencia en la clase de Python en el siguiente ejemplo. En el guión, el 'Alumno'es la clase principal y el'Deceta de alumno'¿Es la clase infantil?. Ambas clases tienen los constructores parametrizados. La clase principal tiene un método nombrado mostrar básico () Para imprimir las variables de identificación, nombre y correo electrónico de la clase principal. La clase infantil tiene un método nombrado DisplayInfo () para imprimir los valores del lote y variables semestrales de la clase infantil. El constructor de la clase principal se llama constructor de clase infantil. Después de la declaración de clase, el objeto de la clase principal se ha declarado con valores de tres parámetros para inicializar las variables de clase de la clase principal, y se ha llamado al método de la clase principal para mostrar estos valores. A continuación, el objeto de clase infantil se ha declarado con valores de tres parámetros para inicializar las variables de clase de la clase infantil, y se ha llamado al método de la clase infantil para mostrar estos valores.

herencia.py

# Defina la clase principal
Estudiante de clase:
# Defina el constructor de la clase principal
def __init __ (self, id, nombre, correo electrónico):
# Inicializar las variables de la clase principal
ser.ID = ID
ser.nombre = nombre
ser.correo electrónico = correo electrónico
# Defina el método de clase principal
Def displayBasic (self):
# Imprima los valores de las variables de clase principal
print ("id: \ nname: \ nemail: ".formato (yo mismo.Identificación.nombre, yo.correo electrónico))
# Defina la clase infantil
Class StudentDetails (Estudiante):
# Definir constructor de clase infantil
def __init __ (self, id, nombre, correo electrónico, departamento, lote, SEM, CGPA):
# Llame al constructor de la clase matriz
Alumno.__init __ (self, id, nombre, correo electrónico)
# Inicializar las variables de la clase infantil
ser.departamento = departamento
ser.lote = lote
ser.semestre = sem
ser.CGPA = CGPA
# Defina el método de clase infantil
Def displayInfo (self):
Alumno.DisplayBasic (yo)
# Imprima los valores de las variables de clase infantil
print ("Departamento: \ nbatch: \ nsemerter: "
.formato (yo mismo.Departamento, yo.lote,.semestre))
# Crea el objeto de la clase principal
objstudent = estudiante ('674534', 'rakib Hasan', '[email protected] ')
Imprimir ("Información básica del estudiante: \ n")
# Llame al método de la clase principal
objeco.DisplayBasic ()
# Crea el objeto de la clase infantil
objstudentDetails = StudentDetails ('783412', 'Zannatul Ferdous', '[email protected] ',' CSE ', 48, 10, 3.89)
Imprima ("\ Nstudent's Detalle Information: \ n")
# Llamar al método de la clase infantil
objstudentdetails.DisplayInfo ()
# Imprimir un valor de propiedad de la clase infantil
print ("CGPA: ".formato (objStudentDetails.CGPA))

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior.

Encapsulación:

Otra característica básica de la programación orientada a objetos es la encapsulación. La forma de ocultar las variables y métodos particulares de una clase se llama encapsulación. Se utiliza para establecer la restricción para acceder a los datos particulares. El objetivo principal de esta característica es proporcionar seguridad de datos mediante la ocultación de datos. La encapsulación se puede implementar en Python declarando a los miembros de datos privados o protegidos de la clase. La forma en que se puede implementar la encapsulación en Python ha demostrado en el siguiente ejemplo. En el guión, el Agregar la clase ha creado heredando el Número clase. Un miembro privado nombrado '__resultado'ha declarado en la clase infantil para almacenar la suma de dos números, y esta variable es accesible solo dentro de la clase infantil. El constructor de la clase principal inicializará dos variables de clase con los números. Según el script, el constructor de la clase infantil llamará al constructor de la clase principal, calculará la suma de las variables de clase e imprimirá el resultado de la adición. Después de la declaración de clase, el objeto de la clase infantil ha sido declarado. A continuación, el miembro privado de la clase infantil ha utilizado en la función de impresión que generará un error.

encalsulación.py

# Defina la clase principal
numero de clase:
def __init __ (self):
# Inicializar a los miembros públicos de la clase matriz
ser.N1 = 10
ser.N2 = 30
# Defina la clase infantil
clase ADD (Número):
def __init __ (self):
# Llame al constructor matriz
Número.__en si mismo)
"
Almacenar el resultado de la adición en un miembro privado
de la clase infantil
"
ser.__result = self.N1 + yo.N2
# Imprima el resultado de la adición
imprimir ("El resultado de la adición = \ n".formato (yo mismo.__resultado))
# Crea el objeto de la clase infantil
objadd = add ()
# Imprima la propiedad privada de la clase infantil
imprimir (objadd.__resultado)

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior. Cuando se definió el objeto, se llamó al método del constructor y la suma de 10 y 30 se ha imprimido. El mensaje de error ha aparecido para intentar acceder al miembro privado desde el exterior de la clase.

Polimorfismo:

Otra característica básica de la programación orientada a objetos es el polimorfismo. El significado de escuela politécnica es 'muchos', y morfismo es 'formularios'. La forma de declarar la misma función varias veces para diferentes propósitos se llama polimorfismo. La codificación se vuelve más fácil para usar esta característica del OOP. Esta característica se puede implementar utilizando script de pitón, como el polimorfismo en diferentes clases, polimorfismo en clases heredadas, etc. La forma en que el polimorfismo se puede implementar en diferentes clases utilizando el script de Python se ha mostrado en el siguiente ejemplo. En el script, se han declarado dos clases no relacionadas llamadas Rectangle y Circle. Ambas clases tienen el constructor parametrizado y un método nombrado área(). Aquí, ambas clases contienen el mismo método, pero el propósito del método es diferente. En la clase rectangular, el constructor inicializará dos variables nombradas altura y ancho, y el área() El método calculará el área del rectángulo. En la clase Circle, el constructor inicializará una variable nombrada radio, y el área() El método calculará el área del círculo. Después de declarar la clase, se tomarán dos valores de números del usuario para pasar los valores de altura y ancho al constructor del Rectángulo clase en el momento de la declaración de objetos. A continuación, el área() método del Rectángulo Se llamará a la clase para imprimir el área del rectángulo en función de los valores de entrada. Después de eso, se tomará un valor de número del usuario para pasar el valor de radio al constructor del Círculo clase en el momento de la creación de objetos. , el área() método del Círculo Se llamará a la clase para imprimir el área del círculo en función del valor de entrada.

polimorfismo.py

# Defina la clase de rectángulo
Rectángulo de clase:
# Defina el constructor
def __init __ (self, altura, ancho):
# Inicializar las variables de clase
ser.altura = altura
ser.ancho = ancho
# Defina el método para calcular el área rectangular
Área Def (yo):
área = yo.altura * yo.ancho
imprimir ("El área del rectángulo es \ n".formato (área))
# Defina la clase Circle
Círculo de clase:
# Defina el constructor
def __init __ (self, radio):
# Inicializar la variable de clase
ser.radio = radio
# Defina el método para calcular el área del círculo
Área Def (yo):
área = 3.14 * yo.radio * yo.radio
imprimir ("El área del círculo es \ n".formato (área))
# Tome los valores de altura y ancho del usuario
altura = int (entrada ("Ingrese la altura del rectángulo:"))
width = int (input ("Ingrese el ancho del rectángulo:"))
# Crea el objeto de la clase rectángulo
objrectangle = rectángulo (altura, ancho)
# Método de área de llamada () para imprimir el área del rectángulo
objecano.área()
# Tomar el valor de radio del usuario
radio = int (entrada ("Ingrese el radio del rectángulo:"))
# Crea el objeto de la clase Circle
objcircle = círculo (radio)
# Método de área de llamada () para imprimir el área del círculo
ob00000000000000000000000000000000000000000000000000000000000000000000J Circle.área()

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior. Según la salida, 5 ha tomado como valor de altura, y 2 ha tomado como valor de ancho. Para estos valores, el área del rectan0gle es 10 (5 × 2) que se ha impreso. A continuación, 2 se ha tomado como valor de radio, y el área del círculo es de 12.56 (3.14x2x2) que se ha impreso.

Getter y Setter:

El método utilizado para leer el valor de la propiedad se llama getter, y el método utilizado para establecer el valor de la propiedad se llama setter. En la programación orientada a objetos, el Getter se usa para acceder a los atributos privados de la clase, y el setter se usa para establecer los valores de los atributos privados de la clase. Los principales propósitos de esta característica son garantizar la encapsulación de datos y la validación de datos. El getter y el setter se pueden implementar utilizando la función normal o @Property Decorator. Ambas formas de implementar Setter y Getter se han mostrado en esta parte del tutorial.

Setter y getter usando la función normal:

El siguiente script muestra cómo se puede usar la función normal para implantar métodos de Getter y Setter. En el guión, el Persona La clase contiene los métodos personalizados de Getter y Setter para leer los valores de las variables de clase privada y establecer el valor de la variable de correo electrónico que es un miembro privado. El valor vacío ha pasado para la variable de correo electrónico en el momento de la creación de objetos, y el método de setter personalizado se ha utilizado para establecer el valor del correo electrónico. El método Getter personalizado devolverá todos los valores de la variable de clase como una lista.

custom_setter_getter.py

# Defina la clase
Persona de clase:
def __init __ (self, nombre, correo electrónico, teléfono):
# Defina las variables de los miembros privados
ser.__name = nombre
ser.__Email = correo electrónico
ser.__phone = teléfono
# Definir Getter personalizado
Def get_person_data (self):
imprimir ("se llama el método de getter personalizado")
regresar [yo.__Name, yo.__Mail, yo.__teléfono]
# Definir setter personalizado
def set_person_data (self, correo electrónico):
imprimir ("se llama el método de setter personalizado")
ser.__Email = correo electrónico
# Crear objeto de la clase
objperson = persona ('rifat bin Hasan', ", '01855435626')
# Establezca el valor de correo electrónico usando el setter personalizado
objero.set_person_data ('[email protected] ')
# Lea todos los valores de los miembros de datos utilizando Getter personalizado
persona = objperson.get_person_data ()
# Imprima los valores de retorno
print ("nombre: \ nemail: \ nphone: ".formato (persona [0], persona [1], persona [2]))

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior.

Setter y getter usando @Property Decorator:

El siguiente script muestra cómo se puede usar el decorador @property para implantar los métodos de Getter y Setter. En el script, el Getter y el Setter han declarado mediante el uso de @Property Decorator para establecer el valor de la variable de nombre, un miembro de clase privada. Después de declarar la clase, se ha definido el objeto de la clase, y el valor de la variable de nombre se ha asignado y recuperado mediante el uso de setter y getter.

decorator_setter_getter.py

# Defina la clase
Persona de clase:
def __init __ (self, name = "):
# Defina las variables de los miembros privados
ser.__name = nombre
# Definir Getter personalizado
@propiedad
DEF NOMBRE (Self):
imprimir ("se llama el método getter")
volver a ser.__nombre
# Definir setter personalizado
@nombre.setter
Nombre Def (yo mismo, nombre):
imprimir ("El método setter se llama")
ser.__name = nombre
# Crear objeto de la clase
objperson = persona ()
# Establezca el valor de correo electrónico usando el setter personalizado
objero.nombre = 'Zanifer Ali'
imprimir ("El nombre de la persona es \ n".formato (objperson.nombre))

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior.

Operador de sobrecarga y función:

Cuando cualquier función u operador se usa para un propósito diferente basado en el parámetro de función o los operandos en lugar del uso normal de la función u operador, se denomina sobrecarga. La función de reutilización se puede implementar en la programación orientada a objetos mediante la sobrecarga del operador y la sobrecarga de funciones. Es una característica útil de OOP, pero el uso excesivo de esta característica crea dificultad para administrar el código. El uso simple de la sobrecarga del operador y la sobrecarga de funciones en la clase Python se ha mostrado en este tutorial.

Sobrecarga del operador:

El operador se usa en dos operandos. El propósito de cada operador es diferente. Por ejemplo, hay muchos usos del operador '+', como se puede usar para suma, combinando dos cuerdas, etc. Pero cuando el operador '+' se usa para un propósito diferente, se llama sobrecarga del operador. Las funciones especiales se utilizan para diferentes tipos de sobrecarga de operadores. La función especial se declara utilizando '__' al principio y finalización del nombre de la función. Existen muchas funciones especiales de diferentes tipos de operadores en Python para sobrecarga de operadores. El operador puede ser matemático, comparación operador, operador de asignación, etc. El uso de la función especial del operador matemático se ha demostrado en esta parte de este tutorial para comprender el concepto de sobrecarga del operador en Python.

Operador matemático:

Los operadores que se utilizan para operaciones aritméticas se llaman operador matemático. Estos operadores pueden usarse para un propósito especial mediante la función de una función especial. A continuación se mencionan algunas funciones especiales del operador matemático.

Nombre del operador	Símbolo	Funcion especial
Suma	+	__add __ (yo, otro)
Sustracción	-	__sub __ (yo, otro)
Multiplicación	*	__mul __ (yo, otro)
División	/	__trudediv __ (yo, otro)
Módulo	De %	__mod __ (yo, otro)
Fuerza	**	__pow __ (yo, otro)

Uso de la función especial del operador de energía (**):

__pow __ () Se utiliza una función especial para sobrecargar el operador de energía. El objetivo principal del operador de energía es calcular el valor de potencia de un número particular. Pero si necesitamos calcular los valores de potencia utilizando valores de punto, entonces el operador de energía general no funcionará. Supongamos que hay dos puntos (3, 2) y (2, 4). Necesitamos la suma de 32 y 24. En este caso, tenemos que usar la función especial del operador de energía. La función __pow __ () puede calcular la suma de las potencias basadas en los valores de puntos que se muestran en el siguiente script. La clase Sumafpower contiene un constructor parametrizado para inicializar dos variables de clase, __pow __ () función para calcular la suma de dos potencias basadas en valores de puntos, y __STR __ () función para imprimir el objeto de la clase. A continuación, se han declarado dos objetos de la clase. El operador de energía ha utilizado dos variables de objetos en la impresión () función para llamar al __pow __ () función para completar la operación.

Operator_verloading.py

# Defina la clase
clase SUMOFPOWERS:
# Defina el constructor de clase
def __init __ (self, n1, n2):
ser.a = n1
ser.B = N2
# Sobrecarga del operador de energía
def __pow __ (self, otro):
a = yo.A ** Otro.a
b = yo.molestar.b
ser.resultado = a + b
return SumOfPowers (A, B)
# función de cadena para imprimir objeto de la clase
def __str __ (self):
regresar str (yo mismo.a)+'+'+str (yo.b)
# Crea el primer objeto
POW1 = SUMOFPOWERS (3, 2)
# Crea el segundo objeto
Pow2 = SumOfPowers (2, 4)
# Calcule los poderes e imprima la suma de los poderes
Imprimir ("La suma de Powers =", Pow1 ** Pow2, "=", Pow1.resultado)

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior. 32 es 9 y 24 es 16. La suma de 9 y 16 es 25 que se muestra en la salida.

Sobrecarga de funciones:

A veces necesitamos escribir múltiples métodos que sean bastante similares pero que difieran solo en algunas partes. En este caso, se puede definir un solo método para hacer las mismas tareas utilizando la sobrecarga de funciones. La complejidad del código se puede eliminar y el código se vuelve más claro utilizando la sobrecarga de funciones. La salida de la función depende del argumento pasado a la función. Cómo se puede implementar la sobrecarga de funciones en Python en el siguiente script. El objetivo principal del script es realizar cuatro tipos de operaciones aritméticas con el valor predeterminado o los valores aprobados en el momento de la creación de objetos. El método nombrado calcular () se ha utilizado aquí para hacer las operaciones aritméticas. El método se ha llamado cuatro veces en el script para hacer cuatro tipos de tareas. Cuando el método llama sin ningún argumento, solo mostrará un mensaje solo. Cuando el método llama con '+' como valor de argumento, calculará los valores predeterminados. Cuando el método llama con '-' y un valor numérico como valores de argumento, luego restará el segundo valor predeterminado del valor del argumento. Cuando el método llama con '*' y dos valores numéricos como valores de argumento, calculará dos valores de argumento.

function_overloading.py

# Defina la clase
clase aritmética:
# Defina la variable de clase
resultado = 0
# Defina el método de clase
def calculación (self, operator = "", número1 = 25, número2 = 35):
# Calcule la suma
if operador == "+":
ser.resultado = número1 + número2
imprimir ('El resultado de la adición es '.formato (yo mismo.resultado))
# Calcule la resta
ELIF Operator == "-":
ser.resultado = número1 - número2
imprimir ('El resultado de la resta es '.formato (yo mismo.resultado))
# Calcule la multiplicación
ELIF Operator == "*":
ser.resultado = número1 * número2
imprimir ('El resultado de la multiplicación es '.formato (yo mismo.resultado))
# Calcule la división
ELIF Operator == "/":
ser.resultado = número1 / número2
imprimir ('El resultado de la división es '.formato (yo mismo.resultado))
demás:
Imprimir ("No se da operador")
# Crea el objeto de la clase
objarithmetic = aritmética ()
# Llamar al método sin argumento
obtaritmético.calcular()
# Llamar al método con un argumento
obtaritmético.Calcular ('+')
# Llame al método con dos argumentos
obtaritmético.Calcular ('-', 50)
# Llame al método con tres argumentos
obtaritmético.Calcular ('*', 2, 3)

Producción:

La siguiente salida aparecerá después de ejecutar el script anterior. 'No se da ningún operador'El mensaje ha impreso para llamar al método sin ningún argumento. La suma de 25 y 35 se ha imprimido para llamar al método con un argumento. El valor de sustracción de 50-35 se ha imprimido para llamar al método con dos valores de argumento. El valor de multiplicación de 3 y 2 ha impreso para llamar al método con tres valores de argumento. De esta manera, la sobrecarga de funciones se ha implementado en el script para usar la misma función varias veces.

Conclusión:

La programación básica orientada a objetos en Python se ha explicado en este tutorial utilizando ejemplos de Python muy simples. Aquí se discuten las características más comunes del OOP para ayudar a los lectores a conocer la forma de OOP en Python y poder escribir el programa Python usando clase y objeto.