Módulo8Katas.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Ejercicio 1: Creación de diccionarios de Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Ejercicio: Crear y modificar un diccionario de Python\n",
        "\n",
        "Los diccionarios python te permiten modelar datos más complejos. Los diccionarios son una colección de pares clave/valor, y son muy comunes en los programas Python. Su flexibilidad le permite trabajar dinámicamente con valores relacionados sin tener que crear clases u objetos.\n",
        "\n",
        "Un diccionario se indica en Python mediante el uso de llaves (`{ }`), con pares clave/valor separados por dos puntos (`:`). Las claves son literales de cadena y los valores pueden ser de cualquier tipo de datos.{ }:\n",
        "\n",
        "```python\n",
        "demo = {\n",
        "    'key': 'value',\n",
        "    'number': 42\n",
        "}\n",
        "```\n",
        "\n",
        "Para este ejercicio, crearás un diccionario que almacene información sobre el planeta Marte.\n",
        "\n",
        "\n",
        "> **TIP**\n",
        "> Dedica unos minutos para tratar de encontrar una solución. Luego desplázate hacia abajo hasta la parte inferior para ver si has logrado compilar el programa de acuerdo con las especificaciones\n",
        "\n",
        "Agrega el código para crear un nuevo diccionario denominado 'planet'. Rellena con la siguiente información:\n",
        "\n",
        "```\n",
        "name: Mars\n",
        "moons: 2\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Crea un diccionario llamado planet con los datos propuestos\n",
        "\n",
        "planet = {\n",
        "    'name': 'Mars',\n",
        "    'moons': 2\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Para recuperar valores, puede utilizar el método  `get` o corchetes (`[ ]`) con el nombre de la clave que desea recuperar."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mars has 2 moons\n"
          ]
        }
      ],
      "source": [
        "# Muestra el nombre del planeta y el número de lunas que tiene.\n",
        "\n",
        "print(planet.get('name'),\"has\",planet.get('moons'),\"moons\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Puedes actualizar las claves existentes o crear otras nuevas utilizando el método `update` o entre corchetes (`[ ]`). Cuando se usa `update`, se pasa un nuevo objeto de diccionario con los valores actualizados o nuevos. Cuando se usan corchetes, se especifica el nombre de la clave y se asigna un nuevo valor.\n",
        "\n",
        "\n",
        "```python\n",
        "demo['new_key'] = 'New value'\n",
        "```\n",
        "\n",
        "Agrega un nuevo valor con una clave de 'circunferencia (km)'. Este nuevo valor debería almacenar un diccionario con las dos circunferencias del planeta:\n",
        "\n",
        "```\n",
        "polar: 6752\n",
        "equatorial: 6792\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Agrega la clave circunferencia con los datos proporcionados previamente\n",
        "planet['circunferencia (km)'] = {\n",
        "    'polar': 6752,\n",
        "    'equatorial': 6792\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Imprime el nombre del planeta con su circunferencia polar."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mars has a has a polar circumference: 6752\n"
          ]
        }
      ],
      "source": [
        "# Imprime el nombre del planeta con su circunferencia polar.\n",
        "\n",
        "print(f\"{planet['name']} has a has a polar circumference: {planet['circunferencia (km)']['polar']}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "> Recuerda: Lo importante es intentarlo, puedes auxiliarte de internet, libros, etc. El objetivo de una kata es la comprobación de la comprensión de la lección y su aplicación inmediata a la resolución de problemas. Go for it!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Ejercicio 2: Programación dinámica con diccionarios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Ejercicio: Cálculo de valores\n",
        "En este escenario, calcularás tanto el número total de lunas en el sistema solar como el número promedio de lunas que tiene un planeta."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Planets and moons\n",
        "\n",
        "planet_moons = {\n",
        "    'mercury': 0,\n",
        "    'venus': 0,\n",
        "    'earth': 1,\n",
        "    'mars': 2,\n",
        "    'jupiter': 79,\n",
        "    'saturn': 82,\n",
        "    'uranus': 27,\n",
        "    'neptune': 14,\n",
        "    'pluto': 5,\n",
        "    'haumea': 2,\n",
        "    'makemake': 1,\n",
        "    'eris': 1\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Los diccionarios de Python te permiten recuperar todos los valores y claves utilizando los métodos `values` y `keys`, respectivamente. Cada método devuelve una lista que contiene los datos, que luego se puede usar como una lista normal de Python. Puedes determinar el número de elementos mediante `len`, e iterar a través de él mediante un ciclo `for`.\n",
        "\n",
        "Agrega el código a continuación para determinar el número de lunas. Comienza almacenando el valor `values` de `planet_moons` en una variable denominada `moons`. A continuación, almacena el número de planetas en una variable denominada `planets`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "dict_values([0, 0, 1, 2, 79, 82, 27, 14, 5, 2, 1, 1])\n",
            "12\n"
          ]
        }
      ],
      "source": [
        "# Añade el código para determinar el número de lunas.\n",
        "\n",
        "moons = planet_moons.values()\n",
        "print(moons)\n",
        "\n",
        "planets = len(planet_moons.keys())\n",
        "print(planets)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Agrega el código para contar el número de lunas. Puedes hacerlo creando un ciclo `for` para iterar a través de las lunas `moons` y agregándolos a una variable denominada `total_moons`. Finalmente calcule el promedio dividiendo `total_moons` por `planets` e imprimiendo los resultados."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "There are 214 moons\n",
            "17.833333333333332\n"
          ]
        }
      ],
      "source": [
        "# Agrega el código para contar el número de lunas. \n",
        "total_moons=0\n",
        "for nmoons in moons:\n",
        "    total_moons = total_moons + nmoons\n",
        "print(\"There are\",total_moons,\"moons\")\n",
        "averMoons = total_moons/planets\n",
        "print(averMoons)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Soluciones"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Ejercicio 1:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Crea un diccionario llamado planet con los datos propuestos\n",
        "\n",
        "planet = {\n",
        "    'name': 'Mars',\n",
        "    'moons': 2\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Muestra el nombre del planeta y el número de lunas que tiene.\n",
        "\n",
        "print(f'{planet[\"name\"]} has {planet[\"moons\"]} moons')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Agrega la clave circunferencia con los datos proporcionados previamente\n",
        "\n",
        "planet['circumference (km)'] = {\n",
        "    'polar': 6752,\n",
        "    'equatorial': 6792\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Imprime el nombre del planeta con su circunferencia polar.\n",
        "\n",
        "print(f'{planet[\"name\"]} has a polar circumference of {planet[\"circumference (km)\"][\"polar\"]}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Ejercicio 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Añade el código para determinar el número de lunas.\n",
        "\n",
        "# Obtenemos la lista de las lunas\n",
        "# Almacenamos los resultados en una variable moons\n",
        "moons = planet_moons.values()\n",
        "\n",
        "# Obtenemos el total de planetas\n",
        "# Almacenamos los resultados en una variable llamada years\n",
        "planets = len(planet_moons.keys())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "214\n",
            "17.833333333333332\n"
          ]
        }
      ],
      "source": [
        "# Calcula el total_moons agregando todas las lunas\n",
        "# Almacena su valor en una variable llamada total_moons\n",
        "\n",
        "total_moons = 0\n",
        "for moon in moons:\n",
        "    total_moons = total_moons + moon\n",
        "\n",
        "# Calcula el promedio dividiendo el total_moons por el número de planetas\n",
        "average = total_moons / planets\n",
        "\n",
        "# Muestra el promedio\n",
        "print(average)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "Curso Propedútico de Python para Launch X - Innovacción Virtual.\n",
        "\n",
        "Material desarrollado con base en los contenidos de MSLearn y la metáfora de LaunchX, traducción e implementación por: Fernanda Ochoa - Learning Producer de LaunchX.\n",
        "\n",
        "Redes:\n",
        "* GitHub: [FernandaOchoa](https://github.com/FernandaOchoa)\n",
        "* Twitter: [@imonsh](https://twitter.com/imonsh)\n",
        "* Instagram: [fherz8a](https://www.instagram.com/fherz8a/)"
      ]
    }
  ],
  "metadata": {
    "interpreter": {
      "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
    },
    "kernelspec": {
      "display_name": "Python 3.8.10 64-bit",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.5"
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    },
    "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 2
}