08-Kata.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejercicio 1: Creación de diccionarios de Python\n",
    "### 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",
    "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",
    "planet = {\n",
    "    'name' : 'Mars',\n",
    "    'number' : '2'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Mars', 'number': '2'}\n"
     ]
    }
   ],
   "source": [
    "print(planet)"
   ]
  },
  {
   "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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mars\n"
     ]
    }
   ],
   "source": [
    "print(planet.get('name'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Muestra el nombre del planeta y el número de lunas que tiene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mars has 2 moons\n"
     ]
    }
   ],
   "source": [
    "print(f'{planet[\"name\"]} has {planet[\"number\"]} 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": 8,
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Mars',\n",
       " 'number': '2',\n",
       " 'circumference (km)': {'polar': 6752, 'equatorial': 6792}}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imprime el nombre del planeta con su circunferencia polar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Mars has a has a equatorial circumference of 6792\n"
     ]
    }
   ],
   "source": [
    "print(f'The {planet[\"name\"]} has a has a equatorial circumference of {planet[\"circumference (km)\"][\"equatorial\"]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mars has a polar circumference of 6752\n"
     ]
    }
   ],
   "source": [
    "print(f'{planet[\"name\"]} has a polar circumference of {planet[\"circumference (km)\"][\"polar\"]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 2: Programación dinámica con diccionarios\n",
    "\n",
    "### Ejercicio: Cálculo de valores\n",
    "\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": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'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}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planet_moons"
   ]
  },
  {
   "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": 15,
   "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",
    "# 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())\n",
    "\n",
    "print(moons)\n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['mercury', 'venus', 'earth', 'mars', 'jupiter', 'saturn', 'uranus', 'neptune', 'pluto', 'haumea', 'makemake', 'eris'])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planet_moons.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "llevamos 0 lunas.\n",
      "llevamos 0 lunas.\n",
      "llevamos 1 lunas.\n",
      "llevamos 3 lunas.\n",
      "llevamos 82 lunas.\n",
      "llevamos 164 lunas.\n",
      "llevamos 191 lunas.\n",
      "llevamos 205 lunas.\n",
      "llevamos 210 lunas.\n",
      "llevamos 212 lunas.\n",
      "llevamos 213 lunas.\n",
      "llevamos 214 lunas.\n"
     ]
    }
   ],
   "source": [
    "# Calcula el total_moons agregando todas las lunas\n",
    "# Almacena su valor en una variable llamada total_moons\n",
    "contador = 0\n",
    "for moon in moons:\n",
    "    contador = contador + moon\n",
    "    print(\"llevamos \" + str(contador) + \" lunas.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.833333333333332\n"
     ]
    }
   ],
   "source": [
    "# Calcula el promedio dividiendo el total_moons por el número de planetas\n",
    "average = contador / planets\n",
    "print(average)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "bdd6452835a1642e2d58e70cd39963fdd7c788606328ae08c41b50372f3c6a18"
  },
  "kernelspec": {
   "display_name": "Python 3.10.2 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.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}