Módulo_7_Reutilizando_Funciones.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vSaCHJGm80CV"
      },
      "source": [
        "![Data Science Black@300x.png](https://i.imgur.com/eJKkh5m.png)\n",
        "\n",
        "# ¡Bienvenidos a la \"Ciudad Python: Programando la Ciudad del Futuro\"!\n",
        "\n",
        "\n",
        "En este módulo, aprenderás sobre la definición de funciones en Python y cómo reutilizar código de manera eficiente. También exploraremos las funciones incorporadas de Python y los atributos de los objetos, incluyendo métodos y propiedades. Además, veremos ejemplos de métodos aplicados a objetos de cadena. Al final, pondrás en práctica lo aprendido a través de ejercicios.\n",
        "\n",
        "## ¿Funciones?\n",
        "\n",
        "Sí, con Python puedes repetir acciones varias veces y ejecutarlas, segun tus condiciones, hasta cuando tu quieras.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2i8uy7mlQWqg"
      },
      "source": [
        "## Funciones en Python\n",
        "\n",
        "Una función es un objeto de Python que puedes \"llamar\" para realizar una acción o calcular y devolver otro objeto. Se llama a una función colocando paréntesis a la derecha del nombre de la función. Algunas funciones permiten pasar argumentos dentro de los paréntesis (separando varios argumentos con una coma). Internamente a la función, estos argumentos son tratados como variables.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XegzbZuHQ2EA"
      },
      "source": [
        "Para hacer una función utilizamos la palabra **def** que viene del inglés *definition* y se utiliza en Python para reutilizar partes del código llamando su ejecución:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LD6Qh03oScuK"
      },
      "source": [
        "![function](https://i.imgur.com/FwdhGTVm.png)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FD-R8ssJQ1U2",
        "outputId": "bc858313-2c5d-41a6-de35-d7b0be7ebf04"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Area de radio 5: 78.53790000000001\n",
            "Area de radio 50: 7853.790000000001\n",
            "Area de radio 500: 785379.0\n"
          ]
        }
      ],
      "source": [
        "def circle_area(radius):              # Definimos la función circle_area con el parámetro radius\n",
        "    return 3.141516 * (radius ** 2)   # Retornamos el cálculo del área\n",
        "\n",
        "print(\"Area de radio 5:\",  circle_area(5))              # llamamos la función pasando el argumento y imprimimos el valor\n",
        "print(\"Area de radio 50:\", circle_area(50))\n",
        "print(\"Area de radio 500:\",  circle_area(500))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "HhNF_B6aZXYH"
      },
      "source": [
        "## Funciones incorporadas de Python \n",
        "\n",
        "Algunas funciones permiten pasar **argumentos** dentro de los paréntesis (separando varios argumentos con una coma). Internamente a la función, estos argumentos son tratados como variables.\n",
        "\n",
        "Python tiene varias funciones incorporadas muy útiles para ayudarte a trabajar con diferentes objetos y/o tu entorno. Aquí hay una pequeña muestra de ellas:\n",
        "\n",
        "- **`type(obj)`** para determinar el tipo de un objeto\n",
        "- **`len(container)`** para determinar cuántos elementos hay en un contenedor\n",
        "- **`callable(obj)`** para determinar si un objeto es llamable\n",
        "- **`sorted(container)`** para devolver una nueva lista de un contenedor, con los elementos ordenados\n",
        "- **`suma(contenedor)`** para calcular la suma de un contenedor de números\n",
        "- **`min(contenedor)`** para determinar el elemento más pequeño de un contenedor\n",
        "- **`max(contenedor)`** para determinar el elemento más grande de un contenedor\n",
        "- **`abs(número)`** para determinar el valor absoluto de un número\n",
        "- **`repr(obj)`** para devolver una representación de cadena de un objeto\n",
        "\n",
        "> Lista completa de funciones incorporadas: https://docs.python.org/3/library/functions.html\n",
        "\n",
        "También hay diferentes formas de definir tus propias funciones y objetos invocables que exploraremos más adelante."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "Pu5QRgFpV32v"
      },
      "outputs": [],
      "source": [
        "simple_string1 = 'Hello Ciudad Python'\n",
        "simple_string2 = 'Hola Ciudad Python'\n",
        "list1 = [3, 5, 6, 3, 'pasajero', 'conductor', False]\n",
        "tuple1 = (3, 5, 6, 3, 'pasajero', 'conductor', False)\n",
        "set1 = {3, 5, 6, 3, 'pasajero', 'conductor', False}\n",
        "dict1 = {'bus_id': 'MB-564', 'age': 23, 'stop_name': ['UTP', 'Machetazo', 'San Miguelito']}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "5AUfabkmZXYI",
        "outputId": "4be96fef-6de6-4139-d624-9542fae224b4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función type() para identificar al tipo de ojeto\n",
        "type(simple_string1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "deletable": true,
        "editable": true,
        "id": "_i3XkdJqZXYI",
        "outputId": "be89749c-3a7f-41f6-e908-8f286b460ae6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función len() para contar el número de elementos dentro del contenedor\n",
        "len(dict1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "GhGrjn0YZXYI",
        "outputId": "9c49fff7-a63f-4c7b-a8e9-00298406e01f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "18"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función len() para contar el número de elementos dentro del contenedor\n",
        "len(simple_string2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "deletable": true,
        "editable": true,
        "id": "XlmlBbD2ZXYI",
        "outputId": "6bca9d61-8dfb-489c-8f19-064dfaf320e0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función callable() para verificar si puedes \"llamar\" a una función\n",
        "callable(len)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Jrnbd2NQZXYJ",
        "outputId": "f2118887-cc53-4bd5-cc0f-a36b2002cd2f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función callable() para verificar si puedes \"llamar\" a un objeto\n",
        "callable(dict1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ewoKZytHZXYJ",
        "outputId": "7fca41fe-b14a-42ed-9d57-d6e49878bdc5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[-3, 1, 2, 3.6, 5, 7, 10]"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función sorted() para retornar una nueva secuencia lógica de un contenedor\n",
        "sorted([10, 1, 3.6, 7, 5, 2, -3])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "QjdkZImkZXYJ",
        "outputId": "d4594756-d84e-4d4e-a04e-40fa322861c4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['California', 'Chicago', 'ants', 'cats', 'dogs', 'mice', 'zebras']"
            ]
          },
          "execution_count": 48,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función sorted() para retornar una nueva secuencia lógica de un contenedor\n",
        "# Nota que las palabras con mayúscula se colocan de primero\n",
        "sorted(['dogs', 'cats', 'zebras', 'Chicago', 'California', 'ants', 'mice'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "deletable": true,
        "editable": true,
        "id": "BArcvNk4ZXYJ",
        "outputId": "d8934a95-9ea3-4d56-a092-b94d2f53c1c4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "26.6"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función sum() para retornar la suma de los elementos en un contenedor puramente numérico\n",
        "sum([10, 1, 3.6, 7, 5, 3, -3])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "deletable": true,
        "editable": true,
        "id": "rae4f9aSZXYJ",
        "outputId": "dbd6ad73-d6ab-4b84-a0e5-e4438dbe4842"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "-3"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función min() para obtener el elemento mínimo en un contenedor\n",
        "min([10, 1, 3.6, 7, 5, 2, -3])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1YQnsGj6ZXYK",
        "outputId": "0d75efaf-eec0-4bb1-b240-653d8c2840f6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'a'"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función min() para obtener el elemento mínimo en un contenedor\n",
        "min(['g', 'z', 'a', 'y'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "QJ5F5W2AZXYK",
        "outputId": "3e2d7ef7-0de0-4de2-c9c9-fce6fb3f6835"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "execution_count": 52,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función max() para obtener el elemento máximo en un contenedor\n",
        "max([10, 1, 3.6, 7, 5, 2, -3])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "AVN8fNcYZXYK",
        "outputId": "332094b6-2503-4786-876f-9045fbcf226e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'t'"
            ]
          },
          "execution_count": 18,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función max() para obtener el elemento máximo en un contenedor\n",
        "max('transporte')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "JCQfvclSZXYK",
        "outputId": "5803ad40-9390-4bde-dc80-0791855a4019"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función abs() para obtener el valor absoluto de un número\n",
        "abs(10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "zfMBYCpwZXYK",
        "outputId": "4db40338-e8ce-41e3-a7c4-af400ba1f84c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función abs() para obtener el valor absoluto de un número\n",
        "abs(-12)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "MEYIvfg-ZXYK",
        "outputId": "a97cd4e6-a860-4dc3-8a27-61a6dab3c127"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 21,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Usa la función round() para redondear un decimal a su entero mas próximo\n",
        "round(3.1416)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "xrDFQDeqZXYL"
      },
      "source": [
        "## Atributos de los objetos de Python (métodos y propiedades)\n",
        "\n",
        "Los diferentes tipos de objetos en Python tienen diferentes **atributos** a los que se puede hacer referencia por su nombre (similar a una variable). Para acceder a un atributo de un objeto, utiliza un punto (`.`) después del objeto, y luego especifica el atributo (es decir, `obj.atributo`)\n",
        "\n",
        "Cuando un atributo de un objeto es invocable, ese atributo se llama **método**. Es lo mismo que una función, sólo que esta función está ligada a un objeto concreto.\n",
        "\n",
        "Cuando un atributo de un objeto no es invocable, ese atributo se llama **propiedad**. Es sólo un dato sobre el objeto, que es en sí mismo otro objeto.\n",
        "\n",
        "La función incorporada `dir()` puede utilizarse para devolver una lista de los atributos de un objeto.\n",
        "\n",
        "Por ejemplo para saber todo lo que podemos hacer con un cadena de texto podemos utilizar:\n",
        "<hr>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xews4ic6XCeh",
        "outputId": "80f3936b-5879-4bb2-e2c2-82d02d3b20d3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['__add__',\n",
              " '__class__',\n",
              " '__contains__',\n",
              " '__delattr__',\n",
              " '__dir__',\n",
              " '__doc__',\n",
              " '__eq__',\n",
              " '__format__',\n",
              " '__ge__',\n",
              " '__getattribute__',\n",
              " '__getitem__',\n",
              " '__getnewargs__',\n",
              " '__gt__',\n",
              " '__hash__',\n",
              " '__init__',\n",
              " '__init_subclass__',\n",
              " '__iter__',\n",
              " '__le__',\n",
              " '__len__',\n",
              " '__lt__',\n",
              " '__mod__',\n",
              " '__mul__',\n",
              " '__ne__',\n",
              " '__new__',\n",
              " '__reduce__',\n",
              " '__reduce_ex__',\n",
              " '__repr__',\n",
              " '__rmod__',\n",
              " '__rmul__',\n",
              " '__setattr__',\n",
              " '__sizeof__',\n",
              " '__str__',\n",
              " '__subclasshook__',\n",
              " 'capitalize',\n",
              " 'casefold',\n",
              " 'center',\n",
              " 'count',\n",
              " 'encode',\n",
              " 'endswith',\n",
              " 'expandtabs',\n",
              " 'find',\n",
              " 'format',\n",
              " 'format_map',\n",
              " 'index',\n",
              " 'isalnum',\n",
              " 'isalpha',\n",
              " 'isascii',\n",
              " 'isdecimal',\n",
              " 'isdigit',\n",
              " 'isidentifier',\n",
              " 'islower',\n",
              " 'isnumeric',\n",
              " 'isprintable',\n",
              " 'isspace',\n",
              " 'istitle',\n",
              " 'isupper',\n",
              " 'join',\n",
              " 'ljust',\n",
              " 'lower',\n",
              " 'lstrip',\n",
              " 'maketrans',\n",
              " 'partition',\n",
              " 'replace',\n",
              " 'rfind',\n",
              " 'rindex',\n",
              " 'rjust',\n",
              " 'rpartition',\n",
              " 'rsplit',\n",
              " 'rstrip',\n",
              " 'split',\n",
              " 'splitlines',\n",
              " 'startswith',\n",
              " 'strip',\n",
              " 'swapcase',\n",
              " 'title',\n",
              " 'translate',\n",
              " 'upper',\n",
              " 'zfill']"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "nombre = \"Elon\"\n",
        "dir(nombre) # Lista todos los métodos que podemos utilizar"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ldUNcArXZXYL"
      },
      "source": [
        "## Algunos métodos sobre objetos de cadena\n",
        "\n",
        "- **`.capitalize()`** para devolver una versión en mayúsculas de la cadena (sólo el primer caracter en mayúscula)\n",
        "- **`.upper()`** para devolver una versión en mayúsculas de la cadena (todos los caracteres en mayúsculas)\n",
        "- **`.lower()`** para devolver una versión en minúsculas de la cadena (todos los caracteres en minúsculas)\n",
        "- **`.count(substring)`** para devolver el número de apariciones de la subcadena en la cadena\n",
        "- **`.startswith(substring)`** para determinar si la cadena comienza con la subcadena\n",
        "- **`.endswith(substring)`** para determinar si la cadena termina con la subcadena\n",
        "- **`.replace(old, new)`** para devolver una copia de la cadena con las ocurrencias de \"old\" reemplazadas por \"new\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "vqVvTnQ0ZXYL"
      },
      "outputs": [],
      "source": [
        "# Asigna una cadena de caracteres a una variable\n",
        "a_string = 'eStA es unA cadeNa De caRaCtERes'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wsg6P4gFZXYL",
        "outputId": "0fc2a1a3-cfa9-43e3-ca8e-2599e4d36149"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'Esta es una cadena de caracteres'"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Devuelve una versión en mayúsculas de la cadena (solo el primer caracter en mayúscula)\n",
        "a_string.capitalize()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "I1LOComsZXYL",
        "outputId": "560a2287-9ece-4b75-a1fb-b48e1efa0c34"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'ESTA ES UNA CADENA DE CARACTERES'"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Devuelve una versión en mayúsculas de la cadena\n",
        "a_string.upper()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ksjS_j2HZXYL",
        "outputId": "2a07bac5-ad26-4e0f-bc8f-22dceb73efb7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'esta es una cadena de caracteres'"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Devuelve una versión en minúsculas de la cadena\n",
        "a_string.lower()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1zEXwlsNZXYM",
        "outputId": "f6fe498f-4f0e-42c4-e3c2-f130a5d9bef5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'eStA es unA cAdeNa De caRaCtERes'"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Nota que los métodos llamados no han modificado a la cadena de caracteres original\n",
        "a_string"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "9DIybecJZXYM",
        "outputId": "b49b82fb-66ff-4722-f312-491289475d19"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Ahora, contemos el número de ocurrencias de una subcadena dentro de una cadena\n",
        "a_string.count('A')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "-uoi01GgZXYM",
        "outputId": "37c4c9e4-c207-4433-c203-b28a1d626f62"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 30,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Ahora, contemos el número de ocurrencias de una subcadena dentro de una cadena después de una posición\n",
        "a_string.count('A', 7)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0qEdNePtZXYM",
        "outputId": "9ddf20f0-bd80-4ee6-91a9-6882441975c8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Contemos el numero de ocurrencias de una subcadena dentro de una cadena\n",
        "a_string.count('ca')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "mQTL1c93ZXYM",
        "outputId": "661e47af-8bfa-4b8b-f1ad-f52d9bfabb48"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 33,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# la cadena comienza con 'Esta'?\n",
        "a_string.startswith('this')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1k-NY1W_ZXYM",
        "outputId": "428b9da4-5024-4132-8128-5e62bd4029d4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# la cadena en versión minúscula comienza con 'esta'?\n",
        "a_string.lower().startswith('esta')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "WGmMRQzaZXYM",
        "outputId": "4d7e699f-85fb-4382-9a94-c3aecd60d4c4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 36,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# La cadena termina con 'es'?\n",
        "a_string.endswith('es')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "SZKQBX5fZXYN",
        "outputId": "aabdc7a8-d57d-403e-f7be-e72828ef2322"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'eStA XYZ unA cadeNa De caRaCtERXYZ'"
            ]
          },
          "execution_count": 37,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Devueleve una nueva versión de la cadena con una subcadena siendo reemplazada por algo más\n",
        "a_string.replace('es', 'XYZ')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "kOT1C0b6ZXYN",
        "outputId": "332d7ca2-1517-4463-ce4e-328d7bb8f08a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'eStA es unA c@deN@ De c@R@CtERes'"
            ]
          },
          "execution_count": 39,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Devueleve una nueva versión de la cadena con una subcadena siendo reemplazada por algo más\n",
        "a_string.replace('a', '@')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Zr8L-zK6ZXYN",
        "outputId": "c2b56ec6-727a-4cca-ddcb-ec8683c117bf"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'eStA es unA c@deN@ De caRaCtERes'"
            ]
          },
          "execution_count": 40,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Devueleve una nueva versión de la cadena con las primeras dos ocurrencias de la subcadena y siendo reemplazada por algo más\n",
        "a_string.replace('a', '@', 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FGqMU7K2YPQe"
      },
      "source": [
        "## Este programa pregunta por 5 números y te dice cuál es el más grande.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ql6Mu1OEYa7K"
      },
      "source": [
        "Primero definiremos 5 variables con la función input."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m9DhibD7YaH1",
        "outputId": "c846d14f-cdfa-4fb7-e406-be820b2415ab"
      },
      "outputs": [],
      "source": [
        "a = int(input('Ingresa un numero 1 '))\n",
        "b = int(input('Ingresa un numero 2 '))\n",
        "c = int(input('Ingresa un numero 3 '))\n",
        "d = int(input('Ingresa un numero 4 '))\n",
        "f = int(input('Ingresa un numero 5 '))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PxvoIdT1YaVY"
      },
      "source": [
        "En este paso, arreglamos todos los inputs en una lista y asignamos esta lista a la variable **Numeros** "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "sTo7nlejZECU"
      },
      "outputs": [],
      "source": [
        "Numeros = [a,b,c,d,f]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FWKJRBO2Zuee"
      },
      "source": [
        "La función **Max** te permitirá saber cuál es el número mas grande de la lista recién creada."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KCEYtgUQaeIE",
        "outputId": "af2f401e-66a8-47c5-ead0-9adde5e1457f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n"
          ]
        }
      ],
      "source": [
        "print(max(Numeros))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VuhJEqPGayF_"
      },
      "source": [
        "## .format\n",
        "\n",
        "El método **.format** me permite agregar un valor a un texto impreso por medio de {}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CcmOo4K3aj4c",
        "outputId": "267f8df9-29df-4626-856a-378533141065"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "El número más grande es 6\n",
            "El número más chico es 1\n"
          ]
        }
      ],
      "source": [
        "print('El número más grande es {}'.format(max(Numeros)))\n",
        "print('El número más chico es {}'.format(min(Numeros)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q1nQnhm1Xt-f"
      },
      "source": [
        "Si queremos podemos utilizar **.format** para tambien dar formato a cierto tipo de números por ejemplo números con decimales:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N90IQXAWX6PS",
        "outputId": "1d2e97ed-6364-4938-d443-432c07f5e7b4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "El número pi es 3.14\n"
          ]
        }
      ],
      "source": [
        "print('El número pi es {:.3}'.format(3.141516))  # Estamos dando instrucciones para que solo imprima 3 dígitos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jNqQlZ_XajCS"
      },
      "source": [
        "## Explorando Más Funciones\n",
        "\n",
        "La función **Def** indica el inicio del encabezado de una función. Esto nos permite llamar los parámetros establecidos por medio de este encabezado.\n",
        "\n",
        "Creemos una función para hacer una pregunta ¿Qué les parece?\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "id": "eHS5WuioLR5t"
      },
      "outputs": [],
      "source": [
        "def mi_pregunta(nombre=\"Ana\", pregunta=\"¿Cuántos años tienes?\"):\n",
        "  print(\"Bienvenid@, {}\\n\\n¡Hola! Soy un programa sencillo y tengo una pregunta para ti.\\n{}\\n\\n¡Gracias por tu tiempo!\".format(nombre,pregunta))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8yDEVA1hMZP9",
        "outputId": "b8dfcacc-d362-49aa-a05e-ddc650904bed"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Bienvenid@, Pablo\n",
            "\n",
            "¡Hola! Soy un programa sencillo y tengo una pregunta para ti.\n",
            "Cuál es tu comida favorita?\n",
            "\n",
            "¡Gracias por tu tiempo!\n"
          ]
        }
      ],
      "source": [
        "mi_pregunta(nombre='Pablo', pregunta='Cuál es tu comida favorita?')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7yjhRQhgM6I0",
        "outputId": "c0d887ba-fdec-4f57-b95c-b861547e1033"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Bienvenid@, Santos\n",
            "\n",
            "¡Hola! Soy un programa sencillo y tengo una pregunta para ti.\n",
            "¿Cuál es tu comida favorita?\n",
            "\n",
            "¡Gracias por tu tiempo!\n"
          ]
        }
      ],
      "source": [
        "# Cambiemos los parámetros de nombre y pregunta\n",
        "\n",
        "mi_pregunta(nombre=\"Santos\",pregunta=\"¿Cuál es tu comida favorita?\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UWT4erXxaQ1M"
      },
      "source": [
        "# Taller\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_AKbLXQ_aTUl"
      },
      "source": [
        "1. Escribe una función en Python para determinar la distancia (en km) recorrida por un bus dependiendo de su velocidad y tiempo de recorrido. \n",
        "Hint: distancia = velocidad * tiempo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WlDpDOH6aSXl"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TCa1ei-ualod"
      },
      "source": [
        "2. Escribe una función de Python para comprobar si el bus numero \"MB-145\" pasa por la parada Universidad de Panamá.\n",
        "Hint: Crea una lista con todas las numeraciones de buses que pasan por la parada Universidad de Panamá y pide al usuario que ingrese un número de bus para verificar si pasa o no."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ARCMhDGcan89"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "Semana_4_1_Reutilizando_en_funciones.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.10.5 64-bit",
      "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.5"
    },
    "vscode": {
      "interpreter": {
        "hash": "26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}