¿Qué es la Programación Orientada a Objetos?

Introducción a la Programación Orientada a Objetos en Python

¡Hola, futuro maestro del código! En esta lectura, exploraremos el fascinante mundo de la Programación Orientada a Objetos (POO). Descubrirás qué es la POO y cómo esta poderosa técnica te permite crear programas más organizados, reutilizables y fáciles de mantener.

A continuación veremos un pequeño ejemplo sobre cómo representar una persona con una clase de Python.

1class Persona:
2    def __init__(self, nombre, apellido, edad):
3        self.nombre = nombre
4        self.apellido = apellido
5        self.edad = edad
6
7    def mensaje_presentacion(self):
8        return f"¡Hola!, me llamo {self.nombre} {self.apellido} y tengo {self.edad} años de edad"
9
10
11persona = Persona("Thomas", "Smith", 27)
12print(persona.mensaje_presentacion()) # output: ¡Hola!, me llamo Thomas Smith y tengo 27 años de edad

En este ejemplo vemos cómo representar una persona haciendo uso de este estilo de la programación orientada a objetos (POO), para representar un objeto del mundo real en una clase, primeros debes crear una clase con el nombre de ese objeto, luego dentro de la clase creas la función __init__() y dentro de esta función crearás las propiedades de tu objeto como por ejemplo el nombre, la edad, el peso etc..., también puedes crear funciones (métodos) para tu manipular las propiedades del objeto.

¿Qué es la Programación Orientada a Objetos (POO)?

La Programación Orientada a Objetos (POO) es un enfoque de programación que se basa en la idea de "objetos". En lugar de escribir líneas de código secuencial, en la POO creamos objetos que representan entidades del mundo real o conceptos abstractos. Estos objetos contienen tanto datos (atributos), como funciones (métodos) que actúan sobre esos datos. 🏰🔧

La programación orientada a objetos (POO) se basa en cuatro principios fundamentales.

1. Abstracción: Representamos entidades y conceptos del mundo real en forma de objetos con atributos y métodos.

2. Encapsulación: Ocultamos los detalles internos del objeto y solo exponemos una interfaz para interactuar con él.

3. Herencia: Los objetos pueden heredar atributos y métodos de otros objetos, lo que permite crear jerarquías de clases.

4. Polimorfismo: Los objetos pueden utilizar los mismos métodos con distintas implementaciones.

No te preocupes, luego explicaremos más a fondo cada uno de estos conceptos.

Clases y Objetos: Los Pilares de la POO

En la POO, definimos las características y comportamientos de un objeto mediante una "clase". Una clase es como un plano o plantilla que describe cómo se crea el objeto y qué puede hacer. Por ejemplo, podemos tener una clase Perro que tenga atributos como nombre y edad, y métodos como ladrar() y jugar(). 🐶

A continuación crearemos una clase que representa una computadora paso a paso, para que puedas entender mejor cómo funciona el concepto de clases en Python.

1. Primero crea una clase haciendo uso de la palabra reservada class, luego en esta clase crea las propiedades necesarias para representar una computadora y los métodos necesarios para manipular o extraer estas propiedades.

1class Computadora:
2    def __init__(self, marca, precio, color, procesador):
3        self.marca = marca
4        self.precio = precio
5        self.color = color
6        self.procesador = procesador
7
8    def obtener_informacion(self):
9        return {
10            "Marca": self.marca,
11            "Precio": self.precio,
12            "Color": self.color,
13            "Procesador": self.procesador
14        }

1. Luego puedes crear instancias u objetos basados en esa clase. Cada objeto es una entidad independiente con sus propios valores de atributos y puede invocar los métodos definidos en la clase.

1computador_apple = Computadora("MacOS", 300_000, "Gris", "Apple M1")
2computador_hp = Computadora("Hewlett-Packard HP", 200_000, "Azul", "Intel core 5")
3
4print("Apple: ", computador_apple.obtener_informacion())
5print("HP: ", computador_hp.obtener_informacion())

output:

1Apple: {
2    'Marca': 'MacOS', 
3    'Precio': 300000, 
4    'Color': 'Gris', 
5    'Procesador': 'Apple M1'
6}
7HP: {
8    'Marca': 'Hewlett-Packard HP', 
9    'Precio': 200000, 
10    'Color': 'Azul', 
11    'Procesador': 'Intel core 5'
12}

Como vemos en este ejemplo, puedes representar dos computadores diferentes haciendo uso del mismo objeto/clase, cada vez que creas una nueva instancia de esa clase, el método obtener_informacion() retornará los valores de esa instancia de la clase, así nos evitamos la necesidad de repetir código innecesario para representar diferentes objetos, esto es muy útil cuando necesitas representar muchos elementos como por ejemplo en un Ecommerce.

Principios de la Programacion Orientada a Objetos

Como mencionamos anteriormente, la programación orientada a objetos (POO) se basa en cuatro conceptos fundamentales, a continuación veremos cada una de ellos con más detalle y ejemplos de código que te ayudarán a entenderlos mejor.

Abstracción

La abstracción es un concepto muy importante en (POO) que permite representar objetos del mundo real en un programa mediante el uso de clases y objetos, básicamente la abstracción permite representar un tipo de objeto en particular real o abstracto como una persona, un electrodoméstico o un animal, para ser utilizado en un programa.

Herencia

La herencia de objetos/clases en la programación orientada a objetos es un concepto fundamental, te permite crear una nueva clase basada en una clase ya existente. La clase ya existente se conoce como clase base o superclase, y la clase creada se conoce como clase derivada o subclase.

Ejemplo:

1class Persona:
2    def __init__(self, nombre, apellido, ciudadania):
3        self.nombre = nombre
4        self.apellido = apellido
5        self.ciudadania = ciudadania
6
7    def obtener_nombre_completo(self):
8        return f"{self.nombre} {self.apellido}"
9
10class Programador(Persona):
11    def __init__(self, nombre, apellido, ciudadania, salario, compañia):
12        super().__init__(nombre, apellido, ciudadania)
13        self.salario = salario
14        self.compañia = compañia
15
16persona = Persona("Axel", "Castro", "Mexicano")
17programador = Programador("Thomas", "Smith", "United States", 800_000, "Google")
18
19print(persona.obtener_nombre_completo()) # output: Axel Castro
20print(programador.obtener_nombre_completo()) # output: Thomas Smith

En este ejemplo, la clase Persona te permite representar a una persona con sus características básicas, luego la clase Programador puede heredar las características de la clase Persona y añadirle las demás características que representan a un programador, se puede decir que la clase programador es una clase hija de la clase Persona y puede usar las propiedades y métodos esta misma como puedes ver en el ejemplo con el método obtener_nombre_completo(). Para que una clase herede las propiedades y métodos de otra debes usar la siguiente sintaxis class nueva_clase(clase_padre), también es muy importante que dentro en la función __init__() le pases la función super().__init__() con las propiedades de la clase padre para que puedas utilizar sus propiedades en la nueva clase hija.

3. Encapsulación

La encapsulación también en un concepto muy importante en (POO), es una forma de ocultar la implementación interna de una clase permitiendo que solo alguno atributos y métodos específicos sean directamente accesible. puedes entender la encapsulación como la capacidad de una clase de permitir el acceso a sus atributos declarándolos como públicos o privados. En Python se utilizan convenciones de nomenclatura para indicar la visibilidad de sus miembros, si un atributo o método tiene un nombre que comienza con dos guiones bajos (__) se considera fuertemente privado.

Ejemplo:

1class Casa:
2    def __init__(self, area_cuadrada, lugar, precio):
3        self.area_cuadrada = area_cuadrada
4        self.lugar = lugar
5        self.__precio = precio
6
7    def get_precio(self):
8        return self.__precio
9
10    def set_precio(self, value):
11        self.__precio = value
12
13nueva_casa = Casa(100_000, "México", 700_000_000)
14
15print(nueva_casa.__precio) # output: 'Casa' object has no attribute '__precio'. Did you mean: 'get_precio'?
16print(nueva_casa.get_precio())  # output: 700000000
17
18nueva_casa.__precio = 500_000_000  # No te permite modificar la propiedad __precio
19print(nueva_casa.get_precio())  # output: 700000000
20
21nueva_casa.set_precio(400_000_000)
22print(nueva_casa.get_precio())  # output: 400000000

Como puedes ver en el ejemplo, en la clase Casa las porpiedades area_cuadrada y lugar son propiedades públicas a las cuales puedes acceder sin ningún problema, pero la propiedad __precio por otro lado es una propiedad privada y no puedes acceder a ella directamente, para poder acceder o modificar una propiedad privada debes hacer uso de las funciones Getter y Setter get_precio(), set_precio() estan son convenciones en la programación orientada a objetos, los método get y set se utilizan para obtener o modificar propiedades privadas dentro de la clase.

4. Polimorfismo

Por último, el polimorfismo es otro concepto fundamental en la programación orientada a objetos. En términos sencillos, el polimorfismo permite que diferentes clases se comporten de manera similar, pero con implementaciones específicas para cada una de ellas.

Ejemplo:

1class Automovil:
2    def __init__(self, marca, modelo):
3        self.marca = marca
4        self.modelo = modelo
5
6    def obtener_modelo(self):
7        pass
8
9class Auto_familiar(Automovil):
10    def __init__(self, marca, modelo):
11        super().__init__(marca, modelo)
12
13    def obtener_modelo(self):
14        return f"El auto familiar tiene un modelo: '{self.modelo}'"
15
16class Auto_deportivo(Automovil):
17    def __init__(self, marca, modelo):
18        super().__init__(marca, modelo)
19
20    def obtener_modelo(self):
21        return f"El modelo '{self.modelo}' del auto deportivo es el más reciente"
22
23auto_familiar = Auto_familiar("Ford", "Familiar 2023")
24auto_deportivo = Auto_deportivo("Tesla", "Tesla motors sport")
25
26print(auto_familiar.obtener_modelo()) # output: El auto familiar tiene un modelo: 'Familiar 2023'
27print(auto_deportivo.obtener_modelo()) # output: El modelo 'Tesla motors sport' del auto deportivo es el más reciente

El polimorfismo se basa en la capacidad de un objeto/clase de tomar diferentes formas, en el ejemplo enterior el método obtener_modelo() de la clase abstracta Automovil se utiliza de formas diferentes en la clases Auto_familiar y Auto_deportivo retornando mensajes diferentes cada una, esto es un pequeño ejemplo sobre el concepto de polimorfismo la capacidad de usar la misma función de una clase de formas diferentes.

Ventajas de la Programación Orientada a Objetos 🌟💼

La POO ofrece numerosas ventajas que hacen que la programación sea más eficiente y efectiva:

• Reutilización de Código: Con la POO, puedes reutilizar clases y objetos existentes para crear nuevos programas, lo que ahorra tiempo y esfuerzo.

• Mantenimiento Simplificado: La encapsulación permite modificar una clase sin afectar el resto del programa, facilitando el mantenimiento y evitando efectos secundarios no deseados.

• Organización y Claridad: La POO promueve una estructura clara y organizada en el código, lo que facilita su lectura y comprensión.

• Modelado del Mundo Real: La POO te permite modelar entidades y procesos del mundo real de manera natural, lo que hace que el código sea más intuitivo.

La Programación Orientada a Objetos (POO) es una técnica fundamental que te permite crear programas más organizados, reutilizables y fáciles de mantener. Ahora que tienes una comprensión básica de la POO, ¡puedes comenzar a crear tus propias clases y objetos para darle vida a tus proyectos! Si quieres conocer más sobre este lenguaje de programación te invito a que leas el siguiente tutorial de Python en el Blog de 4Geeks.

Code will set you free ✨👨‍💻