Video:Programación orientada a objetos en Python

Programación Orientada a Objetos

Python es un lenguaje de programación multiparadigma. Admite diferentes enfoques de programación.

Uno de los enfoques populares para resolver un problema de programación es mediante la creación de objetos. Esto se conoce como Programación Orientada a Objetos (POO).

Un objeto tiene dos características:

• atributos
• comportamiento

Tomemos un ejemplo:

Un loro es un objeto, ya que tiene las siguientes propiedades:

• nombre, edad, color como atributos
• cantar, bailar como comportamiento

El concepto de programación orientada a objetos en Python se centra en la creación de código reutilizable. Este concepto también se conoce como DRY (Don't Repeat Yourself).

En Python, el concepto de programación orientada a objetos sigue algunos principios básicos:

Clase

Una clase es un modelo para el objeto.

Podemos pensar en la clase como un boceto de un loro con etiquetas. Contiene todos los detalles sobre el nombre, colores, tamaño, etc. Con base en estas descripciones, podemos estudiar sobre el loro. Aquí, un loro es un objeto.

El ejemplo de clase de loro puede ser:

class Parrot:
    pass

Aquí, usamos el class palabra clave para definir una clase vacía Parrot . Desde la clase, construimos instancias. Una instancia es un objeto específico creado a partir de una clase en particular.

Objeto

Un objeto (instancia) es una instanciación de una clase. Cuando se define la clase, solo se define la descripción del objeto. Por lo tanto, no se asigna memoria ni almacenamiento.

El ejemplo de objeto de la clase loro puede ser:

obj = Parrot()

Aquí, obj es un objeto de clase Parrot .

Supongamos que tenemos detalles de loros. Ahora, vamos a mostrar cómo construir la clase y los objetos de loros.

Ejemplo 1:Creación de clases y objetos en Python

class Parrot:

    # class attribute
    species = "bird"

    # instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age

# instantiate the Parrot class
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)

# access the class attributes
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))

# access the instance attributes
print("{} is {} years old".format( blu.name, blu.age))
print("{} is {} years old".format( woo.name, woo.age))

Salida

Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old

En el programa anterior, creamos una clase con el nombre Parrot . Luego, definimos los atributos. Los atributos son una característica de un objeto.

Estos atributos se definen dentro del __init__ método de la clase. Es el método de inicialización que se ejecuta por primera vez tan pronto como se crea el objeto.

Luego, creamos instancias del Parrot clase. Aquí, azul y guau son referencias (valor) a nuestros nuevos objetos.

Podemos acceder al atributo de clase usando __class__.species . Los atributos de clase son los mismos para todas las instancias de una clase. De manera similar, accedemos a los atributos de la instancia usando blu.name y blu.age . Sin embargo, los atributos de instancia son diferentes para cada instancia de una clase.

Para obtener más información sobre clases y objetos, vaya a Clases y objetos de Python

Métodos

Los métodos son funciones definidas dentro del cuerpo de una clase. Se utilizan para definir los comportamientos de un objeto.

Ejemplo 2:Creación de métodos en Python

class Parrot:
    
    # instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # instance method
    def sing(self, song):
        return "{} sings {}".format(self.name, song)

    def dance(self):
        return "{} is now dancing".format(self.name)

# instantiate the object
blu = Parrot("Blu", 10)

# call our instance methods
print(blu.sing("'Happy'"))
print(blu.dance())

Salida

Blu sings 'Happy'
Blu is now dancing

En el programa anterior, definimos dos métodos, es decir, sing() y dance() . Estos se llaman métodos de instancia porque se llaman en un objeto de instancia, es decir, blu .

Herencia

La herencia es una forma de crear una nueva clase para usar detalles de una clase existente sin modificarla. La clase recién formada es una clase derivada (o clase secundaria). De manera similar, la clase existente es una clase base (o clase padre).

Ejemplo 3:uso de la herencia en Python

# parent class
class Bird:
    
    def __init__(self):
        print("Bird is ready")

    def whoisThis(self):
        print("Bird")

    def swim(self):
        print("Swim faster")

# child class
class Penguin(Bird):

    def __init__(self):
        # call super() function
        super().__init__()
        print("Penguin is ready")

    def whoisThis(self):
        print("Penguin")

    def run(self):
        print("Run faster")

peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

Salida

Bird is ready
Penguin is ready
Penguin
Swim faster
Run faster

En el programa anterior, creamos dos clases, es decir, Bird (clase principal) y Pingüino (clase infantil). La clase secundaria hereda las funciones de la clase principal. Podemos ver esto desde el swim() método.

Nuevamente, la clase secundaria modificó el comportamiento de la clase principal. Podemos ver esto desde el whoisThis() método. Además, ampliamos las funciones de la clase padre creando un nuevo run() método.

Además, usamos el super() función dentro del __init__() método. Esto nos permite ejecutar el __init__() método de la clase principal dentro de la clase secundaria.

Encapsulación

Usando OOP en Python, podemos restringir el acceso a métodos y variables. Esto evita que los datos se modifiquen directamente, lo que se denomina encapsulación. En Python, denotamos atributos privados usando guiones bajos como prefijo, es decir, _ único o doble __ .

Ejemplo 4:Encapsulación de datos en Python

class Computer:

    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print("Selling Price: {}".format(self.__maxprice))

    def setMaxPrice(self, price):
        self.__maxprice = price

c = Computer()
c.sell()

# change the price
c.__maxprice = 1000
c.sell()

# using setter function
c.setMaxPrice(1000)
c.sell()

Salida

Selling Price: 900
Selling Price: 900
Selling Price: 1000

En el programa anterior, definimos una Computadora clase.

Usamos __init__() método para almacenar el precio de venta máximo de Computer . Aquí, observe el código

c.__maxprice = 1000

Aquí, hemos intentado modificar el valor de __maxprice fuera de la clase. Sin embargo, dado que __maxprice es una variable privada, esta modificación no se ve en la salida.

Como se muestra, para cambiar el valor, tenemos que usar una función de establecimiento, es decir, setMaxPrice() que toma el precio como parámetro.

Polimorfismo

El polimorfismo es una capacidad (en programación orientada a objetos) para utilizar una interfaz común para varios formularios (tipos de datos).

Supongamos que necesitamos colorear una forma, hay múltiples opciones de forma (rectángulo, cuadrado, círculo). Sin embargo, podríamos usar el mismo método para colorear cualquier forma. Este concepto se llama Polimorfismo.

Ejemplo 5:Usar polimorfismo en Python

class Parrot:

    def fly(self):
        print("Parrot can fly")
    
    def swim(self):
        print("Parrot can't swim")

class Penguin:

    def fly(self):
        print("Penguin can't fly")
    
    def swim(self):
        print("Penguin can swim")

# common interface
def flying_test(bird):
    bird.fly()

#instantiate objects
blu = Parrot()
peggy = Penguin()

# passing the object
flying_test(blu)
flying_test(peggy)

Salida

Parrot can fly
Penguin can't fly

En el programa anterior, definimos dos clases Parrot y Pingüino . Cada uno de ellos tiene un fly() común método. Sin embargo, sus funciones son diferentes.

Para usar polimorfismo, creamos una interfaz común, es decir, flying_test() función que toma cualquier objeto y llama al fly() del objeto método. Así, cuando pasamos el blu y peggy objetos en el flying_test() función, se ejecutó de manera efectiva.

Puntos clave para recordar:

• La programación orientada a objetos hace que el programa sea fácil de entender y eficiente.
• Dado que la clase se puede compartir, el código se puede reutilizar.
• Los datos están seguros y protegidos con la abstracción de datos.
• El polimorfismo permite la misma interfaz para diferentes objetos, por lo que los programadores pueden escribir código eficiente.