TODOs R1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TODOs (R1)\n",
    "\n",
    "Una lista de TODOs (tareas por hacer) nos permite mantener un registro de actividades que debemos completar. Utilizamos este tipo de listas todo el tiempo: cuando hacemos una lista del supermercado, o cuando nos preparamos para un evento o un viaje. Por ejemplo, esta es una lista antes de salir de viaje:\n",
    "\n",
    "- Preparar maletas\n",
    "- Preparar documentos\n",
    "- Revisar el automóvil\n",
    "- Ir al aeropuerto\n",
    "\n",
    "En esta primera lección, utilizaremos Python para crear nuestra propia aplicación de TODOs. Exploraremos como Python nos permitirá crear y almacenar nuestra lista, quitar y añadir elementos, y mostrar los elementos que hemos creado.\n",
    "\n",
    "Utilizaremos un enfoque *iterativo*, lo que significa que empezaremos con una implementación muy sencilla que cumpla con requisitos básicos, y con cada *iteración* añadiremos nuevas características que conviertan nuestra aplicación en algo más robusto. Identificaremos cada iteración con el distintivo R1, R2, R3, etc. Además, cada iteración tendrá su propio conjunto de requisitos que nos permitirán definir lo que queremos lograr al final."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Requisitos\n",
    "\n",
    "En este iteración queremos lograr lo siguiente para nuestra aplicación de TODOs:\n",
    "\n",
    "- Debe almacenar los elementos de la lista\n",
    "- Debe mostrar los elementos de la lista\n",
    "- Debe permitir añadir nuevos elementos a la lista\n",
    "- Debe permitir eliminar elementos de la lista\n",
    "\n",
    "¿Están claros los requisitos? Si es así, ¡estamos listos para empezar! Vamos a desarrollar cada uno de los requisitos en las secciones a continuación. Abre una ventana de la línea de comandos e inicia una sesión interactiva de Python introduciendo el comando `python`. Si todo está bien instalado y configurado, verás un texto como este en la línea de comandos:\n",
    "\n",
    "```\n",
    "Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>\n",
    "```\n",
    "\n",
    "Si recibes un error o no estás seguro de como iniciar Python, pide ayuda. Puedes descargar e instalar Python desde aquí: https://www.python.org/downloads/. Si todo sale bien, continúa con la lección."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Debe almacenar los elementos de la lista\n",
    "\n",
    "Sucede que Python tiene un tipo de datos que nos permite almacenar listas directamente, y se llama simplemente `list`. En otros lenguajes de programación este tipo de datos también se conoce como `array`. Para declarar una lista en Python, simplemente abres un conjunto de corchetes e introduces los elementos de la lista separados por coma. Recuerda que cada elemento debe ir rodeado por comillas dobles `\"` o sencillas `'` para que Python entienda que estamos introduciendo `strings`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[\"Preparar documentos\", \"Revisar automóvil\", \"Ir al aeropuerto\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas también pueden ser numéricas, y en ese caso no necesitas las comillas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[2, 4, 6, 8, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puedes mezclar `strings` y números en tu lista si quieres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[\"Mi string\", 3, 4, 5, \"Otra string después de los números\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con esto damos por terminado el primer requisito, ya que hemos descubierto como hacer que Python almacene cualquier lista que nosotros querramos. ¡Buen trabajo!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Debe mostrar los elementos de la lista\n",
    "\n",
    "Te habrás dado cuenta que podemos definir cualquier tipo de lista, pero no hay una forma de mostrar los elementos de la lista sin tener que escribirlos de nuevo. Queremos introducir la lista solo una vez y que Python la recuerde y nos la muestre cuando querramos. Para ello vamos a nombrar nuestra lista utilizando una variable.\n",
    "\n",
    "Una variable es simplemente un nombre que le damos a un dato en Python. Python tiene muchísimos tipo de datos y a todos los podemos almacenar en una variable, pero en este caso queremos hablar de listas nada más. Así es como le das un nombre a tu lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_lista = [\"Preparar documentos\", \"Revisar automóvil\", \"Ir al aeropuerto\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Te diste cuenta? Al ejecutar el código anterior Python no nos mostró la lista. Eso es porque en lugar de mostrarla la guardó en la variable `mi_lista`. Le estamos diciendo a Python: \"Oye, crea un lista y guardala con el nombre `mi_lista`\" \n",
    "\n",
    "¿Pero entonces como podemos hacer para mostrar la lista de nuevo? Muy sencillo, simplemente escribimos el nombre de nuestra variable, y Python nos mostrará lo que está almacenado en ella."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Excelente, ahora no tenemos que escribir la lista de nuevo cuando queremos verla, solo tenemos que recordar el nombre que le dimos la primera vez que la definimos. Esto se llama *acceder a una variable*. Pasemos al siguiente requisito.\n",
    "\n",
    "### Acerca de las variables\n",
    "\n",
    "Aquí hay un poco de información extra acerca de las variables si te interesa:\n",
    "\n",
    "- Puedes almacenar todo tipo de datos en una variable, no solo listas. Por ejemplo, puedes guardar números: `mi_edad = 26` o strings `mi_nombre = \"Alicia\"`.\n",
    "- Los nombres de variables deben contener solo números, letras, y guión bajo. No puedes utilizar espacios ni otros caracteres especiales, porque causará un error de sintaxis. Cuando una variable tiene un nombre que consiste de varias palabras, la convención es utilizar guiones bajos para unirlas, como `mi_variable_especial` o `resultado_del_calculo`.\n",
    "- Otra convención útil es utilizar palabras en inglés para nombrar nuestras variables. Esto es opcional, pero es recomendado porque Python en sí está escrito en inglés, y así evitamos mezclar idiomas.\n",
    "- Si tratas de acceder a una variable antes de que sea declarada, recibiras un error. Por ejemplo, prueba escribiendo `asdf` y verás que Python responde con `NameError`, lo que significa que la variable `asdf` no ha sido asignada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Debe permitir añadir nuevos elementos a la lista\n",
    "\n",
    "Ahora que podemos guardar nuestra lista en una variable, ¿cómo podemos añadir nuevos elementos a la lista? Lo haremos de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_lista.append(\"Nuevo elemento\")\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Viste lo que pasó? Hemos ejecutado el método `append` de nuestra lista, y le hemos pasado el argumento `\"Nuevo elemento\"` (que es un `string`). Cuando le pedimos a Python que nos mostrara la lista de nuevo nos ha mostrado los elemntos originales más \"Nuevo elemento\". ¡Genial!\n",
    "\n",
    "Veamos detenidamente lo que ha pasado:\n",
    "\n",
    "- Para ejecutar alguna acción sobre nuesta lista, añadimos un punto al final de la variable y escribimos el nombre de la acción que queremos ejecutar (conocida como `método` o `method`). En este caso el método es `append` (que significa añadir).\n",
    "- Luego debemos pasar parámetros al método. Los parámetros son información adicional que el método necesita para ejecutar la acción. En este caso, el método `append` necesita saber qué añadir a la lista, por lo que le pasamos el elemento a añadir entre paréntesis.\n",
    "- Si un método no requiere ningún parámetro, simplemente abres y cierras los paréntesis. Por ejemplo, existe un método que nos permite revertir el orden de los elementos en la lista. El método se llama `reverse` y no necesita ningún parámetro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_lista.reverse()\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notarás que los elementos ahora están en orden invertido. Si quieres volver al orden original puedes volver a llamar al método `reverse` sobre `mi_lista`.\n",
    "\n",
    "Muy bien, ahora estamos listos para movernos al último requisito."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Debe permitir eliminar elementos de la lista\n",
    "\n",
    "Hemos aprendido que el método `append` permite añadir nuevos elementos a la lista. Es lógico pensar que las listas también tienen un método disponible para eliminar elementos. Y en efecto, ese es el caso. El método es `remove`.\n",
    "\n",
    "Vamos a eliminar el último elemento que añadimos: `\"Nuevo elemento\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_lista.remove(\"Nuevo elemento\")\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora tenemos los elementos originales en la lista. Como puedes ver, el método `remove` acepta un argumento, que es el elemento de la lista que quieres eliminar. Ten en cuenta que si tratas de remover un elemento que no existe en la lista, Python producirá el error `ValueError` porque no puede encontrar lo que quieres eliminar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusión\n",
    "\n",
    "¡Felicidades! Hemos cumplido todos los requisitos y completado la primera iteración de nuestra aplicación de listas de tareas. Sin embargo, quizá hayas notado algunas de las desventajas de esta iteración:\n",
    "\n",
    "- Debemos escribir todo de nuevo cuando iniciamos una sesión interactiva de Python\n",
    "- No hay forma de compartir nuestro programa con otras personas\n",
    "\n",
    "En la segunda iteración vamos a darle solución a estos problemas utilizando dos nuevas herramientas que nos proporciona Python: módulos y funciones."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}