WhatsApp

  
Programación Orientada a Objetos

Curso de Python 3 - Programación Orientada a Objetos (POO)

En este curso, te enseñaremos los conceptos básicos de la programación orientada a objetos (POO) en Python y cómo utilizar dichos conceptos en tus programas. La programación orientada a objetos es un paradigma de programación que permite organizar el código en torno a objetos, que son instancias de clases.

Objetivos del curso:

  • Comprender los conceptos básicos de la POO
  • Aprender a crear y utilizar clases en Python
  • Explorar la encapsulación, herencia y polimorfismo en Python
  • Aplicar los conceptos de la POO en la resolución de problemas

Contenido del curso:

  1. Introducción a la programación orientada a objetos
  2. Clases y objetos
  3. Atributos y métodos
  4. Encapsulación
  5. Herencia
  6. Polimorfismo
  7. Resolución de problemas utilizando la POO

Requisitos:

  • Conocimientos básicos de Python
  • Editor de texto o entorno de desarrollo integrado (IDE) para escribir código

Metodología:

Este curso se llevará a cabo a través de lecciones teóricas y ejercicios prácticos. Cada lección incluirá ejemplos de código que podrás probar en tu propio entorno de desarrollo. Además, al final de cada sección, habrá ejercicios para que pongas en práctica lo aprendido.

Duración:

El curso consta de 7 secciones y puede ser completado en aproximadamente 4 semanas, dependiendo de tu nivel de dedicación y práctica. Sin embargo, puedes realizarlo a tu propio ritmo y tomar el tiempo que necesites.

¡Comencemos!

Estás a punto de embarcarte en un emocionante viaje de aprendizaje de la programación orientada a objetos en Python. ¡Esperamos que disfrutes del curso y te diviertas mientras adquieres nuevos conocimientos!

Introducción a la programación orientada a objetos (POO) en Python

La programación orientada a objetos (POO) es un estilo de programación que se basa en el concepto de "objetos", los cuales son estructuras que contienen tanto datos como funciones (métodos) que operan sobre estos datos. Este enfoque nos permite organizar y estructurar nuestro código de manera más eficiente y modular, lo cual resulta especialmente útil en proyectos grandes y complejos.

En Python, casi todo es un objeto. Por ejemplo, los números, las cadenas de texto y las listas son objetos en sí mismos, los cuales tienen métodos y atributos asociados. Además, podemos crear nuestros propios objetos definidos por el usuario. Estos objetos se construyen a partir de una plantilla o clase, que define la estructura y el comportamiento del objeto.

Clases y objetos en Python

En Python, las clases son las plantillas o moldes a partir de las cuales se crean los objetos. Una clase define la estructura y el comportamiento de un objeto. Los objetos, por otro lado, son instancias de una clase específica. Puedes crear múltiples objetos de la misma clase, cada uno con sus propios valores para los atributos.

Para definir una clase en Python, simplemente utilizamos la siguiente sintaxis:


class NombreClase:
    # Definición de variables y métodos
    pass

Por ejemplo, vamos a crear una clase llamada "Persona" que tendrá un atributo "nombre" y un método "saludar":


class Persona:
    def __init__(self, nombre):
        self.nombre = nombre
    def saludar(self):
        print(f"Hola, mi nombre es {self.nombre}.")

En este ejemplo, el método especial "__init__" se ejecuta automáticamente cuando se crea un objeto de la clase. Este método se utiliza para inicializar los atributos de la clase. El parámetro "self" se refiere al objeto actual y se utiliza para acceder a los atributos y métodos del objeto.

Para crear un objeto de esta clase, simplemente llamamos a la clase como si fuera una función y pasamos los valores necesarios para los atributos:


p1 = Persona("Juan")
p2 = Persona("María")

En este caso, hemos creado dos objetos de la clase "Persona" con diferentes valores para el atributo "nombre". Luego, podemos llamar al método "saludar" en cada uno de estos objetos para obtener la siguiente salida:


p1.saludar()  # Hola, mi nombre es Juan.
p2.saludar()  # Hola, mi nombre es María.

Como puedes ver, cada objeto de la clase "Persona" tiene su propio valor para el atributo "nombre" y puede acceder a los métodos definidos en la clase.

Recuerda que las clases y los objetos son fundamentales en la programación orientada a objetos, ya que nos permiten organizar y estructurar nuestro código de manera más eficiente y modular.

Atributos y métodos en Python

Los atributos son variables que se define dentro de una clase y que almacenan información sobre el estado de un objeto. Los métodos son funciones que también se definen dentro de una clase y que permiten realizar operaciones con los atributos del objeto.

A continuación, veremos tres ejemplos detallados de cómo definir y utilizar atributos y métodos en Python.

Ejemplo 1: Clase "Rectangulo"

Imaginemos que queremos representar un rectángulo mediante una clase en Python. El rectángulo estaría definido por sus dimensiones: ancho y altura.


    class Rectangulo:
        def __init__(self, ancho, altura):
            self.ancho = ancho
            self.altura = altura
        def calcular_area(self):
            return self.ancho * self.altura
        def calcular_perimetro(self):
            return 2 * (self.ancho + self.altura)
    # Crear un objeto de la clase "Rectangulo"
    rect = Rectangulo(5, 3)
    # Obtener el área y el perímetro del rectángulo
    area = rect.calcular_area()
    perimetro = rect.calcular_perimetro()
    print("Área:", area)
    print("Perímetro:", perimetro)
    

En este ejemplo, la clase "Rectangulo" tiene dos atributos: "ancho" y "altura". El método "__init__" se utiliza para inicializar estos atributos. Luego, tenemos dos métodos adicionales: "calcular_area()" y "calcular_perimetro()", que calculan el área y el perímetro del rectángulo, respectivamente.

Al crear un objeto de la clase "Rectangulo" con valores de ancho y altura, podemos llamar a los métodos definidos en la clase para obtener el área y el perímetro del rectángulo.

Ejemplo 2: Clase "Estudiante"

Supongamos que queremos representar a un estudiante mediante una clase en Python. El estudiante estaría definido por su nombre y su promedio.


    class Estudiante:
        def __init__(self, nombre, promedio):
            self.nombre = nombre
            self.promedio = promedio
        def obtener_calificacion(self):
            if self.promedio >= 90:
                return "A"
            elif self.promedio >= 80:
                return "B"
            elif self.promedio >= 70:
                return "C"
            elif self.promedio >= 60:
                return "D"
            else:
                return "F"
    # Crear un objeto de la clase "Estudiante"
    estudiante = Estudiante("Juan", 85)
    # Obtener la calificación del estudiante
    calificacion = estudiante.obtener_calificacion()
    print(f"El estudiante {estudiante.nombre} tiene una calificación de {calificacion}.")
    

En este ejemplo, la clase "Estudiante" tiene dos atributos: "nombre" y "promedio". El método "__init__" se utiliza para inicializar estos atributos. Luego, tenemos un método adicional: "obtener_calificacion()", que devuelve la calificación correspondiente al promedio del estudiante.

Al crear un objeto de la clase "Estudiante" con un nombre y un promedio, podemos llamar al método para obtener la calificación del estudiante.

Ejemplo 3: Clase "CuentaBancaria"

Imaginemos que queremos representar una cuenta bancaria mediante una clase en Python. La cuenta bancaria estaría definida por el nombre del titular, el saldo y las transacciones.


    class CuentaBancaria:
        def __init__(self, titular):
            self.titular = titular
            self.saldo = 0
            self.transacciones = []
        def depositar(self, cantidad):
            self.saldo += cantidad
            self.transacciones.append(f"Depósito de {cantidad}")
        def retirar(self, cantidad):
            if cantidad <= self.saldo:
                self.saldo -= cantidad
                self.transacciones.append(f"Retiro de {cantidad}")
            else:
                print("Saldo insuficiente.")
        def obtener_saldo(self):
            return self.saldo
        def obtener_transacciones(self):
            return self.transacciones
    # Crear un objeto de la clase "CuentaBancaria"
    cuenta = CuentaBancaria("Juan")
    # Realizar operaciones en la cuenta
    cuenta.depositar(1000)
    cuenta.retirar(500)
    # Obtener saldo y transacciones de la cuenta
    saldo = cuenta.obtener_saldo()
    transacciones = cuenta.obtener_transacciones()
    print("Saldo:", saldo)
    print("Transacciones:", transacciones)
    

En este ejemplo, la clase "CuentaBancaria" tiene tres atributos: "titular", "saldo" y "transacciones". El método "__init__" se utiliza para inicializar estos atributos. Luego, tenemos cuatro métodos adicionales: "depositar()", "retirar()", "obtener_saldo()" y "obtener_transacciones()", que permiten realizar operaciones en la cuenta y obtener información sobre el saldo y las transacciones.

Al crear un objeto de la clase "CuentaBancaria", podemos llamar a los métodos para realizar operaciones en la cuenta y obtener información.

Encapsulación en Python

La encapsulación es un principio de la programación orientada a objetos que consiste en ocultar los detalles internos de un objeto y solo exponer una interfaz para interactuar con él. En Python, esto se logra mediante el uso de atributos y métodos privados, los cuales son accesibles solo desde dentro de la clase.

A continuación, veremos tres ejemplos detallados de cómo aplicar la encapsulación en Python.

Ejemplo 1: Clase "Persona"

En este ejemplo, vamos a encapsular el atributo "edad" de la clase "Persona" para que no se pueda modificar directamente desde fuera de la clase. En su lugar, proporcionaremos un método público para establecer la edad.


    class Persona:
        def __init__(self, nombre, edad):
            self.nombre = nombre
            self.__edad = edad
        def obtener_edad(self):
            return self.__edad
        def establecer_edad(self, edad):
            if edad >= 0:
                self.__edad = edad
            else:
                print("La edad no puede ser negativa.")
    # Crear un objeto de la clase "Persona"
    persona = Persona("Juan", 25)
    # Obtener la edad de la persona
    edad = persona.obtener_edad()
    print("Edad:", edad)
    # Establecer una nueva edad para la persona
    persona.establecer_edad(30)
    # Intentar establecer una edad negativa para la persona
    persona.establecer_edad(-5)
    

En este ejemplo, hemos encapsulado el atributo "__edad" al agregar un doble guion bajo al principio de su nombre. Esto indica que el atributo es privado y no se debe acceder directamente desde fuera de la clase.

En su lugar, hemos proporcionado dos métodos públicos: "obtener_edad()" y "establecer_edad()", que permiten obtener y establecer la edad de la persona.

Ejemplo 2: Clase "Vehiculo"

En este ejemplo, vamos a encapsular los atributos "marca" y "modelo" de la clase "Vehiculo" y proporcionar métodos públicos para obtener y establecer dichos atributos.


    class Vehiculo:
        def __init__(self, marca, modelo):
            self.__marca = marca
            self.__modelo = modelo
        def obtener_marca(self):
            return self.__marca
        def obtener_modelo(self):
            return self.__modelo
        def establecer_marca(self, marca):
            self.__marca = marca
        def establecer_modelo(self, modelo):
            self.__modelo = modelo
    # Crear un objeto de la clase "Vehiculo"
    vehiculo = Vehiculo("Toyota", "Corolla")
    # Obtener la marca y el modelo del vehiculo
    marca = vehiculo.obtener_marca()
    modelo = vehiculo.obtener_modelo()
    print("Marca:", marca)
    print("Modelo:", modelo)
    # Establecer una nueva marca y modelo para el vehiculo
    vehiculo.establecer_marca("Honda")
    vehiculo.establecer_modelo("Civic")
    

En este ejemplo, hemos encapsulado los atributos "__marca" y "__modelo" para que no puedan ser modificados directamente desde fuera de la clase. En su lugar, hemos proporcionado métodos públicos para obtener y establecer la marca y el modelo del vehículo.

Ejemplo 3: Clase "CuentaBancaria"

En este ejemplo, vamos a encapsular los atributos "titular", "saldo" y "transacciones" de la clase "CuentaBancaria" para que no puedan ser accedidos ni modificados directamente desde fuera de la clase. En su lugar, proporcionaremos métodos públicos para interactuar con la cuenta.


    class CuentaBancaria:
        def __init__(self, titular):
            self.__titular = titular
            self.__saldo = 0
            self.__transacciones = []
        def depositar(self, cantidad):
            self.__saldo += cantidad
            self.__transacciones.append(f"Depósito de {cantidad}")
        def retirar(self, cantidad):
            if cantidad <= self.__saldo:
                self.__saldo -= cantidad
                self.__transacciones.append(f"Retiro de {cantidad}")
            else:
                print("Saldo insuficiente.")
        def obtener_saldo(self):
            return self.__saldo
        def obtener_transacciones(self):
            return self.__transacciones
    # Crear un objeto de la clase "CuentaBancaria"
    cuenta = CuentaBancaria("Juan")
    # Operar con la cuenta
    cuenta.depositar(1000)
    cuenta.retirar(500)
    # Obtener saldo y transacciones de la cuenta
    saldo = cuenta.obtener_saldo()
    transacciones = cuenta.obtener_transacciones()
    print("Saldo:", saldo)
    print("Transacciones:", transacciones)
    

En este ejemplo, hemos encapsulado los atributos "__titular", "__saldo" y "__transacciones" para que no puedan ser accedidos ni modificados directamente desde fuera de la clase. En su lugar, hemos proporcionado métodos públicos para realizar operaciones en la cuenta y obtener información.

La encapsulación nos permite proteger los datos de un objeto y limitar su acceso desde fuera de la clase. Esto ayuda a garantizar la integridad de los datos y favorece el diseño de código más robusto y mantenible.

Herencia en Python

La herencia es un concepto fundamental en la programación orientada a objetos que nos permite crear nuevas clases basadas en clases existentes. Una clase que hereda de otra clase se denomina clase hija o clase derivada, mientras que la clase de la cual se hereda se denomina clase padre o clase base.

A continuación, exploraremos tres ejemplos detallados de cómo utilizar la herencia en Python.

Ejemplo 1: Clase "Animal"

Imaginemos que queremos modelar diferentes tipos de animales en nuestro programa. Podemos comenzar creando una clase base llamada "Animal".


    class Animal:
        def __init__(self, nombre):
            self.nombre = nombre
        def hacer_sonido(self):
            return "El animal hace un sonido."
    # Crear un objeto de la clase "Animal"
    animal = Animal("Animal")
    # Acceder a los atributos y métodos de la clase "Animal"
    print("Nombre:", animal.nombre)
    print("Sonido:", animal.hacer_sonido())
    

En este ejemplo, la clase "Animal" tiene un atributo "nombre" y un método "hacer_sonido()". Al crear un objeto de esta clase y acceder a los atributos y métodos, obtendremos la siguiente salida:


    Nombre: Animal
    Sonido: El animal hace un sonido.
    

Ahora, podemos crear clases hijas que hereden de la clase base "Animal" y agregar comportamientos específicos para cada tipo de animal.

Ejemplo 2: Clase "Perro"

En este ejemplo, vamos a crear una clase hija llamada "Perro" que hereda de la clase base "Animal". Luego, agregaremos un método adicional para que los perros hagan sonidos de ladrido.


    class Perro(Animal):
        def hacer_sonido(self):
            return "El perro hace un ladrido."
    # Crear un objeto de la clase "Perro"
    perro = Perro("Perro")
    # Acceder a los atributos y métodos de la clase "Animal" y "Perro"
    print("Nombre:", perro.nombre)
    print("Sonido:", perro.hacer_sonido())
    

En este caso, la clase "Perro" hereda el atributo "nombre" y el método "hacer_sonido()" de la clase "Animal". Sin embargo, hemos redefinido el método "hacer_sonido()" en la clase "Perro" para que los perros hagan ladridos.

Al crear un objeto de la clase "Perro" y acceder a los atributos y métodos, obtendremos la siguiente salida:


    Nombre: Perro
    Sonido: El perro hace un ladrido.
    

Ejemplo 3: Clase "Gato"

En este ejemplo, vamos a crear otra clase hija llamada "Gato" que hereda de la clase base "Animal". A diferencia de la clase "Perro", los gatos harán sonidos de maullido.


    class Gato(Animal):
        def hacer_sonido(self):
            return "El gato hace un maullido."
    # Crear un objeto de la clase "Gato"
    gato = Gato("Gato")
    # Acceder a los atributos y métodos de la clase "Animal" y "Gato"
    print("Nombre:", gato.nombre)
    print("Sonido:", gato.hacer_sonido())
    

En este caso, la clase "Gato" también hereda el atributo "nombre" y el método "hacer_sonido()" de la clase "Animal". Hemos redefinido el método "hacer_sonido()" en la clase "Gato" para que los gatos hagan maullidos.

Al crear un objeto de la clase "Gato" y acceder a los atributos y métodos, obtendremos la siguiente salida:


    Nombre: Gato
    Sonido: El gato hace un maullido.
    

La herencia nos permite reutilizar código y modelar jerarquías de clases en base a relaciones de generalización/especialización. Además, podemos agregar comportamientos específicos a las clases hijas mientras heredamos los atributos y métodos de la clase base.

Polimorfismo en Python

El polimorfismo es un concepto importante en la programación orientada a objetos que nos permite utilizar un objeto de una clase hija de manera similar a un objeto de la clase padre. Esto se debe a que los objetos de las clases hijas pueden heredar los métodos y atributos de la clase padre, y también pueden agregar sus propios métodos y atributos.

A continuación, vamos a explorar tres ejemplos detallados de cómo utilizar el polimorfismo en Python.

Ejemplo 1: Clase "Figura"

Imaginemos que queremos modelar diferentes tipos de figuras geométricas en nuestro programa. Podemos comenzar creando una clase base llamada "Figura" que define un método para calcular el área de la figura.


    class Figura:
        def calcular_area(self):
            raise NotImplementedError("El método calcular_area debe ser implementado en las clases hijas.")
    # Crear un objeto de la clase "Figura"
    figura = Figura()
    # Llamar al método "calcular_area" de la clase "Figura"
    area = figura.calcular_area()
    

En este ejemplo, la clase "Figura" define un método llamado "calcular_area()" pero no proporciona una implementación. En su lugar, la clase muestra un mensaje de error para indicar que este método debe ser implementado en las clases hijas.

Ejemplo 2: Clase "Triangulo"

En este ejemplo, vamos a crear una clase hija llamada "Triangulo" que hereda de la clase base "Figura". Luego, vamos a implementar el método "calcular_area()" para calcular el área de un triángulo.


    class Triangulo(Figura):
        def __init__(self, base, altura):
            self.base = base
            self.altura = altura
        def calcular_area(self):
            return (self.base * self.altura) / 2
    # Crear un objeto de la clase "Triangulo"
    triangulo = Triangulo(5, 3)
    # Llamar al método "calcular_area" de la clase "Triangulo"
    area = triangulo.calcular_area()
    print("Área del triángulo:", area)
    

En este caso, la clase "Triangulo" hereda el método "calcular_area()" de la clase base "Figura" y proporciona una implementación específica para calcular el área de un triángulo.

Al crear un objeto de la clase "Triangulo" y llamar al método "calcular_area()", obtendremos la siguiente salida:


    Área del triángulo: 7.5
    

Ejemplo 3: Clase "Rectangulo"

En este ejemplo, vamos a crear otra clase hija llamada "Rectangulo" que hereda de la clase base "Figura". Vamos a implementar el método "calcular_area()" para calcular el área de un rectángulo.


    class Rectangulo(Figura):
        def __init__(self, base, altura):
            self.base = base
            self.altura = altura
        def calcular_area(self):
            return self.base * self.altura
    # Crear un objeto de la clase "Rectangulo"
    rectangulo = Rectangulo(5, 3)
    # Llamar al método "calcular_area" de la clase "Rectangulo"
    area = rectangulo.calcular_area()
    print("Área del rectángulo:", area)
    

En este caso, la clase "Rectangulo" también hereda el método "calcular_area()" de la clase base "Figura" y proporciona una implementación específica para calcular el área de un rectángulo.

Al crear un objeto de la clase "Rectangulo" y llamar al método "calcular_area()", obtendremos la siguiente salida:


    Área del rectángulo: 15
    

El polimorfismo nos permite tratar objetos de clases diferentes de manera similar, siempre y cuando compartan una interfaz común. Esto nos permite escribir código más genérico y modular, ya que podemos escribir funciones y métodos que toman como argumento objetos de la clase base y funcionarán correctamente con objetos de las clases hijas.

Resolución de problemas utilizando la POO en Python

La programación orientada a objetos (POO) en Python nos brinda una gran ventaja a la hora de resolver problemas complejos. Nos permite organizar el código en clases y objetos, lo que facilita la identificación de los elementos clave del problema y su interacción.

A continuación, veremos un ejemplo detallado de cómo resolver un problema utilizando la POO en Python.

Ejemplo: Sistema de gestión de empleados

Imaginemos que queremos crear un sistema de gestión de empleados en una empresa. Cada empleado tendrá un nombre, un salario y pertenecerá a un departamento específico. El sistema debe permitir realizar las siguientes operaciones:

  • Agregar un nuevo empleado
  • Calcular el salario promedio de todos los empleados
  • Calcular el salario total pagado por la empresa
  • Obtener la lista de empleados de un departamento específico

Para resolver este problema, podemos utilizar la programación orientada a objetos en Python. Vamos a crear las siguientes clases:

Clase "Empleado":

Esta clase representará a un empleado de la empresa. Tendrá los siguientes atributos:

  • nombre: el nombre del empleado
  • salario: el salario del empleado
  • departamento: el departamento al que pertenece el empleado

También tendrá los siguientes métodos:

  • get_nombre(): devuelve el nombre del empleado
  • get_salario(): devuelve el salario del empleado
  • get_departamento(): devuelve el departamento del empleado

class Empleado:
    def __init__(self, nombre, salario, departamento):
        self.nombre = nombre
        self.salario = salario
        self.departamento = departamento
    def get_nombre(self):
        return self.nombre
    def get_salario(self):
        return self.salario
    def get_departamento(self):
        return self.departamento
Clase "Empresa":

Esta clase representará a la empresa y contendrá una lista de empleados. Tendrá los siguientes atributos:

  • empleados: una lista de objetos de la clase "Empleado"

También tendrá los siguientes métodos:

  • agregar_empleado(empleado): agrega un nuevo empleado a la lista
  • calcular_salario_promedio(): calcula el salario promedio de todos los empleados
  • calcular_salario_total(): calcula el salario total pagado por la empresa
  • obtener_empleados_por_departamento(departamento): devuelve una lista de empleados de un departamento específico

class Empresa:
    def __init__(self):
        self.empleados = []
    def agregar_empleado(self, empleado):
        self.empleados.append(empleado)
    def calcular_salario_promedio(self):
        total_salarios = sum(empleado.get_salario() for empleado in self.empleados)
        return total_salarios / len(self.empleados)
    def calcular_salario_total(self):
        return sum(empleado.get_salario() for empleado in self.empleados)
    def obtener_empleados_por_departamento(self, departamento):
        return [empleado for empleado in self.empleados if empleado.get_departamento() == departamento]

Ahora, podemos utilizar estas clases para resolver el problema:


# Crear una instancia de la clase "Empresa"
empresa = Empresa()
# Agregar empleados
empleado1 = Empleado("Juan", 1000, "Ventas")
empleado2 = Empleado("María", 1500, "Ventas")
empleado3 = Empleado("Carlos", 2000, "Finanzas")
empleado4 = Empleado("Laura", 2500, "Finanzas")
empresa.agregar_empleado(empleado1)
empresa.agregar_empleado(empleado2)
empresa.agregar_empleado(empleado3)
empresa.agregar_empleado(empleado4)
# Calcular y mostrar el salario promedio
salario_promedio = empresa.calcular_salario_promedio()
print("Salario promedio:", salario_promedio)
# Calcular y mostrar el salario total
salario_total = empresa.calcular_salario_total()
print("Salario total:", salario_total)
# Obtener la lista de empleados de un departamento específico
empleados_ventas = empresa.obtener_empleados_por_departamento("Ventas")
print("Empleados de Ventas:", [empleado.get_nombre() for empleado in empleados_ventas])

En este ejemplo, hemos creado una instancia de la clase "Empresa" y hemos agregado cuatro empleados. Luego, hemos utilizado los métodos de la clase "Empresa" para calcular el salario promedio, el salario total y obtener la lista de empleados de un departamento específico. Finalmente, hemos mostrado los resultados por pantalla.

De esta manera, hemos resuelto el problema utilizando la programación orientada a objetos en Python.

en IA
Programación Orientada a Objetos
ASIMOV Ingeniería S. de R.L. de C.V., Emiliano Nava 27 octubre, 2023
Compartir
Categorías


Iniciar sesión dejar un comentario

  
Manipulación de Archivos