0_Intro_Python/2_Funciones_Clases.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/contreras-juan/UPTC_Seminario_ML/blob/main/0_Intro_Python/2_Funciones_Clases.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Autor:** Nicolás Castillo Ojeda y Andrés Felipe Florez"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HQoqDGI8XSTk"
   },
   "source": [
    "# **Módulo 2 - Curso: Fundamentos de Python**\n",
    "\n",
    "Bienvenido al curso \"Introducción al lenguaje de programación Python\". Durante esta experiencia educativa, nos sumergiremos en los conceptos y técnicas fundamentales de programación utilizando el lenguaje Python. Este segúndo módulo, contenido en el presente notebook, tiene como objetivo principal proporcionar una sólida introducción a la programación en Python, abordando desde funciones y constructores hasta algunas aplicaciones de nivel intermedio.\n",
    "\n",
    "A lo largo de esta lección, exploraremos ejemplos que clarificarán los conceptos presentados, pero también brindarán una visión concreta de las aplicaciones prácticas de cada técnica. Este curso está diseñado para guiarlos de manera gradual a través de los aspectos esenciales de Python, creando una base sólida para su desarrollo como programadores.\n",
    "\n",
    "---\n",
    "\n",
    "# **Contenidos:**\n",
    "\n",
    "1. **Funciones en Python**\n",
    "  * Definición de funciones\n",
    "  * Scope y funciones anidadas\n",
    "  * Funciones anónimas\n",
    "  * Funciones especiales\n",
    "2. **Manejo de errores en Python**\n",
    "  * Manejo de errores\n",
    "3. **Clases y objetos**\n",
    "  * Definición de una clase y constructores\n",
    "\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aMkZsHY5tzQv"
   },
   "source": [
    "# **1. Funciones en Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZdqDbnr-uX94"
   },
   "source": [
    "### 1.1. Definición de funciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hOiWPI2kGVxF"
   },
   "source": [
    "---\n",
    "Definición de funciones\n",
    "\n",
    "---\n",
    "\n",
    "Las funciones en Python son bloques de código reutilizables que realizan una tarea específica. Su uso es fundamental para organizar y modularizar el código, facilitando la lectura, mantenimiento y reutilización."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qwVSAuXiGXU8"
   },
   "source": [
    "La sintaxis básica de una función es la siguiente, donde para la definición de una función se usa el comando `def`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9otX5y4QGwAz"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica de una funcion\n",
    "\n",
    "def nombre_de_mi_funcion(parametros):\n",
    "  # Bloque de código a usar como función (reutilizable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AE_S0C0wHSsL"
   },
   "source": [
    "Las funciones que no requieren el ingreso de parámetros por parte del programador, son ejecutadas mediante su nombre y un par cerrado de paréntesis en la forma `nombre_de_mi_funcion()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1706144102678,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "kRunSj5qHDM8",
    "outputId": "27a017d0-385d-4d42-be53-fbc6ffb13afa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mensaje por defecto\n"
     ]
    }
   ],
   "source": [
    "# Ejempo básico de una función\n",
    "\n",
    "def imprimir_mensaje():\n",
    "  print('Mensaje por defecto')\n",
    "\n",
    "imprimir_mensaje()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 205,
     "status": "ok",
     "timestamp": 1706144226701,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "AEdx9EveHkcH",
    "outputId": "9d7983e7-0cd6-4095-b571-7c3d67d776c4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola, Alice!\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo simple de una función con parámetros\n",
    "\n",
    "def saludar(nombre):\n",
    "    \"\"\"Esta función saluda a la persona proporcionada.\"\"\"\n",
    "    print(f\"Hola, {nombre}!\")\n",
    "\n",
    "# Uso de la función\n",
    "saludar(\"Alice\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 183,
     "status": "ok",
     "timestamp": 1706144324218,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "ZNi8zQl4HxOD",
    "outputId": "943a1798-5619-472d-f06f-3ce085fd7097"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resultado =  26\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo simple de una función con parámetros\n",
    "\n",
    "def operacion(a,b,c):\n",
    "    variable_interna = (a + b)^c + a**3\n",
    "    print(\"Resultado = \", variable_interna )\n",
    "\n",
    "# Uso de la función\n",
    "operacion(3,4,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "l1xfIgvhIJoL"
   },
   "source": [
    "Las funciónes cuando son ejecutadas, corren el código que tienen dentro de sí, no obstante estos bloques de código pueden o no retornar un valor producto de la ejecución del bloque. Para que una función retorne un resultado producto de la ejecución de una secuencia de procedimientos es necesario especificarlo mediante la palabra reservada `return`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1706144597292,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "Ee4yY7wlIjf7",
    "outputId": "f6b129a7-a1f9-4b58-eb70-06daeb3a1d4e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "el resultado de la operacion es =  26\n",
      "el resultado de la operacion es =  None\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de función que retorna un valor\n",
    "\n",
    "def operacion_no_return(a,b,c):\n",
    "    variable_interna = (a + b)^c + a**3\n",
    "\n",
    "def operacion_return(a,b,c):\n",
    "    variable_interna = (a + b)^c + a**3\n",
    "    return variable_interna\n",
    "\n",
    "# Uso de la función\n",
    "nueva_variable = operacion_return(3,4,2)\n",
    "\n",
    "print(\"el resultado de la operacion es = \", nueva_variable)\n",
    "print(\"el resultado de la operacion es = \", operacion_no_return(3,4,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MRHeqNo6Jose"
   },
   "source": [
    "Las funciónes, como bloques de procedimientos, pueden ser definidas para operar con valores por defecto, los cuales son valores que tomarán los parámetros requerídos por la función en caso de que el programador no estipule explícitamente el valor de éstos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 183,
     "status": "ok",
     "timestamp": 1706144878248,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "eeQKKtICKFKc",
    "outputId": "da912b3a-603f-4a17-8e94-82f709fdf2a4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma con dos números: 8\n",
      "Suma con un número (b asume valor predeterminado): 3\n"
     ]
    }
   ],
   "source": [
    "# Función con valores por defecto\n",
    "\n",
    "def suma(a, b=0):\n",
    "    return a + b\n",
    "\n",
    "# Uso de la función con parámetro opcional\n",
    "resultado1 = suma(3, 5)\n",
    "resultado2 = suma(3)\n",
    "\n",
    "print(f\"Suma con dos números: {resultado1}\")\n",
    "print(f\"Suma con un número (b asume valor predeterminado): {resultado2}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aDeUpvHDKkcz"
   },
   "source": [
    "Las funciones pueden tomar como argumentos, o parámetros, cualquier tipo de dato siempre y cuando este valor de entrada coincída con los requerimientos de tipo de las operaciones efectuadas dentro de la función."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1706145621989,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "w9IY72nCL3iz",
    "outputId": "acf82fed-8d71-486a-82a1-806b2fd33056"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(45, [1, 3, 6, 10, 15, 21, 28, 36, 45], [-1, -3, -6, -10, -15, -21, -28, -36, -45])\n",
      "45\n",
      "[1, 3, 6, 10, 15, 21, 28, 36, 45]\n",
      "[-1, -3, -6, -10, -15, -21, -28, -36, -45]\n"
     ]
    }
   ],
   "source": [
    "# Función con ciclo for()\n",
    "\n",
    "def suma_acumulativa(min, max):\n",
    "  sum = 0\n",
    "  sust = 0\n",
    "  proceso_1 = []\n",
    "  proceso_2 = []\n",
    "\n",
    "  for x in range(min, max):\n",
    "    sum += x\n",
    "    sust -=x\n",
    "\n",
    "    proceso_1.append(sum)\n",
    "    proceso_2.append(sust)\n",
    "\n",
    "  return sum, proceso_1, proceso_2\n",
    "\n",
    "result = suma_acumulativa(1, 10)\n",
    "suma, progreso_1, progreso_2 = suma_acumulativa(1, 10)\n",
    "\n",
    "print(result)\n",
    "print(suma)\n",
    "print(progreso_1)\n",
    "print(progreso_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 190,
     "status": "ok",
     "timestamp": 1706145048504,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "nTDoEpHOJzb9",
    "outputId": "e8a0a3ed-06cf-430b-be50-c799dbd653aa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original: [1, 2, 3, 4, 5]\n",
      "Resultado de la operación: [3, 6, 9, 12, 15]\n"
     ]
    }
   ],
   "source": [
    "# Función con una lista y un número como parámetros\n",
    "\n",
    "def operacion_con_lista(lista, multiplicador):\n",
    "    \"\"\"\n",
    "    Esta función toma una lista y un entero como argumentos,\n",
    "    multiplica cada elemento de la lista por el multiplicador\n",
    "    y devuelve una nueva lista con los resultados.\n",
    "    \"\"\"\n",
    "    resultado = []\n",
    "\n",
    "    for elemento in lista:\n",
    "        resultado.append(elemento * multiplicador)\n",
    "\n",
    "    return resultado\n",
    "\n",
    "# Ejemplo de uso\n",
    "mi_lista = [1, 2, 3, 4, 5]\n",
    "resultado_operacion = operacion_con_lista(mi_lista, 3)\n",
    "\n",
    "print(f\"Lista original: {mi_lista}\")\n",
    "print(f\"Resultado de la operación: {resultado_operacion}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 9,
     "status": "ok",
     "timestamp": 1706145166651,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "nMS2HO4SLIbD",
    "outputId": "1a9d61dd-78f2-4c28-e7af-07f6dfc59391"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original: [1, 2, 3, 4, 5]\n",
      "Diccionario original: {'a': 10, 'b': 20, 'c': 30}\n",
      "Número original: 5\n",
      "Resultado de la operación: [5, 10, 15, 20, 25, 5, 15, 25]\n"
     ]
    }
   ],
   "source": [
    "# Función con una lista, un diccionario y un número como parámetros\n",
    "\n",
    "def operacion_con_lista_diccionario(lista, diccionario, numero):\n",
    "    \"\"\"\n",
    "    Esta función toma una lista, un diccionario y un número como argumentos,\n",
    "    realiza una operación combinada con estos datos,\n",
    "    y devuelve el resultado.\n",
    "    \"\"\"\n",
    "    resultado = []\n",
    "\n",
    "    for elemento in lista:\n",
    "        resultado.append(elemento * numero)\n",
    "\n",
    "    for key, value in diccionario.items():\n",
    "        resultado.append(value - numero)\n",
    "\n",
    "    return resultado\n",
    "\n",
    "# Ejemplo de uso\n",
    "mi_lista = [1, 2, 3, 4, 5]\n",
    "mi_diccionario = {'a': 10, 'b': 20, 'c': 30}\n",
    "mi_numero = 5\n",
    "\n",
    "resultado_operacion = operacion_con_lista_diccionario(mi_lista, mi_diccionario, mi_numero)\n",
    "\n",
    "print(f\"Lista original: {mi_lista}\")\n",
    "print(f\"Diccionario original: {mi_diccionario}\")\n",
    "print(f\"Número original: {mi_numero}\")\n",
    "print(f\"Resultado de la operación: {resultado_operacion}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_6L2HLzXT_es"
   },
   "source": [
    "### 1.2. Funciones anónimas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PsRc4JNIUPvT"
   },
   "source": [
    "---\n",
    "Funciones anónimas\n",
    "\n",
    "---\n",
    "\n",
    "Las funciones anónimas en Python, también conocidas como funciones lambda, son funciones que se definen sin utilizar la palabra clave `def` de manera convencional. Estas funciones se caracterizan por ser simples y expresivas, diseñadas para realizar operaciones específicas de manera concisa en un solo línea de código y son especificadas mediante la palabra clave `lambda`.\n",
    "\n",
    "Sus características principales son:\n",
    "\n",
    "* **Sintaxis Compacta:** La sintaxis de una función anónima es más breve que la de una función definida con `def`.\n",
    "La estructura básica es: `lambda argumentos: expresion`.\n",
    "\n",
    "* **Sin Nombre Explícito:** A diferencia de las funciones tradicionales, las funciones anónimas no tienen un nombre explícito. Se crean y utilizan inmediatamente en el lugar donde se necesitan.\n",
    "\n",
    "* **Una Única Expresión:** La función lambda consiste en una única expresión, y esta expresión se evalúa y devuelve automáticamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EqopIXrPUfZF"
   },
   "outputs": [],
   "source": [
    "# Sintaxis de una función lambda\n",
    "\n",
    "nombre_de_la_funcion = lambda argumentos: expresion\n",
    "\n",
    "# Es equivalente a\n",
    "def nombre_de_la_funcion(argumentos):\n",
    "  expresion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1706148069657,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "coAK08DJWBxP",
    "outputId": "15e623cb-878b-4ef7-9512-491f09d06658"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de función lambda\n",
    "\n",
    "suma = lambda x, y: x + y\n",
    "\n",
    "def suma_2(x,y):\n",
    "  resultado = x + y\n",
    "  return resultado\n",
    "\n",
    "resultado_1 = suma(3, 5)\n",
    "resultado_2 = suma_2(3, 5)\n",
    "\n",
    "print(resultado_1)\n",
    "print(resultado_2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 187,
     "status": "ok",
     "timestamp": 1706148543515,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "EVo9j7wdWbTz",
    "outputId": "b98efc4b-44b4-4964-97b1-e87790755736"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "# Función lambda condicionada\n",
    "\n",
    "cuadrado_par = lambda x: x**2 if x % 2 == 0 else None\n",
    "resultado_par = cuadrado_par(4)\n",
    "\n",
    "print(resultado_par)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 197,
     "status": "ok",
     "timestamp": 1706148573882,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "3R94WLkuYNcL",
    "outputId": "67c5d19c-c1f3-48d8-8a6b-5a86e5f3ce81"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'reconocer' es palíndromo: True\n",
      "'python' es palíndromo: False\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de palabra palíndromo\n",
    "\n",
    "es_palindromo = lambda s: s.lower() == s.lower()[::-1]\n",
    "resultado1 = es_palindromo(\"reconocer\")\n",
    "resultado2 = es_palindromo(\"python\")\n",
    "\n",
    "print(f\"'reconocer' es palíndromo: {resultado1}\")\n",
    "print(f\"'python' es palíndromo: {resultado2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dDzTO69kYmF9"
   },
   "source": [
    "### 1.3. Funciones especiales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HZd6JdTfYwTS"
   },
   "source": [
    "---\n",
    "Funciones especiales\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "Las funciones especiales son funciones que se aplican a objetos iterables condiferentes motivos, dentro de las más comúnes encontramos:\n",
    "\n",
    "* **La función `map()`**: En Python es una herramienta poderosa y eficiente que se utiliza para aplicar una función a cada elemento de un iterable (como una lista) y devolver un nuevo iterable con los resultados.\n",
    "\n",
    "* **La función `filter()` **en Python se utiliza para filtrar elementos de un iterable (como una lista) según una función de prueba."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wayobxPKZrVG"
   },
   "source": [
    "#### 1.3.1. Función map()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J01ypu2TFtyL"
   },
   "source": [
    "---\n",
    "Función map()\n",
    "\n",
    "---\n",
    "\n",
    "La función `map()` es un método de Python el cuál se emplea para aplicar procedimientos como funciones (tanto incluidas dentro de Python, como anónimas o construidas por el programador) a una estructura de datos iterable como las listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UUE9kKiJaRkz"
   },
   "outputs": [],
   "source": [
    "# Sintaxis de la función map()\n",
    "\n",
    "resultado = list( map(funcion_lambda, iterable) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 9,
     "status": "ok",
     "timestamp": 1706148763450,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "NCvXsn9yY-Mw",
    "outputId": "940d807f-8512-4116-8447-9bb033d73196"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de función map\n",
    "\n",
    "numeros = [1, 2, 3, 4, 5]\n",
    "duplicados = list(map(lambda x: x * 2, numeros))\n",
    "print(duplicados)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 196,
     "status": "ok",
     "timestamp": 1706148148666,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "PwRKFz1CWq3b",
    "outputId": "0d33c099-62dd-4f87-f9fd-ad18c14a8017"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precios en euros: [85.0, 127.5, 170.0, 212.5]\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de función lambda para procesamiento de datos\n",
    "\n",
    "datos_precios = [100, 150, 200, 250]\n",
    "tasa_cambio = 0.85\n",
    "\n",
    "convertir_a_euros = lambda precio: precio * tasa_cambio\n",
    "precios_en_euros = list(map(convertir_a_euros, datos_precios))\n",
    "\n",
    "print(f\"Precios en euros: {precios_en_euros}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1706148793247,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "VPKgjwE6ZIUt",
    "outputId": "4cadd456-f401-47c6-ec20-77ae767a4172"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'nombre': 'Alice', 'nuevo_salario': 55000.00000000001}, {'nombre': 'Bob', 'nuevo_salario': 66000.0}, {'nombre': 'Charlie', 'nuevo_salario': 82500.0}]\n"
     ]
    }
   ],
   "source": [
    "# Función map() aplicada a un diccionario\n",
    "\n",
    "empleados = [\n",
    "    {\"nombre\": \"Alice\", \"salario\": 50000},\n",
    "    {\"nombre\": \"Bob\", \"salario\": 60000},\n",
    "    {\"nombre\": \"Charlie\", \"salario\": 75000}\n",
    "]\n",
    "\n",
    "aumento_salario = lambda empleado: {\"nombre\": empleado[\"nombre\"], \"nuevo_salario\": empleado[\"salario\"] * 1.1}\n",
    "empleados_actualizados = list(map(aumento_salario, empleados))\n",
    "\n",
    "print(empleados_actualizados)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xyC2AfFSaHFc"
   },
   "source": [
    "#### 1.3.2. Función filter()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ycpcQZq6GDyz"
   },
   "source": [
    "---\n",
    "Función filter()\n",
    "\n",
    "---\n",
    "\n",
    "El método `filter()`, como su nombre lo indica, se emplea para filtrar o descartar ciertos elementos de un objeto iterable deacuerdo a un criterio condicional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nl4thXGkabW6"
   },
   "outputs": [],
   "source": [
    "# Sintaxis de la función filter()\n",
    "\n",
    "resultado = list( filter(funcion_lambda, iterable) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 196,
     "status": "ok",
     "timestamp": 1706149166647,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "xkA_z1wsafmC",
    "outputId": "be4de237-ee6d-4ced-d5c3-b8c9f54c066e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de map() para seleccionar pares\n",
    "\n",
    "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "pares = list(filter(lambda x: x % 2 == 0, numeros))\n",
    "print(pares)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1706149188803,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "gZVmTTAEalZ6",
    "outputId": "260054f3-d2e4-4490-a846-a200529b2194"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Charlie']\n"
     ]
    }
   ],
   "source": [
    "# Filtro de nombres que comienzan por una letra en específico\n",
    "\n",
    "nombres = [\"Alice\", \"Bob\", \"Charlie\", \"David\", \"Eva\"]\n",
    "letra_inicial = \"C\"\n",
    "filtrados = list(filter(lambda x: x.startswith(letra_inicial), nombres))\n",
    "print(filtrados)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1706149211988,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "WyIbBRCCaqzr",
    "outputId": "6b5f4f55-7de3-4346-c5d5-80e91700fa6b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'nombre': 'Charlie', 'salario': 75000}]\n"
     ]
    }
   ],
   "source": [
    "# Filtrar empleados con salarios superiores a un umbral\n",
    "\n",
    "empleados = [\n",
    "    {\"nombre\": \"Alice\", \"salario\": 50000},\n",
    "    {\"nombre\": \"Bob\", \"salario\": 60000},\n",
    "    {\"nombre\": \"Charlie\", \"salario\": 75000}\n",
    "]\n",
    "\n",
    "umbral_salario = 60000\n",
    "filtrados_salario = list(filter(lambda x: x[\"salario\"] > umbral_salario, empleados))\n",
    "\n",
    "print(filtrados_salario)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e3xXlj50t5--"
   },
   "source": [
    "# **2. Manejo de errores en Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iADXFGIsze07"
   },
   "source": [
    "El manejo de errores en Python se refiere a la implementación de estructuras y técnicas que permiten gestionar y controlar las excepciones o errores que pueden surgir durante la ejecución de un programa. Las excepciones son eventos inesperados o condiciones anómalas que pueden ocurrir durante la ejecución del código y que pueden interrumpir el flujo normal del programa si no se gestionan adecuadamente. Para lidiar con posibles excepciones en el programa se hace uso de las palabras reservadas `try-except`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UkLps6WqdEku"
   },
   "source": [
    "La sintaxis básica de un `try-except` es"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z6wpFtgUdLXS"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica del manejo de errores o excepciones\n",
    "\n",
    "try:\n",
    "    # Código propenso a generar excepciones\n",
    "except ExcepcionTipo1 as e1:\n",
    "    # Manejar excepción de tipo 1\n",
    "except ExcepcionTipo2 as e2:\n",
    "    # Manejar excepción de tipo 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_lCBfFxKdTYr"
   },
   "source": [
    "Opcionalmente, se pueden utilizar bloques `else` y `finally` después de los bloques except. El bloque `else` se ejecuta si no se produce ninguna excepción en el bloque `try`. El bloque `finally` se ejecuta siempre, independientemente de si se produjo una excepción o no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "V2OPpccudcGa"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica del manejo de errores o excepciones con bloques else y finally\n",
    "\n",
    "try:\n",
    "    # Código propenso a generar excepciones\n",
    "except ExcepcionTipo1 as e1:\n",
    "    # Manejar excepción de tipo 1\n",
    "except ExcepcionTipo2 as e2:\n",
    "    # Manejar excepción de tipo 2\n",
    "else:\n",
    "    # Código a ejecutar si no hay excepciones\n",
    "finally:\n",
    "    # Código que siempre se ejecutará\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 2230,
     "status": "ok",
     "timestamp": 1706150081392,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "J2wt-LIPduPb",
    "outputId": "66f5cb69-10e1-4089-a5ea-87c67cbaba39"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un numero para dividir a 'a' =  4\n",
      "Su resultado es = 3.25\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo simple de try-except\n",
    "\n",
    "a = 13\n",
    "\n",
    "try:\n",
    "    b = int(input(\"Ingrese un numero para dividir a 'a' =  \"))\n",
    "    a = a/b\n",
    "    print(\"Su resultado es =\",a)\n",
    "except:\n",
    "    print(\"Hay un error!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_Tek5mLseWvf"
   },
   "source": [
    "Un error o excepcion puede ser \"bloqueado\" mediante una o varias líneas de código. Tambíen, los bloques `except` pueden ser programadas para tener en cuenta algún tipo de excepción específica o no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9n-Es_XWeiKK"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de múltiples excepciones dentro de un mísmo bloque except\n",
    "\n",
    "try:\n",
    "    # Código propenso a generar excepciones\n",
    "except (ZeroDivisionError, NameError):\n",
    "    # Código a ejecutar si hay excepciones ZeroDivisionError ni NameError\n",
    "\n",
    "# codigo a ejecutar si no exísten excepciones\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "S6zcEKvrfLaq"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de múltiples excepciones programadas explícitamente\n",
    "\n",
    "try:\n",
    "    # Código propenso a generar excepciones\n",
    "except ZeroDivisionError:\n",
    "    # Código a ejecutar si exíste un ZeroDivisionError\n",
    "except NameError:\n",
    "    # Código a ejecutar si exíste un NameError\n",
    "except:\n",
    "    # Código a ejecutar si exíste alguna excepcion en general\n",
    "\n",
    "# codigo a ejecutar si no exísten excepciones\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "55prSJfJfiM2"
   },
   "source": [
    "Por ejemplo, podrémos ejecutar diferentes bloques de código dependiendo de casos específicos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6734,
     "status": "ok",
     "timestamp": 1706150595653,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "KtJDjpIUfhwD",
    "outputId": "47e783f0-0bb3-48c9-afce-6e8c293c3e19"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un número para dividir a 'a' = 7\n",
      "Su número es =  0.14285714285714285\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de manejo de excepciones/errores específicas\n",
    "\n",
    "a = 1\n",
    "\n",
    "try:\n",
    "    b = int(input(\"Ingrese un número para dividir a 'a' = \"))\n",
    "    a = a/b\n",
    "    print(\"Resultado = \",a)\n",
    "except ZeroDivisionError:\n",
    "    print(\"No es posible realizar la división ya que usted ingresó a = 0\")\n",
    "except ValueError:\n",
    "    print(\"Usted no ingresó número alguno.\")\n",
    "except:\n",
    "    print(\"Algo salió mal, que puede ser?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 3228,
     "status": "ok",
     "timestamp": 1706150669365,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "tCJe_keBgJF6",
    "outputId": "52c937e1-d63e-4bc9-8390-d633f692ffa3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un número para dividir a 'a' = 5\n",
      "Resultado = 0.2\n",
      "Felicidades, pudo hacer la división\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de manejo de excepciones/errores específicas con bloque finally\n",
    "\n",
    "a = 1\n",
    "\n",
    "try:\n",
    "    b = int(input(\"Ingrese un número para dividir a 'a' = \"))\n",
    "    a = a/b\n",
    "\n",
    "except ZeroDivisionError:\n",
    "    print(\"No es posible realizar la división ya que usted ingresó a = 0\")\n",
    "except ValueError:\n",
    "    print(\"Usted no ingresó número alguno.\")\n",
    "except:\n",
    "    print(\"Algo salió mal, que puede ser?\")\n",
    "else:\n",
    "    print(\"Resultado =\",a)\n",
    "finally:\n",
    "    print(\"Felicidades, pudo hacer la división\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1706150721226,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "8WjSCgNCgbAD",
    "outputId": "5e2e843d-5bf4-4123-995d-41678eca1dc1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resultado de la operación: 2.0\n",
      "Este bloque siempre se ejecutará\n",
      "Error: División por cero no permitida\n",
      "Este bloque siempre se ejecutará\n"
     ]
    }
   ],
   "source": [
    "# Ejempo de manejo de excepciones/errores dentro de una función\n",
    "\n",
    "def operacion_compleja(a, b):\n",
    "    try:\n",
    "        resultado = a / b\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Error: División por cero no permitida\")\n",
    "    else:\n",
    "        print(f\"Resultado de la operación: {resultado}\")\n",
    "    finally:\n",
    "        print(\"Este bloque siempre se ejecutará\")\n",
    "\n",
    "# Ejemplo de uso\n",
    "operacion_compleja(8, 4)\n",
    "operacion_compleja(6, 0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dvT3LC7EgqiV"
   },
   "source": [
    "### 2.1. Tipos de errores comúnes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8aLWbsyIGjLy"
   },
   "source": [
    "---\n",
    "Tipos de errores comúnes\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4b8xMFgKgtxa"
   },
   "source": [
    "`SyntaxError`: Ocurre cuando hay un error en la sintaxis del código."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5fOFdmPqgtHS"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de SyntaxError\n",
    "print(\"Hola\"  # Falta cerrar paréntesis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CvP6_MN6g0N0"
   },
   "source": [
    "`IndentationError`: Ocurre cuando hay un error en la indentación del código."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z6owqPwqg4qB"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de IndentationError\n",
    "def mi_funcion():\n",
    "print(\"Hola\")  # Falta indentación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "boTZ7KF2g6j6"
   },
   "source": [
    "`NameError`: Ocurre cuando se intenta utilizar una variable o un nombre que no está definido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wUZrGRkGg9lC"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de NameError\n",
    "print(variable_inexistente)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pE8N7aUlg_Hd"
   },
   "source": [
    "`TypeError`: Ocurre cuando se realiza una operación con un tipo de dato no permitido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RrWqrIqhhE2K"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de TypeError\n",
    "resultado = 10 + \"5\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vY065FLMhHvq"
   },
   "source": [
    "`ZeroDivisionError:` Ocurre cuando se intenta dividir entre cero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nwWtQ_HNhKF7"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de ZeroDivisionError\n",
    "resultado = 10 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c7xaC5bDhRqE"
   },
   "source": [
    "`ValueError`: Ocurre cuando una función recibe un argumento con un tipo correcto pero un valor incorrecto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "K3_TeTj_hTaU"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de ValueError\n",
    "numero = int(\"abc\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vEzpnQ7UhVEL"
   },
   "source": [
    "`KeyError`: Ocurre cuando se intenta acceder a una clave que no está presente en un diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6-5aWihkhXhK"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de KeyError\n",
    "diccionario = {\"clave1\": 1, \"clave2\": 2}\n",
    "valor = diccionario[\"clave3\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WK0JDtqKhMtj"
   },
   "source": [
    "`FileNotFoundError`: Ocurre cuando se intenta abrir un archivo que no existe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kh5pX7UnhPNS"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de FileNotFoundError\n",
    "with open(\"archivo_inexistente.txt\", \"r\") as archivo:\n",
    "    contenido = archivo.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wfxkZ2y5rNz6"
   },
   "source": [
    "# **3. Clases y objetos**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6lgq8czNiFQ6"
   },
   "source": [
    "En el contexto de la programación orientada a objetos (OOP), una clase es una plantilla o un \"molde\" que define la estructura y el comportamiento de objetos. Los objetos son instancias de clases, y las clases proporcionan un mecanismo para organizar y encapsular el código de manera que sea reutilizable y fácil de entender.\n",
    "\n",
    "**Principales Características de las Clases:**\n",
    "\n",
    "* **Atributos:** Las clases pueden tener atributos que representan características o propiedades del objeto. Estos atributos pueden ser variables que almacenan datos.\n",
    "\n",
    "* **Métodos**: Las clases también pueden contener métodos, que son funciones asociadas a la clase y que definen el comportamiento del objeto. Los métodos operan sobre los atributos del objeto.\n",
    "\n",
    "* **Encapsulación**: Las clases permiten encapsular la implementación interna, ocultando detalles complejos y exponiendo solo la interfaz necesaria para interactuar con el objeto. Esto facilita la modularidad y el mantenimiento del código.\n",
    "\n",
    "* **Herencia**: La herencia es un concepto clave en OOP que permite que una clase herede atributos y métodos de otra clase. Esto fomenta la reutilización del código y la creación de jerarquías de clases.\n",
    "\n",
    "* **Polimorfismo**: El polimorfismo permite que objetos de diferentes clases respondan de manera consistente a un mismo conjunto de métodos. Esto facilita el uso de interfaces comunes en situaciones diversas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7wa0MZsHmFqN"
   },
   "source": [
    "### 3.1. Definición de clases, atributos y métodos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8nc53C9IGtTT"
   },
   "source": [
    "---\n",
    "Definición de clases, atributos y métodos\n",
    "\n",
    "---\n",
    "\n",
    "Las clases dentro de Python, se definen como objetos los cuales están caracterizados por poseer ciertos atributos y métodos própios. Una clase puede entenderse como una colección de funciones, constantes y ótros objetos que se pueden emplear de manera dinámica y generan instancias usables en diferentes contextos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YVnhYfVxmUWC"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica\n",
    "\n",
    "class tipo_de_objeto_o_entidad:\n",
    "  # Atributos de la clase\n",
    "  atributo_1 = valor _1\n",
    "  atributo_2 = valor _2\n",
    "\n",
    "  def metodo_1(self, parametros):\n",
    "    expresion\n",
    "\n",
    "  def metodo_2(self, parametros):\n",
    "    expresion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 231,
     "status": "ok",
     "timestamp": 1706154209403,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "YwlyPYqmmIc7",
    "outputId": "bf5c8977-ae3d-43fc-ee9b-c3e755fcf6e7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Blu tiene 10 años\n",
      "Cacao tiene 20 años\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo básico de una clase y creación de un objeto y polimorfísmo\n",
    "\n",
    "class ave:\n",
    "\n",
    "    # Atributos de la clase\n",
    "    nombre = \"\"\n",
    "    edad = 0\n",
    "\n",
    "# Creación del objeto\n",
    "ave_1 = ave()\n",
    "ave_1.nombre = \"Blu\"\n",
    "ave_1.edad = 10\n",
    "\n",
    "# Creación de otro objeto\n",
    "ave_2 = ave()\n",
    "ave_2.nombre = \"Cacao\"\n",
    "ave_2.edad = 20\n",
    "\n",
    "# access attributes\n",
    "print(f\"{ave_1.nombre} tiene {ave_1.edad} años\")\n",
    "print(f\"{ave_2.nombre} tiene {ave_2.edad} años\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 205,
     "status": "ok",
     "timestamp": 1706152557816,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "TkpXn7aWnayz",
    "outputId": "4be03b01-0be8-4af4-c15a-cf177dbdd2c3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma: 8\n",
      "Resta: 2\n",
      "Multiplicación: 15\n",
      "División: 1.6666666666666667\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de una clase con métodos\n",
    "\n",
    "class Calculadora:\n",
    "    def sumar(self, a, b):\n",
    "        return a + b\n",
    "\n",
    "    def restar(self, a, b):\n",
    "        return a - b\n",
    "\n",
    "    def multiplicar(self, a, b):\n",
    "        return a * b\n",
    "\n",
    "    def dividir(self, a, b):\n",
    "        if b != 0:\n",
    "            return a / b\n",
    "        else:\n",
    "            print(\"Error: División por cero.\")\n",
    "\n",
    "# Crear una instancia de la clase\n",
    "calculadora = Calculadora()\n",
    "\n",
    "# Llamar a los métodos\n",
    "resultado_suma = calculadora.sumar(5, 3)\n",
    "resultado_resta = calculadora.restar(5, 3)\n",
    "resultado_multiplicacion = calculadora.multiplicar(5, 3)\n",
    "resultado_division = calculadora.dividir(5, 3)\n",
    "\n",
    "# Imprimir resultados\n",
    "print(f\"Suma: {resultado_suma}\")\n",
    "print(f\"Resta: {resultado_resta}\")\n",
    "print(f\"Multiplicación: {resultado_multiplicacion}\")\n",
    "print(f\"División: {resultado_division}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mJChbNTql5E7"
   },
   "source": [
    "### 3.1. Encapsulamiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t0v0y2RcoEsb"
   },
   "source": [
    "---\n",
    "Encapsulamiento\n",
    "\n",
    "---\n",
    "\n",
    "La encapsulación es una de las características clave de la programación orientada a objetos. La encapsulación consiste en agrupar atributos y métodos dentro de una misma clase. Evita que las clases externas accedan a los atributos y métodos de una clase y los modifiquen. Esto también ayuda a lograr la ocultación de datos. En Python, denotamos atributos privados utilizando el guión bajo como prefijo, es decir,` _` o `__`.\n",
    "\n",
    "* `__init__`:\n",
    "  * Es un método especial en Python que se llama automáticamente cuando se crea una nueva instancia de una clase.\n",
    "  * Este método se utiliza para inicializar los atributos de la clase o realizar otras acciones de configuración necesarias al crear un objeto.\n",
    "  * Se usa para asignar valores iniciales a los atributos de la clase y puede aceptar argumentos que se pasan al crear una instancia.\n",
    "\n",
    "* `__variable`:\n",
    "\n",
    "  * La convención de nombres con doble guion bajo (`__`) se utiliza para indicar que una variable es privada y no debe ser accedida directamente desde fuera de la clase.\n",
    "  * Aunque en Python no hay restricciones estrictas de acceso, la convención `__variable` sugiere que la variable es para uso interno y no debe ser modificada externamente.\n",
    "  * La encapsulación en Python se basa en esta convención y la buena práctica de no acceder directamente a variables privadas desde fuera de la clase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5voup749i2xz"
   },
   "source": [
    "La definición de una clase con encapsulación implica el uso de palabras clave tales como `class` y `__init__()`, veamos unos ejemplos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xyR84nWHjCUj"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica de una clase\n",
    "\n",
    "class un_tipo_de_objeto:\n",
    "  def __init__(parametros o atributos):        # Esta línea de código inicializa la clase\n",
    "    self.atributo_intrínseco_al_objeto_1 = valor_1\n",
    "    self.atributo_intrínseco_al_objeto_2 = valor_2\n",
    "\n",
    "  def metodo_del_objeto(parametros):\n",
    "    expresion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B9hRzzdFk0bT"
   },
   "source": [
    "En Python, la palabra reservada `self` se utiliza como convención para referirse al objeto actual de una clase. En el contexto de las clases y objetos, `self `se utiliza como el primer parámetro de los métodos de una clase y representa la instancia de la propia clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 188,
     "status": "ok",
     "timestamp": 1706153167668,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "J5T6pnK8izJm",
    "outputId": "ff6c005d-f886-45f9-acba-e5cd05cadb20"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre: Alice, Edad: 25\n",
      "Nombre: Alice, Edad: 25\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de definición de una clase con encapsulamiento\n",
    "\n",
    "class Persona:\n",
    "    def __init__(self, nombre, edad):\n",
    "        self.__nombre = nombre  # Atributo privado\n",
    "        self.__edad = edad      # Atributo privado\n",
    "\n",
    "    def obtener_nombre(self):\n",
    "        return self.__nombre\n",
    "\n",
    "    def obtener_edad(self):\n",
    "        return self.__edad\n",
    "\n",
    "    def imprimir_informacion(self):\n",
    "        print(f\"Nombre: {self.__nombre}, Edad: {self.__edad}\")\n",
    "\n",
    "# Crear una instancia de la clase\n",
    "persona1 = Persona(\"Alice\", 25)\n",
    "\n",
    "# Intentar acceder directamente a los atributos privados (no es recomendado)\n",
    "# print(persona1.__nombre)  # Esto generaría un error\n",
    "\n",
    "# Acceder a través de métodos\n",
    "print(f\"Nombre: {persona1.obtener_nombre()}, Edad: {persona1.obtener_edad()}\")\n",
    "\n",
    "# Imprimir información utilizando un método público\n",
    "persona1.imprimir_informacion()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1706153195849,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "ZmF5xhrEofHj",
    "outputId": "3802de93-6acd-43f6-e660-eaaee944dd32"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precio de venta: 900\n",
      "Precio de venta: 900\n",
      "Precio de venta: 1000\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de definición de una clase con encapsulamiento\n",
    "\n",
    "class Computador:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.__preciomaximo = 900\n",
    "\n",
    "    def venta(self):\n",
    "        print(\"Precio de venta: {}\".format(self.__preciomaximo))\n",
    "\n",
    "    def FijarPrecioMaximo(self, precio):\n",
    "        self.__preciomaximo = precio\n",
    "\n",
    "c = Computador()\n",
    "c.venta()\n",
    "\n",
    "# Intento de cambio de precio\n",
    "c.__preciomaximo = 1000\n",
    "c.venta()\n",
    "\n",
    "# Usar una función que tome como argumento el atributo privado para cambiar el atributo privado\n",
    "c.FijarPrecioMaximo(1000)\n",
    "c.venta()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 255,
     "status": "ok",
     "timestamp": 1706153682519,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "EljhVxuCruor",
    "outputId": "1e113167-6676-4925-d745-50041d25cebe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La suma de los elementos es: 15\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de una clase como un objeto usado para procesar datos\n",
    "\n",
    "class ProcesadorNumeros:\n",
    "    def __init__(self, numeros):\n",
    "        self.numeros = numeros\n",
    "\n",
    "    def sumar_elementos(self):\n",
    "        suma = 0\n",
    "        for numero in self.numeros:\n",
    "            suma += numero\n",
    "        return suma\n",
    "\n",
    "# Crear una instancia de la clase\n",
    "numeros_a_procesar = [1, 2, 3, 4, 5]\n",
    "procesador = ProcesadorNumeros(numeros_a_procesar)\n",
    "\n",
    "# Llamar al método para sumar elementos\n",
    "resultado_suma = procesador.sumar_elementos()\n",
    "\n",
    "# Imprimir el resultado\n",
    "print(f\"La suma de los elementos es: {resultado_suma}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1706153617349,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "6Lano4tPrW57",
    "outputId": "875c834c-9857-4d1e-d497-596a1578dd88"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma: 15\n",
      "Resta: 5\n",
      "Multiplicación: 50\n",
      "División: 2.0\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de una clase Calculadora con encapsulamiento\n",
    "\n",
    "class Calculadora:\n",
    "    def __init__(self, numero1, numero2):\n",
    "        self.__numero1 = numero1\n",
    "        self.__numero2 = numero2\n",
    "\n",
    "    def sumar(self):\n",
    "        return self.__numero1 + self.__numero2\n",
    "\n",
    "    def restar(self):\n",
    "        return self.__numero1 - self.__numero2\n",
    "\n",
    "    def multiplicar(self):\n",
    "        return self.__numero1 * self.__numero2\n",
    "\n",
    "    def dividir(self):\n",
    "        if self.__numero2 != 0:\n",
    "            return self.__numero1 / self.__numero2\n",
    "        else:\n",
    "            print(\"Error: División por cero.\")\n",
    "            return None\n",
    "\n",
    "# Crear una instancia de la clase\n",
    "calculadora = Calculadora(10, 5)\n",
    "\n",
    "# Llamar a los métodos encapsulados\n",
    "resultado_suma = calculadora.sumar()\n",
    "resultado_resta = calculadora.restar()\n",
    "resultado_multiplicacion = calculadora.multiplicar()\n",
    "resultado_division = calculadora.dividir()\n",
    "\n",
    "# Imprimir resultados\n",
    "print(f\"Suma: {resultado_suma}\")\n",
    "print(f\"Resta: {resultado_resta}\")\n",
    "print(f\"Multiplicación: {resultado_multiplicacion}\")\n",
    "print(f\"División: {resultado_division}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yHTnjCj5nnwq"
   },
   "source": [
    "### 3.2. Herencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W4YlSSmkr6Ck"
   },
   "source": [
    "---\n",
    "Herencia\n",
    "\n",
    "---\n",
    "\n",
    "La herencia es un mecanismo en programación orientada a objetos donde una clase puede adquirir atributos y métodos de otra clase. La clase derivada hereda las características de la clase base, lo que facilita la reutilización del código y la creación de una jerarquía de clases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WoDPcXqds736"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica de herencia de clases\n",
    "\n",
    "class clase_1:\n",
    "  atributo_1 = valor\n",
    "  atributo_2 = valor\n",
    "\n",
    "   def metodo_1(self):\n",
    "    expresion\n",
    "\n",
    "  def metodo_2(self):\n",
    "    expresion\n",
    "\n",
    "class clase_2(clase_2): # Clase que hereda los metodos de otra clase\n",
    "  atributo_1 = valore\n",
    "  atributo_2 = valor\n",
    "\n",
    "  def metodo_1(self):\n",
    "    expresion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 179,
     "status": "ok",
     "timestamp": 1706153979244,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "rqxdx_YMr5q6",
    "outputId": "ea3c2968-cd2f-45c6-c7f5-ab0d28b3d045"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mario\n",
      "Rodriguez\n",
      "Puedo hacer comentarios!\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de herencia simple\n",
    "\n",
    "class persona:\n",
    "\n",
    "  def nombre(self):\n",
    "    print('Mario')\n",
    "\n",
    "  def apellido(self):\n",
    "    print('Rodriguez')\n",
    "\n",
    "class otra_persona(persona):\n",
    "  def comentario(self):\n",
    "    print('Puedo hacer comentarios!')\n",
    "\n",
    "p = otra_persona()\n",
    "\n",
    "p.nombre()\n",
    "p.apellido()\n",
    "p.comentario()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1706154093764,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "LK0-OJ1-jtEM",
    "outputId": "ac195be7-cf32-4f21-c5f4-8ca4ad6eb08f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Marca: Toyota, Modelo: Camry\n",
      "Color: Azul\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de clase cvehículo\n",
    "\n",
    "class Vehiculo:\n",
    "    def __init__(self, marca, modelo):\n",
    "        self.marca = marca\n",
    "        self.modelo = modelo\n",
    "\n",
    "    def mostrar_informacion(self):\n",
    "        print(f\"Marca: {self.marca}, Modelo: {self.modelo}\")\n",
    "\n",
    "class Coche(Vehiculo):\n",
    "    def __init__(self, marca, modelo, color):\n",
    "        # Llamada al constructor de la clase base\n",
    "        super().__init__(marca, modelo)\n",
    "        self.color = color\n",
    "\n",
    "    def mostrar_informacion_coche(self):\n",
    "        print(f\"Color: {self.color}\")\n",
    "\n",
    "# Crear una instancia de la clase derivada (Coche)\n",
    "mi_coche = Coche(\"Toyota\", \"Camry\", \"Azul\")\n",
    "\n",
    "# Acceder a los métodos de la clase base y la clase derivada\n",
    "mi_coche.mostrar_informacion()  # Métodos de la clase base\n",
    "mi_coche.mostrar_informacion_coche()  # Método de la clase derivada\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CqsxWgG-mYei"
   },
   "source": [
    "# **Créditos**\n",
    "---\n",
    "\n",
    "**Docente:** Nicolás Castillo Ojeda\n",
    "\n",
    "**Universidad Pedagógica y Tecnológica de Colombia** - *Diplomado en Data Science - Cohorte I - 2024*\n",
    "\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyNxNNUL5p3yHCB51zV7Rn3I",
   "collapsed_sections": [
    "aMkZsHY5tzQv",
    "ZdqDbnr-uX94",
    "0quzOVhCNpDr",
    "_6L2HLzXT_es",
    "dDzTO69kYmF9",
    "wayobxPKZrVG",
    "xyC2AfFSaHFc",
    "e3xXlj50t5--",
    "dvT3LC7EgqiV",
    "wfxkZ2y5rNz6",
    "7wa0MZsHmFqN",
    "mJChbNTql5E7",
    "yHTnjCj5nnwq"
   ],
   "mount_file_id": "19iXRvnqKue-0kstpQ_9wQT0sOVW37IZg",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}