Copia_de_Funciones_Clases.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "010DZlFzzUrf"
   },
   "source": [
    "# **Funciones**\n",
    "\n",
    "En computación, una función se define como un bloque de código que se puede llamar y ejecutar en un programa para realizar una tarea específica. En términos más técnicos, una función se define como una subrutina o procedimiento que toma cero o más argumentos, realiza un conjunto de operaciones y puede devolver un resultado.\n",
    "\n",
    "En Python existen funciones que aparecen recurrentemente (no confundir con un algoritmo recurrente) tales como `print()` o `open()`. Estas funciones son las llamadas \"Built in\" y es posible acceder a su documentación de manera sencilla con `help`.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "J5i1x-rRzKaa"
   },
   "outputs": [],
   "source": [
    "help(open)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U_m0NE3Zqx0W"
   },
   "source": [
    "Sin embargo, también es posible trabajar con funciones construidas a partir de rutinas propias. Para ello, Python contiene una sintaxis para su definición.\n",
    "\n",
    "```\n",
    "def function(arguments):\n",
    "    routine\n",
    "    return result_of_the_reoutine\n",
    "```\n",
    "\n",
    "En el esquema anterior se pueden ver varios elementos importantes en la definición de una función. La primera es la palabra clave `def` que sirve para comunicarle a python que se está por declarar o definir una función. La segunda es el nombre de la función, en este caso se ha utilizado un nombre bastante general: `function`. Luego entre paréntesis deben ir predefinidos los argumentos que deben ser definidos para el correcto funcionamiento de la función. Seguido se puede ver que existe una rutina llamada `routine`. Claramente esta linea resume de forma muy simplificada un algoritmo completo que conduce a que posteriormente la función devuelva através de `return` el valor que se precisa que la función entregue.\n",
    "\n",
    "En ocasiones, no es necesario que una función \"devuelva\" algo, en ocasiones la función puede simplemente hacer una impresión, o guardar información como un archivo en disco. Posteriormente veremos esto de una forma más profunda. Por lo pronto veamos cómo y por qué se usan funciones de una forma intuitiva.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bPpdzgxJtY3K"
   },
   "source": [
    "**Ejercicio 0**\n",
    "\n",
    "La ecuación cuadrática es una ecuación de la forma\n",
    "$$ax^2 + bx + c = 0$$\n",
    "Donde $a, b, c \\in \\Re$. Dicha ecuación tiene 2 soluciones en general complejas de la forma\n",
    "\n",
    "$$x = \\frac{-b \\pm \\sqrt{b^2 - 4 a c}}{2 a}$$\n",
    "\n",
    "Desarrolle una rutina para el cálculo de las soluciones de $x$ dependiendo de $a,b,c$ préviamente definidas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MHtDtpnMqQRe",
    "outputId": "fbb2b8f0-1c59-4938-e5be-9b2ef0f2bd84"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0 2.0\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = -5\n",
    "c = 6\n",
    "\n",
    "x1 = (-b + (b**2 - 4*a*c)**0.5)/(2*a)\n",
    "x2 = (-b - (b**2 - 4*a*c)**0.5)/(2*a)\n",
    "\n",
    "print(x1, x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "arQyOMDCVHmx",
    "outputId": "324bed54-bd83-4784-ffe3-be716d6ae93d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Las soluciones a la ecuación cuadrática son (3.0, 2.0)\n"
     ]
    }
   ],
   "source": [
    "def cuadratic_solution(a, b, c):\n",
    "  x1 = (-b + (b**2 - 4*a*c)**0.5)/(2*a)\n",
    "  x2 = (-b - (b**2 - 4*a*c)**0.5)/(2*a)\n",
    "\n",
    "  print(f\"Las soluciones a la ecuación cuadrática son {x1, x2}\")\n",
    "  return x1, x2\n",
    "\n",
    "var1, var2 = cuadratic_solution(1, -5, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uL3dNa0Vu5TS"
   },
   "source": [
    "Cuando se está desarrollando código es fácil cometer errores. Suponga que en lugar de elevar al valor de `**0.5`, se multiplica por dicho valor `*0.5`, y esta rutina se utiliza para resolver todo el álgebra de Baldor.\n",
    "\n",
    "Este error se propagaría a lo largo de cientos o quizás miles de ejercicios, lo cual en el punto en el que una persona encargada de \"debuggear\" el código habría demasiadas lineas que revisar para poder corregir un simple `*` que se propagó por hacer `Ctrl+C`, `Ctrl+V`. En este sentido implementar una función y utilizarla recurrentemente podría ser más útil, pues corregir todos estos ejercicios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CCOggflCuxM0",
    "outputId": "090ed12a-db52-4d78-c86c-775c5adee55c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Las soluciones a la ecuación cuadrática son (3.0, 2.0)\n"
     ]
    }
   ],
   "source": [
    "def cuadratic_solution(a, b, c):\n",
    "  \"\"\"\n",
    "  Función recibe 3 valores enteros o flotantes: a, b, y c,\n",
    "  y retorna la solución a la ecuación cuadrática ax^2 + bx + c = 0\n",
    "\n",
    "  Ex:\n",
    "    In[0]: x, y = cuadratic_solution(1, -5, 6)\n",
    "    Out[0]: Las soluciones a la ecuación cuadrática son (3.0, 2.0)\n",
    "  \"\"\"\n",
    "  x1 = (-b + (b**2 - 4*a*c)**0.5)/(2*a)\n",
    "  x2 = (-b - (b**2 - 4*a*c)**0.5)/(2*a)\n",
    "\n",
    "  print(f\"Las soluciones a la ecuación cuadrática son {x1, x2}\")\n",
    "  return x1, x2\n",
    "\n",
    "var1, var2 = cuadratic_solution(1, -5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3CYClQ5rZGQY",
    "outputId": "610589cd-d9fb-4279-b8aa-cf947a09e583"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(var1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ODBaMFxXz_VC",
    "outputId": "13aaddec-f2c2-411c-bb21-8a65a80ac507"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function cuadratic_solution in module __main__:\n",
      "\n",
      "cuadratic_solution(a: float, b: float, c: float)\n",
      "    Función recibe 3 valores enteros o flotantes: a, b, y c,\n",
      "    y retorna la solución a la ecuación cuadrática ax^2 + bx + c = 0\n",
      "    \n",
      "    Ex:\n",
      "      In[0]: x, y = cuadratic_solution(1, -5, 6)\n",
      "      Out[0]: Las soluciones a la ecuación cuadrática son (3.0, 2.0)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(cuadratic_solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hjkg3rED0mQW"
   },
   "source": [
    "La posibilidad de definir nuestras propias funciones nos ayudará de diversas maneras:\n",
    "\n",
    "* Cuando estemos escribiendo un programa y veamos que estamos escribiendo el mismo código más de una vez, probablemente sea mejor definir una función con el código repetido. Luego podremos llamar a la función tantas veces como sea necesario en lugar de reescribir el código una y otra vez. Es importante que evitemos escribir el mismo código más de una vez en nuestros programas.\n",
    "\n",
    "* Si escribimos el mismo código más de una vez y cometemos un error, debemos corregir ese error en cada lugar donde copiamos el código. Si por el contrario, tenemos el código en un solo lugar, definido en una función, podremos resolver el error solo en este lugar y olvidarnos del resto de lugares.\n",
    "\n",
    "  Si cometemos un error al escribir una función, y luego corregimos el código en la función, habremos corregido automáticamente el código en cada lugar que utiliza la función. Este principio de programación modular es un concepto muy importante.\n",
    "\n",
    "* Las funciones también ayudan a que nuestro código sea más fácil de leer. Cuando usamos buenos nombres para las variables y funciones en nuestros programas, podemos leer el código y comprender lo que hemos escrito, no solo mientras lo escribimos, sino tiempo después, cuando necesitemos mirar el código que escribimos nuevamente.\n",
    "\n",
    "Las funciones son pues una forma de organizar nuestro código y hacerlo más legible y reutilizable. Cuando escribamos una función debemos tener presentes los siguientes puntos:\n",
    "\n",
    " * ¿Cómo deberíamos llamar nuestra función? Deberíamos darle un nombre que tenga sentido y describa lo que hace la función. Como una función hace algo, el nombre de una función suele ser un verbo o una descripción de lo que devuelve la función. Puede ser una palabra o varias palabras.\n",
    " * ¿Qué debemos pasarle a nuestra función? En otras palabras, ¿qué argumentos pasaremos a la función? Al pensar en argumentos para pasarle a una función, debemos pensar cómo se usará la función y qué argumentos la harían más útil.\n",
    " * ¿Qué debe hacer la función? ¿Cual es su propósito? La función debe tener un propósito claramente definido. ¿Debería devolver un valor particular o debería realizar alguna tarea secundaria?\n",
    " * Finalmente, ¿qué debe devolver nuestra función? Se debe considerar el tipo y el valor a devolver. Si la función va a devolver un valor, debebemos decidir qué tipo de valor deberá devolver.\n",
    "\n",
    "Al considerar estas preguntas y responderlas, podemos asegurarnos de que nuestras funciones tengan sentido antes de escribirlas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "z9uSXro8013c"
   },
   "source": [
    "## **Tipos de Funciones**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TQsi1g4S1kwa"
   },
   "source": [
    "1. **Funciones de argumentos requeridos**: Los argumentos requeridos son argumentos pasados a una función, que tienen un carácter obligatorio y se dan en el **orden posicional correcto**. Veamos un ejemplo: creemos una función que, dados dos parámetros, nos devuelva la resta de estos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "liVp67A50SUM",
    "outputId": "83b592ff-9c1a-4924-f568-ebf4b446538d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def substraction(a, b):\n",
    "  return b - a\n",
    "\n",
    "substraction(3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "kv77sD6RaRbB",
    "outputId": "bc024f13-704f-4945-805b-b020ede4f8ed"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "substraction(b = 3, a = 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Na-PhdQG1pWM"
   },
   "source": [
    "  Esta función solamente precisa específicamente de dos argumentos para funcionar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZcPYIvUM2HLg"
   },
   "source": [
    "2. **Argumentos predeterminados**: A menudo, al definir una función, hay ciertos valores que queremos que la función use la mayor parte del tiempo, pero también nos gustaría tener cierta flexibilidad en la elección de estos valores. En tal caso, podemos usar valores predeterminados para los argumentos. Redefinamos la función `Saludo` de manera que el argumento `nombre` tome un valor por defecto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "uKPQZuzh16GF",
    "outputId": "230274e8-ee1e-4d16-f9cc-6c67c1e4248d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Señor o Señora, cómo se encuentra hoy?\n"
     ]
    }
   ],
   "source": [
    "def generic_greetings(name = 'Señor o Señora'):\n",
    "  print(f'Hola {name}, cómo se encuentra hoy?')\n",
    "\n",
    "generic_greetings()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dzH3wT4y2hcp",
    "outputId": "3bc71959-6821-4167-8748-ebea9ab72aa1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Tomas, cómo se encuentra hoy?\n"
     ]
    }
   ],
   "source": [
    "generic_greetings(name = 'Tomas')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W_IaahR45zFv"
   },
   "source": [
    "## **Argumentos de longitud variable**\n",
    "\n",
    "Es posible que necesitemos ejecutar una función en la que en principio no sabemos cuántos argumentos se pasarán a la función. En este caso, podemos utilizar una clase especial de argumentos, denominados argumentos de longitud variable, con los que podemos capturar todos los argumentos que se pasen a la función.\n",
    "\n",
    "**args**: El argumento de longitud variable `*args` permite capturar una serie de argumentos sin necesidad de especificar en un principio su número"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WLh4rBz12X0D"
   },
   "outputs": [],
   "source": [
    "def sumatory(*nums):\n",
    "  total = 5\n",
    "  for number in nums:\n",
    "    total += number\n",
    "\n",
    "    #print(total)\n",
    "  return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oAw-F2r7dw4g",
    "outputId": "8c9c57cc-25d2-4cee-fa43-49c79c1e259c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums = 1, 2, 3\n",
    "type(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "VxUWvMhR7HPp",
    "outputId": "56a64801-9af0-4039-c017-c7bb690fc930"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sumatory(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Znfzf2aG7u-d"
   },
   "source": [
    "## **Lambdas $\\lambda$**\n",
    "\n",
    "Estas funciones se denominan anónimas porque no se declaran de la manera estándar utilizando la palabra clave `def`. Podemos usar la palabra clave `lambda` para crear pequeñas funciones anónimas. La sintáxis general es de la forma:\n",
    "\n",
    "  `lambda arg1, arg2, ... : expresion(arg1, arg2, ...)`\n",
    "\n",
    "Por ejemplo, definamos una función que realice la suma de dos números"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4fOhDrPj7I-W",
    "outputId": "93caa335-a455-48e6-a8b5-b8ffdd38f057"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "suma_2 =lambda a,b : a + b\n",
    "suma_2(3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7kR4Xkrr8AFb",
    "outputId": "9d6380c3-cfae-4b32-e742-adcc6aab0d52"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.sumatory(*nums)>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sumatory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Dv8Jq5mK9o3H"
   },
   "source": [
    "# **Clases y Objetos**\n",
    "\n",
    "Una clase es una plantilla o un plano que define la estructura y el comportamiento de un tipo de objeto en particular. En Python, absolutamente todo es un objeto, esto quiere decir que todo tiene métodos (funcionalidades) y atributos (características). Una clase en Python actúa como un \"molde\" a partir del cual se crean múltiples objetos. Define los atributos y los métodos que los objetos de esa clase tendrán. Los atributos son las variables asociadas a la clase y los métodos son las funciones que pueden ser llamadas en los objetos de esa clase.\n",
    "\n",
    "Por otro lado, un objeto es una instancia específica de una clase. Un objeto puede ser cualquier cosa, desde números, cadenas de texto o listas, hasta estructuras de datos más complejas o incluso entidades abstractas en un programa. Cada objeto tiene un estado (representado por sus atributos o variables) y un comportamiento (definido por sus métodos o funciones).\n",
    "\n",
    "\n",
    "```\n",
    "class Nombre_De_La_Clase():\n",
    "  def __init__(self, characts_args):\n",
    "    self.characteristics = characts_args\n",
    "\n",
    "  def funcionalidad(self, args):\n",
    "    routine\n",
    "```\n",
    "\n",
    "En la técnica esta es la sintaxis básica para la implementación de una clase. Veámoslo en la práctica.\n",
    "\n",
    "**Ejercicio 2**\n",
    "\n",
    "Cree una clase que ayude a una empresa a estandarizar la información de las personas que ingresan a sus planteles. Entre los atributos de las personas como nombre e identificación, debe estar la información de si son clientes o personal de la empresa, además. Genere\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_7ip6D6K8Mgq"
   },
   "outputs": [],
   "source": [
    "class Persona():\n",
    "\n",
    "  def __init__(self, name: str, last_name: str, ID: int):\n",
    "    self.info = {\"Nombre\": name,\n",
    "                 \"Apellido\": last_name,\n",
    "                 \"ID\": ID}\n",
    "\n",
    "  def generar_binario(self):\n",
    "    id_bin = format(self.info['ID'], 'b')\n",
    "    print(f\"Su identificación en binario es {id_bin}\")\n",
    "\n",
    "\n",
    "class Empleado(Persona):\n",
    "\n",
    "  def __init__(self, position: str, name: str, last_name: str, ID: int):\n",
    "    Persona.__init__(self, name, last_name, ID)\n",
    "    self.info['Cargo'] = position\n",
    "    self.info['Responsabilidades'] = []\n",
    "\n",
    "  def definir_responsabilidades(self):\n",
    "    n_resp = int(input(\"Ingrese el número de responsabilidades que desea ingresar: \"))\n",
    "    self.info['Responsabilidades'] = [input(f\"Ingrese la responsabilidad número {n+1}\") for n in range(n_resp)]\n",
    "\n",
    "  def remover_responsabilidades(self, responsabilidad):\n",
    "    self.info['responsabilidades'].remove(responsabilidad)\n",
    "\n",
    "class Usuario(Persona):\n",
    "\n",
    "  def __init__(self, razon: str, date: str, name: str, last_name: str, ID: int):\n",
    "    Persona.__init__(self, name, last_name, ID)\n",
    "    self.info['Razón última visita'] = [razon]\n",
    "    self.info['Fecha de ingreso'] = [date]\n",
    "\n",
    "  def agregar_nuevo_ingreso(self, date, razon):\n",
    "    self.info['Fecha de ingreso'].append(date)\n",
    "    self.info['Razón última visita'].append(razon)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Tomas = Empleado(\"Docente\" ,\"Tomas\", \"Atehortua\", 1020459251)\n",
    "Tomas.info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gJyeej-mFGf6"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ls6W1u0YFOZt"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZFvfAbqiKPqx"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Y_8bD7c8HuCL"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5zQg_6moG-Fg"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LUxudoO3EbOK"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}