12_clases.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programación Orientada a Objetos (POO) en Python\n",
    "\n",
    "La programación orientada a objetos es un paradigma de programación que utiliza el concepto de objetos como base, estos objetos permiten guardar información en forma de atributos y codigo en forma de métodos. Estos objetos son capaces de interactuar y modificar la información que contienen en sus atributos (estado) a través de sus métodos (comportamiento). \n",
    "\n",
    "Los objetos en la POO son definidos mediante **clases**, las clases son una plantilla que permite definir los atributos y métodos predeterminados para un tipo determinado objeto. Esta plantilla permite crear facilmente diferentes objetos del mismo tipo.\n",
    "\n",
    "La POO esta fundamentada en cuatro pilares principales:\n",
    "\n",
    "1. **Abstracción:** Se refiere a las caracteristicas principales de un objeto, donde se capturan todos sus comportamientos (métodos). Este principio busca ocultar los detalles de implementación y solo revelar operaciones relevantes a otros objetos, de esta forma, un objeto solo debe exponer un mecanismo de alto nivel para usarlo.\n",
    "2. **Encapsulamiento:** El encapsulamiento hace referencia a mantener el estado del objeto de forma privada dentro de la clase, de forma que otros objetos no puedan acceder directamente al estado del objeto y solo tienen acceso a una lista publica de funciones (métodos).\n",
    "3. **Herencia:** Este pilar es útil cuando se tienen objetos similares que comparten ciertos elementos en su lógica, pero tienen algunas diferencias. La herencia permite crear una clase (hija) derivada de otra clase (padre) de forma de que la clase hija comparte los atributos y métodos de la clase padre y ademas puede implementar atributos y métodos nuevos. Este concepto permite generar una jerarquia entre clases que comparten caracteristicas. \n",
    "4. **Polimorfismo:** Este pilar hace referencia a la capacidad que pueden tener los objetos para presentar comportamientos diferentes, asociados a diferentes objetos, pero con un mismo nombre. De esta forma, al llamar ese nombre el comportamiento estara determinado por el objeto que se este usando. En otras palabras, el polimorfismo ofrece una forma de utilizar una clase exactamente como su clase principal (clase padre), de modo que no haya confusión con la mezcla de tipos. Sin embargo, cada clase secundaria (clase hija) mantiene sus propios métodos tal como están.\n",
    "\n",
    "Python es un lenguage orientado a objetos, donde casi todos sus elementos estan representados por objetos con diferentes atributos y métodos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "variable = \"string\"\n",
    "print(type(variable))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creación de clases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Clase():\n",
    "\n",
    "    x = 1\n",
    "    y = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Clase'>\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "objeto = Clase()\n",
    "\n",
    "print(type(objeto))\n",
    "print(objeto.x)\n",
    "print(objeto.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta es simplemente la creación de una clase en su forma más pura, sin embargo, esta definición no tiene ninguna utilidad practica en aplicaciónes reales. Para comenzar a crear clases que de verdad son de útilidad practica, debemos definir el constructor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constructor de la clase - Método \\_\\_init\\_\\_()\n",
    "\n",
    "El constructor de la clase permite definir e inicializar los atributos del objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Persona():\n",
    "\n",
    "    def __init__(self, nombre, edad):\n",
    "\n",
    "        self.nombre = nombre\n",
    "        self.edad = edad\n",
    "        \n",
    "        self.identificacion = 1234"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Persona'>\n",
      "El nombre de p1 es: Santiago\n",
      "La edad de p1 es: 25\n",
      "La identificación de p1 es: 1234\n"
     ]
    }
   ],
   "source": [
    "p1 = Persona(\"Santiago\", 25)\n",
    "\n",
    "print(type(p1))\n",
    "print(\"El nombre de p1 es:\", p1.nombre)\n",
    "print(\"La edad de p1 es:\", p1.edad)\n",
    "print(\"La identificación de p1 es:\", p1.identificacion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Persona'>\n",
      "El nombre de p2 es: Sofia\n",
      "La edad de p2 es: 20\n",
      "La identificación de p2 es: 1234\n"
     ]
    }
   ],
   "source": [
    "p2 = Persona(\"Sofia\", 20)\n",
    "\n",
    "print(type(p2))\n",
    "print(\"El nombre de p2 es:\", p2.nombre)\n",
    "print(\"La edad de p2 es:\", p2.edad)\n",
    "print(\"La identificación de p2 es:\", p2.identificacion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Método to string - \\_\\_str\\_\\_()\n",
    "\n",
    "Este método permite definir que se quiere devolver cuando el objeto es representado como una string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Persona object at 0x00000250ACCDADF0>\n",
      "<__main__.Persona object at 0x00000250ACCDADF0>\n"
     ]
    }
   ],
   "source": [
    "print(p1)\n",
    "print(p1.__str__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Persona():\n",
    "\n",
    "    def __init__(self, nombre, edad):\n",
    "\n",
    "        self.nombre = nombre\n",
    "        self.edad = edad\n",
    "    \n",
    "    def __str__(self):\n",
    "        \n",
    "        return \"Esta es una persona de nombre \" + self.nombre + \" con \" + str(self.edad) + \" años.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta es una persona de nombre Santiago con 25 años.\n"
     ]
    }
   ],
   "source": [
    "p1 = Persona(\"Santiago\", 25)\n",
    "\n",
    "print(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Persona():\n",
    "\n",
    "    def __init__(self, nombre, edad):\n",
    "\n",
    "        self.nombre = nombre\n",
    "        self.edad = edad\n",
    "\n",
    "    def metodo(self):\n",
    "\n",
    "        print(\"Este es un método\")\n",
    "\n",
    "    def saludar(self):\n",
    "\n",
    "        print(\"Hola\")\n",
    "\n",
    "    def devolver_datos(self):\n",
    "\n",
    "        return self.nombre, self.edad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este es un método\n",
      "Hola\n",
      "Alejandro - 26\n"
     ]
    }
   ],
   "source": [
    "p = Persona(\"Alejandro\", 26)\n",
    "\n",
    "p.metodo()\n",
    "p.saludar()\n",
    "\n",
    "nombre, edad = p.devolver_datos()\n",
    "\n",
    "print(nombre, \"-\", edad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parametro self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Persona():\n",
    "\n",
    "    def __init__(mi_objeto, nombre, edad):\n",
    "\n",
    "        mi_objeto.nombre = nombre\n",
    "        mi_objeto.edad = edad\n",
    "\n",
    "    def devolver_nombre(abc):\n",
    "\n",
    "        return abc.nombre\n",
    "    \n",
    "    def devolver_edad(xyz):\n",
    "\n",
    "        return xyz.edad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Andres - 20\n"
     ]
    }
   ],
   "source": [
    "p = Persona(\"Andres\", 20)\n",
    "\n",
    "nombre = p.devolver_nombre()\n",
    "edad = p.devolver_edad()\n",
    "\n",
    "print(nombre, \"-\", edad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modificación de propiedades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Andres - 20\n",
      "Camilo - 20\n"
     ]
    }
   ],
   "source": [
    "print(p.nombre, \"-\", p.edad)\n",
    "\n",
    "p.nombre = \"Camilo\"\n",
    "\n",
    "print(p.nombre, \"-\", p.edad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eliminación de objetos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El objeto no existe\n"
     ]
    }
   ],
   "source": [
    "del p\n",
    "\n",
    "try:\n",
    "    print(p.nombre)\n",
    "except:\n",
    "    print(\"El objeto no existe\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}