Breaking

Post Top Ad

Your Ad Spot

martes, 9 de julio de 2019

Programación Orientada a Objetos en Python

Introducción

La programación orientada a objetos (OOP) es un paradigma de programación en el que diferentes componentes de un programa de computadora se modelan a partir de objetos del mundo real. Un objeto es cualquier cosa que tiene algunas características y puede realizar una función.
Considere un escenario en el que tiene que desarrollar un juego de carreras de coches de Fórmula 1 utilizando el enfoque de programación orientada a objetos. Lo primero que debes hacer es identificar objetos del mundo real en la carrera de Fórmula 1 real. ¿Cuáles son las entidades en una carrera de Fórmula 1 que tienen algunas características y pueden realizar cualquier función? Una de las respuestas obvias a esta pregunta es el auto. Un automóvil puede tener características como la capacidad del motor, la marca, el modelo, el fabricante, etc. De forma similar, un automóvil puede arrancarse, detenerse, acelerarse, etc. Un piloto puede ser otro objeto en una carrera de Fórmula 1. Un conductor tiene una nacionalidad, edad, género, etc., y puede realizar funciones como conducir el automóvil, mover la dirección o cambiar la transmisión.
Al igual que en este ejemplo, en la programación orientada a objetos crearemos objetos para la entidad del mundo real correspondiente.
Es importante mencionar aquí que la programación orientada a objetos no es un concepto dependiente del lenguaje. Es un concepto de programación general y la mayoría de los lenguajes modernos, como Java, C #, C ++ y Python, admiten la programación orientada a objetos. En este artículo, veremos una introducción detallada a la programación orientada a objetos en Python, pero antes de eso, veremos algunas de las ventajas y desventajas de la programación orientada a objetos.

Pros y contras de la POO

Las siguientes son algunas de las ventajas de la programación orientada a objetos:
  • La programación orientada a objetos fomenta la reutilización. Un programa de computadora se escribe en forma de objetos y clases, que también pueden reutilizarse en otros proyectos.
  • El enfoque modular utilizado en la programación orientada a objetos da como resultado un código altamente mantenible.
  • En la programación orientada a objetos, cada clase tiene una tarea específica. Si se produce un error en una parte del código, puede rectificarlo localmente sin tener que afectar a otras partes del código.
  • La encapsulación de datos (que estudiaremos más adelante en el artículo) agrega una capa adicional de seguridad al programa desarrollado utilizando el enfoque orientado a objetos.
Aunque la programación orientada a objetos tiene varias ventajas, como se comentó, también tiene algunas desventajas, algunas de las cuales se han incluido a continuación:
  • Se necesita un conocimiento detallado del dominio del software que se está desarrollando para crear objetos. No todas las entidades en el software son candidatas para ser implementadas como un objeto. Puede ser difícil para los novatos identificar esta línea fina.
  • A medida que agrega más y más clases al código, el tamaño y la complejidad del programa aumentan exponencialmente.
En la siguiente sección, veremos algunos de los conceptos más importantes de la programación orientada a objetos.
Como su nombre lo indica, la programación orientada a objetos se trata de objetos. Sin embargo, antes de poder crear un objeto, necesitamos definir la clase para el objeto.

Clase

Una clase en programación orientada a objetos sirve como un plano para el objeto. Una clase puede ser considerada como un mapa para la casa. Puedes tener una idea de cómo se ve la casa simplemente viendo el mapa. Sin embargo, una clase en sí misma no es nada. Por ejemplo, un mapa no es una casa, solo explica cómo se verá la casa real.
La relación entre una clase y un objeto puede entenderse observando la relación entre un automóvil y un Audi. Un Audi es en realidad un coche. Sin embargo, no hay tal cosa como un coche solamente. Un automóvil es un concepto abstracto, en realidad se implementa en forma de Toyota, Ferrari, Honda, etc.
La palabra clave classse utiliza para crear una clase en Python. El nombre de la clase sigue la classpalabra clave, seguido del carácter de dos puntos. El cuerpo de la clase comienza en una nueva línea, sangrada una pestaña desde la izquierda.
Veamos cómo podemos crear una clase muy básica en Python. Echa un vistazo al siguiente código:
# Creates class Car
class Car:

    # create class attributes
    name = "c200"
    make = "mercedez"
    model = 2008

    # create class methods
    def start(self):
        print ("Engine started")

    def stop(self):
        print ("Engine switched off")
En el ejemplo anterior, creamos una clase llamada Carcon tres atributos: namemake, y modelLa carclase también contiene dos métodos: start()stop().

Objetos

Anteriormente, dijimos que una clase proporciona un plan. Sin embargo, para utilizar realmente los objetos y métodos de una clase, debe crear un objeto fuera de esa clase. Hay pocos métodos y atributos de clase que se pueden usar sin un objeto, que veremos en la sección posterior. Por ahora, solo tenga en cuenta que, de forma predeterminada, debemos crear un objeto de una clase antes de poder usar sus métodos y atributos.
Un objeto también se llama una instancia; por lo tanto, el proceso de crear un objeto de una clase se llama instanciación . En Python, para crear un objeto de una clase, simplemente necesitamos escribir el nombre de la clase seguido de la apertura y cierre del paréntesis.
Vamos a crear un objeto de la Carclase que creamos en la última sección.
# Creates car_a object of Car class
car_a = Car()

# Creates car_b object of car class
car_b = Car()  
En el script anterior, creamos dos objetos de la clase de automóvil: car_acar_bPara verificar el tipo de objetos que creamos, podemos usar el typemétodo y pasarle el nombre de nuestro objeto. Ejecuta el siguiente script:
print(type(car_b))  
En la salida, verás:
<class '__main__.Car'>  
Lo que dice que el tipo de car_bobjeto es una clase Car.
En este punto hemos creado nuestra clase y los objetos correspondientes. Ahora es el momento de acceder a los atributos de clase y llamar al método de clase utilizando el objeto de clase. Para hacerlo, simplemente tiene que escribir el nombre del objeto, seguido del operador de punto y el nombre del atributo o el método al que desea acceder o llamar, respectivamente. Echa un vistazo al siguiente ejemplo:
car_b.start()  
En el script anterior, llamamos al start()método a través del car_bobjeto. La salida será la siguiente:
Engine started  
Del mismo modo, puede acceder a un atributo utilizando la siguiente sintaxis:
print(car_b.model)  
En la salida, verá el valor del modelatributo, como se muestra a continuación:
2008  

Atributos

En la sección anterior, vimos cómo podemos crear objetos de una clase y podemos usar esos objetos para acceder a los atributos de una clase.
En Python, cada objeto tiene algunos atributos y métodos predeterminados además de los atributos definidos por el usuario. Para ver todos los atributos y métodos de un objeto, dir()se puede utilizar la función incorporada Intentemos ver todos los atributos del car_bobjeto que creamos en la última sección. Ejecuta el siguiente script:
dir(car_b)  
En la salida, verás los siguientes atributos:
['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'make',
 'model',
 'name',
 'start',
 'stop']
Esta función incorporada es útil para inspeccionar todos los atributos y funciones de un objeto, especialmente cuando se usa a través del REPL de Python.

Atributos de clase vs instancia

Los atributos se pueden clasificar en dos categorías: atributos de clase y atributos de instancia. Los atributos de clase son compartidos por todos los objetos de una clase, mientras que los atributos de instancia son propiedad exclusiva de la instancia.
Recuerde, una instancia es solo otro nombre para el objeto. Los atributos de instancia se declaran dentro de cualquier método, mientras que los atributos de clase se declaran fuera de cualquier método. El siguiente ejemplo aclara la diferencia:
class Car:

    # create class attributes
    car_count = 0

    # create class methods
    def start(self, name, make, model):
        print ("Engine started")
        self.name = name
        self.make = make
        self.model = model
        Car.car_count += 1
En el script anterior, creamos una clase Carcon un atributo de clase car_county tres atributos de instancia namemakemodeLa clase contiene un método start()que contiene los tres atributos de instancia. Los valores para los atributos de instancia se pasan como argumentos al start()método. Dentro del startmétodo, el car_countatributo se incrementa en uno.
Es importante mencionar que dentro del método, los atributos de instancia son referidos usando la selfpalabra clave, mientras que los atributos de clase son referidos por el nombre de clase.
Vamos a crear un objeto de la Carclase y llamar al start()método.
car_a = Car()  
car_a.start("Corrola", "Toyota", 2015)  
print(car_a.name)  
print(car_a.car_count)  
En el script anterior imprimimos el atributo de instancia namey el atributo de clase car_countVerá en la salida que el car_countatributo tendrá un valor de 1, como se muestra a continuación:
Engine started  
Corrola  
1  
Ahora, creemos otro objeto de la carclase y llamemos al start()método.
car_b = Car()  
car_b.start("City", "Honda", 2013)  
print(car_b.name)  
print(car_b.car_count)  
Ahora, si imprime el valor del car_countatributo, verá 2 en la salida. Esto se debe a que el car_countatributo es un atributo de clase y, por lo tanto, se comparte entre las instancias. El car_aobjeto incrementó su valor a 1, mientras que el car_bobjeto lo incrementó nuevamente, por lo tanto, el valor final se convirtió en 2. La salida se ve así:
Engine started  
City  
2  

Los metodos

Como describimos anteriormente, en la programación orientada a objetos, los métodos se utilizan para implementar las funcionalidades de un objeto. En la sección anterior, creamos start()stop()métodos para la Carclase. Hasta ahora, hemos estado utilizando los objetos de una clase para llamar a los métodos. Sin embargo, hay un tipo de método que se puede llamar directamente usando el nombre de la clase. Tal método se llama método estático .

Métodos estáticos

Para declarar un método estático, debe especificar el @staticmethoddescriptor antes del nombre del método como se muestra a continuación:
class Car:

    @staticmethod
    def get_class_details():
        print ("This is a car class")

Car.get_class_details()  
En el script anterior, creamos una clase Carcon un método estático get_class_details()Llamemos a este método usando el nombre de la clase.
Car.get_class_details()  
Puede ver que no necesitamos crear una instancia de la Carclase para llamar al get_class_details()método, sino que simplemente usamos el nombre de la clase. Es importante mencionar que los métodos estáticos solo pueden acceder a los atributos de clase en Python.

Devolviendo valores múltiples de un método

Una de las mejores características del lenguaje Python es la capacidad de los métodos de clase para devolver múltiples valores. Echa un vistazo al siguiente ejemplo:
class Square:

    @staticmethod
    def get_squares(a, b):
        return a*a, b*b

print(Square.get_squares(3, 5))  
En el script anterior, creamos una clase nombrada Squarecon un método estático get_squares()El método toma dos parámetros; multiplica cada parámetro consigo mismo y devuelve ambos resultados usando la returndeclaración. En la salida del script anterior, verás los cuadrados de 3 y 5.

El método str

Hasta ahora hemos estado imprimiendo atributos utilizando el print()método. Veamos qué pasa si imprimimos el objeto de una clase.
Para hacerlo, crearemos una Carclase simple con un método e intentaremos imprimir el objeto de la clase en la consola. Ejecuta el siguiente script:
class Car:

    # create class methods
    def start(self):
        print ("Engine started")

car_a = Car()  
print(car_a)  
En el script anterior creamos el car_aobjeto de la Carclase e imprimimos su valor en la pantalla. Básicamente aquí estamos tratando el car_aobjeto como una cadena. La salida se ve así:
<__main__.Car object at 0x000001CCCF4335C0>  
La salida muestra la ubicación de la memoria donde se almacena nuestro objeto. Cada objeto Python tiene un __str__método por defecto. Cuando utiliza el objeto como una cadena, __str__se llama al método, que de forma predeterminada imprime la ubicación de la memoria del objeto. Sin embargo, también puede proporcionar su propia definición para el __str__método. Por ejemplo, mira el siguiente ejemplo:
# Creates class Car
class Car:

    # create class methods

    def __str__(self):
        return "Car class Object"

    def start(self):
        print ("Engine started")

car_a = Car()  
print(car_a)  
En el script anterior, anulamos el __str__método al proporcionar nuestra propia definición personalizada para el método. Ahora, si imprime el car_aobjeto, verá el mensaje "Objeto de clase de automóvil" en la consola. Este es el mensaje que imprimimos dentro de nuestro __str__método personalizado .
Usando este método, puede crear descripciones personalizadas y más significativas para cuando se imprime un objeto. Incluso podría mostrar algunos de los datos dentro de la clase, como el namede una Personclase.

Constructores

Un constructor es un método especial que se llama de forma predeterminada cada vez que crea un objeto de una clase.
Para crear un constructor, debe crear un método con palabra clave __init__Echa un vistazo al siguiente ejemplo:
class Car:

    # create class attributes
    car_count = 0

    # create class methods
    def __init__(self):
        Car.car_count +=1
        print(Car.car_count)
En el script anterior, creamos una Carclase con un atributo de clase car_countLa clase contiene un constructor que incrementa el valor de car_counte imprime el valor resultante en la pantalla.
Ahora, cada vez Carque se creará un objeto de la clase se llamará al constructor, el valor de la misma car_countse incrementará y se mostrará en la pantalla. Vamos a crear un objeto simple y ver qué pasa:
car_a = Car()  
car_b = Car()  
car_c = Car()  
En la salida, verá un valor de 1, 2 y 3 impresos ya que con cada objeto el valor de la car_countvariable se incrementa y se muestra en la pantalla.
Excepto por el nombre, el constructor puede usarse como un método ordinario. Puedes pasar y recibir valores de un constructor. Por lo general, se usa de esta manera cuando desea inicializar valores de atributos al crear una instancia de la clase.

Variables locales vs globales

Sabemos que hay dos tipos de atributos de Python, atributos de instancia y atributos de clase. Los atributos de una clase también se conocen como variables. Según el alcance, las variables también se pueden clasificar en dos tipos: variables locales y variables globales.

Variables locales

Una variable local en una clase es una variable a la que solo se puede acceder dentro del bloque de código donde se define. Por ejemplo, si define una variable dentro de un método, no se puede acceder a ella en ningún lugar fuera de ese método. Mira el siguiente script:
# Creates class Car
class Car:  
    def start(self):
        message = "Engine started"
        return message
En el script anterior creamos una variable local messagedentro del start()método de la Carclase. Ahora vamos a crear un objeto de la Carclase e intentar acceder a la variable local messagecomo se muestra a continuación:
car_a = Car()  
print(car_a.message)  
El script anterior devolverá el siguiente error:
AttributeError: 'Car' object has no attribute 'message'  
Esto se debe a que no podemos acceder a la variable local fuera del bloque en el que se define la variable local.

Variable global

Una variable global se define fuera de cualquier bloque de código, por ejemplo, método, sentencias if, etc. Se puede acceder a una variable global en cualquier parte de la clase. Echa un vistazo al siguiente ejemplo.
# Creates class Car
class Car:  
    message1 = "Engine started"

    def start(self):
        message2 = "Car started"
        return message2

car_a = Car()  
print(car_a.message1)  
En el script anterior, creamos una variable global message1e imprimimos su valor en la pantalla. En la salida, verá el valor de la message1variable, impreso sin un error.
Es importante mencionar que existe una diferencia entre los atributos de clase y instancia, y las variables locales frente a las globales. Los atributos de clase e instancia difieren en la forma en que se accede, es decir, usando el nombre de clase y usando el nombre de instancia. Por otro lado, las variables locales vs globales difieren en su alcance, o en otras palabras, el lugar donde se puede acceder. Sólo se puede acceder a una variable local dentro del método. Aunque en este artículo, tanto la variable local como los atributos de instancia se definen dentro del método, el atributo local se define con la palabra clave propia.

Modificadores de acceso

Los modificadores de acceso en Python se utilizan para modificar el alcance predeterminado de las variables. Existen tres tipos de modificadores de acceso en Python: público, privado y protegido.
Se puede acceder a las variables con los modificadores de acceso público desde cualquier lugar dentro o fuera de la clase, solo se puede acceder a las variables privadas dentro de la clase, mientras que se puede acceder a las variables protegidas dentro del mismo paquete.
Para crear una variable privada, debe prefijar los guiones bajos con el nombre de la variable. Para crear una variable protegida, debe prefijar un guión bajo con el nombre de la variable. Para las variables públicas, no es necesario agregar ningún prefijo.
Veamos variables públicas, privadas y protegidas en acción. Ejecuta el siguiente script:
class Car:  
    def __init__(self):
        print ("Engine started")
        self.name = "corolla"
        self.__make = "toyota"
        self._model = 1999
En el guión anterior, creamos una sencilla Carclase con un constructor y tres variables namemakemodelLa namevariable es pública, mientras que las variables makemodelse han declarado privadas y protegidas, respectivamente.
Vamos a crear un objeto de la Carclase e intentar acceder a la namevariable. Ejecuta el siguiente script:
car_a = Car()  
print(car_a.name)  
Dado que namees una variable pública, por lo tanto podemos acceder a ella fuera de la clase. En la salida, verá el valor para el nameimpreso en la consola.
Ahora intentemos imprimir el valor de la makevariable. Ejecuta el siguiente script:
print(car_a.make)  
En la salida, verá el siguiente mensaje de error:
AttributeError: 'Car' object has no attribute 'make'  
Hemos cubierto la mayoría de los conceptos básicos de programación orientada a objetos en las últimas secciones. Ahora, hablemos de los pilares de la programación orientada a objetos: polimorfismo, herencia y encapsulación, denominados colectivamente como PIE.

Herencia

La herencia en la programación orientada a objetos es bastante similar a la herencia en el mundo real donde un niño hereda algunas de las características de sus padres, además de sus propias características únicas.
En la programación orientada a objetos, la herencia significa una relación IS-A. Por ejemplo, un automóvil es un vehículo. La herencia es uno de los conceptos más sorprendentes de la programación orientada a objetos, ya que fomenta la reutilización del código.
La idea básica de la herencia en la programación orientada a objetos es que una clase puede heredar las características de otra clase. La clase que hereda a otra clase se llama clase secundaria o clase derivada, y la clase que es heredada por otra clase se llama clase principal o base.
Echemos un vistazo a un ejemplo muy simple de la herencia. Ejecuta el siguiente script:
# Create Class Vehicle
class Vehicle:  
    def vehicle_method(self):
        print("This is parent Vehicle class method")

# Create Class Car that inherits Vehicle
class Car(Vehicle):  
    def car_method(self):
        print("This is child Car class method")
En el script anterior, creamos dos clases de Vehicleclase y la Carclase que hereda la Vehicleclase. Para heredar una clase, simplemente tiene que escribir el nombre de la clase principal dentro del paréntesis que sigue al nombre de la clase secundaria. La Vehicleclase contiene un método vehicle_method()y la clase secundaria contiene un método car_method()Sin embargo, como la Carclase hereda la Vehicleclase, también heredará la clase vehicle_method().
Veamos esto en acción. Ejecuta el siguiente script:
car_a = Car()  
car_a.vehicle_method() # Calling parent class method  
En el script anterior, creamos un objeto de la Carclase y llamamos al objeto vehicle_method()que usa esa Carclase. Puede ver que la Carclase no tiene ninguno, vehicle_method()pero como ha heredado la Vehicleclase que contiene el vehicle_method(), la clase de automóvil también puede usarlo. La salida se ve así:
This is parent Vehicle class method  
En Python, una clase padre puede tener varios hijos y, de manera similar, una clase hijo puede tener varias clases padre. Echemos un vistazo al primer escenario. Ejecuta el siguiente script:
# Create Class Vehicle
class Vehicle:  
    def vehicle_method(self):
        print("This is parent Vehicle class method")

# Create Class Car that inherits Vehicle
class Car(Vehicle):  
    def car_method(self):
        print("This is child Car class method")

# Create Class Cycle that inherits Vehicle
class Cycle(Vehicle):  
    def cycleMethod(self):
        print("This is child Cycle class method")
En el script anterior, la Vehicleclase principal es heredada por dos clases secundarias CarCycleAmbas clases secundarias tendrán acceso a la vehicle_method()clase principal. Ejecute el siguiente script para ver que:
car_a = Car()  
car_a.vehicle_method() # Calling parent class method  
car_b = Cycle()  
car_b.vehicle_method() # Calling parent class method  
En la salida, verá la salida del vehicle_method()método dos veces como se muestra a continuación:
This is parent Vehicle class method  
This is parent Vehicle class method  
Puede ver cómo una clase principal puede ser heredada por dos clases secundarias. De la misma manera, un niño puede tener múltiples padres. Echemos un vistazo al ejemplo:
class Camera:  
    def camera_method(self):
        print("This is parent Camera class method")

class Radio:  
    def radio_method(self):
        print("This is parent Radio class method")

class CellPhone(Camera, Radio):  
     def cell_phone_method(self):
        print("This is child CellPhone class method")
En el guión anterior, creamos tres clases: CameraRadio, y CellPhoneLa Cameraclase y las Radioclases son heredados por la CellPhoneclase que significa que la CellPhoneclase tendrá acceso a los métodos de ambos CameraRadioclases. La siguiente secuencia de comandos verifica esto:
cell_phone_a = CellPhone()  
cell_phone_a.camera_method()  
cell_phone_a.radio_method()  
La salida se ve así:
This is parent Camera class method  
This is parent Radio class method  

Polimorfismo

El término polimorfismo significa literalmente tener múltiples formas. En el contexto de la programación orientada a objetos, el polimorfismo se refiere a la capacidad de un objeto para comportarse de múltiples maneras.
El polimorfismo en la programación se implementa a través de la sobrecarga de métodos y la invalidación de métodos.

Método de sobrecarga

La sobrecarga de métodos se refiere a la propiedad de un método para comportarse de diferentes maneras dependiendo del número o los tipos de parámetros. Eche un vistazo a un ejemplo muy simple de sobrecarga de métodos. Ejecuta el siguiente script:
# Creates class Car
class Car:  
   def start(self, a, b=None):
        if b is not None:
            print (a + b)
        else:
            print (a)
En el script anterior, si start()se llama al método pasando un solo argumento, el parámetro se imprimirá en la pantalla. Sin embargo, si pasamos 2 argumentos al start()método, agregará ambos argumentos e imprimirá el resultado de la suma.
Probemos primero con un solo argumento:
car_a = Car()  
car_a.start(10)  
En la salida, verá 10. Ahora intentemos pasar 2 argumentos:
car_a.start(10,20)  
En la salida, verá 30.

Método Anulando

La anulación del método se refiere a tener un método con el mismo nombre en la clase secundaria que en la clase principal. La definición del método difiere en las clases padre e hijo, pero el nombre sigue siendo el mismo. Tomemos un método de ejemplo simple que reemplaza en Python.
# Create Class Vehicle
class Vehicle:  
    def print_details(self):
        print("This is parent Vehicle class method")

# Create Class Car that inherits Vehicle
class Car(Vehicle):  
    def print_details(self):
        print("This is child Car class method")

# Create Class Cycle that inherits Vehicle
class Cycle(Vehicle):  
    def print_details(self):
        print("This is child Cycle class method")
En el script de arriba, las clases CarCycleheredan la Vehicleclase. La clase de vehículo tiene un print_details()método, que está anulado por las clases secundarias. Ahora, si llama al print_details()método, la salida dependerá del objeto a través del cual se llama al método. Ejecute el siguiente script para ver este concepto en acción:
car_a = Vehicle()  
car_a. print_details()

car_b = Car()  
car_b.print_details()

car_c = Cycle()  
car_c.print_details()  
La salida se verá así:
This is parent Vehicle class method  
This is child Car class method  
This is child Cycle class method  
Puede ver que la salida es diferente, aunque el print_details()método se llama a través de clases derivadas de la misma clase base. Sin embargo, dado que las clases secundarias han anulado el método de la clase primaria, los métodos se comportan de manera diferente.

Encapsulacion

La encapsulación es el tercer pilar de la programación orientada a objetos. La encapsulación simplemente se refiere a la ocultación de datos. Como principio general, en la programación orientada a objetos, una clase no debe tener acceso directo a los datos de la otra clase. Más bien, el acceso debe ser controlado a través de métodos de clase.
Para proporcionar acceso controlado a los datos de clase en Python, se utilizan los modificadores de acceso y las propiedades. Ya hemos visto modificadores de acceso, en esta sección veremos propiedades en acción.
Supongamos que queremos asegurarnos de que el modelo de automóvil siempre debe estar entre 2000 y 2018. Si un usuario intenta ingresar un valor inferior a 2000 para el modelo de automóvil, el valor se establece automáticamente en 2000 y si el valor ingresado es mayor que 2018, debe establecerse en 2018. Si el valor está entre 2000 y 2018, no debe cambiarse. Podemos crear una propiedad para el atributo de modelo que implementa esta lógica de la siguiente manera:
# Creates class Car
class Car:

    # Creates Car class constructor
    def __init__(self, model):
        # initialize instance variables
        self.model = model

    # Creates model property
    @property
    def model(self):
        return self.__model

    # Create property setter
    @model.setter
    def model(self, model):
        if model < 2000:
            self.__model = 2000
        elif model > 2018:
            self.__model = 2018
        else:
            self.__model = model

    def getCarModel(self):
        return "The car model is " + str(self.model)

carA = Car(2088)  
print(carA.getCarModel())  
Una propiedad tiene tres partes. Debe definir el atributo, que se encuentra modelen el script anterior. A continuación, debe definir la propiedad del atributo utilizando el decorador @property . Finalmente, debe crear el establecedor de propiedades que es el @model.setterdescriptor en el script anterior.
Ahora, si intenta ingresar un valor mayor que 2018 para el atributo de modelo, verá que el valor está establecido en 2018. Probemos esto. Ejecuta el siguiente script:
car_a = Car(2088)  
print(car_a.get_car_model())  
Aquí estamos pasando 2088 como valor para model, sin embargo, si imprime el valor para el modelatributo a través de la get_car_model()función, verá 2018 en la salida.

Conclusión

En este artículo, estudiamos algunos de los conceptos de programación orientados a objetos más importantes. La programación orientada a objetos es uno de los paradigmas de programación más famosos y más utilizados. La importancia de la programación orientada a objetos se refleja en el hecho de que la mayoría de los lenguajes de programación modernos están totalmente orientados a objetos o son compatibles con la programación orientada a objetos.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas