Programación orientada a objetos en Python

P

Introducción

La programación orientada a objetos (OOP) es un paradigma de programación en el que diferentes componentes de un programa informático se modelan a partir de objetos del mundo real. Un objeto es cualquier cosa que tenga algunas características y pueda realizar una función.

Considere un escenario en el que tiene que desarrollar un juego de carreras de autos de Fórmula 1 utilizando el enfoque de programación orientada a objetos. Lo primero que debe 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 automóvil. Un automóvil puede tener características como capacidad del motor, marca, modelo, fabricante, etc. De manera similar, un automóvil se puede encender, detener, acelerar, etc. Un piloto puede ser un objeto más en una carrera de Fórmula 1. Un conductor tiene nacionalidad, edad, sexo, 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 programación orientada a objetos

A continuación se muestran algunas de las ventajas de la programación orientada a objetos:

  • La programación orientada a objetos fomenta la reutilización. Un programa informático se escribe en forma de objetos y clases, que también se pueden reutilizar 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 ocurre un error en una parte del código, puede rectificarlo localmente sin tener que afectar 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 discutió, también tiene algunas desventajas, algunas de las cuales se enumeran a continuación:

  • Se necesita un conocimiento de dominio detallado del software que se está desarrollando para crear objetos. No todas las entidades del software son candidatas a implementarse como objetos. Puede ser difícil para los novatos identificar esta delgada línea.
  • 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 sugiere el nombre, la programación orientada a objetos se trata de objetos. Sin embargo, antes de que se pueda crear un objeto, necesitamos definir la clase para el objeto.

Clase

Una clase de programación orientada a objetos sirve como modelo para el objeto. Una clase puede considerarse como un mapa de la casa. Puede hacerse 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 se puede comprender observando la relación entre un automóvil y un Audi. Un Audi es en realidad un automóvil. Sin embargo, no existe solo un automóvil. Un automóvil es un concepto abstracto, en realidad se implementa en forma de Toyota, Ferrari, Honda, etc.

La palabra clave classse usa para crear una clase en Python. El nombre de la clase sigue a la classpalabra clave, seguido del carácter de dos puntos. El cuerpo de la clase comienza en una nueva línea, con sangría en una pestaña desde la izquierda.

Veamos cómo podemos crear una clase muy básica en Python. Eche 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: name, make, y model. La carclase también contiene dos métodos: start()y stop().

Objetos

Anteriormente, dijimos que una clase proporciona un plano. Sin embargo, para utilizar realmente los objetos y métodos de una clase, necesita crear un objeto a partir 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, necesitamos crear un objeto de una clase antes de que podamos usar sus métodos y atributos.

Un objeto también se denomina instancia; por lo tanto, el proceso de creación de un objeto de una clase se denomina instanciación. En Python, para crear un objeto de una clase, simplemente necesitamos escribir el nombre de la clase seguido de paréntesis de apertura y cierre.

Creemos 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 car: car_ay car_b. Para comprobar el tipo de objetos que creamos, podemos usar el typemétodo y pasarle el nombre de nuestro objeto. Ejecute el siguiente script:

print(type(car_b))

En la salida, verá:

<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 debe 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. Eche 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. Ejecute el siguiente script:

dir(car_b)

En la salida, verá 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 de REPL de Python.

Atributos de clase frente a instancia

Los atributos se pueden categorizar ampliamente en dos tipos: 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 name, makey mode. La clase contiene un método start()que contiene los tres atributos de instancia. Los valores de 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.

Creemos un objeto de la Carclase y llamemos 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_count. Verá 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ó de nuevo, por lo tanto, el valor final se convirtió en 2. La salida se ve así:

Engine started
City
2

Métodos

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()y stop()métodos para la Carclase. Hasta ahora, hemos estado usando los objetos de una clase para llamar a los métodos. Sin embargo, existe un tipo de método que se puede llamar directamente usando el nombre de la clase. Este 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.

Devolver varios valores 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. Eche 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 por sí mismo y devuelve ambos resultados usando returndeclaración. En la salida del script anterior, verá los cuadrados de 3 y 5.

El método str

Hasta ahora hemos estado imprimiendo atributos usando 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. Ejecute 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 de Python tiene un __str__método por defecto. Cuando usa el objeto como una cadena, __str__se llama al método, que de forma predeterminada imprime la ubicación de memoria del objeto. Sin embargo, también puede proporcionar su propia definición del __str__método. Por ejemplo, mire 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 proporcionando 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 .

Con 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__. Eche 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_count. La clase contiene un constructor que incrementa el valor de car_counte imprime el valor resultante en la pantalla.

Ahora, siempre Carque se cree un objeto de la clase, se llamará al constructor, el valor de car_countse incrementará y se mostrará en la pantalla. Creemos un objeto simple y veamos qué sucede:

car_a = Car()
car_b = Car()
car_c = Car()

En la salida, verá un valor de 1, 2 y 3 impreso, 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 se puede utilizar como método ordinario. Puede pasar y recibir valores de un constructor. Por lo general, se usa de esta manera cuando desea inicializar valores de atributo al crear una instancia de la clase.

Local vs Global Variables

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. Dependiendo del 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 está definida. 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 guión:

# 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 creemos un objeto de la Carclase e intentemos acceder a la variable local messagecomo se muestra a continuación:

car_a = Car()
print(car_a.message)

La secuencia de comandos 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 está definida la variable local.

Global Variable

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. Eche 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 error.

Es importante mencionar que existe una diferencia entre los atributos de clase e instancia, y las variables locales y globales. Los atributos de clase e instancia difieren en la forma en que se accede a ellos, es decir, utilizando el nombre de la clase y el nombre de la instancia. Por otro lado, las variables locales y globales difieren en su alcance, es decir, en el lugar donde se puede acceder a ellas. Solo 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 self.

Modificadores de acceso

Los modificadores de acceso en Python se utilizan para modificar el alcance predeterminado de las variables. Hay 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 en cualquier lugar dentro o fuera de la clase, las variables privadas solo se pueden acceder dentro de la clase, mientras que las variables protegidas se pueden acceder dentro del mismo paquete.

Para crear una variable privada, debe anteponer doble subrayado con el nombre de la variable. Para crear una variable protegida, debe anteponer un guión bajo con el nombre de la variable. Para las variables públicas, no es necesario que agregue ningún prefijo.

Veamos las variables públicas, privadas y protegidas en acción. Ejecute 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 name, makey model. La namevariable es pública, mientras que las variables makey modelse han declarado privadas y protegidas, respectivamente.

Creemos un objeto de la Carclase e intentemos acceder a la namevariable. Ejecute el siguiente script:

car_a = Car()
print(car_a.name)

Dado que namees una variable pública, podemos acceder a ella fuera de la clase. En la salida, verá el valor del nameimpreso en la consola.

Ahora intentemos imprimir el valor de la makevariable. Ejecute 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 PIE.

Herencia

La herencia en la programación orientada a objetos es bastante similar a la herencia del 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 otra clase se llama clase secundaria o clase derivada, y la clase que hereda otra clase se llama clase principal o base.

Echemos un vistazo a un ejemplo muy simple de herencia. Ejecute 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 Vehicleclass, y la Carclase que hereda la Vehicleclase. Para heredar una clase, simplemente debe 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, dado que la Carclase hereda la Vehicleclase, también heredará el vehicle_method().

Veamos esto en acción. Ejecute 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 lo llamamos vehicle_method()usando ese Carobjeto de clase. Puede ver que la Carclase no tiene ninguno, vehicle_method()pero dado que ha heredado la Vehicleclase que contiene vehicle_method(), la clase car 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 forma similar, una clase hijo puede tener varias clases padre. Echemos un vistazo al primer escenario. Ejecute 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 Cary Cycle. Ambas clases secundarias tendrán acceso a la vehicle_method()clase principal. Ejecute el siguiente script para ver eso:

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. Del mismo modo, un niño puede tener varios 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: Camera, Radio, y CellPhone. La Cameraclase y las Radioclases son heredadas por la CellPhoneclase, lo que significa que la CellPhoneclase tendrá acceso a los métodos de ambas clases Cameray Radio. 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 de comportarse de múltiples formas.

El polimorfismo en la programación se implementa mediante la sobrecarga de métodos y la anulación de métodos.

Sobrecarga de métodos

La sobrecarga de métodos se refiere a la propiedad de un método de comportarse de diferentes maneras dependiendo del número o tipos de parámetros. Eche un vistazo a un ejemplo muy simple de sobrecarga de métodos. Ejecute 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 con un solo argumento primero:

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.

Anulación de método

La anulación de 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 principal y secundaria, pero el nombre sigue siendo el mismo. Tomemos un método de ejemplo simple anulado 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 anterior, las clases Cary Cycleheredan la Vehicleclase. La clase de vehículo tiene un print_details()método, que es 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 principal, los métodos se comportan de manera diferente.

Encapsulamiento

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 debería tener acceso directo a los datos de la otra clase. Más bien, el acceso debe controlarse mediante métodos de clase.

Para proporcionar acceso controlado a los datos de la 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 menor que 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 del modelo que implemente 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. Tienes que definir el atributo, que está modelen el script anterior. A continuación, debe definir la propiedad para el atributo usando el decorador @property. Finalmente, debe crear un establecedor de propiedades que sea un @model.setterdescriptor en el script anterior.

Ahora, si intenta ingresar un valor mayor que 2018 para el atributo del modelo, verá que el valor está establecido en 2018. Probemos esto. Ejecute el siguiente script:

car_a = Car(2088)
print(car_a.get_car_model())

Aquí estamos pasando 2088 como el valor de model, sin embargo, si imprime el valor del 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 orientada a objetos más importantes. La programación orientada a objetos es uno de los paradigmas de programación más famosos y 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 admiten programación orientada a objetos.

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias para su correcto funcionamiento. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad